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