Exemplo n.º 1
0
        public static AASNodeObjectDetails PassageThroDescendingNode(ref AASEllipticalObjectElements elements)
        {
            double v = AASCoordinateTransformation.MapTo0To360Range(180 - elements.w);

            v = AASCoordinateTransformation.DegreesToRadians(v);
            double E = Math.Atan(Math.Sqrt((1 - elements.e) / (1 + elements.e)) * Math.Tan(v / 2)) * 2;
            double M = E - elements.e * Math.Sin(E);

            M = AASCoordinateTransformation.RadiansToDegrees(M);
            double n = AASElliptical.MeanMotionFromSemiMajorAxis(elements.a);

            AASNodeObjectDetails details = new AASNodeObjectDetails();

            details.t      = elements.T + M / n;
            details.radius = elements.a * (1 - elements.e * Math.Cos(E));

            return(details);
        }
        public static CAAPhysicalMarsDetails Calculate(double JD, bool bHighPrecision)
        {
            //What will be the return value
            CAAPhysicalMarsDetails details = new CAAPhysicalMarsDetails();

            //Step 1
            double T          = (JD - 2451545) / 36525;
            double Lambda0    = 352.9065 + 1.17330 * T;
            double Lambda0rad = AASCoordinateTransformation.DegreesToRadians(Lambda0);
            double Beta0      = 63.2818 - 0.00394 * T;
            double Beta0rad   = AASCoordinateTransformation.DegreesToRadians(Beta0);

            //Step 2
            double l0    = AASEarth.EclipticLongitude(JD, bHighPrecision);
            double l0rad = AASCoordinateTransformation.DegreesToRadians(l0);
            double b0    = AASEarth.EclipticLatitude(JD, bHighPrecision);
            double b0rad = AASCoordinateTransformation.DegreesToRadians(b0);
            double R     = AASEarth.RadiusVector(JD, bHighPrecision);

            double PreviousLightTravelTime = 0;
            double LightTravelTime         = 0;
            double x        = 0;
            double y        = 0;
            double z        = 0;
            bool   bIterate = true;
            double DELTA    = 0;
            double l        = 0;
            double lrad     = 0;
            double b        = 0;
            double r        = 0;

            while (bIterate)
            {
                double JD2 = JD - LightTravelTime;

                //Step 3
                l    = AASMars.EclipticLongitude(JD2, bHighPrecision);
                lrad = AASCoordinateTransformation.DegreesToRadians(l);
                b    = AASMars.EclipticLatitude(JD2, bHighPrecision);
                double brad = AASCoordinateTransformation.DegreesToRadians(b);
                r = AASMars.RadiusVector(JD2, bHighPrecision);

                //Step 4
                x               = r * Math.Cos(brad) * Math.Cos(lrad) - R * Math.Cos(l0rad);
                y               = r * Math.Cos(brad) * Math.Sin(lrad) - R * Math.Sin(l0rad);
                z               = r * Math.Sin(brad) - R * Math.Sin(b0rad);
                DELTA           = Math.Sqrt(x * x + y * y + z * z);
                LightTravelTime = AASElliptical.DistanceToLightTime(DELTA);

                //Prepare for the next loop around
                bIterate = (Math.Abs(LightTravelTime - PreviousLightTravelTime) > 2E-6); //2E-6 correponds to 0.17 of a second
                if (bIterate)
                {
                    PreviousLightTravelTime = LightTravelTime;
                }
            }

            //Step 5
            double lambdarad = Math.Atan2(y, x);
            double lambda    = AASCoordinateTransformation.RadiansToDegrees(lambdarad);
            double betarad   = Math.Atan2(z, Math.Sqrt(x * x + y * y));
            double beta      = AASCoordinateTransformation.RadiansToDegrees(betarad);

            //Step 6
            details.DE = AASCoordinateTransformation.RadiansToDegrees(Math.Asin(-Math.Sin(Beta0rad) * Math.Sin(betarad) - Math.Cos(Beta0rad) * Math.Cos(betarad) * Math.Cos(Lambda0rad - lambdarad)));

            //Step 7
            double N    = 49.5581 + 0.7721 * T;
            double Nrad = AASCoordinateTransformation.DegreesToRadians(N);

            double ldash    = l - 0.00697 / r;
            double ldashrad = AASCoordinateTransformation.DegreesToRadians(ldash);
            double bdash    = b - 0.000225 * (Math.Cos(lrad - Nrad) / r);
            double bdashrad = AASCoordinateTransformation.DegreesToRadians(bdash);

            //Step 8
            details.DS = AASCoordinateTransformation.RadiansToDegrees(Math.Asin(-Math.Sin(Beta0rad) * Math.Sin(bdashrad) - Math.Cos(Beta0rad) * Math.Cos(bdashrad) * Math.Cos(Lambda0rad - ldashrad)));

            //Step 9
            double W = AASCoordinateTransformation.MapTo0To360Range(11.504 + 350.89200025 * (JD - LightTravelTime - 2433282.5));

            //Step 10
            double          e0             = AASNutation.MeanObliquityOfEcliptic(JD);
            double          e0rad          = AASCoordinateTransformation.DegreesToRadians(e0);
            AAS2DCoordinate PoleEquatorial = AASCoordinateTransformation.Ecliptic2Equatorial(Lambda0, Beta0, e0);
            double          alpha0rad      = AASCoordinateTransformation.HoursToRadians(PoleEquatorial.X);
            double          delta0rad      = AASCoordinateTransformation.DegreesToRadians(PoleEquatorial.Y);

            //Step 11
            double u        = y * Math.Cos(e0rad) - z * Math.Sin(e0rad);
            double v        = y * Math.Sin(e0rad) + z * Math.Cos(e0rad);
            double alpharad = Math.Atan2(u, x);
            double alpha    = AASCoordinateTransformation.RadiansToHours(alpharad);
            double deltarad = Math.Atan2(v, Math.Sqrt(x * x + u * u));
            double delta    = AASCoordinateTransformation.RadiansToDegrees(deltarad);
            double xi       = Math.Atan2(Math.Sin(delta0rad) * Math.Cos(deltarad) * Math.Cos(alpha0rad - alpharad) - Math.Sin(deltarad) * Math.Cos(delta0rad), Math.Cos(deltarad) * Math.Sin(alpha0rad - alpharad));

            //Step 12
            details.w = AASCoordinateTransformation.MapTo0To360Range(W - AASCoordinateTransformation.RadiansToDegrees(xi));

            //Step 13
            double NutationInLongitude = AASNutation.NutationInLongitude(JD);
            double NutationInObliquity = AASNutation.NutationInObliquity(JD);

            //Step 14
            lambda += 0.005693 * Math.Cos(l0rad - lambdarad) / Math.Cos(betarad);
            beta   += 0.005693 * Math.Sin(l0rad - lambdarad) * Math.Sin(betarad);

            //Step 15
            Lambda0 += NutationInLongitude / 3600;
            lambda  += NutationInLongitude / 3600;
            e0      += NutationInObliquity / 3600;

            //Step 16
            AAS2DCoordinate ApparentPoleEquatorial = AASCoordinateTransformation.Ecliptic2Equatorial(Lambda0, Beta0, e0);
            double          alpha0dash             = AASCoordinateTransformation.HoursToRadians(ApparentPoleEquatorial.X);
            double          delta0dash             = AASCoordinateTransformation.DegreesToRadians(ApparentPoleEquatorial.Y);
            AAS2DCoordinate ApparentMars           = AASCoordinateTransformation.Ecliptic2Equatorial(lambda, beta, e0);
            double          alphadash = AASCoordinateTransformation.HoursToRadians(ApparentMars.X);
            double          deltadash = AASCoordinateTransformation.DegreesToRadians(ApparentMars.Y);

            //Step 17
            details.P = AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(Math.Cos(delta0dash) * Math.Sin(alpha0dash - alphadash), Math.Sin(delta0dash) * Math.Cos(deltadash) - Math.Cos(delta0dash) * Math.Sin(deltadash) * Math.Cos(alpha0dash - alphadash))));

            //Step 18
            double          SunLambda     = AASSun.GeometricEclipticLongitude(JD, bHighPrecision);
            double          SunBeta       = AASSun.GeometricEclipticLatitude(JD, bHighPrecision);
            AAS2DCoordinate SunEquatorial = AASCoordinateTransformation.Ecliptic2Equatorial(SunLambda, SunBeta, e0);

            details.X = AASMoonIlluminatedFraction.PositionAngle(SunEquatorial.X, SunEquatorial.Y, alpha, delta);

            //Step 19
            details.d = 9.36 / DELTA;
            details.k = AASIlluminatedFraction.IlluminatedFraction(r, R, DELTA);
            details.q = (1 - details.k) * details.d;

            return(details);
        }
Exemplo n.º 3
0
        public static AASNearParabolicObjectDetails Calculate(double JD, ref AASNearParabolicObjectElements elements, bool bHighPrecision)
        {
            double Epsilon = AASNutation.MeanObliquityOfEcliptic(elements.JDEquinox);

            double JD0 = JD;

            //What will be the return value
            AASNearParabolicObjectDetails details = new AASNearParabolicObjectDetails();

            Epsilon = AASCoordinateTransformation.DegreesToRadians(Epsilon);
            double omega = AASCoordinateTransformation.DegreesToRadians(elements.omega);
            double w     = AASCoordinateTransformation.DegreesToRadians(elements.w);
            double i     = AASCoordinateTransformation.DegreesToRadians(elements.i);

            double sinEpsilon = Math.Sin(Epsilon);
            double cosEpsilon = Math.Cos(Epsilon);
            double sinOmega   = Math.Sin(omega);
            double cosOmega   = Math.Cos(omega);
            double cosi       = Math.Cos(i);
            double sini       = Math.Sin(i);

            double F = cosOmega;
            double G = sinOmega * cosEpsilon;
            double H = sinOmega * sinEpsilon;
            double P = -sinOmega * cosi;
            double Q = cosOmega * cosi * cosEpsilon - sini * sinEpsilon;
            double R = cosOmega * cosi * sinEpsilon + sini * cosEpsilon;
            double a = Math.Sqrt(F * F + P * P);
            double b = Math.Sqrt(G * G + Q * Q);
            double c = Math.Sqrt(H * H + R * R);
            double A = Math.Atan2(F, P);
            double B = Math.Atan2(G, Q);
            double C = Math.Atan2(H, R);

            AAS3DCoordinate SunCoord = AASSun.EquatorialRectangularCoordinatesAnyEquinox(JD, elements.JDEquinox, bHighPrecision);

            for (int j = 0; j < 2; j++)
            {
                double v = 0;
                double r = 0;
                CalulateTrueAnnomalyAndRadius(JD0, ref elements, ref v, ref r);

                double x = r * a * Math.Sin(A + w + v);
                double y = r * b * Math.Sin(B + w + v);
                double z = r * c * Math.Sin(C + w + v);

                if (j == 0)
                {
                    details.HeliocentricRectangularEquatorial.X = x;
                    details.HeliocentricRectangularEquatorial.Y = y;
                    details.HeliocentricRectangularEquatorial.Z = z;

                    //Calculate the heliocentric ecliptic coordinates also
                    double u    = w + v;
                    double cosu = Math.Cos(u);
                    double sinu = Math.Sin(u);

                    details.HeliocentricRectangularEcliptical.X = r * (cosOmega * cosu - sinOmega * sinu * cosi);
                    details.HeliocentricRectangularEcliptical.Y = r * (sinOmega * cosu + cosOmega * sinu * cosi);
                    details.HeliocentricRectangularEcliptical.Z = r * sini * sinu;

                    details.HeliocentricEclipticLongitude = AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(details.HeliocentricRectangularEcliptical.Y, details.HeliocentricRectangularEcliptical.X)));
                    details.HeliocentricEclipticLatitude  = AASCoordinateTransformation.RadiansToDegrees(Math.Asin(details.HeliocentricRectangularEcliptical.Z / r));
                }

                double psi   = SunCoord.X + x;
                double nu    = SunCoord.Y + y;
                double sigma = SunCoord.Z + z;

                double Alpha = Math.Atan2(nu, psi);
                Alpha = AASCoordinateTransformation.RadiansToDegrees(Alpha);
                double Delta = Math.Atan2(sigma, Math.Sqrt(psi * psi + nu * nu));
                Delta = AASCoordinateTransformation.RadiansToDegrees(Delta);
                double Distance = Math.Sqrt(psi * psi + nu * nu + sigma * sigma);

                if (j == 0)
                {
                    details.TrueGeocentricRA          = AASCoordinateTransformation.MapTo0To24Range(Alpha / 15);
                    details.TrueGeocentricDeclination = Delta;
                    details.TrueGeocentricDistance    = Distance;
                    details.TrueGeocentricLightTime   = AASElliptical.DistanceToLightTime(Distance);
                }
                else
                {
                    details.AstrometricGeocentricRA          = AASCoordinateTransformation.MapTo0To24Range(Alpha / 15);
                    details.AstrometricGeocentricDeclination = Delta;
                    details.AstrometricGeocentricDistance    = Distance;
                    details.AstrometricGeocentricLightTime   = AASElliptical.DistanceToLightTime(Distance);

                    double RES = Math.Sqrt(SunCoord.X * SunCoord.X + SunCoord.Y * SunCoord.Y + SunCoord.Z * SunCoord.Z);

                    details.Elongation = AASCoordinateTransformation.RadiansToDegrees(Math.Acos((RES * RES + Distance * Distance - r * r) / (2 * RES * Distance)));
                    details.PhaseAngle = AASCoordinateTransformation.RadiansToDegrees(Math.Acos((r * r + Distance * Distance - RES * RES) / (2 * r * Distance)));
                }

                if (j == 0) //Prepare for the next loop around
                {
                    JD0 = JD - details.TrueGeocentricLightTime;
                }
            }

            return(details);
        }
