C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/Physics/GravityCalculator.cs

// --------------------------------------------------------
// GravityCalculator.cs
// (A. Schiffler, 2009)
// --------------------------------------------------------

namespace NewGamePhysics.Physics
{
    using System;
    using System.Text;

    public enum EarthGravityModel
    {
        None,

        FolkPhysics,

        Igf67,

        Grs80,

        Grs80Hd,

        Wgs84,

        Wgs84Hd,

        GfcGrid,

        Ggm03sModel,

        Eigen5cModel,
    }

    public enum EarthGravityAnomaly
    {
        None,

        Fac,

        BouguerPlane,

        BouguerSpherical,
    }


    public enum MarsGravityModel
    {
        None,

        Normal,

        GgMro,
    }

    public class GravityCalculator
    {
        public const double G = 6.67428e-11;

        private CelestialObject simulatedBody;

        public const double StandardBouguerDensity = 2670.0;

        private EarthGravityModel earthGravityModel;

        private MarsGravityModel marsGravityModel;

        private EarthGravityAnomaly earthGravityAnomaly;

        private GravityEarthGrsModel grsModel;

        private GravityEarthWgsModel wgsModel;

        private GravityEarthGfcGrid gfcGrid;

        private GravityEarthGfcModel gfcModel;

        private GravityMarsMroModel mroModel;

        private double value;

        private double latitude;

        private double longitude;

        private double elevation;

        private double groundElevation;

        private DateTime lastCalculation = DateTime.Now;

        public EarthGravityModel EarthGravityModel
        {
            get
            {
                return this.earthGravityModel;
            }

            set
            {
                this.earthGravityModel = value;

                // Set body to mars
                this.simulatedBody = CelestialObject.Earth;

                // Update models
                this.UnloadModelData();
                switch (value)
                {
                    case EarthGravityModel.GfcGrid:
                        this.gfcGrid.LoadGravityMap(@"Physics\Grids\eigen5c.gdf");
                        break;
                    case EarthGravityModel.Ggm03sModel:
                        this.gfcModel.LoadGfcModel(@"Physics\Models\ggm03s.gfc");
                        break;
                    case EarthGravityModel.Eigen5cModel:
                        this.gfcModel.LoadGfcModel(@"Physics\Models\eigen5c.gfc");
                        break;
                }

                UpdateValue();
            }
        }

        public MarsGravityModel MarsGravityModel
        {
            get
            {
                return this.marsGravityModel;
            }

            set
            {
                this.marsGravityModel = value;

                // Set body to mars
                this.simulatedBody = CelestialObject.Mars;

                // Update models
                this.UnloadModelData();
                switch (value)
                {
                    case MarsGravityModel.GgMro:
                        this.mroModel.LoadAnomalyMap(@"Physics\Models\ggmro_095a_anom_085.img");
                        break;
                }

                UpdateValue();
            }
        }

        public EarthGravityAnomaly EarthGravityAnomaly
        {
            get
            {
                return this.earthGravityAnomaly;
            }

            set
            {
                this.earthGravityAnomaly = value;
                if (this.simulatedBody == CelestialObject.Earth)
                {
                    UpdateValue();
                }
            }
        }

        public double Value
        {
            get
            {
                return this.value;
            }
        }

        public double Latitude
        {
            get { return this.latitude; }
            set
            {
                if ((value < -90.0) || (value > 90.0))
                {
                    throw new ArgumentOutOfRangeException();
                }

                this.latitude = value;
                UpdateValue();
            }
        }

        public double Longitude
        {
            get { return this.longitude; }
            set
            {
                if ((value < 0.0) || (value > 360.0))
                {
                    throw new ArgumentOutOfRangeException();
                }

                this.longitude = value;
                UpdateValue();
            }
        }

        public double Elevation
        {
            get { return this.elevation; }
            set
            {
                if ((value >= 0.0) &&
                    (value <= 1000000.0))
                {
                    this.elevation = value;

                    // Maybe adjust ground elevation as well
                    if (this.groundElevation > value)
                    {
                        this.groundElevation = value;
                    }

                    UpdateValue();
                }
                else
                {
                    throw new ArgumentOutOfRangeException();
                }
            }
        }

        public double GroundElevation
        {
            get { return this.groundElevation; }
            set
            {
                if ((value >= 0.0) &&
                    (value <= 10000.0))
                {
                    this.groundElevation = value;

                    // Maybe adjust elevation to be consistent
                    if (this.elevation < value)
                    {
                        this.elevation = value;
                    }

                    UpdateValue();
                }
                else
                {
                    throw new ArgumentOutOfRangeException();
                }
            }
        }

