public static double ParallacticAngle(double HourAngle, double Latitude, double delta)
{
HourAngle = AASCoordinateTransformation.HoursToRadians(HourAngle);
Latitude = AASCoordinateTransformation.DegreesToRadians(Latitude);
delta = AASCoordinateTransformation.DegreesToRadians(delta);
return(AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(Math.Sin(HourAngle), Math.Tan(Latitude) * Math.Cos(delta) - Math.Sin(delta) * Math.Cos(HourAngle))));
}
public static double PhaseAngle(double GeocentricElongation, double EarthObjectDistance, double EarthSunDistance)
{
//Convert from degrees to radians
GeocentricElongation = AASCoordinateTransformation.DegreesToRadians(GeocentricElongation);
//Return the result
return(AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(EarthSunDistance * Math.Sin(GeocentricElongation), EarthObjectDistance - EarthSunDistance * Math.Cos(GeocentricElongation)))));
}
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 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 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 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 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 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 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 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 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 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);
}
public static double PositionAngle(double Alpha1, double Delta1, double Alpha2, double Delta2)
{
Delta1 = AASCoordinateTransformation.DegreesToRadians(Delta1);
Delta2 = AASCoordinateTransformation.DegreesToRadians(Delta2);
Alpha1 = AASCoordinateTransformation.HoursToRadians(Alpha1);
Alpha2 = AASCoordinateTransformation.HoursToRadians(Alpha2);
double DeltaAlpha = Alpha1 - Alpha2;
double value = Math.Atan2(Math.Sin(DeltaAlpha), Math.Cos(Delta2) * Math.Tan(Delta1) - Math.Sin(Delta2) * Math.Cos(DeltaAlpha));
value = AASCoordinateTransformation.RadiansToDegrees(value);
if (value < 0)
{
value += 180;
}
return(value);
}
public static AASTopocentricEclipticDetails Ecliptic2Topocentric(double Lambda, double Beta, double Semidiameter, double Distance, double Epsilon, double Latitude, double Height, double JD)
{
double S = AASGlobe.RhoSinThetaPrime(Latitude, Height);
double C = AASGlobe.RhoCosThetaPrime(Latitude, Height);
//Convert to radians
Lambda = AASCoordinateTransformation.DegreesToRadians(Lambda);
Beta = AASCoordinateTransformation.DegreesToRadians(Beta);
Epsilon = AASCoordinateTransformation.DegreesToRadians(Epsilon);
Semidiameter = AASCoordinateTransformation.DegreesToRadians(Semidiameter);
double sine = Math.Sin(Epsilon);
double cose = Math.Cos(Epsilon);
double cosBeta = Math.Cos(Beta);
double sinBeta = Math.Sin(Beta);
//Calculate the Sidereal time
double theta = AASSidereal.ApparentGreenwichSiderealTime(JD);
theta = AASCoordinateTransformation.HoursToRadians(theta);
double sintheta = Math.Sin(theta);
//Calculate the Parallax
double pi = Math.Asin(g_AAParallax_C1 / Distance);
double sinpi = Math.Sin(pi);
double N = Math.Cos(Lambda) * cosBeta - C * sinpi * Math.Cos(theta);
AASTopocentricEclipticDetails Topocentric = new AASTopocentricEclipticDetails {
Lambda = Math.Atan2(Math.Sin(Lambda) * cosBeta - sinpi * (S * sine + C * cose * sintheta), N)
};
double cosTopocentricLambda = Math.Cos(Topocentric.Lambda);
Topocentric.Beta = Math.Atan(cosTopocentricLambda * (sinBeta - sinpi * (S * cose - C * sine * sintheta)) / N);
Topocentric.Semidiameter = Math.Asin(cosTopocentricLambda * Math.Cos(Topocentric.Beta) * Math.Sin(Semidiameter) / N);
//Convert back to degrees
Topocentric.Semidiameter = AASCoordinateTransformation.RadiansToDegrees(Topocentric.Semidiameter);
Topocentric.Lambda = AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(Topocentric.Lambda));
Topocentric.Beta = AASCoordinateTransformation.RadiansToDegrees(Topocentric.Beta);
return(Topocentric);
}
public static AAS2DCoordinate PrecessEcliptic(double Lambda, double Beta, 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
Lambda = AASCoordinateTransformation.DegreesToRadians(Lambda);
Beta = AASCoordinateTransformation.DegreesToRadians(Beta);
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 A = Math.Cos(eta) * Math.Cos(Beta) * Math.Sin(pi - Lambda) - Math.Sin(eta) * Math.Sin(Beta);
double B = Math.Cos(Beta) * Math.Cos(pi - Lambda);
double C = Math.Cos(eta) * Math.Sin(Beta) + Math.Sin(eta) * Math.Cos(Beta) * Math.Sin(pi - Lambda);
AAS2DCoordinate value = new AAS2DCoordinate {
X = AASCoordinateTransformation.RadiansToDegrees(p + pi - Math.Atan2(A, B))
};
if (value.X < 0)
{
value.X += 360;
}
value.Y = AASCoordinateTransformation.RadiansToDegrees(Math.Asin(C));
return(value);
}
public static AAS2DCoordinate AdjustPositionUsingMotionInSpace(double r, double DeltaR, double t, double Alpha, double Delta, double PMAlpha, double PMDelta)
{
//Convert DeltaR from km/s to Parsecs / Year
DeltaR /= 977792;
//Convert from seconds of time to Radians / Year
PMAlpha /= 13751;
//Convert from seconds of arc to Radians / Year
PMDelta /= 206265;
//Now convert to radians
Alpha = AASCoordinateTransformation.HoursToRadians(Alpha);
Delta = AASCoordinateTransformation.DegreesToRadians(Delta);
double x = r * Math.Cos(Delta) * Math.Cos(Alpha);
double y = r * Math.Cos(Delta) * Math.Sin(Alpha);
double z = r * Math.Sin(Delta);
double DeltaX = x / r * DeltaR - z * PMDelta * Math.Cos(Alpha) - y * PMAlpha;
double DeltaY = y / r * DeltaR - z * PMDelta * Math.Sin(Alpha) + x * PMAlpha;
double DeltaZ = z / r * DeltaR + r * PMDelta * Math.Cos(Delta);
x += t * DeltaX;
y += t * DeltaY;
z += t * DeltaZ;
AAS2DCoordinate value = new AAS2DCoordinate {
X = AASCoordinateTransformation.RadiansToHours(Math.Atan2(y, x))
};
if (value.X < 0)
{
value.X += 24;
}
value.Y = AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(z, Math.Sqrt(x * x + y * y)));
return(value);
}
public static AAS2DCoordinate PrecessEquatorial(double Alpha, double Delta, 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
Alpha = AASCoordinateTransformation.HoursToRadians(Alpha);
Delta = AASCoordinateTransformation.DegreesToRadians(Delta);
double sigma = (2306.2181 + 1.39656 * T - 0.000139 * Tsquared) * t + (0.30188 - 0.0000344 * T) * tsquared + 0.017988 * tcubed;
sigma = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, sigma));
double zeta = (2306.2181 + 1.39656 * T - 0.000138 * Tsquared) * t + (1.09468 + 0.000066 * T) * tsquared + 0.018203 * tcubed;
zeta = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, zeta));
double phi = (2004.3109 - 0.8533 * T - 0.000217 * Tsquared) * t - (0.42665 + 0.000217 * T) * tsquared - 0.041833 * tcubed;
phi = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, phi));
double A = Math.Cos(Delta) * Math.Sin(Alpha + sigma);
double B = Math.Cos(phi) * Math.Cos(Delta) * Math.Cos(Alpha + sigma) - Math.Sin(phi) * Math.Sin(Delta);
double C = Math.Sin(phi) * Math.Cos(Delta) * Math.Cos(Alpha + sigma) + Math.Cos(phi) * Math.Sin(Delta);
AAS2DCoordinate value = new AAS2DCoordinate {
X = AASCoordinateTransformation.RadiansToHours(Math.Atan2(A, B) + zeta)
};
if (value.X < 0)
{
value.X += 24;
}
value.Y = AASCoordinateTransformation.RadiansToDegrees(Math.Asin(C));
return(value);
}
public static AAS2DCoordinate PrecessEquatorialFK4(double Alpha, double Delta, double JD0, double JD)
{
double T = (JD0 - 2415020.3135) / 36524.2199;
double t = (JD - JD0) / 36524.2199;
double tsquared = t * t;
double tcubed = tsquared * t;
//Now convert to radians
Alpha = AASCoordinateTransformation.HoursToRadians(Alpha);
Delta = AASCoordinateTransformation.DegreesToRadians(Delta);
double sigma = (2304.250 + 1.396 * T) * t + 0.302 * tsquared + 0.018 * tcubed;
sigma = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, sigma));
double zeta = 0.791 * tsquared + 0.001 * tcubed;
zeta = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, zeta));
zeta += sigma;
double phi = (2004.682 - 0.853 * T) * t - 0.426 * tsquared - 0.042 * tcubed;
phi = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, phi));
double A = Math.Cos(Delta) * Math.Sin(Alpha + sigma);
double B = Math.Cos(phi) * Math.Cos(Delta) * Math.Cos(Alpha + sigma) - Math.Sin(phi) * Math.Sin(Delta);
double C = Math.Sin(phi) * Math.Cos(Delta) * Math.Cos(Alpha + sigma) + Math.Cos(phi) * Math.Sin(Delta);
AAS2DCoordinate value = new AAS2DCoordinate {
X = AASCoordinateTransformation.RadiansToHours(Math.Atan2(A, B) + zeta)
};
if (value.X < 0)
{
value.X += 24;
}
value.Y = AASCoordinateTransformation.RadiansToDegrees(Math.Asin(C));
return(value);
}
public static double Separation(double Alpha1, double Delta1, double Alpha2, double Delta2)
{
Delta1 = AASCoordinateTransformation.DegreesToRadians(Delta1);
Delta2 = AASCoordinateTransformation.DegreesToRadians(Delta2);
Alpha1 = AASCoordinateTransformation.HoursToRadians(Alpha1);
Alpha2 = AASCoordinateTransformation.HoursToRadians(Alpha2);
double x = Math.Cos(Delta1) * Math.Sin(Delta2) - Math.Sin(Delta1) * Math.Cos(Delta2) * Math.Cos(Alpha2 - Alpha1);
double y = Math.Cos(Delta2) * Math.Sin(Alpha2 - Alpha1);
double z = Math.Sin(Delta1) * Math.Sin(Delta2) + Math.Cos(Delta1) * Math.Cos(Delta2) * Math.Cos(Alpha2 - Alpha1);
double value = Math.Atan2(Math.Sqrt(x * x + y * y), z);
value = AASCoordinateTransformation.RadiansToDegrees(value);
if (value < 0)
{
value += 180;
}
return(value);
}
public static double DistanceFromGreatArc(double Alpha1, double Delta1, double Alpha2, double Delta2, double Alpha3, double Delta3)
{
Delta1 = AASCoordinateTransformation.DegreesToRadians(Delta1);
Delta2 = AASCoordinateTransformation.DegreesToRadians(Delta2);
Delta3 = AASCoordinateTransformation.DegreesToRadians(Delta3);
Alpha1 = AASCoordinateTransformation.HoursToRadians(Alpha1);
Alpha2 = AASCoordinateTransformation.HoursToRadians(Alpha2);
Alpha3 = AASCoordinateTransformation.HoursToRadians(Alpha3);
double X1 = Math.Cos(Delta1) * Math.Cos(Alpha1);
double X2 = Math.Cos(Delta2) * Math.Cos(Alpha2);
double Y1 = Math.Cos(Delta1) * Math.Sin(Alpha1);
double Y2 = Math.Cos(Delta2) * Math.Sin(Alpha2);
double Z1 = Math.Sin(Delta1);
double Z2 = Math.Sin(Delta2);
double A = Y1 * Z2 - Z1 * Y2;
double B = Z1 * X2 - X1 * Z2;
double C = X1 * Y2 - Y1 * X2;
double m = Math.Tan(Alpha3);
double n = Math.Tan(Delta3) / Math.Cos(Alpha3);
double value = Math.Asin((A + B * m + C * n) / (Math.Sqrt(A * A + B * B + C * C) * Math.Sqrt(1 + m * m + n * n)));
value = AASCoordinateTransformation.RadiansToDegrees(value);
if (value < 0)
{
value = Math.Abs(value);
}
return(value);
}
public static double EclipticLatitude(double JD, bool bHighPrecision)
{
if (bHighPrecision)
{
return(AASCoordinateTransformation.MapToMinus90To90Range(AASCoordinateTransformation.RadiansToDegrees(AASVSOP87D_Earth.B(JD))));
}
double rho = (JD - 2451545) / 365250;
//Calculate B0
int nB0Coefficients = g_B0EarthCoefficients.Length;
double B0 = 0;
int i;
for (i = 0; i < nB0Coefficients; i++)
{
B0 += g_B0EarthCoefficients[i].A * Math.Cos(g_B0EarthCoefficients[i].B + g_B0EarthCoefficients[i].C * rho);
}
//Calculate B1
int nB1Coefficients = g_B1EarthCoefficients.Length;
double B1 = 0;
for (i = 0; i < nB1Coefficients; i++)
{
B1 += g_B1EarthCoefficients[i].A * Math.Cos(g_B1EarthCoefficients[i].B + g_B1EarthCoefficients[i].C * rho);
}
//Note for Earth there are no B2, B3 or B4 coefficients to calculate
double value = (B0 + B1 * rho) / 100000000;
//convert results back to degrees
value = AASCoordinateTransformation.RadiansToDegrees(value);
return(value);
}
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 double PhaseAngle(double r, double R, double Delta)
{
//Return the result
return(AASCoordinateTransformation.MapTo0To360Range(AASCoordinateTransformation.RadiansToDegrees(Math.Acos((r * r + Delta * Delta - R * R) / (2 * r * Delta)))));
}
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 double DistanceToParallax(double Distance)
{
double pi = Math.Asin(g_AAParallax_C1 / Distance);
return(AASCoordinateTransformation.RadiansToDegrees(pi));
}
public static AAS2DCoordinate Equatorial2TopocentricDelta(double Alpha, double Delta, double Distance, double Longitude, double Latitude, double Height, double JD)
{
double RhoSinThetaPrime = AASGlobe.RhoSinThetaPrime(Latitude, Height);
double RhoCosThetaPrime = AASGlobe.RhoCosThetaPrime(Latitude, Height);
//Calculate the Sidereal time
double theta = AASSidereal.ApparentGreenwichSiderealTime(JD);
//Convert to radians
Delta = AASCoordinateTransformation.DegreesToRadians(Delta);
double cosDelta = Math.Cos(Delta);
//Calculate the Parallax
double pi = Math.Asin(g_AAParallax_C1 / Distance);
//Calculate the hour angle
double H = AASCoordinateTransformation.HoursToRadians(theta - Longitude / 15 - Alpha);
double cosH = Math.Cos(H);
double sinH = Math.Sin(H);
AAS2DCoordinate DeltaTopocentric = new AAS2DCoordinate {
X = AASCoordinateTransformation.RadiansToHours(-pi * RhoCosThetaPrime * sinH / cosDelta), Y = AASCoordinateTransformation.RadiansToDegrees(-pi * (RhoSinThetaPrime * cosDelta - RhoCosThetaPrime * cosH * Math.Sin(Delta)))
};
return(DeltaTopocentric);
}
public static AAS2DCoordinate Equatorial2Topocentric(double Alpha, double Delta, double Distance, double Longitude, double Latitude, double Height, double JD)
{
double RhoSinThetaPrime = AASGlobe.RhoSinThetaPrime(Latitude, Height);
double RhoCosThetaPrime = AASGlobe.RhoCosThetaPrime(Latitude, Height);
//Calculate the Sidereal time
double theta = AASSidereal.ApparentGreenwichSiderealTime(JD);
//Convert to radians
Delta = AASCoordinateTransformation.DegreesToRadians(Delta);
double cosDelta = Math.Cos(Delta);
//Calculate the Parallax
double pi = Math.Asin(g_AAParallax_C1 / Distance);
double sinpi = Math.Sin(pi);
//Calculate the hour angle
double H = AASCoordinateTransformation.HoursToRadians(theta - Longitude / 15 - Alpha);
double cosH = Math.Cos(H);
double sinH = Math.Sin(H);
//Calculate the adjustment in right ascension
double DeltaAlpha = Math.Atan2(-RhoCosThetaPrime * sinpi * sinH, cosDelta - RhoCosThetaPrime * sinpi * cosH);
AAS2DCoordinate Topocentric = new AAS2DCoordinate {
X = AASCoordinateTransformation.MapTo0To24Range(Alpha + AASCoordinateTransformation.RadiansToHours(DeltaAlpha)), Y = AASCoordinateTransformation.RadiansToDegrees(Math.Atan2((Math.Sin(Delta) - RhoSinThetaPrime * sinpi) * Math.Cos(DeltaAlpha), cosDelta - RhoCosThetaPrime * sinpi * cosH))
};
return(Topocentric);
}