tropmodel.hpp

gps源代码

         throw(InvalidTropModel);

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

         /// Compute and return the mapping function for dry component of
         /// the troposphere. NB this function will return infinity at zero elevation.
         /// @param elevation Elevation of satellite as seen at receiver, in degrees
      virtual double dry_mapping_function(double elevation) const
         throw(InvalidTropModel);

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

         /// Re-define the tropospheric model with explicit weather data.
         /// Typically called just before correction().
         /// @param wx the weather to use for this correction       
      virtual void setWeather(const WxObservation& wx)
         throw(InvalidParameter);

         /// Define the weather data; typically called just before correction().
         /// @param T temperature in degrees Celsius
         /// @param P atmospheric pressure in millibars
         /// @param H relative humidity in percent
      virtual void setWeather(const double& T,
                              const double& P,
                              const double& H)
         throw(InvalidParameter);

         /// Define the receiver height; this required before calling
         /// correction() or any of the zenith_delay or mapping_function routines.
         /// @param ht Height of the receiver in meters.
      void setReceiverHeight(const double& ht);

         /// Define the latitude of the receiver; this is required before calling
         /// correction() or any of the zenith_delay or mapping_function routines.
         /// @param lat Latitude of the receiver in degrees.
      void setReceiverLatitude(const double& lat);

         /// Define the day of year; this is required before calling
         /// correction() or any of the zenith_delay or mapping_function routines.
         /// @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
     *
     * @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.
        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.