.NET wrapper for GeographicLib::NormalGravity. More...

#include <NormalGravity.h>

Public Types
enum	StandardModels { StandardModels::WGS84, StandardModels::GRS80 }
	The enumerated standard gravity models. More...

Public Member Functions
	~NormalGravity ()

Setting up the normal gravity
	NormalGravity (double a, double GM, double omega, double f_J2, bool geometricp)

	NormalGravity (StandardModels model)

	NormalGravity (const GeographicLib::NormalGravity &g)

Compute the gravity
double	SurfaceGravity (double lat)

double	Gravity (double lat, double h, [System::Runtime::InteropServices::Out] double%gammay, [System::Runtime::InteropServices::Out] double%gammaz)

double	U (double X, double Y, double Z, [System::Runtime::InteropServices::Out] double%gammaX, [System::Runtime::InteropServices::Out] double%gammaY, [System::Runtime::InteropServices::Out] double%gammaZ)

double	V0 (double X, double Y, double Z, [System::Runtime::InteropServices::Out] double%GammaX, [System::Runtime::InteropServices::Out] double%GammaY, [System::Runtime::InteropServices::Out] double%GammaZ)

double	Phi (double X, double Y, [System::Runtime::InteropServices::Out] double%fX, [System::Runtime::InteropServices::Out] double%fY)

Static Public Member Functions
static double	FlatteningToJ2 (double a, double GM, double omega, double f)

static NormalGravity	GRS80 ()

static double	J2ToFlattening (double a, double GM, double omega, double J2)

static NormalGravity	WGS84 ()

Private Member Functions
	!NormalGravity (void)

Private Attributes
const GeographicLib::NormalGravity *	m_pNormalGravity

