ModeledReferencePR.hpp

Go to the documentation of this file.

#pragma ident "$Id: ModeledReferencePR.hpp 2741 2011-06-22 16:37:02Z nwu $"

#ifndef MODELEDREFERENCEPR_HPP
#define MODELEDREFERENCEPR_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 ). 2006, 2007, 2008
//
//============================================================================



#include "ModeledPseudorangeBase.hpp"
#include "DayTime.hpp"
#include "EngEphemeris.hpp"
#include "XvtStore.hpp"
#include "GPSEphemerisStore.hpp"
#include "EphemerisRange.hpp"
#include "TropModel.hpp"
#include "IonoModel.hpp"
#include "IonoModelStore.hpp"
#include "Geodetic.hpp"
#include "Position.hpp"
#include "icd_200_constants.hpp"
#include "TypeID.hpp"
#include "DataStructures.hpp"


namespace gpstk
{

   class ModeledReferencePR : public ModeledPseudorangeBase
   {
   public:

      ModeledReferencePR()
         : useTGD(true), pDefaultIonoModel(NULL), pDefaultTropoModel(NULL),
           defaultObservable(TypeID::C1), pDefaultEphemeris(NULL)
      { init(); };


      ModeledReferencePR( const double& aRx,
                          const double& bRx,
                          const double& cRx,
                          Position::CoordinateSystem s = Position::Cartesian,
                          GeoidModel *geoid = NULL )
         : useTGD(true), pDefaultIonoModel(NULL), pDefaultTropoModel(NULL),
           defaultObservable(TypeID::C1), pDefaultEphemeris(NULL)
      { init(); setInitialRxPosition(aRx, bRx, cRx, s, geoid); };


      ModeledReferencePR(const Position& RxCoordinates)
         : useTGD(true), pDefaultIonoModel(NULL), pDefaultTropoModel(NULL),
           defaultObservable(TypeID::C1), pDefaultEphemeris(NULL)
      { init(); setInitialRxPosition(RxCoordinates); };


      ModeledReferencePR( const Position& RxCoordinates,
                          IonoModelStore& dIonoModel,
                          TropModel& dTropoModel,
                          XvtStore<SatID>& dEphemeris,
                          const TypeID& dObservable,
                          bool usetgd = true );


      ModeledReferencePR( const Position& RxCoordinates,
                          IonoModelStore& dIonoModel,
                          XvtStore<SatID>& dEphemeris,
                          const TypeID& dObservable,
                          bool usetgd = true );


      ModeledReferencePR( const Position& RxCoordinates,
                          TropModel& dTropoModel,
                          XvtStore<SatID>& dEphemeris,
                          const TypeID& dObservable,
                          bool usetgd = true );


      ModeledReferencePR( const Position& RxCoordinates,
                          XvtStore<SatID>& dEphemeris,
                          const TypeID& dObservable,
                          bool usetgd = true );


      int Compute( const DayTime& Tr,
                   Vector<SatID>& Satellite,
                   Vector<double>& Pseudorange,
                   const XvtStore<SatID>& Eph,
                   const Vector<double>& extraBiases,
                   TropModel *pTropModel=NULL,
                   IonoModelStore *pIonoModel=NULL )
         throw(Exception);


      int Compute( const DayTime& Tr,
                   Vector<SatID>& Satellite,
                   Vector<double>& Pseudorange,
                   const XvtStore<SatID>& Eph )
         throw(Exception);


      int Compute( const DayTime& Tr,
                   Vector<SatID>& Satellite,
                   Vector<double>& Pseudorange,
                   const XvtStore<SatID>& Eph,
                   TropModel *pTropModel )
         throw(Exception);


      int Compute( const DayTime& Tr,
                   Vector<SatID>& Satellite,
                   Vector<double>& Pseudorange,
                   const XvtStore<SatID>& Eph,
                   const Vector<double>& extraBiases,
                   IonoModelStore *pIonoModel )
         throw(Exception);


      int Compute( const DayTime& Tr,
                   Vector<SatID>& Satellite,
                   Vector<double>& Pseudorange,
                   const XvtStore<SatID>& Eph,
                   IonoModelStore *pIonoModel )
         throw(Exception);