Exemplo n.º 4
0
        private static AASGalileanMoonsDetails CalculateHelper(double JD, double sunlongrad, double betarad, double R, bool bHighPrecision)
        {
            //What will be the return value
            AASGalileanMoonsDetails details = new AASGalileanMoonsDetails();

            //Calculate the position of Jupiter decreased by the light travel time from Jupiter to the specified position
            double DELTA = 5;
            double PreviousLightTravelTime = 0;
            double LightTravelTime         = AASElliptical.DistanceToLightTime(DELTA);
            double x = 0;
            double y = 0;
            double z = 0;
            double l = 0;
            double lrad;
            double b = 0;
            double brad;
            double r;
            double JD1      = JD - LightTravelTime;
            bool   bIterate = true;

            while (bIterate)
            {
                //Calculate the position of Jupiter
                l    = AASJupiter.EclipticLongitude(JD1, bHighPrecision);
                lrad = AASCoordinateTransformation.DegreesToRadians(l);
                b    = AASJupiter.EclipticLatitude(JD1, bHighPrecision);
                brad = AASCoordinateTransformation.DegreesToRadians(b);
                r    = AASJupiter.RadiusVector(JD1, bHighPrecision);

                x               = r * Math.Cos(brad) * Math.Cos(lrad) + R * Math.Cos(sunlongrad);
                y               = r * Math.Cos(brad) * Math.Sin(lrad) + R * Math.Sin(sunlongrad);
                z               = r * Math.Sin(brad) + R * Math.Sin(betarad);
                DELTA           = Math.Sqrt(x * x + y * y + z * z);
                LightTravelTime = AASElliptical.DistanceToLightTime(DELTA);

                //Prepare for the next loop around
                bIterate = (Math.Abs(LightTravelTime - PreviousLightTravelTime) > 2e-6); //2e-6 corresponds to 0.17 of a second
                if (bIterate)
                {
                    JD1 = JD - LightTravelTime;
                    PreviousLightTravelTime = LightTravelTime;
                }
            }

            //Calculate Jupiter's Longitude and Latitude
            double lambda0 = Math.Atan2(y, x);
            double beta0   = Math.Atan(z / Math.Sqrt(x * x + y * y));

            double t = JD - 2443000.5 - LightTravelTime;

            //Calculate the mean longitudes
            double l1    = 106.07719 + 203.488955790 * t;
            double l1rad = AASCoordinateTransformation.DegreesToRadians(l1);
            double l2    = 175.73161 + 101.374724735 * t;
            double l2rad = AASCoordinateTransformation.DegreesToRadians(l2);
            double l3    = 120.55883 + 50.317609207 * t;
            double l3rad = AASCoordinateTransformation.DegreesToRadians(l3);
            double l4    = 84.44459 + 21.571071177 * t;
            double l4rad = AASCoordinateTransformation.DegreesToRadians(l4);

            //Calculate the perijoves
            double pi1 = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.MapTo0To360Range(97.0881 + 0.16138586 * t));
            double pi2 = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.MapTo0To360Range(154.8663 + 0.04726307 * t));
            double pi3 = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.MapTo0To360Range(188.1840 + 0.00712734 * t));
            double pi4 = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.MapTo0To360Range(335.2868 + 0.00184000 * t));

            //Calculate the nodes on the equatorial plane of jupiter
            double w1    = 312.3346 - 0.13279386 * t;
            double w1rad = AASCoordinateTransformation.DegreesToRadians(w1);
            double w2    = 100.4411 - 0.03263064 * t;
            double w2rad = AASCoordinateTransformation.DegreesToRadians(w2);
            double w3    = 119.1942 - 0.00717703 * t;
            double w3rad = AASCoordinateTransformation.DegreesToRadians(w3);
            double w4    = 322.6186 - 0.00175934 * t;
            double w4rad = AASCoordinateTransformation.DegreesToRadians(w4);

            //Calculate the Principal inequality in the longitude of Jupiter
            double GAMMA = 0.33033 * Math.Sin(AASCoordinateTransformation.DegreesToRadians(163.679 + 0.0010512 * t)) +
                           0.03439 * Math.Sin(AASCoordinateTransformation.DegreesToRadians(34.486 - 0.0161731 * t));

            //Calculate the "phase of free libration"
            double philambda = AASCoordinateTransformation.DegreesToRadians(199.6766 + 0.17379190 * t);

            //Calculate the longitude of the node of the equator of Jupiter on the ecliptic
            double psi = AASCoordinateTransformation.DegreesToRadians(316.5182 - 0.00000208 * t);

            //Calculate the mean anomalies of Jupiter and Saturn
            double G     = AASCoordinateTransformation.DegreesToRadians(30.23756 + 0.0830925701 * t + GAMMA);
            double Gdash = AASCoordinateTransformation.DegreesToRadians(31.97853 + 0.0334597339 * t);

            //Calculate the longitude of the perihelion of Jupiter
            double PI = AASCoordinateTransformation.DegreesToRadians(13.469942);

            //Calculate the periodic terms in the longitudes of the satellites
            double Sigma1 = 0.47259 * Math.Sin(2 * (l1rad - l2rad)) +
                            -0.03478 * Math.Sin(pi3 - pi4) +
                            0.01081 * Math.Sin(l2rad - 2 * l3rad + pi3) +
                            0.00738 * Math.Sin(philambda) +
                            0.00713 * Math.Sin(l2rad - 2 * l3rad + pi2) +
                            -0.00674 * Math.Sin(pi1 + pi3 - 2 * PI - 2 * G) +
                            0.00666 * Math.Sin(l2rad - 2 * l3rad + pi4) +
                            0.00445 * Math.Sin(l1rad - pi3) +
                            -0.00354 * Math.Sin(l1rad - l2rad) +
                            -0.00317 * Math.Sin(2 * psi - 2 * PI) +
                            0.00265 * Math.Sin(l1rad - pi4) +
                            -0.00186 * Math.Sin(G) +
                            0.00162 * Math.Sin(pi2 - pi3) +
                            0.00158 * Math.Sin(4 * (l1rad - l2rad)) +
                            -0.00155 * Math.Sin(l1rad - l3rad) +
                            -0.00138 * Math.Sin(psi + w3rad - 2 * PI - 2 * G) +
                            -0.00115 * Math.Sin(2 * (l1rad - 2 * l2rad + w2rad)) +
                            0.00089 * Math.Sin(pi2 - pi4) +
                            0.00085 * Math.Sin(l1rad + pi3 - 2 * PI - 2 * G) +
                            0.00083 * Math.Sin(w2rad - w3rad) +
                            0.00053 * Math.Sin(psi - w2rad);
            double Sigma1rad = AASCoordinateTransformation.DegreesToRadians(Sigma1);

            double Sigma2 = 1.06476 * Math.Sin(2 * (l2rad - l3rad)) +
                            0.04256 * Math.Sin(l1rad - 2 * l2rad + pi3) +
                            0.03581 * Math.Sin(l2rad - pi3) +
                            0.02395 * Math.Sin(l1rad - 2 * l2rad + pi4) +
                            0.01984 * Math.Sin(l2rad - pi4) +
                            -0.01778 * Math.Sin(philambda) +
                            0.01654 * Math.Sin(l2rad - pi2) +
                            0.01334 * Math.Sin(l2rad - 2 * l3rad + pi2) +
                            0.01294 * Math.Sin(pi3 - pi4) +
                            -0.01142 * Math.Sin(l2rad - l3rad) +
                            -0.01057 * Math.Sin(G) +
                            -0.00775 * Math.Sin(2 * (psi - PI)) +
                            0.00524 * Math.Sin(2 * (l1rad - l2rad)) +
                            -0.00460 * Math.Sin(l1rad - l3rad) +
                            0.00316 * Math.Sin(psi - 2 * G + w3rad - 2 * PI) +
                            -0.00203 * Math.Sin(pi1 + pi3 - 2 * PI - 2 * G) +
                            0.00146 * Math.Sin(psi - w3rad) +
                            -0.00145 * Math.Sin(2 * G) +
                            0.00125 * Math.Sin(psi - w4rad) +
                            -0.00115 * Math.Sin(l1rad - 2 * l3rad + pi3) +
                            -0.00094 * Math.Sin(2 * (l2rad - w2rad)) +
                            0.00086 * Math.Sin(2 * (l1rad - 2 * l2rad + w2rad)) +
                            -0.00086 * Math.Sin(5 * Gdash - 2 * G + AASCoordinateTransformation.DegreesToRadians(52.225)) +
                            -0.00078 * Math.Sin(l2rad - l4rad) +
                            -0.00064 * Math.Sin(3 * l3rad - 7 * l4rad + 4 * pi4) +
                            0.00064 * Math.Sin(pi1 - pi4) +
                            -0.00063 * Math.Sin(l1rad - 2 * l3rad + pi4) +
                            0.00058 * Math.Sin(w3rad - w4rad) +
                            0.00056 * Math.Sin(2 * (psi - PI - G)) +
                            0.00056 * Math.Sin(2 * (l2rad - l4rad)) +
                            0.00055 * Math.Sin(2 * (l1rad - l3rad)) +
                            0.00052 * Math.Sin(3 * l3rad - 7 * l4rad + pi3 + 3 * pi4) +
                            -0.00043 * Math.Sin(l1rad - pi3) +
                            0.00041 * Math.Sin(5 * (l2rad - l3rad)) +
                            0.00041 * Math.Sin(pi4 - PI) +
                            0.00032 * Math.Sin(w2rad - w3rad) +
                            0.00032 * Math.Sin(2 * (l3rad - G - PI));
            double Sigma2rad = AASCoordinateTransformation.DegreesToRadians(Sigma2);

            double Sigma3 = 0.16490 * Math.Sin(l3rad - pi3) +
                            0.09081 * Math.Sin(l3rad - pi4) +
                            -0.06907 * Math.Sin(l2rad - l3rad) +
                            0.03784 * Math.Sin(pi3 - pi4) +
                            0.01846 * Math.Sin(2 * (l3rad - l4rad)) +
                            -0.01340 * Math.Sin(G) +
                            -0.01014 * Math.Sin(2 * (psi - PI)) +
                            0.00704 * Math.Sin(l2rad - 2 * l3rad + pi3) +
                            -0.00620 * Math.Sin(l2rad - 2 * l3rad + pi2) +
                            -0.00541 * Math.Sin(l3rad - l4rad) +
                            0.00381 * Math.Sin(l2rad - 2 * l3rad + pi4) +
                            0.00235 * Math.Sin(psi - w3rad) +
                            0.00198 * Math.Sin(psi - w4rad) +
                            0.00176 * Math.Sin(philambda) +
                            0.00130 * Math.Sin(3 * (l3rad - l4rad)) +
                            0.00125 * Math.Sin(l1rad - l3rad) +
                            -0.00119 * Math.Sin(5 * Gdash - 2 * G + AASCoordinateTransformation.DegreesToRadians(52.225)) +
                            0.00109 * Math.Sin(l1rad - l2rad) +
                            -0.00100 * Math.Sin(3 * l3rad - 7 * l4rad + 4 * pi4) +
                            0.00091 * Math.Sin(w3rad - w4rad) +
                            0.00080 * Math.Sin(3 * l3rad - 7 * l4rad + pi3 + 3 * pi4) +
                            -0.00075 * Math.Sin(2 * l2rad - 3 * l3rad + pi3) +
                            0.00072 * Math.Sin(pi1 + pi3 - 2 * PI - 2 * G) +
                            0.00069 * Math.Sin(pi4 - PI) +
                            -0.00058 * Math.Sin(2 * l3rad - 3 * l4rad + pi4) +
                            -0.00057 * Math.Sin(l3rad - 2 * l4rad + pi4) +
                            0.00056 * Math.Sin(l3rad + pi3 - 2 * PI - 2 * G) +
                            -0.00052 * Math.Sin(l2rad - 2 * l3rad + pi1) +
                            -0.00050 * Math.Sin(pi2 - pi3) +
                            0.00048 * Math.Sin(l3rad - 2 * l4rad + pi3) +
                            -0.00045 * Math.Sin(2 * l2rad - 3 * l3rad + pi4) +
                            -0.00041 * Math.Sin(pi2 - pi4) +
                            -0.00038 * Math.Sin(2 * G) +
                            -0.00037 * Math.Sin(pi3 - pi4 + w3rad - w4rad) +
                            -0.00032 * Math.Sin(3 * l3rad - 7 * l4rad + 2 * pi3 + 2 * pi4) +
                            0.00030 * Math.Sin(4 * (l3rad - l4rad)) +
                            0.00029 * Math.Sin(l3rad + pi4 - 2 * PI - 2 * G) +
                            -0.00028 * Math.Sin(w3rad + psi - 2 * PI - 2 * G) +
                            0.00026 * Math.Sin(l3rad - PI - G) +
                            0.00024 * Math.Sin(l2rad - 3 * l3rad + 2 * l4rad) +
                            0.00021 * Math.Sin(l3rad - PI - G) +
                            -0.00021 * Math.Sin(l3rad - pi2) +
                            0.00017 * Math.Sin(2 * (l3rad - pi3));
            double Sigma3rad = AASCoordinateTransformation.DegreesToRadians(Sigma3);

            double Sigma4 = 0.84287 * Math.Sin(l4rad - pi4) +
                            0.03431 * Math.Sin(pi4 - pi3) +
                            -0.03305 * Math.Sin(2 * (psi - PI)) +
                            -0.03211 * Math.Sin(G) +
                            -0.01862 * Math.Sin(l4rad - pi3) +
                            0.01186 * Math.Sin(psi - w4rad) +
                            0.00623 * Math.Sin(l4rad + pi4 - 2 * G - 2 * PI) +
                            0.00387 * Math.Sin(2 * (l4rad - pi4)) +
                            -0.00284 * Math.Sin(5 * Gdash - 2 * G + AASCoordinateTransformation.DegreesToRadians(52.225)) +
                            -0.00234 * Math.Sin(2 * (psi - pi4)) +
                            -0.00223 * Math.Sin(l3rad - l4rad) +
                            -0.00208 * Math.Sin(l4rad - PI) +
                            0.00178 * Math.Sin(psi + w4rad - 2 * pi4) +
                            0.00134 * Math.Sin(pi4 - PI) +
                            0.00125 * Math.Sin(2 * (l4rad - G - PI)) +
                            -0.00117 * Math.Sin(2 * G) +
                            -0.00112 * Math.Sin(2 * (l3rad - l4rad)) +
                            0.00107 * Math.Sin(3 * l3rad - 7 * l4rad + 4 * pi4) +
                            0.00102 * Math.Sin(l4rad - G - PI) +
                            0.00096 * Math.Sin(2 * l4rad - psi - w4rad) +
                            0.00087 * Math.Sin(2 * (psi - w4rad)) +
                            -0.00085 * Math.Sin(3 * l3rad - 7 * l4rad + pi3 + 3 * pi4) +
                            0.00085 * Math.Sin(l3rad - 2 * l4rad + pi4) +
                            -0.00081 * Math.Sin(2 * (l4rad - psi)) +
                            0.00071 * Math.Sin(l4rad + pi4 - 2 * PI - 3 * G) +
                            0.00061 * Math.Sin(l1rad - l4rad) +
                            -0.00056 * Math.Sin(psi - w3rad) +
                            -0.00054 * Math.Sin(l3rad - 2 * l4rad + pi3) +
                            0.00051 * Math.Sin(l2rad - l4rad) +
                            0.00042 * Math.Sin(2 * (psi - G - PI)) +
                            0.00039 * Math.Sin(2 * (pi4 - w4rad)) +
                            0.00036 * Math.Sin(psi + PI - pi4 - w4rad) +
                            0.00035 * Math.Sin(2 * Gdash - G + AASCoordinateTransformation.DegreesToRadians(188.37)) +
                            -0.00035 * Math.Sin(l4rad - pi4 + 2 * PI - 2 * psi) +
                            -0.00032 * Math.Sin(l4rad + pi4 - 2 * PI - G) +
                            0.00030 * Math.Sin(2 * Gdash - 2 * G + AASCoordinateTransformation.DegreesToRadians(149.15)) +
                            0.00029 * Math.Sin(3 * l3rad - 7 * l4rad + 2 * pi3 + 2 * pi4) +
                            0.00028 * Math.Sin(l4rad - pi4 + 2 * psi - 2 * PI) +
                            -0.00028 * Math.Sin(2 * (l4rad - w4rad)) +
                            -0.00027 * Math.Sin(pi3 - pi4 + w3rad - w4rad) +
                            -0.00026 * Math.Sin(5 * Gdash - 3 * G + AASCoordinateTransformation.DegreesToRadians(188.37)) +
                            0.00025 * Math.Sin(w4rad - w3rad) +
                            -0.00025 * Math.Sin(l2rad - 3 * l3rad + 2 * l4rad) +
                            -0.00023 * Math.Sin(3 * (l3rad - l4rad)) +
                            0.00021 * Math.Sin(2 * l4rad - 2 * PI - 3 * G) +
                            -0.00021 * Math.Sin(2 * l3rad - 3 * l4rad + pi4) +
                            0.00019 * Math.Sin(l4rad - pi4 - G) +
                            -0.00019 * Math.Sin(2 * l4rad - pi3 - pi4) +
                            -0.00018 * Math.Sin(l4rad - pi4 + G) +
                            -0.00016 * Math.Sin(l4rad + pi3 - 2 * PI - 2 * G);

            //There is no need to calculate a Sigma4rad as it is not used in any subsequent trignometric functions

            details.Satellite1.MeanLongitude = AASCoordinateTransformation.MapTo0To360Range(l1);
            details.Satellite1.TrueLongitude = AASCoordinateTransformation.MapTo0To360Range(l1 + Sigma1);
            double L1 = AASCoordinateTransformation.DegreesToRadians(details.Satellite1.TrueLongitude);

            details.Satellite2.MeanLongitude = AASCoordinateTransformation.MapTo0To360Range(l2);
            details.Satellite2.TrueLongitude = AASCoordinateTransformation.MapTo0To360Range(l2 + Sigma2);
            double L2 = AASCoordinateTransformation.DegreesToRadians(details.Satellite2.TrueLongitude);

            details.Satellite3.MeanLongitude = AASCoordinateTransformation.MapTo0To360Range(l3);
            details.Satellite3.TrueLongitude = AASCoordinateTransformation.MapTo0To360Range(l3 + Sigma3);
            double L3 = AASCoordinateTransformation.DegreesToRadians(details.Satellite3.TrueLongitude);

            details.Satellite4.MeanLongitude = AASCoordinateTransformation.MapTo0To360Range(l4);
            details.Satellite4.TrueLongitude = AASCoordinateTransformation.MapTo0To360Range(l4 + Sigma4);
            double L4 = AASCoordinateTransformation.DegreesToRadians(details.Satellite4.TrueLongitude);

            //Calculate the periodic terms in the latitudes of the satellites
            double B1 = Math.Atan(0.0006393 * Math.Sin(L1 - w1rad) +
                                  0.0001825 * Math.Sin(L1 - w2rad) +
                                  0.0000329 * Math.Sin(L1 - w3rad) +
                                  -0.0000311 * Math.Sin(L1 - psi) +
                                  0.0000093 * Math.Sin(L1 - w4rad) +
                                  0.0000075 * Math.Sin(3 * L1 - 4 * l2rad - 1.9927 * Sigma1rad + w2rad) +
                                  0.0000046 * Math.Sin(L1 + psi - 2 * PI - 2 * G));

            details.Satellite1.EquatorialLatitude = AASCoordinateTransformation.RadiansToDegrees(B1);

            double B2 = Math.Atan(0.0081004 * Math.Sin(L2 - w2rad) +
                                  0.0004512 * Math.Sin(L2 - w3rad) +
                                  -0.0003284 * Math.Sin(L2 - psi) +
                                  0.0001160 * Math.Sin(L2 - w4rad) +
                                  0.0000272 * Math.Sin(l1rad - 2 * l3rad + 1.0146 * Sigma2rad + w2rad) +
                                  -0.0000144 * Math.Sin(L2 - w1rad) +
                                  0.0000143 * Math.Sin(L2 + psi - 2 * PI - 2 * G) +
                                  0.0000035 * Math.Sin(L2 - psi + G) +
                                  -0.0000028 * Math.Sin(l1rad - 2 * l3rad + 1.0146 * Sigma2rad + w3rad));

            details.Satellite2.EquatorialLatitude = AASCoordinateTransformation.RadiansToDegrees(B2);

            double B3 = Math.Atan(0.0032402 * Math.Sin(L3 - w3rad) +
                                  -0.0016911 * Math.Sin(L3 - psi) +
                                  0.0006847 * Math.Sin(L3 - w4rad) +
                                  -0.0002797 * Math.Sin(L3 - w2rad) +
                                  0.0000321 * Math.Sin(L3 + psi - 2 * PI - 2 * G) +
                                  0.0000051 * Math.Sin(L3 - psi + G) +
                                  -0.0000045 * Math.Sin(L3 - psi - G) +
                                  -0.0000045 * Math.Sin(L3 + psi - 2 * PI) +
                                  0.0000037 * Math.Sin(L3 + psi - 2 * PI - 3 * G) +
                                  0.0000030 * Math.Sin(2 * l2rad - 3 * L3 + 4.03 * Sigma3rad + w2rad) +
                                  -0.0000021 * Math.Sin(2 * l2rad - 3 * L3 + 4.03 * Sigma3rad + w3rad));

            details.Satellite3.EquatorialLatitude = AASCoordinateTransformation.RadiansToDegrees(B3);

            double B4 = Math.Atan(-0.0076579 * Math.Sin(L4 - psi) +
                                  0.0044134 * Math.Sin(L4 - w4rad) +
                                  -0.0005112 * Math.Sin(L4 - w3rad) +
                                  0.0000773 * Math.Sin(L4 + psi - 2 * PI - 2 * G) +
                                  0.0000104 * Math.Sin(L4 - psi + G) +
                                  -0.0000102 * Math.Sin(L4 - psi - G) +
                                  0.0000088 * Math.Sin(L4 + psi - 2 * PI - 3 * G) +
                                  -0.0000038 * Math.Sin(L4 + psi - 2 * PI - G));

            details.Satellite4.EquatorialLatitude = AASCoordinateTransformation.RadiansToDegrees(B4);

            //Calculate the periodic terms for the radius vector
            details.Satellite1.r = 5.90569 * (1 + (-0.0041339 * Math.Cos(2 * (l1rad - l2rad)) +
                                                   -0.0000387 * Math.Cos(l1rad - pi3) +
                                                   -0.0000214 * Math.Cos(l1rad - pi4) +
                                                   0.0000170 * Math.Cos(l1rad - l2rad) +
                                                   -0.0000131 * Math.Cos(4 * (l1rad - l2rad)) +
                                                   0.0000106 * Math.Cos(l1rad - l3rad) +
                                                   -0.0000066 * Math.Cos(l1rad + pi3 - 2 * PI - 2 * G)));

            details.Satellite2.r = 9.39657 * (1 + (0.0093848 * Math.Cos(l1rad - l2rad) +
                                                   -0.0003116 * Math.Cos(l2rad - pi3) +
                                                   -0.0001744 * Math.Cos(l2rad - pi4) +
                                                   -0.0001442 * Math.Cos(l2rad - pi2) +
                                                   0.0000553 * Math.Cos(l2rad - l3rad) +
                                                   0.0000523 * Math.Cos(l1rad - l3rad) +
                                                   -0.0000290 * Math.Cos(2 * (l1rad - l2rad)) +
                                                   0.0000164 * Math.Cos(2 * (l2rad - w2rad)) +
                                                   0.0000107 * Math.Cos(l1rad - 2 * l3rad + pi3) +
                                                   -0.0000102 * Math.Cos(l2rad - pi1) +
                                                   -0.0000091 * Math.Cos(2 * (l1rad - l3rad))));

            details.Satellite3.r = 14.98832 * (1 + (-0.0014388 * Math.Cos(l3rad - pi3) +
                                                    -0.0007919 * Math.Cos(l3rad - pi4) +
                                                    0.0006342 * Math.Cos(l2rad - l3rad) +
                                                    -0.0001761 * Math.Cos(2 * (l3rad - l4rad)) +
                                                    0.0000294 * Math.Cos(l3rad - l4rad) +
                                                    -0.0000156 * Math.Cos(3 * (l3rad - l4rad)) +
                                                    0.0000156 * Math.Cos(l1rad - l3rad) +
                                                    -0.0000153 * Math.Cos(l1rad - l2rad) +
                                                    0.0000070 * Math.Cos(2 * l2rad - 3 * l3rad + pi3) +
                                                    -0.0000051 * Math.Cos(l3rad + pi3 - 2 * PI - 2 * G)));

            details.Satellite4.r = 26.36273 * (1 + (-0.0073546 * Math.Cos(l4rad - pi4) +
                                                    0.0001621 * Math.Cos(l4rad - pi3) +
                                                    0.0000974 * Math.Cos(l3rad - l4rad) +
                                                    -0.0000543 * Math.Cos(l4rad + pi4 - 2 * PI - 2 * G) +
                                                    -0.0000271 * Math.Cos(2 * (l4rad - pi4)) +
                                                    0.0000182 * Math.Cos(l4rad - PI) +
                                                    0.0000177 * Math.Cos(2 * (l3rad - l4rad)) +
                                                    -0.0000167 * Math.Cos(2 * l4rad - psi - w4rad) +
                                                    0.0000167 * Math.Cos(psi - w4rad) +
                                                    -0.0000155 * Math.Cos(2 * (l4rad - PI - G)) +
                                                    0.0000142 * Math.Cos(2 * (l4rad - psi)) +
                                                    0.0000105 * Math.Cos(l1rad - l4rad) +
                                                    0.0000092 * Math.Cos(l2rad - l4rad) +
                                                    -0.0000089 * Math.Cos(l4rad - PI - G) +
                                                    -0.0000062 * Math.Cos(l4rad + pi4 - 2 * PI - 3 * G) +
                                                    0.0000048 * Math.Cos(2 * (l4rad - w4rad))));

            //Calculate T0
            double T0 = (JD - 2433282.423) / 36525;

            //Calculate the precession in longitude from Epoch B1950 to the date
            double P = AASCoordinateTransformation.DegreesToRadians(1.3966626 * T0 + 0.0003088 * T0 * T0);

            //Add it to L1 - L4 and psi
            L1 += P;
            details.Satellite1.TropicalLongitude = AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(L1));
            L2 += P;
            details.Satellite2.TropicalLongitude = AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(L2));
            L3 += P;
            details.Satellite3.TropicalLongitude = AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(L3));
            L4 += P;
            details.Satellite4.TropicalLongitude = AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(L4));
            psi += P;

            //Calculate the inclination of Jupiter's axis of rotation on the orbital plane
            double T    = (JD - 2415020.5) / 36525;
            double I    = 3.120262 + 0.0006 * T;
            double Irad = AASCoordinateTransformation.DegreesToRadians(I);

            double X1 = details.Satellite1.r * Math.Cos(L1 - psi) * Math.Cos(B1);
            double X2 = details.Satellite2.r * Math.Cos(L2 - psi) * Math.Cos(B2);
            double X3 = details.Satellite3.r * Math.Cos(L3 - psi) * Math.Cos(B3);
            double X4 = details.Satellite4.r * Math.Cos(L4 - psi) * Math.Cos(B4);
            double X5 = 0;

            double Y1 = details.Satellite1.r * Math.Sin(L1 - psi) * Math.Cos(B1);
            double Y2 = details.Satellite2.r * Math.Sin(L2 - psi) * Math.Cos(B2);
            double Y3 = details.Satellite3.r * Math.Sin(L3 - psi) * Math.Cos(B3);
            double Y4 = details.Satellite4.r * Math.Sin(L4 - psi) * Math.Cos(B4);
            double Y5 = 0;

            double Z1 = details.Satellite1.r * Math.Sin(B1);
            double Z2 = details.Satellite2.r * Math.Sin(B2);
            double Z3 = details.Satellite3.r * Math.Sin(B3);
            double Z4 = details.Satellite4.r * Math.Sin(B4);
            double Z5 = 1;

            //Now do the rotations, first for the ficticious 5th satellite, so that we can calculate D
            double omega = AASCoordinateTransformation.DegreesToRadians(AASElementsPlanetaryOrbit.JupiterLongitudeAscendingNode(JD));
            double i     = AASCoordinateTransformation.DegreesToRadians(AASElementsPlanetaryOrbit.JupiterInclination(JD));
            double A6    = 0;
            double B6    = 0;
            double C6    = 0;

            Rotations(X5, Y5, Z5, Irad, psi, i, omega, lambda0, beta0, ref A6, ref B6, ref C6);
            double D = Math.Atan2(A6, C6);

            //Now calculate the values for satellite 1
            Rotations(X1, Y1, Z1, Irad, psi, i, omega, lambda0, beta0, ref A6, ref B6, ref C6);
            details.Satellite1.TrueRectangularCoordinates.X = A6 * Math.Cos(D) - C6 * Math.Sin(D);
            details.Satellite1.TrueRectangularCoordinates.Y = A6 * Math.Sin(D) + C6 * Math.Cos(D);
            details.Satellite1.TrueRectangularCoordinates.Z = B6;

            //Now calculate the values for satellite 2
            Rotations(X2, Y2, Z2, Irad, psi, i, omega, lambda0, beta0, ref A6, ref B6, ref C6);
            details.Satellite2.TrueRectangularCoordinates.X = A6 * Math.Cos(D) - C6 * Math.Sin(D);
            details.Satellite2.TrueRectangularCoordinates.Y = A6 * Math.Sin(D) + C6 * Math.Cos(D);
            details.Satellite2.TrueRectangularCoordinates.Z = B6;

            //Now calculate the values for satellite 3
            Rotations(X3, Y3, Z3, Irad, psi, i, omega, lambda0, beta0, ref A6, ref B6, ref C6);
            details.Satellite3.TrueRectangularCoordinates.X = A6 * Math.Cos(D) - C6 * Math.Sin(D);
            details.Satellite3.TrueRectangularCoordinates.Y = A6 * Math.Sin(D) + C6 * Math.Cos(D);
            details.Satellite3.TrueRectangularCoordinates.Z = B6;

            //And finally for satellite 4
            Rotations(X4, Y4, Z4, Irad, psi, i, omega, lambda0, beta0, ref A6, ref B6, ref C6);
            details.Satellite4.TrueRectangularCoordinates.X = A6 * Math.Cos(D) - C6 * Math.Sin(D);
            details.Satellite4.TrueRectangularCoordinates.Y = A6 * Math.Sin(D) + C6 * Math.Cos(D);
            details.Satellite4.TrueRectangularCoordinates.Z = B6;

            //apply the differential light-time correction
            details.Satellite1.ApparentRectangularCoordinates.X = details.Satellite1.TrueRectangularCoordinates.X + Math.Abs(details.Satellite1.TrueRectangularCoordinates.Z) / 17295 * Math.Sqrt(1 - (details.Satellite1.TrueRectangularCoordinates.X / details.Satellite1.r) * (details.Satellite1.TrueRectangularCoordinates.X / details.Satellite1.r));
            details.Satellite1.ApparentRectangularCoordinates.Y = details.Satellite1.TrueRectangularCoordinates.Y;
            details.Satellite1.ApparentRectangularCoordinates.Z = details.Satellite1.TrueRectangularCoordinates.Z;

            details.Satellite2.ApparentRectangularCoordinates.X = details.Satellite2.TrueRectangularCoordinates.X + Math.Abs(details.Satellite2.TrueRectangularCoordinates.Z) / 21819 * Math.Sqrt(1 - (details.Satellite2.TrueRectangularCoordinates.X / details.Satellite2.r) * (details.Satellite2.TrueRectangularCoordinates.X / details.Satellite2.r));
            details.Satellite2.ApparentRectangularCoordinates.Y = details.Satellite2.TrueRectangularCoordinates.Y;
            details.Satellite2.ApparentRectangularCoordinates.Z = details.Satellite2.TrueRectangularCoordinates.Z;

            details.Satellite3.ApparentRectangularCoordinates.X = details.Satellite3.TrueRectangularCoordinates.X + Math.Abs(details.Satellite3.TrueRectangularCoordinates.Z) / 27558 * Math.Sqrt(1 - (details.Satellite3.TrueRectangularCoordinates.X / details.Satellite3.r) * (details.Satellite3.TrueRectangularCoordinates.X / details.Satellite3.r));
            details.Satellite3.ApparentRectangularCoordinates.Y = details.Satellite3.TrueRectangularCoordinates.Y;
            details.Satellite3.ApparentRectangularCoordinates.Z = details.Satellite3.TrueRectangularCoordinates.Z;

            details.Satellite4.ApparentRectangularCoordinates.X = details.Satellite4.TrueRectangularCoordinates.X + Math.Abs(details.Satellite4.TrueRectangularCoordinates.Z) / 36548 * Math.Sqrt(1 - (details.Satellite4.TrueRectangularCoordinates.X / details.Satellite4.r) * (details.Satellite4.TrueRectangularCoordinates.X / details.Satellite4.r));
            details.Satellite4.ApparentRectangularCoordinates.Y = details.Satellite4.TrueRectangularCoordinates.Y;
            details.Satellite4.ApparentRectangularCoordinates.Z = details.Satellite4.TrueRectangularCoordinates.Z;

            //apply the perspective effect correction
            double W = DELTA / (DELTA + details.Satellite1.TrueRectangularCoordinates.Z / 2095);

            details.Satellite1.ApparentRectangularCoordinates.X *= W;
            details.Satellite1.ApparentRectangularCoordinates.Y *= W;

            W = DELTA / (DELTA + details.Satellite2.TrueRectangularCoordinates.Z / 2095);
            details.Satellite2.ApparentRectangularCoordinates.X *= W;
            details.Satellite2.ApparentRectangularCoordinates.Y *= W;

            W = DELTA / (DELTA + details.Satellite3.TrueRectangularCoordinates.Z / 2095);
            details.Satellite3.ApparentRectangularCoordinates.X *= W;
            details.Satellite3.ApparentRectangularCoordinates.Y *= W;

            W = DELTA / (DELTA + details.Satellite4.TrueRectangularCoordinates.Z / 2095);
            details.Satellite4.ApparentRectangularCoordinates.X *= W;
            details.Satellite4.ApparentRectangularCoordinates.Y *= W;

            return(details);
        }
