geodeticframes.hpp

一个gps小工具包

      static double CoordTransTime(DayTime t)
         throw();

      //------------------------------------------------------------------------------
      /// Compute the mean longitude of lunar ascending node, in degrees,
      /// given T, the CoordTransTime at the time of interest.
      /// @param T coordinate transformation time.
      /// @return Omega in degrees.
      static double Omega(double T)
         throw();

      //------------------------------------------------------------------------------
      /// Compute the mean longitude of the moon minus Omega, in degrees,
      /// given T, the CoordTransTime at the time of interest.
      /// @param T coordinate transformation time.
      /// @return F in degrees.
      static double F(double T)
         throw();

      //------------------------------------------------------------------------------
      /// Compute the mean elongation of the moon from the sun, in degrees,
      /// given T, the CoordTransTime at the time of interest.
      /// @param T coordinate transformation time.
      /// @return D in degrees.
      static double D(double T)
         throw();

      //------------------------------------------------------------------------------
      /// Compute the mean anomaly of the moon, in degrees,
      /// given T, the CoordTransTime at the time of interest.
      /// @param T coordinate transformation time.
      /// @return L in degrees.
      static double L(double T)
         throw();

      //------------------------------------------------------------------------------
      /// Compute the mean anomaly of the sun, in degrees,
      /// given T, the CoordTransTime at the time of interest.
      /// @param T coordinate transformation time.
      /// @return Lp in degrees.
      static double Lp(double T)
         throw();

      //------------------------------------------------------------------------------
      /// Compute the obliquity of the ecliptic, in degrees,
      /// given T, the CoordTransTime at the time of interest.
      /// @param T coordinate transformation time.
      /// @return eps in degrees.
      static double Obliquity(double T)
         throw();

      //------------------------------------------------------------------------------
      /// Nutation of the obliquity (deps) and of the longitude (dpsi), IERS 1996
      /// model (ref pg 26), given
      /// @param T,    the coordinate transformation time at the time of interest
      /// @param deps, nutation of the obliquity (output)
      /// @param dpsi, nutation of the longitude (output)
      static void NutationAngles(double T,
                                 double& deps,
                                 double& dpsi)
         throw();

      //------------------------------------------------------------------------------
      /// Zonal tide terms for corrections of UT1mUTC when that quantity does not
      /// include tides (e.g. NGA EOP), ref. IERS 1996 Ch. 8, table 8.1 pg 74.
      /// @param T,    the coordinate transformation time at the time of interest
      /// @param UT1mUT1R, the correction to UT1mUTC (seconds)
      /// @param dlodR, the correction to the length of day (seconds)
      /// @param domegaR, the correction to the Earth rotation rate, rad/second.
      static void UT1mUTCTidalCorrections(double T,
                                          double& UT1mUTR,
                                          double& dlodR,
                                          double& domegaR)
         throw();

      //------------------------------------------------------------------------------
      /// Compute the Greenwich hour angle of the true vernal equinox, or
      /// Greenwich Apparent Sidereal Time, in radians, given the (UT) time of
      /// interest t, and, where T = CoordTransTime(t),
      /// om  = Omega(T) = mean longitude of lunar ascending node, in degrees,
      /// ep = Obliquity(T) = the obliquity of the ecliptic, in degrees,
      /// dp = nutation in longitude (counted in the ecliptic),
      ///                in seconds of arc.
      ///
      /// GAST = Greenwich hour angle of the true vernal equinox
      ///      = Greenwich apparent sidereal time
      ///      = GMST + dpsi*cos(eps) + 0.00264"*sin(Omega) + 0.000063"*sin(2*Omega)
      ///    (these terms account for the accumulated precession and nutation in
      ///       right ascension and minimize any discontinuity in UT1)
      ///
      /// GMST = Greenwich hour angle of the mean vernal equinox
      ///      = Greenwich mean sidereal time
      ///      = GMST0 + r*[UTC + (UT1-UTC)]
      /// r    = is the ratio of universal to sidereal time
      ///      = 1.002737909350795 + 5.9006E-11*T' - 5.9e-15*T'^2
      /// T'   = days'/36525
      /// days'= number of days elapsed since t0 = +/-(integer+0.5)
      ///    and
      /// (UT1-UTC) (seconds) is taken from the IERS bulletin 
      ///
      /// GMST0 = GMST at 0h UT1
      ///      = 6h 41m (50.54841+8640184.812866*T'+0.093104*T'^2-6.2E-6*T'^3)s
      ///
      /// @param t DayTime time of interest.
      /// @param om, Omega(T), mean longitude of lunar ascending node, in degrees,
      /// @param eps, Obliquity(T), the obliquity of the ecliptic, in degrees,
      /// @param dpsi, nutation in longitude (counted in the ecliptic),
      ///                       in seconds of arc
      /// @param UT1mUTC,  UT1-UTC in seconds, as found in the IERS bulletin.
      static double gast(DayTime t,
                         double om,
                         double eps,
                         double dpsi,
                         double UT1mUTC)
         throw();

      //------------------------------------------------------------------------------
      /// Compute the precession matrix, a 3x3 rotation matrix, given
      /// @param T, the coordinate transformation time at the time of interest
      /// @return precession matrix Matrix<double>(3,3)
      static Matrix<double> PrecessionMatrix(double T)
         throw(InvalidRequest);

      //------------------------------------------------------------------------------
      /// Nutation model IAU76 (ref McCarthy), compute the nutation matrix,
      /// a 3x3 rotation matrix, given
      /// @param ep, Obliquity(T), the obliquity of the ecliptic, in degrees,
      /// @param dp, dpsi(T), the nutation in longitude (counted in the ecliptic),
      ///        in seconds of arc, and
      /// @param de, the nutation in obliquity, in seconds of arc.
      /// @return nutation matrix Matrix<double>(3,3)
      static Matrix<double> NutationMatrix(double eps,
                                           double dpsi,
                                           double deps)
         throw(InvalidRequest);

   public:

      //------------------------------------------------------------------------------
      // public functions
      //------------------------------------------------------------------------------
      /// Compute Greenwich Mean Sidereal Time, or the Greenwich hour angle of
      /// the mean vernal equinox, given the coordinate time of interest,
      /// and UT1-UTC (sec), which comes from the IERS bulletin.
      /// @param t DayTime epoch of the rotation.
      /// @param UT1mUTC, UT1-UTC in seconds, as found in the IERS bulletin.
      /// @param reduced, bool true when UT1mUTC is 'reduced', meaning assumes
      ///                 'no tides', as is the case with the NGA EOPs (default=F).
      static double GMST(DayTime t,
                         double UT1mUTC,
                         bool reduced=false)
         throw();

      //------------------------------------------------------------------------------
      /// Compute Greenwich Apparent Sidereal Time, or the Greenwich hour angle of
      /// the true vernal equinox, given the coordinate time of interest,
      /// and UT1-UTC (sec), which comes from the IERS bulletin.
      /// @param t DayTime epoch of the rotation.
      /// @param UT1mUTC, UT1-UTC in seconds, as found in the IERS bulletin.
      /// @param reduced, bool true when UT1mUTC is 'reduced', meaning assumes
      ///                 'no tides', as is the case with the NGA EOPs (default=F).
      static double GAST(DayTime t,
                         double UT1mUTC,
                         bool reduced=false)
         throw();

      //------------------------------------------------------------------------------
      /// Generate transformation matrix (3X3 rotation) due to the polar motion
      /// angles xp and yp (arcseconds), as found in the IERS bulletin;
      /// see class EarthOrientation.
      /// @param xp, Earth wobble in arcseconds, as found in the IERS bulletin.
      /// @param yp, Earth wobble in arcseconds, as found in the IERS bulletin.
      static Matrix<double> PolarMotion(double xp,
                                        double yp)
         throw(InvalidRequest);

      //------------------------------------------------------------------------------
      /// Generate precise transformation matrix (3X3 rotation) due to Earth rotation
      /// at Greenwich hour angle of the true vernal equinox and which accounts for
      /// precession and nutation in right ascension, given the UT time of interest
      /// and the UT1-UTC correction (in sec), obtained from the IERS bulletin.
      /// @param t DayTime epoch of the rotation.
      /// @param UT1mUTC, UT1-UTC in seconds, as found in the IERS bulletin.
      /// @return 3x3 rotation matrix
      static Matrix<double> PreciseEarthRotation(DayTime t,
                                                 double UT1mUTC,
                                                 bool reduced=false)
         throw(InvalidRequest);

      //------------------------------------------------------------------------------
      /// Generate an Earth Precession Matrix (3X3 rotation) at the given DayTime.
      static Matrix<double> Precession(DayTime t)
         throw(InvalidRequest)
         { return PrecessionMatrix(CoordTransTime(t)); }

      //------------------------------------------------------------------------------
      /// Generate an Earth Nutation Matrix (3X3 rotation) at the given DayTime.
      /// @param t DayTime epoch of the rotation.
      /// @return 3x3 rotation matrix
      static Matrix<double> Nutation(DayTime t)
         throw(InvalidRequest);

      //------------------------------------------------------------------------------
      /// Generate the full transformation matrix (3x3 rotation) relating the ECEF
      /// frame to the conventional inertial frame
      /// throw(); Input is the time of interest,
      /// the polar motion angles xp and yp (arcseconds), and UT1-UTC (seconds)
      /// (xp,yp and UT1-UTC are just as found in the IERS bulletin);
      /// see class EarthOrientation.
      /// @param t DayTime epoch of the rotation.
      /// @param xp, Earth wobble in arcseconds, as found in the IERS bulletin.
      /// @param yp, Earth wobble in arcseconds, as found in the IERS bulletin.
      /// @param UT1mUTC, UT1-UTC in seconds, as found in the IERS bulletin.
      /// @param reduced, bool true when UT1mUTC is 'reduced', meaning assumes
      ///                 'no tides', as is the case with the NGA EOPs (default=F).
      /// @return 3x3 rotation matrix
      static Matrix<double> ECEFtoInertial(DayTime t,
                                           double xp,
                                           double yp,
                                           double UT1mUTC,
                                           bool reduced=false)
         throw(InvalidRequest);

      //------------------------------------------------------------------------------
      /// Given a rotation matrix R (3x3), find the Euler angles (theta,phi,psi) which
      /// produce this rotation, and also determine the magnitude alpha and direction
      /// nhat (= unit 3-vector) of the net rotation.
      /// Throw InvalidRequest if the matrix is not a rotation matrix.
      static void ResolveRotation(const Matrix<double>& R,
                                  double& theta,
                                  double& phi,
                                  double& psi,
                                  double& alpha,
                                  Vector<double>& nhat)
         throw(InvalidRequest);

   }; // end class GeodeticFrames

} // end namespace gpstk

#endif  // nothing below this...