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);
}