Exemplo n.º 5
0
        public static AASGalileanMoonsDetails Calculate(double JD, bool bHighPrecision)
        {
            //Calculate the position of the Sun
            double sunlong    = AASSun.GeometricEclipticLongitude(JD, bHighPrecision);
            double sunlongrad = AASCoordinateTransformation.DegreesToRadians(sunlong);
            double beta       = AASSun.GeometricEclipticLatitude(JD, bHighPrecision);
            double betarad    = AASCoordinateTransformation.DegreesToRadians(beta);
            double R          = AASEarth.RadiusVector(JD, bHighPrecision);

            //Calculate the the light travel time from Jupiter to the Earth
            double DELTA = 5;
            double PreviousEarthLightTravelTime = 0;
            double EarthLightTravelTime         = AASElliptical.DistanceToLightTime(DELTA);
            double JD1      = JD - EarthLightTravelTime;
            bool   bIterate = true;
            double x;
            double y;
            double z;
            double l;
            double lrad;
            double b;
            double brad;
            double r;

            while (bIterate)
            {
                //Calculate the position of Jupiter
                l    = AASJupiter.EclipticLongitude(JD1, bHighPrecision);
                lrad = AASCoordinateTransformation.DegreesToRadians(l);
                b    = AASJupiter.EclipticLatitude(JD1, bHighPrecision);
                brad = AASCoordinateTransformation.DegreesToRadians(b);
                r    = AASJupiter.RadiusVector(JD1, bHighPrecision);

                x     = r * Math.Cos(brad) * Math.Cos(lrad) + R * Math.Cos(sunlongrad);
                y     = r * Math.Cos(brad) * Math.Sin(lrad) + R * Math.Sin(sunlongrad);
                z     = r * Math.Sin(brad) + R * Math.Sin(betarad);
                DELTA = Math.Sqrt(x * x + y * y + z * z);
                EarthLightTravelTime = AASElliptical.DistanceToLightTime(DELTA);

                //Prepare for the next loop around
                bIterate = (Math.Abs(EarthLightTravelTime - PreviousEarthLightTravelTime) > 2e-6); //2e-6 corresponds to 0.17 of a second
                if (bIterate)
                {
                    JD1 = JD - EarthLightTravelTime;
                    PreviousEarthLightTravelTime = EarthLightTravelTime;
                }
            }

            //Calculate the details as seen from the earth
            AASGalileanMoonsDetails details1           = CalculateHelper(JD, sunlongrad, betarad, R, bHighPrecision);
            AASGalileanMoonDetail   details1Satellite1 = details1.Satellite1;
            AASGalileanMoonDetail   details1Satellite2 = details1.Satellite2;
            AASGalileanMoonDetail   details1Satellite3 = details1.Satellite3;
            AASGalileanMoonDetail   details1Satellite4 = details1.Satellite4;

            FillInPhenomenaDetails(ref details1Satellite1);
            FillInPhenomenaDetails(ref details1Satellite2);
            FillInPhenomenaDetails(ref details1Satellite3);
            FillInPhenomenaDetails(ref details1Satellite4);

            //Calculate the the light travel time from Jupiter to the Sun
            JD1   = JD - EarthLightTravelTime;
            l     = AASJupiter.EclipticLongitude(JD1, bHighPrecision);
            lrad  = AASCoordinateTransformation.DegreesToRadians(l);
            b     = AASJupiter.EclipticLatitude(JD1, bHighPrecision);
            brad  = AASCoordinateTransformation.DegreesToRadians(b);
            r     = AASJupiter.RadiusVector(JD1, bHighPrecision);
            x     = r * Math.Cos(brad) * Math.Cos(lrad);
            y     = r * Math.Cos(brad) * Math.Sin(lrad);
            z     = r * Math.Sin(brad);
            DELTA = Math.Sqrt(x * x + y * y + z * z);
            double SunLightTravelTime = AASElliptical.DistanceToLightTime(DELTA);

            //Calculate the details as seen from the Sun
            AASGalileanMoonsDetails details2           = CalculateHelper(JD + SunLightTravelTime - EarthLightTravelTime, sunlongrad, betarad, 0, bHighPrecision);
            AASGalileanMoonDetail   details2Satellite1 = details2.Satellite1;
            AASGalileanMoonDetail   details2Satellite2 = details2.Satellite2;
            AASGalileanMoonDetail   details2Satellite3 = details2.Satellite3;
            AASGalileanMoonDetail   details2Satellite4 = details2.Satellite4;

            FillInPhenomenaDetails(ref details2Satellite1);
            FillInPhenomenaDetails(ref details2Satellite2);
            FillInPhenomenaDetails(ref details2Satellite3);
            FillInPhenomenaDetails(ref details2Satellite4);

            //Finally transfer the required values from details2 to details1
            details1.Satellite1.bInEclipse       = details2.Satellite1.bInOccultation;
            details1.Satellite2.bInEclipse       = details2.Satellite2.bInOccultation;
            details1.Satellite3.bInEclipse       = details2.Satellite3.bInOccultation;
            details1.Satellite4.bInEclipse       = details2.Satellite4.bInOccultation;
            details1.Satellite1.bInShadowTransit = details2.Satellite1.bInTransit;
            details1.Satellite2.bInShadowTransit = details2.Satellite2.bInTransit;
            details1.Satellite3.bInShadowTransit = details2.Satellite3.bInTransit;
            details1.Satellite4.bInShadowTransit = details2.Satellite4.bInTransit;

            return(details1);
        }
        private static AASSaturnMoonsDetails CalculateHelper(double JD, double sunlongrad, double betarad, double R, bool bHighPrecision)
        {
            //What will be the return value
            AASSaturnMoonsDetails details = new AASSaturnMoonsDetails();

            //Calculate the position of Saturn decreased by the light travel time from Saturn to the specified position
            double DELTA = 9;
            double PreviousLightTravelTime = 0;
            double LightTravelTime         = AASElliptical.DistanceToLightTime(DELTA);
            double x        = 0;
            double y        = 0;
            double z        = 0;
            double JD1      = JD - LightTravelTime;
            bool   bIterate = true;

            while (bIterate)
            {
                //Calculate the position of Saturn
                double l    = AASSaturn.EclipticLongitude(JD1, bHighPrecision);
                double lrad = AASCoordinateTransformation.DegreesToRadians(l);
                double b    = AASSaturn.EclipticLatitude(JD1, bHighPrecision);
                double brad = AASCoordinateTransformation.DegreesToRadians(b);
                double r    = AASSaturn.RadiusVector(JD1, bHighPrecision);

                x               = r * Math.Cos(brad) * Math.Cos(lrad) + R * Math.Cos(sunlongrad);
                y               = r * Math.Cos(brad) * Math.Sin(lrad) + R * Math.Sin(sunlongrad);
                z               = r * Math.Sin(brad) + R * Math.Sin(betarad);
                DELTA           = Math.Sqrt(x * x + y * y + z * z);
                LightTravelTime = AASElliptical.DistanceToLightTime(DELTA);

                //Prepare for the next loop around
                bIterate = (Math.Abs(LightTravelTime - PreviousLightTravelTime) > 2e-6); //2e-6 corresponds to 0.17 of a second
                if (bIterate)
                {
                    JD1 = JD - LightTravelTime;
                    PreviousLightTravelTime = LightTravelTime;
                }
            }

            //Calculate Saturn's Longitude and Latitude
            double lambda0 = Math.Atan2(y, x);

            lambda0 = AASCoordinateTransformation.RadiansToDegrees(lambda0);
            double beta0 = Math.Atan(z / Math.Sqrt(x * x + y * y));

            beta0 = AASCoordinateTransformation.RadiansToDegrees(beta0);

            //Precess the longtitude and Latitutude to B1950.0
            AAS2DCoordinate Saturn1950 = AASPrecession.PrecessEcliptic(lambda0, beta0, JD, 2433282.4235);

            lambda0 = Saturn1950.X;
            double lambda0rad = AASCoordinateTransformation.DegreesToRadians(lambda0);

            beta0 = Saturn1950.Y;
            double beta0rad = AASCoordinateTransformation.DegreesToRadians(beta0);

            double JDE = JD - LightTravelTime;

            double t1   = JDE - 2411093.0;
            double t2   = t1 / 365.25;
            double t3   = ((JDE - 2433282.423) / 365.25) + 1950.0;
            double t4   = JDE - 2411368.0;
            double t5   = t4 / 365.25;
            double t6   = JDE - 2415020.0;
            double t7   = t6 / 36525.0;
            double t8   = t6 / 365.25;
            double t9   = (JDE - 2442000.5) / 365.25;
            double t10  = JDE - 2409786.0;
            double t11  = t10 / 36525.0;
            double t112 = t11 * t11;
            double t113 = t112 * t11;

            double W0    = AASCoordinateTransformation.MapTo0To360Range(5.095 * (t3 - 1866.39));
            double W0rad = AASCoordinateTransformation.DegreesToRadians(W0);
            double W1    = AASCoordinateTransformation.MapTo0To360Range(74.4 + 32.39 * t2);
            double W1rad = AASCoordinateTransformation.DegreesToRadians(W1);
            double W2    = AASCoordinateTransformation.MapTo0To360Range(134.3 + 92.62 * t2);
            double W2rad = AASCoordinateTransformation.DegreesToRadians(W2);
            double W3    = AASCoordinateTransformation.MapTo0To360Range(42.0 - 0.5118 * t5);
            double W3rad = AASCoordinateTransformation.DegreesToRadians(W3);
            double W4    = AASCoordinateTransformation.MapTo0To360Range(276.59 + 0.5118 * t5);
            double W4rad = AASCoordinateTransformation.DegreesToRadians(W4);
            double W5    = AASCoordinateTransformation.MapTo0To360Range(267.2635 + 1222.1136 * t7);
            double W5rad = AASCoordinateTransformation.DegreesToRadians(W5);
            double W6    = AASCoordinateTransformation.MapTo0To360Range(175.4762 + 1221.5515 * t7);
            double W6rad = AASCoordinateTransformation.DegreesToRadians(W6);
            double W7    = AASCoordinateTransformation.MapTo0To360Range(2.4891 + 0.002435 * t7);
            double W7rad = AASCoordinateTransformation.DegreesToRadians(W7);
            double W8    = AASCoordinateTransformation.MapTo0To360Range(113.35 - 0.2597 * t7);
            double W8rad = AASCoordinateTransformation.DegreesToRadians(W8);

            double s1 = Math.Sin(AASCoordinateTransformation.DegreesToRadians(28.0817));
            double s2 = Math.Sin(AASCoordinateTransformation.DegreesToRadians(168.8112));
            double c1 = Math.Cos(AASCoordinateTransformation.DegreesToRadians(28.0817));
            double c2 = Math.Cos(AASCoordinateTransformation.DegreesToRadians(168.8112));
            double e1 = 0.05589 - 0.000346 * t7;


            //Satellite 1
            double L       = AASCoordinateTransformation.MapTo0To360Range(127.64 + 381.994497 * t1 - 43.57 * Math.Sin(W0rad) - 0.720 * Math.Sin(3 * W0rad) - 0.02144 * Math.Sin(5 * W0rad));
            double p       = 106.1 + 365.549 * t2;
            double M       = L - p;
            double Mrad    = AASCoordinateTransformation.DegreesToRadians(M);
            double C       = 2.18287 * Math.Sin(Mrad) + 0.025988 * Math.Sin(2 * Mrad) + 0.00043 * Math.Sin(3 * Mrad);
            double Crad    = AASCoordinateTransformation.DegreesToRadians(C);
            double lambda1 = AASCoordinateTransformation.MapTo0To360Range(L + C);
            double r1      = 3.06879 / (1 + 0.01905 * Math.Cos(Mrad + Crad));
            double gamma1  = 1.563;
            double omega1  = AASCoordinateTransformation.MapTo0To360Range(54.5 - 365.072 * t2);

            //Satellite 2
            L    = AASCoordinateTransformation.MapTo0To360Range(200.317 + 262.7319002 * t1 + 0.25667 * Math.Sin(W1rad) + 0.20883 * Math.Sin(W2rad));
            p    = 309.107 + 123.44121 * t2;
            M    = L - p;
            Mrad = AASCoordinateTransformation.DegreesToRadians(M);
            C    = 0.55577 * Math.Sin(Mrad) + 0.00168 * Math.Sin(2 * Mrad);
            Crad = AASCoordinateTransformation.DegreesToRadians(C);
            double lambda2 = AASCoordinateTransformation.MapTo0To360Range(L + C);
            double r2      = 3.94118 / (1 + 0.00485 * Math.Cos(Mrad + Crad));
            double gamma2  = 0.0262;
            double omega2  = AASCoordinateTransformation.MapTo0To360Range(348 - 151.95 * t2);

            //Satellite 3
            double lambda3 = AASCoordinateTransformation.MapTo0To360Range(285.306 + 190.69791226 * t1 + 2.063 * Math.Sin(W0rad) + 0.03409 * Math.Sin(3 * W0rad) + 0.001015 * Math.Sin(5 * W0rad));
            double r3      = 4.880998;
            double gamma3  = 1.0976;
            double omega3  = AASCoordinateTransformation.MapTo0To360Range(111.33 - 72.2441 * t2);

            //Satellite 4
            L    = AASCoordinateTransformation.MapTo0To360Range(254.712 + 131.53493193 * t1 - 0.0215 * Math.Sin(W1rad) - 0.01733 * Math.Sin(W2rad));
            p    = 174.8 + 30.820 * t2;
            M    = L - p;
            Mrad = AASCoordinateTransformation.DegreesToRadians(M);
            C    = 0.24717 * Math.Sin(Mrad) + 0.00033 * Math.Sin(2 * Mrad);
            Crad = AASCoordinateTransformation.DegreesToRadians(C);
            double lambda4 = AASCoordinateTransformation.MapTo0To360Range(L + C);
            double r4      = 6.24871 / (1 + 0.002157 * Math.Cos(Mrad + Crad));
            double gamma4  = 0.0139;
            double omega4  = AASCoordinateTransformation.MapTo0To360Range(232 - 30.27 * t2);

            //Satellite 5
            double pdash    = 342.7 + 10.057 * t2;
            double pdashrad = AASCoordinateTransformation.DegreesToRadians(pdash);
            double a1       = 0.000265 * Math.Sin(pdashrad) + 0.001 * Math.Sin(W4rad); //Note the book uses the incorrect constant 0.01*Math.Sin(W4rad);
            double a2       = 0.000265 * Math.Cos(pdashrad) + 0.001 * Math.Cos(W4rad); //Note the book uses the incorrect constant 0.01*cos(W4rad);
            double e        = Math.Sqrt(a1 * a1 + a2 * a2);

            p = AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(a1, a2));
            double N          = 345 - 10.057 * t2;
            double Nrad       = AASCoordinateTransformation.DegreesToRadians(N);
            double lambdadash = AASCoordinateTransformation.MapTo0To360Range(359.244 + 79.69004720 * t1 + 0.086754 * Math.Sin(Nrad));
            double i          = 28.0362 + 0.346898 * Math.Cos(Nrad) + 0.01930 * Math.Cos(W3rad);
            double omega      = 168.8034 + 0.736936 * Math.Sin(Nrad) + 0.041 * Math.Sin(W3rad);
            double a          = 8.725924;
            double lambda5    = 0;
            double gamma5     = 0;
            double omega5     = 0;
            double r5         = 0;

            HelperSubroutine(e, lambdadash, p, a, omega, i, c1, s1, ref r5, ref lambda5, ref gamma5, ref omega5);

            //Satellite 6
            L = 261.1582 + 22.57697855 * t4 + 0.074025 * Math.Sin(W3rad);
            double idash        = 27.45141 + 0.295999 * Math.Cos(W3rad);
            double idashrad     = AASCoordinateTransformation.DegreesToRadians(idash);
            double omegadash    = 168.66925 + 0.628808 * Math.Sin(W3rad);
            double omegadashrad = AASCoordinateTransformation.DegreesToRadians(omegadash);

            a1 = Math.Sin(W7rad) * Math.Sin(omegadashrad - W8rad);
            a2 = Math.Cos(W7rad) * Math.Sin(idashrad) - Math.Sin(W7rad) * Math.Cos(idashrad) * Math.Cos(omegadashrad - W8rad);
            double g0  = AASCoordinateTransformation.DegreesToRadians(102.8623);
            double psi = Math.Atan2(a1, a2);

            if (a2 < 0)
            {
                psi += AASCoordinateTransformation.PI();
            }
            double psideg = AASCoordinateTransformation.RadiansToDegrees(psi);
            double s      = Math.Sqrt(a1 * a1 + a2 * a2);
            double g      = W4 - omegadash - psideg;
            double w_     = 0;

            for (int j = 0; j < 3; j++)
            {
                w_ = W4 + 0.37515 * (Math.Sin(2 * AASCoordinateTransformation.DegreesToRadians(g)) - Math.Sin(2 * g0));
                g  = w_ - omegadash - psideg;
            }
            double grad     = AASCoordinateTransformation.DegreesToRadians(g);
            double edash    = 0.029092 + 0.00019048 * (Math.Cos(2 * grad) - Math.Cos(2 * g0));
            double q        = AASCoordinateTransformation.DegreesToRadians(2 * (W5 - w_));
            double b1       = Math.Sin(idashrad) * Math.Sin(omegadashrad - W8rad);
            double b2       = Math.Cos(W7rad) * Math.Sin(idashrad) * Math.Cos(omegadashrad - W8rad) - Math.Sin(W7rad) * Math.Cos(idashrad);
            double atanb1b2 = Math.Atan2(b1, b2);
            double theta    = atanb1b2 + W8rad;

            e = edash + 0.002778797 * edash * Math.Cos(q);
            p = w_ + 0.159215 * Math.Sin(q);
            double u = 2 * W5rad - 2 * theta + psi;
            double h = 0.9375 * edash * edash * Math.Sin(q) + 0.1875 * s * s * Math.Sin(2 * (W5rad - theta));

            lambdadash = AASCoordinateTransformation.MapTo0To360Range(L - 0.254744 * (e1 * Math.Sin(W6rad) + 0.75 * e1 * e1 * Math.Sin(2 * W6rad) + h));
            i          = idash + 0.031843 * s * Math.Cos(u);
            omega      = omegadash + (0.031843 * s * Math.Sin(u)) / Math.Sin(idashrad);
            a          = 20.216193;
            double lambda6 = 0;
            double gamma6  = 0;
            double omega6  = 0;
            double r6      = 0;

            HelperSubroutine(e, lambdadash, p, a, omega, i, c1, s1, ref r6, ref lambda6, ref gamma6, ref omega6);

            //Satellite 7
            double eta     = 92.39 + 0.5621071 * t6;
            double etarad  = AASCoordinateTransformation.DegreesToRadians(eta);
            double zeta    = 148.19 - 19.18 * t8;
            double zetarad = AASCoordinateTransformation.DegreesToRadians(zeta);

            theta = AASCoordinateTransformation.DegreesToRadians(184.8 - 35.41 * t9);
            double thetadash = theta - AASCoordinateTransformation.DegreesToRadians(7.5);
            double aS        = AASCoordinateTransformation.DegreesToRadians(176 + 12.22 * t8);
            double bs        = AASCoordinateTransformation.DegreesToRadians(8 + 24.44 * t8);
            double cs        = bs + AASCoordinateTransformation.DegreesToRadians(5);

            w_ = 69.898 - 18.67088 * t8;
            double phi    = 2 * (w_ - W5);
            double phirad = AASCoordinateTransformation.DegreesToRadians(phi);
            double chi    = 94.9 - 2.292 * t8;
            double chirad = AASCoordinateTransformation.DegreesToRadians(chi);

            a = 24.50601 - 0.08686 * Math.Cos(etarad) - 0.00166 * Math.Cos(zetarad + etarad) + 0.00175 * Math.Cos(zetarad - etarad);
            e = 0.103458 - 0.004099 * Math.Cos(etarad) - 0.000167 * Math.Cos(zetarad + etarad) + 0.000235 * Math.Cos(zetarad - etarad) +
                0.02303 * Math.Cos(zetarad) - 0.00212 * Math.Cos(2 * zetarad) + 0.000151 * Math.Cos(3 * zetarad) + 0.00013 * Math.Cos(phirad);
            p = w_ + 0.15648 * Math.Sin(chirad) - 0.4457 * Math.Sin(etarad) - 0.2657 * Math.Sin(zetarad + etarad) +
                -0.3573 * Math.Sin(zetarad - etarad) - 12.872 * Math.Sin(zetarad) + 1.668 * Math.Sin(2 * zetarad) +
                -0.2419 * Math.Sin(3 * zetarad) - 0.07 * Math.Sin(phirad);
            lambdadash = AASCoordinateTransformation.MapTo0To360Range(177.047 + 16.91993829 * t6 + 0.15648 * Math.Sin(chirad) + 9.142 * Math.Sin(etarad) +
                                                                      0.007 * Math.Sin(2 * etarad) - 0.014 * Math.Sin(3 * etarad) + 0.2275 * Math.Sin(zetarad + etarad) +
                                                                      0.2112 * Math.Sin(zetarad - etarad) - 0.26 * Math.Sin(zetarad) - 0.0098 * Math.Sin(2 * zetarad) +
                                                                      -0.013 * Math.Sin(aS) + 0.017 * Math.Sin(bs) - 0.0303 * Math.Sin(phirad));
            i     = 27.3347 + 0.643486 * Math.Cos(chirad) + 0.315 * Math.Cos(W3rad) + 0.018 * Math.Cos(theta) - 0.018 * Math.Cos(cs);
            omega = 168.6812 + 1.40136 * Math.Cos(chirad) + 0.68599 * Math.Sin(W3rad) - 0.0392 * Math.Sin(cs) + 0.0366 * Math.Sin(thetadash);
            double lambda7 = 0;
            double gamma7  = 0;
            double omega7  = 0;
            double r7      = 0;

            HelperSubroutine(e, lambdadash, p, a, omega, i, c1, s1, ref r7, ref lambda7, ref gamma7, ref omega7);

            //Satellite 8
            L = AASCoordinateTransformation.MapTo0To360Range(261.1582 + 22.57697855 * t4);
            double w_dash = 91.796 + 0.562 * t7;

            psi = 4.367 - 0.195 * t7;
            double psirad = AASCoordinateTransformation.DegreesToRadians(psi);

            theta  = 146.819 - 3.198 * t7;
            phi    = 60.470 + 1.521 * t7;
            phirad = AASCoordinateTransformation.DegreesToRadians(phi);
            double PHI = 205.055 - 2.091 * t7;

            edash = 0.028298 + 0.001156 * t11;
            double w_0 = 352.91 + 11.71 * t11;
            double mu  = AASCoordinateTransformation.MapTo0To360Range(76.3852 + 4.53795125 * t10);

            idash     = 18.4602 - 0.9518 * t11 - 0.072 * t112 + 0.0054 * t113;
            idashrad  = AASCoordinateTransformation.DegreesToRadians(idash);
            omegadash = 143.198 - 3.919 * t11 + 0.116 * t112 + 0.008 * t113;
            double _l = AASCoordinateTransformation.DegreesToRadians(mu - w_0);

            g = AASCoordinateTransformation.DegreesToRadians(w_0 - omegadash - psi);
            double g1 = AASCoordinateTransformation.DegreesToRadians(w_0 - omegadash - phi);
            double ls = AASCoordinateTransformation.DegreesToRadians(W5 - w_dash);
            double gs = AASCoordinateTransformation.DegreesToRadians(w_dash - theta);
            double lt = AASCoordinateTransformation.DegreesToRadians(L - W4);
            double gt = AASCoordinateTransformation.DegreesToRadians(W4 - PHI);
            double u1 = 2 * (_l + g - ls - gs);
            double u2 = _l + g1 - lt - gt;
            double u3 = _l + 2 * (g - ls - gs);
            double u4 = lt + gt - g1;
            double u5 = 2 * (ls + gs);

            a = 58.935028 + 0.004638 * Math.Cos(u1) + 0.058222 * Math.Cos(u2);
            e = edash - 0.0014097 * Math.Cos(g1 - gt) + 0.0003733 * Math.Cos(u5 - 2 * g) +
                0.0001180 * Math.Cos(u3) + 0.0002408 * Math.Cos(_l) +
                0.0002849 * Math.Cos(_l + u2) + 0.0006190 * Math.Cos(u4);
            double w = 0.08077 * Math.Sin(g1 - gt) + 0.02139 * Math.Sin(u5 - 2 * g) - 0.00676 * Math.Sin(u3) +
                       0.01380 * Math.Sin(_l) + 0.01632 * Math.Sin(_l + u2) + 0.03547 * Math.Sin(u4);

            p          = w_0 + w / edash;
            lambdadash = mu - 0.04299 * Math.Sin(u2) - 0.00789 * Math.Sin(u1) - 0.06312 * Math.Sin(ls) +
                         -0.00295 * Math.Sin(2 * ls) - 0.02231 * Math.Sin(u5) + 0.00650 * Math.Sin(u5 + psirad);
            i = idash + 0.04204 * Math.Cos(u5 + psirad) + 0.00235 * Math.Cos(_l + g1 + lt + gt + phirad) +
                0.00360 * Math.Cos(u2 + phirad);
            double wdash = 0.04204 * Math.Sin(u5 + psirad) + 0.00235 * Math.Sin(_l + g1 + lt + gt + phirad) +
                           0.00358 * Math.Sin(u2 + phirad);

            omega = omegadash + wdash / Math.Sin(idashrad);
            double lambda8 = 0;
            double gamma8  = 0;
            double omega8  = 0;
            double r8      = 0;

            HelperSubroutine(e, lambdadash, p, a, omega, i, c1, s1, ref r8, ref lambda8, ref gamma8, ref omega8);


            u = AASCoordinateTransformation.DegreesToRadians(lambda1 - omega1);
            w = AASCoordinateTransformation.DegreesToRadians(omega1 - 168.8112);
            double gamma1rad = AASCoordinateTransformation.DegreesToRadians(gamma1);
            double X1        = r1 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma1rad) * Math.Sin(w));
            double Y1        = r1 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma1rad) + Math.Cos(u) * Math.Sin(w));
            double Z1        = r1 * Math.Sin(u) * Math.Sin(gamma1rad);

            u = AASCoordinateTransformation.DegreesToRadians(lambda2 - omega2);
            w = AASCoordinateTransformation.DegreesToRadians(omega2 - 168.8112);
            double gamma2rad = AASCoordinateTransformation.DegreesToRadians(gamma2);
            double X2        = r2 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma2rad) * Math.Sin(w));
            double Y2        = r2 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma2rad) + Math.Cos(u) * Math.Sin(w));
            double Z2        = r2 * Math.Sin(u) * Math.Sin(gamma2rad);

            u = AASCoordinateTransformation.DegreesToRadians(lambda3 - omega3);
            w = AASCoordinateTransformation.DegreesToRadians(omega3 - 168.8112);
            double gamma3rad = AASCoordinateTransformation.DegreesToRadians(gamma3);
            double X3        = r3 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma3rad) * Math.Sin(w));
            double Y3        = r3 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma3rad) + Math.Cos(u) * Math.Sin(w));
            double Z3        = r3 * Math.Sin(u) * Math.Sin(gamma3rad);

            u = AASCoordinateTransformation.DegreesToRadians(lambda4 - omega4);
            w = AASCoordinateTransformation.DegreesToRadians(omega4 - 168.8112);
            double gamma4rad = AASCoordinateTransformation.DegreesToRadians(gamma4);
            double X4        = r4 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma4rad) * Math.Sin(w));
            double Y4        = r4 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma4rad) + Math.Cos(u) * Math.Sin(w));
            double Z4        = r4 * Math.Sin(u) * Math.Sin(gamma4rad);

            u = AASCoordinateTransformation.DegreesToRadians(lambda5 - omega5);
            w = AASCoordinateTransformation.DegreesToRadians(omega5 - 168.8112);
            double gamma5rad = AASCoordinateTransformation.DegreesToRadians(gamma5);
            double X5        = r5 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma5rad) * Math.Sin(w));
            double Y5        = r5 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma5rad) + Math.Cos(u) * Math.Sin(w));
            double Z5        = r5 * Math.Sin(u) * Math.Sin(gamma5rad);

            u = AASCoordinateTransformation.DegreesToRadians(lambda6 - omega6);
            w = AASCoordinateTransformation.DegreesToRadians(omega6 - 168.8112);
            double gamma6rad = AASCoordinateTransformation.DegreesToRadians(gamma6);
            double X6        = r6 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma6rad) * Math.Sin(w));
            double Y6        = r6 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma6rad) + Math.Cos(u) * Math.Sin(w));
            double Z6        = r6 * Math.Sin(u) * Math.Sin(gamma6rad);

            u = AASCoordinateTransformation.DegreesToRadians(lambda7 - omega7);
            w = AASCoordinateTransformation.DegreesToRadians(omega7 - 168.8112);
            double gamma7rad = AASCoordinateTransformation.DegreesToRadians(gamma7);
            double X7        = r7 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma7rad) * Math.Sin(w));
            double Y7        = r7 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma7rad) + Math.Cos(u) * Math.Sin(w));
            double Z7        = r7 * Math.Sin(u) * Math.Sin(gamma7rad);

            u = AASCoordinateTransformation.DegreesToRadians(lambda8 - omega8);
            w = AASCoordinateTransformation.DegreesToRadians(omega8 - 168.8112);
            double gamma8rad = AASCoordinateTransformation.DegreesToRadians(gamma8);
            double X8        = r8 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma8rad) * Math.Sin(w));
            double Y8        = r8 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma8rad) + Math.Cos(u) * Math.Sin(w));
            double Z8        = r8 * Math.Sin(u) * Math.Sin(gamma8rad);

            double X9 = 0;
            double Y9 = 0;
            double Z9 = 1;

            //Now do the rotations, first for the ficticious 9th satellite, so that we can calculate D
            double A4 = 0;
            double B4 = 0;
            double C4 = 0;

            Rotations(X9, Y9, Z9, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
            double D = Math.Atan2(A4, C4);

            //Now calculate the values for satellite 1
            Rotations(X1, Y1, Z1, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
            details.Satellite1.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
            details.Satellite1.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
            details.Satellite1.TrueRectangularCoordinates.Z = B4;

            //Now calculate the values for satellite 2
            Rotations(X2, Y2, Z2, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
            details.Satellite2.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
            details.Satellite2.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
            details.Satellite2.TrueRectangularCoordinates.Z = B4;

            //Now calculate the values for satellite 3
            Rotations(X3, Y3, Z3, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
            details.Satellite3.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
            details.Satellite3.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
            details.Satellite3.TrueRectangularCoordinates.Z = B4;

            //Now calculate the values for satellite 4
            Rotations(X4, Y4, Z4, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
            details.Satellite4.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
            details.Satellite4.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
            details.Satellite4.TrueRectangularCoordinates.Z = B4;

            //Now calculate the values for satellite 5
            Rotations(X5, Y5, Z5, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
            details.Satellite5.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
            details.Satellite5.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
            details.Satellite5.TrueRectangularCoordinates.Z = B4;

            //Now calculate the values for satellite 6
            Rotations(X6, Y6, Z6, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
            details.Satellite6.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
            details.Satellite6.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
            details.Satellite6.TrueRectangularCoordinates.Z = B4;

            //Now calculate the values for satellite 7
            Rotations(X7, Y7, Z7, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
            details.Satellite7.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
            details.Satellite7.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
            details.Satellite7.TrueRectangularCoordinates.Z = B4;

            //Now calculate the values for satellite 8
            Rotations(X8, Y8, Z8, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
            details.Satellite8.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
            details.Satellite8.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
            details.Satellite8.TrueRectangularCoordinates.Z = B4;


            //apply the differential light-time correction
            details.Satellite1.ApparentRectangularCoordinates.X = details.Satellite1.TrueRectangularCoordinates.X + Math.Abs(details.Satellite1.TrueRectangularCoordinates.Z) / 20947 * Math.Sqrt(1 - (details.Satellite1.TrueRectangularCoordinates.X / r1) * (details.Satellite1.TrueRectangularCoordinates.X / r1));
            details.Satellite1.ApparentRectangularCoordinates.Y = details.Satellite1.TrueRectangularCoordinates.Y;
            details.Satellite1.ApparentRectangularCoordinates.Z = details.Satellite1.TrueRectangularCoordinates.Z;

            details.Satellite2.ApparentRectangularCoordinates.X = details.Satellite2.TrueRectangularCoordinates.X + Math.Abs(details.Satellite2.TrueRectangularCoordinates.Z) / 23715 * Math.Sqrt(1 - (details.Satellite2.TrueRectangularCoordinates.X / r2) * (details.Satellite2.TrueRectangularCoordinates.X / r2));
            details.Satellite2.ApparentRectangularCoordinates.Y = details.Satellite2.TrueRectangularCoordinates.Y;
            details.Satellite2.ApparentRectangularCoordinates.Z = details.Satellite2.TrueRectangularCoordinates.Z;

            details.Satellite3.ApparentRectangularCoordinates.X = details.Satellite3.TrueRectangularCoordinates.X + Math.Abs(details.Satellite3.TrueRectangularCoordinates.Z) / 26382 * Math.Sqrt(1 - (details.Satellite3.TrueRectangularCoordinates.X / r3) * (details.Satellite3.TrueRectangularCoordinates.X / r3));
            details.Satellite3.ApparentRectangularCoordinates.Y = details.Satellite3.TrueRectangularCoordinates.Y;
            details.Satellite3.ApparentRectangularCoordinates.Z = details.Satellite3.TrueRectangularCoordinates.Z;

            details.Satellite4.ApparentRectangularCoordinates.X = details.Satellite4.TrueRectangularCoordinates.X + Math.Abs(details.Satellite4.TrueRectangularCoordinates.Z) / 29876 * Math.Sqrt(1 - (details.Satellite4.TrueRectangularCoordinates.X / r4) * (details.Satellite4.TrueRectangularCoordinates.X / r4));
            details.Satellite4.ApparentRectangularCoordinates.Y = details.Satellite4.TrueRectangularCoordinates.Y;
            details.Satellite4.ApparentRectangularCoordinates.Z = details.Satellite4.TrueRectangularCoordinates.Z;

            details.Satellite5.ApparentRectangularCoordinates.X = details.Satellite5.TrueRectangularCoordinates.X + Math.Abs(details.Satellite5.TrueRectangularCoordinates.Z) / 35313 * Math.Sqrt(1 - (details.Satellite5.TrueRectangularCoordinates.X / r5) * (details.Satellite5.TrueRectangularCoordinates.X / r5));
            details.Satellite5.ApparentRectangularCoordinates.Y = details.Satellite5.TrueRectangularCoordinates.Y;
            details.Satellite5.ApparentRectangularCoordinates.Z = details.Satellite5.TrueRectangularCoordinates.Z;

            details.Satellite6.ApparentRectangularCoordinates.X = details.Satellite6.TrueRectangularCoordinates.X + Math.Abs(details.Satellite6.TrueRectangularCoordinates.Z) / 53800 * Math.Sqrt(1 - (details.Satellite6.TrueRectangularCoordinates.X / r6) * (details.Satellite6.TrueRectangularCoordinates.X / r6));
            details.Satellite6.ApparentRectangularCoordinates.Y = details.Satellite6.TrueRectangularCoordinates.Y;
            details.Satellite6.ApparentRectangularCoordinates.Z = details.Satellite6.TrueRectangularCoordinates.Z;

            details.Satellite7.ApparentRectangularCoordinates.X = details.Satellite7.TrueRectangularCoordinates.X + Math.Abs(details.Satellite7.TrueRectangularCoordinates.Z) / 59222 * Math.Sqrt(1 - (details.Satellite7.TrueRectangularCoordinates.X / r7) * (details.Satellite7.TrueRectangularCoordinates.X / r7));
            details.Satellite7.ApparentRectangularCoordinates.Y = details.Satellite7.TrueRectangularCoordinates.Y;
            details.Satellite7.ApparentRectangularCoordinates.Z = details.Satellite7.TrueRectangularCoordinates.Z;

            details.Satellite8.ApparentRectangularCoordinates.X = details.Satellite8.TrueRectangularCoordinates.X + Math.Abs(details.Satellite8.TrueRectangularCoordinates.Z) / 91820 * Math.Sqrt(1 - (details.Satellite8.TrueRectangularCoordinates.X / r8) * (details.Satellite8.TrueRectangularCoordinates.X / r8));
            details.Satellite8.ApparentRectangularCoordinates.Y = details.Satellite8.TrueRectangularCoordinates.Y;
            details.Satellite8.ApparentRectangularCoordinates.Z = details.Satellite8.TrueRectangularCoordinates.Z;


            //apply the perspective effect correction
            double W = DELTA / (DELTA + details.Satellite1.TrueRectangularCoordinates.Z / 2475);

            details.Satellite1.ApparentRectangularCoordinates.X *= W;
            details.Satellite1.ApparentRectangularCoordinates.Y *= W;

            W = DELTA / (DELTA + details.Satellite2.TrueRectangularCoordinates.Z / 2475);
            details.Satellite2.ApparentRectangularCoordinates.X *= W;
            details.Satellite2.ApparentRectangularCoordinates.Y *= W;

            W = DELTA / (DELTA + details.Satellite3.TrueRectangularCoordinates.Z / 2475);
            details.Satellite3.ApparentRectangularCoordinates.X *= W;
            details.Satellite3.ApparentRectangularCoordinates.Y *= W;

            W = DELTA / (DELTA + details.Satellite4.TrueRectangularCoordinates.Z / 2475);
            details.Satellite4.ApparentRectangularCoordinates.X *= W;
            details.Satellite4.ApparentRectangularCoordinates.Y *= W;

            W = DELTA / (DELTA + details.Satellite5.TrueRectangularCoordinates.Z / 2475);
            details.Satellite5.ApparentRectangularCoordinates.X *= W;
            details.Satellite5.ApparentRectangularCoordinates.Y *= W;

            W = DELTA / (DELTA + details.Satellite6.TrueRectangularCoordinates.Z / 2475);
            details.Satellite6.ApparentRectangularCoordinates.X *= W;
            details.Satellite6.ApparentRectangularCoordinates.Y *= W;

            W = DELTA / (DELTA + details.Satellite7.TrueRectangularCoordinates.Z / 2475);
            details.Satellite7.ApparentRectangularCoordinates.X *= W;
            details.Satellite7.ApparentRectangularCoordinates.Y *= W;

            W = DELTA / (DELTA + details.Satellite8.TrueRectangularCoordinates.Z / 2475);
            details.Satellite8.ApparentRectangularCoordinates.X *= W;
            details.Satellite8.ApparentRectangularCoordinates.Y *= W;

            return(details);
        }
        public static AASSaturnRingDetails Calculate(double JD, bool bHighPrecision)
        {
            //What will be the return value
            AASSaturnRingDetails details = new AASSaturnRingDetails();

            double T  = (JD - 2451545) / 36525;
            double T2 = T * T;

            //Step 1. Calculate the inclination of the plane of the ring and the longitude of the ascending node referred to the ecliptic and mean equinox of the date
            double i        = 28.075216 - 0.012998 * T + 0.000004 * T2;
            double irad     = AASCoordinateTransformation.DegreesToRadians(i);
            double omega    = 169.508470 + 1.394681 * T + 0.000412 * T2;
            double omegarad = AASCoordinateTransformation.DegreesToRadians(omega);

            //Step 2. Calculate the heliocentric longitude, latitude and radius vector of the Earth in the FK5 system
            double l0 = AASEarth.EclipticLongitude(JD, bHighPrecision);
            double b0 = AASEarth.EclipticLatitude(JD, bHighPrecision);

            l0 += AASFK5.CorrectionInLongitude(l0, b0, JD);
            double l0rad = AASCoordinateTransformation.DegreesToRadians(l0);

            b0 += AASFK5.CorrectionInLatitude(l0, JD);
            double b0rad = AASCoordinateTransformation.DegreesToRadians(b0);
            double R     = AASEarth.RadiusVector(JD, bHighPrecision);

            //Step 3. Calculate the corresponding coordinates l,b,r for Saturn but for the instance t-lightraveltime
            double DELTA = 9;
            double PreviousEarthLightTravelTime = 0;
            double EarthLightTravelTime         = AASElliptical.DistanceToLightTime(DELTA);
            double JD1      = JD - EarthLightTravelTime;
            bool   bIterate = true;
            double x        = 0;
            double y        = 0;
            double z        = 0;
            double l        = 0;
            double b        = 0;
            double r        = 0;

            while (bIterate)
            {
                //Calculate the position of Saturn
                l  = AASSaturn.EclipticLongitude(JD1, bHighPrecision);
                b  = AASSaturn.EclipticLatitude(JD1, bHighPrecision);
                l += AASFK5.CorrectionInLongitude(l, b, JD1);
                b += AASFK5.CorrectionInLatitude(l, JD1);

                double lrad = AASCoordinateTransformation.DegreesToRadians(l);
                double brad = AASCoordinateTransformation.DegreesToRadians(b);
                r = AASSaturn.RadiusVector(JD1, bHighPrecision);

                //Step 4
                x     = r * Math.Cos(brad) * Math.Cos(lrad) - R * Math.Cos(l0rad);
                y     = r * Math.Cos(brad) * Math.Sin(lrad) - R * Math.Sin(l0rad);
                z     = r * Math.Sin(brad) - R * Math.Sin(b0rad);
                DELTA = Math.Sqrt(x * x + y * y + z * z);
                EarthLightTravelTime = AASElliptical.DistanceToLightTime(DELTA);

                //Prepare for the next loop around
                bIterate = (Math.Abs(EarthLightTravelTime - PreviousEarthLightTravelTime) > 2e-6); //2e-6 corresponds to 0.17 of a second
                if (bIterate)
                {
                    JD1 = JD - EarthLightTravelTime;
                    PreviousEarthLightTravelTime = EarthLightTravelTime;
                }
            }

            //Step 5. Calculate Saturn's geocentric Longitude and Latitude
            double lambda = Math.Atan2(y, x);
            double beta   = Math.Atan2(z, Math.Sqrt(x * x + y * y));

            //Step 6. Calculate B, a and b
            details.B = Math.Asin(Math.Sin(irad) * Math.Cos(beta) * Math.Sin(lambda - omegarad) - Math.Cos(irad) * Math.Sin(beta));
            details.a = 375.35 / DELTA;
            details.b = details.a * Math.Sin(Math.Abs(details.B));
            details.B = AASCoordinateTransformation.RadiansToDegrees(details.B);

            //Step 7. Calculate the longitude of the ascending node of Saturn's orbit
            double N        = 113.6655 + 0.8771 * T;
            double Nrad     = AASCoordinateTransformation.DegreesToRadians(N);
            double ldash    = l - 0.01759 / r;
            double ldashrad = AASCoordinateTransformation.DegreesToRadians(ldash);
            double bdash    = b - 0.000764 * Math.Cos(ldashrad - Nrad) / r;
            double bdashrad = AASCoordinateTransformation.DegreesToRadians(bdash);

            //Step 8. Calculate Bdash
            details.Bdash = AASCoordinateTransformation.RadiansToDegrees(Math.Asin(Math.Sin(irad) * Math.Cos(bdashrad) * Math.Sin(ldashrad - omegarad) - Math.Cos(irad) * Math.Sin(bdashrad)));

            //Step 9. Calculate DeltaU
            details.U1     = AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(Math.Sin(irad) * Math.Sin(bdashrad) + Math.Cos(irad) * Math.Cos(bdashrad) * Math.Sin(ldashrad - omegarad), Math.Cos(bdashrad) * Math.Cos(ldashrad - omegarad))));
            details.U2     = AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(Math.Sin(irad) * Math.Sin(beta) + Math.Cos(irad) * Math.Cos(beta) * Math.Sin(lambda - omegarad), Math.Cos(beta) * Math.Cos(lambda - omegarad))));
            details.DeltaU = Math.Abs(details.U1 - details.U2);
            if (details.DeltaU > 180)
            {
                details.DeltaU = 360 - details.DeltaU;
            }

            //Step 10. Calculate the Nutations
            double Obliquity           = AASNutation.TrueObliquityOfEcliptic(JD);
            double NutationInLongitude = AASNutation.NutationInLongitude(JD);

            //Step 11. Calculate the Ecliptical longitude and latitude of the northern pole of the ring plane
            double lambda0 = omega - 90;
            double beta0   = 90 - i;

            //Step 12. Correct lambda and beta for the aberration of Saturn
            lambda += AASCoordinateTransformation.DegreesToRadians(0.005693 * Math.Cos(l0rad - lambda) / Math.Cos(beta));
            beta   += AASCoordinateTransformation.DegreesToRadians(0.005693 * Math.Sin(l0rad - lambda) * Math.Sin(beta));

            //Step 13. Add nutation in longitude to lambda0 and lambda
            lambda   = AASCoordinateTransformation.RadiansToDegrees(lambda);
            lambda  += NutationInLongitude / 3600;
            lambda   = AASCoordinateTransformation.MapTo0To360Range(lambda);
            lambda0 += NutationInLongitude / 3600;
            lambda0  = AASCoordinateTransformation.MapTo0To360Range(lambda0);

            //Step 14. Convert to equatorial coordinates
            beta = AASCoordinateTransformation.RadiansToDegrees(beta);
            AAS2DCoordinate GeocentricEclipticSaturn = AASCoordinateTransformation.Ecliptic2Equatorial(lambda, beta, Obliquity);
            double          alpha = AASCoordinateTransformation.HoursToRadians(GeocentricEclipticSaturn.X);
            double          delta = AASCoordinateTransformation.DegreesToRadians(GeocentricEclipticSaturn.Y);
            AAS2DCoordinate GeocentricEclipticNorthPole = AASCoordinateTransformation.Ecliptic2Equatorial(lambda0, beta0, Obliquity);
            double          alpha0 = AASCoordinateTransformation.HoursToRadians(GeocentricEclipticNorthPole.X);
            double          delta0 = AASCoordinateTransformation.DegreesToRadians(GeocentricEclipticNorthPole.Y);

            //Step 15. Calculate the Position angle
            details.P = AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(Math.Cos(delta0) * Math.Sin(alpha0 - alpha), Math.Sin(delta0) * Math.Cos(delta) - Math.Cos(delta0) * Math.Sin(delta) * Math.Cos(alpha0 - alpha)));

            return(details);
        }
Exemplo n.º 8
0
        public static AASEllipticalPlanetaryDetails Calculate(double JD, AASEllipticalObject ellipticalObject, bool bHighPrecision)
        {
            //What will the the return value
            AASEllipticalPlanetaryDetails details = new AASEllipticalPlanetaryDetails();

            //Calculate the position of the earth first
            double JD0 = JD;
            double L0  = AASEarth.EclipticLongitude(JD0, bHighPrecision);
            double B0  = AASEarth.EclipticLatitude(JD0, bHighPrecision);
            double R0  = AASEarth.RadiusVector(JD0, bHighPrecision);

            L0 = AASCoordinateTransformation.DegreesToRadians(L0);
            B0 = AASCoordinateTransformation.DegreesToRadians(B0);
            double cosB0 = Math.Cos(B0);

            //Iterate to find the positions adjusting for light-time correction if required
            double L = 0;
            double B = 0;
            double R = 0;

            if (ellipticalObject != AASEllipticalObject.SUN)
            {
                bool   bRecalc      = true;
                bool   bFirstRecalc = true;
                double LPrevious    = 0;
                double BPrevious    = 0;
                double RPrevious    = 0;

                while (bRecalc)
                {
                    switch (ellipticalObject)
                    {
                    case AASEllipticalObject.SUN:

                        L = AASSun.GeometricEclipticLongitude(JD0, bHighPrecision);
                        B = AASSun.GeometricEclipticLatitude(JD0, bHighPrecision);
                        R = AASEarth.RadiusVector(JD0, bHighPrecision);
                        break;

                    case AASEllipticalObject.MERCURY:

                        L = AASMercury.EclipticLongitude(JD0, bHighPrecision);
                        B = AASMercury.EclipticLatitude(JD0, bHighPrecision);
                        R = AASMercury.RadiusVector(JD0, bHighPrecision);
                        break;

                    case AASEllipticalObject.VENUS:

                        L = AASVenus.EclipticLongitude(JD0, bHighPrecision);
                        B = AASVenus.EclipticLatitude(JD0, bHighPrecision);
                        R = AASVenus.RadiusVector(JD0, bHighPrecision);
                        break;

                    case AASEllipticalObject.MARS:

                        L = AASMars.EclipticLongitude(JD0, bHighPrecision);
                        B = AASMars.EclipticLatitude(JD0, bHighPrecision);
                        R = AASMars.RadiusVector(JD0, bHighPrecision);
                        break;

                    case AASEllipticalObject.JUPITER:

                        L = AASJupiter.EclipticLongitude(JD0, bHighPrecision);
                        B = AASJupiter.EclipticLatitude(JD0, bHighPrecision);
                        R = AASJupiter.RadiusVector(JD0, bHighPrecision);
                        break;

                    case AASEllipticalObject.SATURN:

                        L = AASSaturn.EclipticLongitude(JD0, bHighPrecision);
                        B = AASSaturn.EclipticLatitude(JD0, bHighPrecision);
                        R = AASSaturn.RadiusVector(JD0, bHighPrecision);
                        break;

                    case AASEllipticalObject.URANUS:

                        L = AASUranus.EclipticLongitude(JD0, bHighPrecision);
                        B = AASUranus.EclipticLatitude(JD0, bHighPrecision);
                        R = AASUranus.RadiusVector(JD0, bHighPrecision);
                        break;

                    case AASEllipticalObject.NEPTUNE:

                        L = AASNeptune.EclipticLongitude(JD0, bHighPrecision);
                        B = AASNeptune.EclipticLatitude(JD0, bHighPrecision);
                        R = AASNeptune.RadiusVector(JD0, bHighPrecision);
                        break;

                    case AASEllipticalObject.PLUTO:

                        L = AASPluto.EclipticLongitude(JD0);
                        B = AASPluto.EclipticLatitude(JD0);
                        R = AASPluto.RadiusVector(JD0);
                        break;

                    default:
                        break;
                    }

                    if (!bFirstRecalc)
                    {
                        bRecalc   = ((Math.Abs(L - LPrevious) > 0.00001) || (Math.Abs(B - BPrevious) > 0.00001) || (Math.Abs(R - RPrevious) > 0.000001));
                        LPrevious = L;
                        BPrevious = B;
                        RPrevious = R;
                    }
                    else
                    {
                        bFirstRecalc = false;
                    }

                    //Calculate the new value
                    if (bRecalc)
                    {
                        double Lrad     = AASCoordinateTransformation.DegreesToRadians(L);
                        double Brad     = AASCoordinateTransformation.DegreesToRadians(B);
                        double cosB     = Math.Cos(Brad);
                        double cosL     = Math.Cos(Lrad);
                        double x1       = R * cosB * cosL - R0 * cosB0 * Math.Cos(L0);
                        double y1       = R * cosB * Math.Sin(Lrad) - R0 * cosB0 * Math.Sin(L0);
                        double z1       = R * Math.Sin(Brad) - R0 * Math.Sin(B0);
                        double distance = Math.Sqrt(x1 * x1 + y1 * y1 + z1 * z1);

                        //Prepare for the next loop around
                        JD0 = JD - AASElliptical.DistanceToLightTime(distance);
                    }
                }
            }

            double x = 0;
            double y = 0;
            double z = 0;

            if (ellipticalObject != AASEllipticalObject.SUN)
            {
                double Lrad = AASCoordinateTransformation.DegreesToRadians(L);
                double Brad = AASCoordinateTransformation.DegreesToRadians(B);
                double cosB = Math.Cos(Brad);
                double cosL = Math.Cos(Lrad);

                x = R * cosB * cosL - R0 * cosB0 * Math.Cos(L0);
                y = R * cosB * Math.Sin(Lrad) - R0 * cosB0 * Math.Sin(L0);
                z = R * Math.Sin(Brad) - R0 * Math.Sin(B0);
            }
            else
            {
                x = -R0 *cosB0 *Math.Cos(L0);

                y = -R0 *cosB0 *Math.Sin(L0);

                z = -R0 *Math.Sin(B0);
            }

            double x2 = x * x;
            double y2 = y * y;

            details.ApparentGeocentricLatitude  = AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(z, Math.Sqrt(x2 + y2)));
            details.ApparentGeocentricDistance  = Math.Sqrt(x2 + y2 + z * z);
            details.ApparentGeocentricLongitude = AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(y, x)));
            details.ApparentLightTime           = AASElliptical.DistanceToLightTime(details.ApparentGeocentricDistance);

            //Adjust for Aberration
            AAS2DCoordinate Aberration = AASAberration.EclipticAberration(details.ApparentGeocentricLongitude, details.ApparentGeocentricLatitude, JD, bHighPrecision);

            details.ApparentGeocentricLongitude += Aberration.X;
            details.ApparentGeocentricLatitude  += Aberration.Y;

            //convert to the FK5 system
            double DeltaLong = AASFK5.CorrectionInLongitude(details.ApparentGeocentricLongitude, details.ApparentGeocentricLatitude, JD);

            details.ApparentGeocentricLatitude  += AASFK5.CorrectionInLatitude(details.ApparentGeocentricLongitude, JD);
            details.ApparentGeocentricLongitude += DeltaLong;

            //Correct for nutation
            double NutationInLongitude = AASNutation.NutationInLongitude(JD);
            double Epsilon             = AASNutation.TrueObliquityOfEcliptic(JD);

            details.ApparentGeocentricLongitude += AASCoordinateTransformation.DMSToDegrees(0, 0, NutationInLongitude);

            //Convert to RA and Dec
            AAS2DCoordinate ApparentEqu = AASCoordinateTransformation.Ecliptic2Equatorial(details.ApparentGeocentricLongitude, details.ApparentGeocentricLatitude, Epsilon);

            details.ApparentGeocentricRA          = ApparentEqu.X;
            details.ApparentGeocentricDeclination = ApparentEqu.Y;

            return(details);
        }