public static CAAPhysicalMoonDetails CalculateTopocentric(double JD, double Longitude, double Latitude)
{
//First convert to radians
Longitude = CAACoordinateTransformation.DegreesToRadians(Longitude);
Latitude = CAACoordinateTransformation.DegreesToRadians(Latitude);
double Lambda=0;
double Beta=0;
double epsilon=0;
CAA2DCoordinate Equatorial = new CAA2DCoordinate();
CAAPhysicalMoonDetails details = CalculateHelper(JD, ref Lambda, ref Beta, ref epsilon, ref Equatorial);
double R = CAAMoon.RadiusVector(JD);
double pi = CAAMoon.RadiusVectorToHorizontalParallax(R);
double Alpha = CAACoordinateTransformation.HoursToRadians(Equatorial.X);
double Delta = CAACoordinateTransformation.DegreesToRadians(Equatorial.Y);
double AST = CAASidereal.ApparentGreenwichSiderealTime(JD);
double H = CAACoordinateTransformation.HoursToRadians(AST) - Longitude - Alpha;
double Q = Math.Atan2(Math.Cos(Latitude)*Math.Sin(H), Math.Cos(Delta)*Math.Sin(Latitude) - Math.Sin(Delta)*Math.Cos(Latitude)*Math.Cos(H));
double Z = Math.Acos(Math.Sin(Delta)*Math.Sin(Latitude) + Math.Cos(Delta)*Math.Cos(Latitude)*Math.Cos(H));
double pidash = pi*(Math.Sin(Z) + 0.0084 *Math.Sin(2 *Z));
double Prad = CAACoordinateTransformation.DegreesToRadians(details.P);
double DeltaL = -pidash *Math.Sin(Q - Prad)/Math.Cos(CAACoordinateTransformation.DegreesToRadians(details.b));
details.l += DeltaL;
double DeltaB = pidash *Math.Cos(Q - Prad);
details.b += DeltaB;
details.P += DeltaL *Math.Sin(CAACoordinateTransformation.DegreesToRadians(details.b)) - pidash *Math.Sin(Q)*Math.Tan(Delta);
return details;
}
public static CAA2DCoordinate Equatorial2Topocentric(double Alpha, double Delta, double Distance, double Longitude, double Latitude, double Height, double JD)
{
double RhoSinThetaPrime = CAAGlobe.RhoSinThetaPrime(Latitude, Height);
double RhoCosThetaPrime = CAAGlobe.RhoCosThetaPrime(Latitude, Height);
//Calculate the Sidereal time
double theta = CAASidereal.ApparentGreenwichSiderealTime(JD);
//Convert to radians
Delta = CAACoordinateTransformation.DegreesToRadians(Delta);
double cosDelta = Math.Cos(Delta);
//Calculate the Parallax
double pi = Math.Asin(GlobalMembersStdafx.g_AAParallax_C1 / Distance);
double sinpi = Math.Sin(pi);
//Calculate the hour angle
double H = CAACoordinateTransformation.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);
CAA2DCoordinate Topocentric = new CAA2DCoordinate();
Topocentric.X = CAACoordinateTransformation.MapTo0To24Range(Alpha + CAACoordinateTransformation.RadiansToHours(DeltaAlpha));
Topocentric.Y = CAACoordinateTransformation.RadiansToDegrees(Math.Atan2((Math.Sin(Delta) - RhoSinThetaPrime * sinpi) * Math.Cos(DeltaAlpha), cosDelta - RhoCosThetaPrime * sinpi * cosH));
return(Topocentric);
}
//Conversion functions
public static CAA2DCoordinate Equatorial2TopocentricDelta(double Alpha, double Delta, double Distance, double Longitude, double Latitude, double Height, double JD)
{
double RhoSinThetaPrime = CAAGlobe.RhoSinThetaPrime(Latitude, Height);
double RhoCosThetaPrime = CAAGlobe.RhoCosThetaPrime(Latitude, Height);
//Calculate the Sidereal time
double theta = CAASidereal.ApparentGreenwichSiderealTime(JD);
//Convert to radians
Delta = CAACoordinateTransformation.DegreesToRadians(Delta);
double cosDelta = Math.Cos(Delta);
//Calculate the Parallax
double pi = Math.Asin(GlobalMembersStdafx.g_AAParallax_C1 / Distance);
//Calculate the hour angle
double H = CAACoordinateTransformation.HoursToRadians(theta - Longitude / 15 - Alpha);
double cosH = Math.Cos(H);
double sinH = Math.Sin(H);
CAA2DCoordinate DeltaTopocentric = new CAA2DCoordinate();
DeltaTopocentric.X = CAACoordinateTransformation.RadiansToHours(-pi * RhoCosThetaPrime * sinH / cosDelta);
DeltaTopocentric.Y = CAACoordinateTransformation.RadiansToDegrees(-pi * (RhoSinThetaPrime * cosDelta - RhoCosThetaPrime * cosH * Math.Sin(Delta)));
return(DeltaTopocentric);
}
public static CAA2DCoordinate Equatorial2Topocentric(double Alpha, double Delta, double Distance, double Longitude, double Latitude, double Height, double JD)
{
double RhoSinThetaPrime = CAAGlobe.RhoSinThetaPrime(Latitude, Height);
double RhoCosThetaPrime = CAAGlobe.RhoCosThetaPrime(Latitude, Height);
//Calculate the Sidereal time
double theta = CAASidereal.ApparentGreenwichSiderealTime(JD);
//Convert to radians
Delta = CAACoordinateTransformation.DegreesToRadians(Delta);
double cosDelta = Math.Cos(Delta);
//Calculate the Parallax
double pi = Math.Asin(GlobalMembersStdafx.g_AAParallax_C1 / Distance);
double sinpi = Math.Sin(pi);
//Calculate the hour angle
double H = CAACoordinateTransformation.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);
CAA2DCoordinate Topocentric = new CAA2DCoordinate();
Topocentric.X = CAACoordinateTransformation.MapTo0To24Range(Alpha + CAACoordinateTransformation.RadiansToHours(DeltaAlpha));
Topocentric.Y = CAACoordinateTransformation.RadiansToDegrees(Math.Atan2((Math.Sin(Delta) - RhoSinThetaPrime *sinpi) * Math.Cos(DeltaAlpha), cosDelta - RhoCosThetaPrime *sinpi *cosH));
return Topocentric;
}
//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 = CAACoordinateTransformation.MapTo0To360Range(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);
CAA2DCoordinate Equatorial = CAACoordinateTransformation.Ecliptic2Equatorial(SunLong, SunLat, epsilon);
epsilon = CAACoordinateTransformation.DegreesToRadians(epsilon);
double E = L0 - 0.0057183 - Equatorial.X * 15 + CAACoordinateTransformation.DMSToDegrees(0, 0, CAANutation.NutationInLongitude(JD)) * Math.Cos(epsilon);
if (E > 180)
{
E = -(360 - E);
}
E *= 4; //Convert to minutes of time
return(E);
}
//Static methods
public static CAAPhysicalMoonDetails CalculateGeocentric(double JD)
{
double Lambda=0;
double Beta=0;
double epsilon=0;
CAA2DCoordinate Equatorial = new CAA2DCoordinate();
return CalculateHelper(JD, ref Lambda, ref Beta, ref epsilon, ref Equatorial);
}
///////////////////////////////// Implementation //////////////////////////////
public static CAA2DCoordinate AdjustPositionUsingUniformProperMotion(double t, double Alpha, double Delta, double PMAlpha, double PMDelta)
{
var @value = new CAA2DCoordinate();
@value.X = Alpha + (PMAlpha * t / 3600);
@value.Y = Delta + (PMDelta * t / 3600);
return @value;
}
///////////////////////////////// Implementation //////////////////////////////
public static CAA2DCoordinate AdjustPositionUsingUniformProperMotion(double t, double Alpha, double Delta, double PMAlpha, double PMDelta)
{
CAA2DCoordinate @value = new CAA2DCoordinate();
@value.X = Alpha + (PMAlpha * t / 3600);
@value.Y = Delta + (PMDelta * t / 3600);
return(@value);
}
//Static methods
public static CAAPhysicalMoonDetails CalculateGeocentric(double JD)
{
double Lambda = 0;
double Beta = 0;
double epsilon = 0;
CAA2DCoordinate Equatorial = new CAA2DCoordinate();
return(CalculateHelper(JD, ref Lambda, ref Beta, ref epsilon, ref Equatorial));
}
public static CAA2DCoordinate Equatorial2Horizontal(double LocalHourAngle, double Delta, double Latitude)
{
LocalHourAngle = HoursToRadians(LocalHourAngle);
Delta = DegreesToRadians(Delta);
Latitude = DegreesToRadians(Latitude);
CAA2DCoordinate Horizontal = new CAA2DCoordinate();
Horizontal.X = RadiansToDegrees(Math.Atan2(Math.Sin(LocalHourAngle), Math.Cos(LocalHourAngle) * Math.Sin(Latitude) - Math.Tan(Delta) * Math.Cos(Latitude)));
if (Horizontal.X < 0)
{
Horizontal.X += 360;
}
Horizontal.Y = RadiansToDegrees(Math.Asin(Math.Sin(Latitude) * Math.Sin(Delta) + Math.Cos(Latitude) * Math.Cos(Delta) * Math.Cos(LocalHourAngle)));
return(Horizontal);
}
//Conversion functions
/////////////////////// Implementation ////////////////////////////////////////
public static CAA2DCoordinate Equatorial2Ecliptic(double Alpha, double Delta, double Epsilon)
{
Alpha = HoursToRadians(Alpha);
Delta = DegreesToRadians(Delta);
Epsilon = DegreesToRadians(Epsilon);
CAA2DCoordinate Ecliptic = new CAA2DCoordinate();
Ecliptic.X = RadiansToDegrees(Math.Atan2(Math.Sin(Alpha) * Math.Cos(Epsilon) + Math.Tan(Delta) * Math.Sin(Epsilon), Math.Cos(Alpha)));
if (Ecliptic.X < 0)
{
Ecliptic.X += 360;
}
Ecliptic.Y = RadiansToDegrees(Math.Asin(Math.Sin(Delta) * Math.Cos(Epsilon) - Math.Cos(Delta) * Math.Sin(Epsilon) * Math.Sin(Alpha)));
return(Ecliptic);
}
public static CAA2DCoordinate Ecliptic2Equatorial(double Lambda, double Beta, double Epsilon)
{
Lambda = DegreesToRadians(Lambda);
Beta = DegreesToRadians(Beta);
Epsilon = DegreesToRadians(Epsilon);
CAA2DCoordinate Equatorial = new CAA2DCoordinate();
Equatorial.X = RadiansToHours(Math.Atan2(Math.Sin(Lambda) * Math.Cos(Epsilon) - Math.Tan(Beta) * Math.Sin(Epsilon), Math.Cos(Lambda)));
if (Equatorial.X < 0)
{
Equatorial.X += 24;
}
Equatorial.Y = RadiansToDegrees(Math.Asin(Math.Sin(Beta) * Math.Cos(Epsilon) + Math.Cos(Beta) * Math.Sin(Epsilon) * Math.Sin(Lambda)));
return(Equatorial);
}
public static CAA2DCoordinate EquatorialPMToEcliptic(double Alpha, double Delta, double Beta, double PMAlpha, double PMDelta, double Epsilon)
{
//Convert to radians
Epsilon = CAACoordinateTransformation.DegreesToRadians(Epsilon);
Alpha = CAACoordinateTransformation.HoursToRadians(Alpha);
Delta = CAACoordinateTransformation.DegreesToRadians(Delta);
Beta = CAACoordinateTransformation.DegreesToRadians(Beta);
double cosb = Math.Cos(Beta);
double sinEpsilon = Math.Sin(Epsilon);
CAA2DCoordinate @value = new CAA2DCoordinate();
@value.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);
@value.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 CAA2DCoordinate Horizontal2Equatorial(double Azimuth, double Altitude, double Latitude)
{
//Convert from degress to radians
Azimuth = DegreesToRadians(Azimuth);
Altitude = DegreesToRadians(Altitude);
Latitude = DegreesToRadians(Latitude);
CAA2DCoordinate Equatorial = new CAA2DCoordinate();
Equatorial.X = RadiansToHours(Math.Atan2(Math.Sin(Azimuth), Math.Cos(Azimuth) * Math.Sin(Latitude) + Math.Tan(Altitude) * Math.Cos(Latitude)));
if (Equatorial.X < 0)
{
Equatorial.X += 24;
}
Equatorial.Y = RadiansToDegrees(Math.Asin(Math.Sin(Latitude) * Math.Sin(Altitude) - Math.Cos(Latitude) * Math.Cos(Altitude) * Math.Cos(Azimuth)));
return(Equatorial);
}
public static CAA2DCoordinate Equatorial2Galactic(double Alpha, double Delta)
{
Alpha = 192.25 - HoursToDegrees(Alpha);
Alpha = DegreesToRadians(Alpha);
Delta = DegreesToRadians(Delta);
CAA2DCoordinate Galactic = new CAA2DCoordinate();
Galactic.X = RadiansToDegrees(Math.Atan2(Math.Sin(Alpha), Math.Cos(Alpha) * Math.Sin(DegreesToRadians(27.4)) - Math.Tan(Delta) * Math.Cos(DegreesToRadians(27.4))));
Galactic.X = 303 - Galactic.X;
if (Galactic.X >= 360)
{
Galactic.X -= 360;
}
Galactic.Y = RadiansToDegrees(Math.Asin(Math.Sin(Delta) * Math.Sin(DegreesToRadians(27.4)) + Math.Cos(Delta) * Math.Cos(DegreesToRadians(27.4)) * Math.Cos(Alpha)));
return(Galactic);
}
public static CAA2DCoordinate Galactic2Equatorial(double l, double b)
{
l -= 123;
l = DegreesToRadians(l);
b = DegreesToRadians(b);
CAA2DCoordinate Equatorial = new CAA2DCoordinate();
Equatorial.X = RadiansToDegrees(Math.Atan2(Math.Sin(l), Math.Cos(l) * Math.Sin(DegreesToRadians(27.4)) - Math.Tan(b) * Math.Cos(DegreesToRadians(27.4))));
Equatorial.X += 12.25;
if (Equatorial.X < 0)
{
Equatorial.X += 360;
}
Equatorial.X = DegreesToHours(Equatorial.X);
Equatorial.Y = RadiansToDegrees(Math.Asin(Math.Sin(b) * Math.Sin(DegreesToRadians(27.4)) + Math.Cos(b) * Math.Cos(DegreesToRadians(27.4)) * Math.Cos(l)));
return(Equatorial);
}
public static CAA2DCoordinate EquatorialAberration(double Alpha, double Delta, double JD)
{
//Convert to radians
Alpha = CAACoordinateTransformation.DegreesToRadians(Alpha * 15);
Delta = CAACoordinateTransformation.DegreesToRadians(Delta);
double cosAlpha = Math.Cos(Alpha);
double sinAlpha = Math.Sin(Alpha);
double cosDelta = Math.Cos(Delta);
double sinDelta = Math.Sin(Delta);
CAA3DCoordinate velocity = EarthVelocity(JD);
//What is the return value
CAA2DCoordinate aberration = new CAA2DCoordinate();
aberration.X = CAACoordinateTransformation.RadiansToHours((velocity.Y * cosAlpha - velocity.X * sinAlpha) / (17314463350.0 * cosDelta));
aberration.Y = CAACoordinateTransformation.RadiansToDegrees(-(((velocity.X * cosAlpha + velocity.Y * sinAlpha) * sinDelta - velocity.Z * cosDelta) / 17314463350.0));
return(aberration);
}
public static CAA2DCoordinate 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 = CAACoordinateTransformation.HoursToRadians(Alpha);
Delta = CAACoordinateTransformation.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;
CAA2DCoordinate @value = new CAA2DCoordinate();
@value.X = CAACoordinateTransformation.RadiansToHours(Math.Atan2(y, x));
if (@value.X < 0)
{
@value.X += 24;
}
@value.Y = CAACoordinateTransformation.RadiansToDegrees(Math.Atan2(z, Math.Sqrt(x * x + y * y)));
return(@value);
}
public static CAA2DCoordinate 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 = CAACoordinateTransformation.DegreesToRadians(Lambda);
Beta = CAACoordinateTransformation.DegreesToRadians(Beta);
double eta = (47.0029 - 0.06603 * T + 0.000598 * Tsquared) * t + (-0.03302 + 0.000598 * T) * tsquared + 0.00006 * tcubed;
eta = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.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 = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.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 = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.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);
CAA2DCoordinate @value = new CAA2DCoordinate();
@value.X = CAACoordinateTransformation.RadiansToDegrees(p + pi - Math.Atan2(A, B));
if (@value.X < 0)
{
@value.X += 360;
}
@value.Y = CAACoordinateTransformation.RadiansToDegrees(Math.Asin(C));
return(@value);
}
//Static methods
public static CAA2DCoordinate 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 = CAACoordinateTransformation.HoursToRadians(Alpha);
Delta = CAACoordinateTransformation.DegreesToRadians(Delta);
double sigma = (2306.2181 + 1.39656 * T - 0.000139 * Tsquared) * t + (0.30188 - 0.0000344 * T) * tsquared + 0.017988 * tcubed;
sigma = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.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 = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.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 = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.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);
CAA2DCoordinate @value = new CAA2DCoordinate();
@value.X = CAACoordinateTransformation.RadiansToHours(Math.Atan2(A, B) + zeta);
if (@value.X < 0)
{
@value.X += 24;
}
@value.Y = CAACoordinateTransformation.RadiansToDegrees(Math.Asin(C));
return(@value);
}
public static CAA2DCoordinate 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 = CAACoordinateTransformation.HoursToRadians(Alpha);
Delta = CAACoordinateTransformation.DegreesToRadians(Delta);
double sigma = (2304.250 + 1.396 * T) * t + 0.302 * tsquared + 0.018 * tcubed;
sigma = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.DMSToDegrees(0, 0, sigma));
double zeta = 0.791 * tsquared + 0.001 * tcubed;
zeta = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.DMSToDegrees(0, 0, zeta));
zeta += sigma;
double phi = (2004.682 - 0.853 * T) * t - 0.426 * tsquared - 0.042 * tcubed;
phi = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.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);
CAA2DCoordinate @value = new CAA2DCoordinate();
@value.X = CAACoordinateTransformation.RadiansToHours(Math.Atan2(A, B) + zeta);
if (@value.X < 0)
{
@value.X += 24;
}
@value.Y = CAACoordinateTransformation.RadiansToDegrees(Math.Asin(C));
return(@value);
}
public static CAA2DCoordinate EclipticAberration(double Lambda, double Beta, double JD)
{
//What is the return value
CAA2DCoordinate aberration = new CAA2DCoordinate();
double T = (JD - 2451545) / 36525;
double Tsquared = T * T;
double e = 0.016708634 - 0.000042037 * T - 0.0000001267 * Tsquared;
double pi = 102.93735 + 1.71946 * T + 0.00046 * Tsquared;
double k = 20.49552;
double SunLongitude = CAASun.GeometricEclipticLongitude(JD);
//Convert to radians
pi = CAACoordinateTransformation.DegreesToRadians(pi);
Lambda = CAACoordinateTransformation.DegreesToRadians(Lambda);
Beta = CAACoordinateTransformation.DegreesToRadians(Beta);
SunLongitude = CAACoordinateTransformation.DegreesToRadians(SunLongitude);
aberration.X = (-k * Math.Cos(SunLongitude - Lambda) + e * k * Math.Cos(pi - Lambda)) / Math.Cos(Beta) / 3600;
aberration.Y = -k *Math.Sin(Beta) * (Math.Sin(SunLongitude - Lambda) - e * Math.Sin(pi - Lambda)) / 3600;
return(aberration);
}
public static CAAPhysicalMoonDetails CalculateTopocentric(double JD, double Longitude, double Latitude)
{
//First convert to radians
Longitude = CAACoordinateTransformation.DegreesToRadians(Longitude);
Latitude = CAACoordinateTransformation.DegreesToRadians(Latitude);
double Lambda = 0;
double Beta = 0;
double epsilon = 0;
CAA2DCoordinate Equatorial = new CAA2DCoordinate();
CAAPhysicalMoonDetails details = CalculateHelper(JD, ref Lambda, ref Beta, ref epsilon, ref Equatorial);
double R = CAAMoon.RadiusVector(JD);
double pi = CAAMoon.RadiusVectorToHorizontalParallax(R);
double Alpha = CAACoordinateTransformation.HoursToRadians(Equatorial.X);
double Delta = CAACoordinateTransformation.DegreesToRadians(Equatorial.Y);
double AST = CAASidereal.ApparentGreenwichSiderealTime(JD);
double H = CAACoordinateTransformation.HoursToRadians(AST) - Longitude - Alpha;
double Q = Math.Atan2(Math.Cos(Latitude) * Math.Sin(H), Math.Cos(Delta) * Math.Sin(Latitude) - Math.Sin(Delta) * Math.Cos(Latitude) * Math.Cos(H));
double Z = Math.Acos(Math.Sin(Delta) * Math.Sin(Latitude) + Math.Cos(Delta) * Math.Cos(Latitude) * Math.Cos(H));
double pidash = pi * (Math.Sin(Z) + 0.0084 * Math.Sin(2 * Z));
double Prad = CAACoordinateTransformation.DegreesToRadians(details.P);
double DeltaL = -pidash *Math.Sin(Q - Prad) / Math.Cos(CAACoordinateTransformation.DegreesToRadians(details.b));
details.l += DeltaL;
double DeltaB = pidash * Math.Cos(Q - Prad);
details.b += DeltaB;
details.P += DeltaL * Math.Sin(CAACoordinateTransformation.DegreesToRadians(details.b)) - pidash * Math.Sin(Q) * Math.Tan(Delta);
return(details);
}
public static CAA2DCoordinate 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 = CAACoordinateTransformation.HoursToRadians(Alpha);
Delta = CAACoordinateTransformation.DegreesToRadians(Delta);
var x = r * Math.Cos(Delta) * Math.Cos(Alpha);
var y = r * Math.Cos(Delta) * Math.Sin(Alpha);
var z = r * Math.Sin(Delta);
var DeltaX = x/r *DeltaR - z *PMDelta *Math.Cos(Alpha) - y *PMAlpha;
var DeltaY = y/r *DeltaR - z *PMDelta *Math.Sin(Alpha) + x *PMAlpha;
var DeltaZ = z/r *DeltaR + r *PMDelta *Math.Cos(Delta);
x += t *DeltaX;
y += t *DeltaY;
z += t *DeltaZ;
var @value = new CAA2DCoordinate();
@value.X = CAACoordinateTransformation.RadiansToHours(Math.Atan2(y, x));
if (@value.X < 0)
@value.X += 24;
@value.Y = CAACoordinateTransformation.RadiansToDegrees(Math.Atan2(z, Math.Sqrt(x *x + y *y)));
return @value;
}
public static CAA2DCoordinate PrecessEcliptic(double Lambda, double Beta, double JD0, double JD)
{
var T = (JD0 - 2451545.0) / 36525;
var Tsquared = T *T;
var t = (JD - JD0) / 36525;
var tsquared = t *t;
var tcubed = tsquared * t;
//Now convert to radians
Lambda = CAACoordinateTransformation.DegreesToRadians(Lambda);
Beta = CAACoordinateTransformation.DegreesToRadians(Beta);
var eta = (47.0029 - 0.06603 *T + 0.000598 *Tsquared)*t + (-0.03302 + 0.000598 *T)*tsquared + 0.00006 *tcubed;
eta = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.DMSToDegrees(0, 0, eta));
var pi = 174.876384 *3600 + 3289.4789 *T + 0.60622 *Tsquared - (869.8089 + 0.50491 *T)*t + 0.03536 *tsquared;
pi = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.DMSToDegrees(0, 0, pi));
var p = (5029.0966 + 2.22226 *T - 0.000042 *Tsquared)*t + (1.11113 - 0.000042 *T)*tsquared - 0.000006 *tcubed;
p = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.DMSToDegrees(0, 0, p));
var A = Math.Cos(eta)*Math.Cos(Beta)*Math.Sin(pi - Lambda) - Math.Sin(eta)*Math.Sin(Beta);
var B = Math.Cos(Beta)*Math.Cos(pi - Lambda);
var C = Math.Cos(eta)*Math.Sin(Beta) + Math.Sin(eta)*Math.Cos(Beta)*Math.Sin(pi - Lambda);
var @value = new CAA2DCoordinate();
@value.X = CAACoordinateTransformation.RadiansToDegrees(p + pi - Math.Atan2(A, B));
if (@value.X < 0)
@value.X += 360;
@value.Y = CAACoordinateTransformation.RadiansToDegrees(Math.Asin(C));
return @value;
}
public static CAA2DCoordinate EquatorialPMToEcliptic(double Alpha, double Delta, double Beta, double PMAlpha, double PMDelta, double Epsilon)
{
//Convert to radians
Epsilon = CAACoordinateTransformation.DegreesToRadians(Epsilon);
Alpha = CAACoordinateTransformation.HoursToRadians(Alpha);
Delta = CAACoordinateTransformation.DegreesToRadians(Delta);
Beta = CAACoordinateTransformation.DegreesToRadians(Beta);
var cosb = Math.Cos(Beta);
var sinEpsilon = Math.Sin(Epsilon);
var @value = new CAA2DCoordinate();
@value.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);
@value.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;
}
//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 = CAACoordinateTransformation.DegreesToRadians(Lambda0);
double Beta0 = 63.2818 - 0.00394 * T;
double Beta0rad = CAACoordinateTransformation.DegreesToRadians(Beta0);
//Step 2
double l0 = CAAEarth.EclipticLongitude(JD);
double l0rad = CAACoordinateTransformation.DegreesToRadians(l0);
double b0 = CAAEarth.EclipticLatitude(JD);
double b0rad = CAACoordinateTransformation.DegreesToRadians(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 = CAACoordinateTransformation.DegreesToRadians(l);
b = CAAMars.EclipticLatitude(JD2);
brad = CAACoordinateTransformation.DegreesToRadians(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 = CAAElliptical.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 = CAACoordinateTransformation.RadiansToDegrees(lambdarad);
double betarad = Math.Atan2(z, Math.Sqrt(x * x + y * y));
double beta = CAACoordinateTransformation.RadiansToDegrees(betarad);
//Step 6
details.DE = CAACoordinateTransformation.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 = CAACoordinateTransformation.DegreesToRadians(N);
double ldash = l - 0.00697 / r;
double ldashrad = CAACoordinateTransformation.DegreesToRadians(ldash);
double bdash = b - 0.000225 * (Math.Cos(lrad - Nrad) / r);
double bdashrad = CAACoordinateTransformation.DegreesToRadians(bdash);
//Step 8
details.DS = CAACoordinateTransformation.RadiansToDegrees(Math.Asin(-Math.Sin(Beta0rad) * Math.Sin(bdashrad) - Math.Cos(Beta0rad) * Math.Cos(bdashrad) * Math.Cos(Lambda0rad - ldashrad)));
//Step 9
double W = CAACoordinateTransformation.MapTo0To360Range(11.504 + 350.89200025 * (JD - LightTravelTime - 2433282.5));
//Step 10
double e0 = CAANutation.MeanObliquityOfEcliptic(JD);
double e0rad = CAACoordinateTransformation.DegreesToRadians(e0);
CAA2DCoordinate PoleEquatorial = CAACoordinateTransformation.Ecliptic2Equatorial(Lambda0, Beta0, e0);
double alpha0rad = CAACoordinateTransformation.HoursToRadians(PoleEquatorial.X);
double delta0rad = CAACoordinateTransformation.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 = CAACoordinateTransformation.RadiansToHours(alpharad);
double deltarad = Math.Atan2(v, Math.Sqrt(x * x + u * u));
double delta = CAACoordinateTransformation.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 = CAACoordinateTransformation.MapTo0To360Range(W - CAACoordinateTransformation.RadiansToDegrees(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 = CAACoordinateTransformation.DegreesToRadians(Lambda0);
lambda += NutationInLongitude / 3600;
lambdarad = CAACoordinateTransformation.DegreesToRadians(lambda);
e0 += NutationInObliquity / 3600;
e0rad = CAACoordinateTransformation.DegreesToRadians(e0rad);
//Step 16
CAA2DCoordinate ApparentPoleEquatorial = CAACoordinateTransformation.Ecliptic2Equatorial(Lambda0, Beta0, e0);
double alpha0dash = CAACoordinateTransformation.HoursToRadians(ApparentPoleEquatorial.X);
double delta0dash = CAACoordinateTransformation.DegreesToRadians(ApparentPoleEquatorial.Y);
CAA2DCoordinate ApparentMars = CAACoordinateTransformation.Ecliptic2Equatorial(lambda, beta, e0);
double alphadash = CAACoordinateTransformation.HoursToRadians(ApparentMars.X);
double deltadash = CAACoordinateTransformation.DegreesToRadians(ApparentMars.Y);
//Step 17
details.P = CAACoordinateTransformation.MapTo0To360Range(CAACoordinateTransformation.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 = CAASun.GeometricEclipticLongitude(JD);
double SunBeta = CAASun.GeometricEclipticLatitude(JD);
CAA2DCoordinate SunEquatorial = CAACoordinateTransformation.Ecliptic2Equatorial(SunLambda, SunBeta, e0);
details.X = CAAMoonIlluminatedFraction.PositionAngle(SunEquatorial.X, SunEquatorial.Y, alpha, delta);
//Step 19
details.d = 9.36 / DELTA;
details.k = CAAIlluminatedFraction.IlluminatedFraction(r, R, DELTA);
details.q = (1 - details.k) * details.d;
return(details);
}
//Static methods
///////////////////////////// Implementation //////////////////////////////////
public static CAARiseTransitSetDetails Rise(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
CAARiseTransitSetDetails details = new CAARiseTransitSetDetails();
details.bValid = false;
//Calculate the sidereal time
double theta0 = CAASidereal.ApparentGreenwichSiderealTime(JD);
theta0 *= 15; //Express it as degrees
//Calculate deltat
double deltaT = CAADynamicalTime.DeltaT(JD);
//Convert values to radians
double Delta2Rad = CAACoordinateTransformation.DegreesToRadians(Delta2);
double LatitudeRad = CAACoordinateTransformation.DegreesToRadians(Latitude);
//Convert the standard latitude to radians
double h0Rad = CAACoordinateTransformation.DegreesToRadians(h0);
double cosH0 = (Math.Sin(h0Rad) - Math.Sin(LatitudeRad) * Math.Sin(Delta2Rad)) / (Math.Cos(LatitudeRad) * Math.Cos(Delta2Rad));
//Check that the object actually rises
if ((cosH0 > 1) || (cosH0 < -1))
{
return(details);
}
double H0 = Math.Acos(cosH0);
H0 = CAACoordinateTransformation.RadiansToDegrees(H0);
double M0 = (Alpha2 * 15 + Longitude - theta0) / 360;
double M1 = M0 - H0 / 360;
double M2 = M0 + H0 / 360;
if (M0 > 1)
{
M0 -= 1;
}
else if (M0 < 0)
{
M0 += 1;
}
if (M1 > 1)
{
M1 -= 1;
}
else if (M1 < 0)
{
M1 += 1;
}
if (M2 > 1)
{
M2 -= 1;
}
else if (M2 < 0)
{
M2 += 1;
}
for (int i = 0; i < 2; i++)
{
//Calculate the details of rising
double theta1 = theta0 + 360.985647 * M1;
theta1 = CAACoordinateTransformation.MapTo0To360Range(theta1);
double n = M1 + deltaT / 86400;
double Alpha = CAAInterpolate.Interpolate(n, Alpha1, Alpha2, Alpha3);
double Delta = CAAInterpolate.Interpolate(n, Delta1, Delta2, Delta3);
double H = theta1 - Longitude - Alpha * 15;
CAA2DCoordinate Horizontal = CAACoordinateTransformation.Equatorial2Horizontal(H / 15, Delta, Latitude);
double DeltaM = (Horizontal.Y - h0) / (360 * Math.Cos(CAACoordinateTransformation.DegreesToRadians(Delta)) * Math.Cos(LatitudeRad) * Math.Sin(CAACoordinateTransformation.DegreesToRadians(H)));
M1 += DeltaM;
//Calculate the details of transit
theta1 = theta0 + 360.985647 * M0;
theta1 = CAACoordinateTransformation.MapTo0To360Range(theta1);
n = M0 + deltaT / 86400;
Alpha = CAAInterpolate.Interpolate(n, Alpha1, Alpha2, Alpha3);
H = theta1 - Longitude - Alpha * 15;
if (H < -180)
{
H += 360;
}
DeltaM = -H / 360;
M0 += DeltaM;
//Calculate the details of setting
theta1 = theta0 + 360.985647 * M2;
theta1 = CAACoordinateTransformation.MapTo0To360Range(theta1);
n = M2 + deltaT / 86400;
Alpha = CAAInterpolate.Interpolate(n, Alpha1, Alpha2, Alpha3);
Delta = CAAInterpolate.Interpolate(n, Delta1, Delta2, Delta3);
H = theta1 - Longitude - Alpha * 15;
Horizontal = CAACoordinateTransformation.Equatorial2Horizontal(H / 15, Delta, Latitude);
DeltaM = (Horizontal.Y - h0) / (360 * Math.Cos(CAACoordinateTransformation.DegreesToRadians(Delta)) * Math.Cos(LatitudeRad) * Math.Sin(CAACoordinateTransformation.DegreesToRadians(H)));
M2 += DeltaM;
}
//Finally before we exit, convert to hours
details.bValid = true;
details.Rise = M1 * 24;
details.Set = M2 * 24;
details.Transit = M0 * 24;
return(details);
}
public static CAA2DCoordinate Equatorial2Galactic(double Alpha, double Delta)
{
Alpha = 192.25 - HoursToDegrees(Alpha);
Alpha = DegreesToRadians(Alpha);
Delta = DegreesToRadians(Delta);
CAA2DCoordinate Galactic = new CAA2DCoordinate();
Galactic.X = RadiansToDegrees(Math.Atan2(Math.Sin(Alpha), Math.Cos(Alpha)*Math.Sin(DegreesToRadians(27.4)) - Math.Tan(Delta)*Math.Cos(DegreesToRadians(27.4))));
Galactic.X = 303 - Galactic.X;
if (Galactic.X >= 360)
Galactic.X -= 360;
Galactic.Y = RadiansToDegrees(Math.Asin(Math.Sin(Delta)*Math.Sin(DegreesToRadians(27.4)) + Math.Cos(Delta)*Math.Cos(DegreesToRadians(27.4))*Math.Cos(Alpha)));
return Galactic;
}
public static CAA2DCoordinate Ecliptic2Equatorial(double Lambda, double Beta, double Epsilon)
{
Lambda = DegreesToRadians(Lambda);
Beta = DegreesToRadians(Beta);
Epsilon = DegreesToRadians(Epsilon);
CAA2DCoordinate Equatorial = new CAA2DCoordinate();
Equatorial.X = RadiansToHours(Math.Atan2(Math.Sin(Lambda)*Math.Cos(Epsilon) - Math.Tan(Beta)*Math.Sin(Epsilon), Math.Cos(Lambda)));
if (Equatorial.X < 0)
Equatorial.X += 24;
Equatorial.Y = RadiansToDegrees(Math.Asin(Math.Sin(Beta)*Math.Cos(Epsilon) + Math.Cos(Beta)*Math.Sin(Epsilon)*Math.Sin(Lambda)));
return Equatorial;
}
//Conversion functions
public static CAA2DCoordinate Equatorial2TopocentricDelta(double Alpha, double Delta, double Distance, double Longitude, double Latitude, double Height, double JD)
{
var RhoSinThetaPrime = CAAGlobe.RhoSinThetaPrime(Latitude, Height);
var RhoCosThetaPrime = CAAGlobe.RhoCosThetaPrime(Latitude, Height);
//Calculate the Sidereal time
var theta = CAASidereal.ApparentGreenwichSiderealTime(JD);
//Convert to radians
Delta = CAACoordinateTransformation.DegreesToRadians(Delta);
var cosDelta = Math.Cos(Delta);
//Calculate the Parallax
var pi = Math.Asin(GlobalMembersStdafx.g_AAParallax_C1 / Distance);
//Calculate the hour angle
var H = CAACoordinateTransformation.HoursToRadians(theta - Longitude/15 - Alpha);
var cosH = Math.Cos(H);
var sinH = Math.Sin(H);
var DeltaTopocentric = new CAA2DCoordinate
{
X = CAACoordinateTransformation.RadiansToHours(-pi*RhoCosThetaPrime*sinH/cosDelta),
Y = CAACoordinateTransformation.RadiansToDegrees(-pi*(RhoSinThetaPrime*cosDelta - RhoCosThetaPrime*cosH*Math.Sin(Delta)))
};
return DeltaTopocentric;
}
public static CAA2DCoordinate Galactic2Equatorial(double l, double b)
{
l -= 123;
l = DegreesToRadians(l);
b = DegreesToRadians(b);
CAA2DCoordinate Equatorial = new CAA2DCoordinate();
Equatorial.X = RadiansToDegrees(Math.Atan2(Math.Sin(l), Math.Cos(l)*Math.Sin(DegreesToRadians(27.4)) - Math.Tan(b)*Math.Cos(DegreesToRadians(27.4))));
Equatorial.X += 12.25;
if (Equatorial.X < 0)
Equatorial.X += 360;
Equatorial.X = DegreesToHours(Equatorial.X);
Equatorial.Y = RadiansToDegrees(Math.Asin(Math.Sin(b)*Math.Sin(DegreesToRadians(27.4)) + Math.Cos(b)*Math.Cos(DegreesToRadians(27.4))*Math.Cos(l)));
return Equatorial;
}
protected static CAAPhysicalMoonDetails CalculateHelper(double JD, ref double Lambda, ref double Beta, ref double epsilon, ref CAA2DCoordinate Equatorial)
{
//What will be the return value
CAAPhysicalMoonDetails details = new CAAPhysicalMoonDetails();
//Calculate the initial quantities
Lambda = CAAMoon.EclipticLongitude(JD);
Beta = CAAMoon.EclipticLatitude(JD);
//Calculate the optical libration
double omega=0;
double DeltaU=0;
double sigma=0;
double I=0;
double rho=0;
CalculateOpticalLibration(JD, Lambda, Beta, ref details.ldash, ref details.bdash, ref details.ldash2, ref details.bdash2, ref epsilon, ref omega, ref DeltaU, ref sigma, ref I, ref rho);
double epsilonrad = CAACoordinateTransformation.DegreesToRadians(epsilon);
//Calculate the total libration
details.l = details.ldash + details.ldash2;
details.b = details.bdash + details.bdash2;
double b = CAACoordinateTransformation.DegreesToRadians(details.b);
//Calculate the position angle
double V = omega + DeltaU + CAACoordinateTransformation.DegreesToRadians(sigma)/Math.Sin(I);
double I_rho = I + CAACoordinateTransformation.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 = CAACoordinateTransformation.Ecliptic2Equatorial(Lambda, Beta, epsilon);
double Alpha = CAACoordinateTransformation.HoursToRadians(Equatorial.X);
details.P = CAACoordinateTransformation.RadiansToDegrees(Math.Asin(Math.Sqrt(X *X + Y *Y)*Math.Cos(Alpha - w)/(Math.Cos(b))));
return details;
}
protected static CAASaturnMoonsDetails CalculateHelper(double JD, double sunlongrad, double betarad, double R)
{
//What will be the return value
CAASaturnMoonsDetails details = new CAASaturnMoonsDetails();
//Calculate the position of Saturn decreased by the light travel time from Saturn to the specified position
double DELTA = 9;
double PreviousLightTravelTime = 0;
double LightTravelTime = CAAElliptical.DistanceToLightTime(DELTA);
double x = 0;
double y = 0;
double z = 0;
double l = 0;
double lrad = 0;
double b = 0;
double brad = 0;
double r = 0;
double JD1 = JD - LightTravelTime;
bool bIterate = true;
while (bIterate)
{
//Calculate the position of Saturn
l = CAASaturn.EclipticLongitude(JD1);
lrad = CAACoordinateTransformation.DegreesToRadians(l);
b = CAASaturn.EclipticLatitude(JD1);
brad = CAACoordinateTransformation.DegreesToRadians(b);
r = CAASaturn.RadiusVector(JD1);
x = r * Math.Cos(brad) * Math.Cos(lrad) + R * Math.Cos(sunlongrad);
y = r * Math.Cos(brad) * Math.Sin(lrad) + R * Math.Sin(sunlongrad);
z = r * Math.Sin(brad) + R * Math.Sin(betarad);
DELTA = Math.Sqrt(x * x + y * y + z * z);
LightTravelTime = CAAElliptical.DistanceToLightTime(DELTA);
//Prepare for the next loop around
bIterate = (Math.Abs(LightTravelTime - PreviousLightTravelTime) > 2E-6); //2E-6 corresponds to 0.17 of a second
if (bIterate)
{
JD1 = JD - LightTravelTime;
PreviousLightTravelTime = LightTravelTime;
}
}
//Calculate Saturn's Longitude and Latitude
double lambda0 = Math.Atan2(y, x);
lambda0 = CAACoordinateTransformation.RadiansToDegrees(lambda0);
double beta0 = Math.Atan(z / Math.Sqrt(x * x + y * y));
beta0 = CAACoordinateTransformation.RadiansToDegrees(beta0);
//Precess the longtitude and Latitutude to B1950.0
CAA2DCoordinate Saturn1950 = CAAPrecession.PrecessEcliptic(lambda0, beta0, JD, 2433282.4235);
lambda0 = Saturn1950.X;
double lambda0rad = CAACoordinateTransformation.DegreesToRadians(lambda0);
beta0 = Saturn1950.Y;
double beta0rad = CAACoordinateTransformation.DegreesToRadians(beta0);
double JDE = JD - LightTravelTime;
double t1 = JDE - 2411093.0;
double t2 = t1 / 365.25;
double t3 = ((JDE - 2433282.423) / 365.25) + 1950.0;
double t4 = JDE - 2411368.0;
double t5 = t4 / 365.25;
double t6 = JDE - 2415020.0;
double t7 = t6 / 36525.0;
double t8 = t6 / 365.25;
double t9 = (JDE - 2442000.5) / 365.25;
double t10 = JDE - 2409786.0;
double t11 = t10 / 36525.0;
double t112 = t11 * t11;
double t113 = t112 * t11;
double W0 = CAACoordinateTransformation.MapTo0To360Range(5.095 * (t3 - 1866.39));
double W0rad = CAACoordinateTransformation.DegreesToRadians(W0);
double W1 = CAACoordinateTransformation.MapTo0To360Range(74.4 + 32.39 * t2);
double W1rad = CAACoordinateTransformation.DegreesToRadians(W1);
double W2 = CAACoordinateTransformation.MapTo0To360Range(134.3 + 92.62 * t2);
double W2rad = CAACoordinateTransformation.DegreesToRadians(W2);
double W3 = CAACoordinateTransformation.MapTo0To360Range(42.0 - 0.5118 * t5);
double W3rad = CAACoordinateTransformation.DegreesToRadians(W3);
double W4 = CAACoordinateTransformation.MapTo0To360Range(276.59 + 0.5118 * t5);
double W4rad = CAACoordinateTransformation.DegreesToRadians(W4);
double W5 = CAACoordinateTransformation.MapTo0To360Range(267.2635 + 1222.1136 * t7);
double W5rad = CAACoordinateTransformation.DegreesToRadians(W5);
double W6 = CAACoordinateTransformation.MapTo0To360Range(175.4762 + 1221.5515 * t7);
double W6rad = CAACoordinateTransformation.DegreesToRadians(W6);
double W7 = CAACoordinateTransformation.MapTo0To360Range(2.4891 + 0.002435 * t7);
double W7rad = CAACoordinateTransformation.DegreesToRadians(W7);
double W8 = CAACoordinateTransformation.MapTo0To360Range(113.35 - 0.2597 * t7);
double W8rad = CAACoordinateTransformation.DegreesToRadians(W8);
double s1 = Math.Sin(CAACoordinateTransformation.DegreesToRadians(28.0817));
double s2 = Math.Sin(CAACoordinateTransformation.DegreesToRadians(168.8112));
double c1 = Math.Cos(CAACoordinateTransformation.DegreesToRadians(28.0817));
double c2 = Math.Cos(CAACoordinateTransformation.DegreesToRadians(168.8112));
double e1 = 0.05589 - 0.000346 * t7;
//Satellite 1
double L = CAACoordinateTransformation.MapTo0To360Range(127.64 + 381.994497 * t1 - 43.57 * Math.Sin(W0rad) - 0.720 * Math.Sin(3 * W0rad) - 0.02144 * Math.Sin(5 * W0rad));
double p = 106.1 + 365.549 * t2;
double M = L - p;
double Mrad = CAACoordinateTransformation.DegreesToRadians(M);
double C = 2.18287 * Math.Sin(Mrad) + 0.025988 * Math.Sin(2 * Mrad) + 0.00043 * Math.Sin(3 * Mrad);
double Crad = CAACoordinateTransformation.DegreesToRadians(C);
double lambda1 = CAACoordinateTransformation.MapTo0To360Range(L + C);
double r1 = 3.06879 / (1 + 0.01905 * Math.Cos(Mrad + Crad));
double gamma1 = 1.563;
double omega1 = CAACoordinateTransformation.MapTo0To360Range(54.5 - 365.072 * t2);
//Satellite 2
L = CAACoordinateTransformation.MapTo0To360Range(200.317 + 262.7319002 * t1 + 0.25667 * Math.Sin(W1rad) + 0.20883 * Math.Sin(W2rad));
p = 309.107 + 123.44121 * t2;
M = L - p;
Mrad = CAACoordinateTransformation.DegreesToRadians(M);
C = 0.55577 * Math.Sin(Mrad) + 0.00168 * Math.Sin(2 * Mrad);
Crad = CAACoordinateTransformation.DegreesToRadians(C);
double lambda2 = CAACoordinateTransformation.MapTo0To360Range(L + C);
double r2 = 3.94118 / (1 + 0.00485 * Math.Cos(Mrad + Crad));
double gamma2 = 0.0262;
double omega2 = CAACoordinateTransformation.MapTo0To360Range(348 - 151.95 * t2);
//Satellite 3
double lambda3 = CAACoordinateTransformation.MapTo0To360Range(285.306 + 190.69791226 * t1 + 2.063 * Math.Sin(W0rad) + 0.03409 * Math.Sin(3 * W0rad) + 0.001015 * Math.Sin(5 * W0rad));
double r3 = 4.880998;
double gamma3 = 1.0976;
double omega3 = CAACoordinateTransformation.MapTo0To360Range(111.33 - 72.2441 * t2);
//Satellite 4
L = CAACoordinateTransformation.MapTo0To360Range(254.712 + 131.53493193 * t1 - 0.0215 * Math.Sin(W1rad) - 0.01733 * Math.Sin(W2rad));
p = 174.8 + 30.820 * t2;
M = L - p;
Mrad = CAACoordinateTransformation.DegreesToRadians(M);
C = 0.24717 * Math.Sin(Mrad) + 0.00033 * Math.Sin(2 * Mrad);
Crad = CAACoordinateTransformation.DegreesToRadians(C);
double lambda4 = CAACoordinateTransformation.MapTo0To360Range(L + C);
double r4 = 6.24871 / (1 + 0.002157 * Math.Cos(Mrad + Crad));
double gamma4 = 0.0139;
double omega4 = CAACoordinateTransformation.MapTo0To360Range(232 - 30.27 * t2);
//Satellite 5
double pdash = 342.7 + 10.057 * t2;
double pdashrad = CAACoordinateTransformation.DegreesToRadians(pdash);
double a1 = 0.000265 * Math.Sin(pdashrad) + 0.001 * Math.Sin(W4rad); //Note the book uses the incorrect constant 0.01*sin(W4rad);
double a2 = 0.000265 * Math.Cos(pdashrad) + 0.001 * Math.Cos(W4rad); //Note the book uses the incorrect constant 0.01*cos(W4rad);
double e = Math.Sqrt(a1 * a1 + a2 * a2);
p = CAACoordinateTransformation.RadiansToDegrees(Math.Atan2(a1, a2));
double N = 345 - 10.057 * t2;
double Nrad = CAACoordinateTransformation.DegreesToRadians(N);
double lambdadash = CAACoordinateTransformation.MapTo0To360Range(359.244 + 79.69004720 * t1 + 0.086754 * Math.Sin(Nrad));
double i = 28.0362 + 0.346898 * Math.Cos(Nrad) + 0.01930 * Math.Cos(W3rad);
double omega = 168.8034 + 0.736936 * Math.Sin(Nrad) + 0.041 * Math.Sin(W3rad);
double a = 8.725924;
double lambda5 = 0;
double gamma5 = 0;
double omega5 = 0;
double r5 = 0;
HelperSubroutine(e, lambdadash, p, a, omega, i, c1, s1, ref r5, ref lambda5, ref gamma5, ref omega5);
//Satellite 6
L = 261.1582 + 22.57697855 * t4 + 0.074025 * Math.Sin(W3rad);
double idash = 27.45141 + 0.295999 * Math.Cos(W3rad);
double idashrad = CAACoordinateTransformation.DegreesToRadians(idash);
double omegadash = 168.66925 + 0.628808 * Math.Sin(W3rad);
double omegadashrad = CAACoordinateTransformation.DegreesToRadians(omegadash);
a1 = Math.Sin(W7rad) * Math.Sin(omegadashrad - W8rad);
a2 = Math.Cos(W7rad) * Math.Sin(idashrad) - Math.Sin(W7rad) * Math.Cos(idashrad) * Math.Cos(omegadashrad - W8rad);
double g0 = CAACoordinateTransformation.DegreesToRadians(102.8623);
double psi = Math.Atan2(a1, a2);
if (a2 < 0)
{
psi += CAACoordinateTransformation.PI();
}
double psideg = CAACoordinateTransformation.RadiansToDegrees(psi);
double s = Math.Sqrt(a1 * a1 + a2 * a2);
double g = W4 - omegadash - psideg;
double w_ = 0;
for (int j = 0; j < 3; j++)
{
w_ = W4 + 0.37515 * (Math.Sin(2 * CAACoordinateTransformation.DegreesToRadians(g)) - Math.Sin(2 * g0));
g = w_ - omegadash - psideg;
}
double grad = CAACoordinateTransformation.DegreesToRadians(g);
double edash = 0.029092 + 0.00019048 * (Math.Cos(2 * grad) - Math.Cos(2 * g0));
double q = CAACoordinateTransformation.DegreesToRadians(2 * (W5 - w_));
double b1 = Math.Sin(idashrad) * Math.Sin(omegadashrad - W8rad);
double b2 = Math.Cos(W7rad) * Math.Sin(idashrad) * Math.Cos(omegadashrad - W8rad) - Math.Sin(W7rad) * Math.Cos(idashrad);
double atanb1b2 = Math.Atan2(b1, b2);
double theta = atanb1b2 + W8rad;
e = edash + 0.002778797 * edash * Math.Cos(q);
p = w_ + 0.159215 * Math.Sin(q);
double u = 2 * W5rad - 2 * theta + psi;
double h = 0.9375 * edash * edash * Math.Sin(q) + 0.1875 * s * s * Math.Sin(2 * (W5rad - theta));
lambdadash = CAACoordinateTransformation.MapTo0To360Range(L - 0.254744 * (e1 * Math.Sin(W6rad) + 0.75 * e1 * e1 * Math.Sin(2 * W6rad) + h));
i = idash + 0.031843 * s * Math.Cos(u);
omega = omegadash + (0.031843 * s * Math.Sin(u)) / Math.Sin(idashrad);
a = 20.216193;
double lambda6 = 0;
double gamma6 = 0;
double omega6 = 0;
double r6 = 0;
HelperSubroutine(e, lambdadash, p, a, omega, i, c1, s1, ref r6, ref lambda6, ref gamma6, ref omega6);
//Satellite 7
double eta = 92.39 + 0.5621071 * t6;
double etarad = CAACoordinateTransformation.DegreesToRadians(eta);
double zeta = 148.19 - 19.18 * t8;
double zetarad = CAACoordinateTransformation.DegreesToRadians(zeta);
theta = CAACoordinateTransformation.DegreesToRadians(184.8 - 35.41 * t9);
double thetadash = theta - CAACoordinateTransformation.DegreesToRadians(7.5);
double @as = CAACoordinateTransformation.DegreesToRadians(176 + 12.22 * t8);
double bs = CAACoordinateTransformation.DegreesToRadians(8 + 24.44 * t8);
double cs = bs + CAACoordinateTransformation.DegreesToRadians(5);
w_ = 69.898 - 18.67088 * t8;
double phi = 2 * (w_ - W5);
double phirad = CAACoordinateTransformation.DegreesToRadians(phi);
double chi = 94.9 - 2.292 * t8;
double chirad = CAACoordinateTransformation.DegreesToRadians(chi);
a = 24.50601 - 0.08686 * Math.Cos(etarad) - 0.00166 * Math.Cos(zetarad + etarad) + 0.00175 * Math.Cos(zetarad - etarad);
e = 0.103458 - 0.004099 * Math.Cos(etarad) - 0.000167 * Math.Cos(zetarad + etarad) + 0.000235 * Math.Cos(zetarad - etarad) + 0.02303 * Math.Cos(zetarad) - 0.00212 * Math.Cos(2 * zetarad) + 0.000151 * Math.Cos(3 * zetarad) + 0.00013 * Math.Cos(phirad);
p = w_ + 0.15648 * Math.Sin(chirad) - 0.4457 * Math.Sin(etarad) - 0.2657 * Math.Sin(zetarad + etarad) + -0.3573 * Math.Sin(zetarad - etarad) - 12.872 * Math.Sin(zetarad) + 1.668 * Math.Sin(2 * zetarad) + -0.2419 * Math.Sin(3 * zetarad) - 0.07 * Math.Sin(phirad);
lambdadash = CAACoordinateTransformation.MapTo0To360Range(177.047 + 16.91993829 * t6 + 0.15648 * Math.Sin(chirad) + 9.142 * Math.Sin(etarad) + 0.007 * Math.Sin(2 * etarad) - 0.014 * Math.Sin(3 * etarad) + 0.2275 * Math.Sin(zetarad + etarad) + 0.2112 * Math.Sin(zetarad - etarad) - 0.26 * Math.Sin(zetarad) - 0.0098 * Math.Sin(2 * zetarad) + -0.013 * Math.Sin(@as) + 0.017 * Math.Sin(bs) - 0.0303 * Math.Sin(phirad));
i = 27.3347 + 0.643486 * Math.Cos(chirad) + 0.315 * Math.Cos(W3rad) + 0.018 * Math.Cos(theta) - 0.018 * Math.Cos(cs);
omega = 168.6812 + 1.40136 * Math.Cos(chirad) + 0.68599 * Math.Sin(W3rad) - 0.0392 * Math.Sin(cs) + 0.0366 * Math.Sin(thetadash);
double lambda7 = 0;
double gamma7 = 0;
double omega7 = 0;
double r7 = 0;
HelperSubroutine(e, lambdadash, p, a, omega, i, c1, s1, ref r7, ref lambda7, ref gamma7, ref omega7);
//Satellite 8
L = CAACoordinateTransformation.MapTo0To360Range(261.1582 + 22.57697855 * t4);
double w_dash = 91.796 + 0.562 * t7;
psi = 4.367 - 0.195 * t7;
double psirad = CAACoordinateTransformation.DegreesToRadians(psi);
theta = 146.819 - 3.198 * t7;
phi = 60.470 + 1.521 * t7;
phirad = CAACoordinateTransformation.DegreesToRadians(phi);
double PHI = 205.055 - 2.091 * t7;
edash = 0.028298 + 0.001156 * t11;
double w_0 = 352.91 + 11.71 * t11;
double mu = CAACoordinateTransformation.MapTo0To360Range(76.3852 + 4.53795125 * t10);
mu = CAACoordinateTransformation.MapTo0To360Range(189097.71668440815);
idash = 18.4602 - 0.9518 * t11 - 0.072 * t112 + 0.0054 * t113;
idashrad = CAACoordinateTransformation.DegreesToRadians(idash);
omegadash = 143.198 - 3.919 * t11 + 0.116 * t112 + 0.008 * t113;
l = CAACoordinateTransformation.DegreesToRadians(mu - w_0);
g = CAACoordinateTransformation.DegreesToRadians(w_0 - omegadash - psi);
double g1 = CAACoordinateTransformation.DegreesToRadians(w_0 - omegadash - phi);
double ls = CAACoordinateTransformation.DegreesToRadians(W5 - w_dash);
double gs = CAACoordinateTransformation.DegreesToRadians(w_dash - theta);
double lt = CAACoordinateTransformation.DegreesToRadians(L - W4);
double gt = CAACoordinateTransformation.DegreesToRadians(W4 - PHI);
double u1 = 2 * (l + g - ls - gs);
double u2 = l + g1 - lt - gt;
double u3 = l + 2 * (g - ls - gs);
double u4 = lt + gt - g1;
double u5 = 2 * (ls + gs);
a = 58.935028 + 0.004638 * Math.Cos(u1) + 0.058222 * Math.Cos(u2);
e = edash - 0.0014097 * Math.Cos(g1 - gt) + 0.0003733 * Math.Cos(u5 - 2 * g) + 0.0001180 * Math.Cos(u3) + 0.0002408 * Math.Cos(l) + 0.0002849 * Math.Cos(l + u2) + 0.0006190 * Math.Cos(u4);
double w = 0.08077 * Math.Sin(g1 - gt) + 0.02139 * Math.Sin(u5 - 2 * g) - 0.00676 * Math.Sin(u3) + 0.01380 * Math.Sin(l) + 0.01632 * Math.Sin(l + u2) + 0.03547 * Math.Sin(u4);
p = w_0 + w / edash;
lambdadash = mu - 0.04299 * Math.Sin(u2) - 0.00789 * Math.Sin(u1) - 0.06312 * Math.Sin(ls) + -0.00295 * Math.Sin(2 * ls) - 0.02231 * Math.Sin(u5) + 0.00650 * Math.Sin(u5 + psirad);
i = idash + 0.04204 * Math.Cos(u5 + psirad) + 0.00235 * Math.Cos(l + g1 + lt + gt + phirad) + 0.00360 * Math.Cos(u2 + phirad);
double wdash = 0.04204 * Math.Sin(u5 + psirad) + 0.00235 * Math.Sin(l + g1 + lt + gt + phirad) + 0.00358 * Math.Sin(u2 + phirad);
omega = omegadash + wdash / Math.Sin(idashrad);
double lambda8 = 0;
double gamma8 = 0;
double omega8 = 0;
double r8 = 0;
HelperSubroutine(e, lambdadash, p, a, omega, i, c1, s1, ref r8, ref lambda8, ref gamma8, ref omega8);
u = CAACoordinateTransformation.DegreesToRadians(lambda1 - omega1);
w = CAACoordinateTransformation.DegreesToRadians(omega1 - 168.8112);
double gamma1rad = CAACoordinateTransformation.DegreesToRadians(gamma1);
double X1 = r1 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma1rad) * Math.Sin(w));
double Y1 = r1 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma1rad) + Math.Cos(u) * Math.Sin(w));
double Z1 = r1 * Math.Sin(u) * Math.Sin(gamma1rad);
u = CAACoordinateTransformation.DegreesToRadians(lambda2 - omega2);
w = CAACoordinateTransformation.DegreesToRadians(omega2 - 168.8112);
double gamma2rad = CAACoordinateTransformation.DegreesToRadians(gamma2);
double X2 = r2 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma2rad) * Math.Sin(w));
double Y2 = r2 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma2rad) + Math.Cos(u) * Math.Sin(w));
double Z2 = r2 * Math.Sin(u) * Math.Sin(gamma2rad);
u = CAACoordinateTransformation.DegreesToRadians(lambda3 - omega3);
w = CAACoordinateTransformation.DegreesToRadians(omega3 - 168.8112);
double gamma3rad = CAACoordinateTransformation.DegreesToRadians(gamma3);
double X3 = r3 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma3rad) * Math.Sin(w));
double Y3 = r3 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma3rad) + Math.Cos(u) * Math.Sin(w));
double Z3 = r3 * Math.Sin(u) * Math.Sin(gamma3rad);
u = CAACoordinateTransformation.DegreesToRadians(lambda4 - omega4);
w = CAACoordinateTransformation.DegreesToRadians(omega4 - 168.8112);
double gamma4rad = CAACoordinateTransformation.DegreesToRadians(gamma4);
double X4 = r4 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma4rad) * Math.Sin(w));
double Y4 = r4 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma4rad) + Math.Cos(u) * Math.Sin(w));
double Z4 = r4 * Math.Sin(u) * Math.Sin(gamma4rad);
u = CAACoordinateTransformation.DegreesToRadians(lambda5 - omega5);
w = CAACoordinateTransformation.DegreesToRadians(omega5 - 168.8112);
double gamma5rad = CAACoordinateTransformation.DegreesToRadians(gamma5);
double X5 = r5 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma5rad) * Math.Sin(w));
double Y5 = r5 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma5rad) + Math.Cos(u) * Math.Sin(w));
double Z5 = r5 * Math.Sin(u) * Math.Sin(gamma5rad);
u = CAACoordinateTransformation.DegreesToRadians(lambda6 - omega6);
w = CAACoordinateTransformation.DegreesToRadians(omega6 - 168.8112);
double gamma6rad = CAACoordinateTransformation.DegreesToRadians(gamma6);
double X6 = r6 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma6rad) * Math.Sin(w));
double Y6 = r6 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma6rad) + Math.Cos(u) * Math.Sin(w));
double Z6 = r6 * Math.Sin(u) * Math.Sin(gamma6rad);
u = CAACoordinateTransformation.DegreesToRadians(lambda7 - omega7);
w = CAACoordinateTransformation.DegreesToRadians(omega7 - 168.8112);
double gamma7rad = CAACoordinateTransformation.DegreesToRadians(gamma7);
double X7 = r7 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma7rad) * Math.Sin(w));
double Y7 = r7 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma7rad) + Math.Cos(u) * Math.Sin(w));
double Z7 = r7 * Math.Sin(u) * Math.Sin(gamma7rad);
u = CAACoordinateTransformation.DegreesToRadians(lambda8 - omega8);
w = CAACoordinateTransformation.DegreesToRadians(omega8 - 168.8112);
double gamma8rad = CAACoordinateTransformation.DegreesToRadians(gamma8);
double X8 = r8 * (Math.Cos(u) * Math.Cos(w) - Math.Sin(u) * Math.Cos(gamma8rad) * Math.Sin(w));
double Y8 = r8 * (Math.Sin(u) * Math.Cos(w) * Math.Cos(gamma8rad) + Math.Cos(u) * Math.Sin(w));
double Z8 = r8 * Math.Sin(u) * Math.Sin(gamma8rad);
double X9 = 0;
double Y9 = 0;
double Z9 = 1;
//Now do the rotations, first for the ficticious 9th satellite, so that we can calculate D
double A4 = 0;
double B4 = 0;
double C4 = 0;
Rotations(X9, Y9, Z9, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
double D = Math.Atan2(A4, C4);
//Now calculate the values for satellite 1
Rotations(X1, Y1, Z1, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
details.Satellite1.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
details.Satellite1.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
details.Satellite1.TrueRectangularCoordinates.Z = B4;
//Now calculate the values for satellite 2
Rotations(X2, Y2, Z2, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
details.Satellite2.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
details.Satellite2.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
details.Satellite2.TrueRectangularCoordinates.Z = B4;
//Now calculate the values for satellite 3
Rotations(X3, Y3, Z3, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
details.Satellite3.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
details.Satellite3.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
details.Satellite3.TrueRectangularCoordinates.Z = B4;
//Now calculate the values for satellite 4
Rotations(X4, Y4, Z4, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
details.Satellite4.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
details.Satellite4.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
details.Satellite4.TrueRectangularCoordinates.Z = B4;
//Now calculate the values for satellite 5
Rotations(X5, Y5, Z5, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
details.Satellite5.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
details.Satellite5.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
details.Satellite5.TrueRectangularCoordinates.Z = B4;
//Now calculate the values for satellite 6
Rotations(X6, Y6, Z6, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
details.Satellite6.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
details.Satellite6.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
details.Satellite6.TrueRectangularCoordinates.Z = B4;
//Now calculate the values for satellite 7
Rotations(X7, Y7, Z7, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
details.Satellite7.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
details.Satellite7.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
details.Satellite7.TrueRectangularCoordinates.Z = B4;
//Now calculate the values for satellite 8
Rotations(X8, Y8, Z8, c1, s1, c2, s2, lambda0rad, beta0rad, ref A4, ref B4, ref C4);
details.Satellite8.TrueRectangularCoordinates.X = A4 * Math.Cos(D) - C4 * Math.Sin(D);
details.Satellite8.TrueRectangularCoordinates.Y = A4 * Math.Sin(D) + C4 * Math.Cos(D);
details.Satellite8.TrueRectangularCoordinates.Z = B4;
//apply the differential light-time correction
details.Satellite1.ApparentRectangularCoordinates.X = details.Satellite1.TrueRectangularCoordinates.X + Math.Abs(details.Satellite1.TrueRectangularCoordinates.Z) / 20947 * Math.Sqrt(1 - (details.Satellite1.TrueRectangularCoordinates.X / r1) * (details.Satellite1.TrueRectangularCoordinates.X / r1));
details.Satellite1.ApparentRectangularCoordinates.Y = details.Satellite1.TrueRectangularCoordinates.Y;
details.Satellite1.ApparentRectangularCoordinates.Z = details.Satellite1.TrueRectangularCoordinates.Z;
details.Satellite2.ApparentRectangularCoordinates.X = details.Satellite2.TrueRectangularCoordinates.X + Math.Abs(details.Satellite2.TrueRectangularCoordinates.Z) / 23715 * Math.Sqrt(1 - (details.Satellite2.TrueRectangularCoordinates.X / r2) * (details.Satellite2.TrueRectangularCoordinates.X / r2));
details.Satellite2.ApparentRectangularCoordinates.Y = details.Satellite2.TrueRectangularCoordinates.Y;
details.Satellite2.ApparentRectangularCoordinates.Z = details.Satellite2.TrueRectangularCoordinates.Z;
details.Satellite3.ApparentRectangularCoordinates.X = details.Satellite3.TrueRectangularCoordinates.X + Math.Abs(details.Satellite3.TrueRectangularCoordinates.Z) / 26382 * Math.Sqrt(1 - (details.Satellite3.TrueRectangularCoordinates.X / r3) * (details.Satellite3.TrueRectangularCoordinates.X / r3));
details.Satellite3.ApparentRectangularCoordinates.Y = details.Satellite3.TrueRectangularCoordinates.Y;
details.Satellite3.ApparentRectangularCoordinates.Z = details.Satellite3.TrueRectangularCoordinates.Z;
details.Satellite4.ApparentRectangularCoordinates.X = details.Satellite4.TrueRectangularCoordinates.X + Math.Abs(details.Satellite4.TrueRectangularCoordinates.Z) / 29876 * Math.Sqrt(1 - (details.Satellite4.TrueRectangularCoordinates.X / r4) * (details.Satellite4.TrueRectangularCoordinates.X / r4));
details.Satellite4.ApparentRectangularCoordinates.Y = details.Satellite4.TrueRectangularCoordinates.Y;
details.Satellite4.ApparentRectangularCoordinates.Z = details.Satellite4.TrueRectangularCoordinates.Z;
details.Satellite5.ApparentRectangularCoordinates.X = details.Satellite5.TrueRectangularCoordinates.X + Math.Abs(details.Satellite5.TrueRectangularCoordinates.Z) / 35313 * Math.Sqrt(1 - (details.Satellite5.TrueRectangularCoordinates.X / r5) * (details.Satellite5.TrueRectangularCoordinates.X / r5));
details.Satellite5.ApparentRectangularCoordinates.Y = details.Satellite5.TrueRectangularCoordinates.Y;
details.Satellite5.ApparentRectangularCoordinates.Z = details.Satellite5.TrueRectangularCoordinates.Z;
details.Satellite6.ApparentRectangularCoordinates.X = details.Satellite6.TrueRectangularCoordinates.X + Math.Abs(details.Satellite6.TrueRectangularCoordinates.Z) / 53800 * Math.Sqrt(1 - (details.Satellite6.TrueRectangularCoordinates.X / r6) * (details.Satellite6.TrueRectangularCoordinates.X / r6));
details.Satellite6.ApparentRectangularCoordinates.Y = details.Satellite6.TrueRectangularCoordinates.Y;
details.Satellite6.ApparentRectangularCoordinates.Z = details.Satellite6.TrueRectangularCoordinates.Z;
details.Satellite7.ApparentRectangularCoordinates.X = details.Satellite7.TrueRectangularCoordinates.X + Math.Abs(details.Satellite7.TrueRectangularCoordinates.Z) / 59222 * Math.Sqrt(1 - (details.Satellite7.TrueRectangularCoordinates.X / r7) * (details.Satellite7.TrueRectangularCoordinates.X / r7));
details.Satellite7.ApparentRectangularCoordinates.Y = details.Satellite7.TrueRectangularCoordinates.Y;
details.Satellite7.ApparentRectangularCoordinates.Z = details.Satellite7.TrueRectangularCoordinates.Z;
details.Satellite8.ApparentRectangularCoordinates.X = details.Satellite8.TrueRectangularCoordinates.X + Math.Abs(details.Satellite8.TrueRectangularCoordinates.Z) / 91820 * Math.Sqrt(1 - (details.Satellite8.TrueRectangularCoordinates.X / r8) * (details.Satellite8.TrueRectangularCoordinates.X / r8));
details.Satellite8.ApparentRectangularCoordinates.Y = details.Satellite8.TrueRectangularCoordinates.Y;
details.Satellite8.ApparentRectangularCoordinates.Z = details.Satellite8.TrueRectangularCoordinates.Z;
//apply the perspective effect correction
double W = DELTA / (DELTA + details.Satellite1.TrueRectangularCoordinates.Z / 2475);
details.Satellite1.ApparentRectangularCoordinates.X *= W;
details.Satellite1.ApparentRectangularCoordinates.Y *= W;
W = DELTA / (DELTA + details.Satellite2.TrueRectangularCoordinates.Z / 2475);
details.Satellite2.ApparentRectangularCoordinates.X *= W;
details.Satellite2.ApparentRectangularCoordinates.Y *= W;
W = DELTA / (DELTA + details.Satellite3.TrueRectangularCoordinates.Z / 2475);
details.Satellite3.ApparentRectangularCoordinates.X *= W;
details.Satellite3.ApparentRectangularCoordinates.Y *= W;
W = DELTA / (DELTA + details.Satellite4.TrueRectangularCoordinates.Z / 2475);
details.Satellite4.ApparentRectangularCoordinates.X *= W;
details.Satellite4.ApparentRectangularCoordinates.Y *= W;
W = DELTA / (DELTA + details.Satellite5.TrueRectangularCoordinates.Z / 2475);
details.Satellite5.ApparentRectangularCoordinates.X *= W;
details.Satellite5.ApparentRectangularCoordinates.Y *= W;
W = DELTA / (DELTA + details.Satellite6.TrueRectangularCoordinates.Z / 2475);
details.Satellite6.ApparentRectangularCoordinates.X *= W;
details.Satellite6.ApparentRectangularCoordinates.Y *= W;
W = DELTA / (DELTA + details.Satellite7.TrueRectangularCoordinates.Z / 2475);
details.Satellite7.ApparentRectangularCoordinates.X *= W;
details.Satellite7.ApparentRectangularCoordinates.Y *= W;
W = DELTA / (DELTA + details.Satellite8.TrueRectangularCoordinates.Z / 2475);
details.Satellite8.ApparentRectangularCoordinates.X *= W;
details.Satellite8.ApparentRectangularCoordinates.Y *= W;
return(details);
}
public static AstroRaDec GalacticToJ2000(double l, double b)
{
CAA2DCoordinate radec = CAACoordinateTransformation.Galactic2Equatorial(l, b);
return(new AstroRaDec(radec.X, radec.Y, 0, false, false));
}
public static AstroRaDec J2000ToGalactic(double ra, double dec)
{
CAA2DCoordinate galactic = CAACoordinateTransformation.Equatorial2Galactic(ra, dec);
return(new AstroRaDec(galactic.X, galactic.Y, 0, false, false));
}
public static AstroRaDec GetPlanet(double jDate, int planet, double locLat, double locLong, double locHeight)
{
locLong = -locLong;
if (planet < 9)
{
CAAEllipticalPlanetaryDetails Details = CAAElliptical.Calculate(jDate, (EllipticalObject)planet);
CAA2DCoordinate 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);
CAA2DCoordinate d = CAACoordinateTransformation.Ecliptic2Equatorial(lng, lat, epsilon);
CAA2DCoordinate 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 = CAAElliptical.Calculate(jDate, (EllipticalObject)4);
jupPhisical = CAAPhysicalJupiter.Calculate(jDate);
CAA2DCoordinate corrected = CAAParallax.Equatorial2Topocentric(jupDetails.ApparentGeocentricRA, jupDetails.ApparentGeocentricDeclination, jupDetails.ApparentGeocentricDistance, locLong, locLat, locHeight, jDate);
jupDetails.ApparentGeocentricRA = corrected.X;
jupDetails.ApparentGeocentricDeclination = corrected.Y;
galDetails = CAAGalileanMoons.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));
}
}
public static CAA2DCoordinate EclipticAberration(double Lambda, double Beta, double JD)
{
//What is the return value
CAA2DCoordinate aberration = new CAA2DCoordinate();
double T = (JD - 2451545) / 36525;
double Tsquared = T *T;
double e = 0.016708634 - 0.000042037 *T - 0.0000001267 *Tsquared;
double pi = 102.93735 + 1.71946 *T + 0.00046 *Tsquared;
double k = 20.49552;
double SunLongitude = CAASun.GeometricEclipticLongitude(JD);
//Convert to radians
pi = CAACoordinateTransformation.DegreesToRadians(pi);
Lambda = CAACoordinateTransformation.DegreesToRadians(Lambda);
Beta = CAACoordinateTransformation.DegreesToRadians(Beta);
SunLongitude = CAACoordinateTransformation.DegreesToRadians(SunLongitude);
aberration.X = (-k *Math.Cos(SunLongitude - Lambda) + e *k *Math.Cos(pi - Lambda)) / Math.Cos(Beta) / 3600;
aberration.Y = -k *Math.Sin(Beta)*(Math.Sin(SunLongitude - Lambda) - e *Math.Sin(pi - Lambda)) / 3600;
return aberration;
}
public static CAA2DCoordinate EquatorialAberration(double Alpha, double Delta, double JD)
{
//Convert to radians
Alpha = CAACoordinateTransformation.DegreesToRadians(Alpha *15);
Delta = CAACoordinateTransformation.DegreesToRadians(Delta);
double cosAlpha = Math.Cos(Alpha);
double sinAlpha = Math.Sin(Alpha);
double cosDelta = Math.Cos(Delta);
double sinDelta = Math.Sin(Delta);
CAA3DCoordinate velocity = EarthVelocity(JD);
//What is the return value
CAA2DCoordinate aberration = new CAA2DCoordinate();
aberration.X = CAACoordinateTransformation.RadiansToHours((velocity.Y * cosAlpha - velocity.X * sinAlpha) / (17314463350.0 * cosDelta));
aberration.Y = CAACoordinateTransformation.RadiansToDegrees(- (((velocity.X * cosAlpha + velocity.Y * sinAlpha) * sinDelta - velocity.Z * cosDelta) / 17314463350.0));
return aberration;
}
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));
}
//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 = CAACoordinateTransformation.DegreesToRadians(i);
double omega = 169.508470 + 1.394681 * T + 0.000412 * T2;
double omegarad = CAACoordinateTransformation.DegreesToRadians(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 = CAACoordinateTransformation.DegreesToRadians(l0);
b0 += CAAFK5.CorrectionInLatitude(l0, JD);
double b0rad = CAACoordinateTransformation.DegreesToRadians(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 = CAAElliptical.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 = CAACoordinateTransformation.DegreesToRadians(l);
double brad = CAACoordinateTransformation.DegreesToRadians(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 = CAAElliptical.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 = CAACoordinateTransformation.RadiansToDegrees(details.B);
//Step 7. Calculate the longitude of the ascending node of Saturn's orbit
double N = 113.6655 + 0.8771 * T;
double Nrad = CAACoordinateTransformation.DegreesToRadians(N);
double ldash = l - 0.01759 / r;
double ldashrad = CAACoordinateTransformation.DegreesToRadians(ldash);
double bdash = b - 0.000764 * Math.Cos(ldashrad - Nrad) / r;
double bdashrad = CAACoordinateTransformation.DegreesToRadians(bdash);
//Step 8. Calculate Bdash
details.Bdash = CAACoordinateTransformation.RadiansToDegrees(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 = CAACoordinateTransformation.RadiansToDegrees(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 += CAACoordinateTransformation.DegreesToRadians(0.005693 * Math.Cos(l0rad - lambda) / Math.Cos(beta));
beta += CAACoordinateTransformation.DegreesToRadians(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 = CAACoordinateTransformation.RadiansToDegrees(lambda);
lambda += NutationInLongitude / 3600;
lambda = CAACoordinateTransformation.MapTo0To360Range(lambda);
lambda0 += NutationInLongitude / 3600;
lambda0 = CAACoordinateTransformation.MapTo0To360Range(lambda0);
//Step 14. Convert to equatorial coordinates
beta = CAACoordinateTransformation.RadiansToDegrees(beta);
CAA2DCoordinate GeocentricEclipticSaturn = CAACoordinateTransformation.Ecliptic2Equatorial(lambda, beta, Obliquity);
double alpha = CAACoordinateTransformation.HoursToRadians(GeocentricEclipticSaturn.X);
double delta = CAACoordinateTransformation.DegreesToRadians(GeocentricEclipticSaturn.Y);
CAA2DCoordinate GeocentricEclipticNorthPole = CAACoordinateTransformation.Ecliptic2Equatorial(lambda0, beta0, Obliquity);
double alpha0 = CAACoordinateTransformation.HoursToRadians(GeocentricEclipticNorthPole.X);
double delta0 = CAACoordinateTransformation.DegreesToRadians(GeocentricEclipticNorthPole.Y);
//Step 15. Calculate the Position angle
details.P = CAACoordinateTransformation.RadiansToDegrees(Math.Atan2(Math.Cos(delta0) * Math.Sin(alpha0 - alpha), Math.Sin(delta0) * Math.Cos(delta) - Math.Cos(delta0) * Math.Sin(delta) * Math.Cos(alpha0 - alpha)));
return(details);
}
//Static methods
public static CAA2DCoordinate PrecessEquatorial(double Alpha, double Delta, double JD0, double JD)
{
var T = (JD0 - 2451545.0) / 36525;
var Tsquared = T *T;
var t = (JD - JD0) / 36525;
var tsquared = t *t;
var tcubed = tsquared * t;
//Now convert to radians
Alpha = CAACoordinateTransformation.HoursToRadians(Alpha);
Delta = CAACoordinateTransformation.DegreesToRadians(Delta);
var sigma = (2306.2181 + 1.39656 *T - 0.000139 *Tsquared)*t + (0.30188 - 0.0000344 *T)*tsquared + 0.017988 *tcubed;
sigma = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.DMSToDegrees(0, 0, sigma));
var zeta = (2306.2181 + 1.39656 *T - 0.000138 *Tsquared)*t + (1.09468 + 0.000066 *T)*tsquared + 0.018203 *tcubed;
zeta = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.DMSToDegrees(0, 0, zeta));
var phi = (2004.3109 - 0.8533 *T - 0.000217 *Tsquared)*t - (0.42665 + 0.000217 *T)*tsquared - 0.041833 *tcubed;
phi = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.DMSToDegrees(0, 0, phi));
var A = Math.Cos(Delta) * Math.Sin(Alpha + sigma);
var B = Math.Cos(phi)*Math.Cos(Delta)*Math.Cos(Alpha + sigma) - Math.Sin(phi)*Math.Sin(Delta);
var C = Math.Sin(phi)*Math.Cos(Delta)*Math.Cos(Alpha + sigma) + Math.Cos(phi)*Math.Sin(Delta);
var @value = new CAA2DCoordinate();
@value.X = CAACoordinateTransformation.RadiansToHours(Math.Atan2(A, B) + zeta);
if (@value.X < 0)
@value.X += 24;
@value.Y = CAACoordinateTransformation.RadiansToDegrees(Math.Asin(C));
return @value;
}
//Conversion functions
/////////////////////// Implementation ////////////////////////////////////////
public static CAA2DCoordinate Equatorial2Ecliptic(double Alpha, double Delta, double Epsilon)
{
Alpha = HoursToRadians(Alpha);
Delta = DegreesToRadians(Delta);
Epsilon = DegreesToRadians(Epsilon);
CAA2DCoordinate Ecliptic = new CAA2DCoordinate();
Ecliptic.X = RadiansToDegrees(Math.Atan2(Math.Sin(Alpha)*Math.Cos(Epsilon) + Math.Tan(Delta)*Math.Sin(Epsilon), Math.Cos(Alpha)));
if (Ecliptic.X < 0)
Ecliptic.X += 360;
Ecliptic.Y = RadiansToDegrees(Math.Asin(Math.Sin(Delta)*Math.Cos(Epsilon) - Math.Cos(Delta)*Math.Sin(Epsilon)*Math.Sin(Alpha)));
return Ecliptic;
}
public static CAA2DCoordinate PrecessEquatorialFK4(double Alpha, double Delta, double JD0, double JD)
{
var T = (JD0 - 2415020.3135) / 36524.2199;
var t = (JD - JD0) / 36524.2199;
var tsquared = t *t;
var tcubed = tsquared * t;
//Now convert to radians
Alpha = CAACoordinateTransformation.HoursToRadians(Alpha);
Delta = CAACoordinateTransformation.DegreesToRadians(Delta);
var sigma = (2304.250 + 1.396 *T)*t + 0.302 *tsquared + 0.018 *tcubed;
sigma = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.DMSToDegrees(0, 0, sigma));
var zeta = 0.791 *tsquared + 0.001 *tcubed;
zeta = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.DMSToDegrees(0, 0, zeta));
zeta += sigma;
var phi = (2004.682 - 0.853 *T)*t - 0.426 *tsquared - 0.042 *tcubed;
phi = CAACoordinateTransformation.DegreesToRadians(CAACoordinateTransformation.DMSToDegrees(0, 0, phi));
var A = Math.Cos(Delta) * Math.Sin(Alpha + sigma);
var B = Math.Cos(phi)*Math.Cos(Delta)*Math.Cos(Alpha + sigma) - Math.Sin(phi)*Math.Sin(Delta);
var C = Math.Sin(phi)*Math.Cos(Delta)*Math.Cos(Alpha + sigma) + Math.Cos(phi)*Math.Sin(Delta);
var @value = new CAA2DCoordinate();
@value.X = CAACoordinateTransformation.RadiansToHours(Math.Atan2(A, B) + zeta);
if (@value.X < 0)
@value.X += 24;
@value.Y = CAACoordinateTransformation.RadiansToDegrees(Math.Asin(C));
return @value;
}
public static CAA2DCoordinate Equatorial2Horizontal(double LocalHourAngle, double Delta, double Latitude)
{
LocalHourAngle = HoursToRadians(LocalHourAngle);
Delta = DegreesToRadians(Delta);
Latitude = DegreesToRadians(Latitude);
CAA2DCoordinate Horizontal = new CAA2DCoordinate();
Horizontal.X = RadiansToDegrees(Math.Atan2(Math.Sin(LocalHourAngle), Math.Cos(LocalHourAngle)*Math.Sin(Latitude) - Math.Tan(Delta)*Math.Cos(Latitude)));
if (Horizontal.X < 0)
Horizontal.X += 360;
Horizontal.Y = RadiansToDegrees(Math.Asin(Math.Sin(Latitude)*Math.Sin(Delta) + Math.Cos(Latitude)*Math.Cos(Delta)*Math.Cos(LocalHourAngle)));
return Horizontal;
}
public static CAAEllipticalPlanetaryDetails Calculate(double JD, EllipticalObject @object)
{
//What will the the return value
CAAEllipticalPlanetaryDetails details = new CAAEllipticalPlanetaryDetails();
double JD0 = JD;
double L0 = 0;
double B0 = 0;
double R0 = 0;
double cosB0 = 0;
if (@object != EllipticalObject.SUN)
{
L0 = CAAEarth.EclipticLongitude(JD0);
B0 = CAAEarth.EclipticLatitude(JD0);
R0 = CAAEarth.RadiusVector(JD0);
L0 = CAACoordinateTransformation.DegreesToRadians(L0);
B0 = CAACoordinateTransformation.DegreesToRadians(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 EllipticalObject.SUN:
{
L = CAASun.GeometricEclipticLongitude(JD0);
B = CAASun.GeometricEclipticLatitude(JD0);
R = CAAEarth.RadiusVector(JD0);
break;
}
case EllipticalObject.MERCURY:
{
L = CAAMercury.EclipticLongitude(JD0);
B = CAAMercury.EclipticLatitude(JD0);
R = CAAMercury.RadiusVector(JD0);
break;
}
case EllipticalObject.VENUS:
{
L = CAAVenus.EclipticLongitude(JD0);
B = CAAVenus.EclipticLatitude(JD0);
R = CAAVenus.RadiusVector(JD0);
break;
}
case EllipticalObject.MARS:
{
L = CAAMars.EclipticLongitude(JD0);
B = CAAMars.EclipticLatitude(JD0);
R = CAAMars.RadiusVector(JD0);
break;
}
case EllipticalObject.JUPITER:
{
L = CAAJupiter.EclipticLongitude(JD0);
B = CAAJupiter.EclipticLatitude(JD0);
R = CAAJupiter.RadiusVector(JD0);
break;
}
case EllipticalObject.SATURN:
{
L = CAASaturn.EclipticLongitude(JD0);
B = CAASaturn.EclipticLatitude(JD0);
R = CAASaturn.RadiusVector(JD0);
break;
}
case EllipticalObject.URANUS:
{
L = CAAUranus.EclipticLongitude(JD0);
B = CAAUranus.EclipticLatitude(JD0);
R = CAAUranus.RadiusVector(JD0);
break;
}
case EllipticalObject.NEPTUNE:
{
L = CAANeptune.EclipticLongitude(JD0);
B = CAANeptune.EclipticLatitude(JD0);
R = CAANeptune.RadiusVector(JD0);
break;
}
case EllipticalObject.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 != EllipticalObject.SUN)
{
Lrad = CAACoordinateTransformation.DegreesToRadians(L);
Brad = CAACoordinateTransformation.DegreesToRadians(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 - CAAElliptical.DistanceToLightTime(distance);
}
}
Lrad = CAACoordinateTransformation.DegreesToRadians(L);
Brad = CAACoordinateTransformation.DegreesToRadians(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 = CAACoordinateTransformation.RadiansToDegrees(Math.Atan2(z, Math.Sqrt(x2 + y2)));
details.ApparentGeocentricDistance = Math.Sqrt(x2 + y2 + z * z);
details.ApparentGeocentricLongitude = CAACoordinateTransformation.MapTo0To360Range(CAACoordinateTransformation.RadiansToDegrees(Math.Atan2(y, x)));
details.ApparentLightTime = CAAElliptical.DistanceToLightTime(details.ApparentGeocentricDistance);
//Adjust for Aberration
CAA2DCoordinate Aberration = CAAAberration.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 += CAACoordinateTransformation.DMSToDegrees(0, 0, NutationInLongitude);
//Convert to RA and Dec
CAA2DCoordinate ApparentEqu = CAACoordinateTransformation.Ecliptic2Equatorial(details.ApparentGeocentricLongitude, details.ApparentGeocentricLatitude, Epsilon);
details.ApparentGeocentricRA = ApparentEqu.X;
details.ApparentGeocentricDeclination = ApparentEqu.Y;
return(details);
}
public static CAA2DCoordinate Horizontal2Equatorial(double Azimuth, double Altitude, double Latitude)
{
//Convert from degress to radians
Azimuth = DegreesToRadians(Azimuth);
Altitude = DegreesToRadians(Altitude);
Latitude = DegreesToRadians(Latitude);
CAA2DCoordinate Equatorial = new CAA2DCoordinate();
Equatorial.X = RadiansToHours(Math.Atan2(Math.Sin(Azimuth), Math.Cos(Azimuth)*Math.Sin(Latitude) + Math.Tan(Altitude)*Math.Cos(Latitude)));
if (Equatorial.X < 0)
Equatorial.X += 24;
Equatorial.Y = RadiansToDegrees(Math.Asin(Math.Sin(Latitude)*Math.Sin(Altitude) - Math.Cos(Latitude)*Math.Cos(Altitude)*Math.Cos(Azimuth)));
return Equatorial;
}
protected static CAAPhysicalMoonDetails CalculateHelper(double JD, ref double Lambda, ref double Beta, ref double epsilon, ref CAA2DCoordinate Equatorial)
{
//What will be the return value
CAAPhysicalMoonDetails details = new CAAPhysicalMoonDetails();
//Calculate the initial quantities
Lambda = CAAMoon.EclipticLongitude(JD);
Beta = CAAMoon.EclipticLatitude(JD);
//Calculate the optical libration
double omega = 0;
double DeltaU = 0;
double sigma = 0;
double I = 0;
double rho = 0;
CalculateOpticalLibration(JD, Lambda, Beta, ref details.ldash, ref details.bdash, ref details.ldash2, ref details.bdash2, ref epsilon, ref omega, ref DeltaU, ref sigma, ref I, ref rho);
double epsilonrad = CAACoordinateTransformation.DegreesToRadians(epsilon);
//Calculate the total libration
details.l = details.ldash + details.ldash2;
details.b = details.bdash + details.bdash2;
double b = CAACoordinateTransformation.DegreesToRadians(details.b);
//Calculate the position angle
double V = omega + DeltaU + CAACoordinateTransformation.DegreesToRadians(sigma) / Math.Sin(I);
double I_rho = I + CAACoordinateTransformation.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 = CAACoordinateTransformation.Ecliptic2Equatorial(Lambda, Beta, epsilon);
double Alpha = CAACoordinateTransformation.HoursToRadians(Equatorial.X);
details.P = CAACoordinateTransformation.RadiansToDegrees(Math.Asin(Math.Sqrt(X * X + Y * Y) * Math.Cos(Alpha - w) / (Math.Cos(b))));
return(details);
}