Inspector functions
property double	MajorRadius { double get()

property double	MassConstant { double get()

property double	AngularVelocity { double get()

property double	Flattening { double get()

property double	EquatorialGravity { double get()

property double	PolarGravity { double get()

property double	GravityFlattening { double get()

property double	SurfacePotential { double get()

double	DynamicalFormFactor (int n)

Geocentric	Earth ()

Detailed Description

.NET wrapper for GeographicLib::NormalGravity.

This class allows .NET applications to access GeographicLib::NormalGravity.

"Normal" gravity refers to an idealization of the earth which is modeled as an rotating ellipsoid. The eccentricity of the ellipsoid, the rotation speed, and the distribution of mass within the ellipsoid are such that the surface of the ellipsoid is a surface of constant potential (gravitational plus centrifugal). The acceleration due to gravity is therefore perpendicular to the surface of the ellipsoid.

There is a closed solution to this problem which is implemented here. Series "approximations" are only used to evaluate certain combinations of elementary functions where use of the closed expression results in a loss of accuracy for small arguments due to cancellation of the two leading terms. However these series include sufficient terms to give full machine precision.

Definitions:

V₀, the gravitational contribution to the normal potential;
Φ, the rotational contribution to the normal potential;
U = V₀ + Φ, the total potential;
Γ = ∇V₀, the acceleration due to mass of the earth;
f = ∇Φ, the centrifugal acceleration;
γ = ∇U = Γ + f, the normal acceleration;
X, Y, Z, geocentric coordinates;
x, y, z, local cartesian coordinates used to denote the east, north and up directions.

References:

W. A. Heiskanen and H. Moritz, Physical Geodesy (Freeman, San Francisco, 1967), Secs. 1-19, 2-7, 2-8 (2-9, 2-10), 6-2 (6-3).
H. Moritz, Geodetic Reference System 1980, J. Geodesy 54(3), 395-405 (1980) https://doi.org/10.1007/BF02521480

C# Example:

using System;
using NETGeographicLib;
namespace example_NormalGravity
{
    class Program
    {
        static void Main(string[] args)
        {
            try {
                NormalGravity grav = new NormalGravity(NormalGravity.StandardModels.WGS84);
                double lat = 27.99, h = 8820; // Mt Everest
                double gammay, gammaz;
                grav.Gravity(lat, h, out gammay, out gammaz);
                Console.WriteLine(String.Format("{0} {1}", gammay, gammaz));
            }
            catch (GeographicErr e) {
                Console.WriteLine(String.Format("Caught exception: {0}", e.Message));
            }
        }
    }
}

Managed C++ Example:

// Example of using the GeographicLib::NormalGravity class
#include <iostream>
#include <exception>
#include <GeographicLib/NormalGravity.hpp>
#include <GeographicLib/Constants.hpp>
using namespace std;
using namespace GeographicLib;
int main() {
  try {
    NormalGravity grav(Constants::WGS84_a(), Constants::WGS84_GM(),
                       Constants::WGS84_omega(), Constants::WGS84_f());
    // Alternatively: const NormalGravity& grav = NormalGravity::WGS84();
    double lat = 27.99, h = 8820; // Mt Everest
    double gammay, gammaz;
    grav.Gravity(lat, h, gammay, gammaz);
    cout << gammay << " " << gammaz << "\n";
  }
  catch (const exception& e) {
    cerr << "Caught exception: " << e.what() << "\n";
    return 1;
  }
}

Visual Basic Example:

Imports NETGeographicLib
Module example_NormalGravity
    Sub Main()
        Try
            Dim grav As NormalGravity = New NormalGravity(NormalGravity.StandardModels.WGS84)
            Dim lat As Double = 27.99, h = 8820 ' Mt Everest
            Dim gammay, gammaz As Double
            grav.Gravity(lat, h, gammay, gammaz)
            Console.WriteLine(String.Format("{0} {1}", gammay, gammaz))
        Catch ex As GeographicErr
            Console.WriteLine(String.Format("Caught exception: {0}", ex.Message))
        End Try
    End Sub
End Module

INTERFACE DIFFERENCES:
A constructor has been provided for creating standard WGS84 and GRS80 gravity models.

The following functions are implemented as properties: MajorRadius, MassConstant, AngularVelocity, Flattening, EquatorialGravity, PolarGravity, GravityFlattening, SurfacePotential.

Definition at line 71 of file NormalGravity.h.

Member Enumeration Documentation

enum NETGeographicLib::NormalGravity::StandardModels

strong

The enumerated standard gravity models.

Enumerator
WGS84	WGS84 gravity model.
GRS80	GRS80 gravity model.

Definition at line 81 of file NormalGravity.h.

Constructor & Destructor Documentation

NormalGravity::!NormalGravity ( void )

private

Definition at line 22 of file dotnet/NETGeographicLib/NormalGravity.cpp.

NormalGravity::NormalGravity	(	double	a,
		double	GM,
		double	omega,
		double	f_J2,
		bool	geometricp
	)

Constructor for the normal gravity.

Parameters

[in]	a	equatorial radius (meters).
[in]	GM	mass constant of the ellipsoid (meters³/seconds²); this is the product of G the gravitational constant and M the mass of the earth (usually including the mass of the earth's atmosphere).
[in]	omega	the angular velocity (rad s⁻¹).
[in]	f_J2	either the flattening of the ellipsoid f or the the dynamical form factor J2.
[out]	geometricp	if true, then f_J2 denotes the flattening, else it denotes the dynamical form factor J2.

Exceptions

if	a is not positive or if the other parameters do not obey the restrictions given below.

The shape of the ellipsoid can be given in one of two ways:

geometrically (geomtricp = true), the ellipsoid is defined by the flattening f = (a − b) / a, where a and b are the equatorial radius and the polar semi-axis. The parameters should obey a > 0, f < 1. There are no restrictions on GM or omega, in particular, GM need not be positive.
physically (geometricp = false), the ellipsoid is defined by the dynamical form factor J₂ = (C − A) / Ma², where A and C are the equatorial and polar moments of inertia and M is the mass of the earth. The parameters should obey a > 0, GM > 0 and J2 < 1/3 − (omega²a³/GM) 8/(45π). There is no restriction on omega.

Definition at line 32 of file dotnet/NETGeographicLib/NormalGravity.cpp.

NormalGravity::NormalGravity ( StandardModels model )

A constructor for creating standard gravity models..

Parameters

[in] model Specifies the desired model.

Definition at line 49 of file dotnet/NETGeographicLib/NormalGravity.cpp.

NormalGravity::NormalGravity ( const GeographicLib::NormalGravity & g )

A constructor that accepts a GeographicLib::NormalGravity. For internal use only.

Parameters

g	An existing GeographicLib::NormalGravity.

Definition at line 64 of file dotnet/NETGeographicLib/NormalGravity.cpp.

NETGeographicLib::NormalGravity::~NormalGravity ( )

inline

The destructor calls the finalizer.

Definition at line 140 of file NormalGravity.h.

Member Function Documentation

double NormalGravity::DynamicalFormFactor ( int n )

Returns: J_n the dynamical form factors of the ellipsoid.

If n = 2 (the default), this is the value of J₂ used in the constructor. Otherwise it is the zonal coefficient of the Legendre harmonic sum of the normal gravitational potential. Note that J_n = 0 if n is odd. In most gravity applications, fully normalized Legendre functions are used and the corresponding coefficient is C_n0 = −J_n / sqrt(2 n + 1).

Definition at line 149 of file dotnet/NETGeographicLib/NormalGravity.cpp.

Geocentric NormalGravity::Earth ( )

Returns: the Geocentric object used by this instance.

Definition at line 135 of file dotnet/NETGeographicLib/NormalGravity.cpp.

double NormalGravity::FlatteningToJ2	(	double	a,
		double	GM,
		double	omega,
		double	f
	)

static

Compute the dynamical form factor from the flattening.

Parameters

[in]	a	equatorial radius (meters).
[in]	GM	mass constant of the ellipsoid (meters³/seconds²); this is the product of G the gravitational constant and M the mass of the earth (usually including the mass of the earth's atmosphere).
[in]	omega	the angular velocity (rad s⁻¹).
[in]	f	the flattening of the ellipsoid.

Returns: J2 the dynamical form factor.

Definition at line 196 of file dotnet/NETGeographicLib/NormalGravity.cpp.

double NormalGravity::Gravity	(	double	lat,
		double	h,
		[System::Runtime::InteropServices::Out] double%	gammay,
		[System::Runtime::InteropServices::Out] double%	gammaz
	)

Evaluate the gravity at an arbitrary point above (or below) the ellipsoid.

Parameters

[in]	lat	the geographic latitude (degrees).
[in]	h	the height above the ellipsoid (meters).
[out]	gammay	the northerly component of the acceleration (m s⁻²).
[out]	gammaz	the upward component of the acceleration (m s⁻²); this is usually negative.

Returns: U the corresponding normal potential.

Due to the axial symmetry of the ellipsoid, the result is independent of the value of the longitude and the easterly component of the acceleration vanishes, gammax = 0. The function includes the effects of the earth's rotation. When h = 0, this function gives gammay = 0 and the returned value matches that of NormalGravity::SurfaceGravity.

Definition at line 83 of file dotnet/NETGeographicLib/NormalGravity.cpp.

NormalGravity NormalGravity::GRS80 ( )

static

A global instantiation of NormalGravity for the GRS80 ellipsoid.

Definition at line 183 of file dotnet/NETGeographicLib/NormalGravity.cpp.

double NormalGravity::J2ToFlattening	(	double	a,
		double	GM,
		double	omega,
		double	J2
	)

static

Compute the flattening from the dynamical form factor.

Parameters

[in]	a	equatorial radius (meters).
[in]	GM	mass constant of the ellipsoid (meters³/seconds²); this is the product of G the gravitational constant and M the mass of the earth (usually including the mass of the earth's atmosphere).
[in]	omega	the angular velocity (rad s⁻¹).
[in]	J2	the dynamical form factor.

Returns: f the flattening of the ellipsoid.

Definition at line 189 of file dotnet/NETGeographicLib/NormalGravity.cpp.

double NormalGravity::Phi	(	double	X,
		double	Y,
		[System::Runtime::InteropServices::Out] double%	fX,
		[System::Runtime::InteropServices::Out] double%	fY
	)

Evaluate the centrifugal acceleration in geocentric coordinates.

Parameters

[in]	X	geocentric coordinate of point (meters).
[in]	Y	geocentric coordinate of point (meters).
[out]	fX	the X component of the centrifugal acceleration (m s⁻²).
[out]	fY	the Y component of the centrifugal acceleration (m s⁻²).

Returns: Φ the centrifugal potential (m² s⁻²).

Φ is independent of Z, thus fZ = 0. This function NormalGravity::U sums the results of NormalGravity::V0 and NormalGravity::Phi.

Definition at line 123 of file dotnet/NETGeographicLib/NormalGravity.cpp.

double NormalGravity::SurfaceGravity ( double lat )

Evaluate the gravity on the surface of the ellipsoid.

Parameters

[in] lat the geographic latitude (degrees).

Returns: γ the acceleration due to gravity, positive downwards (m s⁻²).

Due to the axial symmetry of the ellipsoid, the result is independent of the value of the longitude. This acceleration is perpendicular to the surface of the ellipsoid. It includes the effects of the earth's rotation.

Definition at line 77 of file dotnet/NETGeographicLib/NormalGravity.cpp.

double NormalGravity::U	(	double	X,
		double	Y,
		double	Z,
		[System::Runtime::InteropServices::Out] double%	gammaX,
		[System::Runtime::InteropServices::Out] double%	gammaY,
		[System::Runtime::InteropServices::Out] double%	gammaZ
	)

Evaluate the components of the acceleration due to gravity and the centrifugal acceleration in geocentric coordinates.

Parameters

[in]	X	geocentric coordinate of point (meters).
[in]	Y	geocentric coordinate of point (meters).
[in]	Z	geocentric coordinate of point (meters).
[out]	gammaX	the X component of the acceleration (m s⁻²).
[out]	gammaY	the Y component of the acceleration (m s⁻²).
[out]	gammaZ	the Z component of the acceleration (m s⁻²).

Returns: U = V₀ + Φ the sum of the gravitational and centrifugal potentials (m² s⁻²).

The acceleration given by γ = ∇U = ∇V₀ + ∇Φ = Γ + f.

Definition at line 95 of file dotnet/NETGeographicLib/NormalGravity.cpp.

double NormalGravity::V0	(	double	X,
		double	Y,
		double	Z,
		[System::Runtime::InteropServices::Out] double%	GammaX,
		[System::Runtime::InteropServices::Out] double%	GammaY,
		[System::Runtime::InteropServices::Out] double%	GammaZ
	)

Evaluate the components of the acceleration due to gravity alone in geocentric coordinates.

Parameters

[in]	X	geocentric coordinate of point (meters).
[in]	Y	geocentric coordinate of point (meters).
[in]	Z	geocentric coordinate of point (meters).
[out]	GammaX	the X component of the acceleration due to gravity (m s⁻²).
[out]	GammaY	the Y component of the acceleration due to gravity (m s⁻²).
[out]	GammaZ	the Z component of the acceleration due to gravity (m s⁻²).

Returns: V₀ the gravitational potential (m² s⁻²).

This function excludes the centrifugal acceleration and is appropriate to use for space applications. In terrestrial applications, the function NormalGravity::U (which includes this effect) should usually be used.

Definition at line 109 of file dotnet/NETGeographicLib/NormalGravity.cpp.

NormalGravity NormalGravity::WGS84 ( )

static

A global instantiation of NormalGravity for the WGS84 ellipsoid.

Definition at line 177 of file dotnet/NETGeographicLib/NormalGravity.cpp.

Member Data Documentation

property double NETGeographicLib::NormalGravity::AngularVelocity { double get()

Returns: ω the angular velocity of the ellipsoid (rad s⁻¹). This is the value used in the constructor.

Definition at line 287 of file NormalGravity.h.

property double NETGeographicLib::NormalGravity::EquatorialGravity { double get()

Returns: γ_e the normal gravity at equator (m s⁻²).

Definition at line 299 of file NormalGravity.h.

property double NETGeographicLib::NormalGravity::Flattening { double get()

Returns: f the flattening of the ellipsoid (a − b)/a.

Definition at line 293 of file NormalGravity.h.

property double NETGeographicLib::NormalGravity::GravityFlattening { double get()

Returns: f* the gravity flattening (γ_p − γ_e) / γ_e.

Definition at line 311 of file NormalGravity.h.

const GeographicLib::NormalGravity* NETGeographicLib::NormalGravity::m_pNormalGravity

private

Definition at line 75 of file NormalGravity.h.

property double NETGeographicLib::NormalGravity::MajorRadius { double get()

Returns: a the equatorial radius of the ellipsoid (meters). This is the value used in the constructor.

Definition at line 261 of file NormalGravity.h.

property double NETGeographicLib::NormalGravity::MassConstant { double get()

Returns: GM the mass constant of the ellipsoid (m³ s⁻²). This is the value used in the constructor.

Definition at line 268 of file NormalGravity.h.

property double NETGeographicLib::NormalGravity::PolarGravity { double get()

Returns: γ_p the normal gravity at poles (m s⁻²).

Definition at line 305 of file NormalGravity.h.

property double NETGeographicLib::NormalGravity::SurfacePotential { double get()

Returns: U₀ the constant normal potential for the surface of the ellipsoid (m² s⁻²).

Definition at line 317 of file NormalGravity.h.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Inspector functions

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation