SolverPPPFB Class Reference
[Mathematical algorithms, GPS solution algorithms and Tropospheric]

#include <SolverPPPFB.hpp>

Inheritance diagram for SolverPPPFB:

[legend]Collaboration diagram for SolverPPPFB:

[legend]List of all members.

---

Detailed Description

This class computes the Precise Point Positioning (PPP) solution using a Kalman solver that combines ionosphere-free code and phase measurements.

Also, this class uses the 'forwards-backwards' approach, where the provided data set is processed from 'past to future' and from 'future to past' several times.

This approach improves the final solution because it takes advantage of a better phase ambiguity resolution. On the other hand, it is only applicable in post-process mode (of course).

In reality, "SolverPPPFB.hpp" objects are really "SolverPPP.hpp" objects at their core, with some wrapper code that takes 'normal' forwards input data, stores them, and feeds the internal "SolverPPP" object with a continuous data stream formed by several instances of forwards input data, "mirrored" input data (oldest is newest and viceversa), forwards input data again, and so on.

In order to achieve this, SolverPPPFB.hpp" objects work in three distinct phases:

• Initial "Process()" phase: This does a "normal" forward processing, like the "SolverPPP.hpp" objects. Data feed during this phase are internally stored for later phases.
• "ReProcess()" phase: In this phase the filter will process the stored data in "backwards-forwards" fashion as many times as set by the provided "cycles" parameter (by default, "cycles" is equal to 1). This phase always ends in backwards processing.
• "LastProcess()" phase: This is the last phase and it is always done in forwards mode. During this phase you will get your final results.

Take due note that the "SolverPPPFB.hpp" class is designed to be used ONLY with GNSS data structure objects from "DataStructures" class.

A typical way to use this class follows:

      // INITIALIZATION PART

      // EBRE station nominal position
   Position nominalPos(4833520.192, 41537.1043, 4147461.560);
   RinexObsStream rin("ebre0300.02o");  // Data stream

      // Load all the SP3 ephemerides files
   SP3EphemerisStore SP3EphList;
   SP3EphList.loadFile("igs11512.sp3");
   SP3EphList.loadFile("igs11513.sp3");
   SP3EphList.loadFile("igs11514.sp3");

   NeillTropModel neillTM( nominalPos.getAltitude(),
                           nominalPos.getGeodeticLatitude(),
                           30 );

      // Objects to compute the tropospheric data
   BasicModel basicM(nominalPos, SP3EphList);
   ComputeTropModel computeTropo(neillTM);

      // More declarations here: ComputeMOPSWeights, SimpleFilter,
      // LICSDetector, MWCSDetector, SolidTides, OceanLoading, 
      // PoleTides, CorrectObservables, ComputeWindUp, ComputeLinear,
      // LinearCombinations, etc.

      // Declare a SolverPPPFB object
   SolverPPPFB pppSolver;

     // PROCESSING PART

   gnssRinex gRin;

      // --->>> Process() phase <<<--- //

   while(rin >> gRin)
   {
      try
      {
         gRin  >> basicM
               >> correctObs
               >> compWindup
               >> computeTropo
               >> linear1      // Compute combinations
               >> pcFilter
               >> markCSLI2
               >> markCSMW
               >> markArc
               >> linear2      // Compute prefit residuals
               >> phaseAlign
               >> pppSolver;
      }
      catch(...)
      {
         cerr << "Unknown exception at epoch: " << time << endl;
         continue;
      }

   }   // End of 'while(rin >> gRin)'


      // --->>> ReProcess() phase <<<--- //

   try
   {

         // Now, let's do the forward-backward cycles (4)
      pppSolver.ReProcess(4);

   }
   catch(Exception& e)
   {
      cerr << "Exception: " << e << endl;
   }


      // --->>> LastProcess() phase <<<--- //

      // Loop over all data epochs, again
   while( pppSolver.LastProcess(gRin) )  // True while there are data
   {

         // In this case, gRin is an output from 'LastProcess()'
      DayTime time(gRin.header.epoch);

         // Print results
      cout << time.DOYsecond() << "  ";     // Epoch - Output field #1

      cout << pppSolver.getSolution(TypeID::dLat) << "  "; // dLat - #2
      cout << pppSolver.getSolution(TypeID::dLon) << "  "; // dLon - #3
      cout << pppSolver.getSolution(TypeID::dH) << "  ";   // dH   - #4
      cout << pppSolver.getSolution(TypeID::wetMap) << "  "; // Tropo-#5

   }

