ReferenceFrames.hpp

Go to the documentation of this file.

#pragma ident "$Id: ReferenceFrames.hpp 2457 2010-08-18 14:20:12Z coandrei $"

#ifndef GPSTK_REFERENCE_FRAMES_HPP
#define GPSTK_REFERENCE_FRAMES_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 . 2009, 2010
//
//============================================================================



#include "Vector.hpp"
#include "Matrix.hpp"
#include "SolarSystem.hpp"
#include "UTCTime.hpp"

namespace gpstk
{

   class ReferenceFrames
   {
   public:

      static int setJPLEphFile(std::string filename) 
         throw(Exception)
      {
         return solarPlanets.initializeWithBinaryFile(filename);
      }

      static Vector<double> getJ2kPosition( const DayTime&      TT,
                                            SolarSystem::Planet entity = SolarSystem::Earth)
         throw(Exception);

      static Vector<double> getJ2kVelocity( const DayTime&      TT, 
                                            SolarSystem::Planet entity = SolarSystem::Earth)
         throw(Exception);



      static Vector<double> getJ2kPosVel( const DayTime&      TT, 
                                          SolarSystem::Planet entity,
                                          SolarSystem::Planet center = SolarSystem::Earth)
         throw(Exception);
      
      static Vector<double> getECEFPosition(UTCTime             UTC, 
                                          SolarSystem::Planet entity,
                                          SolarSystem::Planet center = SolarSystem::Earth)
         throw(Exception);

      
      static Vector<double> getECEFVelocity(UTCTime             UTC, 
                                          SolarSystem::Planet entity,
                                          SolarSystem::Planet center = SolarSystem::Earth)
         throw(Exception);


      static Vector<double> getECEFPosVel(UTCTime             UTC, 
                                          SolarSystem::Planet entity,
                                          SolarSystem::Planet center = SolarSystem::Earth)
         throw(Exception);


      static void J2kToECEFMatrix(UTCTime         UTC, 
                                  Matrix<double>& POM,
                                  Matrix<double>& Theta, 
                                  Matrix<double>& NP)
         throw(Exception);


      static Matrix<double> J2kToECEFMatrix(UTCTime UTC);
         
      static Matrix<double> J2kToTODMatrix(UTCTime UTC);

      static Vector<double> J2kPosVelToECEF(UTCTime UTC, Vector<double> j2kPosVel)
         throw(Exception);
         
      static Vector<double> ECEFPosVelToJ2k(UTCTime UTC, Vector<double> ecefPosVel)
         throw(Exception);

      static Vector<double> J2kStateToECEF(UTCTime UTC, Vector<double> j2kState)
         throw(Exception);

      static Vector<double> ECEFStateToJ2k(UTCTime UTC, Vector<double> ecefState)
         throw(Exception);

      static void doodsonArguments(DayTime UT1,DayTime TT,double BETA[6],double FNUT[5]); 


      static double iauGmst00(DayTime UT1,DayTime TT);


      static Matrix<double> enuMatrix(double longitude,double latitude);

      static Vector<double> enuToAzElDt(Vector<double> enu);

      static void XYZ2BLH(double xyz[3],double blh[3]);
      static void BLH2XYZ(double blh[3],double xyz[3]);

      static void XYZ2ENU(double blh[3],double xyz[3],double enu[3]);
      static void ENU2XYZ(double blh[3],double enu[3],double xyz[3]);

      static void test();

      static Matrix<double> Rx(const double& angle);

      static Matrix<double> Ry(const double& angle);

      static Matrix<double> Rz(const double& angle);

   protected:
        
      ReferenceFrames(){}

      ~ReferenceFrames(){}

         
      static Matrix<double> iauPmat76(DayTime TT);
         
      static void nutationAngles(DayTime TT, double& dpsi, double& deps);
         
      static double meanObliquity(DayTime TT);
         
      static double iauEqeq94(DayTime TT);
         
      static double iauGmst82(DayTime UT1);

           
      static Matrix<double> iauNmat(const double& epsa, 
                                    const double& dpsi, 
                                    const double& deps);

      static double earthRotationAngle(DayTime UT1);


      static double earthRotationAngleRate1(const double& mjdTT);


      static double earthRotationAngleRate2(const double& mjdTT);


      static double earthRotationAngleRate3(const double& mjdTT);

  
      static double normalizeAngle(double a);

        
   private:

      static SolarSystem solarPlanets;

      // Constant Variables
      //-------------------------------------------------

      static const double DJ00;

      static const double JD_TO_MJD; 

      static const double D2PI;

      static const double DJC;

      static const double DAS2R;

      static const double DS2R;

      static const double TURNAS;

   }; // End of class 'ReferenceFrames'

      // @}

}  // End of namespace 'gpstk'




#endif  // REFERENCE_FRAMES_HPP

---