GravityModel.hpp

Go to the documentation of this file.

 
#if !defined(GEOGRAPHICLIB_GRAVITYMODEL_HPP)
#define GEOGRAPHICLIB_GRAVITYMODEL_HPP 1
 
#include <GeographicLib/Constants.hpp>
#include <GeographicLib/NormalGravity.hpp>
#include <GeographicLib/SphericalHarmonic.hpp>
#include <GeographicLib/SphericalHarmonic1.hpp>
 
#if defined(_MSC_VER)
// Squelch warnings about dll vs vector
#  pragma warning (push)
#  pragma warning (disable: 4251)
#endif
 
namespace GeographicLib {
 
  class GravityCircle;
 
  class GEOGRAPHICLIB_EXPORT GravityModel {
  private:
    typedef Math::real real;
    friend class GravityCircle;
    static const int idlength_ = 8;
    std::string _name, _dir, _description, _date, _filename, _id;
    real _amodel, _GMmodel, _zeta0, _corrmult;
    SphericalHarmonic::normalization _norm;
    NormalGravity _earth;
    std::vector<real> _Cx, _Sx, _CC, _CS, _zonal;
    real _dzonal0;              // A left over contribution to _zonal.
    SphericalHarmonic _gravitational;
    SphericalHarmonic1 _disturbing;
    SphericalHarmonic _correction;
    void ReadMetadata(const std::string& name);
    Math::real InternalT(real X, real Y, real Z,
                         real& deltaX, real& deltaY, real& deltaZ,
                         bool gradp, bool correct) const;
    GravityModel(const GravityModel&); // copy constructor not allowed
    GravityModel& operator=(const GravityModel&); // nor copy assignment
 
    enum captype {
      CAP_NONE   = 0U,
      CAP_G      = 1U<<0,       // implies potentials W and V
      CAP_T      = 1U<<1,
      CAP_DELTA  = 1U<<2 | CAP_T, // delta implies T?
      CAP_C      = 1U<<3,
      CAP_GAMMA0 = 1U<<4,
      CAP_GAMMA  = 1U<<5,
      CAP_ALL    = 0x3FU,
    };
 
  public:
 
    enum mask {
      NONE = 0U,
      GRAVITY = CAP_G,
      DISTURBANCE = CAP_DELTA,
      DISTURBING_POTENTIAL = CAP_T,
      SPHERICAL_ANOMALY = CAP_DELTA | CAP_GAMMA,
      GEOID_HEIGHT = CAP_T | CAP_C | CAP_GAMMA0,
      ALL = CAP_ALL,
    };
 
    explicit GravityModel(const std::string& name,
                          const std::string& path = "");
 
 
    Math::real Gravity(real lat, real lon, real h,
                       real& gx, real& gy, real& gz) const;
 
    Math::real Disturbance(real lat, real lon, real h,
                           real& deltax, real& deltay, real& deltaz)
      const;
 
    Math::real GeoidHeight(real lat, real lon) const;
 
    void SphericalAnomaly(real lat, real lon, real h,
                          real& Dg01, real& xi, real& eta) const;
 
 
    Math::real W(real X, real Y, real Z,
                 real& gX, real& gY, real& gZ) const;
 
    Math::real V(real X, real Y, real Z,
                 real& GX, real& GY, real& GZ) const;
 
    Math::real T(real X, real Y, real Z,
                 real& deltaX, real& deltaY, real& deltaZ) const
    { return InternalT(X, Y, Z, deltaX, deltaY, deltaZ, true, true); }
 
    Math::real T(real X, real Y, real Z) const {
      real dummy;
      return InternalT(X, Y, Z, dummy, dummy, dummy, false, true);
    }
 
    Math::real U(real X, real Y, real Z,
                 real& gammaX, real& gammaY, real& gammaZ) const
    { return _earth.U(X, Y, Z, gammaX, gammaY, gammaZ); }
 
    Math::real Phi(real X, real Y, real& fX, real& fY) const
    { return _earth.Phi(X, Y, fX, fY); }
 
 
    GravityCircle Circle(real lat, real h, unsigned caps = ALL) const;
 
 
    const NormalGravity& ReferenceEllipsoid() const { return _earth; }
 
    const std::string& Description() const { return _description; }
 
    const std::string& DateTime() const { return _date; }
 
    const std::string& GravityFile() const { return _filename; }
 
    const std::string& GravityModelName() const { return _name; }
 
    const std::string& GravityModelDirectory() const { return _dir; }
 
    Math::real MajorRadius() const { return _earth.MajorRadius(); }
 
    Math::real MassConstant() const { return _GMmodel; }
 
    Math::real ReferenceMassConstant() const
    { return _earth.MassConstant(); }
 
    Math::real AngularVelocity() const
    { return _earth.AngularVelocity(); }
 
    Math::real Flattening() const { return _earth.Flattening(); }
 
    static std::string DefaultGravityPath();
 
    static std::string DefaultGravityName();
  };
 
} // namespace GeographicLib
 
#if defined(_MSC_VER)
#  pragma warning (pop)
#endif
 
#endif  // GEOGRAPHICLIB_GRAVITYMODEL_HPP