The "SolverPPPFB" object will also insert back postfit residual data (both code and phase) into "gRin" if it successfully solves the equation system.

By default, it will build the geometry matrix from the values of coefficients wetMap, dx, dy, dz and cdt, IN THAT ORDER. Please note that the first field of the solution will be the estimation of the zenital wet tropospheric component (or at least, the part that wasn't modeled by the tropospheric model used).

You may configure the solver to work with a NEU system in the class constructor or using the "setNEU()" method.

In any case, the "SolverPPPFB" object will also automatically add and estimate the ionosphere-free phase ambiguities. The independent vector is composed of the code and phase prefit residuals.

This class expects some weights assigned to each satellite. That can be achieved with objects from classes such as "ComputeIURAWeights", "ComputeMOPSWeights", etc.

If these weights are not assigned, then the "SolverPPPFB" object will set a value of "1.0" to code measurements, and "weightFactor" to phase measurements. The default value of "weightFactor" is "10000.0". This implies that code sigma is 1 m, and phase sigma is 1 cm.

By default, the stochastic models used for each type of variable are:

• Coordinates are modeled as constants (StochasticModel).
• Zenital wet tropospheric component is modeled as a random walk (RandomWalkModel), with a qPrime value of 3e-8 m*m/s.
• Receiver clock is modeled as white noise (WhiteNoiseModel).
• Phase biases are modeled as white noise when cycle slips happen, and as constants between cycle slips (PhaseAmbiguityModel).

You may change this assignment with methods "setCoordinatesModel()", "setTroposphereModel()" and "setReceiverClockModel()". However, you are not allowed to change the phase biases stochastic model.

Given the nature of this solver, it is possible for it to trim data according to some preset postfit residuals limits, deleting out potential outliers.

The former is achieved by setting a couple lists of limits (one for code postfit residuals and the other for phase ones) that will be applied, one forward-backward cycle for each, in the same order they where added. One code limit and one phase limit are applied simultaneously per cycle.

In this case you must call the "ReProcess(void)" method instead of the "ReProcess(int)" method.

A way to apply this feature follows:

      // INITIALIZATION PART

      // INITIALIZATION CODE HERE...

      // Declare a SolverPPPFB object
   SolverPPPFB pppSolver;

      // Add limits to solver. Let's start with pseudorange limits
   pppSolver.addCodeLimit(10.0);     // 10 m
   pppSolver.addCodeLimit(5.0);      //  5 m
   pppSolver.addCodeLimit(2.0);      //  2 m

      // Now, let's follow with phase limits
   pppSolver.addPhaseLimit(0.10);    // 10 cm
   pppSolver.addPhaseLimit(0.05);    //  5 cm
   pppSolver.addPhaseLimit(0.02);    //  2 cm

      // PROCESSING PART CODE HERE...


      // --->>> ReProcess() phase <<<--- //

   try
   {

         // Now, let's do the forward-backward cycles.
         // Please note that this method needs no parameters.
         // Three forwards-backwards cycles will be made because
         // maximum limits list size is 3.
      pppSolver.ReProcess();

   }
   catch(Exception& e)
   {
      cerr << "Exception: " << e << endl;
   }


      // LastProcess() PHASE CODE HERE ...

Warning:

"SolverPPPFB" is based on a Kalman filter, and Kalman filters are objets that store their internal state, so you MUST NOT use the SAME object to process DIFFERENT data streams.

See also:

SolverBase.hpp, SolverLMS.hpp, CodeKalmanSolver.hpp and SolverPPP.hpp for base classes.

Definition at line 285 of file SolverPPPFB.hpp.

Public Member Functions
	SolverPPPFB (bool useNEU=false)
	Common constructor.
virtual gnssSatTypeValue &	Process (gnssSatTypeValue &gData) throw (ProcessingException)
	Returns a reference to a gnnsSatTypeValue object after solving the previously defined equation system.
virtual gnssRinex &	Process (gnssRinex &gData) throw (ProcessingException)
	Returns a reference to a gnnsRinex object after solving the previously defined equation system.
virtual void	ReProcess (int cycles) throw (ProcessingException)
	Reprocess the data stored during a previous 'Process()' call.
virtual void	ReProcess (void) throw (ProcessingException)
	Reprocess the data stored during a previous 'Process()' call.
virtual bool	LastProcess (gnssSatTypeValue &gData) throw (ProcessingException)
	Process the data stored during a previous 'ReProcess()' call, one item at a time, and always in forward mode.
virtual bool	LastProcess (gnssRinex &gData) throw (ProcessingException)
	Process the data stored during a previous 'ReProcess()' call, one item at a time, and always in forward mode.
virtual std::list< double >	getCodeList (void) const
	Gets the list storing the limits for postfit residuals in code.
virtual SolverPPPFB &	setCodeList (std::list< double > codeList)
	Sets a list storing the limits for postfit residuals in code.
virtual SolverPPPFB &	addCodeLimit (double codeLimit)
	Adds a postfit residuals limit to list storing limits for code.
virtual SolverPPPFB &	clearCodeList (void)
	Clears the list storing the limits for postfit residuals in code.
virtual std::list< double >	getPhaseList (void) const
	Gets the list storing the limits for postfit residuals in phase.
virtual SolverPPPFB &	setPhaseList (std::list< double > phaseList)
	Sets a list storing the limits for postfit residuals in phase.
virtual SolverPPPFB &	addPhaseLimit (double phaseLimit)
	Adds a postfit residuals limit to list storing limits for phase.
virtual SolverPPPFB &	clearPhaseList (void)
	Clears the list storing the limits for postfit residuals in phase.
virtual int	getProcessedMeasurements (void) const
	Returns the number of processed measurements.
virtual int	getRejectedMeasurements (void) const
	Returns the number of measurements rejected because they were off limits.
virtual SolverPPPFB &	setNEU (bool useNEU)
	Sets if a NEU system will be used.
virtual int	getIndex (void) const
	Returns an index identifying this object.
virtual std::string	getClassName (void) const
	Returns a string identifying this object.
virtual	~SolverPPPFB ()
	Destructor.

---

Constructor & Destructor Documentation

SolverPPPFB (  bool  useNEU = false  )

Common constructor. Parameters: useNEU  If true, will compute dLat, dLon, dH coordinates; if false (the default), will compute dx, dy, dz. Definition at line 56 of file SolverPPPFB.cpp.

virtual ~SolverPPPFB (   )  [inline, virtual]

Destructor. Definition at line 447 of file SolverPPPFB.hpp.

---

Member Function Documentation

virtual SolverPPPFB& addCodeLimit (  double  codeLimit  )  [inline, virtual]

Adds a postfit residuals limit to list storing limits for code. Parameters: codeLimit  New limit for postfit residuals in code. Warning: Limits will be applied in the same order they were added. Definition at line 379 of file SolverPPPFB.hpp.

virtual SolverPPPFB& addPhaseLimit (  double  phaseLimit  )  [inline, virtual]

Adds a postfit residuals limit to list storing limits for phase. Parameters: phaseLimit  New limit for postfit residuals in phase. Warning: Limits will be applied in the same order they were added. Definition at line 409 of file SolverPPPFB.hpp.

virtual SolverPPPFB& clearCodeList (  void   )  [inline, virtual]

Clears the list storing the limits for postfit residuals in code. Definition at line 384 of file SolverPPPFB.hpp.

virtual SolverPPPFB& clearPhaseList (  void   )  [inline, virtual]

Clears the list storing the limits for postfit residuals in phase. Definition at line 414 of file SolverPPPFB.hpp.

std::string getClassName (  void   )  const [virtual]

Returns a string identifying this object. Reimplemented from SolverPPP. Definition at line 47 of file SolverPPPFB.cpp. Referenced by SolverPPPFB::ReProcess().

virtual std::list<double> getCodeList (  void   )  const [inline, virtual]

Gets the list storing the limits for postfit residuals in code. Definition at line 359 of file SolverPPPFB.hpp.

int getIndex (  void   )  const [virtual]

Returns an index identifying this object. Reimplemented from SolverPPP. Definition at line 42 of file SolverPPPFB.cpp. Referenced by SolverPPPFB::ReProcess().

virtual std::list<double> getPhaseList (  void   )  const [inline, virtual]

Gets the list storing the limits for postfit residuals in phase. Definition at line 389 of file SolverPPPFB.hpp.

virtual int getProcessedMeasurements (  void   )  const [inline, virtual]

Returns the number of processed measurements. Definition at line 419 of file SolverPPPFB.hpp.

virtual int getRejectedMeasurements (  void   )  const [inline, virtual]

Returns the number of measurements rejected because they were off limits. Definition at line 425 of file SolverPPPFB.hpp.

bool LastProcess (  gnssRinex &  gData  )  throw (ProcessingException) [virtual]

Process the data stored during a previous 'ReProcess()' call, one item at a time, and always in forward mode. Parameters: gData  Data object that will hold the resulting data. Returns: FALSE when all data is processed, TRUE otherwise. Definition at line 424 of file SolverPPPFB.cpp. References GPSTK_THROW.

bool LastProcess (  gnssSatTypeValue &  gData  )  throw (ProcessingException) [virtual]

Process the data stored during a previous 'ReProcess()' call, one item at a time, and always in forward mode. Parameters: gData  Data object that will hold the resulting data. Returns: FALSE when all data is processed, TRUE otherwise. Definition at line 378 of file SolverPPPFB.cpp. References gnssData::body, GPSTK_THROW, and gnssRinex::header.

gnssRinex & Process (  gnssRinex &  gData  )  throw (ProcessingException) [virtual]

Returns a reference to a gnnsRinex object after solving the previously defined equation system. Parameters: gData  Data object holding the data. Reimplemented from SolverPPP. Definition at line 147 of file SolverPPPFB.cpp. References GPSTK_THROW, and satTypeValueMap::numSats().

gnssSatTypeValue & Process (  gnssSatTypeValue &  gData  )  throw (ProcessingException) [virtual]

Returns a reference to a gnnsSatTypeValue object after solving the previously defined equation system. Parameters: gData  Data object holding the data. Reimplemented from SolverPPP. Definition at line 106 of file SolverPPPFB.cpp. References gnssData::body, GPSTK_THROW, and gnssRinex::header.

void ReProcess (  void   )  throw (ProcessingException) [virtual]

Reprocess the data stored during a previous 'Process()' call. This method will reprocess data trimming satellites whose postfit residual is bigger than the limits indicated by limitsCodeList and limitsPhaseList. Definition at line 267 of file SolverPPPFB.cpp. References SolverPPPFB::getClassName(), SolverPPPFB::getIndex(), and GPSTK_THROW.

void ReProcess (  int  cycles  )  throw (ProcessingException) [virtual]

Reprocess the data stored during a previous 'Process()' call. Parameters: cycles  Number of forward-backward cycles (1 by default). Warning: The minimum number of cycles allowed is "1". In fact, if you introduce a smaller number, 'cycles' will be set to "1". Definition at line 197 of file SolverPPPFB.cpp. References GPSTK_THROW.

virtual SolverPPPFB& setCodeList (  std::list< double >  codeList  )  [inline, virtual]

Sets a list storing the limits for postfit residuals in code. Parameters: codeList  List with limits for postfit residuals in code. Warning: Limits will be applied in the same order they were added. Definition at line 369 of file SolverPPPFB.hpp.

SolverPPPFB & setNEU (  bool  useNEU  )  [virtual]

Sets if a NEU system will be used. Parameters: useNEU  Boolean value indicating if a NEU system will be used Reimplemented from SolverPPP. Definition at line 526 of file SolverPPPFB.cpp.

virtual SolverPPPFB& setPhaseList (  std::list< double >  phaseList  )  [inline, virtual]

Sets a list storing the limits for postfit residuals in phase. Parameters: phaseList  List with limits for postfit residuals in phase. Warning: Limits will be applied in the same order they were added. Definition at line 399 of file SolverPPPFB.hpp.

---

The documentation for this class was generated from the following files:

• SolverPPPFB.hpp
• SolverPPPFB.cpp

---