GravityCircle.hpp

Go to the documentation of this file.

#if !defined(GEOGRAPHICLIB_GRAVITYCIRCLE_HPP)
#define GEOGRAPHICLIB_GRAVITYCIRCLE_HPP 1

#include <vector>
#include <GeographicLib/Constants.hpp>
#include <GeographicLib/CircularEngine.hpp>
#include <GeographicLib/GravityModel.hpp>

namespace GeographicLib {

  class GEOGRAPHICLIB_EXPORT GravityCircle {
  private:
    typedef Math::real real;
    enum mask {
      NONE                 = GravityModel::NONE,
      GRAVITY              = GravityModel::GRAVITY,
      DISTURBANCE          = GravityModel::DISTURBANCE,
      DISTURBING_POTENTIAL = GravityModel::DISTURBING_POTENTIAL,
      GEOID_HEIGHT         = GravityModel::GEOID_HEIGHT,
      SPHERICAL_ANOMALY    = GravityModel::SPHERICAL_ANOMALY,
      ALL                  = GravityModel::ALL,
    };

    unsigned _caps;
    real _a, _f, _lat, _h, _Z, _Px, _invR, _cpsi, _spsi,
      _cphi, _sphi, _amodel, _GMmodel, _dzonal0,
      _corrmult, _gamma0, _gamma, _frot;
    CircularEngine _gravitational, _disturbing, _correction;

    GravityCircle(mask caps, real a, real f, real lat, real h,
                  real Z, real P, real cphi, real sphi,
                  real amodel, real GMmodel, real dzonal0, real corrmult,
                  real gamma0, real gamma, real frot,
                  const CircularEngine& gravitational,
                  const CircularEngine& disturbing,
                  const CircularEngine& correction)
      : _caps(caps)
      , _a(a)
      , _f(f)
      , _lat(Math::LatFix(lat))
      , _h(h)
      , _Z(Z)
      , _Px(P)
      , _invR(1 / Math::hypot(_Px, _Z))
      , _cpsi(_Px * _invR)
      , _spsi(_Z * _invR)
      , _cphi(cphi)
      , _sphi(sphi)
      , _amodel(amodel)
      , _GMmodel(GMmodel)
      , _dzonal0(dzonal0)
      , _corrmult(corrmult)
      , _gamma0(gamma0)
      , _gamma(gamma)
      , _frot(frot)
      , _gravitational(gravitational)
      , _disturbing(disturbing)
      , _correction(correction)
    {}

    friend class GravityModel; // GravityModel calls the private constructor
    Math::real W(real slam, real clam,
                 real& gX, real& gY, real& gZ) const;
    Math::real V(real slam, real clam,
                 real& gX, real& gY, real& gZ) const;
    Math::real InternalT(real slam, real clam,
                         real& deltaX, real& deltaY, real& deltaZ,
                         bool gradp, bool correct) const;
  public:
    GravityCircle() : _a(-1) {}


    Math::real Gravity(real lon, real& gx, real& gy, real& gz) const;

    Math::real Disturbance(real lon, real& deltax, real& deltay, real& deltaz)
      const;

    Math::real GeoidHeight(real lon) const;

    void SphericalAnomaly(real lon, real& Dg01, real& xi, real& eta)
      const;

    Math::real W(real lon, real& gX, real& gY, real& gZ) const {
      real slam, clam;
      Math::sincosd(lon, slam, clam);
      return W(slam, clam, gX, gY, gZ);
    }

    Math::real V(real lon, real& GX, real& GY, real& GZ) const {
      real slam, clam;
      Math::sincosd(lon, slam, clam);
      return V(slam, clam, GX, GY, GZ);
    }

    Math::real T(real lon, real& deltaX, real& deltaY, real& deltaZ)
      const {
      real slam, clam;
      Math::sincosd(lon, slam, clam);
      return InternalT(slam, clam, deltaX, deltaY, deltaZ, true, true);
    }

    Math::real T(real lon) const {
      real slam, clam, dummy;
      Math::sincosd(lon, slam, clam);
      return InternalT(slam, clam, dummy, dummy, dummy, false, true);
    }



    bool Init() const { return _a > 0; }

    Math::real MajorRadius() const
    { return Init() ? _a : Math::NaN(); }

    Math::real Flattening() const
    { return Init() ? _f : Math::NaN(); }

    Math::real Latitude() const
    { return Init() ? _lat : Math::NaN(); }

    Math::real Height() const
    { return Init() ? _h : Math::NaN(); }

    unsigned Capabilities() const { return _caps; }

    bool Capabilities(unsigned testcaps) const {
      return (_caps & testcaps) == testcaps;
    }
  };

} // namespace GeographicLib

#endif  // GEOGRAPHICLIB_GRAVITYCIRCLE_HPP