        public GravityCalculator()
            : this(CelestialObject.Earth)
        {
        }

        public GravityCalculator(CelestialObject body)
        {
            // Initialize earth models
            this.wgsModel = new GravityEarthWgsModel();
            this.grsModel = new GravityEarthGrsModel();
            this.gfcGrid = new GravityEarthGfcGrid();
            this.gfcModel = new GravityEarthGfcModel();

            // Initialize mars models
            this.mroModel = new GravityMarsMroModel();

            // Initialize instance state
            this.simulatedBody = body;
            this.earthGravityModel = EarthGravityModel.None;
            this.earthGravityAnomaly = EarthGravityAnomaly.None;
            this.marsGravityModel = MarsGravityModel.None;
            this.latitude = 0.0;
            this.elevation = 0.0;
            this.groundElevation = 0.0;

            // Initialize current value 
            this.UpdateValue();
        }

        public string GetModelInfo()
        {
            StringBuilder sb = new StringBuilder();

            switch (this.simulatedBody)
            {
                case CelestialObject.Sun:
                    sb.AppendLine("Model: Fixed value.");
                    sb.AppendLine("Source: http://www.wikipedia.org [Earth's Gravity]");
                    break;
                case CelestialObject.Mercury:
                    sb.AppendLine("Model: Fixed value.");
                    sb.AppendLine("Source: http://www.wikipedia.org [Earth's Gravity]");
                    break;
                case CelestialObject.Venus:
                    sb.AppendLine("Model: Fixed value.");
                    sb.AppendLine("Source: http://www.wikipedia.org [Earth's Gravity]");
                    break;
                case CelestialObject.Earth:
                    switch (this.earthGravityModel)
                    {
                        case EarthGravityModel.None:
                            sb.AppendLine("Model: Fixed value.");
                            sb.AppendLine("Source: http://www.wikipedia.org [Earth's Gravity]");
                            break;
                        case EarthGravityModel.FolkPhysics:
                            sb.AppendLine("Model: Commonly used fixed value.");
                            break;
                        case EarthGravityModel.Igf67:
                            sb.AppendLine("Model: Geodetic Reference System from 1967 (Version provided by IGF).");
                            sb.AppendLine("Source: http://geophysics.ou.edu/solid_earth/notes/potential/igf.htm");
                            break;
                        case EarthGravityModel.Grs80:
                            sb.AppendLine("Model: The GRS 80 geodetic system.");
                            sb.AppendLine("Source: http://bgi.cnes.fr:8110");
                            break;
                        case EarthGravityModel.Grs80Hd:
                            sb.AppendLine("Model: High-res calculation of the geodetic reference system (GRS 80)");
                            sb.AppendLine("Applies height correction.");
                            sb.AppendLine("Source: Hofmann-Wellenhof/Moritz, Physical Godesy, 2006.");
                            break;
                        case EarthGravityModel.Wgs84:
                            sb.AppendLine("Model: World Geodetic System 84 Ellipsoidal Gravity Formula");
                            sb.AppendLine("Source: http://www.wikipedia.org [Earth's Gravity]");
                            break;
                        case EarthGravityModel.Wgs84Hd:
                            sb.AppendLine("Model: High-res calculation of the World Geodetic System (WGS 84)");
                            sb.AppendLine("Applies height correction.");
                            sb.AppendLine("Source: Hofmann-Wellenhof/Moritz, Physical Godesy, 2006.");
                            break;
                        case EarthGravityModel.GfcGrid:
                            sb.AppendLine("Model: Grid interpolator of earths gravity based on data from");
                            sb.AppendLine("the International Center for Global Earth Models (ICGEM).");
                            sb.AppendLine("Grid based on eigen5c model with a 1 degree resolution.");
                            sb.AppendLine("Source: http://icgem.gfz-potsdam.de/ICGEM/ICGEM.html");
                            break;
                        case EarthGravityModel.Ggm03sModel:
                            sb.AppendLine("Model: Satellite only mean Earth Gravity Model from GRACE satellite");
                            sb.AppendLine("GGM03S is an unconstrained global gravity model complete to degree and order 180");
                            sb.AppendLine("accelerometer data. 47 months of GRACE data for the period from January 2003");
                            sb.AppendLine("through December 2006 were used (January 2004 excluded). The GRACE atmosphere-ocean");
                            sb.AppendLine("de-aliasing product (AOD1B) was used, but the mean of the AOD1B for the 47 months");
                            sb.AppendLine("has been restored so that GGM03S represents the true mean field.");
                            sb.AppendLine("Source: http://icgem.gfz-potsdam.de/ICGEM/ICGEM.html");
                            break;
                        case EarthGravityModel.Eigen5cModel:
                            sb.AppendLine("Model: A new global combined high-resolution GRACE-based gravity");
                            sb.AppendLine("field model of the GFZ-GRGS cooperation.");
                            sb.AppendLine("The reference epoch of this gravity field model is 01 Oct 2004");
                            sb.AppendLine("Source: http://icgem.gfz-potsdam.de/ICGEM/ICGEM.html");
                            break;
                    }
                    break;
                case CelestialObject.Moon:
                    sb.AppendLine("Model: Fixed value.");
                    sb.AppendLine("Source: http://www.wikipedia.org [Earth's Gravity]");
                    break;
                case CelestialObject.Mars:
                    switch (this.marsGravityModel)
                    {
                        case MarsGravityModel.None:
                            sb.AppendLine("Model: Fixed value.");
                            sb.AppendLine("Source: http://www.wikipedia.org [Earth's Gravity]");
                            break;
                        case MarsGravityModel.Normal:
                            sb.AppendLine("Model: Ellipsoid.");
                            sb.AppendLine("Algorithm: Hofmann-Wellenhof/Moritz, Physical Godesy, 2006");
                            sb.AppendLine("Source: http://pds-geosciences.wustl.edu/mro/mro-m-rss-5-sdp-v1/mrors_1xxx/data/rsdmap/");
                            break;
                        case MarsGravityModel.GgMro:
                            sb.AppendLine("Model: GgMro 095A NASA GSFC Mars Reconnaissance Orbiter.");
                            sb.AppendLine("A digital map of the Mars gravity anomalies derived from");
                            sb.AppendLine("spherical harmonic coefficients of the NASA GSFC MROMGM0032 Mars gravity field");
                            sb.AppendLine("Source: http://pds-geosciences.wustl.edu/mro/mro-m-rss-5-sdp-v1/mrors_1xxx/data/rsdmap/");
                            break;
                    }
                    break;
                case CelestialObject.Jupiter:
                    sb.AppendLine("Model: Fixed value.");
                    sb.AppendLine("Source: http://www.wikipedia.org [Earth's Gravity]");
                    break;
                case CelestialObject.Io:
                    sb.AppendLine("Model: Fixed value.");
                    sb.AppendLine("Source: http://www.wikipedia.org [Io_(moon)]");
                    break;
                case CelestialObject.Europa:
                    sb.AppendLine("Model: Fixed value.");
                    sb.AppendLine("Source: http://www.wikipedia.org [Europa_(moon)]");
                    break;
                case CelestialObject.Ganymede:
                    sb.AppendLine("Model: Fixed value.");
                    sb.AppendLine("Source: http://www.wikipedia.org [Ganymede_(moon)]");
                    break;
                case CelestialObject.Callisto:
                    sb.AppendLine("Model: Fixed value.");
                    sb.AppendLine("Source: http://www.wikipedia.org [Callisto_(moon)]");
                    break;
                case CelestialObject.Saturn:
                    sb.AppendLine("Model: Fixed value.");
                    sb.AppendLine("Source: http://www.wikipedia.org [Earth's Gravity]");
                    break;
                case CelestialObject.Uranus:
                    sb.AppendLine("Model: Fixed value.");
                    sb.AppendLine("Source: http://www.wikipedia.org [Earth's Gravity]");
                    break;
                case CelestialObject.Neptune:
                    sb.AppendLine("Model: Fixed value.");
                    sb.AppendLine("Source: http://www.wikipedia.org [Earth's Gravity]");
                    break;
            }

            return sb.ToString();
        }

