IERS.hpp

Go to the documentation of this file.

#pragma ident "$Id: IERS.hpp 2957 2011-10-30 18:15:34Z yanweignss $"

#ifndef GPSTK_IERS_HPP
#define GPSTK_IERS_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
//
//  Wei Yan - Chinese Academy of Sciences . 2010
//
//============================================================================

#include <string>
#include "IERSConventions.hpp"
#include "PlanetEphemeris.hpp"

namespace gpstk
{

   class IERS
   {
   public:
      static const double PI;

      static const double ARCSEC2RAD;

      
      static std::string version(){return "IERS1996";}


      //
      // Methods to handle EOP data---------------------------------------------
      //

      static void loadIERSFile(const std::string& iersFile)
         throw(FileMissingException){ gpstk::LoadIERSFile(iersFile); } 

      static void loadIGSFile(const std::string& igsFile)
         throw(FileMissingException){ gpstk::LoadIGSFile(igsFile); } 
 
      static void loadSTKFile(const std::string& stkFile)
         throw(FileMissingException){ gpstk::LoadSTKFile(stkFile); } 


      static EOPDataStore::EOPData eopData(const double& mjdUTC)
         throw(InvalidRequest){return gpstk::EOPData( DayTime(mjdUTC) );}

      static EOPDataStore::EOPData eopData(const DayTime& UTC)
         throw(InvalidRequest){return gpstk::EOPData(UTC);}
        
      static double xPole(const double& mjdUTC)
         throw (InvalidRequest){return gpstk::PolarMotionX( DayTime(mjdUTC) );}

      static double xPole(const DayTime& UTC)
         throw (InvalidRequest){return gpstk::PolarMotionX(UTC);}
      
      static double yPole(const double& mjdUTC)
         throw (InvalidRequest){ return gpstk::PolarMotionY( DayTime(mjdUTC) );}

      static double yPole(const DayTime& UTC)
         throw (InvalidRequest){ return gpstk::PolarMotionY(UTC);}

      static double UT1mUTC(const double& mjdUTC)
         throw (InvalidRequest) { return gpstk::UT1mUTC( DayTime(mjdUTC) ); } 

      static double UT1mUTC(const DayTime& UTC)
         throw (InvalidRequest) { return gpstk::UT1mUTC(UTC); } 
     
      static double dPsi(const double& mjdUTC)
         throw (InvalidRequest){return gpstk::NutationDPsi( DayTime(mjdUTC) );}

      static double dPsi(const DayTime& UTC)
         throw (InvalidRequest){return gpstk::NutationDPsi(UTC);}

      static double dEps(const double& mjdUTC)
         throw (InvalidRequest){return gpstk::NutationDEps( DayTime(mjdUTC) );}

      static double dEps(const DayTime& UTC)
         throw (InvalidRequest){return gpstk::NutationDEps(UTC);}

      static int TAImUTC(const double& mjdUTC)
         throw(InvalidRequest){return gpstk::TAImUTC( DayTime(mjdUTC) ); }

      static int TAImUTC(const DayTime& UTC)
         throw(InvalidRequest){return gpstk::TAImUTC(UTC); }


      static double TTmTAI(){return gpstk::TTmTAI();}

      
      static double TAImGPST(){return gpstk::TAImGPST();}

      //
      // Methods to handle time system conversion-------------------------------
      //
      //
      //          -14s
      //    -----------------> BDT(Compass Time)
      //    |                                                                    
      //    |         +19s             +32.184s           +rel.effects       
      //   GPST ------------> TAI ----------------> TT -----------------> TDB   
      //                      T |                                         
      //           -(UT1-TAI) | |    -leap seconds                          
      //   UT1 ---------------| |--------------------> UTC                
      //    |                                                              
      //    |   earth rotation                                            
      //    ---------------------> GAST  
      //========================================================================

      static DayTime GPST2UTC(const DayTime& GPST){return gpstk::GPST2UTC(GPST);}
      static DayTime UTC2GPST(const DayTime& UTC){return gpstk::UTC2GPST(UTC);}
   
      static DayTime UT12UTC(const DayTime& UT1){return gpstk::UT12UTC(UT1);}
      static DayTime UTC2UT1(const DayTime& UTC){return gpstk::UTC2UT1(UTC);}

