NormalGravity.hpp

Go to the documentation of this file.

 
#if !defined(GEOGRAPHICLIB_NORMALGRAVITY_HPP)
#define GEOGRAPHICLIB_NORMALGRAVITY_HPP 1
 
#include <GeographicLib/Constants.hpp>
#include <GeographicLib/Geocentric.hpp>
 
namespace GeographicLib {
 
  class GEOGRAPHICLIB_EXPORT NormalGravity {
  private:
    static const int maxit_ = 20;
    typedef Math::real real;
    friend class GravityModel;
    real _a, _GM, _omega, _f, _J2, _omega2, _aomega2;
    real _e2, _ep2, _b, _E, _U0, _gammae, _gammap, _Q0, _k, _fstar;
    Geocentric _earth;
    static real atanzz(real x, bool alt) {
      // This routine obeys the identity
      //   atanzz(x, alt) = atanzz(-x/(1+x), !alt)
      //
      // Require x >= -1.  Best to call with alt, s.t. x >= 0; this results in
      // a call to atan, instead of asin, or to asinh, instead of atanh.
      using std::sqrt; using std::abs; using std::atan; using std::asin;
      real z = sqrt(abs(x));
      return x == 0 ? 1 :
        (alt ?
         (!(x < 0) ? Math::asinh(z) : asin(z)) / sqrt(abs(x) / (1 + x)) :
         (!(x < 0) ? atan(z) : Math::atanh(z)) / z);
    }
    static real atan7series(real x);
    static real atan5series(real x);
    static real Qf(real x, bool alt);
    static real Hf(real x, bool alt);
    static real QH3f(real x, bool alt);
    real Jn(int n) const;
    void Initialize(real a, real GM, real omega, real f_J2, bool geometricp);
  public:
 
 
    NormalGravity(real a, real GM, real omega, real f_J2,
                  bool geometricp = true);
    GEOGRAPHICLIB_DEPRECATED("Use new NormalGravity constructor")
    NormalGravity(real a, real GM, real omega, real f, real J2);
 
    NormalGravity() : _a(-1) {}
 
 
    Math::real SurfaceGravity(real lat) const;
 
    Math::real Gravity(real lat, real h, real& gammay, real& gammaz)
      const;
 
    Math::real U(real X, real Y, real Z,
                 real& gammaX, real& gammaY, real& gammaZ) const;
 
    Math::real V0(real X, real Y, real Z,
                  real& GammaX, real& GammaY, real& GammaZ) const;
 
    Math::real Phi(real X, real Y, real& fX, real& fY) const;
 
 
    bool Init() const { return _a > 0; }
 
    Math::real MajorRadius() const
    { return Init() ? _a : Math::NaN(); }
 
    Math::real MassConstant() const
    { return Init() ? _GM : Math::NaN(); }
 
    Math::real DynamicalFormFactor(int n = 2) const
    { return Init() ? ( n == 2 ? _J2 : Jn(n)) : Math::NaN(); }
 
    Math::real AngularVelocity() const
    { return Init() ? _omega : Math::NaN(); }
 
    Math::real Flattening() const
    { return Init() ? _f : Math::NaN(); }
 
    Math::real EquatorialGravity() const
    { return Init() ? _gammae : Math::NaN(); }
 
    Math::real PolarGravity() const
    { return Init() ? _gammap : Math::NaN(); }
 
    Math::real GravityFlattening() const
    { return Init() ? _fstar : Math::NaN(); }
 
    Math::real SurfacePotential() const
    { return Init() ? _U0 : Math::NaN(); }
 
    const Geocentric& Earth() const { return _earth; }
 
    static const NormalGravity& WGS84();
 
    static const NormalGravity& GRS80();
 
    static Math::real J2ToFlattening(real a, real GM, real omega, real J2);
 
    static Math::real FlatteningToJ2(real a, real GM, real omega, real f);
  };
 
} // namespace GeographicLib
 
#endif  // GEOGRAPHICLIB_NORMALGRAVITY_HPP