TropModel.hpp

Go to the documentation of this file.

#pragma ident "$Id: TropModel.hpp 1144 2008-03-23 21:21:05Z architest $"

//============================================================================
//
//  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
//  
//  Copyright 2004, The University of Texas at Austin
//
//============================================================================

//============================================================================
//
//This software developed by Applied Research Laboratories at the University of
//Texas at Austin, under contract to an agency or agencies within the U.S. 
//Department of Defense. The U.S. Government retains all rights to use,
//duplicate, distribute, disclose, or release this software. 
//
//Pursuant to DoD Directive 523024 
//
// DISTRIBUTION STATEMENT A: This software has been approved for public 
//                           release, distribution is unlimited.
//
//=============================================================================

#ifndef TROPOSPHERIC_MODELS_GPSTK
#define TROPOSPHERIC_MODELS_GPSTK

#include "Exception.hpp"
#include "ObsEpochMap.hpp"
#include "WxObsMap.hpp"
#include "Xvt.hpp"
#include "Position.hpp"
#include "Matrix.hpp"
#include "icd_200_constants.hpp"


// Model of the troposphere, used to compute non-dispersive delay of
// satellite signal as function of satellite elevation as seen at the
// receiver. Both wet and dry components are computed.
//
// The default model (implemented here) is a simple Black model.
//
// In this model (and many others), the wet and dry components are
// independent, the zenith delays depend only on the weather
// (temperature, pressure and humidity), and the mapping functions
// depend only on the elevation of the satellite as seen at the
// receiver. In general, this is not true; other models depend on,
// for example, latitude or day of year.
//
// Other models may be implemented by inheriting this class and
// redefining the virtual functions, and (perhaps) adding other
// 'set...()' routines as needed.

namespace gpstk
{

   class TropModel
   {
   public:
      NEW_EXCEPTION_CLASS(InvalidTropModel, gpstk::Exception);

      virtual ~TropModel() {}

      bool isValid(void)
         { return valid; }

      virtual double correction(double elevation) const
         throw(InvalidTropModel);

      virtual double correction(const Position& RX,
                                const Position& SV,
                                const DayTime& tt)
         throw(InvalidTropModel);

      virtual double correction(const Xvt& RX,
                                const Xvt& SV,
                                const DayTime& tt)
         throw(InvalidTropModel)
      { Position R(RX),S(SV);  return TropModel::correction(R,S,tt); }

      virtual double dry_zenith_delay(void) const
         throw(InvalidTropModel) = 0;

      virtual double wet_zenith_delay(void) const
         throw(InvalidTropModel) = 0;

      virtual double dry_mapping_function(double elevation)
         const throw(InvalidTropModel) = 0;

      virtual double wet_mapping_function(double elevation)
         const throw(InvalidTropModel) = 0;

      virtual void setWeather(const double& T,
                              const double& P,
                              const double& H)
         throw(InvalidParameter);

      virtual void setWeather(const WxObservation& wx)
         throw(InvalidParameter);

      virtual void setReceiverHeight(const double& ht) {};

      virtual void setReceiverLatitude(const double& lat) {};

      virtual void setDayOfYear(const int& d) {};

   protected:
      bool valid;                 // true only if current model parameters are valid
      double temp;                // latest value of temperature (kelvin or celsius)
      double press;               // latest value of pressure (millibars)
      double humid;               // latest value of relative humidity (percent)

   }; // end class TropModel
   

   //---------------------------------------------------------------------------------
   class ZeroTropModel : public TropModel
   {
   public:
      virtual double correction(double elevation) const
         throw(InvalidTropModel)
         { return 0.0; }

      virtual double correction(const Position& RX,
                                const Position& SV,
                                const DayTime& tt)
         throw(InvalidTropModel)
         { return 0.0; }

      virtual double correction(const Xvt& RX,
                                const Xvt& SV,
                                const DayTime& tt)
         throw(InvalidTropModel)
         { return 0.0; }

      virtual double dry_zenith_delay(void) const
         throw(InvalidTropModel)
         { return 0.0; }

      virtual double wet_zenith_delay(void) const
         throw(InvalidTropModel)
         { return 0.0; }

      virtual double dry_mapping_function(double elevation)
         const throw(InvalidTropModel)
         { return 0.0; }

      virtual double wet_mapping_function(double elevation)
         const throw(InvalidTropModel)
         { return 0.0; }

   }; // end class ZeroTropModel


   //---------------------------------------------------------------------------------
   class SimpleTropModel : public TropModel
   {
   public:
      SimpleTropModel(void);

      SimpleTropModel(const WxObservation& wx)
         throw(InvalidParameter);

