GPS ToolKit Software Library Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
AccessErrorThrown if a function makes a request of the OS that can't be satisfied
AccessErrorThrown if a function makes a request of the OS that can't be satisfied
Adler32This class is used to generate an Alder-32 checksum for a sequence of bytes
AllanDeviationCompute the overlapping Allan variance of the phase data provided
AlmOrbitEncapsulation of almanac SV orbital parameters (page 5, subframes 1-24)
ANSITimeThis class encapsulates the "ANSITime (seconds since Unix epoch)" time representation
AntennaThis class encapsulates the data related to GNSS antennas according to IGS standards
AntennaStoreStore antenna phase center offset information, in AntexData objects, in a std::map with receiver/satellite name
AntexBaseThis level isn't serving any purpose other than to make the class diagram look nice..
AntexDataAntex antenna data record: PCOs and PCVs for one antenna
AntexData::antennaPCOandPCVDataClass encapsulating the PCOs and PCVs of the antenna
AntexHeaderThis class models the header for an ANTEX antenna file
AntexReaderThis is a class to read and parse antenna data in Antex file format
AntexStreamThis class reads an Antex files
ARBaseThis class ..
ARExceptionNew exception for Ambiguity Resolution
ARLambdaThis class resolve integer ambiguity by the LAMBDA method
ARMLambdaThis class resolve integer ambiguity by the Modified LAMBDA method
ARSimpleThis class resolve integer ambiguity by simply round the float ambiguities to the nearest integers
AshtechALB
AshtechData
AshtechEPB
AshtechMBEN
AshtechMBEN::code_block
AshtechPBEN
AshtechStreamThis is a stream used to decode data in the Ashtech format
AssertFailedExceptionAssert failed
AssertionFailureThrown when a required condition in a function is not met
AssertionFailureThrown when a required condition in a function is not met
AtmosphericDragThis class computes the acceleration due to drag on a satellite using an Earth atmosphere model that conforms to the computeDensity abstract method
ATSDataThis class contains header information for all data types transmitted by receiver meeting the MDP specification
ATSData::ChannelBlock
ATSData::SubChannelBlock
ATSStreamThis is a stream used to decode data in the MDP format
AutoPtrAutoPtr is a "smart" pointer for classes implementing reference counting based garbage collection
AutoReleasePool
AxisThis class is used to draw a simple axis
AxisStyleThis class is used to describe an Axis's style
BancroftThis class defines an algebraic algorithm to get an initial guess of GPS receiver's position given satellites' positions and pseudoranges
Base64EncoderThis is used to encode a string in base64
BaseDistributionThis is a base class for statistical distributions
BasicFrameworkThis is a (very) basic framework for programs in the GPS toolkit
BasicModelThis is a class to compute the basic parts of a GNSS model, like geometric distance, relativity correction, satellite position and velocity at transmission time, satellite elevation and azimuth, etc
BasicShapeThis is an interface for basic shapes to group them together
BasicStreamBufThis class easy implement the custom streambufs
BinexDataThis class stores, reads, and writes BINEX records
BinexData::MGFZIA signed integer stored using 1, 2, 3, 4, 5, 6, 7, or 8 bytes to represent integers from about -1.15292e18 to +1.15292e18 using a modified version of a compression scheme developed by GFZ, plus using "special" numbers to flag certain conditions, such as using the 1-byte MFGZI to store "-0" to indicate "no value."
BinexData::UBNXIAn unsigned integer stored using 1, 2, 3, or 4 bytes to represent integers from 0 to 536870911; used to represent BINEX record IDs, subrecord IDs, field IDs, and so on
BinexDataOperatorEqualsDetermine if two BinexData objects are equal
BinexStreamThis class performs file i/o on a BINEX file for the BinexData classes
BitmapThis class defines a simple rectangle
BivarStatsConventional statistics for two samples
BLQDataReaderThis is a class to read and parse ocean tides harmonics data in BLQ file format
BorderLayoutAssists in arranging a new frame within a given one, with a margin
BrcClockCorrectionClock correction information for a single satellite
BrcKeplerOrbitOrbit information for a single satellite
Buffer
CanvasThis is an abstract class for canvases in which you can draw
CheckPRDataThis class checks that pseudorange data is between reasonable values
Chi2DistributionThis class implements the Chi-square distribution
CholeskyCompute cholesky decomposition (upper triangular square root) of the given matrix, which must be positive definite
CholeskyCroutCompute the Cholesky decomposition using the Cholesky-Crout algorithm, which is very fast; if A is the given matrix we will get L, where A = L*LT
CiraExponentialDragThis class computes the acceleration due to drag on a satellite using an exponential Earth atmosphere model
CircleThis class defines a simple circle
CivilTimeThis class encapsulates the representation of time consisting of year, month, day (of month), hour (of day), minute (of hour), and second (of minute)
ClockDataRecordData record for storing clock data. See note on units in class ClockSatStore
ClockModel
ClockSatStoreStore a table of data vs time for each of several satellites
CNAV2EphClkEphemeris information for a single satellite
CNAVClockClock information for a single satellite
CNAVEphemerisEphemeris information for a single satellite
CodeBufferP(Y)-code Buffer class
CodeKalmanSolverThis class computes the code-based solution using a simple Kalman solver
CodeSmootherThis class smoothes a given code observable using the corresponding phase observable
ColorThis class defines a color
ColorMapThis class represents a 2d pixel map of colors
CombinationsClass Combinations will compute C(n,k), all the Combinations of n things taken k at a time (where k <= n)
CombinationsClass Combinations will compute C(n,k), all the combinations of n things taken k at a time (where k <= n)
CommandLineList of Options
CommandOptionThis class is part of a replacement for getopt
CommandOptionAllOfThis is a special "command option" which is really a meta-option to make sure that if one of a set of real options has been used, all of the set are used
CommandOptionDependentThis is a special "command option" which is really a meta-option to make sure that a required option is set where the requirement is based on another option (that is, if you specify one, you must have specified another)
CommandOptionGroupAndThis is a special "command option" which is really a meta-option to group other options together for use in other meta-options
CommandOptionGroupOrThis is a special "command option" which is really a meta-option to group other options together for use in other meta-options
CommandOptionMutexThis is a special "command option" which is really a meta-option to enforce mutual exclusion between a set of real options
CommandOptionNoArgA subclass of CommandOption that has no arguments
CommandOptionOneOfThis is a special "command option" which is really a meta-option to make sure at least one of a set of real options has been used
CommandOptionParserThis class parses the command line options and modifies the corresponding CommandOptions
CommandOptionRestIt only makes sense to have a single one of these set. CommandOption to take the rest of the command line
CommandOptionWithAnyArgA CommandOption that requires a string argument
CommandOptionWithArgA subclass of CommandOption that has an argument
CommandOptionWithCommonTimeArgCommand-line option class for processing time strings. This class is allows the programmer to add command-line options to an application that can parse strings containing representations of time. The programmer must specify the format to be accepted. Refer to each TimeTag class' getDefaultFormat() for details on the formatting specifications
CommandOptionWithNumberArgA CommandOption that requires a numeric argument
CommandOptionWithPositionArgCommand-line option class for processing position strings. This class allows the programmer to add command-line options to an application that can parse strings containing representations of position. The programmer must specify the format to be accepted. Refer to Position::printf() for details on the formatting specifications
CommandOptionWithSimpleTimeArg
CommandOptionWithStringArgA CommandOption that requires a string argument
CommandOptionWithTimeArgCommand-line option class for processing time strings. This class is allows the programmer to add command-line options to an application that can parse strings containing representations of time. The programmer must specify the format to be accepted. Refer to CommonTime::printf() for details on the formatting specifications
CommentThis class defines a simple comment
CommonTimeThis is the common time format that all time formats convert to when converting between themselves
CommonTimeNotFoundThrown when attempting to access a value and the corresponding epoch (CommonTime) does not exist in the map
ComputeCombinationThis class eases computing combination of data for GNSS data structures
ComputeDOPThis class computes the usual DOP values: GDOP, PDOP, TDOP, HDOP and VDOP
ComputeIonoModelThis is a class to compute the main values related to a given GNSS ionospheric model
ComputeIURAWeightsThis class computes satellites weights based on URA Index
ComputeLCThis class eases computing LC combination for GNSS data structures
ComputeLdeltaThis class eases computing Ldelta combination for GNSS data structures
ComputeLIThis class eases computing LI combination for GNSS data structures
ComputeLinearThis class computes linear combinations of GDS data
ComputeMelbourneWubbenaThis class eases computing Melbourne-Wubbena combination for GNSS data structures
ComputeMOPSWeightsThis class computes satellites weights based on the Appendix J of MOPS C
ComputePCThis class eases computing PC combination for GNSS data structures
ComputePdeltaThis class eases computing Pdelta combination for GNSS data structures
ComputePIThis class eases computing PI combination for GNSS data structures
ComputeSatPCenterThis class computes the satellite antenna phase correction, in meters
ComputeSimpleWeightsThis class computes simple satellites weights partially based on the variance model by Kennedy, 2002
ComputeTropModelThis is a class to compute the main values related to a given GNSS tropospheric model
ComputeWindUpThis class computes the wind-up effect on the phase observables, in radians
ConfCallBack
ConfData
ConfDataItem
ConfDataItemAbstractThis class ..
ConfDataReaderThis is a class to parse and manage configuration data files
ConfDataSectionThis class ..
ConfDataWriterThis is a class to write configuration data files
ConfigurationExceptionApplication's configuration is invalid
ConfigurationExceptionApplication's configuration is invalid
ConfigureLOGClass ConfigureLOG - inherits class Log with type ConfigureLOGstream
ConfigureLOGstreamClass ConfigureLOGstream Configure and write to a log stream; type-safe, thread-safe and very portable
ConstMatrixBaseA matrix base class for a non-modifiable matrix
ConstMatrixColSliceConstant slice of a single column from a matrix
ConstMatrixRowSliceUnmodifiable row slice of a matrix
ConstMatrixSliceAn unmodifiable matrix slice
ConstMatrixSliceBaseBase class for an unmodifiable matrix slice
ConstraintConstraint structure declaration
constraintHeaderConstraint header declaration
ConstraintSystem
ConstVectorBaseA base class for a vector that does not allow modification of the internal vector
ConstVectorSliceA Vector<T> slice that doesn't allow modification
ConstVectorSliceBaseA vector slice base class that doesn't allow modification of the internal elements
ConvertC1ToP1This class convert C1 observable to P1 observable with add (P1-C1) Differences of Code Biases(P1-C1)
CorrectCodeBiasesThis class corrects observables from differential code biases.(P1-P2) or (P1-C1)
CorrectedEphemerisRangeClass CorrectedEphemerisRange
CorrectObservablesThis class corrects observables from effects such as antenna excentricity, difference in phase centers, offsets due to tidal effects, etc
CRC32This class is used to generate a CRC-32 checksum for a sequence of bytes
CRCDataStatus
CRCExceptionThis is thrown when there is an error processing a CRC
CRCParamEncapsulate parameters for CRC computation
DataBinMethods to exchange data between gnssDataMap and binary file
DataStatus
DayTimeBin
DCBDataReaderThis is a class to read and DCB(Differences of Code Biases) data file from CODE
DDid
DebugUtilsThis class ..
DecimateThis class decimates GNSS Data Structures data
DecimateEpochThrown when some epoch data must be decimated
DecodeBitsDecodeBits
DecodeQuantDecodeQuant contains the information necessary to decode a given quantity for a particular navigation message subframe
DeltaOpThis class applies the Delta operator (differences on ground-related data) to GNSS data structures
DifferentiatorThis class computes the numerical derivative of a given TypeID
DOPThis class encapsulates the computation of DOP, given the Covariance matrix of an equation system
DoubleOpThis class applies the double difference (differences on ground and satellite -related data) to GNSS data structures
DumperThis class dumps the values inside a GNSS Data Structure (GDS), and therefore is meant to be used with the GDS objects found in "DataStructures" class
EarthBodyClass to handle earth planet, it'll be taken as the central body of the spacecraft
EarthOceanTideSolid Earth Ocean Tide reference: IERS Conventions 2003
EarthOceanTide::CSR_OTIDEStruct to hold Ocean Tide information
EarthOrientationEarth orientation parameters
EarthPoleTideSolid Earth Pole Tide reference: IERS Conventions 2003
EarthSolidTideClass to do Earth Solid Tide correction reference: IERS Conventions 2003
EclipsedSatFilterThis class filters out satellites that are eclipsed by Earth shadow
EGM96GravityModelEGM96 gravity model
EllipsoidModelThis abstract class encapsulates ellipsoid models (e.g
EndOfFileThis gets thrown if a valid EOF occurs on formattedGetLine
EngAlmanacAlmanac information for the GPS constellation
EngAlmanac::SVNotPresentExceptionException - requested almanac page that wasn't present
EngEphemerisEphemeris information for a single satellite
EngNavBase class for ICD-GPS-200 navigation messages
ENUUtilA utility for converting from Cartesian in XZY to East-North-Up (ENU)
EOPDataStoreClass to store and manage Earth Orientation data
EOPDataStore::EOPData
EOPPredictionEarth orientation parameter prediction Read data from EOPP###.txt file, available from NGA
EOPStoreEarth orientation parameter store
EphReader
Epoch
Epoch::EpochException
Epoch::FormatException
EpochClockModel
EpochDataStoreClass to handle interpolatable time serial data
EPSImageThis class generate a vector image in the Encapsulated Postscript (EPS) file format version 3.0
EquationGNSS Data Structure to define and handle 'descriptions' of GNSS equations
equationHeaderDefines a header containing basic equation data
EquationOfMotionThe EquationsOfMotion provides the mechanism for passing a method that computes the derivatives to an integrator
EquationSystemThis class defines and handles complex equation systems for solvers, generating the Vectors and Matrices they will need, including:
ExceptionBase class from which all exception objects thrown in the library are derived
ExceptionBase class from which all exception objects thrown in the library are derived
ExceptionLocationA class for recording locations (in the source code) of exceptions being thrown
ExceptionLocationA class for recording locations (in the source code) of exceptions being thrown
Expression
ExpressionExceptionThis class provides the ability to resolve general mathematical expressions at run time
ExtractCombinationDataThis class eases the extraction of a combination of data from a Rinex3ObsData object
ExtractDataThis is the base class to ease data extraction from a RinexObsData object
ExtractLCThis class eases LC combination data extraction from a Rinex3ObsData object
ExtractPCThis class eases PC combination data extraction from a Rinex3ObsData object
FFBinaryStreamThis is an FFStream that is required to be binary
FFDataThis is the base class for all Formatted File Data (FFData)
FFIdentifier
FFStreamFormatted File Stream (FFStream)
FFStreamErrorFFStreamError is an exception for when the file read doesn't match the specs for that file type
FFTextStreamAn FFStream is meant for reading text
FICAStreamThis is a stream used to obtain data from an ascii FIC File
FICBaseThis is a base class for all FIC-related classes
FICDataThis does all the grunt-work in reading/decoding FIC-formatted files (ASCII And Binary)
FICData109
FICData162
FICData62
FICData9
FICDataFilterBlockRemoves all data that doesn't match the given block numbers
FICDataFilterEndTime
FICDataFilterPRNRemoves all data that doesn't match the given SVID/PRN numbers
FICDataFilterStartTime
FICDataFindBlockFinds all data that matches the given block numbers
FICDataOperatorLessThanBlock109Sorting only for block 109 FICData
FICDataOperatorLessThanBlock9Sorting only for block 9 FICData
FICDataOperatorLessThanFullUseful for FICDiff and others..
FICDataUniqueBlock109Uniqueness operator for block 109 FIC data
FICDataUniqueBlock162Uniqueness operator for block 162 FIC data
FICDataUniqueBlock62Uniqueness operator for block 62 FIC data
FICDataUniqueBlock9Uniqueness operator for block 9 FIC data
FICHeaderThis is the Header for the FIC File Model
FICStreamThis is a stream used to obtain data from a binary FIC File
FICStreamBaseEncapsulates FIC stream data for FIC and FICA files
FileFilterThis class is a framework for sorting and filtering file data
FileFilter::SortAdapterSortAdapter is an adapter class that takes any comparison function and instead uses list iterator objects instead of FileData
FileFilterFrameThis class is a wrapper for FileHunter and FileFilter, allowing you to easily pick what files you want to process and how to process them
FileFilterFrameWithHeaderThis is just like FileFilterFrame but it can also handle header data
FileHunterFileHunter is a class designed to find files matching specified criteria
FileHunterExceptionThe only exception that class FileHunter throws
FileMissingExceptionAttempted to open a file that doesn't exist
FileMissingExceptionAttempted to open a file that doesn't exist
FileSpecA FileSpec is how file names are defined
FileSpec::FileSpecElementThis is an internal, private class of FileSpec that holds information for one individual file specification element
FileSpec::FileSpecSortAnother private, internal class for doing sorting by substring
FileSpecExceptionThis exception is thrown when there is a problem with handling file specifications
FileStoreThis is an abstract class (loadFile is pure virtual) used to add a list of files and the interface to read files into a datastore
FillableThis is an interface for fillable basic shapes to group them together
FilterBaseAbstract base class for filter algorithms
FIRDifferentiator5thOrderThis class implements a Finite Impulsive Response (FIR) Differentiator filter of 5th order designed according to central difference approximation
ForceModelForce Model is a simple interface which allows uniformity among the various force models
ForceModelListForceModelList is a countainer for force models
format
FrameThis class defines a frame that can be drawn in
GalEphemerisEphemeris information for a single satellite
GalEphemerisStoreAbstract base class for storing and accessing an objects position, velocity, and clock data
GaussianDistributionThis class implements the Gaussian (or normal) distribution
GCATTropModelTropospheric model implemented in "GPS Code Analysis Tool" (GCAT) software
GDCconfigurationClass GDCconfiguration encapsulates the configuration for input to the GPSTK Discontinuity Corrector
GDCPass
GDCreturnClass GDCreturn encapsulates the information in the 'message' returned by the GPSTK Discontinuity Corrector
GeneralConstraintThis class working with 'SolverGeneral'
GeneralEquationsThis class ..
GeneralEquations::SatDataStruct holding satellite related data
GenXSequenceGenerate X Sequence for GPS Applied Research Laboratories, The University of Texas at Austin August 2003
GeodeticFramesClass GeodeticFrames encapsulates frame transformations between the conventional terrestrial frame and the conventional inertial frame, as defined by the reference
GeometryExceptionThrown when a gpstk::Triple operation can't be completed
GGHeightTropModelTropospheric model with heights based on Goad and Goodman(1974), "A Modified Hopfield Tropospheric Refraction Correction Model," Paper presented at the Fall Annual Meeting of the American Geophysical Union, San Francisco, December 1974
GGTropModelTropospheric model based on Goad and Goodman(1974), "A Modified Hopfield Tropospheric Refraction Correction Model," Paper presented at the Fall Annual Meeting of the American Geophysical Union, San Francisco, December 1974, as presented in Leick, "GPS Satellite Surveying," Wiley, NY, 1990, Chapter 9 (note particularly Table 9.1)
GloEphemerisEphemeris information for a single GLONASS satellite
GloEphemerisStoreThis adds the interface to get GLONASS broadcast ephemeris information
GloFreqIndexThis class determines the GLONASS frequency (channel) indexes from Obs data
GloFreqIndex::IndexDataData type declarations
gnssConfDataAttention: The BODY_CLASS have to be with a member name as the key of config map
gnssDataBasic gnssData structure
gnssDataMapGNSS data structure consisting in a map with CommonTime as keys, and sourceDataMap as elements
gnssDataMapBin
gnssEquationDefinitionObject defining the structure of a GNSS equation
gnssLinearCombinationObject defining the structure of a GNSS linear combination
gnssRinexGNSS data structure with source, epoch and extra Rinex data as header (common indexes) and satTypeValueMap as body
gnssSatTypeValueGNSS data structure with source and epoch as header (common indexes) and satTypeValueMap as body
gnssSatValueGNSS data structure with source, epoch and data type as header (common indexes) and satValueMap as body
gnssTypeValueGNSS data structure with source, epoch and satellite as header (common indexes) and typeValueMap as body
GPSAlmanacStoreStore GPS almanac information (i.e
GPSEllipsoidThis class represents the ellipsoidal model defined in ICD-GPS-200
GPSEphemerisStoreAbstract base class for storing and accessing an objects position, velocity, and clock data
GPSOrbElemStoreClass for storing and accessing GPS SV's position, velocity, and clock data
GPSWeekThis class is an abstract base class inherited by other GPS-time-related classes
GPSWeekSecondThis class encapsulates the "Full GPS Week and GPS Seconds-of-week" time representation
GPSWeekZcountThis class encapsulates the "Full GPS Week and GPS Z-count" time representation
GPSZcountA representation class for GPS Time consisting of a short GPS week, and a long GPS Z-count
GravitationalDelayThis class computes the delay in the signal due to changes in the gravity field
GridLayoutAssists in arranging frames in a grid with some number of rows and columns
GSatID
HarrisPriesterDragThe HarrisPriester class computes the Harris-Priester atmosphere model
HelmertTransform
HelmertTransform::TransformThe struct holding the prebuilt matrix, its inverse and translation
HelmertTransform::TransformParametersA set of parameters that define a Helmert Transform
HelperThis class contains static helper methods for common code related to this library
HexDumpDataConfigClass for configuring the appearance of hexDumpData() output
HLayoutAssists in arranging frames in a horizontal stack
HouseholderThe Householder transformation is simply an orthogonal transformation designed to make the elements below the diagonal zero
IERSClass to easy handle IERS Earth Orientation Data globally
IndexedColorMapThis class represents a 2d pixel map of colors
IndexOutOfBoundsExceptionAttempts to access an "array" or other element that doesn't exist
IndexOutOfBoundsExceptionAttempts to access an "array" or other element that doesn't exist
InOutFrameworkThis is a framework for programs that take a single type of input data and output a single stream of output
IntegratorThis is an abstract base class for objects solving a ODE system with integrator
InterpolatedColorMapThis class represents a 2d pixel map of colors
InvalidAntexThrown when some problem appeared when reading Antex data
InvalidArgumentExceptionA function was passed an invalid argument
InvalidArgumentExceptionA function was passed an invalid argument
InvalidConstraintThrown when attempting to use an invalid Constraint
InvalidConstraintSystemThrown when attempting to use an invalid ConstraintSystem
InvalidDOPThrown when some problem appeared when computing DOP
InvalidEquationSystemThrown when attempting to use an invalid EquationSystem
InvalidParameterThrown when a function is given a parameter value that it invalid
InvalidParameterThrown when a function is given a parameter value that it invalid
InvalidRequestThrown if a function can not satisfy a request
InvalidRequestThrown if a function can not satisfy a request
InvalidSolverThrown when some problem appeared when solving a given equation set
InvalidValue
InvalidWeightsThrown when some problem appeared when assigning weights to satellites
IonexBaseThis class does not served any purpose other than to make readable inheritance diagrams
IonexDataThis class models a IONEX Data Record
IonexData::IonexValTypeA structure used to store IONEX Value Types
IonexHeaderThis class models the header for a IONEX file
IonexHeader::DCB
IonexModelThis is a class to compute the main values related to a given GNSS IONEX model, i.e., TEC value, ionospheric mapping function and slant ionospheric delay
IonexStoreThis class reads and stores Ionosphere maps
IonexStreamThis class provides access to IONEX files
IonoModelModel of the ionosphere
IonoModel::InvalidIonoModelThrown when attempting to use a model for which all necessary parameters have not been specified
IonoModelStoreThis class defines an interface to hide how we determine the ionospheric delay as determined from GPS navigation message based models at some point in time
IonoModelStore::NoIonoModelFoundThrown when attempting to get a model that isn't stored
JGM3GravityModelJGM3 gravity model
JulianDateThis class encapsulates the "Julian Date" time representation
KalmanFilter
KeeperThis class examines a GNSS Data Structure (GDS) and keeps only specific values according to their TypeIDs
KeplerOrbitThis class do some useful Keplerian orbit computation
LabelledMatrixClass LabelledMatrix. Pretty print a Matrix using the labels in a Namelist
LabelledVectorClass LabelledVector. Pretty print a Vector using the labels in a Namelist
LayoutThis class is used to create new frames from an existing frame
LEOSatOrbitThis class handle equation of motion for low earth orbit satellites
LICSDetectorThis is a class to detect cycle slips using LI observables
LICSDetector2This is a class to detect cycle slips using LI observables and a 2nd order fitting curve
LineThis class defines a simple line between a set of points
LinearClockModel
LinearCombinationsThis class defines handy linear combinations of GDS data
LinePlot
ListStatsListStats (i.e. Statistics on a list of numbers)
LogTemplate class Log is used by classes ConfigureLOG and ConfigureLOGstream
LoopedFrameworkThis is a basic framework for programs processing in loops in the GPSTK
LUDecompPerforms the lower/upper triangular decomposition of a matrix PA = LU
MainAdapterThis is an assist class for the macros 'GPSTK_START_MAIN()' the type T should be a subclass of the class 'BasicFramework'
MarkableThis is an interface for markable basic shapes
MarkerThis class defines a marker which will be drawn at every point on a line
MatrixAn implementation of a matrix class using Vector<T> as its internal basis
MatrixColSliceAssignable single column slice of a matrix
MatrixException
MatrixRowSliceAssignable single row slice of a matrix
MatrixSliceAn assignable slice of a matrix
MatrixSliceBaseBase class for defining a slice of a matrix
MDPHeaderThis class contains header information for all data types transmitted by receiver meeting the MDP specification
MDPNavSubframeThis class represents a Navigation Subframe Message
MDPObsEpochThis class represents a set of observations from a single SV at a single point in time
MDPObsEpoch::Observation
MDPPVTSolutionThis class represents a Position-Velocity-Time Solution
MDPSelftestStatusThis class represents a runtime selftest status message
MDPStreamThis is a stream used to decode data in the MDP format
MetReader
MinSfTest
MJDThis class encapsulates the "Modified Julian Date" time representation
ModeledPRThis class compute modeled pseudoranges from satellites to a mobile receiver
ModeledPseudorangeBaseThis abstract class deals with modeled pseudoranges
ModeledReferencePRThis class compute modeled pseudoranges from satellites to a reference station
ModelObsThis class compute modeled (corrected) observations from satellites to a mobile receiver using GNSS data structures (GDS)
ModelObsFixedStationThis class computes modeled (corrected) observations from a reference station (whose position is known), using GNSS data structures (GDS)
MoonForceThis class calculate the gravitational effect of the moon
MoonPositionThis class computes the approximate position of the Moon at the given epoch in the ECEF system
MOPSTropModelTropospheric model implemented in the RTCA "Minimum Operational Performance Standards" (MOPS), version C
MOPSWeightClass to assign weights to satellites based on the Appendix J of MOPS document RTCA DO-229D
MSCBaseThis is a base class for all MSC-related classes
MSCDataModel for a Monitor Station Coordinates File Data Record
MSCHeaderThis class does not really do anything
MSCStoreStore Monitor Station coordinate information and return either the raw information or the position at a given time based on integration of station velocity information over time since the epoch time
MSCStreamStream used to obtain data from a Monitor Station Coordinates File
Msise00DragThis class computes the NRLMSISE atmosphere model
Msise00Drag::ap_array
Msise00Drag::nrlmsise_flags
Msise00Drag::nrlmsise_input
Msise00Drag::nrlmsise_output
MWCSDetectorThis is a class to detect cycle slips using MW observables
NablaOpThis class applies the Nabla operator (differences on satellite-related data) to GNSS data structures
NamelistClass Namelist
NavSatOrbitThis class handle equation of motion for navigation satellites
NBTropModelTropospheric model developed by University of New Brunswick and described in "A Tropospheric Delay Model for the User of the Wide Area Augmentation System," J
NEDUtilA utility for converting from Cartesian in XZY to North-East-Down (NED)
NeillTropModelTropospheric model based in the Neill mapping functions
NetworkObsStreamsThis class synchronizes rinex observation data streams
NetworkObsStreams::ObsDataStruct to hold all the data for a observation file
NovatelDataRead Novatel binary records and parse into Rinex
NovatelStreamThe stream used to obtain data from a binary Novatel File
NullPointerExceptionAttempted to access a null pointer
NullPointerExceptionAttempted to access a null pointer
NumberOfSatsMismatchThrown when the number of data values and the number of corresponding satellites does not match
NumberOfTypesMismatchThrown when the number of data values and the number of corresponding types does not match
ObjectNotFoundOperation failed because it was unable to locate the requested obj
ObjectNotFoundOperation failed because it was unable to locate the requested obj
ObsClockModel
ObsEphReaderFramework
ObsEpochAll the observations collected from a single receiver at a single epoch
ObsID
ObsID::Initializer
ObsReader
ObsRngDevA single (one observation from one sv), Observed Range Deviation (ORD)
OceanLoadingOcean loading
OneFreqCSDetectorThis is a class to detect cycle slips using observables in just one frequency
OrbElem
OrbElemCNAV
OrbElemCNAV2
OrbElemFIC109
OrbElemFIC9
OrbElemICE
OrbElemLNav
OrbElemRinex
OrbElemStoreAbstract base class for storing and accessing an objects position, velocity, and clock data
ORDEpoch
OutOfMemoryUnable to allocate memory
OutOfMemoryUnable to allocate memory
OWid
PackedNavBits
PaletteThis class defines a simple interpolated palette of colors
PathThis class defines a sequence of points
PCSmootherThis class smoothes the PC (ionosphere-free) code observable using the corresponding LC phase observable
PendulumIntegrator
PhaseAmbiguityModelThis class compute the elements of Phi and Q matrices corresponding to a phase ambiguity variable: Constant stochastic model within cycle slips and white noise stochastic model when a cycle slip happens
PhaseCodeAlignmentThis class aligns phase with code measurements
PlanetEphemerisThis class Handle planet ephemeris from JPL
Plot
PNGUsed to create PNG Images
PointThis class describes a point as an (x,y) coordinate
PoleTidesThis class computes the effect of pole tides, or more properly called "rotational deformations due to polar motion", at a given position and epoch
PolyFitCompute a polynomial fit of the form sum[X(i)*t**i] = d, that is solve for coefficients X given a set of data pairs (t,d)
PolygonThis class defines a simple line between a set of points
PositionA position representation class for common 3D geographic position formats, including geodetic (geodetic latitude, longitude, and height above the ellipsoid) geocentric (geocentric latitude, longitude, and radius from Earth's center), cartesian (Earth-centered, Earth-fixed) and spherical (theta,phi,radius)
PositionSatStoreStore a table of data vs time for each of several satellites
PositionStoreDataRecordData record for storing clock data. See note on units in class PositionStore
PowerSum
PreciseRangeClass PreciseRange
ProblemSatFilterThis class filters out satellites that are in the Satellite Problem File(*.CRX) of Bernese GPS Software 5.0
ProblemSatFilter::SatData
ProcessingClassThis is an abstract base class for objects processing GNSS Data Structures (GDS)
ProcessingExceptionThrown when there is a problem processing GDS data
ProcessingListThis is a class to store ProcessingClass objects in a list
ProcessingVectorThis is a class to store ProcessingClass objects in a vector
PRSMemory
PRSolutionThis class defines an interface to routines which compute a position and time solution from pseudorange data, with a data editing algorithm based on Receiver Autonomous Integrity Monitoring (RAIM) concepts
PRSolution2This class defines an interface to routines which compute a position and time solution from pseudorange data, with a data editing algorithm based on Receiver Autonomous Integrity Monitoring (RAIM) concepts
PrunerThis class examines a GNSS Data Structure (GDS) and prunes specific values according to their TypeIDs
PSImageThis class generates vector graphics conformant with Postscript Level 2
PSImageBaseThis class implements the functionality common between the EPS and Postscript formats
PvtStoreClass to store and manage vehicle position velocity and clock
PvtStore::PvtData
PZ90Ellipsoid
RACRotation
RandomWalkModelThis class compute the elements of Phi and Q matrices corresponding to a random walk stochastic model
RectangleThis class defines a simple rectangle
ReferenceCounter
ReferenceFrameCoordinate Reference Frame Class
ReferenceFramesClass to do Reference frame transformation
RefMatrixBaseA matrix base class that allows assignment of the internal matrix
RefMatrixSliceBaseBase class for a modifiable matrix slice
RefVectorBaseA vector base class that allows modification of the internal representation
RefVectorBaseHelperClass to hold the static members of RefVectorBase
RefVectorSliceBaseA vector slice base class that does allow modification of the internal elements
RelativityEffectThis class calculate Relativity Effect to earth satellite
ReleaseArrayPolicyThe release policy for array of simple or class
ReleaseCustomizePolicyThe release policy for customize
ReleasePolicyDefault release policy for simple type or class
RequiredOptionA subclass of CommandOption that is a required command line option
RequireObservablesThis class filters out satellites that don't have the required observations
Rinex3ClockBaseThis level isn't serving any purpose other than to make the class diagram look nice..
Rinex3ClockDataThis class models a RINEX3 clock data file
Rinex3ClockHeaderThis class models the header for a RINEX3 clock file
Rinex3ClockHeader::RefClkHolds the necessary data for one reference clock corresponding to one "ANALYSIS CLK REF" line
Rinex3ClockHeader::RefClkRecordHolds the data for the analysis clock references i.e., the "# OF CLK REF" lines
Rinex3ClockHeader::RinexClkTypeRINEX clock data types
Rinex3ClockStreamThis class reads RINEX3 clock data files
Rinex3EphemerisStore
Rinex3NavBaseThis class serves no purpose other than to make readable diagrams
Rinex3NavDataThis class models a RINEX 3 Nav record
Rinex3NavDataFilterPRNFilter based on PRN ID
Rinex3NavDataOperatorEqualsFullThis compares all elements of the Rinex3NavData with equals
Rinex3NavDataOperatorLessThanFullThis compares all elements of the Rinex3NavData with less than
Rinex3NavDataOperatorLessThanSimpleOnly compares time. Suitable for sorting a Rinex3Nav file
Rinex3NavHeaderThis class models the RINEX 3 Nav header for a RINEX 3 Nav file
Rinex3NavHeader::IonoCorrIonospheric Corrections
Rinex3NavHeaderTouchHeaderMergeCombines Rinex3NavHeaders into a single header, combining comments
Rinex3NavStreamThis class performs file i/o on a RINEX 3 NAV file
Rinex3ObsBaseThis level isn't serving any purpose other than to make the class diagram look nice..
Rinex3ObsDataThis class models a RINEX Observation Data Record
Rinex3ObsData::RinexDatumA structure used to store a single RINEX Data point
Rinex3ObsDataOperatorEqualsSimpleThis simply compares the times of the two records for equality
Rinex3ObsDataOperatorLessThanFullThis compares all elements of the Rinex3ObsData with less than (only for those fields which the two obs data share)
Rinex3ObsDataOperatorLessThanSimpleThis is a much faster less than operator for Rinex3ObsData, only checking time
Rinex3ObsHeaderThis class models the header for a RINEX 3 Observation File
Rinex3ObsHeader::ExtraWaveFactRINEX 2 extra "WAVELENGTH FACT" lines
Rinex3ObsHeader::Rinex3CorrInfoRINEX 3 DCBS/PCVS info (for differential code bias and phase center variations corr.)
Rinex3ObsHeaderTouchHeaderMergeCombines Rinex3ObsHeaders into a single header, combining comments and adding the appropriate Rinex3ObsTypes
Rinex3ObsStreamThis class reads RINEX 3 Obs files
RinexClockBaseThis class is here to make readable inheritance diagrams
RinexClockDataThis class encapsulates data for satellite clocks as found in RINEX Clock format files, and is used in conjuction with class RinexClockStream, which handles the I/O, and RinexClockHeader, which holds information from the RinexClock file header
RinexClockHeaderThis class models the header for a RINEX Clock file
RinexClockStoreStore a table of data vs time for each of several satellites using data from RINEX clock files
RinexClockStreamThis class performs file I/O on an RINEX Clock format file for the RinexClockHeader and RinexClockData classes
RinexConverter
RinexConverter::Initializer
RinexMetBaseThis class serves no purpose other than to make readable diagrams
RinexMetDataThis class stores, reads, and writes RINEX 2 & 3 Met records
RinexMetDataFilterTimeThis filter will return true for any data not within the specified time range
RinexMetDataOperatorEqualsSimpleCompares only times
RinexMetDataOperatorLessThanFullThis compares all elements of the RinexMetData with less than (only for those fields which the two obs data share)
RinexMetDataOperatorLessThanSimpleCompares only times
RinexMetHeaderThis class models the RINEX MET header for a RINEX MET file
RinexMetHeader::sensorPosTypeStruct for holding info about a sensor position
RinexMetHeader::sensorTypeStruct for holding information about a sensor
RinexMetHeaderTouchHeaderMergeCombines RinexMetHeaders into a single header, combining comments and adding the appropriate RinexMetTypes
RinexMetStreamThis class performs file i/o on a RINEX MET file for the RinexMetHeader and RinexMetData classes
RinexNavBaseThis class serves no purpose other than to make readable diagrams
RinexNavDataThis class models a RINEX NAV record
RinexNavDataFilterPRNFilter based on PRN ID
RinexNavDataOperatorEqualsFullThis compares all elements of the RinexNavData with equals
RinexNavDataOperatorLessThanFullThis compares all elements of the RinexNavData with less than
RinexNavDataOperatorLessThanSimpleOnly compares time. Suitable for sorting a RinexNav file
RinexNavHeaderThis class models the RINEX NAV header for a RINEX NAV file
RinexNavHeaderTouchHeaderMergeCombines RinexNavHeaders into a single header, combining comments This assumes that all the headers come from the same station for setting the other header fields
RinexNavStreamThis class performs file i/o on a RINEX NAV file
RinexObsBaseThis level isn't serving any purpose other than to make the class diagram look nice..
RinexObsDataThis class models a RINEX Observation Data Record
RinexObsData::RinexDatumA structure used to store a single RINEX Data point
RinexObsDataOperatorEqualsSimpleThis simply compares the times of the two records for equality
RinexObsDataOperatorLessThanFullThis compares all elements of the RinexObsData with less than (only for those fields which the two obs data share)
RinexObsDataOperatorLessThanSimpleThis is a much faster less than operator for RinexObsData, only checking time
RinexObsHeaderThis class models the header for a RINEX Observation File
RinexObsHeader::ExtraWaveFactHolds the data for the extra Wavelength Factor lines
RinexObsHeader::RinexObsTypeRINEX Observation Types
RinexObsHeaderTouchHeaderMergeCombines RinexObsHeaders into a single header, combining comments and adding the appropriate RinexObsTypes
RinexObsIDClass RinexObsID is the set of ObsID's which are valid in RINEX 3.01
RinexObsStreamThis class reads RINEX files
RinexSatID
RK4VehicleModelThis class implements a simple kinematic model of a vehicle
RTFileFrameThis class supports two iteration semantics
RTFileFrameHelperSpecifying internal enums and classes of a template class can be problematic, so these are declared outside RTFileFrame
RTFileFrameIteratorAn iterator class for the RTFileFrame
RungeKutta4Collection of integration routines that work on a Matrix of doubles
RungeKuttaFehlbergThis class do integrations with Runge Kutta Fehlberg algorithm
RungeKuttaFehlberg::RKF78Param
SaasTropModelSaastamoinen tropospheric model based on Saastamoinen, J., 'Atmospheric Correction for the Troposphere and Stratosphere in Radio Ranging of Satellites,' Geophysical Monograph 15, American Geophysical Union, 1972, and Ch 9 of McCarthy, D and Petit, G, IERS Conventions (2003), IERS Technical Note 32, IERS, 2004
SatArcMarkerThis class keeps track of satellite arcs caused by cycle slips
SatDataReaderThis is a class to read and parse satellite data from PRN_GPS-like files
SatIDSatellite identifier consisting of a satellite number (PRN, etc.) and a satellite system
SatIDBin
SatIDNotFoundThrown when attempting to access a value and the corresponding SatID does not exist in the map
SatOrbitThis Class handle general orbit for different satellite orbit type
SatOrbit::FMCDataStruct to hold force model setting data
SatOrbitPropagatorSatellite Orbit Progagator
SatOrbitStore
SatPassClass SatPass holds all range and phase data for a full satellite pass
SatPass::SatPassData
SatPassIteratorIterate over a list (vector) of SatPass using this class
satTypeValueMapMap holding SatID with corresponding typeValueMap
satTypeValueMapBin
satValueMapMap holding SatID with corresponding numeric value
ScatterPlot
SDid
Segment
SEMAlmanacStore
SEMBaseThis is a base class for all SEM-related classes
SEMDataThis class stores, reads, and writes SEM records
SEMHeaderThis class stores, reads, and writes SEM records
SEMStreamThis class performs file i/o on a SEM file for the SEMHeader and SEMData classes
SeriesListThis class will maintain a list of series including their title and strokestyle
SimpleFilterThis class filters out satellites with observations grossly out of bounds
SimpleIURAWeightClass to assign weights to satellites based on their URA Index (IURA)
SimpleKalmanFilterThis class computes the solution using a Kalman filter
SimpleTropModelA simple Black model of the troposphere. temp is in Kelvin
Singleton
SingularMatrixException
Slip
SMODFDataModel for a Smoothed Measurement Data File Data Record
SMODFStreamThis is a stream used to obtain data from a Smoothed Measurement Data File
SolarRadiationPressureThis class provides a generic model for the influence of solar radiation pressure on a satellite
SolarSystemClass SolarSystem encapsulates the information in the JPL ephemeris file, both header and data, reading and writing of both ASCII and binary files, as well as the computation of position and velocity of the sun, moon and planets, plus nutations and lunar librations and their rates
SolidTidesThis class computes the effect of solid Earth tides at a given position and epoch
SolverBaseAbstract base class for solver algorithms
SolverGeneralThis class is an Extended Kalman Filter (EKF) implementation that is run-time programmable, making it extremely flexible
SolverLMSThis class computes the Least Mean Squares Solution of a given equations set
SolverPPPThis class computes the Precise Point Positioning (PPP) solution using a Kalman solver that combines ionosphere-free code and phase measurements
SolverPPPFBThis class computes the Precise Point Positioning (PPP) solution using a Kalman solver that combines ionosphere-free code and phase measurements
SolverWMSThis class computes the Weighted Least Mean Squares Solution of a given equations set
sourceDataMapGNSS data structure consisting in a map with SourceID as keys, and satTypeValueMap as elements
sourceDataMapBin
sourceEpochHeaderDefines a header containing the source and epoch of data
sourceEpochRinexHeaderDefines a header containing the source and epoch of data, plus extra data extracted from a Rinex file
sourceEpochSatHeaderDefines a header containing the source, satellite ID and epoch of data
sourceEpochTypeHeaderDefines a header containing the source, type and epoch of data
sourceHeaderSet of several headers to be used with data structures. Defines a header containing just the source of data
SourceID
SourceID::Initializer
SourceIDBin
SourceIDNotFoundThrown when attempting to access a value and the corresponding source (SourceID) does not exist in the map
sourceSatHeaderDefines a header containing the source and satellite ID of data
sourceTypeHeaderDefines a header containing the source and type of data
SP3BaseThis class is here to make readable inheritance diagrams
SP3DataThis class encapsulates data for satellite orbits and clocks, including positions, velocities and other orbit and estimation information read as found in I/O of SP3 format (versions a, b, or c) files
SP3EphemerisStoreStore position and clock bias (and perhaps velocity and drift) data from SP3 files, using (separate) stores based on TabularSatStore
SP3HeaderThis class models the header for a SP3 file
SP3SatID
SP3StreamThis class performs file I/O on an SP3 file for the SP3Header and SP3Data classes
SpacecraftEncapsulates physical parameters
SphericalHarmonicGravityThis class computes the body fixed acceleration due to the harmonic gravity field of the central body
SphericalHarmonicGravity::GravityModelData
SplitterThis is a helper class that assists with cutting a set of points along a line
SRIClass SRI encapsulates all the information associated with the solution of a set of simultaneous linear equations
SRIFilterClass SRIFilter inherits SRI and implements a square root information filter, which is the square root formulation of the Kalman filter algorithm
SRIleastSquaresClass SRIleastSquares inherits SRI and implements a general least squares algorithm using SRI, including weighted, linear or linearized, robust and/or sequential algorithms
StatsConventional statistics for one sample
StochasticModelThis is a base class to define stochastic models
StringBin
StringExceptionThis is thrown instread of a std::exception when a gpstk::StringUtils function fails
StrokeStyleThis class defines how a line, path, or edge appears
StudentDistributionThis class implements the t-Student distribution
SunForceThis class calculate the gravitational effect of the Sun
SunPositionThis class computes the approximate position of the Sun at the given epoch in the ECEF system
SurfacePlot
SVDClass SVD: A function object for the singular value decomposition of a matrix
SVData
SVExclusion
SVExclusionList
SVExclusionList::NoSVExclusionFound
SVExclusionList::SVExclusionFileNotFound
SVGImageThis class generates graphics in Scalable Vector Graphics format
SVNumXRef
SVNumXRef::NoNAVSTARNumberFound
SVNumXRef::NoPRNNumberFound
SvObsEpoch
SVPCodeGenSV P-code Generator
SynchronizeThis class synchronizes two GNSS Data Structures data streams
SynchronizeExceptionThrown when synchronization was not possible at a given epoch
SystemPipeExceptionA problem using a system pipe
SystemPipeExceptionA problem using a system pipe
SystemQueueExceptionA problem using a system queue
SystemQueueExceptionA problem using a system queue
SystemSemaphoreExceptionA problem using a system semaphore
SystemSemaphoreExceptionA problem using a system semaphore
SystemTimeThis class reads the current system time and stores it in a UnixTime
TabularSatStoreStore a table of data vs time for each of several satellites
TAImUTCData
Test
TestEOM
TestException
TestException::TE
TestFFData
TestOperatorEquals
TestOperatorLessThan
TestRangeFilter
TestValueFilter
TextThis class defines a text object that is to be displayed in an image
TextStyleThis class defines a style of text
TimeNamedFileStream
TimeSystemThis class encapsulates time systems, including std::string I/O
TimeSystemCorrectionTime System Corrections as defined in the RINEX version 3 Navigation header
TimeTagThis class is an abstract base class inherited by all the classes that provide a specific time representation
TripleThree-dimensional vectors
TropModelAbstract base class for tropospheric models
TropModel::InvalidTropModelThrown when attempting to use a model for which all necessary parameters have not been specified
TropoRandomWalkModelThis class compute the elements of Phi and Q matrices corresponding to zenital tropospheric wet delays, modeled as a random walk stochastic model
TwoSampleStatsConventional statistics for two samples
TypeIDThis class creates an index able to represent any type of observation, correction, model parameter or other data value of interest for GNSS data processing
TypeID::Initializer
TypeIDBin
TypeIDNotFoundThrown when attempting to access a value and the corresponding TypeID does not exist in the map
typeValueMapMap holding TypeID with corresponding numeric value
typeValueMapBin
UnimplementedExceptionAttempted to access a unimplemented function
UnimplementedExceptionAttempted to access a unimplemented function
UnixTimeThis class encapsulates the "Unix Timeval" time representation
UTCTimeClass to convert UTC Time to all other different time systems
UTCTime::MJDTimeHandy struct
ValidType
ValueNotFoundThrown when attempting to access a value and any of the corresponding indexes (SourceID, SatID or TypeID) does not exist in the map
VariableClass to define and handle 'descriptions' of GNSS variables
VDrawExceptionException class unique to this library
VectorThis class pretty much duplicates std::valarray<T> except it's fully STL container compliant
VectorExceptionAn exception thrown when there's a problem with a vector
VectorSliceA slice of Vector<T> that can be modified
VectorSliceBaseA base class that represents a subset of a vector
VGImageThis is a generic, format- and device-independent interface to vector plotting
VGStateThis class will simply maintain state about text and line styles, fill colors, and markers
ViewerManagerThis class provides a convenient and consistent mechanism by which to launch a graphics file viewer
VLayoutAssists in arranging frames in a vertical stack
WeightBaseAbstract base class for algorithms assigning weights to satellites
WGS84EllipsoidThis class represents the ellipsoid model defined in NIMA TR8350.2, "Department of Defense World Geodetic System 1984"
WhiteNoiseModelThis class compute the elements of Phi and Q matrices corresponding to a white noise stochastic model
WrongBlockFormatThis gets thrown if we don't have the wrong format block is used
WrongBlockNumberThis gets thrown if we don't have the right data for cast operations
WtdAveStats
WxObsDataThis is a time history weather data from a single site
WxObservationA Single Weather Observation
X1SequenceGPS X1 Sequencer
X2SequenceGPS X2 Sequencer
XRefNode
XvAn Earth-Centered, Earth-Fixed position/velocity/clock representation
XvtEarth-Centered, Earth-Fixed Cartesian position, velocity, clock bias and drift
XvtStoreAbstract base class for storing and accessing an object's position, velocity, and clock data
XYZ2NEDThis class changes the reference base from an Earth-Centered, Earth-Fixed (ECEF) system to a North-East-Down (NED) topocentric system, centered at the provided reference location
XYZ2NEUThis class changes the reference base from an Earth-Centered, Earth-Fixed (ECEF) system to a North-East-Up (NEU) topocentric system, centered at the provided reference location
YDSTimeThis class encapsulates the "year, day-of-year, and seconds-of-day" time format
YumaAlmanacStore
YumaBaseThis is a base class for all Yuma-related classes
YumaDataThis class stores, reads, and writes Yuma records
YumaHeaderThis class does not really do anything
YumaStreamThis class performs file i/o on a Yuma file for the YumaHeader and YumaData classes
ZeroTropModelThe 'zero' trop model, meaning it always returns zero

Generated on Fri Dec 6 03:31:13 2013 for GPS ToolKit Software Library by  doxygen 1.3.9.1