modeledreferencepr.hpp

gps源代码

         * @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 EphemerisStore& 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)
        {
            (*this).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)
        {
            (*this).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 void setMinElev(double newElevation)
        {
           minElev = newElevation;
        };


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


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


        /// Method to set a NULL ionospheric model.
        virtual void setNULLIonoModel()
        {
           pDefaultIonoModel = NULL;
        };


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


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


        /// Method to set a NULL tropospheric model.
        virtual void setNULLTropoModel()
        {
           pDefaultTropoModel = NULL;
        };


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


        /** 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 void setDefaultObservable(const TypeID& type)
        {
           defaultObservable = type;
        };


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


        /** Method to set the default EphemerisStore to be used with GNSS data structures.
         * @param ephem     EphemerisStore object to be used by default
         */
        virtual void setDefaultEphemeris(EphemerisStore& ephem)
        {
           pDefaultEphemeris = &ephem;
        };


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


        /// 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 EphemerisStore object when working with GNSS data structures.
        EphemerisStore* pDefaultEphemeris;

        /// Initialization method
        virtual void InitializeValues() throw(Exception) { 
            setInitialRxPosition();
            geometricRho(0);
            svClockBiases(0);
            svXvt(0);
            svTGD(0);
            svRelativity(0);
            ionoCorrections(0);
            tropoCorrections(0);
            modeledPseudoranges(0);
            prefitResiduals(0);
            extraBiases(0);
            availableSV(0);
            rejectedSV(0);
        };


        /** 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) 
        {
            try {
                Position rxpos(aRx, bRx, cRx, s, geoid);
                setInitialRxPosition(rxpos);
                return 0;
            }
            catch(GeometryException& e) {
                return -1;
            }
        };


        /// Method to set the initial (a priori) position of receiver.
        virtual int setInitialRxPosition(const Position& RxCoordinates) throw(GeometryException) 
        {
            try {
                (*this).rxPos = RxCoordinates;
                return 0;
            }
            catch(GeometryException& e) {
                return -1;
            }
        };


        /// Method to set the initial (a priori) position of receiver.
        virtual int setInitialRxPosition() throw(GeometryException) 
        {
            try {
                Position rxpos(0.0, 0.0, 0.0, Position::Cartesian, NULL);
                setInitialRxPosition(rxpos);
                return 0;
            }
            catch(GeometryException& e) {
                return -1;
            }
        };


        /// Method to get the tropospheric corrections.
        virtual double getTropoCorrections(TropModel *pTropModel, double elevation) throw() 
        {
            double tropoCorr(0.0);
            try {
                tropoCorr = pTropModel->correction(elevation);
                // Check validity
                if(!(pTropModel->isValid())) tropoCorr = 0.0;
            }
            catch(TropModel::InvalidTropModel& e) {
                tropoCorr = 0.0;
            }
            return tropoCorr;
        };


        /// Method to get the ionospheric corrections.
        virtual double getIonoCorrections(IonoModelStore *pIonoModel, DayTime Tr, Geodetic rxGeo, double elevation, double azimuth) throw() 
        {
            double ionoCorr(0.0);
            try {
                ionoCorr = pIonoModel->getCorrection(Tr, rxGeo, elevation, azimuth);
            }
            catch(IonoModelStore::NoIonoModelFound& e) {
                ionoCorr = 0.0;
            }
            return ionoCorr;
        };


        /// Method to get TGD corrections.
        virtual double getTGDCorrections(DayTime Tr, const EphemerisStore& Eph, SatID sat) throw() 
        {

            double TGDCorr(0.0);

            try {
                TGDCorr = (Eph.getTGD(sat, Tr));
            }
            catch(EphemerisStore::NoTGDFound& e) {
                TGDCorr = 0.0;
            }
            return TGDCorr;
        };


    }; // 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