      int Compute( const DayTime& Tr,
                   Vector<SatID>& Satellite,
                   Vector<double>& Pseudorange,
                   const XvtStore<SatID>& Eph,
                   TropModel *pTropModel,
                   IonoModelStore *pIonoModel )
         throw(Exception);


      int Compute( const DayTime& Tr,
                   SatID& Satellite,
                   double& Pseudorange,
                   const XvtStore<SatID>& Eph,
                   const double& extraBiases,
                   TropModel *pTropModel=NULL,
                   IonoModelStore *pIonoModel=NULL )
         throw(Exception);


      virtual satTypeValueMap& processModel( const DayTime& time,
                                             satTypeValueMap& gData )
         throw(Exception);


      virtual gnssSatTypeValue& processModel(gnssSatTypeValue& gData)
         throw(Exception)
      { processModel(gData.header.epoch, gData.body); return gData; };


      virtual gnssRinex& processModel(gnssRinex& gData)
         throw(Exception)
      { processModel(gData.header.epoch, gData.body); return gData; };


      bool useTGD;


      virtual double getMinElev() const
      { return minElev; };


      virtual ModeledReferencePR& setMinElev(double newElevation)
      { minElev = newElevation; return (*this); };


      virtual IonoModelStore* getDefaultIonoModel() const
      { return pDefaultIonoModel; };


      virtual ModeledReferencePR& setDefaultIonoModel(
                                                IonoModelStore& dIonoModel )
      { pDefaultIonoModel = &dIonoModel; return (*this); };


      virtual ModeledReferencePR& setNULLIonoModel()
      { pDefaultIonoModel = NULL; return (*this); };


      virtual TropModel* getDefaultTropoModel() const
      { return pDefaultTropoModel; };


      virtual ModeledReferencePR& setDefaultTropoModel(TropModel& dTropoModel)
      { pDefaultTropoModel = &dTropoModel; return (*this); };


      virtual ModeledReferencePR& setNULLTropoModel()
      { pDefaultTropoModel = NULL; return (*this); };


      virtual ModeledReferencePR& setDefaultExtraBiases(
                                                   Vector<double>& eBiases )
      { extraBiases = eBiases; return (*this); };


      virtual TypeID getDefaultObservable() const
      { return defaultObservable; };


      virtual ModeledReferencePR& setDefaultObservable(const TypeID& type)
      { defaultObservable = type; return (*this); };


      virtual XvtStore<SatID>* getDefaultEphemeris() const
      { return pDefaultEphemeris; };


      virtual ModeledReferencePR& setDefaultEphemeris(XvtStore<SatID>& ephem)
      { pDefaultEphemeris = &ephem; return (*this); };


      virtual ~ModeledReferencePR() {};


   protected:


      IonoModelStore *pDefaultIonoModel;

      TropModel *pDefaultTropoModel;

      TypeID defaultObservable;

      XvtStore<SatID>* pDefaultEphemeris;

      virtual void init();


      virtual int setInitialRxPosition( const double& aRx,
                                        const double& bRx,
                                        const double& cRx,
                           Position::CoordinateSystem s=Position::Cartesian,
                                        GeoidModel *geoid = NULL );


      virtual int setInitialRxPosition(const Position& RxCoordinates);


      virtual int setInitialRxPosition();


      virtual double getTropoCorrections( TropModel *pTropModel,
                                          double elevation );


      virtual double getIonoCorrections( IonoModelStore *pIonoModel,
                                         DayTime Tr,
                                         Geodetic rxGeo,
                                         double elevation,
                                         double azimuth );


      virtual double getTGDCorrections( DayTime Tr,
                                        const XvtStore<SatID>& Eph,
                                        SatID sat );


   }; // End of class 'ModeledReferencePR'


   inline gnssSatTypeValue& operator>>( gnssSatTypeValue& gData,
                                        ModeledReferencePR& modRefPR )
      throw(Exception)
   { modRefPR.processModel(gData); return gData; }


   inline gnssRinex& operator>>( gnssRinex& gData,
                                 ModeledReferencePR& modRefPR )
      throw(Exception)
   { modRefPR.processModel(gData); return gData; }



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

---