geographiclib 0.0.1

data/ext/geographiclib/Georef.cpp

@@ -0,0 +1,135 @@
+/**
+ * \file Georef.cpp
+ * \brief Implementation for GeographicLib::Georef class
+ *
+ * Copyright (c) Charles Karney (2015) <charles@karney.com> and licensed under
+ * the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#include <GeographicLib/Georef.hpp>
+#include <GeographicLib/Utility.hpp>
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  const string Georef::digits_ = "0123456789";
+  const string Georef::lontile_ = "ABCDEFGHJKLMNPQRSTUVWXYZ";
+  const string Georef::lattile_ = "ABCDEFGHJKLM";
+  const string Georef::degrees_ = "ABCDEFGHJKLMNPQ";
+
+  void Georef::Forward(real lat, real lon, int prec, std::string& georef) {
+    if (abs(lat) > 90)
+      throw GeographicErr("Latitude " + Utility::str(lat)
+                          + "d not in [-90d, 90d]");
+    if (Math::isnan(lat) || Math::isnan(lon)) {
+      georef = "INVALID";
+      return;
+    }
+    lon = Math::AngNormalize(lon); // lon in [-180,180)
+    if (lat == 90) lat *= (1 - numeric_limits<real>::epsilon() / 2);
+    prec = max(-1, min(int(maxprec_), prec));
+    if (prec == 1) ++prec;      // Disallow prec = 1
+    // The C++ standard mandates 64 bits for long long.  But
+    // check, to make sure.
+    GEOGRAPHICLIB_STATIC_ASSERT(numeric_limits<long long>::digits >= 45,
+                                "long long not wide enough to store 21600e9");
+    const long long m = 60000000000LL;
+    long long
+      x = (long long)(floor(lon * m)) - lonorig_ * m,
+      y = (long long)(floor(lat * m)) - latorig_ * m;
+    int ilon = int(x / m); int ilat = int(y / m);
+    char georef1[maxlen_];
+    georef1[0] = lontile_[ilon / tile_];
+    georef1[1] = lattile_[ilat / tile_];
+    if (prec >= 0) {
+      georef1[2] = degrees_[ilon % tile_];
+      georef1[3] = degrees_[ilat % tile_];
+      if (prec > 0) {
+        x -= m * ilon; y -= m * ilat;
+        long long d = (long long)pow(real(base_), maxprec_ - prec);
+        x /= d; y /= d;
+        for (int c = prec; c--;) {
+          georef1[baselen_ + c       ] = digits_[x % base_]; x /= base_;
+          georef1[baselen_ + c + prec] = digits_[y % base_]; y /= base_;
+        }
+      }
+    }
+    georef.resize(baselen_ + 2 * prec);
+    copy(georef1, georef1 + baselen_ + 2 * prec, georef.begin());
+  }
+
+  void Georef::Reverse(const std::string& georef, real& lat, real& lon,
+                        int& prec, bool centerp) {
+    int len = int(georef.length());
+    if (len >= 3 &&
+        toupper(georef[0]) == 'I' &&
+        toupper(georef[1]) == 'N' &&
+        toupper(georef[2]) == 'V') {
+      lat = lon = Math::NaN();
+      return;
+    }
+    if (len < baselen_ - 2)
+      throw GeographicErr("Georef must start with at least 2 letters "
+                          + georef);
+    int prec1 = (2 + len - baselen_) / 2 - 1;
+    int k;
+    k = Utility::lookup(lontile_, georef[0]);
+    if (k < 0)
+      throw GeographicErr("Bad longitude tile letter in georef " + georef);
+    real lon1 = k + lonorig_ / tile_;
+    k = Utility::lookup(lattile_, georef[1]);
+    if (k < 0)
+      throw GeographicErr("Bad latitude tile letter in georef " + georef);
+    real lat1 = k + latorig_ / tile_;
+    real unit = 1;
+    if (len > 2) {
+      unit *= tile_;
+      k = Utility::lookup(degrees_, georef[2]);
+      if (k < 0)
+        throw GeographicErr("Bad longitude degree letter in georef " + georef);
+      lon1 = lon1 * tile_ + k;
+      if (len < 4)
+        throw GeographicErr("Missing latitude degree letter in georef "
+                            + georef);
+      k = Utility::lookup(degrees_, georef[3]);
+      if (k < 0)
+        throw GeographicErr("Bad latitude degree letter in georef " + georef);
+      lat1 = lat1 * tile_ + k;
+      if (prec1 > 0) {
+        if (georef.find_first_not_of(digits_, baselen_) != string::npos)
+          throw GeographicErr("Non digits in trailing portion of georef "
+                              + georef.substr(baselen_));
+        if (len % 2)
+          throw GeographicErr("Georef must end with an even number of digits "
+                              + georef.substr(baselen_));
+        if (prec1 == 1)
+          throw GeographicErr("Georef needs at least 4 digits for minutes "
+                              + georef.substr(baselen_));
+        if (prec1 > maxprec_)
+          throw GeographicErr("More than " + Utility::str(2*maxprec_)
+                              + " digits in georef " + georef.substr(baselen_));
+        for (int i = 0; i < prec1; ++i) {
+          int m = i ? base_ : 6;
+          unit *= m;
+          int
+            x = Utility::lookup(digits_, georef[baselen_ + i]),
+            y = Utility::lookup(digits_, georef[baselen_ + i + prec1]);
+          if (!(i || (x < m && y < m)))
+            throw GeographicErr("Minutes terms in georef must be less than 60 "
+                                + georef.substr(baselen_));
+          lon1 = m * lon1 + x;
+          lat1 = m * lat1 + y;
+        }
+      }
+    }
+    if (centerp) {
+      unit *= 2; lat1 = 2 * lat1 + 1; lon1 = 2 * lon1 + 1;
+    }
+    lat = (tile_ * lat1) / unit;
+    lon = (tile_ * lon1) / unit;
+    prec = prec1;
+  }
+
+} // namespace GeographicLib

data/ext/geographiclib/Gnomonic.cpp

@@ -0,0 +1,85 @@
+/**
+ * \file Gnomonic.cpp
+ * \brief Implementation for GeographicLib::Gnomonic class
+ *
+ * Copyright (c) Charles Karney (2010-2015) <charles@karney.com> and licensed
+ * under the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#include <GeographicLib/Gnomonic.hpp>
+
+#if defined(_MSC_VER)
+// Squelch warnings about potentially uninitialized local variables and
+// constant conditional expressions
+#  pragma warning (disable: 4701 4127)
+#endif
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  Gnomonic::Gnomonic(const Geodesic& earth)
+    : eps0_(numeric_limits<real>::epsilon())
+    , eps_(real(0.01) * sqrt(eps0_))
+    , _earth(earth)
+    , _a(_earth.MajorRadius())
+    , _f(_earth.Flattening())
+  {}
+
+  void Gnomonic::Forward(real lat0, real lon0, real lat, real lon,
+                         real& x, real& y, real& azi, real& rk)
+    const {
+    real azi0, m, M, t;
+    _earth.GenInverse(lat0, lon0, lat, lon,
+                      Geodesic::AZIMUTH | Geodesic::REDUCEDLENGTH |
+                      Geodesic::GEODESICSCALE,
+                      t, azi0, azi, m, M, t, t);
+    rk = M;
+    if (M <= 0)
+      x = y = Math::NaN();
+    else {
+      real rho = m/M;
+      Math::sincosd(azi0, x, y);
+      x *= rho; y *= rho;
+    }
+  }
+
+  void Gnomonic::Reverse(real lat0, real lon0, real x, real y,
+                         real& lat, real& lon, real& azi, real& rk)
+    const {
+    real
+      azi0 = Math::atan2d(x, y),
+      rho = Math::hypot(x, y),
+      s = _a * atan(rho/_a);
+    bool little = rho <= _a;
+    if (!little)
+      rho = 1/rho;
+    GeodesicLine line(_earth.Line(lat0, lon0, azi0,
+                                  Geodesic::LATITUDE | Geodesic::LONGITUDE |
+                                  Geodesic::AZIMUTH | Geodesic::DISTANCE_IN |
+                                  Geodesic::REDUCEDLENGTH |
+                                  Geodesic::GEODESICSCALE));
+    int count = numit_, trip = 0;
+    real lat1, lon1, azi1, M;
+    while (count-- || GEOGRAPHICLIB_PANIC) {
+      real m, t;
+      line.Position(s, lat1, lon1, azi1, m, M, t);
+      if (trip)
+        break;
+      // If little, solve rho(s) = rho with drho(s)/ds = 1/M^2
+      // else solve 1/rho(s) = 1/rho with d(1/rho(s))/ds = -1/m^2
+      real ds = little ? (m/M - rho) * M * M : (rho - M/m) * m * m;
+      s -= ds;
+      // Reversed test to allow escape with NaNs
+      if (!(abs(ds) >= eps_ * _a))
+        ++trip;
+    }
+    if (trip) {
+      lat = lat1; lon = lon1; azi = azi1; rk = M;
+    } else
+      lat = lon = azi = rk = Math::NaN();
+    return;
+  }
+
+} // namespace GeographicLib

data/ext/geographiclib/GravityCircle.cpp

@@ -0,0 +1,129 @@
+/**
+ * \file GravityCircle.cpp
+ * \brief Implementation for GeographicLib::GravityCircle class
+ *
+ * Copyright (c) Charles Karney (2011-2015) <charles@karney.com> and licensed
+ * under the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#include <GeographicLib/GravityCircle.hpp>
+#include <fstream>
+#include <sstream>
+#include <GeographicLib/Geocentric.hpp>
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  Math::real GravityCircle::Gravity(real lon, real& gx, real& gy, real& gz)
+    const {
+    real slam, clam, M[Geocentric::dim2_];
+    Math::sincosd(lon, slam, clam);
+    real Wres = W(slam, clam, gx, gy, gz);
+    Geocentric::Rotation(_sphi, _cphi, slam, clam, M);
+    Geocentric::Unrotate(M, gx, gy, gz, gx, gy, gz);
+    return Wres;
+  }
+
+  Math::real GravityCircle::Disturbance(real lon, real& deltax, real& deltay,
+                                        real& deltaz) const {
+    real slam, clam, M[Geocentric::dim2_];
+    Math::sincosd(lon, slam, clam);
+    real Tres = InternalT(slam, clam, deltax, deltay, deltaz, true, true);
+    Geocentric::Rotation(_sphi, _cphi, slam, clam, M);
+    Geocentric::Unrotate(M, deltax, deltay, deltaz, deltax, deltay, deltaz);
+    return Tres;
+  }
+
+  Math::real GravityCircle::GeoidHeight(real lon) const {
+    if ((_caps & GEOID_HEIGHT) != GEOID_HEIGHT)
+      return Math::NaN();
+    real slam, clam, dummy;
+    Math::sincosd(lon, slam, clam);
+    real T = InternalT(slam, clam, dummy, dummy, dummy, false, false);
+    real correction = _corrmult * _correction(slam, clam);
+    return T/_gamma0 + correction;
+  }
+
+  void GravityCircle::SphericalAnomaly(real lon,
+                                       real& Dg01, real& xi, real& eta)
+    const {
+    if ((_caps & SPHERICAL_ANOMALY) != SPHERICAL_ANOMALY) {
+      Dg01 = xi = eta = Math::NaN();
+      return;
+    }
+    real slam, clam;
+    Math::sincosd(lon, slam, clam);
+    real
+      deltax, deltay, deltaz,
+      T = InternalT(slam, clam, deltax, deltay, deltaz, true, false);
+    // Rotate cartesian into spherical coordinates
+    real MC[Geocentric::dim2_];
+    Geocentric::Rotation(_spsi, _cpsi, slam, clam, MC);
+    Geocentric::Unrotate(MC, deltax, deltay, deltaz, deltax, deltay, deltaz);
+    // H+M, Eq 2-151c
+    Dg01 = - deltaz - 2 * T * _invR;
+    xi  = -(deltay/_gamma) / Math::degree();
+    eta = -(deltax/_gamma) / Math::degree();
+  }
+
+  Math::real GravityCircle::W(real slam, real clam,
+                              real& gX, real& gY, real& gZ) const {
+    real Wres = V(slam, clam, gX, gY, gZ) + _frot * _Px / 2;
+    gX += _frot * clam;
+    gY += _frot * slam;
+    return Wres;
+  }
+
+  Math::real GravityCircle::V(real slam, real clam,
+                              real& GX, real& GY, real& GZ)
+    const {
+    if ((_caps & GRAVITY) != GRAVITY) {
+      GX = GY = GZ = Math::NaN();
+      return Math::NaN();
+    }
+    real
+      Vres = _gravitational(slam, clam, GX, GY, GZ),
+      f = _GMmodel / _amodel;
+    Vres *= f;
+    GX *= f;
+    GY *= f;
+    GZ *= f;
+    return Vres;
+  }
+
+  Math::real GravityCircle::InternalT(real slam, real clam,
+                                      real& deltaX, real& deltaY, real& deltaZ,
+                                      bool gradp, bool correct) const {
+    if (gradp) {
+      if ((_caps & DISTURBANCE) != DISTURBANCE) {
+        deltaX = deltaY = deltaZ = Math::NaN();
+        return Math::NaN();
+      }
+    } else {
+      if ((_caps & DISTURBING_POTENTIAL) != DISTURBING_POTENTIAL)
+        return Math::NaN();
+    }
+    if (_dzonal0 == 0)
+      correct = false;
+    real T = (gradp
+              ? _disturbing(slam, clam, deltaX, deltaY, deltaZ)
+              : _disturbing(slam, clam));
+    T = (T / _amodel - (correct ? _dzonal0 : 0) * _invR) * _GMmodel;
+    if (gradp) {
+      real f = _GMmodel / _amodel;
+      deltaX *= f;
+      deltaY *= f;
+      deltaZ *= f;
+      if (correct) {
+        real r3 = _GMmodel * _dzonal0 * _invR * _invR * _invR;
+        deltaX += _Px * clam * r3;
+        deltaY += _Px * slam * r3;
+        deltaZ += _Z * r3;
+      }
+    }
+    return T;
+  }
+
+} // namespace GeographicLib

data/ext/geographiclib/GravityModel.cpp

@@ -0,0 +1,360 @@
+/**
+ * \file GravityModel.cpp
+ * \brief Implementation for GeographicLib::GravityModel class
+ *
+ * Copyright (c) Charles Karney (2011-2012) <charles@karney.com> and licensed
+ * under the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#include <GeographicLib/GravityModel.hpp>
+#include <fstream>
+#include <GeographicLib/SphericalEngine.hpp>
+#include <GeographicLib/GravityCircle.hpp>
+#include <GeographicLib/Utility.hpp>
+
+#if !defined(GEOGRAPHICLIB_DATA)
+#  if defined(_WIN32)
+#    define GEOGRAPHICLIB_DATA "C:/ProgramData/GeographicLib"
+#  else
+#    define GEOGRAPHICLIB_DATA "/usr/local/share/GeographicLib"
+#  endif
+#endif
+
+#if !defined(GEOGRAPHICLIB_GRAVITY_DEFAULT_NAME)
+#  define GEOGRAPHICLIB_GRAVITY_DEFAULT_NAME "egm96"
+#endif
+
+#if defined(_MSC_VER)
+// Squelch warnings about unsafe use of getenv
+#  pragma warning (disable: 4996)
+#endif
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  GravityModel::GravityModel(const std::string& name,const std::string& path)
+    : _name(name)
+    , _dir(path)
+    , _description("NONE")
+    , _date("UNKNOWN")
+    , _amodel(Math::NaN())
+    , _GMmodel(Math::NaN())
+    , _zeta0(0)
+    , _corrmult(1)
+    , _norm(SphericalHarmonic::FULL)
+  {
+    if (_dir.empty())
+      _dir = DefaultGravityPath();
+    ReadMetadata(_name);
+    {
+      string coeff = _filename + ".cof";
+      ifstream coeffstr(coeff.c_str(), ios::binary);
+      if (!coeffstr.good())
+        throw GeographicErr("Error opening " + coeff);
+      char id[idlength_ + 1];
+      coeffstr.read(id, idlength_);
+      if (!coeffstr.good())
+        throw GeographicErr("No header in " + coeff);
+      id[idlength_] = '\0';
+      if (_id != string(id))
+        throw GeographicErr("ID mismatch: " + _id + " vs " + id);
+      int N, M;
+      SphericalEngine::coeff::readcoeffs(coeffstr, N, M, _Cx, _Sx);
+      if (!(N >= 0 && M >= 0))
+        throw GeographicErr("Degree and order must be at least 0");
+      if (_Cx[0] != 0)
+        throw GeographicErr("A degree 0 term should be zero");
+      _Cx[0] = 1;               // Include the 1/r term in the sum
+      _gravitational = SphericalHarmonic(_Cx, _Sx, N, N, M, _amodel, _norm);
+      SphericalEngine::coeff::readcoeffs(coeffstr, N, M, _CC, _CS);
+      if (N < 0) {
+        N = M = 0;
+        _CC.resize(1, real(0));
+      }
+      _CC[0] += _zeta0 / _corrmult;
+      _correction = SphericalHarmonic(_CC, _CS, N, N, M, real(1), _norm);
+      int pos = int(coeffstr.tellg());
+      coeffstr.seekg(0, ios::end);
+      if (pos != coeffstr.tellg())
+        throw GeographicErr("Extra data in " + coeff);
+    }
+    int nmx = _gravitational.Coefficients().nmx();
+    // Adjust the normalization of the normal potential to match the model.
+    real mult = _earth._GM / _GMmodel;
+    real amult = Math::sq(_earth._a / _amodel);
+    // The 0th term in _zonal should be is 1 + _dzonal0.  Instead set it to 1
+    // to give exact cancellation with the (0,0) term in the model and account
+    // for _dzonal0 separately.
+    _zonal.clear(); _zonal.push_back(1);
+    _dzonal0 = (_earth.MassConstant() - _GMmodel) / _GMmodel;
+    for (int n = 2; n <= nmx; n += 2) {
+      // Only include as many normal zonal terms as matter.  Figuring the limit
+      // in this way works because the coefficients of the normal potential
+      // (which is smooth) decay much more rapidly that the corresponding
+      // coefficient of the model potential (which is bumpy).  Typically this
+      // goes out to n = 18.
+      mult *= amult;
+      real
+        r = _Cx[n],                                        // the model term
+        s = - mult * _earth.Jn(n) / sqrt(real(2 * n + 1)), // the normal term
+        t = r - s;                                         // the difference
+      if (t == r)               // the normal term is negligible
+        break;
+      _zonal.push_back(0);      // index = n - 1; the odd terms are 0
+      _zonal.push_back(s);
+    }
+    int nmx1 = int(_zonal.size()) - 1;
+    _disturbing = SphericalHarmonic1(_Cx, _Sx,
+                                     _gravitational.Coefficients().N(),
+                                     nmx, _gravitational.Coefficients().mmx(),
+                                     _zonal,
+                                     _zonal, // This is not accessed!
+                                     nmx1, nmx1, 0,
+                                     _amodel,
+                                     SphericalHarmonic1::normalization(_norm));
+  }
+
+  void GravityModel::ReadMetadata(const std::string& name) {
+    const char* spaces = " \t\n\v\f\r";
+    _filename = _dir + "/" + name + ".egm";
+    ifstream metastr(_filename.c_str());
+    if (!metastr.good())
+      throw GeographicErr("Cannot open " + _filename);
+    string line;
+    getline(metastr, line);
+    if (!(line.size() >= 6 && line.substr(0,5) == "EGMF-"))
+      throw GeographicErr(_filename + " does not contain EGMF-n signature");
+    string::size_type n = line.find_first_of(spaces, 5);
+    if (n != string::npos)
+      n -= 5;
+    string version = line.substr(5, n);
+    if (version != "1")
+      throw GeographicErr("Unknown version in " + _filename + ": " + version);
+    string key, val;
+    real a = Math::NaN(), GM = a, omega = a, f = a, J2 = a;
+    while (getline(metastr, line)) {
+      if (!Utility::ParseLine(line, key, val))
+        continue;
+      // Process key words
+      if (key == "Name")
+        _name = val;
+      else if (key == "Description")
+        _description = val;
+      else if (key == "ReleaseDate")
+        _date = val;
+      else if (key == "ModelRadius")
+        _amodel = Utility::num<real>(val);
+      else if (key == "ModelMass")
+        _GMmodel = Utility::num<real>(val);
+      else if (key == "AngularVelocity")
+        omega = Utility::num<real>(val);
+      else if (key == "ReferenceRadius")
+        a = Utility::num<real>(val);
+      else if (key == "ReferenceMass")
+        GM = Utility::num<real>(val);
+      else if (key == "Flattening")
+        f = Utility::fract<real>(val);
+      else if (key == "DynamicalFormFactor")
+        J2 = Utility::fract<real>(val);
+      else if (key == "HeightOffset")
+        _zeta0 = Utility::fract<real>(val);
+      else if (key == "CorrectionMultiplier")
+        _corrmult = Utility::fract<real>(val);
+      else if (key == "Normalization") {
+        if (val == "FULL" || val == "Full" || val == "full")
+          _norm = SphericalHarmonic::FULL;
+        else if (val == "SCHMIDT" || val == "Schmidt" || val == "schmidt")
+          _norm = SphericalHarmonic::SCHMIDT;
+        else
+          throw GeographicErr("Unknown normalization " + val);
+      } else if (key == "ByteOrder") {
+        if (val == "Big" || val == "big")
+          throw GeographicErr("Only little-endian ordering is supported");
+        else if (!(val == "Little" || val == "little"))
+          throw GeographicErr("Unknown byte ordering " + val);
+      } else if (key == "ID")
+        _id = val;
+      // else unrecognized keywords are skipped
+    }
+    // Check values
+    if (!(Math::isfinite(_amodel) && _amodel > 0))
+      throw GeographicErr("Model radius must be positive");
+    if (!(Math::isfinite(_GMmodel) && _GMmodel > 0))
+      throw GeographicErr("Model mass constant must be positive");
+    if (!(Math::isfinite(_corrmult) && _corrmult > 0))
+      throw GeographicErr("Correction multiplier must be positive");
+    if (!(Math::isfinite(_zeta0)))
+      throw GeographicErr("Height offset must be finite");
+    if (int(_id.size()) != idlength_)
+      throw GeographicErr("Invalid ID");
+    _earth = NormalGravity(a, GM, omega, f, J2);
+  }
+
+  Math::real GravityModel::InternalT(real X, real Y, real Z,
+                                     real& deltaX, real& deltaY, real& deltaZ,
+                                     bool gradp, bool correct) const {
+    // If correct, then produce the correct T = W - U.  Otherwise, neglect the
+    // n = 0 term (which is proportial to the difference in the model and
+    // reference values of GM).
+    if (_dzonal0 == 0)
+      // No need to do the correction
+      correct = false;
+    real T, invR = correct ? 1 / Math::hypot(Math::hypot(X, Y), Z) : 1;
+    if (gradp) {
+      // initial values to suppress warnings
+      deltaX = deltaY = deltaZ = 0;
+      T = _disturbing(-1, X, Y, Z, deltaX, deltaY, deltaZ);
+      real f = _GMmodel / _amodel;
+      deltaX *= f;
+      deltaY *= f;
+      deltaZ *= f;
+      if (correct) {
+        invR = _GMmodel * _dzonal0 * invR * invR * invR;
+        deltaX += X * invR;
+        deltaY += Y * invR;
+        deltaZ += Z * invR;
+      }
+    } else
+      T = _disturbing(-1, X, Y, Z);
+    T = (T / _amodel - (correct ? _dzonal0 : 0) * invR) * _GMmodel;
+    return T;
+  }
+
+  Math::real GravityModel::V(real X, real Y, real Z,
+                             real& GX, real& GY, real& GZ) const {
+    real
+      Vres = _gravitational(X, Y, Z, GX, GY, GZ),
+      f = _GMmodel / _amodel;
+    Vres *= f;
+    GX *= f;
+    GY *= f;
+    GZ *= f;
+    return Vres;
+  }
+
+  Math::real GravityModel::W(real X, real Y, real Z,
+                             real& gX, real& gY, real& gZ) const {
+    real fX, fY,
+      Wres = V(X, Y, Z, gX, gY, gZ) + _earth.Phi(X, Y, fX, fY);
+    gX += fX;
+    gY += fY;
+    return Wres;
+  }
+
+  void GravityModel::SphericalAnomaly(real lat, real lon, real h,
+                                      real& Dg01, real& xi, real& eta)
+    const {
+    real X, Y, Z, M[Geocentric::dim2_];
+    _earth.Earth().IntForward(lat, lon, h, X, Y, Z, M);
+    real
+      deltax, deltay, deltaz,
+      T = InternalT(X, Y, Z, deltax, deltay, deltaz, true, false),
+      clam = M[3], slam = -M[0],
+      P = Math::hypot(X, Y),
+      R = Math::hypot(P, Z),
+      // psi is geocentric latitude
+      cpsi = R ? P / R : M[7],
+      spsi = R ? Z / R : M[8];
+    // Rotate cartesian into spherical coordinates
+    real MC[Geocentric::dim2_];
+    Geocentric::Rotation(spsi, cpsi, slam, clam, MC);
+    Geocentric::Unrotate(MC, deltax, deltay, deltaz, deltax, deltay, deltaz);
+    // H+M, Eq 2-151c
+    Dg01 = - deltaz - 2 * T / R;
+    real gammaX, gammaY, gammaZ;
+    _earth.U(X, Y, Z, gammaX, gammaY, gammaZ);
+    real gamma = Math::hypot( Math::hypot(gammaX, gammaY), gammaZ);
+    xi  = -(deltay/gamma) / Math::degree();
+    eta = -(deltax/gamma) / Math::degree();
+  }
+
+  Math::real GravityModel::GeoidHeight(real lat, real lon) const
+  {
+    real X, Y, Z;
+    _earth.Earth().IntForward(lat, lon, 0, X, Y, Z, NULL);
+    real
+      gamma0 = _earth.SurfaceGravity(lat),
+      dummy,
+      T = InternalT(X, Y, Z, dummy, dummy, dummy, false, false),
+      invR = 1 / Math::hypot(Math::hypot(X, Y), Z),
+      correction = _corrmult * _correction(invR * X, invR * Y, invR * Z);
+    // _zeta0 has been included in _correction
+    return T/gamma0 + correction;
+  }
+
+  Math::real GravityModel::Gravity(real lat, real lon, real h,
+                                   real& gx, real& gy, real& gz) const {
+    real X, Y, Z, M[Geocentric::dim2_];
+    _earth.Earth().IntForward(lat, lon, h, X, Y, Z, M);
+    real Wres = W(X, Y, Z, gx, gy, gz);
+    Geocentric::Unrotate(M, gx, gy, gz, gx, gy, gz);
+    return Wres;
+  }
+  Math::real GravityModel::Disturbance(real lat, real lon, real h,
+                                       real& deltax, real& deltay, real& deltaz)
+    const {
+    real X, Y, Z, M[Geocentric::dim2_];
+    _earth.Earth().IntForward(lat, lon, h, X, Y, Z, M);
+    real Tres = InternalT(X, Y, Z, deltax, deltay, deltaz, true, true);
+    Geocentric::Unrotate(M, deltax, deltay, deltaz, deltax, deltay, deltaz);
+    return Tres;
+  }
+
+  GravityCircle GravityModel::Circle(real lat, real h, unsigned caps) const {
+    if (h != 0)
+      // Disallow invoking GeoidHeight unless h is zero.
+      caps &= ~(CAP_GAMMA0 | CAP_C);
+    real X, Y, Z, M[Geocentric::dim2_];
+    _earth.Earth().IntForward(lat, 0, h, X, Y, Z, M);
+    // Y = 0, cphi = M[7], sphi = M[8];
+    real
+      invR = 1 / Math::hypot(X, Z),
+      gamma0 = (caps & CAP_GAMMA0 ?_earth.SurfaceGravity(lat)
+                : Math::NaN()),
+      fx, fy, fz, gamma;
+    if (caps & CAP_GAMMA) {
+      _earth.U(X, Y, Z, fx, fy, fz); // fy = 0
+      gamma = Math::hypot(fx, fz);
+    } else
+      gamma = Math::NaN();
+    _earth.Phi(X, Y, fx, fy);
+    return GravityCircle(GravityCircle::mask(caps),
+                         _earth._a, _earth._f, lat, h, Z, X, M[7], M[8],
+                         _amodel, _GMmodel, _dzonal0, _corrmult,
+                         gamma0, gamma, fx,
+                         caps & CAP_G ?
+                         _gravitational.Circle(X, Z, true) :
+                         CircularEngine(),
+                         // N.B. If CAP_DELTA is set then CAP_T should be too.
+                         caps & CAP_T ?
+                         _disturbing.Circle(-1, X, Z, (caps & CAP_DELTA) != 0) :
+                         CircularEngine(),
+                         caps & CAP_C ?
+                         _correction.Circle(invR * X, invR * Z, false) :
+                         CircularEngine());
+  }
+
+  std::string GravityModel::DefaultGravityPath() {
+    string path;
+    char* gravitypath = getenv("GEOGRAPHICLIB_GRAVITY_PATH");
+    if (gravitypath)
+      path = string(gravitypath);
+    if (!path.empty())
+      return path;
+    char* datapath = getenv("GEOGRAPHICLIB_DATA");
+    if (datapath)
+      path = string(datapath);
+    return (!path.empty() ? path : string(GEOGRAPHICLIB_DATA)) + "/gravity";
+  }
+
+  std::string GravityModel::DefaultGravityName() {
+    string name;
+    char* gravityname = getenv("GEOGRAPHICLIB_GRAVITY_NAME");
+    if (gravityname)
+      name = string(gravityname);
+    return !name.empty() ? name : string(GEOGRAPHICLIB_GRAVITY_DEFAULT_NAME);
+  }
+
+} // namespace GeographicLib