//Static methods ///////////////////////// Implementation ////////////////////////////////////// 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 = CT.M360(280.4664567 + 360007.6982779 * rho + 0.03032028 * rhosquared + rhocubed / 49931 - rho4 / 15300 - rho5 / 2000000); //Calculate the Suns apparent right ascension double SunLong = CAASun.ApparentEclipticLongitude(JD); double SunLat = CAASun.ApparentEclipticLatitude(JD); double epsilon = CAANutation.TrueObliquityOfEcliptic(JD); COR Equatorial = CT.Ec2Eq(SunLong, SunLat, epsilon); epsilon = CT.D2R(epsilon); double E = L0 - 0.0057183 - Equatorial.X * 15 + CT.DMS2D(0, 0, CAANutation.NutationInLongitude(JD)) * Math.Cos(epsilon); if (E > 180) { E = -(360 - E); } E *= 4; //Convert to minutes of time return(E); }
public static AstroRaDec EclipticToJ2000(double l, double b, double jNow) { //CAA2DCoordinate Galactic = CAACoordinateTransformation::Equatorial2Galactic(CAACoordinateTransformation::DMSToDegrees(17, 48, 59.74), CAACoordinateTransformation::DMSToDegrees(14, 43, 8.2, false)); COR radec = CT.Ec2Eq(l, b, CAANutation.TrueObliquityOfEcliptic(jNow)); return(new AstroRaDec(radec.X, radec.Y, 0, false, false)); }
public static double EclipticLongitude(double JD) { double Ldash = MeanLongitude(JD); double LdashDegrees = Ldash; Ldash = CT.D2R(Ldash); double D = MeanElongation(JD); D = CT.D2R(D); double M = CAAEarth.SunMeanAnomaly(JD); M = CT.D2R(M); double Mdash = MeanAnomaly(JD); Mdash = CT.D2R(Mdash); double F = ArgumentOfLatitude(JD); F = CT.D2R(F); double E = CAAEarth.Eccentricity(JD); double T = (JD - 2451545) / 36525; double A1 = CT.M360(119.75 + 131.849 * T); A1 = CT.D2R(A1); double A2 = CT.M360(53.09 + 479264.290 * T); A2 = CT.D2R(A2); double A3 = CT.M360(313.45 + 481266.484 * T); A3 = CT.D2R(A3); int nLCoefficients = GFX.g_MoonCoefficients1.Length; Debug.Assert(GFX.g_MoonCoefficients2.Length == nLCoefficients); double SigmaL = 0; for (int i = 0; i < nLCoefficients; i++) { double ThisSigma = GFX.g_MoonCoefficients2[i].A * Math.Sin(GFX.g_MoonCoefficients1[i].D * D + GFX.g_MoonCoefficients1[i].M * M + GFX.g_MoonCoefficients1[i].Mdash * Mdash + GFX.g_MoonCoefficients1[i].F * F); if (GFX.g_MoonCoefficients1[i].M != 0) { ThisSigma *= E; } 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 = CAANutation.NutationInLongitude(JD); return(CT.M360(LdashDegrees + SigmaL / 1000000 + NutationInLong / 3600)); }
public static double ApparentGreenwichSiderealTime(double JD) { double MeanObliquity = CAANutation.MeanObliquityOfEcliptic(JD); double TrueObliquity = MeanObliquity + CAANutation.NutationInObliquity(JD) / 3600; double NutationInLongitude = CAANutation.NutationInLongitude(JD); double Value = MeanGreenwichSiderealTime(JD) + (NutationInLongitude * Math.Cos(CT.D2R(TrueObliquity)) / 54000); return(CT.M24(Value)); }
public static double ApparentGreenwichSiderealTime(double JD) { double MeanObliquity = CAANutation.MeanObliquityOfEcliptic(JD); double TrueObliquity = MeanObliquity + CAANutation.NutationInObliquity(JD) / 3600; double NutationInLongitude = CAANutation.NutationInLongitude(JD); double Value = MeanGreenwichSiderealTime(JD) + (NutationInLongitude * Math.Cos(CAACoordinateTransformation.DegreesToRadians(TrueObliquity)) / 54000); return(CAACoordinateTransformation.MapTo0To24Range(Value)); }
//////////////////////////////// Implementation /////////////////////////////// protected 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 = CAACoordinateTransformation.DegreesToRadians(Lambda); double Betarad = CAACoordinateTransformation.DegreesToRadians(Beta); I = CAACoordinateTransformation.DegreesToRadians(1.54242); DeltaU = CAACoordinateTransformation.DegreesToRadians(CAANutation.NutationInLongitude(JD) / 3600); double F = CAACoordinateTransformation.DegreesToRadians(CAAMoon.ArgumentOfLatitude(JD)); omega = CAACoordinateTransformation.DegreesToRadians(CAAMoon.MeanLongitudeAscendingNode(JD)); epsilon = CAANutation.MeanObliquityOfEcliptic(JD) + CAANutation.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 = CAACoordinateTransformation.MapTo0To360Range(CAACoordinateTransformation.RadiansToDegrees(A) - CAACoordinateTransformation.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 = CAACoordinateTransformation.DegreesToRadians(K1); double K2 = 72.56 + 20.186 * T; K2 = CAACoordinateTransformation.DegreesToRadians(K2); double M = CAAEarth.SunMeanAnomaly(JD); M = CAACoordinateTransformation.DegreesToRadians(M); double Mdash = CAAMoon.MeanAnomaly(JD); Mdash = CAACoordinateTransformation.DegreesToRadians(Mdash); double D = CAAMoon.MeanElongation(JD); D = CAACoordinateTransformation.DegreesToRadians(D); double E = CAAEarth.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 = CAACoordinateTransformation.RadiansToDegrees(bdash); bdash2 = sigma * Math.Cos(A) - rho * Math.Sin(A); }
public static double ApparentEclipticLongitude(double JD) { double Longitude = GeometricFK5EclipticLongitude(JD); //Apply the correction in longitude due to nutation Longitude += CAACoordinateTransformation.DMSToDegrees(0, 0, CAANutation.NutationInLongitude(JD)); //Apply the correction in longitude due to aberration double R = CAAEarth.RadiusVector(JD); Longitude -= CAACoordinateTransformation.DMSToDegrees(0, 0, 20.4898 / R); return(Longitude); }
public static CAA3DCoordinate EclipticRectangularCoordinatesMeanEquinox(double JD) { double Longitude = CAACoordinateTransformation.DegreesToRadians(GeometricFK5EclipticLongitude(JD)); double Latitude = CAACoordinateTransformation.DegreesToRadians(GeometricFK5EclipticLatitude(JD)); double R = CAAEarth.RadiusVector(JD); double epsilon = CAACoordinateTransformation.DegreesToRadians(CAANutation.MeanObliquityOfEcliptic(JD)); CAA3DCoordinate @value = new CAA3DCoordinate(); @value.X = R * Math.Cos(Latitude) * Math.Cos(Longitude); @value.Y = R * (Math.Cos(Latitude) * Math.Sin(Longitude) * Math.Cos(epsilon) - Math.Sin(Latitude) * Math.Sin(epsilon)); @value.Z = R * (Math.Cos(Latitude) * Math.Sin(Longitude) * Math.Sin(epsilon) + Math.Sin(Latitude) * Math.Cos(epsilon)); return(@value); }
public static C3D EclipticRectangularCoordinatesMeanEquinox(double JD) { double Longitude = CT.D2R(GeometricFK5EclipticLongitude(JD)); double Latitude = CT.D2R(GeometricFK5EclipticLatitude(JD)); double R = CAAEarth.RadiusVector(JD); double epsilon = CT.D2R(CAANutation.MeanObliquityOfEcliptic(JD)); C3D @value = new C3D(); @value.X = R * Math.Cos(Latitude) * Math.Cos(Longitude); @value.Y = R * (Math.Cos(Latitude) * Math.Sin(Longitude) * Math.Cos(epsilon) - Math.Sin(Latitude) * Math.Sin(epsilon)); @value.Z = R * (Math.Cos(Latitude) * Math.Sin(Longitude) * Math.Sin(epsilon) + Math.Sin(Latitude) * Math.Cos(epsilon)); return(@value); }
//Static methods //////////////////////////////// Implementation /////////////////////////////// public static CAAPhysicalSunDetails Calculate(double JD) { double theta = CAACoordinateTransformation.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 = CAAEarth.EclipticLongitude(JD); double R = CAAEarth.RadiusVector(JD); double SunLong = L + 180 - CAACoordinateTransformation.DMSToDegrees(0, 0, 20.4898 / R); double SunLongDash = SunLong + CAACoordinateTransformation.DMSToDegrees(0, 0, CAANutation.NutationInLongitude(JD)); double epsilon = CAANutation.TrueObliquityOfEcliptic(JD); //Convert to radians epsilon = CAACoordinateTransformation.DegreesToRadians(epsilon); SunLong = CAACoordinateTransformation.DegreesToRadians(SunLong); SunLongDash = CAACoordinateTransformation.DegreesToRadians(SunLongDash); K = CAACoordinateTransformation.DegreesToRadians(K); I = CAACoordinateTransformation.DegreesToRadians(I); theta = CAACoordinateTransformation.DegreesToRadians(theta); double x = Math.Atan(-Math.Cos(SunLong) * Math.Tan(epsilon)); double y = Math.Atan(-Math.Cos(SunLong - K) * Math.Tan(I)); CAAPhysicalSunDetails details = new CAAPhysicalSunDetails(); details.P = CAACoordinateTransformation.RadiansToDegrees(x + y); details.B0 = CAACoordinateTransformation.RadiansToDegrees(Math.Asin(Math.Sin(SunLong - K) * Math.Sin(I))); double eta = Math.Atan(Math.Tan(SunLong - K) * Math.Cos(I)); details.L0 = CAACoordinateTransformation.MapTo0To360Range(CAACoordinateTransformation.RadiansToDegrees(eta - theta)); return(details); }
//Static methods //////////////////////////////// Implementation /////////////////////////////// public static CAAPhysicalJupiterDetails Calculate(double JD) { //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 = CT.D2R(alpha0); double delta0 = 64.50 - 0.0164 * T1; double delta0rad = CT.D2R(delta0); //Step 2 double W1 = CT.M360(17.710 + 877.90003539 * d); double W2 = CT.M360(16.838 + 870.27003539 * d); //Step 3 double l0 = CAAEarth.EclipticLongitude(JD); double l0rad = CT.D2R(l0); double b0 = CAAEarth.EclipticLatitude(JD); double b0rad = CT.D2R(b0); double R = CAAEarth.RadiusVector(JD); //Step 4 double l = CAAJupiter.EclipticLongitude(JD); double lrad = CT.D2R(l); double b = CAAJupiter.EclipticLatitude(JD); double brad = CT.D2R(b); double r = CAAJupiter.RadiusVector(JD); //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 = CT.D2R(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 = CAANutation.MeanObliquityOfEcliptic(JD); double e0rad = CT.D2R(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 = CT.R2D(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 = CT.R2D(alpharad); double deltarad = Math.Atan2(v, Math.Sqrt(x * x + u * u)); double delta = CT.R2D(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 = CT.R2D(Math.Asin(-Math.Sin(delta0rad) * Math.Sin(deltarad) - Math.Cos(delta0rad) * Math.Cos(deltarad) * Math.Cos(alpha0rad - alpharad))); //Step 13 details.Geometricw1 = CT.M360(W1 - CT.R2D(xi) - 5.07033 * DELTA); details.Geometricw2 = CT.M360(W2 - CT.R2D(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 = CT.M360(details.Geometricw1 + C); details.Apparentw2 = CT.M360(details.Geometricw2 + C); } else { details.Apparentw1 = CT.M360(details.Geometricw1 - C); details.Apparentw2 = CT.M360(details.Geometricw2 - C); } //Step 15 double NutationInLongitude = CAANutation.NutationInLongitude(JD); double NutationInObliquity = CAANutation.NutationInObliquity(JD); e0 += NutationInObliquity / 3600; e0rad = CT.D2R(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 = CT.M360(alpha); alpharad = CT.D2R(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)); deltarad = CT.D2R(delta); //Step 17 double NutationRA = CAANutation.NutationInRightAscension(alpha / 15, delta, e0, NutationInLongitude, NutationInObliquity); double alphadash = alpha + NutationRA / 3600; double alphadashrad = CT.D2R(alphadash); double NutationDec = CAANutation.NutationInDeclination(alpha / 15, delta, e0, NutationInLongitude, NutationInObliquity); double deltadash = delta + NutationDec / 3600; double deltadashrad = CT.D2R(deltadash); NutationRA = CAANutation.NutationInRightAscension(alpha0 / 15, delta0, e0, NutationInLongitude, NutationInObliquity); double alpha0dash = alpha0 + NutationRA / 3600; double alpha0dashrad = CT.D2R(alpha0dash); NutationDec = CAANutation.NutationInDeclination(alpha0 / 15, delta0, e0, NutationInLongitude, NutationInObliquity); double delta0dash = delta0 + NutationDec / 3600; double delta0dashrad = CT.D2R(delta0dash); //Step 18 details.P = CT.M360(CT.R2D(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); }
public static AstroRaDec GetPlanet(double jDate, EO planetIn, double locLat, double locLong, double locHeight) { int planet = (int)planetIn; //C++ TO C# CONVERTER NOTE: This static local variable declaration (not allowed in C#) has been moved just prior to the method: // static CAAGalileanMoonsDetails galDetails; //C++ TO C# CONVERTER NOTE: This static local variable declaration (not allowed in C#) has been moved just prior to the method: // static CAAEllipticalPlanetaryDetails jupDetails; //C++ TO C# CONVERTER NOTE: This static local variable declaration (not allowed in C#) has been moved just prior to the method: // static CAAPhysicalJupiterDetails jupPhisical; //C++ TO C# CONVERTER NOTE: This static local variable declaration (not allowed in C#) has been moved just prior to the method: // static double jDateLast = 0; locLong = -locLong; if (planet < 9) { EPD Details = ELL.Calculate(jDate, planetIn); COR corrected = CAAParallax.Equatorial2Topocentric(Details.ApparentGeocentricRA, Details.ApparentGeocentricDeclination, Details.ApparentGeocentricDistance, locLong, locLat, locHeight, jDate); return(new AstroRaDec(corrected.X, corrected.Y, Details.ApparentGeocentricDistance, false, false)); } else if (planet == 9) { double lat = CAAMoon.EclipticLatitude(jDate); double lng = CAAMoon.EclipticLongitude(jDate); double dis = CAAMoon.RadiusVector(jDate) / 149598000; double epsilon = CAANutation.TrueObliquityOfEcliptic(jDate); COR d = CT.Ec2Eq(lng, lat, epsilon); COR corrected = CAAParallax.Equatorial2Topocentric(d.X, d.Y, dis, locLong, locLat, locHeight, jDate); return(new AstroRaDec(corrected.X, corrected.Y, dis, false, false)); } else { if (jDate != jDateLast) { jupDetails = ELL.Calculate(jDate, (EO)4); jupPhisical = CAAPhysicalJupiter.Calculate(jDate); COR corrected = CAAParallax.Equatorial2Topocentric(jupDetails.ApparentGeocentricRA, jupDetails.ApparentGeocentricDeclination, jupDetails.ApparentGeocentricDistance, locLong, locLat, locHeight, jDate); jupDetails.ApparentGeocentricRA = corrected.X; jupDetails.ApparentGeocentricDeclination = corrected.Y; galDetails = GM.Calculate(jDate); jDateLast = jDate; } double jupiterDiameter = 0.000954501; double scale = (Math.Atan(.5 * (jupiterDiameter / jupDetails.ApparentGeocentricDistance))) / 3.1415927 * 180; double raScale = (scale / Math.Cos(jupDetails.ApparentGeocentricDeclination / 180.0 * 3.1415927)) / 15; double xMoon = 0; double yMoon = 0; double zMoon = 0; bool shadow = false; bool eclipsed = false; switch (planet) { case 10: // IO xMoon = galDetails.Satellite1.ApparentRectangularCoordinates.X; yMoon = galDetails.Satellite1.ApparentRectangularCoordinates.Y; zMoon = galDetails.Satellite1.ApparentRectangularCoordinates.Z; eclipsed = galDetails.Satellite1.bInEclipse; shadow = galDetails.Satellite1.bInShadowTransit; break; case 11: //Europa xMoon = galDetails.Satellite2.ApparentRectangularCoordinates.X; yMoon = galDetails.Satellite2.ApparentRectangularCoordinates.Y; zMoon = galDetails.Satellite2.ApparentRectangularCoordinates.Z; eclipsed = galDetails.Satellite2.bInEclipse; shadow = galDetails.Satellite2.bInShadowTransit; break; case 12: //Ganymede xMoon = galDetails.Satellite3.ApparentRectangularCoordinates.X; yMoon = galDetails.Satellite3.ApparentRectangularCoordinates.Y; zMoon = galDetails.Satellite3.ApparentRectangularCoordinates.Z; eclipsed = galDetails.Satellite3.bInEclipse; shadow = galDetails.Satellite3.bInShadowTransit; break; case 13: //Callisto xMoon = galDetails.Satellite4.ApparentRectangularCoordinates.X; yMoon = galDetails.Satellite4.ApparentRectangularCoordinates.Y; zMoon = galDetails.Satellite4.ApparentRectangularCoordinates.Z; eclipsed = galDetails.Satellite4.bInEclipse; shadow = galDetails.Satellite4.bInShadowTransit; break; case 14: // IO Shadow xMoon = galDetails.Satellite1.ApparentShadowRectangularCoordinates.X; yMoon = galDetails.Satellite1.ApparentShadowRectangularCoordinates.Y; zMoon = galDetails.Satellite1.ApparentShadowRectangularCoordinates.Z * .9; shadow = galDetails.Satellite1.bInShadowTransit; break; case 15: //Europa Shadow xMoon = galDetails.Satellite2.ApparentShadowRectangularCoordinates.X; yMoon = galDetails.Satellite2.ApparentShadowRectangularCoordinates.Y; zMoon = galDetails.Satellite2.ApparentShadowRectangularCoordinates.Z * .9; shadow = galDetails.Satellite2.bInShadowTransit; break; case 16: //Ganymede Shadow xMoon = galDetails.Satellite3.ApparentShadowRectangularCoordinates.X; yMoon = galDetails.Satellite3.ApparentShadowRectangularCoordinates.Y; zMoon = galDetails.Satellite3.ApparentShadowRectangularCoordinates.Z * .9; shadow = galDetails.Satellite3.bInShadowTransit; break; case 17: //Callisto Shadow xMoon = galDetails.Satellite4.ApparentShadowRectangularCoordinates.X; yMoon = galDetails.Satellite4.ApparentShadowRectangularCoordinates.Y; zMoon = galDetails.Satellite4.ApparentShadowRectangularCoordinates.Z * .9; shadow = galDetails.Satellite4.bInShadowTransit; break; } double xTemp; double yTemp; double radians = jupPhisical.P / 180.0 * 3.1415927; xTemp = xMoon * Math.Cos(radians) - yMoon * Math.Sin(radians); yTemp = xMoon * Math.Sin(radians) + yMoon * Math.Cos(radians); xMoon = xTemp; yMoon = yTemp; return(new AstroRaDec(jupDetails.ApparentGeocentricRA - (xMoon * raScale), jupDetails.ApparentGeocentricDeclination + yMoon * scale, jupDetails.ApparentGeocentricDistance + (zMoon * jupiterDiameter / 2), shadow, eclipsed)); } }
//Static methods //////////////////////////////// Implementation /////////////////////////////// public static CAAPhysicalMarsDetails Calculate(double JD) { //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 = CT.D2R(Lambda0); double Beta0 = 63.2818 - 0.00394 * T; double Beta0rad = CT.D2R(Beta0); //Step 2 double l0 = CAAEarth.EclipticLongitude(JD); double l0rad = CT.D2R(l0); double b0 = CAAEarth.EclipticLatitude(JD); double b0rad = CT.D2R(b0); double R = CAAEarth.RadiusVector(JD); 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 brad = 0; double r = 0; while (bIterate) { double JD2 = JD - LightTravelTime; //Step 3 l = CAAMars.EclipticLongitude(JD2); lrad = CT.D2R(l); b = CAAMars.EclipticLatitude(JD2); brad = CT.D2R(b); r = CAAMars.RadiusVector(JD2); //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 = ELL.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 = CT.R2D(lambdarad); double betarad = Math.Atan2(z, Math.Sqrt(x * x + y * y)); double beta = CT.R2D(betarad); //Step 6 details.DE = CT.R2D(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 = CT.D2R(N); double ldash = l - 0.00697 / r; double ldashrad = CT.D2R(ldash); double bdash = b - 0.000225 * (Math.Cos(lrad - Nrad) / r); double bdashrad = CT.D2R(bdash); //Step 8 details.DS = CT.R2D(Math.Asin(-Math.Sin(Beta0rad) * Math.Sin(bdashrad) - Math.Cos(Beta0rad) * Math.Cos(bdashrad) * Math.Cos(Lambda0rad - ldashrad))); //Step 9 double W = CT.M360(11.504 + 350.89200025 * (JD - LightTravelTime - 2433282.5)); //Step 10 double e0 = CAANutation.MeanObliquityOfEcliptic(JD); double e0rad = CT.D2R(e0); COR PoleEquatorial = CT.Ec2Eq(Lambda0, Beta0, e0); double alpha0rad = CT.H2R(PoleEquatorial.X); double delta0rad = CT.D2R(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 = CT.R2H(alpharad); double deltarad = Math.Atan2(v, Math.Sqrt(x * x + u * u)); double delta = CT.R2D(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 = CT.M360(W - CT.R2D(xi)); //Step 13 double NutationInLongitude = CAANutation.NutationInLongitude(JD); double NutationInObliquity = CAANutation.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; Lambda0rad = CT.D2R(Lambda0); lambda += NutationInLongitude / 3600; lambdarad = CT.D2R(lambda); e0 += NutationInObliquity / 3600; e0rad = CT.D2R(e0rad); //Step 16 COR ApparentPoleEquatorial = CT.Ec2Eq(Lambda0, Beta0, e0); double alpha0dash = CT.H2R(ApparentPoleEquatorial.X); double delta0dash = CT.D2R(ApparentPoleEquatorial.Y); COR ApparentMars = CT.Ec2Eq(lambda, beta, e0); double alphadash = CT.H2R(ApparentMars.X); double deltadash = CT.D2R(ApparentMars.Y); //Step 17 details.P = CT.M360(CT.R2D(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 = CAASun.GeometricEclipticLongitude(JD); double SunBeta = CAASun.GeometricEclipticLatitude(JD); COR SunEquatorial = CT.Ec2Eq(SunLambda, SunBeta, e0); details.X = MIFR.PositionAngle(SunEquatorial.X, SunEquatorial.Y, alpha, delta); //Step 19 details.d = 9.36 / DELTA; details.k = IFR.IlluminatedFraction2(r, R, DELTA); details.q = (1 - details.k) * details.d; return(details); }
//Static methods //////////////////////////////// Implementation /////////////////////////////// public static CAASaturnRingDetails Calculate(double JD) { //What will be the return value CAASaturnRingDetails details = new CAASaturnRingDetails(); 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 = CT.D2R(i); double omega = 169.508470 + 1.394681 * T + 0.000412 * T2; double omegarad = CT.D2R(omega); //Step 2. Calculate the heliocentric longitude, latitude and radius vector of the Earth in the FK5 system double l0 = CAAEarth.EclipticLongitude(JD); double b0 = CAAEarth.EclipticLatitude(JD); l0 += CAAFK5.CorrectionInLongitude(l0, b0, JD); double l0rad = CT.D2R(l0); b0 += CAAFK5.CorrectionInLatitude(l0, JD); double b0rad = CT.D2R(b0); double R = CAAEarth.RadiusVector(JD); //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 = ELL.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 = CAASaturn.EclipticLongitude(JD1); b = CAASaturn.EclipticLatitude(JD1); l += CAAFK5.CorrectionInLongitude(l, b, JD1); b += CAAFK5.CorrectionInLatitude(l, JD1); double lrad = CT.D2R(l); double brad = CT.D2R(b); r = CAASaturn.RadiusVector(JD1); //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 = ELL.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 = CT.R2D(details.B); //Step 7. Calculate the longitude of the ascending node of Saturn's orbit double N = 113.6655 + 0.8771 * T; double Nrad = CT.D2R(N); double ldash = l - 0.01759 / r; double ldashrad = CT.D2R(ldash); double bdash = b - 0.000764 * Math.Cos(ldashrad - Nrad) / r; double bdashrad = CT.D2R(bdash); //Step 8. Calculate Bdash details.Bdash = CT.R2D(Math.Asin(Math.Sin(irad) * Math.Cos(bdashrad) * Math.Sin(ldashrad - omegarad) - Math.Cos(irad) * Math.Sin(bdashrad))); //Step 9. Calculate DeltaU double U1 = 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)); double U2 = 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 = CT.R2D(Math.Abs(U1 - U2)); //Step 10. Calculate the Nutations double Obliquity = CAANutation.TrueObliquityOfEcliptic(JD); double NutationInLongitude = CAANutation.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 += CT.D2R(0.005693 * Math.Cos(l0rad - lambda) / Math.Cos(beta)); beta += CT.D2R(0.005693 * Math.Sin(l0rad - lambda) * Math.Sin(beta)); //Step 13. Add nutation in longitude to lambda0 and lambda //double NLrad = CAACoordinateTransformation::DegreesToRadians(NutationInLongitude/3600); lambda = CT.R2D(lambda); lambda += NutationInLongitude / 3600; lambda = CT.M360(lambda); lambda0 += NutationInLongitude / 3600; lambda0 = CT.M360(lambda0); //Step 14. Convert to equatorial coordinates beta = CT.R2D(beta); COR GeocentricEclipticSaturn = CT.Ec2Eq(lambda, beta, Obliquity); double alpha = CT.H2R(GeocentricEclipticSaturn.X); double delta = CT.D2R(GeocentricEclipticSaturn.Y); COR GeocentricEclipticNorthPole = CT.Ec2Eq(lambda0, beta0, Obliquity); double alpha0 = CT.H2R(GeocentricEclipticNorthPole.X); double delta0 = CT.D2R(GeocentricEclipticNorthPole.Y); //Step 15. Calculate the Position angle details.P = CT.R2D(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); }
//Static methods public static CAANearParabolicObjectDetails Calculate(double JD, CAANearParabolicObjectElements elements) { double Epsilon = CAANutation.MeanObliquityOfEcliptic(elements.JDEquinox); double JD0 = JD; //What will be the return value CAANearParabolicObjectDetails details = new CAANearParabolicObjectDetails(); Epsilon = CAACoordinateTransformation.DegreesToRadians(Epsilon); double omega = CAACoordinateTransformation.DegreesToRadians(elements.omega); double w = CAACoordinateTransformation.DegreesToRadians(elements.w); double i = CAACoordinateTransformation.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); CAA3DCoordinate SunCoord = CAASun.EquatorialRectangularCoordinatesAnyEquinox(JD, elements.JDEquinox); for (int j = 0; j < 2; j++) { double v = 0; double r = 0; CalulateTrueAnnomalyAndRadius(JD0, 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 = omega + 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 = Math.Atan2(y, x); details.HeliocentricEclipticLongitude = CAACoordinateTransformation.MapTo0To24Range(CAACoordinateTransformation.RadiansToDegrees(details.HeliocentricEclipticLongitude) / 15); details.HeliocentricEclipticLatitude = Math.Asin(z / r); details.HeliocentricEclipticLatitude = CAACoordinateTransformation.RadiansToDegrees(details.HeliocentricEclipticLatitude); } double psi = SunCoord.X + x; double nu = SunCoord.Y + y; double sigma = SunCoord.Z + z; double Alpha = Math.Atan2(nu, psi); Alpha = CAACoordinateTransformation.RadiansToDegrees(Alpha); double Delta = Math.Atan2(sigma, Math.Sqrt(psi * psi + nu * nu)); Delta = CAACoordinateTransformation.RadiansToDegrees(Delta); double Distance = Math.Sqrt(psi * psi + nu * nu + sigma * sigma); if (j == 0) { details.TrueGeocentricRA = CAACoordinateTransformation.MapTo0To24Range(Alpha / 15); details.TrueGeocentricDeclination = Delta; details.TrueGeocentricDistance = Distance; details.TrueGeocentricLightTime = CAAElliptical.DistanceToLightTime(Distance); } else { details.AstrometricGeocenticRA = CAACoordinateTransformation.MapTo0To24Range(Alpha / 15); details.AstrometricGeocentricDeclination = Delta; details.AstrometricGeocentricDistance = Distance; details.AstrometricGeocentricLightTime = CAAElliptical.DistanceToLightTime(Distance); double RES = Math.Sqrt(SunCoord.X * SunCoord.X + SunCoord.Y * SunCoord.Y + SunCoord.Z * SunCoord.Z); details.Elongation = CAACoordinateTransformation.RadiansToDegrees(Math.Acos((RES * RES + Distance * Distance - r * r) / (2 * RES * Distance))); details.PhaseAngle = CAACoordinateTransformation.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 AstroRaDec EclipticToJ2000(double l, double b, double jNow) { CAA2DCoordinate radec = CAACoordinateTransformation.Ecliptic2Equatorial(l, b, CAANutation.TrueObliquityOfEcliptic(jNow)); return(new AstroRaDec(radec.X, radec.Y, 0, false, false)); }
public static EOD CalculateElements(double JD, EOE elements) { double Epsilon = CAANutation.MeanObliquityOfEcliptic(elements.JDEquinox); double JD0 = JD; //What will be the return value EOD details = new EOD(); Epsilon = CT.D2R(Epsilon); double omega = CT.D2R(elements.omega); double w = CT.D2R(elements.w); double i = CT.D2R(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); double n = ELL.MeanMotionFromSemiMajorAxis(elements.a); C3D SunCoord = CAASun.EquatorialRectangularCoordinatesAnyEquinox(JD, elements.JDEquinox); for (int j = 0; j < 2; j++) { double M = n * (JD0 - elements.T); double E = CAAKepler.Calculate(M, elements.e); E = CT.D2R(E); double v = 2 * Math.Atan(Math.Sqrt((1 + elements.e) / (1 - elements.e)) * Math.Tan(E / 2)); double r = elements.a * (1 - elements.e * Math.Cos(E)); 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 = omega + 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 = Math.Atan2(y, x); details.HeliocentricEclipticLongitude = CT.M24(CT.R2D(details.HeliocentricEclipticLongitude) / 15); details.HeliocentricEclipticLatitude = Math.Asin(z / r); details.HeliocentricEclipticLatitude = CT.R2D(details.HeliocentricEclipticLatitude); } double psi = SunCoord.X + x; double nu = SunCoord.Y + y; double sigma = SunCoord.Z + z; double Alpha = Math.Atan2(nu, psi); Alpha = CT.R2D(Alpha); double Delta = Math.Atan2(sigma, Math.Sqrt(psi * psi + nu * nu)); Delta = CT.R2D(Delta); double Distance = Math.Sqrt(psi * psi + nu * nu + sigma * sigma); if (j == 0) { details.TrueGeocentricRA = CT.M24(Alpha / 15); details.TrueGeocentricDeclination = Delta; details.TrueGeocentricDistance = Distance; details.TrueGeocentricLightTime = DistanceToLightTime(Distance); } else { details.AstrometricGeocenticRA = CT.M24(Alpha / 15); details.AstrometricGeocentricDeclination = Delta; details.AstrometricGeocentricDistance = Distance; details.AstrometricGeocentricLightTime = DistanceToLightTime(Distance); double RES = Math.Sqrt(SunCoord.X * SunCoord.X + SunCoord.Y * SunCoord.Y + SunCoord.Z * SunCoord.Z); details.Elongation = Math.Acos((RES * RES + Distance * Distance - r * r) / (2 * RES * Distance)); details.Elongation = CT.R2D(details.Elongation); details.PhaseAngle = Math.Acos((r * r + Distance * Distance - RES * RES) / (2 * r * Distance)); details.PhaseAngle = CT.R2D(details.PhaseAngle); } if (j == 0) //Prepare for the next loop around { JD0 = JD - details.TrueGeocentricLightTime; } } return(details); }
public static EPD Calculate(double JD, EO @object) { //What will the the return value EPD details = new EPD(); double JD0 = JD; double L0 = 0; double B0 = 0; double R0 = 0; double cosB0 = 0; if (@object != EO.SUN) { L0 = CAAEarth.EclipticLongitude(JD0); B0 = CAAEarth.EclipticLatitude(JD0); R0 = CAAEarth.RadiusVector(JD0); L0 = CT.D2R(L0); B0 = CT.D2R(B0); cosB0 = Math.Cos(B0); } //Calculate the initial values double L = 0; double B = 0; double R = 0; double Lrad; double Brad; double cosB; double cosL; double x; double y; double z; bool bRecalc = true; bool bFirstRecalc = true; double LPrevious = 0; double BPrevious = 0; double RPrevious = 0; while (bRecalc) { switch (@object) { case EO.SUN: { L = CAASun.GeometricEclipticLongitude(JD0); B = CAASun.GeometricEclipticLatitude(JD0); R = CAAEarth.RadiusVector(JD0); break; } case EO.MERCURY: { L = CAAMercury.EclipticLongitude(JD0); B = CAAMercury.EclipticLatitude(JD0); R = CAAMercury.RadiusVector(JD0); break; } case EO.VENUS: { L = CAAVenus.EclipticLongitude(JD0); B = CAAVenus.EclipticLatitude(JD0); R = CAAVenus.RadiusVector(JD0); break; } case EO.MARS: { L = CAAMars.EclipticLongitude(JD0); B = CAAMars.EclipticLatitude(JD0); R = CAAMars.RadiusVector(JD0); break; } case EO.JUPITER: { L = CAAJupiter.EclipticLongitude(JD0); B = CAAJupiter.EclipticLatitude(JD0); R = CAAJupiter.RadiusVector(JD0); break; } case EO.SATURN: { L = CAASaturn.EclipticLongitude(JD0); B = CAASaturn.EclipticLatitude(JD0); R = CAASaturn.RadiusVector(JD0); break; } case EO.URANUS: { L = CAAUranus.EclipticLongitude(JD0); B = CAAUranus.EclipticLatitude(JD0); R = CAAUranus.RadiusVector(JD0); break; } case EO.NEPTUNE: { L = CAANeptune.EclipticLongitude(JD0); B = CAANeptune.EclipticLatitude(JD0); R = CAANeptune.RadiusVector(JD0); break; } case EO.PLUTO: { L = CAAPluto.EclipticLongitude(JD0); B = CAAPluto.EclipticLatitude(JD0); R = CAAPluto.RadiusVector(JD0); break; } default: { Debug.Assert(false); 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 distance = 0; if (@object != EO.SUN) { Lrad = CT.D2R(L); Brad = CT.D2R(B); cosB = Math.Cos(Brad); 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); distance = Math.Sqrt(x * x + y * y + z * z); } else { distance = R; //Distance to the sun from the earth is in fact the radius vector } //Prepare for the next loop around JD0 = JD - ELL.DistanceToLightTime(distance); } } Lrad = CT.D2R(L); Brad = CT.D2R(B); cosB = Math.Cos(Brad); 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); double x2 = x * x; double y2 = y * y; details.ApparentGeocentricLatitude = CT.R2D(Math.Atan2(z, Math.Sqrt(x2 + y2))); details.ApparentGeocentricDistance = Math.Sqrt(x2 + y2 + z * z); details.ApparentGeocentricLongitude = CT.M360(CT.R2D(Math.Atan2(y, x))); details.ApparentLightTime = ELL.DistanceToLightTime(details.ApparentGeocentricDistance); //Adjust for Aberration COR Aberration = ABR.EclipticAberration(details.ApparentGeocentricLongitude, details.ApparentGeocentricLatitude, JD); details.ApparentGeocentricLongitude += Aberration.X; details.ApparentGeocentricLatitude += Aberration.Y; //convert to the FK5 system double DeltaLong = CAAFK5.CorrectionInLongitude(details.ApparentGeocentricLongitude, details.ApparentGeocentricLatitude, JD); details.ApparentGeocentricLatitude += CAAFK5.CorrectionInLatitude(details.ApparentGeocentricLongitude, JD); details.ApparentGeocentricLongitude += DeltaLong; //Correct for nutation double NutationInLongitude = CAANutation.NutationInLongitude(JD); double Epsilon = CAANutation.TrueObliquityOfEcliptic(JD); details.ApparentGeocentricLongitude += CT.DMS2D(0, 0, NutationInLongitude); //Convert to RA and Dec COR ApparentEqu = CT.Ec2Eq(details.ApparentGeocentricLongitude, details.ApparentGeocentricLatitude, Epsilon); details.ApparentGeocentricRA = ApparentEqu.X; details.ApparentGeocentricDeclination = ApparentEqu.Y; return(details); }