EarthOrientation.hpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk 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 3.0 of the License, or
//  any later version.
//
//  The GNSSTk 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 GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was 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 CLASS_EARTHORIENT_INCLUDE
#define CLASS_EARTHORIENT_INCLUDE
 
//------------------------------------------------------------------------------------
// system includes
#include <iomanip>
#include <iostream>
#include <vector>
// GNSSTk
#include "Exception.hpp"
#include "Matrix.hpp"
#include "Position.hpp"
#include "Triple.hpp"
// geomatics
#include "EphTime.hpp"
#include "IERSConvention.hpp"
 
//------------------------------------------------------------------------------------
namespace gnsstk
{
 
   class EarthOrientation
   {
   public:
      double xp;
 
      double yp;
 
      double UT1mUTC;
 
      IERSConvention convention;
 
      EarthOrientation()
         : xp(0), yp(0), UT1mUTC(0), convention(IERSConvention::Unknown)
      {
      }
 
      friend std::ostream& operator<<(std::ostream& s,
                                      const EarthOrientation& );
 
      //------------------------------------------------------------------------------
      // constants
 
      static const double JulianEpoch;
 
      static const int intJulianEpoch;
 
      static const double PI, TWOPI, HALFPI;
 
      static const double DEG_TO_RAD, RAD_TO_DEG;
 
      static const double ARCSEC_TO_RAD;
 
      static const double ARCSEC_PER_CIRCLE;
 
      //------------------------------------------------------------------------------
      // interpolation of data from EOPStore to get EOPs
      void interpolateEOP(const EphTime& ttag, const std::vector<double>& time,
                          const std::vector<double>& X,
                          const std::vector<double>& Y, std::vector<double>& dT,
                          const IERSConvention& conv);
 
      //------------------------------------------------------------------------------
      static double coordTransTime(EphTime t);
 
      //------------------------------------------------------------------------------
      static double Omega(double T);
 
      //------------------------------------------------------------------------------
      static double Omega2003(double T);
 
      //------------------------------------------------------------------------------
      static double F(double T);
 
      //------------------------------------------------------------------------------
      static double D(double T);
 
      //------------------------------------------------------------------------------
      static double L(double T);
 
      //------------------------------------------------------------------------------
      static double Lp(double T);
 
      //------------------------------------------------------------------------------
      static double LMe(double T);
 
      //------------------------------------------------------------------------------
      static double LV(double T);
 
      //------------------------------------------------------------------------------
      static double LE(double T);
 
      //------------------------------------------------------------------------------
      static double LMa(double T);
 
      //------------------------------------------------------------------------------
      static double LJ(double T);
 
      //------------------------------------------------------------------------------
      static double LS(double T);
 
      //------------------------------------------------------------------------------
      static double LU(double T);
 
      //------------------------------------------------------------------------------
      static double LN(double T);
 
      //------------------------------------------------------------------------------
      static double Pa(double T);
 
      //------------------------------------------------------------------------------
      double obliquity(double T);
 
      //------------------------------------------------------------------------------
      double GMST(const EphTime& t, bool reduced = false);
 
      //------------------------------------------------------------------------------
      double GAST(const EphTime& t, bool reduced = false);
 
      //------------------------------------------------------------------------------
      Matrix<double> polarMotionMatrix(const EphTime& t);
 
      //------------------------------------------------------------------------------
      Matrix<double> precessionMatrix(const EphTime& t);
 
      //------------------------------------------------------------------------------
      // Nutation of the obliquity (deps) and of the longitude (dpsi)
      // @param T    the coordinate transformation time at the time of interest
      // @param deps nutation of the obliquity (output) in radians
      // @param dpsi nutation of the longitude (output) in radians
      // @throw Exception if convention is not defined
      // void nutationAngles(double T, double& deps, double& dpsi)
 
      //------------------------------------------------------------------------------
      Matrix<double> nutationMatrix(const EphTime& t);
 
      //------------------------------------------------------------------------------
      Matrix<double> preciseEarthRotation(const EphTime& t);
 
      //------------------------------------------------------------------------------
      Matrix<double> ECEFtoInertial(const EphTime& t, bool reduced = false);
 
      //------------------------------------------------------------------------------
      Matrix<double> ECEFtoJ2000(const EphTime& t, bool reduced = false);
 
   private:
      //------------------------------------------------------------------------------
      static double S(double T, double& X, double& Y,
                      IERSConvention which = IERSConvention::IERS2003);
 
