| ►Nboost | |
| ►Ndetails | |
| Ctrace_manip | |
| Cbacktrace | |
| Cshared_ptr | |
| ►Nfactory_test | |
| CAddCreator | |
| ►NFullPhysics | Contains classes to abstract away details in various Spurr Radiative Transfer software |
| CAbsco | This class is used to read the absco tables |
| CAbscoHdf | This class is used to read the absco tables |
| CAbscoInterpolator | This is a helper class that calculates the absorption cross section for a fixed set of Pressure, Temperature, and Broadner VMR (e.g |
| CAbsorber | This class maintains the absorber portion of the state |
| CAbsorberAbsco | This class maintains the absorber portion of the state |
| CAbsorberAbscoOutput | This registers the portions of the Absorber class that should be written as output |
| CAbsorberVmr | This gives the Gas Absorber Volumn mixing ratio for a single gas |
| CAbsorberVmrFixedLevel | This class maps the state vector to the absorber VMR on each level |
| CAbsorberVmrFixedLevelOutput | This registers the portions of the AbsorberVmrFixedLevel class that should be written as output |
| CAbsorberVmrFixedLevelScaled | This class maps the state vector to the absorber VMR on each level |
| CAbsorberVmrFixedLevelScaledOutput | This registers the portions of the AbsorberVmrFixedLevel class that should be written as output |
| CAbsorberVmrImpBase | As a design principle, we have each base class with the absolutely minimum interface needed for use from the rest of the system |
| CAbsorberVmrLevel | This class maps the state vector to the absorber VMR on each level |
| CAbsorberVmrLevelOutput | This registers the portions of the AbsorberVmrLevel class that should be written as output |
| CAbsorberVmrLevelScaled | This class maps the state vector to the absorber VMR on each level |
| CAbsorberVmrLevelScaledOutput | This registers the portions of the AbsorberVmrLevelScaled class that should be written as output |
| CAbsorberVmrMet | This class maps the state vector to the absorber VMR on each level |
| CAbsorberVmrMetOutput | This registers the portions of the AbsorberVmrMet class that should be written as output |
| CAbsorberVmrScaled | This class maps the state vector to the absorber VMR on each level |
| CAccumulatedTimer | This is a simple timer class that can be used to accumulate the time spent in multiple calls to a function |
| CAerosol | This class maintains the aerosol portion of the state |
| CAerosolAodOutput | This registers the portions of the Aerosol class that should be written as output |
| CAerosolConsolidatedOutput | This registers the portions of the Aerosol class that should be written as output |
| CAerosolExtinction | This class maps the state vector to the aerosol extinction on each level |
| CAerosolExtinctionImpBase | As a design principle, we have each base class with the absolutely minimum interface needed for use from the rest of the system |
| CAerosolExtinctionLinear | This class maps the state vector to the aerosol extinction on each level |
| CAerosolExtinctionLog | This class maps the state vector to the aerosol extinction on each level |
| CAerosolOptical | Implementation of Aerosol |
| CAerosolParamOutput | This registers the coefficients used for classes that inherits from AerosolExtinctionBaseImp |
| CAerosolProperty | This gives the Aerosol properties for an Aerosol |
| CAerosolPropertyHdf | This gives the Aerosol properties for an Aerosol |
| CAerosolPropertyImpBase | As a design principle, we have each base class with the absolutely minimum interface needed for use from the rest of the system |
| CAerosolPropertyRhHdf | This gives the Aerosol properties for an Aerosol |
| CAerosolShapeGaussian | This class maps the state vector to aerosol extinction defined by a Gaussian parameterization |
| CAltitude | The class handles the calculation of the altitude and gravity constants |
| CAltitudeHydrostatic | This class handles the calculation of the altitude an gravity constants, automatically updating with the surface pressure or temperature profile is updated |
| CAltitudeOutput | This registers the portions of the Altitude class that should be written as output |
| CApplyInstrumentUnits | An InstrumentCorrection class that applies units and scales monochromatic radiances in those cases when no other modifications applies radiances |
| CArrayAd | The AutoDerivative<T> works well, and it works with blitz if you create a blitz::Array<AutoDerivative<T>, D>, however the performance tends to be a bit poor for larger Arrays because of all the temporaries that get created |
| CArrayAdCache | Defines an interface for caching ArrayAd objects such that the underlying caching mechanism is not necessarily exposed to a user of the cache |
| CArrayAdMapCache | Caches ArrayAd objects using a std::map |
| CArrayAdVectorCache | Caches ArrayAd objects using a std::vector |
| CArrayAdWithUnit | This is a ArrayAd that also has units associated with it |
| CArrayWithUnit | We frequently have a array of numbers with units associated with them |
| CAtmosphereFixture | This is a test fixture that creates an Atmosphere and related Statevector based on the unit test data set up in ConfigurationFixture |
| CAtmosphereOco | This class maintains the atmosphere portion of the state, and uses this to set up the atmosphere and ground information needed to run the Radiative transfer code |
| CAtmRefractiveIndex | This class provides an interface for classes that compute a refractive index for an atmosphere at a given level or layer |
| CAutoDerivative | There are a number of tools that can be used to do "Automatic
Differentiation" (see for example http://www.autodiff.org/?module=Tools) |
| CAutoDerivativeRef | Helper class that gives us a reference that we can assign a AutoDerivative to and write into the correct space in a ArrayAd |
| CAutoDerivativeWithUnit | This is a AutoDerivative that also has units associated with it |
| CBadSampleNoiseModel | When we have bad samples, we usually pass this to the spectral window to prevent the sample from even being used |
| CBardMLProblem | |
| CBardNLLSProblem | |
| CBinMap | This is a map that takes and index and returns a value |
| CBrdf_Input_Exception_Handling | |
| Cbrdf_input_exception_handling | |
| CBrdf_Linsup_Inputs | |
| Cbrdf_linsup_inputs | |
| CBrdf_Linsup_Masters | |
| CBrdf_Linsup_Outputs | |
| Cbrdf_linsup_outputs | |
| CBrdf_Output_Exception_Handling | |
| Cbrdf_output_exception_handling | |
| CBrdf_Sup_Inputs | |
| Cbrdf_sup_inputs | |
| CBrdf_Sup_Masters | |
| CBrdf_Sup_Outputs | |
| Cbrdf_sup_outputs | |
| CBridgeLuabindAndGeneric | Instance of BridgeLuabindAndGenericBase for a particular type |
| CBridgeLuabindAndGenericBase | For use with python, it is useful to map all the LuabindObject that are a class defined in full physics (or derived from those classes) to and from a GenericObject |
| CBrownNLLSProblem | |
| CChapmanBOA | This class computes Bottom of the Atmosphere radiance |
| CChapmanBoaRT | |
| CChisqConvergence | This class tests for convergence of a Levenberg-Marquardt solver |
| CCompositeInitialGuess | A common way to create an initial guess is to have other classes responsible for portions of the state vector (e.g., an Atmosphere class creates the portion of the initial guess that handles the description of the atmosphere layers) |
| CCompositePerturbation | A common way to create a perturbation is to have other classes responsible for portions of the state vector (e.g., an Atmosphere class creates the portion of the initial guess that handles the description of the atmosphere layers) |
| CConfigurationBrdfSoilFixture | There are a number of tests that need to use a standard set of objects, similar to what we generate when running l2_fp |
| CConfigurationBrdfVegFixture | There are a number of tests that need to use a standard set of objects, similar to what we generate when running l2_fp |
| CConfigurationCoxmunkFixture | There are a number of tests that need to use a standard set of objects, similar to what we generate when running l2_fp |
| CConfigurationCoxmunkPlusLambertianFixture | There are a number of tests that need to use a standard set of objects, similar to what we generate when running l2_fp |
| CConfigurationFixture | There are a number of tests that need to use a standard set of objects, similar to what we generate when running l2_fp |
| CConnorConvergence | This class tests for convergence of a Levenberg-Marquardt solver |
| CConnorConvergenceOutput | This registers the portions of the ConnorConvergence class that should be written as output |
| CConnorCostFunction | |
| CConnorIterationLog | This is an observer of the ConnorSolver that writes out the state vector values in a nicely formated way on each iteration |
| CConnorSolver | |
| CConnorSolverMAP | This solves a nonlinear least squares problem using Levenberg-Marquardt |
| CConnorSolverOutput | This registers the portions of the ConnorSolver class that should be written as output |
| CConnorSolverState | Class that saves the state of a ConnorSolver |
| CConstant | This class contains various constants |
| CConvergenceCheck | This class tests for convergence of a Levenberg-Marquardt solver |
| CCostFunc | The base class for all problem classes that implement a cost function |
| CCostFuncDiff | The base class for all problem classes that implement a cost function and its gradient |
| CCostFuncDiffState | The state for a problem with implemented cost function and its gradient |
| CCostFuncState | The state for a problem that only its cost function is implemented |
| CCostFunction | This class calculates a cost function, along with a jacobian |
| CCostMinimizer | The base class for all iterative cost minimizers that do not require derivatives of any order |
| CCostMinimizerGSL | |
| CDefaultConstant | This class is an implementation of Constant that uses hard coded values suitable for Earth |
| CDirChange | Utility class |
| CDispersion | This class calculates the wavenumber for each pixel in a single band of an Instrument |
| CDispersionFit | Given a single frame of data, estimate the spectral shift in band 1P |
| CDispersionFitOutput | This registers the portions of the DispersionFit class that should be written as output |
| CDispersionPolynomial | This is an implementation of Dispersion that uses a polynomial expression to calculate the wavenumbers |
| CDispersionPolynomialOutput | This registers the portions of the DispersionPolynomial class that should be written as output |
| CDoubleWithUnit | We frequently have a double with units associated with it |
| CEmpiricalOrthogonalFunction | This class applies a empirical orthogonal function (EOF) correction to instrument data |
| CEmpiricalOrthogonalFunctionOutput | This registers the portions of the EmpiricalOrthogonalFunction class that should be written as output |
| CErrorAnalysis | This calculates a variety of values to help with the error analysis of a Level 2 Full Physics Run |
| CErrorAnalysisOutput | This registers the portions of the ErrorAnalysis class that should be written as output |
| CExampleLevel1b | This is an example L1B reader that reads a HDF formatted file that corresponds one-to-one with the expected interface |
| CExampleMetFile | This class implements and example Meteorological reader that reads data from an HDF file with datasets of the same name as the values |
| CException | This is the base of the exception hierarchy for Full Physics code |
| CFdForwardModel | This a forward model class that calcualtes jacobians using the finite difference method |
| CFeDisableException | To detect things like divide by zero, we may turn on floating point exceptions |
| CFilteringIstream | This allows filtering stream to created on top of an underlying ifstream |
| CFilteringOstream | This allows filtering stream to created on top of an underlying ofstream |
| CFitStatistic | This class holds various parameters describing how good of a fit we have |
| CFluorescenceEffect | Implements adding the effect of fluorescence to A-Band spectrum by using a retrievable across the band parametrization of the effect |
| CFluorescenceEffectOutput | This registers the portions of the FluorescenceEffect class that should be written as output |
| CFmNLLSProblem | This is the forward model cost function, rewritten to match the standard format used in nonlinear least squares solvers |
| CForwardModel | The forward model represents the encapsulation of modeling spectra from an atmospheric state then applying instrument specific effects to it |
| CForwardModelSpectralGrid | This is the Forward Model spectral grid |
| CFpLogger | This is the implementation of the Logger used for the Full Physics program |
| CFreudensteinRothNLLSProblem | |
| CFunctionTimer | Helper class for AccumulatedTimer |
| CFunctionTimerR | Helper class for AccumulatedTimer |
| CGasAbsorption | This class determine the gaseous absorption coefficient for a given wave number, temperature and pressure |
| CGasVmrApriori | Adapts the ReferenceVmrApriori class into a form that is easier to work with in the context of how this framework works |
| CGasVmrAprioriOutput | This registers the portions of the GasVmrApriori class that should be written as output |
| CGenericObject | For use with SWIG, it is useful to have a base class that everything can be cast to |
| CGlobalFixture | This is a global fixture that is available to all unit tests |
| CGround | This class maintains the ground portion of the state |
| CGroundBrdf | This class implements the Breon + Rahman ground type |
| CGroundBrdfOutput | This registers the portions of the GroundBrdf class that should be written as output |
| CGroundBrdfSoil | |
| CGroundBrdfVeg | |
| CGroundCoxmunk | This class implements a Coxmunk ground type |
| CGroundCoxmunkOutput | This registers the portions of the GroundCoxmunk class that should be written as output |
| CGroundCoxmunkPlusLambertian | This class implements a Coxmunk plus Lambertian ground type |
| CGroundCoxmunkPlusLambertianOutput | This registers the portions of the GroundCoxmunkPlusLambertian class that should be written as output |
| CGroundLambertian | This class implements a Lambertian albedo as a ground type |
| CGroundLambertianOutput | This registers the portions of the GroundLambertian class that should be written as output |
| CGslIntegrate | This is a thin wrapper around the GSL integration function |
| CGslMatrix | This provides thin wrapper around the GNU Scientific Library gsl_matrix |
| CGslVector | This provides thin wrapper around the GNU Scientific Library gsl_vector |
| CHdfConstant | |
| CHdfFile | This class reads and writes a HDF5 file |
| CHdfFileGenerating | To avoid creating files when an error occurs, we create the file with the name ".generating" appended |
| CHelicalValleyNLLSProblem | |
| CHighResSpectrumOutput | This class will recieve observer notifications from any class that pushes out NamedSpectrum and write them to the output file in individual datasets for the spectral domain and spectral range parts |
| CHresWrapper | For timing purposes, it can be useful to separate out the high resolution radiative transfer vs |
| CIfstreamCs | It can be convenient to allow comments in a text data file that are ignored by the program reading it |
| CIls | This class models an Instrument Line Shape (ILS) |
| CIlsConvolution | This is a ILS where we use a Dispersion object to determine the wavenumbers of each pixel, and convolve against a IlsFunction |
| CIlsFunction | This class models an Instrument Line Shape (ILS) function |
| CIlsGaussian | This is an ILS function that is a Gaussian |
| CIlsInstrument | This is a instrument that uses a Ils object for each spectrometer to model the instrument |
| CIlsTable | This class in a IlsFunction where we get the ILS response by using a table of measured values |
| CInitialGuess | This gets the initial guess and the apriori state vector values |
| CInitialGuessBuilder | Class that builds a portion of the state vector |
| CInitialGuessValue | This is a simple implementation of InitialGuessBuilder that just has variables used to give the apriori, initial guess, and covariance |
| CInstrument | This applies a instrument model to radiances |
| CInstrumentCorrection | This class models an Instrument correction |
| CInstrumentDoppler | Corrects Spectrum spectral domain to account for the doppler shift due to the relative velocity between earth and the instrument |
| CInterpolatePoint | Interface for interpolating values |
| CInterpolatePoint< AutoDerivative< double >, AutoDerivative< double > > | |
| CIstreamCompress | / This opens a file for reading, possibly with automatic / decompression |
| CIterativeSolver | The base class for all iterative optimizers |
| CIterativeSolverDer | The base class for all iterative optimizers that use first order derivatives |
| CJennrichSampsonNLLSProblem | |
| CL2FpConfiguration | Before running L2 full physics, we need to create the solver that we will be using, along with registering whatever output we will be generating |
| CL2FpConfigurationLua | This is an implementation of L2FpConfiguration that uses Lua |
| CLevel1b | This is used to read a Level 1B file |
| CLevel1bAverage | This reads averages a set of Level1b classes to get the various values |
| CLevel1bCache | This is a Level1b implementation that just saves the data read from another Level1b object |
| CLevel1bSampleCoefficient | This is used to wrap the nominal Level 1B file reader |
| CLevel1bScaleRadiance | Scales the measured radiance of another Level1b class for each spectral band |
| CLidort_Exception_Handling | |
| Clidort_exception_handling | |
| CLidort_Fixed_Boolean | |
| Clidort_fixed_boolean | |
| CLidort_Fixed_Chapman | |
| Clidort_fixed_chapman | |
| CLidort_Fixed_Control | |
| Clidort_fixed_control | |
| CLidort_Fixed_Inputs | |
| Clidort_fixed_inputs | |
| CLidort_Fixed_Lincontrol | |
| Clidort_fixed_lincontrol | |
| CLidort_Fixed_Lininputs | |
| Clidort_fixed_lininputs | |
| CLidort_Fixed_Linoptical | |
| Clidort_fixed_linoptical | |
| CLidort_Fixed_Optical | |
| Clidort_fixed_optical | |
| CLidort_Fixed_Sunrays | |
| Clidort_fixed_sunrays | |
| CLidort_Fixed_Uservalues | |
| Clidort_fixed_uservalues | |
| CLidort_Input_Exception_Handling | |
| Clidort_input_exception_handling | |
| CLidort_Inputs | |
| CLidort_Lcs_Masters | |
| CLidort_Linatmos | |
| Clidort_linatmos | |
| CLidort_Linoutputs | |
| Clidort_linoutputs | |
| CLidort_Linsup_Brdf | |
| Clidort_linsup_brdf | |
| CLidort_Linsup_Inout | |
| Clidort_linsup_inout | |
| CLidort_Linsup_Sleave | |
| Clidort_linsup_sleave | |
| CLidort_Linsup_Ss | |
| Clidort_linsup_ss | |
| CLidort_Linsup_Ss_Atmos | |
| Clidort_linsup_ss_atmos | |
| CLidort_Linsup_Ss_Surf | |
| Clidort_linsup_ss_surf | |
| CLidort_Linsurf | |
| Clidort_linsurf | |
| CLidort_Lps_Masters | |
| CLidort_Main_Outputs | |
| Clidort_main_outputs | |
| CLidort_Masters | |
| CLidort_Modified_Boolean | |
| Clidort_modified_boolean | |
| CLidort_Modified_Chapman | |
| Clidort_modified_chapman | |
| CLidort_Modified_Control | |
| Clidort_modified_control | |
| CLidort_Modified_Inputs | |
| Clidort_modified_inputs | |
| CLidort_Modified_Lininputs | |
| Clidort_modified_lininputs | |
| CLidort_Modified_Optical | |
| Clidort_modified_optical | |
| CLidort_Modified_Sunrays | |
| Clidort_modified_sunrays | |
| CLidort_Modified_Uservalues | |
| Clidort_modified_uservalues | |
| CLidort_Outputs | |
| Clidort_outputs | |
| CLidort_Pars | |
| CLidort_Structure | |
| CLidort_Sup_Accessories | |
| CLidort_Sup_Brdf | |
| Clidort_sup_brdf | |
| Clidort_sup_inout | |
| CLidort_Sup_Inout | |
| CLidort_Sup_Sleave | |
| Clidort_sup_sleave | |
| Clidort_sup_ss | |
| CLidort_Sup_Ss | |
| CLidortBrdfDriver | LIDORT specific BRDF driver implementation |
| CLidortCoxmunkFixture | This is a test fixture that creates a Atmosphere, Statevector, and LidortRt based on the ConfigurationCoxmunkFixture |
| CLidortCoxmunkPlusLambertianFixture | This is a test fixture that creates a Atmosphere, Statevector, and LidortRt based on the ConfigurationCoxmunkPlusLambertianFixture |
| CLidortDriverBrdfVegFixture | Fixture for LidortRtDriver coxmunk mode |
| CLidortDriverCommonFixture | Base fixture for testing LidortRtDriver |
| CLidortDriverCoxmunkFixture | Fixture for LidortRtDriver coxmunk mode |
| CLidortDriverLambertianFixture | Fixture for LidortRtDriver lambertian mode |
| CLidortDriverLambertianThermalFixture | Fixture for LidortRtDriver lambertian mode thermal mode |
| CLidortLambertianFixture | This is a test fixture that creates a Atmosphere, Statevector, and LidortRt based on the ConfigurationFixture |
| CLidortLowHighCommon | |
| CLidortLowHighCoxmunkFixture | This is a test fixture that creates a Atmosphere, Statevector, and LidortLowHighDriver based on the ConfigurationCoxmunkFixture |
| CLidortLowHighCoxmunkPlusLambertianFixture | This is a test fixture that creates a Atmosphere, Statevector, and LidortRt based on the ConfigurationCoxmunkPlusLambertianFixture |
| CLidortLowHighFixtureNoPolarization | This is a test fixture that creates a Atmosphere, Statevector, and LidortLowHighDriver based on the ConfigurationFixture |
| CLidortLowHighLambertianFixture | This is a test fixture that creates a Atmosphere, Statevector, and LidortLowHighDriver based on the ConfigurationFixture |
| CLidortRt | Uses the Spurr interfaces to construct a radiative transfer class connecting L2 FP and LIDORT 3.5 |
| CLidortRtCommonFixture | Base fixture for testing LidortRt modes |
| CLidortRtDriver | LIDORT specific Radiative transfer interface implementation |
| CLinearInterpolate | This class takes a set of points and values, and linearly interpolates between those values |
| CLinearInterpolate2Point | This does linear interpolate between two points |
| CLinearInterpolate2Point< AutoDerivative< double >, AutoDerivative< double > > | This is a specialization of LinearInterpolate2Point for AutoDerivative |
| CLinearInterpolate< AutoDerivative< double >, AutoDerivative< double > > | This is a specialization of LinearInterpolate for AutoDerivative |
| CLinearLogInterpolate | Wrapper around LinearInterpolate that uses log(y) rather than x and y when interpolating |
| CLinearLogInterpolate< AutoDerivative< double >, AutoDerivative< double > > | Specialization for AutoDerivative<double> types |
| CLogger | This is a simple logger |
| CLogHelper | This is a class that holds the level we are logging |
| CLogImp | The actual implementation of the Logger |
| CLogLinearInterpolate | Wrapper around LinearInterpolate that uses log(x) rather than x in interpolating |
| CLogLogInterpolate | Wrapper around LinearInterpolate that uses log(x) and log(y) rather than x and y when interpolating |
| CLogLogInterpolate< AutoDerivative< double >, AutoDerivative< double > > | Specialization for AutoDerivative<double> types |
| CLogTiming | This is a helper class that logs basic timing information to the Logger |
| CLRadDriver | This class drives the LRAD code, which gives a polarization correction to scalar intensity and jacobians |
| CLRadRt | This class drives the LRAD code, which gives a polarization correction to scalar intensity and jacobians |
| CLsiRt | This does a Low Stream Interpolator correction to another RadiativeTransfer object |
| CLuabindIterator | This is a light wrapper around the luabind::iterator |
| CLuabindObject | This is a light wrapper around the luabind::object |
| CLuaCallback | This is a simple object to call a callback that can be used in Lua |
| CLuaState | This is a light wrapper around the lua_state object |
| CLuaStateImp | |
| CMaxAPosteriori | The base class for maximum a posteriori estimation |
| CMaxAPosterioriOutput | This registers the portions of the MaxAPosteriori class that should be written as output |
| CMaxAPosterioriStandard | |
| CMaxLikelihood | The base class for maximum likelihood estimation |
| CMerraAerosol | This class is used to create the Aerosol from a Merra climatology file |
| CMeteorology | Defines the interface for supplying meteorological data |
| CMetPassThroughOutput | Writes source filenames into the output file |
| CMeyerMLProblem | |
| CMeyerNLLSProblem | |
| CModelMeasure | The base class for models and measurements |
| CModelMeasureBard | |
| CModelMeasureMeyer | |
| CModelMeasureStandard | |
| CModelState | The state for a parametrized mathematical model (a vector function) and its Jacobian |
| CNamedSpectrum | Adds name and spec index fields to a Spectrum |
| CNLLSMaxAPosteriori | |
| CNLLSMaxLikelihood | |
| CNLLSProblem | The base class for the Non-Linear Least Squares problem |
| CNLLSProblemScaled | |
| CNLLSProblemState | The state for a NLLS problem with implemented residual function and its Jacobian |
| CNLLSSolver | The base class for the solvers of the Nonlinear-Least-Squares Problem |
| CNLLSSolverGSL | |
| CNLLSSolverGSLLMDER | |
| CNLLSSolverGSLLMSDER | |
| CNLLSSolverGSLSM | |
| ►CNLLSSolverLM | |
| COptions | |
| CNoiseModel | Interface for calculating noise/uncertainty values from radiance data given some internal representation of the noise model |
| CNonuniformSpectrumSampling | This is a simple SpectrumSampling that is just a nonuniform sampling |
| Cnull_deleter | Class for use with boost::shared_ptr when we don't want data to be deleted |
| Cnull_type | Dummy class to use as a nice default for type_index |
| ►CObservable | Mixin for a class that allows other classes to observe it state |
| CPointerDead | |
| CPointerEqual | |
| CObservation | |
| CObservationId | Defines a simple mechanism by where a specific dataset from a HDF file is read along with some sort of identifer to obtain an index that should be used for extracting data |
| CObservationLevel1b | |
| CObserver | Simple Mixin to be and Observer of another object of class T |
| COcoRefractiveIndex | Computes refractive index per level/layer using a method that takes into account knowledge of OCO spectral domains |
| COstreamCompress | / This opens a file for writing, possibly with automatic / compression |
| COstreamPad | This is a filtering stream that adds a pad to the front of every line written out |
| COstreamPadFilter | |
| COutput | This is the base class for classes that write output for Level 2 Full Physics |
| COutputBlitz1d | |
| COutputBlitz2d | |
| COutputDouble | |
| COutputHdf | This write the output of the Level 2 Full physics |
| COutputHdfIteration | This write the output of the Level 2 Full physics |
| COutputTemplate | Most of the time the write_data needed by Output is best done through a template |
| CPCABinning | |
| CPerturbation | This gets the perturbation to use with a finite difference Jacobian |
| CPerturbationBuilder | Class that builds a perturbation to use for a finite difference Jacobian |
| CPoly1d | A one-dimensional polynomial class |
| CPowellNLLSProblem | |
| CPowellSingularNLLSProblem | |
| CPressure | This class maintains the pressure portion of the state |
| CPressureFixedLevel | This class maintains the pressure portion of the state |
| CPressureFixedLevelOutput | This registers the portions of the PressureFixedLevel class that should be written as output |
| CPressureImpBase | As a design principle, we have each base class with the absolutely minimum interface needed for use from the rest of the system |
| CPressureLevelInput | In a retrieval, there are typically two different pressure levels of interest |
| CPressureOutput | This registers the portions of the Pressure class that should be written as output |
| CPressureSigma | This class maintains the pressure portion of the state |
| CPrintable | This is a Mixin for classes that can be printed |
| CProblemState | The base class for all problem states |
| CRadianceScaling | This abstract class provides the generic capabilities for applying a radiance scaling to a Radiance |
| CRadianceScalingLinearFit | Implements a fitted radiance scaling correction where the correction is determined by a linear fit of the measured spectra to the radiance input instead of using the state vector for fitting |
| CRadianceScalingOutput | This registers the portions of the RadianceScaling class that should be written as output |
| CRadianceScalingSvFit | Implements a fitted radiance scaling correction |
| CRadiantDriver | This class drives the RADIANT Radiative Transfer code |
| CRadiativeTransfer | This runs a Radiative Transfer code to determine the reflectance for a given set of wavelengths |
| CRadiativeTransferFixedStokesCoefficient | For GOSAT and OCO, we have a set of stokes coefficients to go from Stokes vector to radiation |
| CRadiativeTransferImpBase | As a design principle, we have each base class with the absolutely minimum interface needed for use from the rest of the system |
| CRadiativeTransferRetrievable | Interface class for radiative transfer implementations that happen to have retrievable parameters |
| CRadiativeTransferSingleWn | This is a RadiativeTransfer that supplies an interface that can be called for a single wavenumber |
| CRayleigh | This class calculates the Rayleigh portion of the optical depth |
| CRayleighGreekMoment | This class provides the Rayleigh Greek Moments |
| CReferenceVmrApriori | Creates a VMR profile for a gas using a set of dated reference VMRs with a known latitude |
| CRegisterLua | This class handles the registration of luabind class wrappers with Lua |
| CRegisterOutputBase | As described in the Output class, we have a decentralized model of producing output for L2 Full Physics |
| CRelativeHumidity | This calculates the relative humidity |
| CReturn1Point | This just returns the same y value, always |
| CReturn1Point< AutoDerivative< double >, AutoDerivative< double > > | |
| CRosenbrock2NLLSProblem | |
| CRtAtmosphere | This class is responsible for setting up the atmosphere and ground information needed to run the Radiative transfer code |
| CSampleGrid | This determines the sample grid that should be used for each of the instrument indexes |
| CScatteringMomentInterpolate | |
| CScatteringMomentInterpolate2Point | The calculation of the phase function scattering matrix moments is fairly expensive |
| CSimpleFixedSpectrumSampling | This is a simple SpectrumSampling that is just a uniform sampling |
| CSimpleRefractiveIndex | Computes refractive index per level/layer using a simple approximation using pressure and temperature |
| Csleave_sup_inputs | |
| CSleave_Sup_Inputs | |
| CSolarAbsorptionAndContinuum | This applies a solar model to radiances to model the incoming solar irradiance |
| CSolarAbsorptionGfitFile | This class calculates the solar absorption spectrum |
| CSolarAbsorptionSpectrum | This class calculates the solar absorption spectrum |
| CSolarAbsorptionTable | This class calculates the solar absorption spectrum |
| CSolarContinuumPolynomial | This class calculates the solar continuum spectrum |
| CSolarContinuumSpectrum | This class calculates the solar continuum spectrum |
| CSolarContinuumTable | This class calculates the solar continuum spectrum |
| CSolarDopplerShift | This class handles the solar Doppler stretch to calculate the shift of the solar lines with respect to the telluric lines |
| CSolarDopplerShiftL1b | This class handles the solar Doppler stretch to calculate the shift of the solar lines with respect to the telluric lines |
| CSolarDopplerShiftPolynomial | This class handles the solar Doppler stretch to calculate the shift of the solar lines with respect to the telluric lines |
| CSolarModel | This applies a solar model to reflectance to model the incoming solar irradiance |
| CSolverFinishedFixture | This is a test fixture that puts us into the state we are in after doing the solver step of l2_fp |
| CSolverIterationLog | This is an observer of IterativeSolver that writes out the state vector values in a nicely formated way on each accepted iteration |
| CSourceFilesOutput | Writes source filenames into the output file |
| CSpectralBound | This gives the upper and lower bounds of the SpectralWindow |
| CSpectralDomain | For different instruments, it is more natural to either work with wavenumbers (e.g., GOSAT) or wavelength (e.g., OCO) |
| CSpectrallyResolvedNoise | Adds a spectrally varying modification to an existing noise model |
| CSpectralParametersOutput | This registers the portions of the ForwardModel class that should be written as output |
| CSpectralRange | We have a number of different spectrums that appear in different parts of the code |
| CSpectralWindow | This class represents a the spectral window |
| CSpectralWindowRange | This is an implementation of a SpectralWindow that covers a fixed window |
| CSpectrum | This is a full spectrum, which contains a SpectralRange and SpectralDomain |
| CSpectrumEffect | This class models models any effects that need to be applied to high resolution spectra after the radiative transfer model has finished its work |
| CSpectrumEffectImpBase | As a design principle, we have each base class with the absolutely minimum interface needed for use from the rest of the system |
| CSpectrumSampling | This determines the sampling of the spectrum that should be used for each of the spectrum indexes |
| CSpectrumSamplingFixedSpacing | This generates a spectrum sampling that covers all the high resolution points needed to create the spectral domain covered by the given Instrument, subject to the given low resolution grid |
| CSpurrBrdfDriver | Abstracts away set up of BRDF kernel interfaces |
| CSpurrRt | Abstract Interface for Rt classes based on Spurr driver implementations |
| CSpurrRtDriver | Abstracts away set up of Radiative Transfer software from Rob Spurr into a simpler common inteface used by the L2 software |
| CStackedRadianceMixin | |
| CStandardForwardModel | This is the forward model used form GOSAT/OCO |
| CStandardForwardModelOutput | This registers the portions of the StandardForwardModel class that should be written as output |
| CStateVector | This handles informing a set of interested objects when the state vector has updated |
| CStateVectorObserver | This is an observer of a StateVector |
| CStateVectorOutput | This registers the portions of the StateVector class that should be written as output |
| CStokesCoefficient | This class maintains the stokes coefficient portion of the state |
| CStokesCoefficientConstant | This class maintains the stokes coefficient portion of the state |
| CStokesCoefficientFraction | This class maintains the stokes coefficient portion of the state |
| CStokesCoefficientFractionOutput | This registers the portions of the StokesCoefficientFraction class that should be written as output |
| CStokesCoefficientImpBase | As a design principle, we have each base class with the absolutely minimum interface needed for use from the rest of the system |
| CSubStateVectorArray | It is common to have a class that is an Observable with a set of coefficients, a subset of which are updated by changes to the StateVector |
| CSubStateVectorObserver | A common StateVectorObserver just "owns" a subset of the StateVector |
| CSubStateVectorProxy | Proxies for multiple SubStateVectorObserver classes that are combined for a result, but handle their state vector data seperately |
| CSurfaceTemperature | This class represents the surface of the temperature under observation |
| CSurfaceTemperatureDirect | Implements a direct representation of the surface temperature in the atmospheric state from the supplied value |
| CSwigTypeMapper | This is the implementation of SwigTypeMapperBase |
| CSwigTypeMapperBase | This is the base class that is used by fp_shared_ptr.i to map a shared_ptr to a python object |
| CTemperature | This class maintains the temperature portion of the state |
| CTemperatureFixedLevel | This class maintains the temperature portion of the state |
| CTemperatureFixedLevelOutput | This registers the portions of the TemperatureFixedLevel class that should be written as output |
| CTemperatureImpBase | As a design principle, we have each base class with the absolutely minimum interface needed for use from the rest of the system |
| CTemperatureLevelOffset | This class maintains the temperature portion of the state |
| CTemperatureLevelOffsetOutput | This registers the portions of the TemperatureLevelOffset class that should be written as output |
| CTemperatureMet | This class maintains the temperature portion of the state |
| CTemperatureMetOutput | This registers the portions of the TemperatureMet class that should be written as output |
| CTemperatureOffset | This class maintains the temperature portion of the state |
| CTime | This is a simple time class |
| CTwostream_Lps_Master | |
| CTwostream_Ls_Brdf_Supplement | |
| CTwostreamBrdfDriver | TwoStream specific BRDF driver implementation |
| CTwostreamRt | Uses the Spurr interfaces to construct a radiative transfer class connecting L2 FP and TwoStream |
| CTwostreamRtDriver | TwoStream specific Radiative transfer driver implementation |
| Ctype_index | This is a wrapper around std::type_info that allows it to be used as an index in a associative container |
| CUniformSpectrumSampling | This spectrum sampling creates a grid that begins the nearest ils_half_width before the low resolution grid beginning point and uniformly increases along some spacing until one ils_half_width past the end of the lowe resolution grid |
| CUnit | Libraries such as boost::units allow unit handling where we know the units at compile time |
| ►Nlua_test | |
| CLuaCallback | |
| CMyCallback0 | |
| CMyCallback1 | |
| CTestLua | |
| ►NPython | |
| ►Nfactory | |
| ►Ncreator | |
| ►Nabsorber | |
| CAbscoHdf | |
| CAbsorberAbsco | |
| CAbsorberGasDefinition | |
| CAbsorberVmrLevel | |
| CAbsorberVmrMet | |
| CGasVmrApriori | |
| CGasVmrAprioriMetL1b | |
| CReferenceAtmFileMixin | |
| ►Naerosol | |
| CAerosolDefinition | |
| CAerosolOptical | |
| CAerosolPropertyHdf | |
| CAerosolShapeGaussian | |
| ►Natmosphere | |
| CAltitudeHydrostatic | |
| CAtmosphereCreator | |
| CConstantForAllLevels | |
| CPressureGrid | |
| CPressureSigma | |
| CRelativeHumidity | |
| CSurfaceTemperature | |
| CTemperatureLevelOffset | |
| CTemperatureMet | |
| ►Nbase | |
| CCreator | |
| CCreatorError | |
| CParameterAccessor | |
| CParamIterateCreator | |
| CParamPassThru | |
| CPickChild | |
| CSaveToCommon | |
| ►Ncommon | |
| CDefaultConstants | |
| ►Nforward_model | |
| CFixedSpacingSpectrumSampling | |
| CForwardModel | |
| CNonuniformSpectrumSampling | |
| CPerChannelMixin | |
| CSpectralWindowRange | |
| CSpectrumEffectList | |
| CSpectrumSamplingBase | |
| CUniformSpectrumSampling | |
| ►Nground | |
| CAlbedoFromSignalLevel | |
| CGroundLambertian | |
| ►Ninstrument | |
| CApplyInstrumentUnits | |
| CDispersionPolynomial | |
| CIlsGaussian | |
| CIlsInstrument | |
| CIlsTable | |
| CInstrumentCorrectionList | |
| CInstrumentDoppler | |
| CRadianceScaling | |
| ►Nl1b | |
| CRelativeAzimuthFromLevel1b | |
| CSolarDistanceFromL1b | |
| CValueFromLevel1b | |
| ►Nmet | |
| CValueFromMet | |
| ►Nretrieval | |
| CAprioriFromIG | |
| CConnorSolverMAP | |
| CCovarianceByComponent | |
| CInitialGuessFromSV | |
| CLegacyConnorSolver | |
| CMaxAPosterioriBase | |
| CNLLSRetrieval | |
| CNLLSSolverGSLLMSDER | |
| CNLLSSolverLM | |
| CRetrievalBaseCreator | |
| CStateVector | |
| CSVObserverComponents | |
| ►Nrt | |
| CLidortRt | |
| CLsiRt | |
| CTwostreamRt | |
| ►Nsolar_model | |
| CSolarAbsorptionAndContinuum | |
| CSolarAbsorptionTable | |
| CSolarContinuumTable | |
| CSolarDopplerShiftPolynomial | |
| ►Nutil | |
| CExtendedFormatter | |
| ►Nvalue | |
| CArrayWithUnit | |
| CCreatorFlaggedValue | |
| CCreatorFlaggedValueMultiChannel | |
| CLoadValuesFromHDF | |
| CNamedCommonValue | |
| ►Nparam | |
| CAnyValue | |
| CArray | |
| CArrayWithUnit | |
| CChoice | |
| CConfigParam | |
| CDict | |
| CDoubleWithUnit | |
| CInstanceOf | |
| CIterable | |
| CObjectVector | |
| CParamError | |
| CScalar | |
| ►Nversion_util | |
| CVersionError | |
| ►Nswig_cast_test | |
| CPressureImpBase | |
| CPythonPressureSigma | |
| CAbsorberAbscoOutputHelper | |
| CAbsorberVmrFixedLevelOutputHelper | |
| CAbsorberVmrLevelHelper | |
| CAerosolOutputHelper | |
| Cbase_unit_ | Symbol table to parse a base unit |
| CBrdfOutputHelper | |
| CFluorescenceFixture | |
| CForwardModelCalc | |
| CGasAbscoOutputHelper | |
| CGroundFixture | |
| CMetDataFixture | |
| Cprefix_ | Symbol table to parse a prefix |
| CPressureFixedLevelOutputHelper | |
| CPressureOutputHelper | |
| CStandardForwardModelCalc | |
| CStokesCoefficientFractionOutputHelper | |
| Cunit_parser | |
