public static AstroRaDec EclipticToJ2000(double l, double b, double jNow)
{
//CAA2DCoordinate Galactic = CAACoordinateTransformation::Equatorial2Galactic(CAACoordinateTransformation::DMSToDegrees(17, 48, 59.74), CAACoordinateTransformation::DMSToDegrees(14, 43, 8.2, false));
COR radec = CT.Ec2Eq(l, b, CAANutation.TrueObliquityOfEcliptic(jNow));
return(new AstroRaDec(radec.X, radec.Y, 0, false, false));
}
//Static methods
///////////////////////// Implementation //////////////////////////////////////
public static double Calculate(double JD)
{
double rho = (JD - 2451545) / 365250;
double rhosquared = rho * rho;
double rhocubed = rhosquared * rho;
double rho4 = rhocubed * rho;
double rho5 = rho4 * rho;
//Calculate the Suns mean longitude
double L0 = CT.M360(280.4664567 + 360007.6982779 * rho + 0.03032028 * rhosquared + rhocubed / 49931 - rho4 / 15300 - rho5 / 2000000);
//Calculate the Suns apparent right ascension
double SunLong = CAASun.ApparentEclipticLongitude(JD);
double SunLat = CAASun.ApparentEclipticLatitude(JD);
double epsilon = CAANutation.TrueObliquityOfEcliptic(JD);
COR Equatorial = CT.Ec2Eq(SunLong, SunLat, epsilon);
epsilon = CT.D2R(epsilon);
double E = L0 - 0.0057183 - Equatorial.X * 15 + CT.DMS2D(0, 0, CAANutation.NutationInLongitude(JD)) * Math.Cos(epsilon);
if (E > 180)
{
E = -(360 - E);
}
E *= 4; //Convert to minutes of time
return(E);
}
/// <summary>
/// Initializes a new instance of the <see cref="MVC_Controller"/> class.
/// </summary>
public MVC_Controller(long maxSize, bool isByte, bool isNS, bool isClean, string path)
{
this.caretaker = new Caretaker();
this.cor = new COR();
this.maxSize = maxSize;
this.isNS = isNS;
this.isByte = isByte;
this.path = path;
if (isClean)
{
cleanStorage();
}
else
{
try
{
LoadStorage();
}
catch
{
Console.WriteLine("Storage file doesn't exist!");
Console.WriteLine("Creating a new one...");
this.storage = new Storage(maxSize, isByte, isNS, path);
SaveStorage();
}
}
}
public static AstroRaDec GalacticToJ2000(double l, double b)
{
//CAA2DCoordinate Galactic = CAACoordinateTransformation::Equatorial2Galactic(CAACoordinateTransformation::DMSToDegrees(17, 48, 59.74), CAACoordinateTransformation::DMSToDegrees(14, 43, 8.2, false));
COR radec = CT.G2Eq(l, b);
return(new AstroRaDec(radec.X, radec.Y, 0, false, false));
}
public static COR 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 = CT.D2R(Delta);
double cosDelta = Math.Cos(Delta);
//Calculate the Parallax
double pi = Math.Asin(GFX.g_AAParallax_C1 / Distance);
double sinpi = Math.Sin(pi);
//Calculate the hour angle
double H = CT.H2R(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);
COR Topocentric = new COR();
Topocentric.X = CT.M24(Alpha + CT.R2H(DeltaAlpha));
Topocentric.Y = CT.R2D(Math.Atan2((Math.Sin(Delta) - RhoSinThetaPrime * sinpi) * Math.Cos(DeltaAlpha), cosDelta - RhoCosThetaPrime * sinpi * cosH));
return(Topocentric);
}
//Conversion functions
public static COR 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 = CT.D2R(Delta);
double cosDelta = Math.Cos(Delta);
//Calculate the Parallax
double pi = Math.Asin(GFX.g_AAParallax_C1 / Distance);
//Calculate the hour angle
double H = CT.H2R(theta - Longitude / 15 - Alpha);
double cosH = Math.Cos(H);
double sinH = Math.Sin(H);
COR DeltaTopocentric = new COR();
DeltaTopocentric.X = CT.R2H(-pi * RhoCosThetaPrime * sinH / cosDelta);
DeltaTopocentric.Y = CT.R2D(-pi * (RhoSinThetaPrime * cosDelta - RhoCosThetaPrime * cosH * Math.Sin(Delta)));
return(DeltaTopocentric);
}
public async void escolherCor(COR cor)
{
carta c = new carta();
c._cor = (int)cor;
c._valor = (int)descarte.ultimaCarta().Valor;
Jogada jogada = new Jogada();
project.src.models.Carta au = new project.src.models.Carta();
au.Cor = cor;
au.Valor = descarte.ultimaCarta().Valor;
jogada.carta = c;
jogada.jogadorId = jogadorPosicao;
jogada.sala = NumeroSala;
au.setCor(cor);
areaMensagens.mostraMensage("Cor escolhida: " + cor);
await Client.EmitAsync("escolhe-cor", response =>
{
int resp = response.GetValue <int>();
if (resp == 1)
{
descarte.ultimaCartaView().Carta = au;
corSelecao.Visible = false;
aguardarAnimacaoCompra();
}
}, jogada);
}
public static COR 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 = CT.D2R(Delta);
double cosDelta = Math.Cos(Delta);
//Calculate the Parallax
double pi = Math.Asin(GFX.g_AAParallax_C1 / Distance);
double sinpi = Math.Sin(pi);
//Calculate the hour angle
double H = CT.H2R(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);
COR Topocentric = new COR();
Topocentric.X = CT.M24(Alpha + CT.R2H(DeltaAlpha));
Topocentric.Y = CT.R2D(Math.Atan2((Math.Sin(Delta) - RhoSinThetaPrime *sinpi) * Math.Cos(DeltaAlpha), cosDelta - RhoCosThetaPrime *sinpi *cosH));
return Topocentric;
}
///////////////////////////////// Implementation //////////////////////////////
public static COR AdjustPositionUsingUniformProperMotion(double t, double Alpha, double Delta, double PMAlpha, double PMDelta)
{
COR @value = new COR();
@value.X = Alpha + (PMAlpha * t / 3600);
@value.Y = Delta + (PMDelta * t / 3600);
return @value;
}
public ActionResult DeleteConfirmed(int id)
{
COR cor = db.COR.Find(id);
db.COR.Remove(cor);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public JsonResult DeleteCor(int ID)
{
COR cor = db.COR.Find(ID);
db.COR.Remove(cor);
db.SaveChanges();
return(Json(true, JsonRequestBehavior.AllowGet));
}
public static COR Create(double x, double y)
{
COR item = new COR();
item.X = x;
item.Y = y;
return(item);
}
///////////////////////////////// Implementation //////////////////////////////
public static COR AdjustPositionUsingUniformProperMotion(double t, double Alpha, double Delta, double PMAlpha, double PMDelta)
{
COR @value = new COR();
@value.X = Alpha + (PMAlpha * t / 3600);
@value.Y = Delta + (PMDelta * t / 3600);
return(@value);
}
public ActionResult Edit(int id = 0)
{
COR cor = db.COR.Find(id);
if (cor == null)
{
return(HttpNotFound());
}
return(View(cor));
}
public ActionResult Edit(COR cor)
{
if (ModelState.IsValid)
{
db.Entry(cor).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(cor));
}
public ActionResult Create(COR cor)
{
if (ModelState.IsValid)
{
db.COR.Add(cor);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(cor));
}
//Conversion functions
/////////////////////// Implementation ////////////////////////////////////////
public static COR Eq2Ec(double Alpha, double Delta, double Epsilon) // was Equatorial2Ecliptic
{
Alpha = H2R(Alpha);
Delta = D2R(Delta);
Epsilon = D2R(Epsilon);
COR Ecliptic = new COR();
Ecliptic.X = R2D(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 = R2D(Math.Asin(Math.Sin(Delta) * Math.Cos(Epsilon) - Math.Cos(Delta) * Math.Sin(Epsilon) * Math.Sin(Alpha)));
return(Ecliptic);
}
public static COR Eq2H(double LocalHourAngle, double Delta, double Latitude) // was Equatorial2Horizontal
{
LocalHourAngle = H2R(LocalHourAngle);
Delta = D2R(Delta);
Latitude = D2R(Latitude);
COR Horizontal = new COR();
Horizontal.X = R2D(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 = R2D(Math.Asin(Math.Sin(Latitude) * Math.Sin(Delta) + Math.Cos(Latitude) * Math.Cos(Delta) * Math.Cos(LocalHourAngle)));
return(Horizontal);
}
public static COR Ec2Eq(double Lambda, double Beta, double Epsilon) // was Ecliptic2Equatorial
{
Lambda = D2R(Lambda);
Beta = D2R(Beta);
Epsilon = D2R(Epsilon);
COR Equatorial = new COR();
Equatorial.X = R2H(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 = R2D(Math.Asin(Math.Sin(Beta) * Math.Cos(Epsilon) + Math.Cos(Beta) * Math.Sin(Epsilon) * Math.Sin(Lambda)));
return(Equatorial);
}
public static COR EquatorialPMToEcliptic(double Alpha, double Delta, double Beta, double PMAlpha, double PMDelta, double Epsilon)
{
//Convert to radians
Epsilon = CT.D2R(Epsilon);
Alpha = CT.H2R(Alpha);
Delta = CT.D2R(Delta);
Beta = CT.D2R(Beta);
double cosb = Math.Cos(Beta);
double sinEpsilon = Math.Sin(Epsilon);
COR @value = new COR();
@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 COR Eq2G(double Alpha, double Delta) // was Equatorial2Galactic
{
Alpha = 192.25 - H2D(Alpha);
Alpha = D2R(Alpha);
Delta = D2R(Delta);
COR Galactic = new COR();
Galactic.X = R2D(Math.Atan2(Math.Sin(Alpha), Math.Cos(Alpha) * Math.Sin(D2R(27.4)) - Math.Tan(Delta) * Math.Cos(D2R(27.4))));
Galactic.X = 303 - Galactic.X;
if (Galactic.X >= 360)
{
Galactic.X -= 360;
}
Galactic.Y = R2D(Math.Asin(Math.Sin(Delta) * Math.Sin(D2R(27.4)) + Math.Cos(Delta) * Math.Cos(D2R(27.4)) * Math.Cos(Alpha)));
return(Galactic);
}
public static COR H2Eq(double Azimuth, double Altitude, double Latitude) // was Horizontal2Equatorial
{
//Convert from degress to radians
Azimuth = D2R(Azimuth);
Altitude = D2R(Altitude);
Latitude = D2R(Latitude);
COR Equatorial = new COR();
Equatorial.X = R2H(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 = R2D(Math.Asin(Math.Sin(Latitude) * Math.Sin(Altitude) - Math.Cos(Latitude) * Math.Cos(Altitude) * Math.Cos(Azimuth)));
return(Equatorial);
}
public static COR G2Eq(double l, double b) // was Galactic2Equatorial
{
l -= 123;
l = D2R(l);
b = D2R(b);
COR Equatorial = new COR();
Equatorial.X = R2D(Math.Atan2(Math.Sin(l), Math.Cos(l) * Math.Sin(D2R(27.4)) - Math.Tan(b) * Math.Cos(D2R(27.4))));
Equatorial.X += 12.25;
if (Equatorial.X < 0)
{
Equatorial.X += 360;
}
Equatorial.X = D2H(Equatorial.X);
Equatorial.Y = R2D(Math.Asin(Math.Sin(b) * Math.Sin(D2R(27.4)) + Math.Cos(b) * Math.Cos(D2R(27.4)) * Math.Cos(l)));
return(Equatorial);
}
public static COR EquatorialAberration(double Alpha, double Delta, double JD)
{
//Convert to radians
Alpha = CT.D2R(Alpha * 15);
Delta = CT.D2R(Delta);
double cosAlpha = Math.Cos(Alpha);
double sinAlpha = Math.Sin(Alpha);
double cosDelta = Math.Cos(Delta);
double sinDelta = Math.Sin(Delta);
C3D velocity = EarthVelocity(JD);
//What is the return value
COR aberration = new COR();
aberration.X = CT.R2H((velocity.Y * cosAlpha - velocity.X * sinAlpha) / (17314463350.0 * cosDelta));
aberration.Y = CT.R2D(-(((velocity.X * cosAlpha + velocity.Y * sinAlpha) * sinDelta - velocity.Z * cosDelta) / 17314463350.0));
return(aberration);
}
//Static methods
public static COR 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 = CT.H2R(Alpha);
Delta = CT.D2R(Delta);
double sigma = (2306.2181 + 1.39656 * T - 0.000139 * Tsquared) * t + (0.30188 - 0.0000344 * T) * tsquared + 0.017988 * tcubed;
sigma = CT.D2R(CT.DMS2D(0, 0, sigma));
double zeta = (2306.2181 + 1.39656 * T - 0.000138 * Tsquared) * t + (1.09468 + 0.000066 * T) * tsquared + 0.018203 * tcubed;
zeta = CT.D2R(CT.DMS2D(0, 0, zeta));
double phi = (2004.3109 - 0.8533 * T - 0.000217 * Tsquared) * t - (0.42665 + 0.000217 * T) * tsquared - 0.041833 * tcubed;
phi = CT.D2R(CT.DMS2D(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);
COR @value = new COR();
@value.X = CT.R2H(Math.Atan2(A, B) + zeta);
if (@value.X < 0)
{
@value.X += 24;
}
@value.Y = CT.R2D(Math.Asin(C));
return(@value);
}
public static COR 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 = CT.D2R(Lambda);
Beta = CT.D2R(Beta);
double eta = (47.0029 - 0.06603 * T + 0.000598 * Tsquared) * t + (-0.03302 + 0.000598 * T) * tsquared + 0.00006 * tcubed;
eta = CT.D2R(CT.DMS2D(0, 0, eta));
double pi = 174.876384 * 3600 + 3289.4789 * T + 0.60622 * Tsquared - (869.8089 + 0.50491 * T) * t + 0.03536 * tsquared;
pi = CT.D2R(CT.DMS2D(0, 0, pi));
double p = (5029.0966 + 2.22226 * T - 0.000042 * Tsquared) * t + (1.11113 - 0.000042 * T) * tsquared - 0.000006 * tcubed;
p = CT.D2R(CT.DMS2D(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);
COR @value = new COR();
@value.X = CT.R2D(p + pi - Math.Atan2(A, B));
if (@value.X < 0)
{
@value.X += 360;
}
@value.Y = CT.R2D(Math.Asin(C));
return(@value);
}
public static COR 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 = CT.H2R(Alpha);
Delta = CT.D2R(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;
COR @value = new COR();
@value.X = CT.R2H(Math.Atan2(y, x));
if (@value.X < 0)
{
@value.X += 24;
}
@value.Y = CT.R2D(Math.Atan2(z, Math.Sqrt(x * x + y * y)));
return(@value);
}
public static COR 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 = CT.H2R(Alpha);
Delta = CT.D2R(Delta);
double sigma = (2304.250 + 1.396 * T) * t + 0.302 * tsquared + 0.018 * tcubed;
sigma = CT.D2R(CT.DMS2D(0, 0, sigma));
double zeta = 0.791 * tsquared + 0.001 * tcubed;
zeta = CT.D2R(CT.DMS2D(0, 0, zeta));
zeta += sigma;
double phi = (2004.682 - 0.853 * T) * t - 0.426 * tsquared - 0.042 * tcubed;
phi = CT.D2R(CT.DMS2D(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);
COR @value = new COR();
@value.X = CT.R2H(Math.Atan2(A, B) + zeta);
if (@value.X < 0)
{
@value.X += 24;
}
@value.Y = CT.R2D(Math.Asin(C));
return(@value);
}
public static COR EclipticAberration(double Lambda, double Beta, double JD)
{
//What is the return value
COR aberration = new COR();
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 = CT.D2R(pi);
Lambda = CT.D2R(Lambda);
Beta = CT.D2R(Beta);
SunLongitude = CT.D2R(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 COR EclipticAberration(double Lambda, double Beta, double JD)
{
//What is the return value
COR aberration = new COR();
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 = CT.D2R(pi);
Lambda = CT.D2R(Lambda);
Beta = CT.D2R(Beta);
SunLongitude = CT.D2R(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 COR 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 = CT.H2R(Alpha);
Delta = CT.D2R(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;
COR @value = new COR();
@value.X = CT.R2H(Math.Atan2(y, x));
if (@value.X < 0)
@value.X += 24;
@value.Y = CT.R2D(Math.Atan2(z, Math.Sqrt(x *x + y *y)));
return @value;
}
// was Ecliptic2Equatorial
public static COR Ec2Eq(double Lambda, double Beta, double Epsilon)
{
Lambda = D2R(Lambda);
Beta = D2R(Beta);
Epsilon = D2R(Epsilon);
COR Equatorial = new COR();
Equatorial.X = R2H(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 = R2D(Math.Asin(Math.Sin(Beta)*Math.Cos(Epsilon) + Math.Cos(Beta)*Math.Sin(Epsilon)*Math.Sin(Lambda)));
return Equatorial;
}
private static void MakeEclipticText()
{
int year = SpaceTimeController.Now.GetUTCFullYear();
if (EclipOvTextBatch == null)
{
EclipOvTextBatch = new Text3dBatch(80);
EclipticTextYear = year;
double obliquity = Coordinates.MeanObliquityOfEcliptic(SpaceTimeController.JNow);
Matrix3d mat = Matrix3d.RotationX((-obliquity / 360.0 * (Math.PI * 2)));
double daysPerYear = 365.25;
if (DT.IsLeap(year, true))
{
monthDays[1] = 29;
daysPerYear = 366;
}
else
{
monthDays[1] = 28;
daysPerYear = 365;
}
int count = 2 * (int)daysPerYear;
EclipticCount = (int)daysPerYear;
double jYear = SpaceTimeController.UtcToJulian(new Date(year, 0, 1, 12, 0, 0));
int index = 0;
double d = 0;
for (int m = 0; m < 12; m++)
{
int daysThisMonth = (int)monthDays[m];
for (int i = 0; i < daysThisMonth; i++)
{
AstroRaDec sunRaDec = Planets.GetPlanetLocationJD("Sun", jYear);
COR sunEcliptic = CT.Eq2Ec(sunRaDec.RA, sunRaDec.Dec, obliquity);
d = sunEcliptic.X;
double dd = d;// +180;
if (i == Math.Floor(daysThisMonth / 2.0))
{
Vector3d center = Vector3d.TransformCoordinate(Vector3d.Create((Math.Cos((dd * Math.PI * 2.0) / 360)),
.025f,
(Math.Sin((dd * Math.PI * 2.0) / 360))), mat);
Vector3d up = Vector3d.TransformCoordinate(Vector3d.Create((Math.Cos((dd * Math.PI * 2.0) / 360)),
.045f,
(Math.Sin((dd * Math.PI * 2.0) / 360))), mat);
up.Subtract(center);
up.Normalize();
EclipOvTextBatch.Add(new Text3d(center, up, monthNames[m], 80, .000159375));
}
index++;
index++;
jYear += 1;
}
d += monthDays[m];
}
}
}
public static COR Create(double x, double y)
{
COR item = new COR();
item.X = x;
item.Y = y;
return item;
}
// was Horizontal2Equatorial
public static COR H2Eq(double Azimuth, double Altitude, double Latitude)
{
//Convert from degress to radians
Azimuth = D2R(Azimuth);
Altitude = D2R(Altitude);
Latitude = D2R(Latitude);
COR Equatorial = new COR();
Equatorial.X = R2H(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 = R2D(Math.Asin(Math.Sin(Latitude)*Math.Sin(Altitude) - Math.Cos(Latitude)*Math.Cos(Altitude)*Math.Cos(Azimuth)));
return Equatorial;
}
// was Galactic2Equatorial
public static COR G2Eq(double l, double b)
{
l -= 123;
l = D2R(l);
b = D2R(b);
COR Equatorial = new COR();
Equatorial.X = R2D(Math.Atan2(Math.Sin(l), Math.Cos(l)*Math.Sin(D2R(27.4)) - Math.Tan(b)*Math.Cos(D2R(27.4))));
Equatorial.X += 12.25;
if (Equatorial.X < 0)
Equatorial.X += 360;
Equatorial.X = D2H(Equatorial.X);
Equatorial.Y = R2D(Math.Asin(Math.Sin(b)*Math.Sin(D2R(27.4)) + Math.Cos(b)*Math.Cos(D2R(27.4))*Math.Cos(l)));
return Equatorial;
}
//Conversion functions
public static COR 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 = CT.D2R(Delta);
double cosDelta = Math.Cos(Delta);
//Calculate the Parallax
double pi = Math.Asin(GFX.g_AAParallax_C1 / Distance);
//Calculate the hour angle
double H = CT.H2R(theta - Longitude/15 - Alpha);
double cosH = Math.Cos(H);
double sinH = Math.Sin(H);
COR DeltaTopocentric = new COR();
DeltaTopocentric.X = CT.R2H(-pi *RhoCosThetaPrime *sinH/cosDelta);
DeltaTopocentric.Y = CT.R2D(-pi*(RhoSinThetaPrime *cosDelta - RhoCosThetaPrime *cosH *Math.Sin(Delta)));
return DeltaTopocentric;
}
public static AstroRaDec J2000ToGalactic(double ra, double dec)
{
COR galactic = CT.Eq2G(ra, dec);
return(new AstroRaDec(galactic.X, galactic.Y, 0, false, false));
}
public static COR 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 = CT.H2R(Alpha);
Delta = CT.D2R(Delta);
double sigma = (2304.250 + 1.396 *T)*t + 0.302 *tsquared + 0.018 *tcubed;
sigma = CT.D2R(CT.DMS2D(0, 0, sigma));
double zeta = 0.791 *tsquared + 0.001 *tcubed;
zeta = CT.D2R(CT.DMS2D(0, 0, zeta));
zeta += sigma;
double phi = (2004.682 - 0.853 *T)*t - 0.426 *tsquared - 0.042 *tcubed;
phi = CT.D2R(CT.DMS2D(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);
COR @value = new COR();
@value.X = CT.R2H(Math.Atan2(A, B) + zeta);
if (@value.X < 0)
@value.X += 24;
@value.Y = CT.R2D(Math.Asin(C));
return @value;
}
public static COR EquatorialAberration(double Alpha, double Delta, double JD)
{
//Convert to radians
Alpha = CT.D2R(Alpha *15);
Delta = CT.D2R(Delta);
double cosAlpha = Math.Cos(Alpha);
double sinAlpha = Math.Sin(Alpha);
double cosDelta = Math.Cos(Delta);
double sinDelta = Math.Sin(Delta);
C3D velocity = EarthVelocity(JD);
//What is the return value
COR aberration = new COR();
aberration.X = CT.R2H((velocity.Y * cosAlpha - velocity.X * sinAlpha) / (17314463350.0 * cosDelta));
aberration.Y = CT.R2D(- (((velocity.X * cosAlpha + velocity.Y * sinAlpha) * sinDelta - velocity.Z * cosDelta) / 17314463350.0));
return aberration;
}
public static COR 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 = CT.D2R(Lambda);
Beta = CT.D2R(Beta);
double eta = (47.0029 - 0.06603 *T + 0.000598 *Tsquared)*t + (-0.03302 + 0.000598 *T)*tsquared + 0.00006 *tcubed;
eta = CT.D2R(CT.DMS2D(0, 0, eta));
double pi = 174.876384 *3600 + 3289.4789 *T + 0.60622 *Tsquared - (869.8089 + 0.50491 *T)*t + 0.03536 *tsquared;
pi = CT.D2R(CT.DMS2D(0, 0, pi));
double p = (5029.0966 + 2.22226 *T - 0.000042 *Tsquared)*t + (1.11113 - 0.000042 *T)*tsquared - 0.000006 *tcubed;
p = CT.D2R(CT.DMS2D(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);
COR @value = new COR();
@value.X = CT.R2D(p + pi - Math.Atan2(A, B));
if (@value.X < 0)
@value.X += 360;
@value.Y = CT.R2D(Math.Asin(C));
return @value;
}
public static COR EquatorialPMToEcliptic(double Alpha, double Delta, double Beta, double PMAlpha, double PMDelta, double Epsilon)
{
//Convert to radians
Epsilon = CT.D2R(Epsilon);
Alpha = CT.H2R(Alpha);
Delta = CT.D2R(Delta);
Beta = CT.D2R(Beta);
double cosb = Math.Cos(Beta);
double sinEpsilon = Math.Sin(Epsilon);
COR @value = new COR();
@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 CAASaturnRingDetails Calculate(double JD)
{
//What will be the return value
CAASaturnRingDetails details = new CAASaturnRingDetails();
double T = (JD - 2451545) / 36525;
double T2 = T * T;
//Step 1. Calculate the inclination of the plane of the ring and the longitude of the ascending node referred to the ecliptic and mean equinox of the date
double i = 28.075216 - 0.012998 * T + 0.000004 * T2;
double irad = CT.D2R(i);
double omega = 169.508470 + 1.394681 * T + 0.000412 * T2;
double omegarad = CT.D2R(omega);
//Step 2. Calculate the heliocentric longitude, latitude and radius vector of the Earth in the FK5 system
double l0 = CAAEarth.EclipticLongitude(JD);
double b0 = CAAEarth.EclipticLatitude(JD);
l0 += CAAFK5.CorrectionInLongitude(l0, b0, JD);
double l0rad = CT.D2R(l0);
b0 += CAAFK5.CorrectionInLatitude(l0, JD);
double b0rad = CT.D2R(b0);
double R = CAAEarth.RadiusVector(JD);
//Step 3. Calculate the corresponding coordinates l,b,r for Saturn but for the instance t-lightraveltime
double DELTA = 9;
double PreviousEarthLightTravelTime = 0;
double EarthLightTravelTime = ELL.DistanceToLightTime(DELTA);
double JD1 = JD - EarthLightTravelTime;
bool bIterate = true;
double x = 0;
double y = 0;
double z = 0;
double l = 0;
double b = 0;
double r = 0;
while (bIterate)
{
//Calculate the position of Saturn
l = CAASaturn.EclipticLongitude(JD1);
b = CAASaturn.EclipticLatitude(JD1);
l += CAAFK5.CorrectionInLongitude(l, b, JD1);
b += CAAFK5.CorrectionInLatitude(l, JD1);
double lrad = CT.D2R(l);
double brad = CT.D2R(b);
r = CAASaturn.RadiusVector(JD1);
//Step 4
x = r * Math.Cos(brad) * Math.Cos(lrad) - R * Math.Cos(l0rad);
y = r * Math.Cos(brad) * Math.Sin(lrad) - R * Math.Sin(l0rad);
z = r * Math.Sin(brad) - R * Math.Sin(b0rad);
DELTA = Math.Sqrt(x * x + y * y + z * z);
EarthLightTravelTime = ELL.DistanceToLightTime(DELTA);
//Prepare for the next loop around
bIterate = (Math.Abs(EarthLightTravelTime - PreviousEarthLightTravelTime) > 2E-6); //2E-6 corresponds to 0.17 of a second
if (bIterate)
{
JD1 = JD - EarthLightTravelTime;
PreviousEarthLightTravelTime = EarthLightTravelTime;
}
}
//Step 5. Calculate Saturn's geocentric Longitude and Latitude
double lambda = Math.Atan2(y, x);
double beta = Math.Atan2(z, Math.Sqrt(x * x + y * y));
//Step 6. Calculate B, a and b
details.B = Math.Asin(Math.Sin(irad) * Math.Cos(beta) * Math.Sin(lambda - omegarad) - Math.Cos(irad) * Math.Sin(beta));
details.a = 375.35 / DELTA;
details.b = details.a * Math.Sin(Math.Abs(details.B));
details.B = CT.R2D(details.B);
//Step 7. Calculate the longitude of the ascending node of Saturn's orbit
double N = 113.6655 + 0.8771 * T;
double Nrad = CT.D2R(N);
double ldash = l - 0.01759 / r;
double ldashrad = CT.D2R(ldash);
double bdash = b - 0.000764 * Math.Cos(ldashrad - Nrad) / r;
double bdashrad = CT.D2R(bdash);
//Step 8. Calculate Bdash
details.Bdash = CT.R2D(Math.Asin(Math.Sin(irad) * Math.Cos(bdashrad) * Math.Sin(ldashrad - omegarad) - Math.Cos(irad) * Math.Sin(bdashrad)));
//Step 9. Calculate DeltaU
double U1 = Math.Atan2(Math.Sin(irad) * Math.Sin(bdashrad) + Math.Cos(irad) * Math.Cos(bdashrad) * Math.Sin(ldashrad - omegarad), Math.Cos(bdashrad) * Math.Cos(ldashrad - omegarad));
double U2 = Math.Atan2(Math.Sin(irad) * Math.Sin(beta) + Math.Cos(irad) * Math.Cos(beta) * Math.Sin(lambda - omegarad), Math.Cos(beta) * Math.Cos(lambda - omegarad));
details.DeltaU = CT.R2D(Math.Abs(U1 - U2));
//Step 10. Calculate the Nutations
double Obliquity = CAANutation.TrueObliquityOfEcliptic(JD);
double NutationInLongitude = CAANutation.NutationInLongitude(JD);
//Step 11. Calculate the Ecliptical longitude and latitude of the northern pole of the ring plane
double lambda0 = omega - 90;
double beta0 = 90 - i;
//Step 12. Correct lambda and beta for the aberration of Saturn
lambda += CT.D2R(0.005693 * Math.Cos(l0rad - lambda) / Math.Cos(beta));
beta += CT.D2R(0.005693 * Math.Sin(l0rad - lambda) * Math.Sin(beta));
//Step 13. Add nutation in longitude to lambda0 and lambda
//double NLrad = CAACoordinateTransformation::DegreesToRadians(NutationInLongitude/3600);
lambda = CT.R2D(lambda);
lambda += NutationInLongitude / 3600;
lambda = CT.M360(lambda);
lambda0 += NutationInLongitude / 3600;
lambda0 = CT.M360(lambda0);
//Step 14. Convert to equatorial coordinates
beta = CT.R2D(beta);
COR GeocentricEclipticSaturn = CT.Ec2Eq(lambda, beta, Obliquity);
double alpha = CT.H2R(GeocentricEclipticSaturn.X);
double delta = CT.D2R(GeocentricEclipticSaturn.Y);
COR GeocentricEclipticNorthPole = CT.Ec2Eq(lambda0, beta0, Obliquity);
double alpha0 = CT.H2R(GeocentricEclipticNorthPole.X);
double delta0 = CT.D2R(GeocentricEclipticNorthPole.Y);
//Step 15. Calculate the Position angle
details.P = CT.R2D(Math.Atan2(Math.Cos(delta0) * Math.Sin(alpha0 - alpha), Math.Sin(delta0) * Math.Cos(delta) - Math.Cos(delta0) * Math.Sin(delta) * Math.Cos(alpha0 - alpha)));
return(details);
}
// was Equatorial2Ecliptic
//Conversion functions
/////////////////////// Implementation ////////////////////////////////////////
public static COR Eq2Ec(double Alpha, double Delta, double Epsilon)
{
Alpha = H2R(Alpha);
Delta = D2R(Delta);
Epsilon = D2R(Epsilon);
COR Ecliptic = new COR();
Ecliptic.X = R2D(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 = R2D(Math.Asin(Math.Sin(Delta)*Math.Cos(Epsilon) - Math.Cos(Delta)*Math.Sin(Epsilon)*Math.Sin(Alpha)));
return Ecliptic;
}
//Static methods
public static COR 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 = CT.H2R(Alpha);
Delta = CT.D2R(Delta);
double sigma = (2306.2181 + 1.39656 *T - 0.000139 *Tsquared)*t + (0.30188 - 0.0000344 *T)*tsquared + 0.017988 *tcubed;
sigma = CT.D2R(CT.DMS2D(0, 0, sigma));
double zeta = (2306.2181 + 1.39656 *T - 0.000138 *Tsquared)*t + (1.09468 + 0.000066 *T)*tsquared + 0.018203 *tcubed;
zeta = CT.D2R(CT.DMS2D(0, 0, zeta));
double phi = (2004.3109 - 0.8533 *T - 0.000217 *Tsquared)*t - (0.42665 + 0.000217 *T)*tsquared - 0.041833 *tcubed;
phi = CT.D2R(CT.DMS2D(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);
COR @value = new COR();
@value.X = CT.R2H(Math.Atan2(A, B) + zeta);
if (@value.X < 0)
@value.X += 24;
@value.Y = CT.R2D(Math.Asin(C));
return @value;
}
// was Equatorial2Galactic
public static COR Eq2G(double Alpha, double Delta)
{
Alpha = 192.25 - H2D(Alpha);
Alpha = D2R(Alpha);
Delta = D2R(Delta);
COR Galactic = new COR();
Galactic.X = R2D(Math.Atan2(Math.Sin(Alpha), Math.Cos(Alpha)*Math.Sin(D2R(27.4)) - Math.Tan(Delta)*Math.Cos(D2R(27.4))));
Galactic.X = 303 - Galactic.X;
if (Galactic.X >= 360)
Galactic.X -= 360;
Galactic.Y = R2D(Math.Asin(Math.Sin(Delta)*Math.Sin(D2R(27.4)) + Math.Cos(Delta)*Math.Cos(D2R(27.4))*Math.Cos(Alpha)));
return Galactic;
}
public static AstroRaDec GetPlanet(double jDate, EO planetIn, double locLat, double locLong, double locHeight)
{
int planet = (int)planetIn;
//C++ TO C# CONVERTER NOTE: This static local variable declaration (not allowed in C#) has been moved just prior to the method:
// static CAAGalileanMoonsDetails galDetails;
//C++ TO C# CONVERTER NOTE: This static local variable declaration (not allowed in C#) has been moved just prior to the method:
// static CAAEllipticalPlanetaryDetails jupDetails;
//C++ TO C# CONVERTER NOTE: This static local variable declaration (not allowed in C#) has been moved just prior to the method:
// static CAAPhysicalJupiterDetails jupPhisical;
//C++ TO C# CONVERTER NOTE: This static local variable declaration (not allowed in C#) has been moved just prior to the method:
// static double jDateLast = 0;
locLong = -locLong;
if (planet < 9)
{
EPD Details = ELL.Calculate(jDate, planetIn);
COR corrected = CAAParallax.Equatorial2Topocentric(Details.ApparentGeocentricRA, Details.ApparentGeocentricDeclination, Details.ApparentGeocentricDistance, locLong, locLat, locHeight, jDate);
return(new AstroRaDec(corrected.X, corrected.Y, Details.ApparentGeocentricDistance, false, false));
}
else if (planet == 9)
{
double lat = CAAMoon.EclipticLatitude(jDate);
double lng = CAAMoon.EclipticLongitude(jDate);
double dis = CAAMoon.RadiusVector(jDate) / 149598000;
double epsilon = CAANutation.TrueObliquityOfEcliptic(jDate);
COR d = CT.Ec2Eq(lng, lat, epsilon);
COR corrected = CAAParallax.Equatorial2Topocentric(d.X, d.Y, dis, locLong, locLat, locHeight, jDate);
return(new AstroRaDec(corrected.X, corrected.Y, dis, false, false));
}
else
{
if (jDate != jDateLast)
{
jupDetails = ELL.Calculate(jDate, (EO)4);
jupPhisical = CAAPhysicalJupiter.Calculate(jDate);
COR corrected = CAAParallax.Equatorial2Topocentric(jupDetails.ApparentGeocentricRA, jupDetails.ApparentGeocentricDeclination, jupDetails.ApparentGeocentricDistance, locLong, locLat, locHeight, jDate);
jupDetails.ApparentGeocentricRA = corrected.X;
jupDetails.ApparentGeocentricDeclination = corrected.Y;
galDetails = GM.Calculate(jDate);
jDateLast = jDate;
}
double jupiterDiameter = 0.000954501;
double scale = (Math.Atan(.5 * (jupiterDiameter / jupDetails.ApparentGeocentricDistance))) / 3.1415927 * 180;
double raScale = (scale / Math.Cos(jupDetails.ApparentGeocentricDeclination / 180.0 * 3.1415927)) / 15;
double xMoon = 0;
double yMoon = 0;
double zMoon = 0;
bool shadow = false;
bool eclipsed = false;
switch (planet)
{
case 10: // IO
xMoon = galDetails.Satellite1.ApparentRectangularCoordinates.X;
yMoon = galDetails.Satellite1.ApparentRectangularCoordinates.Y;
zMoon = galDetails.Satellite1.ApparentRectangularCoordinates.Z;
eclipsed = galDetails.Satellite1.bInEclipse;
shadow = galDetails.Satellite1.bInShadowTransit;
break;
case 11: //Europa
xMoon = galDetails.Satellite2.ApparentRectangularCoordinates.X;
yMoon = galDetails.Satellite2.ApparentRectangularCoordinates.Y;
zMoon = galDetails.Satellite2.ApparentRectangularCoordinates.Z;
eclipsed = galDetails.Satellite2.bInEclipse;
shadow = galDetails.Satellite2.bInShadowTransit;
break;
case 12: //Ganymede
xMoon = galDetails.Satellite3.ApparentRectangularCoordinates.X;
yMoon = galDetails.Satellite3.ApparentRectangularCoordinates.Y;
zMoon = galDetails.Satellite3.ApparentRectangularCoordinates.Z;
eclipsed = galDetails.Satellite3.bInEclipse;
shadow = galDetails.Satellite3.bInShadowTransit;
break;
case 13: //Callisto
xMoon = galDetails.Satellite4.ApparentRectangularCoordinates.X;
yMoon = galDetails.Satellite4.ApparentRectangularCoordinates.Y;
zMoon = galDetails.Satellite4.ApparentRectangularCoordinates.Z;
eclipsed = galDetails.Satellite4.bInEclipse;
shadow = galDetails.Satellite4.bInShadowTransit;
break;
case 14: // IO Shadow
xMoon = galDetails.Satellite1.ApparentShadowRectangularCoordinates.X;
yMoon = galDetails.Satellite1.ApparentShadowRectangularCoordinates.Y;
zMoon = galDetails.Satellite1.ApparentShadowRectangularCoordinates.Z * .9;
shadow = galDetails.Satellite1.bInShadowTransit;
break;
case 15: //Europa Shadow
xMoon = galDetails.Satellite2.ApparentShadowRectangularCoordinates.X;
yMoon = galDetails.Satellite2.ApparentShadowRectangularCoordinates.Y;
zMoon = galDetails.Satellite2.ApparentShadowRectangularCoordinates.Z * .9;
shadow = galDetails.Satellite2.bInShadowTransit;
break;
case 16: //Ganymede Shadow
xMoon = galDetails.Satellite3.ApparentShadowRectangularCoordinates.X;
yMoon = galDetails.Satellite3.ApparentShadowRectangularCoordinates.Y;
zMoon = galDetails.Satellite3.ApparentShadowRectangularCoordinates.Z * .9;
shadow = galDetails.Satellite3.bInShadowTransit;
break;
case 17: //Callisto Shadow
xMoon = galDetails.Satellite4.ApparentShadowRectangularCoordinates.X;
yMoon = galDetails.Satellite4.ApparentShadowRectangularCoordinates.Y;
zMoon = galDetails.Satellite4.ApparentShadowRectangularCoordinates.Z * .9;
shadow = galDetails.Satellite4.bInShadowTransit;
break;
}
double xTemp;
double yTemp;
double radians = jupPhisical.P / 180.0 * 3.1415927;
xTemp = xMoon * Math.Cos(radians) - yMoon * Math.Sin(radians);
yTemp = xMoon * Math.Sin(radians) + yMoon * Math.Cos(radians);
xMoon = xTemp;
yMoon = yTemp;
return(new AstroRaDec(jupDetails.ApparentGeocentricRA - (xMoon * raScale), jupDetails.ApparentGeocentricDeclination + yMoon * scale, jupDetails.ApparentGeocentricDistance + (zMoon * jupiterDiameter / 2), shadow, eclipsed));
}
}
// was Equatorial2Horizontal
public static COR Eq2H(double LocalHourAngle, double Delta, double Latitude)
{
LocalHourAngle = H2R(LocalHourAngle);
Delta = D2R(Delta);
Latitude = D2R(Latitude);
COR Horizontal = new COR();
Horizontal.X = R2D(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 = R2D(Math.Asin(Math.Sin(Latitude)*Math.Sin(Delta) + Math.Cos(Latitude)*Math.Cos(Delta)*Math.Cos(LocalHourAngle)));
return Horizontal;
}