public void Equatorial2EclipticTest(double alpha, double delta, double epsilon, double expectedX, double expectedY)
{
AAS2DCoordinate Ecliptic = AASCoordinateTransformation.Equatorial2Ecliptic(alpha, delta, epsilon);
Assert.Equal(expectedX, Ecliptic.X);
Assert.Equal(expectedY, Ecliptic.Y);
}
public void Equatorial2TopocentricDeltaTest(double alpha, double delta, double distance, double longitude, double latitude, double height, double jd, double expectedX, double expectedY)
{
AAS2DCoordinate topocentricDelta = AASParallax.Equatorial2TopocentricDelta(alpha, delta, distance, longitude, latitude, height, jd);
Assert.Equal(expectedX, topocentricDelta.X);
Assert.Equal(expectedY, topocentricDelta.Y);
}
public static AAS2DCoordinate SunPosition(DateTime dateTime)
{
var bHighPrecision = false;
dateTime = dateTime.ToUniversalTime(); // NOTE: time must be converted to Universal Time
//Calculate the topocentric horizontal position of the Sun
AASDate dateSunCalc = new AASDate(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second, true);
double JDSun = dateSunCalc.Julian + AASDynamicalTime.DeltaT(dateSunCalc.Julian) / 86400.0;
double SunLong = AASSun.ApparentEclipticLongitude(JDSun, bHighPrecision);
double SunLat = AASSun.ApparentEclipticLatitude(JDSun, bHighPrecision);
AAS2DCoordinate Equatorial = AASCoordinateTransformation.Ecliptic2Equatorial(SunLong, SunLat, AASNutation.TrueObliquityOfEcliptic(JDSun));
double SunRad = AASEarth.RadiusVector(JDSun, bHighPrecision);
AAS2DCoordinate SunTopo = AASParallax.Equatorial2Topocentric(Equatorial.X, Equatorial.Y, SunRad, RT_LONG, RT_LAT, RT_HEIGHT, JDSun);
double AST = AASSidereal.ApparentGreenwichSiderealTime(dateSunCalc.Julian);
double LongtitudeAsHourAngle = AASCoordinateTransformation.DegreesToHours(RT_LONG);
double LocalHourAngle = AST - LongtitudeAsHourAngle - SunTopo.X;
AAS2DCoordinate SunHorizontal = AASCoordinateTransformation.Equatorial2Horizontal(LocalHourAngle, SunTopo.Y, RT_LAT);
SunHorizontal.Y += AASRefraction.RefractionFromTrue(SunHorizontal.Y, 1013, 10);
//The result above should be that we have a setting Sun at Y degrees above the horizon at azimuth X degrees south of the westerly horizon
//NOTE: for azimuth west is considered positive, to get east as positive subtract the result from 360
return(SunHorizontal);
}
public void MoonPositionTest()
{
AAS2DCoordinate moonPos = CelestialLocation.CelestialObjectSwitch(CelestialLocation.CelestialObjectEnum.Moon, testDate);
Assert.IsTrue(moonPos.X == 242.21120161301471);
Assert.IsTrue(moonPos.Y == -21.999140976834383);
}
public void Equatorial2HorizontalTest(double localHourAngle, double delta, double latitude, double expectedX, double expectedY)
{
AAS2DCoordinate horizontal = AASCoordinateTransformation.Equatorial2Horizontal(localHourAngle, delta, latitude);
Assert.Equal(expectedX, horizontal.X);
Assert.Equal(expectedY, horizontal.Y);
}
public void Horizontal2EquatorialTest(double azimuth, double altitude, double latitude, double expectedX, double expectedY)
{
AAS2DCoordinate horizontal = AASCoordinateTransformation.Horizontal2Equatorial(azimuth, altitude, latitude);
Assert.Equal(expectedX, horizontal.X);
Assert.Equal(expectedY, horizontal.Y);
}
public void SunPositionTest()
{
AAS2DCoordinate sunPos = CelestialLocation.CelestialObjectSwitch(CelestialLocation.CelestialObjectEnum.Sun, testDate);
Assert.IsTrue(sunPos.X == 269.57123926548138);
Assert.IsTrue(sunPos.Y == 33.628720015243417);
}
public static AAS2DCoordinate Equatorial2Topocentric(double Alpha, double Delta, double Distance, double Longitude, double Latitude, double Height, double JD)
{
double RhoSinThetaPrime = AASGlobe.RhoSinThetaPrime(Latitude, Height);
double RhoCosThetaPrime = AASGlobe.RhoCosThetaPrime(Latitude, Height);
//Calculate the Sidereal time
double theta = AASSidereal.ApparentGreenwichSiderealTime(JD);
//Convert to radians
Delta = AASCoordinateTransformation.DegreesToRadians(Delta);
double cosDelta = Math.Cos(Delta);
//Calculate the Parallax
double pi = Math.Asin(g_AAParallax_C1 / Distance);
double sinpi = Math.Sin(pi);
//Calculate the hour angle
double H = AASCoordinateTransformation.HoursToRadians(theta - Longitude / 15 - Alpha);
double cosH = Math.Cos(H);
double sinH = Math.Sin(H);
//Calculate the adjustment in right ascension
double DeltaAlpha = Math.Atan2(-RhoCosThetaPrime * sinpi * sinH, cosDelta - RhoCosThetaPrime * sinpi * cosH);
AAS2DCoordinate Topocentric = new AAS2DCoordinate { X = AASCoordinateTransformation.MapTo0To24Range(Alpha + AASCoordinateTransformation.RadiansToHours(DeltaAlpha)), Y = AASCoordinateTransformation.RadiansToDegrees(Math.Atan2((Math.Sin(Delta) - RhoSinThetaPrime * sinpi) * Math.Cos(DeltaAlpha), cosDelta - RhoCosThetaPrime * sinpi * cosH)) };
return Topocentric;
}
protected void CorrectForFK5SystemReduction()
{
double appGeoLon = GetGeocentricLongitude(vectorToEarthCorrected.x, vectorToEarthCorrected.y);
double appGeoLat = GetGeocentricLatitude(vectorToEarthCorrected.x, vectorToEarthCorrected.y, vectorToEarthCorrected.z);
double deltaLambdaFK5 = AASFK5.CorrectionInLongitude(appGeoLon, appGeoLat, jdeCorrected);
double deltaBetaFK5 = AASFK5.CorrectionInLatitude(appGeoLon, jdeCorrected);
lambdaFK5 = lambdaAberration + deltaLambdaFK5;
betaFK5 = betaAberration + deltaBetaFK5;
//correct for nutation
double deltaPhi = AASNutation.NutationInLongitude(jdeCorrected) / 3600;
double deltaEpsilon = AASNutation.NutationInObliquity(jdeCorrected) / 3600;
epsilon = AASNutation.TrueObliquityOfEcliptic(jdeCorrected);
double lambdaNutation = lambdaFK5 + deltaPhi;
double betaNutation = betaFK5 + deltaEpsilon;
//x=RA in decimal hours, y=dec in degrees
AAS2DCoordinate equatorial = AASCoordinateTransformation.Ecliptic2Equatorial(lambdaNutation, betaNutation, epsilon);
equatorialCoords.RA = new HourAngle(equatorial.X);
equatorialCoords.Declination = new DegreesAngle(equatorial.Y);
}
public Coordinate OrientationToCoordinate(Orientation currHorizontal, DateTime datetime)
{
// We don't want to modify the current orientation, so we must create a new instance
Orientation horizontal = (Orientation)currHorizontal.Clone();
if (horizontal == null)
{
throw new ArgumentException("Orientation cannot be null");
}
// Since AASharp considers south zero, flip the orientation 180 degrees
horizontal.Azimuth += 180;
if (horizontal.Azimuth > 360)
{
horizontal.Azimuth -= 360;
}
AAS2DCoordinate equatorial = AASCoordinateTransformation.Horizontal2Equatorial(horizontal.Azimuth, horizontal.Elevation, Location.Latitude);
AASDate date = new AASDate(datetime.Year, datetime.Month, datetime.Day, datetime.Hour, datetime.Minute, datetime.Second, true);
double ApparentGreenwichSiderealTime = AASSidereal.ApparentGreenwichSiderealTime(date.Julian);
double LongtitudeAsHourAngle = AASCoordinateTransformation.DegreesToHours(Location.Longitude);
double RightAscension = ApparentGreenwichSiderealTime - LongtitudeAsHourAngle - equatorial.X;
if (RightAscension < 0)
{
RightAscension += 24;
}
return(new Coordinate(RightAscension, equatorial.Y));
}
public static AAS2DCoordinate MoonPosition(DateTime dateTime)
{
dateTime = dateTime.ToUniversalTime(); // NOTE: time must be converted to Universal Time
//Calculate the topocentric horizontal position of the Moon
AASDate dateMoonCalc = new AASDate(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second, true);
double JDMoon = dateMoonCalc.Julian + AASDynamicalTime.DeltaT(dateMoonCalc.Julian) / 86400.0;
double MoonLong = AASMoon.EclipticLongitude(JDMoon);
double MoonLat = AASMoon.EclipticLatitude(JDMoon);
AAS2DCoordinate Equatorial = AASCoordinateTransformation.Ecliptic2Equatorial(MoonLong, MoonLat, AASNutation.TrueObliquityOfEcliptic(JDMoon));
double MoonRad = AASMoon.RadiusVector(JDMoon);
MoonRad /= 149597870.691; //Convert KM to AU
AAS2DCoordinate MoonTopo = AASParallax.Equatorial2Topocentric(Equatorial.X, Equatorial.Y, MoonRad, RT_LONG, RT_LAT, RT_HEIGHT, JDMoon);
double AST = AASSidereal.ApparentGreenwichSiderealTime(dateMoonCalc.Julian);
double LongtitudeAsHourAngle = AASCoordinateTransformation.DegreesToHours(RT_LONG);
double LocalHourAngle = AST - LongtitudeAsHourAngle - MoonTopo.X;
AAS2DCoordinate MoonHorizontal = AASCoordinateTransformation.Equatorial2Horizontal(LocalHourAngle, MoonTopo.Y, RT_LAT);
MoonHorizontal.Y += AASRefraction.RefractionFromTrue(MoonHorizontal.Y, 1013, 10);
//The result above should be that we have a rising Moon at Y degrees above the horizon at azimuth X degrees east of the southern horizon
//NOTE: for azimuth west is considered positive, to get east as positive subtract the result from 360
return(MoonHorizontal);
}
public void SunPositionTest()
{
AAS2DCoordinate sunPos = CelestialLocation.SunPosition(testTime);
Assert.IsTrue(sunPos.X > 270 && sunPos.X < 271.00);
Assert.IsTrue(sunPos.Y > 33.00 && sunPos.Y < 34.00);
}
public static AAS2DCoordinate AdjustPositionUsingMotionInSpace(double r, double DeltaR, double t, double Alpha, double Delta, double PMAlpha, double PMDelta)
{
//Convert DeltaR from km/s to Parsecs / Year
DeltaR /= 977792;
//Convert from seconds of time to Radians / Year
PMAlpha /= 13751;
//Convert from seconds of arc to Radians / Year
PMDelta /= 206265;
//Now convert to radians
Alpha = AASCoordinateTransformation.HoursToRadians(Alpha);
Delta = AASCoordinateTransformation.DegreesToRadians(Delta);
double x = r * Math.Cos(Delta) * Math.Cos(Alpha);
double y = r * Math.Cos(Delta) * Math.Sin(Alpha);
double z = r * Math.Sin(Delta);
double DeltaX = x / r * DeltaR - z * PMDelta * Math.Cos(Alpha) - y * PMAlpha;
double DeltaY = y / r * DeltaR - z * PMDelta * Math.Sin(Alpha) + x * PMAlpha;
double DeltaZ = z / r * DeltaR + r * PMDelta * Math.Cos(Delta);
x += t * DeltaX;
y += t * DeltaY;
z += t * DeltaZ;
AAS2DCoordinate value = new AAS2DCoordinate { X = AASCoordinateTransformation.RadiansToHours(Math.Atan2(y, x)) };
if (value.X < 0)
value.X += 24;
value.Y = AASCoordinateTransformation.RadiansToDegrees(Math.Atan2(z, Math.Sqrt(x * x + y * y)));
return value;
}
void Log()
{
Debug.Log("------- SUN ------- ");
Debug.Log(string.Format("JD: {0}", dt.JulianDay()));
Debug.Log(string.Format("Time: {0}:{1}:{2}", dt.Hour(), dt.Minute(), dt.Second()));
skyModel.GetSun().Log();
HourAngle H = new HourAngle(skyModel.GetSun().localHourAngle);
Debug.Log(string.Format("H {0}", H.ToString()));
AAS2DCoordinate local = AASCoordinateTransformation.Equatorial2Horizontal(skyModel.GetSun().localHourAngle,
skyModel.GetSun().EquatorialCoords.Declination.Get(),
location.Latitude);
Debug.Log(string.Format("local X {0}", local.X));
Debug.Log(string.Format("local Y {0}", local.Y));
Debug.Log("------- VENUS ------- ");
VenusModel venus = skyModel.GetPlanets() ["Venus"] as VenusModel;
venus.Log();
Debug.Log("------- MOON ------- ");
MoonModel moon = skyModel.GetMoon();
moon.Log();
Debug.Log("------- JUPITER ------- ");
JupiterModel jup = skyModel.GetPlanets()["Jupiter"] as JupiterModel;
Debug.Log("p " + jup.GetParallacticAngle());
}
public void PrecessEquatorialTest(double alpha, double delta, double jd0, double jd, double expectedX, double expectedY)
{
AAS2DCoordinate precessed = AASPrecession.PrecessEquatorial(alpha, delta, jd0, jd);
Assert.Equal(expectedX, precessed.X);
Assert.Equal(expectedY, precessed.Y);
}
public void EquatorialPmToEclipticTest()
{
AAS2DCoordinate pm = AASPrecession.EquatorialPMToEcliptic(0, 0, 0, 1, 1, 23);
Assert.Equal(1.3112359819417141, pm.X);
Assert.Equal(0.52977372496316666, pm.Y);
}
public void AdjustPositionUsingUniformProperMotionTest(double t, double alpha, double delta, double PMAlpha, double PMDelta, double expectedX, double expectedY)
{
AAS2DCoordinate pa = AASPrecession.AdjustPositionUsingUniformProperMotion(t, alpha, delta, PMAlpha, PMDelta);
Assert.Equal(expectedX, pa.X);
Assert.Equal(expectedY, pa.Y);
}
public void Equatorial2GalacticTest(double alpha, double delta, double expectedX, double expectedY)
{
AAS2DCoordinate galactic = AASCoordinateTransformation.Equatorial2Galactic(alpha, delta);
Assert.Equal(expectedX, galactic.X);
Assert.Equal(expectedY, galactic.Y);
}
public void Galactic2EquatorialTest(double l, double b, double expectedX, double expectedY)
{
AAS2DCoordinate equatorial = AASCoordinateTransformation.Galactic2Equatorial(l, b);
Assert.Equal(expectedX, equatorial.X);
Assert.Equal(expectedY, equatorial.Y);
}
public void PrecessEclipticTest(double lambda, double beta, double jd0, double jd, double expectedX, double expectedY)
{
AAS2DCoordinate coordinates = AASPrecession.PrecessEcliptic(lambda, beta, jd0, jd);
Assert.Equal(expectedX, coordinates.X);
Assert.Equal(expectedY, coordinates.Y);
}
public EquatorialCoords Horizontal2Equatorial(double azimuth, double altitude){
AAS2DCoordinate coords = AASCoordinateTransformation.Horizontal2Equatorial (azimuth+180, altitude, location.latitude);
//right ascension (alpha) = apparent sidereal time at Greenwich (theta) - Local hour angle (H) - observer's longitude (L, positive west, negative east from Greenwich)
double theta0Apparent = AASSidereal.ApparentGreenwichSiderealTime (jd);
double ra = theta0Apparent - coords.X - location.longitude / 15d;
return new EquatorialCoords(new HourAngle(ra), new DegreesAngle( coords.Y ));
}
public LocalCoords Equatorial2Horizontal(double ra, double dec){
double theta0Apparent = AASSidereal.ApparentGreenwichSiderealTime (jd);
//hour angle in hours
double H = theta0Apparent - location.longitude/15d - ra;
AAS2DCoordinate localCoords = AASCoordinateTransformation.Equatorial2Horizontal (H, dec, location.latitude);
double azimuth = AASCoordinateTransformation.MapTo0To360Range (localCoords.X + 180d);
return new LocalCoords(new DegreesAngle(azimuth), new DegreesAngle(localCoords.Y));
}
private void CalculateEquatorialPosition()
{
DegreesAngle ecLon = new DegreesAngle(AASMoon.EclipticLongitude(jd));
DegreesAngle ecLat = new DegreesAngle(AASMoon.EclipticLatitude(jd));
double epsilon = AASNutation.TrueObliquityOfEcliptic(jd);
AAS2DCoordinate eq = AASCoordinateTransformation.Ecliptic2Equatorial(ecLon.Get(), ecLat.Get(), epsilon);
equatorialCoords.RA = new HourAngle(eq.X);
equatorialCoords.Declination = new DegreesAngle(eq.Y);
}
public static AAS2DCoordinate Ecliptic2Equatorial(double Lambda, double Beta, double Epsilon)
{
Lambda = DegreesToRadians(Lambda);
Beta = DegreesToRadians(Beta);
Epsilon = DegreesToRadians(Epsilon);
AAS2DCoordinate Equatorial = new AAS2DCoordinate { 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;
}
protected void CalculateTopocentricPosition()
{
double theta0Apparent = AASSidereal.ApparentGreenwichSiderealTime(jd);
//hour angle in hours
localHourAngle = theta0Apparent - location.longitude / 15d - equatorialCoords.RA.Get();
AAS2DCoordinate local = AASCoordinateTransformation.Equatorial2Horizontal(localHourAngle, equatorialCoords.Declination.Get(), location.latitude);
localCoords.Azimuth = DegreesAngle.FromDecimalTo0To360Range(180.0f + local.X);
localCoords.Altitude = new DegreesAngle(local.Y);
}
public static AAS2DCoordinate Equatorial2Ecliptic(double Alpha, double Delta, double Epsilon)
{
Alpha = HoursToRadians(Alpha);
Delta = DegreesToRadians(Delta);
Epsilon = DegreesToRadians(Epsilon);
AAS2DCoordinate Ecliptic = new AAS2DCoordinate { 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 AAS2DCoordinate Equatorial2Galactic(double Alpha, double Delta)
{
Alpha = 192.25 - HoursToDegrees(Alpha);
Alpha = DegreesToRadians(Alpha);
Delta = DegreesToRadians(Delta);
AAS2DCoordinate Galactic = new AAS2DCoordinate() { 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 AAS2DCoordinate EquatorialPMToEcliptic(double Alpha, double Delta, double Beta, double PMAlpha, double PMDelta, double Epsilon)
{
//Convert to radians
Epsilon = AASCoordinateTransformation.DegreesToRadians(Epsilon);
Alpha = AASCoordinateTransformation.HoursToRadians(Alpha);
Delta = AASCoordinateTransformation.DegreesToRadians(Delta);
Beta = AASCoordinateTransformation.DegreesToRadians(Beta);
double cosb = Math.Cos(Beta);
double sinEpsilon = Math.Sin(Epsilon);
AAS2DCoordinate value = new AAS2DCoordinate { X = (PMDelta * sinEpsilon * Math.Cos(Alpha) + PMAlpha * Math.Cos(Delta) * (Math.Cos(Epsilon) * Math.Cos(Delta) + sinEpsilon * Math.Sin(Delta) * Math.Sin(Alpha))) / (cosb * cosb), Y = (PMDelta * (Math.Cos(Epsilon) * Math.Cos(Delta) + sinEpsilon * Math.Sin(Delta) * Math.Sin(Alpha)) - PMAlpha * sinEpsilon * Math.Cos(Alpha) * Math.Cos(Delta)) / cosb };
return value;
}
public Coordinate GetSunCoordinate(DateTime datetime)
{
AASDate date = new AASDate(datetime.Year, datetime.Month, datetime.Day, datetime.Hour, datetime.Minute, datetime.Second, true);
double JD = date.Julian + AASDynamicalTime.DeltaT(date.Julian) / 86400.0;
double SunLong = AASSun.ApparentEclipticLongitude(JD, false);
double SunLat = AASSun.ApparentEclipticLatitude(JD, false);
AAS2DCoordinate equatorial = AASCoordinateTransformation.Ecliptic2Equatorial(SunLong, SunLat, AASNutation.TrueObliquityOfEcliptic(JD));
double SunRad = AASEarth.RadiusVector(JD, false);
// This line gives us RA & Declination.
AAS2DCoordinate SunTopo = AASParallax.Equatorial2Topocentric(equatorial.X, equatorial.Y, SunRad, Location.Longitude, Location.Latitude, Location.Altitude, JD);
return(new Coordinate(SunTopo.X, SunTopo.Y));
}
public Coordinate GetMoonCoordinate(DateTime datetime)
{
AASDate date = new AASDate(datetime.Year, datetime.Month, datetime.Day, datetime.Hour, datetime.Minute, datetime.Second, true);
double JD = date.Julian + AASDynamicalTime.DeltaT(date.Julian) / 86400.0;
double MoonLong = AASMoon.EclipticLongitude(JD);
double MoonLat = AASMoon.EclipticLatitude(JD);
AAS2DCoordinate Equatorial = AASCoordinateTransformation.Ecliptic2Equatorial(MoonLong, MoonLat, AASNutation.TrueObliquityOfEcliptic(JD));
double MoonRad = AASMoon.RadiusVector(JD);
MoonRad /= 149597870.691; //Convert KM to AU
AAS2DCoordinate MoonTopo = AASParallax.Equatorial2Topocentric(Equatorial.X, Equatorial.Y, MoonRad, Location.Longitude, Location.Latitude, Location.Altitude, JD);
return(new Coordinate(MoonTopo.X, MoonTopo.Y));
}
/*
* public LocalCoords LocalCoords(double jd, LocationData location){
* double theta0Apparent = AASSidereal.ApparentGreenwichSiderealTime (jd);
*
* //hour angle in hours
* double H = theta0Apparent - location.longitude/15d - ra;
*
* AAS2DCoordinate localCoords = AASCoordinateTransformation.Equatorial2Horizontal (H, dec, location.latitude);
* double azimuth = AASCoordinateTransformation.MapTo0To360Range (localCoords.X + 180d);
*
* return new LocalCoords(new DegreesAngle(azimuth), new DegreesAngle(localCoords.Y));
* }*/
public Vector3 GetLocalRectangularCoordinates(double jd, LocationData location)
{
double theta0Apparent = AASSidereal.ApparentGreenwichSiderealTime(jd);
//hour angle in hours
double H = theta0Apparent - location.longitude / 15d - this.ra;
AAS2DCoordinate local = AASCoordinateTransformation.Equatorial2Horizontal(H, this.dec, location.latitude);
double az = local.X;
double alt = local.Y;
double x = Math.Cos(alt * M.DEG2RAD) * Math.Sin(az * 15.0f * M.DEG2RAD);
double y = Math.Sin(alt * M.DEG2RAD);
double z = -Math.Cos(alt * M.DEG2RAD) * Math.Cos(az * 15.0f * M.DEG2RAD);
return(new Vector3((float)x, (float)y, (float)z));
}
// converts horizontal coordinates to equitorial coordinates
public static AAS2DCoordinate ToCelestialCoordinates(float lat, float lng, float az, float alt)
{
/*
* Key:
* ------------ Local Coordinates -------------
* az = azimuth - angle around the horizon from due north to under POI (north has azimuth of 0m south has azimuth of 180)
* alt = altitude - angle from the horizon where the object is.
* lat = latitude
* long = Longitude
* lst = local sideral time - Greenwich meridian plus Longitude
* lha = local hour angle - It is the angle between the meridian of your Assumed Position and the meridian of the geographical position of the celestial body.
* ------------ Equatorial Coordinates ---------------
* ra = right ascention
* dec = declination angle
* ha = hour angle - angle between local meridian projected on celestial sphere, and right ascention of body
*
*
* CALCULATING: 'right ascension' (ra) and 'declination' (dec)
* 1) sin(alt) = sin(dec)sin(lat) + cos(dec)cos(lat)cos(ha)
* 2) sin(ha) = tan(az)[cos(ha)sin(lat) - tan(dec)cos(lat)]
* 3) ra = lst - ha
*
* Rearranging leads to:
* ha = arctan(x,y)
* x = sin(lat)cos(alt)cos(az) + cos(lat)sin(alt)
* y = cos(alt)sin(az)
*
* dec = arctan(x', y')
* x' = sin(az)cos(ha)sin(lat) - sin(ha)cos(az)
* y' = cos(lat)sin(az)
*/
//find coordinates assuming sidereal_time is 00::00::00
AAS2DCoordinate converted = AASCoordinateTransformation.Horizontal2Equatorial(az, alt, lat);
//adjust for local sideral_time
converted.X += (LocalSiderealTime(lng) * (360f / 24f));
return(converted);
}
public static AAS2DCoordinate CelestialObjectSwitch(CelestialObjectEnum target, DateTime dateTime)
{
AAS2DCoordinate currentPostion = new AAS2DCoordinate();
switch (target)
{
case CelestialObjectEnum.Unspecified:
throw new Exception("Celestial Object Unspecifed");
case CelestialObjectEnum.Sun:
currentPostion = SunPosition(dateTime);
break;
case CelestialObjectEnum.Moon:
currentPostion = MoonPosition(dateTime);
break;
default:
throw new Exception("Default Case Reached");
}
return(currentPostion);
}
public Orientation CoordinateToOrientation(Coordinate coordinate, DateTime datetime)
{
if (coordinate == null)
{
throw new ArgumentException("Coordinate cannot be null");
}
AASDate date = new AASDate(datetime.Year, datetime.Month, datetime.Day, datetime.Hour, datetime.Minute, datetime.Second, true);
double ApparentGreenwichSiderealTime = AASSidereal.ApparentGreenwichSiderealTime(date.Julian);
double LongtitudeAsHourAngle = AASCoordinateTransformation.DegreesToHours(Location.Longitude);
double LocalHourAngle = ApparentGreenwichSiderealTime - LongtitudeAsHourAngle - coordinate.RightAscension;
AAS2DCoordinate Horizontal = AASCoordinateTransformation.Equatorial2Horizontal(LocalHourAngle, coordinate.Declination, Location.Latitude);
// Since AASharp considers south zero, flip the orientation 180 degrees
Horizontal.X += 180;
if (Horizontal.X > 360)
{
Horizontal.X -= 360;
}
return(new Orientation(Horizontal.X, Horizontal.Y));
}
public static AAS2DCoordinate EquatorialAberration(double Alpha, double Delta, double JD)
{
//Convert to radians
Alpha = AASCoordinateTransformation.DegreesToRadians(Alpha * 15);
Delta = AASCoordinateTransformation.DegreesToRadians(Delta);
double cosAlpha = Math.Cos(Alpha);
double sinAlpha = Math.Sin(Alpha);
double cosDelta = Math.Cos(Delta);
double sinDelta = Math.Sin(Delta);
AAS3DCoordinate velocity = EarthVelocity(JD);
//What is the return value
AAS2DCoordinate aberration = new AAS2DCoordinate() { X = AASCoordinateTransformation.RadiansToHours((velocity.Y * cosAlpha - velocity.X * sinAlpha) / (17314463350.0 * cosDelta)), Y = AASCoordinateTransformation.RadiansToDegrees(-(((velocity.X * cosAlpha + velocity.Y * sinAlpha) * sinDelta - velocity.Z * cosDelta) / 17314463350.0)) };
return aberration;
}
public static AAS2DCoordinate Equatorial2TopocentricDelta(double Alpha, double Delta, double Distance, double Longitude, double Latitude, double Height, double JD)
{
double RhoSinThetaPrime = AASGlobe.RhoSinThetaPrime(Latitude, Height);
double RhoCosThetaPrime = AASGlobe.RhoCosThetaPrime(Latitude, Height);
//Calculate the Sidereal time
double theta = AASSidereal.ApparentGreenwichSiderealTime(JD);
//Convert to radians
Delta = AASCoordinateTransformation.DegreesToRadians(Delta);
double cosDelta = Math.Cos(Delta);
//Calculate the Parallax
double pi = Math.Asin(g_AAParallax_C1 / Distance);
//Calculate the hour angle
double H = AASCoordinateTransformation.HoursToRadians(theta - Longitude / 15 - Alpha);
double cosH = Math.Cos(H);
double sinH = Math.Sin(H);
AAS2DCoordinate DeltaTopocentric = new AAS2DCoordinate { X = AASCoordinateTransformation.RadiansToHours(-pi * RhoCosThetaPrime * sinH / cosDelta), Y = AASCoordinateTransformation.RadiansToDegrees(-pi * (RhoSinThetaPrime * cosDelta - RhoCosThetaPrime * cosH * Math.Sin(Delta))) };
return DeltaTopocentric;
}
public static AAS2DCoordinate Horizontal2Equatorial(double Azimuth, double Altitude, double Latitude)
{
//Convert from degress to radians
Azimuth = DegreesToRadians(Azimuth);
Altitude = DegreesToRadians(Altitude);
Latitude = DegreesToRadians(Latitude);
AAS2DCoordinate Equatorial = new AAS2DCoordinate { 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 AAS2DCoordinate Equatorial2Horizontal(double LocalHourAngle, double Delta, double Latitude)
{
LocalHourAngle = HoursToRadians(LocalHourAngle);
Delta = DegreesToRadians(Delta);
Latitude = DegreesToRadians(Latitude);
AAS2DCoordinate Horizontal = new AAS2DCoordinate { 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 AAS2DCoordinate Galactic2Equatorial(double l, double b)
{
l -= 123;
l = DegreesToRadians(l);
b = DegreesToRadians(b);
AAS2DCoordinate Equatorial = new AAS2DCoordinate { 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 AAS2DCoordinate EclipticAberration(double Lambda, double Beta, double JD)
{
//What is the return value
AAS2DCoordinate aberration = new AAS2DCoordinate();
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;
const double k = 20.49552;
double SunLongitude = AASSun.GeometricEclipticLongitude(JD);
//Convert to radians
pi = AASCoordinateTransformation.DegreesToRadians(pi);
Lambda = AASCoordinateTransformation.DegreesToRadians(Lambda);
Beta = AASCoordinateTransformation.DegreesToRadians(Beta);
SunLongitude = AASCoordinateTransformation.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 AAS2DCoordinate PrecessEquatorial(double Alpha, double Delta, double JD0, double JD)
{
double T = (JD0 - 2451545.0) / 36525;
double Tsquared = T * T;
double t = (JD - JD0) / 36525;
double tsquared = t * t;
double tcubed = tsquared * t;
//Now convert to radians
Alpha = AASCoordinateTransformation.HoursToRadians(Alpha);
Delta = AASCoordinateTransformation.DegreesToRadians(Delta);
double sigma = (2306.2181 + 1.39656 * T - 0.000139 * Tsquared) * t + (0.30188 - 0.0000344 * T) * tsquared + 0.017988 * tcubed;
sigma = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, sigma));
double zeta = (2306.2181 + 1.39656 * T - 0.000138 * Tsquared) * t + (1.09468 + 0.000066 * T) * tsquared + 0.018203 * tcubed;
zeta = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, zeta));
double phi = (2004.3109 - 0.8533 * T - 0.000217 * Tsquared) * t - (0.42665 + 0.000217 * T) * tsquared - 0.041833 * tcubed;
phi = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, phi));
double A = Math.Cos(Delta) * Math.Sin(Alpha + sigma);
double B = Math.Cos(phi) * Math.Cos(Delta) * Math.Cos(Alpha + sigma) - Math.Sin(phi) * Math.Sin(Delta);
double C = Math.Sin(phi) * Math.Cos(Delta) * Math.Cos(Alpha + sigma) + Math.Cos(phi) * Math.Sin(Delta);
AAS2DCoordinate value = new AAS2DCoordinate { X = AASCoordinateTransformation.RadiansToHours(Math.Atan2(A, B) + zeta) };
if (value.X < 0)
value.X += 24;
value.Y = AASCoordinateTransformation.RadiansToDegrees(Math.Asin(C));
return value;
}
public static AAS2DCoordinate PrecessEquatorialFK4(double Alpha, double Delta, double JD0, double JD)
{
double T = (JD0 - 2415020.3135) / 36524.2199;
double t = (JD - JD0) / 36524.2199;
double tsquared = t * t;
double tcubed = tsquared * t;
//Now convert to radians
Alpha = AASCoordinateTransformation.HoursToRadians(Alpha);
Delta = AASCoordinateTransformation.DegreesToRadians(Delta);
double sigma = (2304.250 + 1.396 * T) * t + 0.302 * tsquared + 0.018 * tcubed;
sigma = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, sigma));
double zeta = 0.791 * tsquared + 0.001 * tcubed;
zeta = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, zeta));
zeta += sigma;
double phi = (2004.682 - 0.853 * T) * t - 0.426 * tsquared - 0.042 * tcubed;
phi = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, phi));
double A = Math.Cos(Delta) * Math.Sin(Alpha + sigma);
double B = Math.Cos(phi) * Math.Cos(Delta) * Math.Cos(Alpha + sigma) - Math.Sin(phi) * Math.Sin(Delta);
double C = Math.Sin(phi) * Math.Cos(Delta) * Math.Cos(Alpha + sigma) + Math.Cos(phi) * Math.Sin(Delta);
AAS2DCoordinate value = new AAS2DCoordinate { X = AASCoordinateTransformation.RadiansToHours(Math.Atan2(A, B) + zeta) };
if (value.X < 0)
value.X += 24;
value.Y = AASCoordinateTransformation.RadiansToDegrees(Math.Asin(C));
return value;
}
public static AAS2DCoordinate AdjustPositionUsingUniformProperMotion(double t, double Alpha, double Delta, double PMAlpha, double PMDelta)
{
AAS2DCoordinate value = new AAS2DCoordinate { X = Alpha + (PMAlpha * t / 3600), Y = Delta + (PMDelta * t / 3600) };
return value;
}
public static AAS2DCoordinate PrecessEcliptic(double Lambda, double Beta, double JD0, double JD)
{
double T = (JD0 - 2451545.0) / 36525;
double Tsquared = T * T;
double t = (JD - JD0) / 36525;
double tsquared = t * t;
double tcubed = tsquared * t;
//Now convert to radians
Lambda = AASCoordinateTransformation.DegreesToRadians(Lambda);
Beta = AASCoordinateTransformation.DegreesToRadians(Beta);
double eta = (47.0029 - 0.06603 * T + 0.000598 * Tsquared) * t + (-0.03302 + 0.000598 * T) * tsquared + 0.00006 * tcubed;
eta = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, eta));
double pi = 174.876384 * 3600 + 3289.4789 * T + 0.60622 * Tsquared - (869.8089 + 0.50491 * T) * t + 0.03536 * tsquared;
pi = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, pi));
double p = (5029.0966 + 2.22226 * T - 0.000042 * Tsquared) * t + (1.11113 - 0.000042 * T) * tsquared - 0.000006 * tcubed;
p = AASCoordinateTransformation.DegreesToRadians(AASCoordinateTransformation.DMSToDegrees(0, 0, p));
double A = Math.Cos(eta) * Math.Cos(Beta) * Math.Sin(pi - Lambda) - Math.Sin(eta) * Math.Sin(Beta);
double B = Math.Cos(Beta) * Math.Cos(pi - Lambda);
double C = Math.Cos(eta) * Math.Sin(Beta) + Math.Sin(eta) * Math.Cos(Beta) * Math.Sin(pi - Lambda);
AAS2DCoordinate value = new AAS2DCoordinate { X = AASCoordinateTransformation.RadiansToDegrees(p + pi - Math.Atan2(A, B)) };
if (value.X < 0)
value.X += 360;
value.Y = AASCoordinateTransformation.RadiansToDegrees(Math.Asin(C));
return value;
}