      static DayTime UT12UTC(const DayTime& UT1,double ut1mutc)
      {return gpstk::UT12UTC(UT1,ut1mutc);}
      
      static DayTime UTC2UT1(const DayTime& UTC,double ut1mutc)
      {return gpstk::UTC2UT1(UTC,ut1mutc);}

      static DayTime TT2UTC(const DayTime& TT){return gpstk::TT2UTC(TT);}
      static DayTime UTC2TT(const DayTime& UTC){return gpstk::UTC2TT(UTC);}

      static DayTime TAI2UTC(const DayTime& TAI){return gpstk::TAI2UTC(TAI);}
      static DayTime UTC2TAI(const DayTime& UTC){return gpstk::UTC2TAI(UTC);}

      static DayTime BDT2UTC(const DayTime& BDT){return gpstk::BDT2UTC(BDT);}
      static DayTime UTC2BDT(const DayTime& UTC){return gpstk::UTC2BDT(UTC);}

      static DayTime ConvertTimeSystem(const DayTime& time,TimeSystem from,TimeSystem to)
      {return gpstk::ConvertTimeSystem(time,from,to);}


         //
         // Methods to handle reference system conversion-------------------------------
         // 
         //Ritrf = POM * Theta * N * P * Ricrf
         //
      
      static Matrix<double> J2kToECEFMatrix(const DayTime& UTC,const EOPDataStore::EOPData& ERP)
         throw(Exception) { return gpstk::J2kToECEFMatrix(UTC,ERP); }

      static Vector<double> J2kPosToECEF(const DayTime& UTC, const Vector<double>& j2kPos)
         throw(Exception) {return gpstk::J2kPosToECEF(UTC,j2kPos);}

      static Vector<double> ECEFPosToJ2k(const DayTime& UTC, const Vector<double>& ecefPos)
         throw(Exception){return gpstk::ECEFPosToJ2k(UTC,ecefPos);}

      static Vector<double> J2kPosVelToECEF(const DayTime& UTC, const Vector<double>& j2kPosVel)
         throw(Exception){return gpstk::J2kPosVelToECEF(UTC,j2kPosVel);}


      static Vector<double> ECEFPosVelToJ2k(const DayTime& UTC, const Vector<double>& ecefPosVel)
         throw(Exception){return gpstk::ECEFPosVelToJ2k(UTC,ecefPosVel);}

      
      //
      // Methods to handle planet ephemeris -------------------------------
      // 
      // DE405
      //

      static void loadBinaryEphemeris(const std::string ephFile)
         throw(Exception);
      
      static Vector<double> planetJ2kPosVel( const DayTime&      TT, 
                                             PlanetEphemeris::Planet entity,
                                             PlanetEphemeris::Planet center 
                                                      = PlanetEphemeris::Earth)
         throw(Exception);

      static Vector<double> sunJ2kPosition(const DayTime& TT);
      static Vector<double> sunJ2kPosition(const DayTime& time,TimeSystem sys)
      { return sunJ2kPosition(ConvertTimeSystem(time,sys,TS_TT));}

      static Vector<double> moonJ2kPosition(const DayTime& TT);
      static Vector<double> moonJ2kPosition(const DayTime& time,TimeSystem sys)
      { return moonJ2kPosition(ConvertTimeSystem(time,sys,TS_TT));}

      static Vector<double> sunECEFPosition(const DayTime& TT);
      static Vector<double> sunECEFPosition(const DayTime& time,TimeSystem sys)
      { return sunECEFPosition(ConvertTimeSystem(time,sys,TS_TT));}

      static Vector<double> moonECEFPosition(const DayTime& TT);
      static Vector<double> moonECEFPosition(const DayTime& time,TimeSystem sys)
      { return moonECEFPosition(ConvertTimeSystem(time,sys,TS_TT));}

   protected:
      IERS() {}
      ~IERS() {}
      
      static PlanetEphemeris jplEphemeris;

   }; // End of class 'IERS'

      // @}

}  // End of namespace 'gpstk'

#endif   // GPSTK_IERS_HPP

---