      //------------------------------------------------------------------------------
      static double Sprime(double T);
 
      static double Sprime(EphTime t)
      {
         return Sprime(coordTransTime(t));
      }
 
      //------------------------------------------------------------------------------
      static void XYCIO(double& T, double& X, double& Y);
 
      //------------------------------------------------------------------------------
      static double EarthRotationAngle(const EphTime& t, double& UT1mUTC);
 
      //------------------------------------------------------------------------------
      static double equationOfEquinoxes2003(EphTime t);
 
      //------------------------------------------------------------------------------
      static void UT1mUTCTidalCorrections(double T, double& UT1mUTR,
                                          double& dlodR,
                                          double& domegaR);
 
      //------------------------------------------------------------------------------
      static double obliquity1996(double T);
 
      //------------------------------------------------------------------------------
      static double obliquity2010(double T);
 
      //------------------------------------------------------------------------------
      static double GMST1996(EphTime t, double UT1mUTC, bool reduced = false);
 
      //------------------------------------------------------------------------------
      static double GMST2003(EphTime t, double UT1mUTC);
 
      //------------------------------------------------------------------------------
      static double GMST2010(EphTime t, double UT1mUTC);
 
      //------------------------------------------------------------------------------
      static double gast1996(EphTime t, double om, double eps, double dpsi,
                             double UT1mUTC);
 
      //------------------------------------------------------------------------------
      static double GAST1996(EphTime t, double UT1mUTC, bool reduced = false);
 
      //------------------------------------------------------------------------------
      static double GAST2003(EphTime t, double UT1mUTC);
 
      //------------------------------------------------------------------------------
      static double GAST2010(EphTime t, double UT1mUTC);
 
      //------------------------------------------------------------------------------
      static Matrix<double> polarMotionMatrix1996(double xp, double yp);
 
      //------------------------------------------------------------------------------
      static Matrix<double> polarMotionMatrix2003(EphTime t, double xp,
                                                  double yp);
 
      //------------------------------------------------------------------------------
      static void FukushimaWilliams(double T, double& gamb, double& phib,
                                    double& psib, double& eps);
 
      //------------------------------------------------------------------------------
      static Matrix<double> FukushimaWilliams(double gamb, double phib,
                                              double psib, double epsa);
 
      //------------------------------------------------------------------------------
      static void nutationAngles1996(double T, double& deps, double& dpsi,
                                     double& om);
 
      //------------------------------------------------------------------------------
      static void nutationAngles2003(double T, double& deps,
                                     double& dpsi);
 
      //------------------------------------------------------------------------------
      static void nutationAngles2010(double T, double& deps,
                                     double& dpsi);
 
      //------------------------------------------------------------------------------
      static Matrix<double> nutationMatrix(double eps, double dpsi,
                                           double deps);
 
      //------------------------------------------------------------------------------
      static Matrix<double> nutationMatrix1996(double T);
 
      //------------------------------------------------------------------------------
      static Matrix<double> nutationMatrix2003(double T);
 
      //------------------------------------------------------------------------------
      static Matrix<double> nutationMatrix2010(double T);
 
      //------------------------------------------------------------------------------
      static Matrix<double> precessionMatrix1996(double T);
 
      //------------------------------------------------------------------------------
      static Matrix<double> precessionMatrix2003(double T);
 
      //------------------------------------------------------------------------------
      static void precessionRateCorrections2003(double T, double& dpsi,
                                                double& deps);
 
      //------------------------------------------------------------------------------
      static Matrix<double> biasMatrix2010();
 
      //------------------------------------------------------------------------------
      static Matrix<double> precessionMatrix2010(double T);
 
      //------------------------------------------------------------------------------
      static Matrix<double> preciseEarthRotation2003(double T);
 
      //------------------------------------------------------------------------------
      static Matrix<double> preciseEarthRotation2010(double T);
 
      //------------------------------------------------------------------------------
      Matrix<double> ECEFtoInertial1996(EphTime t, double xp, double yp,
                                        double UT1mUTC, bool reduced = false);
 
      //------------------------------------------------------------------------------
      Matrix<double> ECEFtoInertial2003(EphTime t, double xp, double yp,
                                        double UT1mUTC);
 
      //------------------------------------------------------------------------------
      Matrix<double> ECEFtoInertial2010(EphTime t, double xp, double yp,
                                        double UT1mUTC);
 
   }; // end class EarthOrientation
 
} // end namespace gnsstk
 
#endif // CLASS_EARTHORIENT_INCLUDE