      SimpleTropModel(const double& T,
                      const double& P,
                      const double& H)
         throw(InvalidParameter);

      virtual double dry_zenith_delay(void) const
         throw(InvalidTropModel);

      virtual double wet_zenith_delay(void) const
         throw(InvalidTropModel);

      virtual double dry_mapping_function(double elevation) const
         throw(InvalidTropModel);

      virtual double wet_mapping_function(double elevation) const
         throw(InvalidTropModel);

      virtual void setWeather(const double& T,
                              const double& P,
                              const double& H)
         throw(InvalidParameter);

      virtual void setWeather(const WxObservation& wx)
         throw(InvalidParameter);

   private:
      double Cdrydelay;
      double Cwetdelay;
      double Cdrymap;
      double Cwetmap;

   };    // end class SimpleTropModel

   //---------------------------------------------------------------------------------
   class GGTropModel : public TropModel
   {
   public:
      GGTropModel(void);

      GGTropModel(const WxObservation& wx)
         throw(InvalidParameter);

      GGTropModel(const double& T,
                  const double& P,
                  const double& H)
         throw(InvalidParameter);

      virtual double dry_zenith_delay(void) const
         throw(InvalidTropModel);

      virtual double wet_zenith_delay(void) const
         throw(InvalidTropModel);

      virtual double dry_mapping_function(double elevation) const
         throw(InvalidTropModel);

      virtual double wet_mapping_function(double elevation) const
         throw(InvalidTropModel);

      virtual void setWeather(const double& T,
                              const double& P,
                              const double& H)
         throw(InvalidParameter);

      virtual void setWeather(const WxObservation& wx)
         throw(InvalidParameter);

   private:
      double Cdrydelay;
      double Cwetdelay;
      double Cdrymap;
      double Cwetmap;

   };    // end class GGTropModel

   //---------------------------------------------------------------------------------
   class GGHeightTropModel : public TropModel
   {
   public:
      GGHeightTropModel(void);

      GGHeightTropModel(const WxObservation& wx)
         throw(InvalidParameter);

      GGHeightTropModel(const double& T,
                        const double& P,
                        const double& H)
         throw(InvalidParameter);

      GGHeightTropModel(const double& T,
                        const double& P,
                        const double& H,
                        const double hT,
                        const double hP,
                        const double hH)
         throw(InvalidParameter);

      virtual double correction(double elevation) const
         throw(InvalidTropModel);

      virtual double correction(const Position& RX,
                                const Position& SV,
                                const DayTime& tt)
         throw(InvalidTropModel);

      virtual double correction(const Xvt& RX,
                                const Xvt& SV,
                                const DayTime& tt)
         throw(InvalidTropModel);

      virtual double dry_zenith_delay(void) const
         throw(InvalidTropModel);

      virtual double wet_zenith_delay(void) const
         throw(InvalidTropModel);

      virtual double dry_mapping_function(double elevation) const
         throw(InvalidTropModel);

      virtual double wet_mapping_function(double elevation) const
         throw(InvalidTropModel);

      virtual void setWeather(const double& T,
                              const double& P,
                              const double& H)
         throw(InvalidParameter);

      virtual void setWeather(const WxObservation& wx)
         throw(InvalidParameter);

      void setHeights(const double& hT,
                      const double& hP,
                      const double& hH);

      void setReceiverHeight(const double& ht);

   private:
      double height;                // height (m) of the receiver
      double htemp;                 // height (m) at which temp applies
      double hpress;                // height (m) at which press applies
      double hhumid;                // height (m) at which humid applies
      bool validWeather;
      bool validHeights;
      bool validRxHeight;

   };    // end class GGHeightTropModel


   //---------------------------------------------------------------------------------
   class NBTropModel : public TropModel
   {
   public:
      NBTropModel(void);

      NBTropModel(const double& lat,
                  const int& day);

      NBTropModel(const double& lat,
                  const int& day,
                  const WxObservation& wx)
         throw(InvalidParameter);

      NBTropModel(const double& lat,
                  const int& day,
                  const double& T,
                  const double& P,
                  const double& H)
         throw(InvalidParameter);

      NBTropModel(const double& ht,
                  const double& lat,
                  const int& day);

      virtual double correction(double elevation) const
         throw(InvalidTropModel);

      virtual double correction(const Position& RX,
                                const Position& SV,
                                const DayTime& tt)
         throw(InvalidTropModel);

      virtual double correction(const Xvt& RX,
                                const Xvt& SV,
                                const DayTime& tt)
         throw(InvalidTropModel);

      virtual double dry_zenith_delay(void) const
         throw(InvalidTropModel);

      virtual double wet_zenith_delay(void) const
         throw(InvalidTropModel);

