modeledreferencepr.hpp

一个gps小工具包

         /// Compute the modeled pseudoranges, given satellite ID's,
         /// pseudoranges and other data.
      int Compute( const DayTime& Tr,
                   Vector<SatID>& Satellite,
                   Vector<double>& Pseudorange,
                   const XvtStore<SatID>& Eph )
         throw(Exception);


         /// Compute the modeled pseudoranges, given satellite ID's,
         /// pseudoranges and other data.
      int Compute( const DayTime& Tr,
                   Vector<SatID>& Satellite,
                   Vector<double>& Pseudorange,
                   const XvtStore<SatID>& Eph,
                   TropModel *pTropModel )
         throw(Exception);


         /// Compute the modeled pseudoranges, given satellite ID's,
         /// pseudoranges and other data.
      int Compute( const DayTime& Tr,
                   Vector<SatID>& Satellite,
                   Vector<double>& Pseudorange,
                   const XvtStore<SatID>& Eph,
                   const Vector<double>& extraBiases,
                   IonoModelStore *pIonoModel )
         throw(Exception);


         /// Compute the modeled pseudoranges, given satellite ID's,
         /// pseudoranges and other data.
      int Compute( const DayTime& Tr,
                   Vector<SatID>& Satellite,
                   Vector<double>& Pseudorange,
                   const XvtStore<SatID>& Eph,
                   IonoModelStore *pIonoModel )
         throw(Exception);


         /// Compute the modeled pseudoranges, given satellite ID's,
         /// pseudoranges and other data.
      int Compute( const DayTime& Tr,
                   Vector<SatID>& Satellite,
                   Vector<double>& Pseudorange,
                   const XvtStore<SatID>& Eph,
                   TropModel *pTropModel,
                   IonoModelStore *pIonoModel )
         throw(Exception);


         /** Compute just one modeled pseudorange, given satellite ID's,
          *  pseudorange and other data.
          *
          * @param Tr            Measured time of reception of the data.
          * @param Satellite     ID's of satellite
          * @param Pseudorange   Pseudorange (parallel to satellite), in 
          *                      meters.
          * @param Eph           XvtStore<SatID> to be used.
          * @param pTropModel    Pointer to tropospheric model to be used.
          *                      By default points to NULL.
          * @param pIonoModel    Pointer to ionospheric model to be used.
          *                      By default points to NULL.
          * @param extraBiases   Extra bias to be added to the model.
          *
          * @return
          *  1 if satellite has valid data
          *
          * @sa TropModel.hpp, IonoModelStore.hpp.
          */
      int Compute( const DayTime& Tr,
                   SatID& Satellite,
                   double& Pseudorange,
                   const XvtStore<SatID>& Eph,
                   const double& extraBiases,
                   TropModel *pTropModel=NULL,
                   IonoModelStore *pIonoModel=NULL )
         throw(Exception);


         /** Returns a satTypeValueMap object, adding the new data 
          *  generated when calling a modeling object.
          *
          * @param time      Epoch.
          * @param gData     Data object holding the data.
          */
      virtual satTypeValueMap& processModel( const DayTime& time,
                                             satTypeValueMap& gData )
         throw(Exception);


         /** Returns a gnnsSatTypeValue object, adding the new data 
          *  generated when calling a modeling object.
          *
          * @param gData    Data object holding the data.
          */
      virtual gnssSatTypeValue& processModel(gnssSatTypeValue& gData)
         throw(Exception)
      { processModel(gData.header.epoch, gData.body); return gData; };


         /** Returns a gnnsRinex object, adding the new data generated
          *  when calling a modeling object.
          *
          * @param gData    Data object holding the data.
          */
      virtual gnssRinex& processModel(gnssRinex& gData)
         throw(Exception)
      { processModel(gData.header.epoch, gData.body); return gData; };


         /// Boolean variable indicating if SV instrumental delays (TGD) 
         /// will be included  in results. It is true by default.
      bool useTGD;


         /// Method to get satellite elevation cut-off angle. By default, 
         /// it is set to 10 degrees.
      virtual double getMinElev() const
      { return minElev; };


         /// Method to set satellite elevation cut-off angle. By default, 
         /// it is set to 10 degrees.
      virtual ModeledReferencePR& setMinElev(double newElevation)
      { minElev = newElevation; return (*this); };


         /// Method to get a pointer to the default ionospheric model.
      virtual IonoModelStore* getDefaultIonoModel() const
      { return pDefaultIonoModel; };


         /** Method to set the default ionospheric model.
          *
          * @param dIonoModel    Ionospheric model to be used by default.
          */
      virtual ModeledReferencePR& setDefaultIonoModel(
                                                IonoModelStore& dIonoModel )
      { pDefaultIonoModel = &dIonoModel; return (*this); };


         /// Method to set a NULL ionospheric model.
      virtual ModeledReferencePR& setNULLIonoModel()
      { pDefaultIonoModel = NULL; return (*this); };


         /// Method to get a pointer to the default tropospheric model.
      virtual TropModel* getDefaultTropoModel() const
      { return pDefaultTropoModel; };


         /** Method to set the default tropospheric model.
          *
          * @param dTropoModel    Tropospheric model to be used by default.
          */
      virtual ModeledReferencePR& setDefaultTropoModel(TropModel& dTropoModel)
      { pDefaultTropoModel = &dTropoModel; return (*this); };


         /// Method to set a NULL tropospheric model.
      virtual ModeledReferencePR& setNULLTropoModel()
      { pDefaultTropoModel = NULL; return (*this); };


         /** Method to set the default extra biases.
          *
          * @param eBiases    Vector with the default extra biases
          */
      virtual ModeledReferencePR& setDefaultExtraBiases(
                                                   Vector<double>& eBiases )
      { extraBiases = eBiases; return (*this); };


         /// Method to get the default observable being used with 
         /// GNSS data structures.
      virtual TypeID getDefaultObservable() const
      { return defaultObservable; };


         /** Method to set the default observable to be used when fed with 
          *  GNSS data structures.
          *
          * @param type      TypeID object to be used by default
          */
      virtual ModeledReferencePR& setDefaultObservable(const TypeID& type)
      { defaultObservable = type; return (*this); };


         /// Method to get a pointer to the default XvtStore<SatID> to be 
         /// used with GNSS data structures.
      virtual XvtStore<SatID>* getDefaultEphemeris() const
      { return pDefaultEphemeris; };


         /** Method to set the default XvtStore<SatID> to be used with 
          *  GNSS data structures.
          *
          * @param ephem     XvtStore<SatID> object to be used by default
          */
      virtual ModeledReferencePR& setDefaultEphemeris(XvtStore<SatID>& ephem)
      { pDefaultEphemeris = &ephem; return (*this); };


         /// Destructor.
      virtual ~ModeledReferencePR() throw () {};


   protected:

         /// Pointer to default ionospheric model.
      IonoModelStore *pDefaultIonoModel;

         /// Pointer to default tropospheric model.
      TropModel *pDefaultTropoModel;

         /// Default observable to be used when fed with GNSS data structures.
      TypeID defaultObservable;

         /// Pointer to default XvtStore<SatID> object when working with 
         /// GNSS data structures.
      XvtStore<SatID>* pDefaultEphemeris;

         /// Initialization method
      virtual void init() throw(Exception);


         /** Method to set the initial (a priori) position of receiver.
          * @return
          *  0 if OK
          *  -1 if problems arose
          */
      virtual int setInitialRxPosition( const double& aRx,
                                        const double& bRx,
                                        const double& cRx, 
                           Position::CoordinateSystem s=Position::Cartesian,
                                        GeoidModel *geoid = NULL )
         throw(GeometryException);


         /// Method to set the initial (a priori) position of receiver.
      virtual int setInitialRxPosition(const Position& RxCoordinates)
         throw(GeometryException);


         /// Method to set the initial (a priori) position of receiver.
      virtual int setInitialRxPosition() throw(GeometryException);


         /// Method to get the tropospheric corrections.
      virtual double getTropoCorrections( TropModel *pTropModel,
                                          double elevation )
         throw();


         /// Method to get the ionospheric corrections.
      virtual double getIonoCorrections( IonoModelStore *pIonoModel,
                                         DayTime Tr,
                                         Geodetic rxGeo,
                                         double elevation,
                                         double azimuth )
         throw();


         /// Method to get TGD corrections.
      virtual double getTGDCorrections( DayTime Tr,
                                        const XvtStore<SatID>& Eph,
                                        SatID sat )
         throw();


   }; // End of class ModeledReferencePR


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


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


      //@}

} // namespace
#endif // MODELEDREFERENCEPR_HPP