protected virtual bool CheckForSameDefinition(TwoBodyGravity other)
 {
     return((other != null) && (other.GetType() == typeof(TwoBodyGravity)));
 }
Example #2
0
        /// <summary>
        /// This will configure the entered point with all of the force models as entered in the GUI.
        /// </summary>
        /// <param name="point">The point to add the force models too.</param>
        /// <param name="area">The Scalar representing the area that the SRP and Drag model will see.</param>
        public void SetForceModelsOnPoint(PropagationNewtonianPoint point, Scalar area)
        {
            point.AppliedForces.Clear();
            if (m_useSRP.Checked)
            {
                SimpleSolarRadiationForce srp = new SimpleSolarRadiationForce(point.IntegrationPoint, double.Parse(m_reflectivity.Text), area);
                if (m_shadowModel.SelectedItem.ToString() == DUALCONE)
                {
                    srp.OccultationFactor = new ScalarOccultationDualCone(CentralBodiesFacet.GetFromContext().Sun,
                                                                          point.IntegrationPoint);
                }
                else if (m_shadowModel.SelectedItem.ToString() == CYLINDRICAL)
                {
                    srp.OccultationFactor = new ScalarOccultationCylindrical(CentralBodiesFacet.GetFromContext().Sun,
                                                                             point.IntegrationPoint);
                }
                foreach (string id in m_eclipsingBodies.CheckedItems)
                {
                    srp.OccultationFactor.OccludingBodies.Add(CentralBodiesFacet.GetFromContext().GetByName(id));
                }

                point.AppliedForces.Add(srp);
            }

            if (m_useDrag.Checked)
            {
                ScalarAtmosphericDensity density = null;
                SolarGeophysicalData     geoData = new ConstantSolarGeophysicalData(double.Parse(m_averageSolarFlux.Text),
                                                                                    double.Parse(m_solarFlux.Text),
                                                                                    double.Parse(m_kp.Text));
                if (m_densityModel.SelectedItem.ToString() == JR)
                {
                    density = new ScalarDensityJacchiaRoberts(point.IntegrationPoint, geoData);
                }
                else if (m_densityModel.SelectedItem.ToString() == MSIS86)
                {
                    density = new ScalarDensityMsis86(point.IntegrationPoint, geoData);
                }
                else if (m_densityModel.SelectedItem.ToString() == MSIS90)
                {
                    density = new ScalarDensityMsis90(point.IntegrationPoint, geoData);
                }
                else if (m_densityModel.SelectedItem.ToString() == MSIS2000)
                {
                    density = new ScalarDensityMsis2000(point.IntegrationPoint, geoData);
                }
                AtmosphericDragForce atmo = new AtmosphericDragForce(density, new ScalarFixed(double.Parse(m_dragCoeff.Text)), area);
                point.AppliedForces.Add(atmo);
            }

            ThirdBodyGravity thirdGravity = new ThirdBodyGravity(point.IntegrationPoint);

            foreach (string item in m_thirdBodies.CheckedItems)
            {
                if (item == EARTH || item == SUN || item == MOON)
                {
                    thirdGravity.AddThirdBody(item, CentralBodiesFacet.GetFromContext().GetByName(item).CenterOfMassPoint, m_gravConstants[item]);
                }
                else
                {
                    thirdGravity.AddThirdBody(item, m_jplInfo.GetCenterOfMassPoint(m_nameToJplMapping[item]), m_gravConstants[item]);
                }
            }
            thirdGravity.CentralBody = CentralBodiesFacet.GetFromContext().GetByName(m_primaryCB.SelectedItem.ToString());
            if (thirdGravity.ThirdBodies.Count > 0)
            {
                point.AppliedForces.Add(thirdGravity);
            }

            // Primary gravity
            string primaryCB = m_primaryCB.SelectedItem.ToString();

            if (m_twoBody.Checked)
            {
                TwoBodyGravity gravity = new TwoBodyGravity(point.IntegrationPoint, CentralBodiesFacet.GetFromContext().GetByName(primaryCB), m_gravConstants[primaryCB]);
                point.AppliedForces.Add(gravity);
            }
            else
            {
                SphericalHarmonicsTideType tideType = SphericalHarmonicsTideType.None;
                if (m_tides.SelectedItem.ToString() == NOTIDES)
                {
                    tideType = SphericalHarmonicsTideType.None;
                }
                else if (m_tides.SelectedItem.ToString() == PERMANENTTIDES)
                {
                    tideType = SphericalHarmonicsTideType.PermanentTideOnly;
                }

                int order  = int.Parse(m_order.Text);
                int degree = int.Parse(m_degree.Text);
                SphericalHarmonicGravityModel model   = SphericalHarmonicGravityModel.ReadFrom(m_gravFile.Text);
                SphericalHarmonicGravity      gravity = new SphericalHarmonicGravity(point.IntegrationPoint,
                                                                                     new SphericalHarmonicGravityField(model, degree, order, true, tideType));
                point.AppliedForces.Add(gravity);

                if (gravity.GravityField.CentralBody.Name != primaryCB)
                {
                    throw new InvalidDataException("The central body you have selected does not match the central body in the gravity file.");
                }
            }
            if (primaryCB == EARTH)
            {
                point.IntegrationFrame = CentralBodiesFacet.GetFromContext().Earth.InternationalCelestialReferenceFrame;
            }
            else if (primaryCB == MOON)
            {
                point.IntegrationFrame = CentralBodiesFacet.GetFromContext().Moon.InertialFrame;
            }
        }