      virtual double dry_mapping_function(double elevation) const
         throw(InvalidTropModel);

      virtual double wet_mapping_function(double elevation) const
         throw(InvalidTropModel);

      virtual void setWeather(const WxObservation& wx)
         throw(InvalidParameter);

      virtual void setWeather(const double& T,
                              const double& P,
                              const double& H)
         throw(InvalidParameter);

      void setWeather()
         throw(InvalidTropModel);

      void setReceiverHeight(const double& ht);

      void setReceiverLatitude(const double& lat);

      void setDayOfYear(const int& d);

   private:
      bool interpolateWeather;      // if true, compute T,P,H from latitude,doy
      double height;                // height (m) of the receiver
      double latitude;              // latitude (deg) of receiver
      int doy;                      // day of year
      bool validWeather;
      bool validRxLatitude;
      bool validRxHeight;
      bool validDOY;

   };    // end class NBTropModel

   //---------------------------------------------------------------------------------
   class SaasTropModel : public TropModel
   {
   public:
      SaasTropModel(void);

      SaasTropModel(const double& lat,
                    const int& day);

      SaasTropModel(const double& lat,
                    const int& day,
                    const WxObservation& wx)
         throw(InvalidParameter);

      SaasTropModel(const double& lat,
                    const int& day,
                    const double& T,
                    const double& P,
                    const double& H)
         throw(InvalidParameter);

      virtual double correction(double elevation) const
         throw(InvalidTropModel);

      virtual double correction(const Position& RX,
                                const Position& SV,
                                const DayTime& tt)
         throw(InvalidTropModel);

      virtual double correction(const Xvt& RX,
                                const Xvt& SV,
                                const DayTime& tt)
         throw(InvalidTropModel);

      virtual double dry_zenith_delay(void) const
         throw(InvalidTropModel);

      virtual double wet_zenith_delay(void) const
         throw(InvalidTropModel);

      virtual double dry_mapping_function(double elevation) const
         throw(InvalidTropModel);

      virtual double wet_mapping_function(double elevation) const
         throw(InvalidTropModel);

      virtual void setWeather(const WxObservation& wx)
         throw(InvalidParameter);

      virtual void setWeather(const double& T,
                              const double& P,
                              const double& H)
         throw(InvalidParameter);

      void setReceiverHeight(const double& ht);

      void setReceiverLatitude(const double& lat);

      void setDayOfYear(const int& d);

   private:
      double height;                
      double latitude;              
      int doy;                      
      bool validWeather;
      bool validRxLatitude;
      bool validRxHeight;
      bool validDOY;

   };    // end class SaasTropModel


      //--------------------------------------------------------------------

   class GCATTropModel : public TropModel
   {
   public:


      GCATTropModel(void)
      { valid = false; };


      GCATTropModel(const double& ht);


      virtual double correction(double elevation) const
         throw(InvalidTropModel);


      virtual double correction( const Position& RX,
                                 const Position& SV )
         throw(InvalidTropModel);


      virtual double correction( const Position& RX,
                                 const Position& SV,
                                 const DayTime& tt )
         throw(InvalidTropModel)
      { return correction(RX, SV); };


      virtual double correction( const Xvt& RX,
                                 const Xvt& SV,
                                 const DayTime& tt )
         throw(InvalidTropModel);


      virtual double dry_zenith_delay(void) const
         throw(InvalidTropModel);


      virtual double wet_zenith_delay(void) const
         throw(InvalidTropModel)
      { return 0.1; };


      virtual double mapping_function(double elevation) const
         throw(InvalidTropModel);


      virtual double dry_mapping_function(double elevation) const
         throw(InvalidTropModel)
      { return mapping_function(elevation); };


      virtual double wet_mapping_function(double elevation) const
         throw(InvalidTropModel)
      { return mapping_function(elevation); };


      virtual void setWeather( const double& T,
                               const double& P,
                               const double& H )
         throw(InvalidParameter) {};


      virtual void setWeather(const WxObservation& wx)
         throw(InvalidParameter) {};


      virtual void setReceiverHeight(const double& ht);


   private:

      double gcatHeight;

   };    // end class GCATTropModel


      //---------------------------------------------------------------------

   class MOPSTropModel : public GCATTropModel
   {
   public:

      MOPSTropModel(void);


      MOPSTropModel(const double& ht)
      { setReceiverHeight(ht); };


      MOPSTropModel(const double& ht, const double& lat, const int& doy);


      MOPSTropModel(const Position& RX, const DayTime& time);


      virtual double correction(double elevation) const 
         throw(InvalidTropModel);


      virtual double correction( const Position& RX,
                                 const Position& SV )
         throw(InvalidTropModel);