        private void UpdateValue()
        {
            switch (this.simulatedBody)
            {
                case CelestialObject.Sun:
                    value = 274.1;
                    break;

                case CelestialObject.Mercury:
                    value = 3.703;
                    break;

                case CelestialObject.Venus:
                    value = 8.872;
                    break;

                case CelestialObject.Earth:
                    // Flag controlling usage of fac correction 
                    bool facApplicable = false;

                    // Model gravity and calculate a dynamic value
                    double sinLat = Math.Sin(this.latitude * Math.PI / 180.0);
                    double sin2Lat = Math.Sin(2.0 * this.latitude * Math.PI / 180.0);
                    double sinLat2 = sinLat * sinLat;
                    double sin2Lat2 = sin2Lat * sin2Lat;
                    switch (earthGravityModel)
                    {
                        case EarthGravityModel.None:
                            value = 9.80665;
                            break;

                        case EarthGravityModel.FolkPhysics:
                            value = 9.81;
                            break;

                        case EarthGravityModel.Igf67:
                            value = 9.78031846 * (1.0 + 0.0053024 * sinLat2 - 0.0000058 * sin2Lat2);
                            facApplicable = true;
                            break;

                        case EarthGravityModel.Grs80:
                            value = 9.7803267715 * (1.0 + 0.001931851353 * sinLat2) / Math.Sqrt(1.0 - 0.00669438002290 * sinLat2);
                            facApplicable = true;
                            break;

                        case EarthGravityModel.Grs80Hd:
                            value = grsModel.Calculate(this.latitude, this.elevation);
                            break;

                        case EarthGravityModel.Wgs84:
                            value = 9.780326774 * (1.0 + 0.00193185138639 * sinLat2) / Math.Sqrt(1.0 - 0.00669437999013 * sinLat2);
                            facApplicable = true;
                            break;

                        case EarthGravityModel.Wgs84Hd:
                            value = wgsModel.Calculate(this.latitude, this.elevation);
                            break;

                        case EarthGravityModel.GfcGrid:
                            value = gfcGrid.Calculate(this.latitude, this.longitude, this.elevation);
                            break;

                        case EarthGravityModel.Ggm03sModel:
                            value = gfcModel.Calculate(this.latitude, this.longitude, this.elevation);
                            break;

                        case EarthGravityModel.Eigen5cModel:
                            // Use rate limiter (5Hz max.) since calculation is slow 
                            if (DateTime.Now > lastCalculation.AddMilliseconds(200))
                            {
                                value = gfcModel.Calculate(this.latitude, this.longitude, this.elevation);
                                lastCalculation = DateTime.Now;
                            }

                            break;
                    }

                    // Anomaly correction for elevation
                    if ((facApplicable) &&
                        ((earthGravityAnomaly == EarthGravityAnomaly.Fac) ||
                         (earthGravityAnomaly == EarthGravityAnomaly.BouguerPlane)))
                    {
                        value -= (3.086e-6 * this.elevation);

                    }

                    if (earthGravityAnomaly == EarthGravityAnomaly.BouguerPlane)
                    {
                        // Anomaly correction for ground level (plane Bouguer plate
                        value += (2.0 * Math.PI * G * StandardBouguerDensity * this.groundElevation);
                    }
                    else if (earthGravityAnomaly == EarthGravityAnomaly.BouguerSpherical)
                    {
                        // Anomaly correction for ground level (spherical Bouguer plate)
                        value += (4.0 * Math.PI * G * StandardBouguerDensity * this.groundElevation);
                    }

                    break;

                case CelestialObject.Moon:
                    value = 1.625;
                    break;

                case CelestialObject.Mars:
                    // Model gravity and calculate a dynamic value
                    switch (marsGravityModel)
                    {
                        case MarsGravityModel.None:
                            value = 3.728;
                            break;

                        case MarsGravityModel.Normal:
                            value = GravityMarsNormalModel.Calculate(this.latitude);
                            break;

                        case MarsGravityModel.GgMro:
                            value = mroModel.Calculate(this.latitude, this.longitude, this.elevation);
                            break;
                    }

                    break;

                case CelestialObject.Jupiter:
                    value = 25.93;
                    break;

                case CelestialObject.Io:
                    value = 1.796;
                    break;

                case CelestialObject.Europa:
                    value = 1.314;
                    break;

                case CelestialObject.Ganymede:
                    value = 1.428;
                    break;

                case CelestialObject.Callisto:
                    value = 1.235;
                    break;

                case CelestialObject.Saturn:
                    value = 11.19;
                    break;

                case CelestialObject.Uranus:
                    value = 9.01;
                    break;

                case CelestialObject.Neptune:
                    value = 11.28;
                    break;

                case CelestialObject.Pluto:
                    value = 0.61;
                    break;
            }
        }

        private void UnloadModelData()
        {
            this.gfcGrid.UnloadGravityMap();
            this.gfcModel.UnloadGfcModel();
            this.mroModel.UnloadAnomalyMap();
        }
    }
}

---