예제 #1
0
        public static AASPhysicalSunDetails Calculate(double JD)
        {
            double theta = AASCoordinateTransformation.MapTo0To360Range((JD - 2398220) * 360 / 25.38);
            double I     = 7.25;
            double K     = 73.6667 + 1.3958333 * (JD - 2396758) / 36525;

            //Calculate the apparent longitude of the sun (excluding the effect of nutation)
            double L       = AASEarth.EclipticLongitude(JD);
            double R       = AASEarth.RadiusVector(JD);
            double SunLong = L + 180 - AASCoordinateTransformation.DMSToDegrees(0, 0, 20.4898 / R);

            double epsilon = AASNutation.TrueObliquityOfEcliptic(JD);

            //Convert to radians
            epsilon = AASCoordinateTransformation.DegreesToRadians(epsilon);
            SunLong = AASCoordinateTransformation.DegreesToRadians(SunLong);
            K       = AASCoordinateTransformation.DegreesToRadians(K);
            I       = AASCoordinateTransformation.DegreesToRadians(I);
            theta   = AASCoordinateTransformation.DegreesToRadians(theta);

            double x = Math.Atan(-Math.Cos(SunLong) * Math.Tan(epsilon));
            double y = Math.Atan(-Math.Cos(SunLong - K) * Math.Tan(I));

            AASPhysicalSunDetails details = new AASPhysicalSunDetails();

            details.P  = AASCoordinateTransformation.RadiansToDegrees(x + y);
            details.B0 = AASCoordinateTransformation.RadiansToDegrees(Math.Asin(Math.Sin(SunLong - K) * Math.Sin(I)));

            double eta = Math.Atan(Math.Tan(SunLong - K) * Math.Cos(I));

            details.L0 = AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(eta - theta));

            return(details);
        }
예제 #2
0
        public static double Calculate(double JD)
        {
            double rho        = (JD - 2451545) / 365250;
            double rhosquared = rho * rho;
            double rhocubed   = rhosquared * rho;
            double rho4       = rhocubed * rho;
            double rho5       = rho4 * rho;

            //Calculate the Suns mean longitude
            double L0 = AASCoordinateTransformation.MapTo0To360Range(280.4664567 + 360007.6982779 * rho + 0.03032028 * rhosquared +
                                                                     rhocubed / 49931 - rho4 / 15300 - rho5 / 2000000);

            //Calculate the Suns apparent right ascension
            double          SunLong    = AASSun.ApparentEclipticLongitude(JD);
            double          SunLat     = AASSun.ApparentEclipticLatitude(JD);
            double          epsilon    = AASNutation.TrueObliquityOfEcliptic(JD);
            AAS2DCoordinate Equatorial = AASCoordinateTransformation.Ecliptic2Equatorial(SunLong, SunLat, epsilon);

            epsilon = AASCoordinateTransformation.DegreesToRadians(epsilon);
            double E = L0 - 0.0057183 - Equatorial.X * 15 + AASCoordinateTransformation.DMSToDegrees(0, 0, AASNutation.NutationInLongitude(JD)) * Math.Cos(epsilon);

            if (E > 180)
            {
                E = -(360 - E);
            }
            E *= 4; //Convert to minutes of time

            return(E);
        }
        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);
        }
예제 #4
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);
        }