      virtual double correction( const Position& RX,
                                 const Position& SV,
                                 const DayTime& tt )
         throw(InvalidTropModel);


      virtual double correction( const Position& RX,
                                 const Position& SV,
                                 const int& doy )
         throw(InvalidTropModel);


      virtual double correction( const Xvt& RX,
                                 const Xvt& SV )
         throw(InvalidTropModel);


      virtual double correction( const Xvt& RX,
                                 const Xvt& SV,
                                 const DayTime& tt )
         throw(InvalidTropModel);


      virtual double correction( const Xvt& RX,
                                 const Xvt& SV,
                                 const int& doy )
         throw(InvalidTropModel);


      virtual double dry_zenith_delay(void) const
         throw(InvalidTropModel);


      virtual double wet_zenith_delay(void) const
         throw(InvalidTropModel);


      void setWeather()
         throw(InvalidTropModel);


      virtual void setWeather( const double& T,
                               const double& P,
                               const double& H )
         throw(InvalidParameter) {};


      virtual void setWeather(const WxObservation& wx)
         throw(InvalidParameter) {};


      virtual void setReceiverHeight(const double& ht);


      virtual void setReceiverLatitude(const double& lat);


      virtual void setDayOfYear(const int& doy);


      virtual void setDayOfYear(const DayTime& time);


      virtual void setAllParameters( const DayTime& time,
                                     const Position& rxPos );


      double MOPSsigma2(double elevation) 
         throw(TropModel::InvalidTropModel);


   private:

      double MOPSHeight;
      double MOPSLat;
      int MOPSTime;
      bool validHeight;
      bool validLat;
      bool validTime;
      Matrix<double> avr;
      Matrix<double> svr;
      Vector<double> fi0;
      Vector<double> MOPSParameters;


         // The MOPS tropospheric model needs to compute several extra
         // parameters
      virtual void prepareParameters(void) throw(TropModel::InvalidTropModel);


         // The MOPS tropospheric model uses several predefined data tables
      virtual void prepareTables(void);

   };    // end class MOPSTropModel


      //--------------------------------------------------------------------

   class NeillTropModel : public TropModel
   {
   public:

      NeillTropModel(void) 
      { validHeight=false; validLat=false; validDOY=false; valid=false; };


      NeillTropModel(const double& ht)
      { setReceiverHeight(ht); };


      NeillTropModel( const double& ht,
                      const double& lat,
                      const int& doy )
      { setReceiverHeight(ht); setReceiverLatitude(lat); setDayOfYear(doy); };


      NeillTropModel( const Position& RX,
                      const DayTime& time );


      virtual double correction(double elevation) const
         throw(InvalidTropModel);


      virtual double correction( const Position& RX,
                                 const Position& SV )
         throw(InvalidTropModel);


      virtual double correction( const Position& RX,
                                 const Position& SV,
                                 const DayTime& tt )
        throw(InvalidTropModel);


      virtual double correction( const Position& RX,
                                 const Position& SV,
                                 const int& doy )
         throw(InvalidTropModel);


      virtual double correction( const Xvt& RX,
                                 const Xvt& SV  )
         throw(InvalidTropModel);


      virtual double correction( const Xvt& RX,
                                 const Xvt& SV,
                                 const DayTime& tt )
         throw(InvalidTropModel);


      virtual double correction( const Xvt& RX,
                                 const Xvt& SV,
                                 const int& doy )
         throw(InvalidTropModel);


      virtual double dry_zenith_delay(void) const
         throw(InvalidTropModel);


      virtual double wet_zenith_delay(void) const
         throw(InvalidTropModel)
      { return 0.1; };           // Returns a nominal value


      virtual double dry_mapping_function(double elevation) const
         throw(InvalidTropModel);


      virtual double wet_mapping_function(double elevation) const
         throw(InvalidTropModel);


      void setWeather()
         throw(InvalidTropModel);


      virtual void setWeather( const double& T,
                               const double& P,
                               const double& H )
         throw(InvalidParameter) {};


      virtual void setWeather(const WxObservation& wx)
         throw(InvalidParameter) {};


      virtual void setReceiverHeight(const double& ht);


      virtual void setReceiverLatitude(const double& lat);


      virtual void setDayOfYear(const int& doy);


      virtual void setDayOfYear(const DayTime& time);


      virtual void setAllParameters( const DayTime& time,
                                     const Position& rxPos );


   private:


      double NeillHeight;
      double NeillLat;
      int NeillDOY;
      bool validHeight;
      bool validLat;
      bool validDOY;


   };    // end class NeillTropModel
   
   
}
#endif   // TROPOSPHERIC_MODELS_GPSTK

---