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); }
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 double EclipticLongitude(double JD) { double Ldash = MeanLongitude(JD); double LdashDegrees = Ldash; Ldash = AASCoordinateTransformation.DegreesToRadians(Ldash); double D = MeanElongation(JD); D = AASCoordinateTransformation.DegreesToRadians(D); double M = AASEarth.SunMeanAnomaly(JD); M = AASCoordinateTransformation.DegreesToRadians(M); double Mdash = MeanAnomaly(JD); Mdash = AASCoordinateTransformation.DegreesToRadians(Mdash); double F = ArgumentOfLatitude(JD); F = AASCoordinateTransformation.DegreesToRadians(F); double E = AASEarth.Eccentricity(JD); double Esquared = E * E; double T = (JD - 2451545) / 36525; double A1 = AASCoordinateTransformation.MapTo0To360Range(119.75 + 131.849 * T); A1 = AASCoordinateTransformation.DegreesToRadians(A1); double A2 = AASCoordinateTransformation.MapTo0To360Range(53.09 + 479264.290 * T); A2 = AASCoordinateTransformation.DegreesToRadians(A2); int nLCoefficients = g_MoonCoefficients1.Length; double SigmaL = 0; for (int i = 0; i < nLCoefficients; i++) { double ThisSigma = g_MoonCoefficients2[i].A * Math.Sin(g_MoonCoefficients1[i].D * D + g_MoonCoefficients1[i].M * M + g_MoonCoefficients1[i].Mdash * Mdash + g_MoonCoefficients1[i].F * F); if ((g_MoonCoefficients1[i].M == 1) || (g_MoonCoefficients1[i].M == -1)) { ThisSigma *= E; } else if ((g_MoonCoefficients1[i].M == 2) || (g_MoonCoefficients1[i].M == -2)) { ThisSigma *= Esquared; } SigmaL += ThisSigma; } //Finally the additive terms SigmaL += 3958 * Math.Sin(A1); SigmaL += 1962 * Math.Sin(Ldash - F); SigmaL += 318 * Math.Sin(A2); //And finally apply the nutation in longitude double NutationInLong = AASNutation.NutationInLongitude(JD); return(AASCoordinateTransformation.MapTo0To360Range(LdashDegrees + SigmaL / 1000000 + NutationInLong / 3600)); }
public static double ApparentGreenwichSiderealTime(double JD) { double MeanObliquity = AASNutation.MeanObliquityOfEcliptic(JD); double TrueObliquity = MeanObliquity + AASNutation.NutationInObliquity(JD) / 3600; double NutationInLongitude = AASNutation.NutationInLongitude(JD); double Value = MeanGreenwichSiderealTime(JD) + (NutationInLongitude * Math.Cos(AASCoordinateTransformation.DegreesToRadians(TrueObliquity)) / 54000); return(AASCoordinateTransformation.MapTo0To24Range(Value)); }
public static double ApparentEclipticLongitude(double JD) { double Longitude = GeometricFK5EclipticLongitude(JD); //Apply the correction in longitude due to nutation Longitude += AASCoordinateTransformation.DMSToDegrees(0, 0, AASNutation.NutationInLongitude(JD)); //Apply the correction in longitude due to aberration double R = AASEarth.RadiusVector(JD); Longitude -= AASCoordinateTransformation.DMSToDegrees(0, 0, 20.4898 / R); return(Longitude); }
public static AAS3DCoordinate EquatorialRectangularCoordinatesMeanEquinox(double JD, bool bHighPrecision) { double Longitude = AASCoordinateTransformation.DegreesToRadians(GeometricFK5EclipticLongitude(JD, bHighPrecision)); double Latitude = AASCoordinateTransformation.DegreesToRadians(GeometricFK5EclipticLatitude(JD, bHighPrecision)); double R = AASEarth.RadiusVector(JD, bHighPrecision); double epsilon = AASCoordinateTransformation.DegreesToRadians(AASNutation.MeanObliquityOfEcliptic(JD)); AAS3DCoordinate value = new AAS3DCoordinate { X = R * Math.Cos(Latitude) * Math.Cos(Longitude), Y = R * (Math.Cos(Latitude) * Math.Sin(Longitude) * Math.Cos(epsilon) - Math.Sin(Latitude) * Math.Sin(epsilon)), Z = R * (Math.Cos(Latitude) * Math.Sin(Longitude) * Math.Sin(epsilon) + Math.Sin(Latitude) * Math.Cos(epsilon)) }; return(value); }
public static double ApparentEclipticLongitude(double JD, bool bHighPrecision) { double Longitude = GeometricFK5EclipticLongitude(JD, bHighPrecision); //Apply the correction in longitude due to nutation Longitude += AASCoordinateTransformation.DMSToDegrees(0, 0, AASNutation.NutationInLongitude(JD)); //Apply the correction in longitude due to aberration double R = AASEarth.RadiusVector(JD, bHighPrecision); if (bHighPrecision) { Longitude -= (0.005775518 * R * AASCoordinateTransformation.DMSToDegrees(0, 0, VariationGeometricEclipticLongitude(JD))); } else { Longitude -= AASCoordinateTransformation.DMSToDegrees(0, 0, 20.4898 / R); } return(Longitude); }
public static void CalculateOpticalLibration(double JD, double Lambda, double Beta, ref double ldash, ref double bdash, ref double ldash2, ref double bdash2, ref double epsilon, ref double omega, ref double DeltaU, ref double sigma, ref double I, ref double rho) { //Calculate the initial quantities double Lambdarad = AASCoordinateTransformation.DegreesToRadians(Lambda); double Betarad = AASCoordinateTransformation.DegreesToRadians(Beta); I = AASCoordinateTransformation.DegreesToRadians(1.54242); DeltaU = AASCoordinateTransformation.DegreesToRadians(AASNutation.NutationInLongitude(JD) / 3600); double F = AASCoordinateTransformation.DegreesToRadians(AASMoon.ArgumentOfLatitude(JD)); omega = AASCoordinateTransformation.DegreesToRadians(AASMoon.MeanLongitudeAscendingNode(JD)); epsilon = AASNutation.MeanObliquityOfEcliptic(JD) + AASNutation.NutationInObliquity(JD) / 3600; //Calculate the optical librations double W = Lambdarad - DeltaU / 3600 - omega; double A = Math.Atan2(Math.Sin(W) * Math.Cos(Betarad) * Math.Cos(I) - Math.Sin(Betarad) * Math.Sin(I), Math.Cos(W) * Math.Cos(Betarad)); ldash = AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(A) - AASCoordinateTransformation.RadiansToDegrees(F)); if (ldash > 180) { ldash -= 360; } bdash = Math.Asin(-Math.Sin(W) * Math.Cos(Betarad) * Math.Sin(I) - Math.Sin(Betarad) * Math.Cos(I)); //Calculate the physical librations double T = (JD - 2451545.0) / 36525; double K1 = 119.75 + 131.849 * T; K1 = AASCoordinateTransformation.DegreesToRadians(K1); double K2 = 72.56 + 20.186 * T; K2 = AASCoordinateTransformation.DegreesToRadians(K2); double M = AASEarth.SunMeanAnomaly(JD); M = AASCoordinateTransformation.DegreesToRadians(M); double Mdash = AASMoon.MeanAnomaly(JD); Mdash = AASCoordinateTransformation.DegreesToRadians(Mdash); double D = AASMoon.MeanElongation(JD); D = AASCoordinateTransformation.DegreesToRadians(D); double E = AASEarth.Eccentricity(JD); rho = -0.02752 * Math.Cos(Mdash) + -0.02245 * Math.Sin(F) + 0.00684 * Math.Cos(Mdash - 2 * F) + -0.00293 * Math.Cos(2 * F) + -0.00085 * Math.Cos(2 * F - 2 * D) + -0.00054 * Math.Cos(Mdash - 2 * D) + -0.00020 * Math.Sin(Mdash + F) + -0.00020 * Math.Cos(Mdash + 2 * F) + -0.00020 * Math.Cos(Mdash - F) + 0.00014 * Math.Cos(Mdash + 2 * F - 2 * D); sigma = -0.02816 * Math.Sin(Mdash) + 0.02244 * Math.Cos(F) + -0.00682 * Math.Sin(Mdash - 2 * F) + -0.00279 * Math.Sin(2 * F) + -0.00083 * Math.Sin(2 * F - 2 * D) + 0.00069 * Math.Sin(Mdash - 2 * D) + 0.00040 * Math.Cos(Mdash + F) + -0.00025 * Math.Sin(2 * Mdash) + -0.00023 * Math.Sin(Mdash + 2 * F) + 0.00020 * Math.Cos(Mdash - F) + 0.00019 * Math.Sin(Mdash - F) + 0.00013 * Math.Sin(Mdash + 2 * F - 2 * D) + -0.00010 * Math.Cos(Mdash - 3 * F); double tau = 0.02520 * E * Math.Sin(M) + 0.00473 * Math.Sin(2 * Mdash - 2 * F) + -0.00467 * Math.Sin(Mdash) + 0.00396 * Math.Sin(K1) + 0.00276 * Math.Sin(2 * Mdash - 2 * D) + 0.00196 * Math.Sin(omega) + -0.00183 * Math.Cos(Mdash - F) + 0.00115 * Math.Sin(Mdash - 2 * D) + -0.00096 * Math.Sin(Mdash - D) + 0.00046 * Math.Sin(2 * F - 2 * D) + -0.00039 * Math.Sin(Mdash - F) + -0.00032 * Math.Sin(Mdash - M - D) + 0.00027 * Math.Sin(2 * Mdash - M - 2 * D) + 0.00023 * Math.Sin(K2) + -0.00014 * Math.Sin(2 * D) + 0.00014 * Math.Cos(2 * Mdash - 2 * F) + -0.00012 * Math.Sin(Mdash - 2 * F) + -0.00012 * Math.Sin(2 * Mdash) + 0.00011 * Math.Sin(2 * Mdash - 2 * M - 2 * D); ldash2 = -tau + (rho * Math.Cos(A) + sigma * Math.Sin(A)) * Math.Tan(bdash); bdash = AASCoordinateTransformation.RadiansToDegrees(bdash); bdash2 = sigma * Math.Cos(A) - rho * Math.Sin(A); }
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); }
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); }
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); }
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); }
public static CAAPhysicalJupiterDetails Calculate(double JD, bool bHighPrecision) { //What will be the return value CAAPhysicalJupiterDetails details = new CAAPhysicalJupiterDetails(); //Step 1 double d = JD - 2433282.5; double T1 = d / 36525; double alpha0 = 268.00 + 0.1061 * T1; double alpha0rad = AASCoordinateTransformation.DegreesToRadians(alpha0); double delta0 = 64.50 - 0.0164 * T1; double delta0rad = AASCoordinateTransformation.DegreesToRadians(delta0); //Step 2 double W1 = AASCoordinateTransformation.MapTo0To360Range(17.710 + 877.90003539 * d); double W2 = AASCoordinateTransformation.MapTo0To360Range(16.838 + 870.27003539 * d); //Step 3 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); //Step 4 double l = AASJupiter.EclipticLongitude(JD, bHighPrecision); double lrad = AASCoordinateTransformation.DegreesToRadians(l); double b = AASJupiter.EclipticLatitude(JD, bHighPrecision); double brad = AASCoordinateTransformation.DegreesToRadians(b); double r = AASJupiter.RadiusVector(JD, bHighPrecision); //Step 5 double x = r * Math.Cos(brad) * Math.Cos(lrad) - R * Math.Cos(l0rad); double y = r * Math.Cos(brad) * Math.Sin(lrad) - R * Math.Sin(l0rad); double z = r * Math.Sin(brad) - R * Math.Sin(b0rad); double DELTA = Math.Sqrt(x * x + y * y + z * z); //Step 6 l -= 0.012990 * DELTA / (r * r); lrad = AASCoordinateTransformation.DegreesToRadians(l); //Step 7 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); //Step 8 double e0 = AASNutation.MeanObliquityOfEcliptic(JD); double e0rad = AASCoordinateTransformation.DegreesToRadians(e0); //Step 9 double alphas = Math.Atan2(Math.Cos(e0rad) * Math.Sin(lrad) - Math.Sin(e0rad) * Math.Tan(brad), Math.Cos(lrad)); double deltas = Math.Asin(Math.Cos(e0rad) * Math.Sin(brad) + Math.Sin(e0rad) * Math.Cos(brad) * Math.Sin(lrad)); //Step 10 details.DS = AASCoordinateTransformation.RadiansToDegrees(Math.Asin(-Math.Sin(delta0rad) * Math.Sin(deltas) - Math.Cos(delta0rad) * Math.Cos(deltas) * Math.Cos(alpha0rad - alphas))); //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.RadiansToDegrees(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.DE = AASCoordinateTransformation.RadiansToDegrees(Math.Asin(-Math.Sin(delta0rad) * Math.Sin(deltarad) - Math.Cos(delta0rad) * Math.Cos(deltarad) * Math.Cos(alpha0rad - alpharad))); //Step 13 details.Geometricw1 = AASCoordinateTransformation.MapTo0To360Range(W1 - AASCoordinateTransformation.RadiansToDegrees(xi) - 5.07033 * DELTA); details.Geometricw2 = AASCoordinateTransformation.MapTo0To360Range(W2 - AASCoordinateTransformation.RadiansToDegrees(xi) - 5.02626 * DELTA); //Step 14 double C = 57.2958 * (2 * r * DELTA + R * R - r * r - DELTA * DELTA) / (4 * r * DELTA); if (Math.Sin(lrad - l0rad) > 0) { details.Apparentw1 = AASCoordinateTransformation.MapTo0To360Range(details.Geometricw1 + C); details.Apparentw2 = AASCoordinateTransformation.MapTo0To360Range(details.Geometricw2 + C); } else { details.Apparentw1 = AASCoordinateTransformation.MapTo0To360Range(details.Geometricw1 - C); details.Apparentw2 = AASCoordinateTransformation.MapTo0To360Range(details.Geometricw2 - C); } //Step 15 double NutationInLongitude = AASNutation.NutationInLongitude(JD); double NutationInObliquity = AASNutation.NutationInObliquity(JD); e0 += NutationInObliquity / 3600; e0rad = AASCoordinateTransformation.DegreesToRadians(e0); //Step 16 alpha += 0.005693 * (Math.Cos(alpharad) * Math.Cos(l0rad) * Math.Cos(e0rad) + Math.Sin(alpharad) * Math.Sin(l0rad)) / Math.Cos(deltarad); alpha = AASCoordinateTransformation.MapTo0To360Range(alpha); alpharad = AASCoordinateTransformation.DegreesToRadians(alpha); delta += 0.005693 * (Math.Cos(l0rad) * Math.Cos(e0rad) * (Math.Tan(e0rad) * Math.Cos(deltarad) - Math.Sin(alpharad) * Math.Sin(deltarad)) + Math.Cos(alpharad) * Math.Sin(deltarad) * Math.Sin(l0rad)); //Step 17 double NutationRA = AASNutation.NutationInRightAscension(alpha / 15, delta, e0, NutationInLongitude, NutationInObliquity); double alphadash = alpha + NutationRA / 3600; double alphadashrad = AASCoordinateTransformation.DegreesToRadians(alphadash); double NutationDec = AASNutation.NutationInDeclination(alpha / 15, e0, NutationInLongitude, NutationInObliquity); double deltadash = delta + NutationDec / 3600; double deltadashrad = AASCoordinateTransformation.DegreesToRadians(deltadash); NutationRA = AASNutation.NutationInRightAscension(alpha0 / 15, delta0, e0, NutationInLongitude, NutationInObliquity); double alpha0dash = alpha0 + NutationRA / 3600; double alpha0dashrad = AASCoordinateTransformation.DegreesToRadians(alpha0dash); NutationDec = AASNutation.NutationInDeclination(alpha0 / 15, e0, NutationInLongitude, NutationInObliquity); double delta0dash = delta0 + NutationDec / 3600; double delta0dashrad = AASCoordinateTransformation.DegreesToRadians(delta0dash); //Step 18 details.P = AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(Math.Cos(delta0dashrad) * Math.Sin(alpha0dashrad - alphadashrad), Math.Sin(delta0dashrad) * Math.Cos(deltadashrad) - Math.Cos(delta0dashrad) * Math.Sin(deltadashrad) * Math.Cos(alpha0dashrad - alphadashrad)))); return(details); }