def _calc_ECI(self):
''' calc position in ECI reference from time:LMST and pos:LLA'''
self._df_clear("time") # clear dirty flags
self._df_clear("pos")
a = wgs72_complete["radiusearthkm"]
e2 = wgs72_complete["e^2"]
phi = self._geo_lat
lambd = self.sidereal_get_LMST()
h = self._geo_alti / 1000 # m to km
sin_phi = math_helper.sin_deg(phi)
cos_phi = math_helper.cos_deg(phi)
sin_lambd = math_helper.sin_deg(lambd)
cos_lambd = math_helper.cos_deg(lambd)
# [Günter Seeber, "Satellite Geodesy", 2nd edition] page 24
# N is the radius of curvature in the prime vertical:
# N = a / sqrt( 1 - (e^2)*(sin(lat)^2) )
# EQUATION (2.36)
N = a / math.sqrt(1 - e2 * (sin_phi**2))
# EQUATION (2.35)
self._eci_x = (N + h) * cos_phi * cos_lambd
self._eci_y = (N + h) * cos_phi * sin_lambd
self._eci_z = ((1 - e2) * N + h) * sin_phi
def _calc_topoc_equator_spherical(self):
''' computes [Position Angles] and [Angular Velocities]
([Right Ascencion] and [Declination])
in [TOPOcentric Equatorial Coordinate System] of the Sat
relavtive to the telescope.
(Center = [surface position],
References: [Earth axis] / [Equatorial plane] and
the direction to the [Vernal equinox].) '''
# Berechnung is aehnlich zu GEOzentrisch spherical,
# JEDOCH ist (x,y,z) der vektor vom telescop zum satelliten
# und fuer (x',y',z') muss x',y' vom teleskop berechnet werden
# -------------
# get cartesian corrdinates
xp, yp, zp = self._topocentr_equator["cartesian"]["vel"]
x, y, z = self._topocentr_equator["cartesian"]["pos"]
r = math_helper.vector_abs((x, y, z))
# -------------
# calc spherical coordinates
# -------------
# ANGULAR POSITION
Ra = math_helper.atan2_deg(y, x)
De = math_helper.asin_deg(z / r)
self._topocentr_equator["spherical"]["pos"]["Ra"] = Ra
self._topocentr_equator["spherical"]["pos"]["De"] = De
self._topocentr_equator["spherical"]["pos"]["R"] = r
# -------------
# ANGULAR VELOCITY
# x,y,z = f(t)
# r = f(t) = sqrt(x^2+y^2+z^2)
# Ra = atan(y/x)
# d( atan(y(t)/x(t)) )/dt = (x*y' - y*x')/(x^2+y^2) in rad/s
Ra_dot = math.degrees((x * yp - y * xp) / (x**2 + y**2))
# De = asin(z/r)
# d( asin(z(t)/r(t)) )/dt =
# z' - z/(r^2) * (x*x'+y*y'+z*z')
# = ------------------------------ in rad/s
# sqrt(r^2 - z^2)
De_dot = math.degrees((zp - z / (r**2) * (x * xp + y * yp + z * zp)) /
math.sqrt(r**2 - z**2))
self._topocentr_equator["spherical"]["vel"]["Ra"] = Ra_dot
self._topocentr_equator["spherical"]["vel"]["De"] = De_dot
def __calc_equatorialCoordinates(self):
''' calculates position in equatorial coords from ecliptic '''
import math
Jcty = self._TSMgr.time_get_julianCenturiesJ2000()
Lam_deg = self._moonCoordinates["ecl_Lon"] # Lambda
Bet_deg = self._moonCoordinates["ecl_Lat"] # Beta
Eps_deg = MH.eps_deg(Jcty) # Epsilon
sinLam = MH.sin_deg(Lam_deg)
cosLam = MH.cos_deg(Lam_deg)
sinBet = MH.sin_deg(Bet_deg)
cosBet = MH.cos_deg(Bet_deg)
sinEps = MH.sin_deg(Eps_deg)
cosEps = MH.cos_deg(Eps_deg)
# [o. Montenbruck] "Grundlagen der Ephemeridenrechnung" S.14
# cos(del)*cos(alp) = cos(bet)*cos(lam)
# cos(del)*sin(alp) = cos(eps)*cos(bet)*sin(lam) - sin(eps)*sin(bet)
# sin(del) = sin(eps)*cos(bet)*sin(lam) + cos(eps)*sin(bet)
Del_rad = math.asin( sinEps*cosBet*sinLam + cosEps*sinBet )
Del_deg = math.degrees(Del_rad)
cosDel = math.cos(Del_rad)
cosAlp = (cosBet*cosLam) / cosDel
sinAlp = (cosEps*cosBet*sinLam - sinEps*sinBet) / cosDel
Alp_deg = MH.atan2_deg(sinAlp,cosAlp)%360
self._moonCoordinates["equa_Lon"] = Alp_deg # Alpha / RA
self._moonCoordinates["equa_Lat"] = Del_deg # Delta / DE
def _propagate(self):
''' Calculates [Position] and [Velocity] in [Cartesian Coordinate
System] for the [GEOcentric AND TOPOcentric Equatorial System]
for the statet utc time.
(Center = [Earth Center], [Surface position],
References: [Earth axis] / [Equatorial plane] and
the direction to the [Vernal equinox].) '''
# get utc time of TSMgr object
t = self._TSMgr.time_get_utcDateTime()
# -------------
# calc pos and vel for GEOcentr cartesian coordins of SAT
pos_sat, vel_sat = self._sat.propagate(t.year, t.month, t.day, t.hour,
t.minute,
t.second + t.microsecond * 1e-6)
self._geocentr_equator["cartesian"]["pos"] = pos_sat
self._geocentr_equator["cartesian"]["vel"] = vel_sat
# -------------
# calc pos and vel for GEOcentr cartesian coordins of TELE
#get geocentr pos of tele
pos_tele = self._TSMgr.pos_get_ECI()
#calc geocentr vel of tele
# Formel fuer kartesiches koordinatensystem:
# drehender pfeil in xy ebene mit w = winkelgeschw.
w = wgs72_complete["omega_RadPerSec"] # winkelgeschw in xy ebene
vel_tele = [0, 0, 0]
vel_tele[0] = w * pos_tele[1] # x' = w*y
vel_tele[1] = -w * pos_tele[0] # y' = - w*x
vel_tele[2] = 0 # z' = 0 # (erdrotation in z) = 0
# -------------
# calc pos and vel for TOPOcentr cartesian coordins of SAT(fromTELE)
#topocentr pos of sat = [geocentr pos of sat] - [geocentr pos of tele]
pos_topo = math_helper.vector_sub(pos_sat, pos_tele)
vel_topo = math_helper.vector_sub(vel_sat, vel_tele)
self._topocentr_equator["cartesian"]["pos"] = tuple(pos_topo)
self._topocentr_equator["cartesian"]["vel"] = tuple(vel_topo)
def __init__(self, TSMgrObj: TSMgr.TimeSpaceMgr, planet: str):
''' Create a planet by its name,
with reference to a TimeSpaceMgr object
(preferably one for all planets). '''
#print("PLANET: "+str(planet))
# default values
self._successPlanet = False
self._planetName = None
self._TSMgr = None
if (planet.lower() in Planetlist.Planetlist
and planet.lower() != "earth"):
#wenn planet sich in der liste bekannter planeten befindet
self._planetName = planet.lower()
self._TSMgr = TSMgrObj # reference to the global TSMgr
Jcty = self._TSMgr.time_get_julianCenturiesJ2000()
self._keplerPlanet = Planetlist.getCurrentKeplerElem(
self._planetName, Jcty) #get kepler elements
self._keplerEarth = Planetlist.getCurrentKeplerElem(
"earth", Jcty) #get kepler elements
# astronomical almanach 2018
# schiefe der eklitptic epsilon = epsJ2000 + epsDot * T
# T = julian centuries since J2000
# epsJ2000 = 84381.406 arcsec
# epsDot = -46.836769 arcsec per julian century
# self._eps = (84381.406 -
# 46.836769*self._TSMgr.time_get_julianCenturiesJ2000()
# )/3600
self._eps = MH.eps_deg(Jcty)
# astronomic unit in km
self._AU = 149597870.7
self._successPlanet = True
def calcPos(self, utcDateTime=None):
# es müssen position von erde und planet immer gleichzeitig
# berechnet werden, da wir den relativen richtungsvektor
# zwischen beiden benötigen (und alles im heliozentr koord sys
# berechnet wird)
import EPH_ADD_math_helper as math_helper
from EPH_ADD_wgs72_complete import wgs72_complete
#update time in TSMgr
#self._TSMgr.time_set_utcDateTime(utcDateTime)
#get kepler elements
Jcty = self._TSMgr.time_get_julianCenturiesJ2000()
self._keplerPlanet = Planetlist.getCurrentKeplerElem(
self._planetName, Jcty) #get kepler elements
self._keplerEarth = Planetlist.getCurrentKeplerElem(
"earth", Jcty) #get kepler elements
# -------------------------------------------------------------------
# get eccentric anomaly with KEPLER EQUATION (newton verfahren)
# PLANET
self._keplerPlanet["E"] = Planetlist.keplerEquation(
self._keplerPlanet["M"], self._keplerPlanet["e"])
# EARTH
self._keplerEarth["E"] = Planetlist.keplerEquation(
self._keplerEarth["M"], self._keplerEarth["e"])
# -------------------------------------------------------------------
# heliocentric coordinates in the planet's orbital plane
# x-axis aligned from focus towards perihelion
# PLANET
xyzHelioOrbitP = self.__calc_helio_orbit_from_kepler(
self._keplerPlanet)
# EARTH
xyzHelioOrbitE = self.__calc_helio_orbit_from_kepler(self._keplerEarth)
# -------------------------------------------------------------------
# heliocentric coordinates in the ecliptic plane (earths orbit)
# x-axis aligned towards the equinox
# PLANET
xyzHelioEclP = self.__calc_helio_ecliptical_from_helio_orbit(
xyzHelioOrbitP, self._keplerPlanet)
# EARTH
xyzHelioEclE = self.__calc_helio_ecliptical_from_helio_orbit(
xyzHelioOrbitE, self._keplerEarth)
# -------------------------------------------------------------------
# relativer vektor von erde zu planet (Erde2Planet) im heliocentr.
# ekliptikalen kartes. koordin system (entspricht geozentr.
# ekliptikalen kartes. koord system)
# Sonne2Planet = Sonne2Erde + Erde2Planet
# Erde2Planet = Sonne2Planet - Sonne2Erde
xyzHelioEcl_E2P = math_helper.vector_sub(xyzHelioEclP, xyzHelioEclE)
# (entspricht geozentr. ekliptikalen kartes. koord system)
planetGeoEclCartesian = tuple(xyzHelioEcl_E2P)
# -------------------------------------------------------------------
# an dieser stelle ist der relative vektor vom zentrum der erde zum
# gesuchten planeten im heliocentr, ecliptical cartes. coord sys
# bekannt - es folgen umrechungen in koordin systeme für die
# beobachtung von der erde aus.
# -------------------------------------------------------------------
# drehe koordinate von ekliptical zu equatorial
planetGeoEquCartesian = self.__rotate_from_ecliptical_to_equatorial(
planetGeoEclCartesian, self._eps)
#get geocentr equatorial pos of tele in KM!!!
pos_tele_GeoEquCartesian = self._TSMgr.pos_get_ECI()
planetTopoEquCartesian = [0, 0, 0]
# um parallax effekte zu vermeiden, wird die position des teleskops
# abgezogen.
# Im falle von Mars würde die maximale parallaxe bei seinem letzten
# Closest approach in 2018 Jul 27 (näheste annäherung an die erde)
# ca 22.78 arcsec betragen (dist_min = 0.386 AU,
# parallax_max = asin(earthradius in km / dist in km ),
# parallax_max = asin(6378/57744778) )
for k in range(3):
planetTopoEquCartesian[k] = (
planetGeoEquCartesian[k] -
pos_tele_GeoEquCartesian[k] / self._AU)
# # wandle in spherical koordinaten um
# planetGeoEquSpherical = self.__calc_spherical_from_cartesian(
# planetGeoEquCartesian)
# wandle in spherical koordinaten um
planetTopoEquSpherical = self.__calc_spherical_from_cartesian(
planetTopoEquCartesian)
return {
"Ra": planetTopoEquSpherical[0],
"De": planetTopoEquSpherical[1],
"R": planetTopoEquSpherical[2]
}
def calcMoonCoords_1stSolution(self):
# self.__meanArgs_checkDF()
self.calcMoonMeanArgumentsFromDate()
L0 = self._moonMeanArguments['L0']
l = self._moonMeanArguments['l']
l_ = self._moonMeanArguments['l_']
F = self._moonMeanArguments['F']
D = self._moonMeanArguments['D']
# print('L0 ',L0)
# print('l ',l)
# print('l_ ',l_)
# print('F ',F)
# print('D ',D)
term = [None]*13
term[0] = (
22640 * MH.sin_deg(l) +
769 * MH.sin_deg(2*l) +
36 * MH.sin_deg(3*l) ) #grosse ungleicheit
term[1] = -4586 * MH.sin_deg(l-2*D) #evektion
term[2] = 2370 * MH.sin_deg(2*D) #variation
term[3] = -668 * MH.sin_deg(l_) #jaehrliche ungleichheit
term[4] = -412 * MH.sin_deg(2*F) #differenz in bahnlaenge und ekliptikaler laenge
term[5] = -212 * MH.sin_deg(2*l-2*D)
term[6] = -206 * MH.sin_deg(l+l_-2*D)
term[7] = 192 * MH.sin_deg(l+2*D)
term[8] = -165 * MH.sin_deg(l_-2*D)
term[9] = 148 * MH.sin_deg(l-l_)
term[10] = -125 * MH.sin_deg(D) #paralaktiche gleichung
term[11] = -110 * MH.sin_deg(l+l_)
term[12] = -55 * MH.sin_deg(2*F-2*D)
ecl_Laenge = L0 + sum(term)/3600
self._moonCoordinates["ecl_Lon"] = ecl_Laenge %360
# Reset des "term" Arrays
term = [None]*8
term[0] = 18520* MH.sin_deg( F + ecl_Laenge - L0 +
0.114*MH.sin_deg(2*F) +0.15*MH.sin_deg(l_) )
term[1] = -526 * MH.sin_deg( F - 2*D )
term[2] = 44 * MH.sin_deg( l + F - 2*D )
term[3] = -31 * MH.sin_deg( -l + F - 2*D )
term[4] = -25 * MH.sin_deg( -2*l + F )
term[5] = -23 * MH.sin_deg( l_ + F - 2*D )
term[6] = 21 * MH.sin_deg( -l + F )
term[7] = 11 * MH.sin_deg( -l_ + F - 2*D )
self._moonCoordinates["ecl_Lat"] = sum(term)/3600
# ergebnis ist im ekliptischen koordsys
# wird benötigt im äquatorialen koordsys
self.__calc_equatorialCoordinates()