ModelObsFixedStation.hpp

Go to the documentation of this file.

#pragma ident "$Id: ModelObsFixedStation.hpp 1312 2008-07-24 18:15:26Z architest $"

#ifndef MODELOBSFIXEDSTATION_HPP
#define MODELOBSFIXEDSTATION_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 "ProcessingClass.hpp"
#include "EphemerisRange.hpp"
#include "EngEphemeris.hpp"
#include "XvtStore.hpp"
#include "GPSEphemerisStore.hpp"
#include "TropModel.hpp"
#include "IonoModelStore.hpp"


namespace gpstk
{


   class ModelObsFixedStation : public ProcessingClass
   {
   public:

      ModelObsFixedStation()
         : minElev(10.0), useTGD(true), pDefaultIonoModel(NULL),
           pDefaultTropoModel(NULL), defaultObservable(TypeID::C1),
           pDefaultEphemeris(NULL)
      { InitializeValues(); setIndex(); };


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


      ModelObsFixedStation(const Position& RxCoordinates);


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


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


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


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


      virtual satTypeValueMap& Process( const DayTime& time,
                                        satTypeValueMap& gData )
         throw(ProcessingException);


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


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


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


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


      virtual ModelObsFixedStation& setTGD(bool use)
      { useTGD = use; return (*this); };


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


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


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


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


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


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


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


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


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


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


      Position rxPos;


      virtual int getIndex(void) const;


      virtual std::string getClassName(void) const;


      virtual ~ModelObsFixedStation() {};


   protected:


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


      double minElev;

      bool useTGD;

      IonoModelStore *pDefaultIonoModel;

      TropModel *pDefaultTropoModel;

      TypeID defaultObservable;

      XvtStore<SatID>* pDefaultEphemeris;

      virtual void InitializeValues()
      { setInitialRxPosition(); };


      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 );


   private:


      static int classIndex;

      int index;

      void setIndex(void)
      { index = classIndex++; };


   }; // End of class 'ModelObsFixedStation'


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

---