tropmodel.hpp

GPS定位中对流层模型改正

         /// @param d Day of year.
      void setDayOfYear(const int& d);

   private:
      double height;                /// height (m) of the receiver above the geoid
      double latitude;              /// latitude (deg) of receiver
      int doy;                      /// day of year
      bool validWeather;
      bool validRxLatitude;
      bool validRxHeight;
      bool validDOY;

   };    // end class SaasTropModel


//--------------------------------------------------------------------------
      /** Tropospheric model implemented in "GPS Code Analysis Tool" (GCAT)
       *  software.
       *
       * This model is described in the book "GPS Data processing: code and
       * phase Algorithms, Techniques and Recipes" by Hernandez-Pajares, M.,
       * J.M. Juan-Zornoza and Sanz-Subirana, J. See Chapter 5.
       *
       * This book and associated software are freely available at:
       *
       * http://gage152.upc.es/~manuel/tdgps/tdgps.html
       *
       * This is a simple but efective model composed of the wet and dry
       * vertical tropospheric delays as defined in Gipsy/Oasis-II GPS
       * analysis software, and the mapping function as defined by Black and
       * Eisner (H. D. Black, A. Eisner. Correcting Satellite Doppler
       * Data for Tropospheric Effects. Journal of  Geophysical Research.
       * Vol 89. 1984.) and used in MOPS (RTCA/DO-229C) standards.
       *
       * Usually, the caller will set the receiver height using
       * setReceiverHeight() method, and then call the correction() method
       * with the satellite elevation as parameter.
       *
       * @code
       *   GCATTropModel gcatTM();
       *   ...
       *   gcatTM.setReceiverHeight(150.0);
       *   trop = gcatTM.correction(elevation);
       * @endcode
       *
       * Another posibility is to set the receiver height when calling
       * the constructor.
       *
       * @code
       *   GCATTropModel gcatTM(150.0);    // Receiver height is 150.0 meters
       *   ...
       *   trop = gcatTM.correction(elevation);
       * @endcode
       */
   class GCATTropModel : public TropModel
   {
   public:


         /// Empty constructor
      GCATTropModel(void)
      { valid = false; };


         /// Constructor to create a GCAT trop model providing  the height
         /// of the receiver above mean sea level (as defined by ellipsoid
         /// model).
         /// 
         /// @param ht Height of the receiver above mean sea level, in meters.
      GCATTropModel(const double& ht);


        /// Compute and return the full tropospheric delay. The receiver height must
        /// has been provided before, whether using the appropriate constructor of
        /// with the setReceiverHeight() method
        /// @param elevation Elevation of satellite as seen at receiver, in degrees
        virtual double correction(double elevation) const
        throw(InvalidTropModel);


        /**
         * Compute and return the full tropospheric delay, given the positions of
         * receiver and satellite. This version is most useful within positioning 
         * algorithms, where the receiver position may vary; it computes the elevation
         * (and other receiver location information as height) and passes them to 
         * setReceiverHeight() method and correction(elevation) method.
         * @param RX  Receiver position
         * @param SV  Satellite position
         */
        virtual double correction(const Position& RX,
                                  const Position& SV)
        throw(InvalidTropModel);


        /**
         * Compute and return the full tropospheric delay, given the positions of
         * receiver and satellite and the time tag. This version is most useful
         * within positioning algorithms, where the receiver position and timetag
         * may vary; it computes the elevation (and other receiver location
         * information as height) and passes them to setReceiverHeight() method and
         * correction(elevation) method.
         * @param RX  Receiver position
         * @param SV  Satellite position
         * @param tt  Time. In this model, tt is a dummy parameter kept just for consistency
         */
        virtual double correction(const Position& RX,
                                  const Position& SV,
                                  const DayTime& tt)
        throw(InvalidTropModel)
        { return correction(RX, SV); };


        /** \deprecated
         * Compute and return the full tropospheric delay, given the positions of
         * receiver and satellite and the time tag. This version is most useful
         * within positioning algorithms, where the receiver position and timetag
         * may vary; it computes the elevation (and other receiver location
         * information as height) and passes them to setReceiverHeight() method and
         * correction(elevation) method.
         * @param RX  Receiver position in ECEF cartesian coordinates (meters)
         * @param SV  Satellite position in ECEF cartesian coordinates (meters)
         * @param tt  Time. In this model, tt is a dummy parameter kept just for consistency
         */
        virtual double correction(const Xvt& RX,
                                  const Xvt& SV,
                                  const DayTime& tt)
        throw(InvalidTropModel);


        /// Compute and return the zenith delay for dry component of the troposphere
        virtual double dry_zenith_delay(void) const
            throw(InvalidTropModel);


        /// Compute and return the zenith delay for wet component of the troposphere
        virtual double wet_zenith_delay(void) const
            throw(InvalidTropModel)
        { return 0.1; };


        /// Compute and return the mapping function for both components of
        /// the troposphere.
        /// @param elevation Elevation of satellite as seen at receiver, in degrees
        virtual double mapping_function(double elevation) const
        throw(InvalidTropModel);


        /// Compute and return the mapping function for dry component
        /// of the troposphere
        /// @param elevation Elevation of satellite as seen at receiver, in degrees
        virtual double dry_mapping_function(double elevation) const
            throw(InvalidTropModel)
        { return mapping_function(elevation); };


        /// Compute and return the mapping function for wet component
        /// of the troposphere
        /// @param elevation Elevation of satellite as seen at receiver, in degrees
        virtual double wet_mapping_function(double elevation) const
            throw(InvalidTropModel)
        { return mapping_function(elevation); };


        /// In GCAT tropospheric model, this is a dummy method kept here just for consistency
        virtual void setWeather(const double& T,
                                const double& P,
                                const double& H)
            throw(InvalidParameter) {};


        /// In GCAT tropospheric model, this is a dummy method kept here just for consistency
        virtual void setWeather(const WxObservation& wx)
            throw(InvalidParameter) {};


        /// Define the receiver height; this is required before calling
        /// correction() or any of the zenith_delay routines.
        /// @param ht Height of the receiver above mean sea level, in meters.
        virtual void setReceiverHeight(const double& ht);


    private:
        double gcatHeight;

   };    // end class GCATTropModel


 //---------------------------------------------------------------------------------
    /** Tropospheric model implemented in the RTCA "Minimum Operational Performance Standards" (MOPS), version C.
     * This model is described in the RTCA "Minimum Operational Performance
     * Standards" (MOPS), version C (RTCA/DO-229C), in Appendix A.4.2.4. Although
     * originally developed for SBAS systems (EGNOS, WAAS), it  may be suitable 
     * for other uses as well.
     *
     * This model needs the day of year, satellite elevation (degrees), receiver
     * height over mean sea level (meters) and receiver latitude in order to start
     * computing.
     *
     * On the other hand, the outputs are the tropospheric correction (in meters)
     * and the sigma-squared of tropospheric delay residual error (meters^2)
     * 
     * A typical way to use this model follows:
     *
     * @code
     *   MOPSTropModel mopsTM;
     *   mopsTM.setReceiverLatitude(lat);
     *   mopsTM.setReceiverHeight(height);
     *   mopsTM.setDayOfYear(doy);
     * @endcode
     *
     * Once all the basic model parameters are set (latitude, height and day of
     * year), then we are able to compute the tropospheric correction as a 
     * function of elevation:
     *
     * @code
     *   trop = mopsTM.correction(elevation);
     * @endcode
     *
     */
    class MOPSTropModel : public GCATTropModel
    {
    public:

        /// Empty constructor
        MOPSTropModel(void) 
        {
            validHeight = false;
            validLat = false;
            validTime = false;
            valid = false;
        };


        /// Constructor to create a MOPS trop model providing just the height of the 
        /// receiver above mean sea level. The other parameters must be set with the
        /// appropriate set methods before calling correction methods.
        /// 
        /// @param ht   Height of the receiver above mean sea level, in meters.
        MOPSTropModel(const double& ht)
        {
            setReceiverHeight(ht);
        };



        /// Constructor to create a MOPS trop model providing the height of the receiver
        /// above mean sea level (as defined by ellipsoid model), its latitude and the day
        /// of year.
        /// 
        /// @param ht   Height of the receiver above mean sea level, in meters.
        /// @param lat  Latitude of receiver, in degrees.
        /// @param doy  Day of year.
        MOPSTropModel(const double& ht, const double& lat, const int& doy)
        {
            setReceiverHeight(ht);
            setReceiverLatitude(lat);
            setDayOfYear(doy);
        };


        /// Constructor to create a MOPS trop model providing the position of the receiver
        /// and current time.
        /// 
        /// @param RX   Receiver position.
        /// @param time Time.
        MOPSTropModel(const Position& RX, const DayTime& time)
        {
            setReceiverHeight(RX.getAltitude());
            setReceiverLatitude(RX.getGeodeticLatitude());
            setDayOfYear(time);
        };


        /// Compute and return the full tropospheric delay. The receiver height, 
        /// latitude and Day oy Year must has been set before using the 
        /// appropriate constructor or the provided methods.
        /// @param elevation Elevation of satellite as seen at receiver, in degrees.
        virtual double correction(double elevation) const 
            throw(InvalidTropModel);


        /**
         * Compute and return the full tropospheric delay, given the positions of
         * receiver and satellite. This version is most useful within positioning 
         * algorithms, where the receiver position may vary; it computes the
         * elevation (and other receiver location information as height and
         * latitude) and passes them to appropriate methods. You must set time
         * using method setReceiverDOY() before calling this method.
         * @param RX  Receiver position.
         * @param SV  Satellite position.
         */
        virtual double correction(const Position& RX,
                                  const Position& SV)
        throw(InvalidTropModel);


        /**
         * Compute and return the full tropospheric delay, given the positions of
         * receiver and satellite and the time tag. This version is most useful 
         * within positioning algorithms, where the receiver position may vary; it
         * computes the elevation (and other receiver location information as
         * height and latitude) and passes them to appropriate methods.
         * @param RX  Receiver position.
         * @param SV  Satellite position.