StochasticModel.hpp

Go to the documentation of this file.

#pragma ident "$Id: StochasticModel.hpp 2580 2011-04-28 14:53:04Z architest $"

#ifndef GPSTK_STOCHASTICMODEL_HPP
#define GPSTK_STOCHASTICMODEL_HPP

//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 2.1 of the License, or
//  any later version.
//
//  The GPSTk is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GPSTk; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  Dagoberto Salazar - gAGE ( http://www.gage.es ). 2007, 2008
//
//============================================================================



#include "DayTime.hpp"
#include "DataStructures.hpp"



namespace gpstk
{



   class StochasticModel
   {
   public:

      StochasticModel() {};


      virtual double getPhi()
      { return 1.0; };


      virtual double getQ()
      { return 0.0; };


      virtual void Prepare( const SatID& sat,
                            gnssSatTypeValue& gData )
      { return; };


      virtual void Prepare( const SatID& sat,
                            gnssRinex& gData )
      { return; };


      virtual ~StochasticModel() {};


   }; // End of class 'StochasticModel'



   class RandomWalkModel : public StochasticModel
   {
   public:

      RandomWalkModel()
         : qprime(90000000000.0), previousTime(DayTime::BEGINNING_OF_TIME),
           currentTime(DayTime::BEGINNING_OF_TIME) {};


      RandomWalkModel( double qp,
                       const DayTime& prevTime=DayTime::BEGINNING_OF_TIME,
                       const DayTime& currentTime=DayTime::BEGINNING_OF_TIME )
         : qprime(qp), previousTime(prevTime), currentTime(prevTime) {};


      virtual RandomWalkModel& setPreviousTime(const DayTime& prevTime)
      { previousTime = prevTime; return (*this); }


      virtual RandomWalkModel& setCurrentTime(const DayTime& currTime)
      { currentTime = currTime; return (*this); }


      virtual RandomWalkModel& setQprime(double qp)
      { qprime = qp; return (*this); }


      virtual double getQ();


      virtual void Prepare( const SatID& sat,
                            gnssSatTypeValue& gData );


      virtual void Prepare( const SatID& sat,
                            gnssRinex& gData );


      virtual ~RandomWalkModel() {};


   private:


      double qprime;


      DayTime previousTime;


      DayTime currentTime;


   }; // End of class 'RandomWalkModel'



   class WhiteNoiseModel : public StochasticModel
   {
   public:


      WhiteNoiseModel( double sigma = 300000.0 )
         : variance(sigma*sigma) {};


      virtual WhiteNoiseModel& setSigma(double sigma)
      { variance = sigma*sigma; return (*this); }


      virtual double getPhi()
      { return 0.0; };


      virtual double getQ()
      { return variance; };


      virtual ~WhiteNoiseModel() {};


   private:


      double variance;


   }; // End of class 'WhiteNoiseModel'



   class PhaseAmbiguityModel : public StochasticModel
   {
   public:


      PhaseAmbiguityModel( double sigma = 2e7 )
         : variance(sigma*sigma), cycleSlip(false), watchSatArc(true),
           csFlagType(TypeID::CSL1) {};


      virtual PhaseAmbiguityModel& setSigma(double sigma)
      { variance = sigma*sigma; return (*this); }


      virtual PhaseAmbiguityModel& setCS(bool cs)
      { cycleSlip = cs; return (*this); };


      virtual PhaseAmbiguityModel& setWatchSatArc(bool watchArc)
      { watchSatArc = watchArc; return (*this); };


      virtual PhaseAmbiguityModel& setCycleSlipFlag( const TypeID& type )
      { csFlagType = type; return (*this); };


      virtual TypeID getCycleSlipFlag( void )
      { return csFlagType; };


      virtual double getPhi();


      virtual double getQ();


      virtual void Prepare( const SatID& sat,
                            gnssSatTypeValue& gData )
      { checkCS(sat, gData.body, gData.header.source); return; };


      virtual void Prepare( const SatID& sat,
                            gnssRinex& gData )
      { checkCS(sat, gData.body, gData.header.source); return; };


      virtual ~PhaseAmbiguityModel() {};


   private:


      double variance;

      bool cycleSlip;

      bool watchSatArc;

      TypeID csFlagType;

      std::map<SourceID, std::map<SatID, double> > satArcMap;


      virtual void checkCS( const SatID& sat,
                            satTypeValueMap& data,
                            SourceID& source );


   }; // End of class 'PhaseAmbiguityModel'



   class TropoRandomWalkModel : public StochasticModel
   {
   public:

      TropoRandomWalkModel() {};


      virtual TropoRandomWalkModel& setPreviousTime( const SourceID& source,
                                                     const DayTime& prevTime )
      { tmData[source].previousTime = prevTime; return (*this); };


      virtual TropoRandomWalkModel& setCurrentTime( const SourceID& source,
                                                    const DayTime& currTime )
      { tmData[source].currentTime = currTime; return (*this); };


      virtual TropoRandomWalkModel& setQprime(double qp);


      virtual TropoRandomWalkModel& setQprime( const SourceID& source,
                                               double qp )
      { tmData[source].qprime = qp; return (*this); };



      virtual double getQ()
      { return variance; };


      virtual void Prepare( const SatID& sat,
                            gnssSatTypeValue& gData );


      virtual void Prepare( const SatID& sat,
                            gnssRinex& gData );


      virtual ~TropoRandomWalkModel() {};


   private:


      struct tropModelData
      {
            // Default constructor initializing the data in the structure
         tropModelData() : qprime(3e-8),
                           previousTime(DayTime::BEGINNING_OF_TIME) {};

         double qprime;          
         DayTime previousTime;   
         DayTime currentTime;    

      }; // End of struct 'tropModelData'


      std::map<SourceID, tropModelData> tmData;


      double variance;


      virtual void computeQ( const SatID& sat,
                             satTypeValueMap& data,
                             SourceID& source );


   }; // End of class 'TropoRandomWalkModel'


}  // End of namespace gpstk
#endif // GPSTK_STOCHASTICMODEL_HPP

---