public static double RadiusOfParallelOfLatitude(double GeographicalLatitude) { //Convert from degress to radians GeographicalLatitude = AASCoordinateTransformation.DegreesToRadians(GeographicalLatitude); double sinGeo = Math.Sin(GeographicalLatitude); return((6378.14 * Math.Cos(GeographicalLatitude)) / (Math.Sqrt(1 - 0.0066943847614084 * sinGeo * sinGeo))); }
public static double RadiusOfCurvature(double GeographicalLatitude) { //Convert from degress to radians GeographicalLatitude = AASCoordinateTransformation.DegreesToRadians(GeographicalLatitude); double sinGeo = Math.Sin(GeographicalLatitude); return((6378.14 * (1 - 0.0066943847614084)) / Math.Pow((1 - 0.0066943847614084 * sinGeo * sinGeo), 1.5)); }
public static double RhoCosThetaPrime(double GeographicalLatitude, double Height) { //Convert from degress to radians GeographicalLatitude = AASCoordinateTransformation.DegreesToRadians(GeographicalLatitude); double U = Math.Atan(0.99664719 * Math.Tan(GeographicalLatitude)); return(Math.Cos(U) + (Height / 6378140 * Math.Cos(GeographicalLatitude))); }
public static AASEclipticalElementDetails Calculate(double i0, double w0, double omega0, double JD0, double JD) { double T = (JD0 - 2451545.0) / 36525; double Tsquared = T * T; double t = (JD - JD0) / 36525; double tsquared = t * t; double tcubed = tsquared * t; //Now convert to radians double i0rad = AASCoordinateTransformation.DegreesToRadians(i0); double omega0rad = AASCoordinateTransformation.DegreesToRadians(omega0); double eta = (47.0029 - 0.06603 * T + 0.000598 * Tsquared) * t + (-0.03302 + 0.000598 * T) * tsquared + 0.00006 * tcubed; eta = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, eta)); double pi = 174.876384 * 3600 + 3289.4789 * T + 0.60622 * Tsquared - (869.8089 + 0.50491 * T) * t + 0.03536 * tsquared; pi = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, pi)); double p = (5029.0966 + 2.22226 * T - 0.000042 * Tsquared) * t + (1.11113 - 0.000042 * T) * tsquared - 0.000006 * tcubed; p = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, p)); double sini0rad = Math.Sin(i0rad); double cosi0rad = Math.Cos(i0rad); double sinomega0rad_pi = Math.Sin(omega0rad - pi); double cosomega0rad_pi = Math.Cos(omega0rad - pi); double sineta = Math.Sin(eta); double coseta = Math.Cos(eta); double A = sini0rad * sinomega0rad_pi; double B = -sineta * cosi0rad + coseta * sini0rad * cosomega0rad_pi; double irad = Math.Asin(Math.Sqrt(A * A + B * B)); AASEclipticalElementDetails details = new AASEclipticalElementDetails(); details.i = AASCoordinateTransformation.RadiansToDegrees(irad); double cosi = cosi0rad * coseta + sini0rad * sineta * cosomega0rad_pi; if (cosi < 0) { details.i = 180 - details.i; } double phi = pi + p; details.omega = AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(A, B) + phi)); A = -sineta * sinomega0rad_pi; B = sini0rad * coseta - cosi0rad * sineta * cosomega0rad_pi; double deltaw = AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(A, B)); details.w = AASCoordinateTransformation.MapTo0To360Range(w0 + deltaw); return(details); }
public static double PhaseAngle(double R, double R0, double B, double L, double L0, double Delta) { //Convert from degrees to radians B = AASCoordinateTransformation.DegreesToRadians(B); L = AASCoordinateTransformation.DegreesToRadians(L); L0 = AASCoordinateTransformation.DegreesToRadians(L0); //Return the result return(AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(Math.Acos((R - R0 * Math.Cos(B) * Math.Cos(L - L0)) / Delta)))); }
public static double PhaseAngleRectangular(double x, double y, double z, double B, double L, double Delta) { //Convert from degrees to radians B = AASCoordinateTransformation.DegreesToRadians(B); L = AASCoordinateTransformation.DegreesToRadians(L); double cosB = Math.Cos(B); //Return the result return(AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(Math.Acos((x * cosB * Math.Cos(L) + y * cosB * Math.Sin(L) + z * Math.Sin(B)) / Delta)))); }
public static double PositionAngle(double Alpha0, double Delta0, double Alpha, double Delta) { //Convert to radians Alpha0 = AASCoordinateTransformation.HoursToRadians(Alpha0); Alpha = AASCoordinateTransformation.HoursToRadians(Alpha); Delta0 = AASCoordinateTransformation.DegreesToRadians(Delta0); Delta = AASCoordinateTransformation.DegreesToRadians(Delta); return(AASCoordinateTransformation.MapTo0To360Range(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))))); }
public static double MinorPlanetMagnitude(double H, double delta, double G, double r, double PhaseAngle) { //Convert from degrees to radians PhaseAngle = AASCoordinateTransformation.DegreesToRadians(PhaseAngle); double phi1 = Math.Exp(-3.33 * Math.Pow(Math.Tan(PhaseAngle / 2), 0.63)); double phi2 = Math.Exp(-1.87 * Math.Pow(Math.Tan(PhaseAngle / 2), 1.22)); return(H + 5 * Math.Log10(r * delta) - 2.5 * Math.Log10((1 - G) * phi1 + G * phi2)); }
public static double EclipticLongitudeOnHorizon(double LocalSiderealTime, double ObliquityOfEcliptic, double Latitude) { LocalSiderealTime = AASCoordinateTransformation.HoursToRadians(LocalSiderealTime); Latitude = AASCoordinateTransformation.DegreesToRadians(Latitude); ObliquityOfEcliptic = AASCoordinateTransformation.DegreesToRadians(ObliquityOfEcliptic); double value = AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(-Math.Cos(LocalSiderealTime), Math.Sin(ObliquityOfEcliptic) * Math.Tan(Latitude) + Math.Cos(ObliquityOfEcliptic) * Math.Sin(LocalSiderealTime))); return(AASCoordinateTransformation.MapTo0To360Range(value)); }
public static double AngleBetweenEclipticAndHorizon(double LocalSiderealTime, double ObliquityOfEcliptic, double Latitude) { LocalSiderealTime = AASCoordinateTransformation.HoursToRadians(LocalSiderealTime); Latitude = AASCoordinateTransformation.DegreesToRadians(Latitude); ObliquityOfEcliptic = AASCoordinateTransformation.DegreesToRadians(ObliquityOfEcliptic); double value = AASCoordinateTransformation.RadiansToDegrees(Math.Acos(Math.Cos(ObliquityOfEcliptic) * Math.Sin(Latitude) - Math.Sin(ObliquityOfEcliptic) * Math.Cos(Latitude) * Math.Sin(LocalSiderealTime))); return(AASCoordinateTransformation.MapTo0To360Range(value)); }
public static double AngleBetweenNorthCelestialPoleAndNorthPoleOfEcliptic(double Lambda, double Beta, double ObliquityOfEcliptic) { Lambda = AASCoordinateTransformation.DegreesToRadians(Lambda); Beta = AASCoordinateTransformation.DegreesToRadians(Beta); ObliquityOfEcliptic = AASCoordinateTransformation.DegreesToRadians(ObliquityOfEcliptic); double value = AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(Math.Cos(Lambda) * Math.Tan(ObliquityOfEcliptic), Math.Sin(Beta) * Math.Sin(Lambda) * Math.Tan(ObliquityOfEcliptic) - Math.Cos(Beta))); return(AASCoordinateTransformation.MapTo0To360Range(value)); }
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 CorrectionInLatitude(double Longitude, double JD) { double T = (JD - 2451545) / 36525; double Ldash = Longitude - 1.397 * T - 0.00031 * T * T; //Convert to radians Ldash = AASCoordinateTransformation.DegreesToRadians(Ldash); double value = 0.03916 * (Math.Cos(Ldash) - Math.Sin(Ldash)); return(AASCoordinateTransformation.DMSToDegrees(0, 0, value)); }
public static double TimeOfStartOfRotation(long C) { double JED = 2398140.2270 + 27.2752316 * C; double M = AASCoordinateTransformation.MapTo0To360Range(281.96 + 26.882476 * C); M = AASCoordinateTransformation.DegreesToRadians(M); JED += (0.1454 * Math.Sin(M) - 0.0085 * Math.Sin(2 * M) - 0.0141 * Math.Cos(2 * M)); return(JED); }
public static double EclipticLatitude(double JD) { double Ldash = MeanLongitude(JD); 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 T = (JD - 2451545) / 36525; double A1 = AASCoordinateTransformation.MapTo0To360Range(119.75 + 131.849 * T); A1 = AASCoordinateTransformation.DegreesToRadians(A1); double A3 = AASCoordinateTransformation.MapTo0To360Range(313.45 + 481266.484 * T); A3 = AASCoordinateTransformation.DegreesToRadians(A3); int nBCoefficients = g_MoonCoefficients3.Length; double SigmaB = 0; for (int i = 0; i < nBCoefficients; i++) { double ThisSigma = g_MoonCoefficients4[i] * Math.Sin(g_MoonCoefficients3[i].D * D + g_MoonCoefficients3[i].M * M + g_MoonCoefficients3[i].Mdash * Mdash + g_MoonCoefficients3[i].F * F); if (g_MoonCoefficients3[i].M == 1) { ThisSigma *= E; } SigmaB += ThisSigma; } //Finally the additive terms SigmaB -= 2235 * Math.Sin(Ldash); SigmaB += 382 * Math.Sin(A3); SigmaB += 175 * Math.Sin(A1 - F); SigmaB += 175 * Math.Sin(A1 + F); SigmaB += 127 * Math.Sin(Ldash - Mdash); SigmaB -= 115 * Math.Sin(Ldash + Mdash); return(SigmaB / 1000000); }
public static double GeocentricElongation(double ObjectAlpha, double ObjectDelta, double SunAlpha, double SunDelta) { //Convert the RA's to radians ObjectAlpha = AASCoordinateTransformation.DegreesToRadians(ObjectAlpha * 15); SunAlpha = AASCoordinateTransformation.DegreesToRadians(SunAlpha * 15); //Convert the declinations to radians ObjectDelta = AASCoordinateTransformation.DegreesToRadians(ObjectDelta); SunDelta = AASCoordinateTransformation.DegreesToRadians(SunDelta); //Return the result return(AASCoordinateTransformation.RadiansToDegrees(Math.Acos(Math.Sin(SunDelta) * Math.Sin(ObjectDelta) + Math.Cos(SunDelta) * Math.Cos(ObjectDelta) * Math.Cos(SunAlpha - ObjectAlpha)))); }
public static double AltitudeOfSun(double JD, double Longitude, double Latitude, bool bHighPrecision) { //Calculate the selenographic details AASSelenographicMoonDetails selenographicDetails = CalculateSelenographicPositionOfSun(JD, bHighPrecision); //convert to radians Latitude = AASCoordinateTransformation.DegreesToRadians(Latitude); Longitude = AASCoordinateTransformation.DegreesToRadians(Longitude); selenographicDetails.b0 = AASCoordinateTransformation.DegreesToRadians(selenographicDetails.b0); selenographicDetails.c0 = AASCoordinateTransformation.DegreesToRadians(selenographicDetails.c0); return(AASCoordinateTransformation.RadiansToDegrees(Math.Asin(Math.Sin(selenographicDetails.b0) * Math.Sin(Latitude) + Math.Cos(selenographicDetails.b0) * Math.Cos(Latitude) * Math.Sin(selenographicDetails.c0 + Longitude)))); }
public static AASRiseTransitSetDetails Calculate(double JD, double Alpha1, double Delta1, double Alpha2, double Delta2, double Alpha3, double Delta3, double Longitude, double Latitude, double h0) { //What will be the return value AASRiseTransitSetDetails details = new AASRiseTransitSetDetails(); details.bRiseValid = false; details.bSetValid = false; details.bTransitValid = true; details.bTransitAboveHorizon = false; //Calculate the sidereal time double theta0 = AASSidereal.ApparentGreenwichSiderealTime(JD); theta0 *= 15; //Express it as degrees //Calculate deltat double deltaT = AASDynamicalTime.DeltaT(JD); //Convert values to radians double Delta2Rad = AASCoordinateTransformation.DegreesToRadians(Delta2); double LatitudeRad = AASCoordinateTransformation.DegreesToRadians(Latitude); //Convert the standard latitude to radians double h0Rad = AASCoordinateTransformation.DegreesToRadians(h0); //Calculate cosH0 double cosH0 = (Math.Sin(h0Rad) - Math.Sin(LatitudeRad) * Math.Sin(Delta2Rad)) / (Math.Cos(LatitudeRad) * Math.Cos(Delta2Rad)); //Calculate M0 double M0 = CalculateTransit(Alpha2, theta0, Longitude); //Calculate M1 & M2 double M1 = 0; double M2 = 0; CalculateRiseSet(M0, cosH0, ref details, ref M1, ref M2); //Ensure the RA values are corrected for interpolation. Due to important Remark 2 by Meeus on Interopolation of RA values CorrectRAValuesForInterpolation(ref Alpha1, ref Alpha2, ref Alpha3); //Do the main work CalculateTransitHelper(ref details, theta0, deltaT, Alpha1, Alpha2, Alpha3, Longitude, ref M0); CalculateRiseHelper(ref details, theta0, deltaT, Alpha1, Delta1, Alpha2, Delta2, Alpha3, Delta3, Longitude, Latitude, LatitudeRad, h0, ref M1); CalculateSetHelper(ref details, theta0, deltaT, Alpha1, Delta1, Alpha2, Delta2, Alpha3, Delta3, Longitude, Latitude, LatitudeRad, h0, ref M2); details.Rise = details.bRiseValid ? (M1 * 24) : 0.0; details.Set = details.bSetValid ? (M2 * 24) : 0.0; details.Transit = details.bTransitValid ? (M0 * 24) : 0.0; return(details); }
private static void CorrectRAValuesForInterpolation(ref double Alpha1, ref double Alpha2, ref double Alpha3) { //Ensure the RA values are corrected for interpolation. Due to important Remark 2 by Meeus on Interopolation of RA values Alpha1 = AASCoordinateTransformation.MapTo0To24Range(Alpha1); Alpha2 = AASCoordinateTransformation.MapTo0To24Range(Alpha2); Alpha3 = AASCoordinateTransformation.MapTo0To24Range(Alpha3); if (Math.Abs(Alpha2 - Alpha1) > 12.0) { if (Alpha2 > Alpha1) { Alpha1 += 24; } else { Alpha2 += 24; } } if (Math.Abs(Alpha3 - Alpha2) > 12.0) { if (Alpha3 > Alpha2) { Alpha2 += 24; } else { Alpha3 += 24; } } if (Math.Abs(Alpha2 - Alpha1) > 12.0) { if (Alpha2 > Alpha1) { Alpha1 += 24; } else { Alpha2 += 24; } } if (Math.Abs(Alpha3 - Alpha2) > 12.0) { if (Alpha3 > Alpha2) { Alpha2 += 24; } else { Alpha3 += 24; } } }
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 double RefractionFromApparent(double Altitude, double Pressure = 1010, double Temperature = 10) { //return a constant value from this method if the altitude is below a specific value if (Altitude <= -1.6962987799993996) { Altitude = -1.6962987799993996; } double value = 1 / (Math.Tan(AASCoordinateTransformation.DegreesToRadians(Altitude + 7.31 / (Altitude + 4.4)))) + 0.0013515; value *= (Pressure / 1010 * 283 / (273 + Temperature)); value /= 60; return(value); }
public static double RefractionFromTrue(double Altitude, double Pressure = 1010, double Temperature = 10) { //return a constant value from this method if the altitude is below a specific value if (Altitude <= -1.9006387000003735) { Altitude = -1.9006387000003735; } double value = 1.02 / (Math.Tan(AASCoordinateTransformation.DegreesToRadians(Altitude + 10.3 / (Altitude + 5.11)))) + 0.0019279; value *= (Pressure / 1010 * 283 / (273 + Temperature)); value /= 60; return(value); }
public static AASPhysicalMoonDetails CalculateHelper(double JD, ref double Lambda, ref double Beta, ref double epsilon, ref AAS2DCoordinate Equatorial) { //What will be the return value AASPhysicalMoonDetails details = new AASPhysicalMoonDetails(); //Calculate the initial quantities Lambda = AASMoon.EclipticLongitude(JD); Beta = AASMoon.EclipticLatitude(JD); //Calculate the optical libration double omega = 0; double DeltaU = 0; double sigma = 0; double I = 0; double rho = 0; double ldash = 0; double bdash = 0; double ldash2 = 0; double bdash2 = 0; CalculateOpticalLibration(JD, Lambda, Beta, ref ldash, ref bdash, ref ldash2, ref bdash2, ref epsilon, ref omega, ref DeltaU, ref sigma, ref I, ref rho); details.ldash = ldash; details.bdash = bdash; details.ldash2 = ldash2; details.bdash2 = bdash2; double epsilonrad = AASCoordinateTransformation.DegreesToRadians(epsilon); //Calculate the total libration details.l = details.ldash + details.ldash2; details.b = details.bdash + details.bdash2; double b = AASCoordinateTransformation.DegreesToRadians(details.b); //Calculate the position angle double V = omega + DeltaU + AASCoordinateTransformation.DegreesToRadians(sigma) / Math.Sin(I); double I_rho = I + AASCoordinateTransformation.DegreesToRadians(rho); double X = Math.Sin(I_rho) * Math.Sin(V); double Y = Math.Sin(I_rho) * Math.Cos(V) * Math.Cos(epsilonrad) - Math.Cos(I_rho) * Math.Sin(epsilonrad); double w = Math.Atan2(X, Y); Equatorial = AASCoordinateTransformation.Ecliptic2Equatorial(Lambda, Beta, epsilon); double Alpha = AASCoordinateTransformation.HoursToRadians(Equatorial.X); details.P = AASCoordinateTransformation.RadiansToDegrees(Math.Asin(Math.Sqrt(X * X + Y * Y) * Math.Cos(Alpha - w) / (Math.Cos(b)))); return(details); }
public static AASNodeObjectDetails PassageThroAscendingNode(ref AASParabolicObjectElements elements) { double v = AASCoordinateTransformation.MapTo0To360Range(-elements.w); v = AASCoordinateTransformation.DegreesToRadians(v); double s = Math.Tan(v / 2); double s2 = s * s; AASNodeObjectDetails details = new AASNodeObjectDetails(); details.t = elements.T + 27.403895 * (s2 * s + 3 * s) * elements.q * Math.Sqrt(elements.q); details.radius = elements.q * (1 + s2); return(details); }
public static double Calculate(double M, double e, int nIterations = 53) { //Convert from degrees to radians M = AASCoordinateTransformation.DegreesToRadians(M); double PI = AASCoordinateTransformation.PI(); double F = 1; if (M < 0) { F = -1; } M = Math.Abs(M) / (2 * PI); M = (M - (int)(M)) * 2 * PI * F; if (M < 0) { M += 2 * PI; } F = 1; if (M > PI) { F = -1; } if (M > PI) { M = 2 * PI - M; } double E = PI / 2; double scale = PI / 4; for (int i = 0; i < nIterations; i++) { double R = E - e * Math.Sin(E); if (M > R) { E += scale; } else { E -= scale; } scale /= 2; } //Convert the result back to degrees return(AASCoordinateTransformation.RadiansToDegrees(E) * F); }
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 TopocentricMoonSemidiameter(double DistanceDelta, double Delta, double H, double Latitude, double Height) { //Convert to radians H = AASCoordinateTransformation.HoursToRadians(H); Delta = AASCoordinateTransformation.DegreesToRadians(Delta); double pi = Math.Asin(6378.14 / DistanceDelta); double A = Math.Cos(Delta) * Math.Sin(H); double B = Math.Cos(Delta) * Math.Cos(H) - AASGlobe.RhoCosThetaPrime(Latitude, Height) * Math.Sin(pi); double C = Math.Sin(Delta) - AASGlobe.RhoSinThetaPrime(Latitude, Height) * Math.Sin(pi); double q = Math.Sqrt(A * A + B * B + C * C); double s = AASCoordinateTransformation.DegreesToRadians(GeocentricMoonSemidiameter(DistanceDelta) / 3600); return(AASCoordinateTransformation.RadiansToDegrees(Math.Asin(Math.Sin(s) / q)) * 3600); }
public static AAS2DCoordinate EquatorialPMToEcliptic(double Alpha, double Delta, double Beta, double PMAlpha, double PMDelta, double Epsilon) { //Convert to radians Epsilon = AASCoordinateTransformation.DegreesToRadians(Epsilon); Alpha = AASCoordinateTransformation.HoursToRadians(Alpha); Delta = AASCoordinateTransformation.DegreesToRadians(Delta); Beta = AASCoordinateTransformation.DegreesToRadians(Beta); double cosb = Math.Cos(Beta); double sinEpsilon = Math.Sin(Epsilon); AAS2DCoordinate value = new AAS2DCoordinate { X = (PMDelta * sinEpsilon * Math.Cos(Alpha) + PMAlpha * Math.Cos(Delta) * (Math.Cos(Epsilon) * Math.Cos(Delta) + sinEpsilon * Math.Sin(Delta) * Math.Sin(Alpha))) / (cosb * cosb), Y = (PMDelta * (Math.Cos(Epsilon) * Math.Cos(Delta) + sinEpsilon * Math.Sin(Delta) * Math.Sin(Alpha)) - PMAlpha * sinEpsilon * Math.Cos(Alpha) * Math.Cos(Delta)) / cosb }; return(value); }
public static double ApparentEccentricity(double e, double i, double w) { i = AASCoordinateTransformation.DegreesToRadians(i); w = AASCoordinateTransformation.DegreesToRadians(w); double cosi = Math.Cos(i); double cosw = Math.Cos(w); double sinw = Math.Sin(w); double esquared = e * e; double A = (1 - esquared * cosw * cosw) * cosi * cosi; double B = esquared * sinw * cosw * cosi; double C = 1 - esquared * sinw * sinw; double D = (A - C) * (A - C) + 4 * B * B; double sqrtD = Math.Sqrt(D); return(Math.Sqrt(2 * sqrtD / (A + C + sqrtD))); }
public static AASNodeObjectDetails PassageThroDescendingNode(ref AASEllipticalObjectElements elements) { double v = AASCoordinateTransformation.MapTo0To360Range(180 - elements.w); v = AASCoordinateTransformation.DegreesToRadians(v); double E = Math.Atan(Math.Sqrt((1 - elements.e) / (1 + elements.e)) * Math.Tan(v / 2)) * 2; double M = E - elements.e * Math.Sin(E); M = AASCoordinateTransformation.RadiansToDegrees(M); double n = AASElliptical.MeanMotionFromSemiMajorAxis(elements.a); AASNodeObjectDetails details = new AASNodeObjectDetails(); details.t = elements.T + M / n; details.radius = elements.a * (1 - elements.e * Math.Cos(E)); return(details); }