def planet_elements_and_sv(planet_id, year, month, day, hour, minute, second):
global mu
mu = 1.327124e11
#calculating julian time
j0 = sum(jdcal.gcal2jd(year, month, day))
ut = (hour+minute/60+second/3600)/24
jd = j0+ut
#determining state vectors
eph = Ephemeris(de421)
planet = month_planet_names.planet_name(planet_id)
if planet=="earth":
barycenter = eph.position_and_velocity('earthmoon', jd)
moonvector = eph.position_and_velocity('moon', jd)
r = barycenter[0] - eph.earth_share*moonvector[0]
v = barycenter[1] - eph.earth_share*moonvector[1]
elif planet=="moon":
barycenter = eph.position_and_velocity('earthmoon', jd)
moonvector = eph.position_and_velocity('moon', jd)
r = barycenter[0] - eph.moon_share*moonvector[0]
v = barycenter[1] - eph.moon_share*moonvector[1]
mu = 3.986e14
else:
r, v = eph.position_and_velocity(planet, jd)
r = r.flatten()
v = v.flatten()/(24*3600)
coe = coe_from_sv.coe_from_sv(r, v, mu)
return [coe, r, v, jd]
class LegacyTests(_CommonTests, TestCase):
def setUp(self):
try:
import de421
except ImportError:
raise SkipTest('the "de421" ephemeris package has not been'
' installed with "pip install de421"')
self.eph = Ephemeris(de421)
self.jalpha = self.eph.jalpha
self.jomega = self.eph.jomega
def position(self, name, tdb, tdb2=0.0):
return self.eph.position(name, tdb, tdb2)
def position_and_velocity(self, name, tdb, tdb2=0.0):
return self.eph.position_and_velocity(name, tdb, tdb2)
def test_names(self):
self.assertEqual(self.eph.names, (
'earthmoon',
'jupiter',
'librations',
'mars',
'mercury',
'moon',
'neptune',
'nutations',
'pluto',
'saturn',
'sun',
'uranus',
'venus',
))
def test_legacy_compute_method(self):
pv = self.eph.compute('earthmoon', 2414994.0)
self.check0(pv[:3], pv[3:])
pv = self.eph.compute('earthmoon', np.array([2414994.0, 2415112.5]))
self.check0(pv[:3, 0], pv[3:, 0])
self.check1(pv[:3, 1], pv[3:, 1])
def test_ephemeris_end_date(self):
x, y, z = self.position('earthmoon', self.jomega)
self.assertAlmostEqual(x, -94189805.73967789, delta=epsilon_m)
self.assertAlmostEqual(y, 1.05103857e+08, delta=1.0)
self.assertAlmostEqual(z, 45550861.44383482, delta=epsilon_m)
class LegacyTests(_CommonTests, TestCase):
def setUp(self):
try:
import de421
except ImportError:
raise SkipTest('the "de421" ephemeris package has not been'
' installed with "pip install de421"')
self.eph = Ephemeris(de421)
self.jalpha = self.eph.jalpha
self.jomega = self.eph.jomega
def position(self, name, tdb, tdb2=0.0):
return self.eph.position(name, tdb, tdb2)
def position_and_velocity(self, name, tdb, tdb2=0.0):
return self.eph.position_and_velocity(name, tdb, tdb2)
def test_names(self):
self.assertEqual(self.eph.names, (
'earthmoon', 'jupiter', 'librations', 'mars', 'mercury',
'moon', 'neptune', 'nutations', 'pluto', 'saturn', 'sun',
'uranus', 'venus',
))
def test_legacy_compute_method(self):
pv = self.eph.compute('earthmoon', 2414994.0)
self.check0(pv[:3], pv[3:])
pv = self.eph.compute('earthmoon', np.array([2414994.0, 2415112.5]))
self.check0(pv[:3,0], pv[3:,0])
self.check1(pv[:3,1], pv[3:,1])
def test_ephemeris_end_date(self):
x, y, z = self.position('earthmoon', self.jomega)
self.assertAlmostEqual(x, -94189805.73967789, delta=epsilon_m)
self.assertAlmostEqual(y, 1.05103857e+08, delta=1.0)
self.assertAlmostEqual(z, 45550861.44383482, delta=epsilon_m)
def ephemeris(celestial_body, Julian_date):
'''
:param celestial_body: earthmoon mercury pluto venus
jupiter moon saturn
librations neptune sun
mars nutations uranus
:param Julian_date:儒略日
:return:天体的位置（km）,速度（km/s）
'''
import de405
from jplephem import Ephemeris
eph = Ephemeris(de405)
position, velocity = eph.position_and_velocity(celestial_body,
Julian_date) # 1980.06.01
position = np.transpose(position)
position = np.array(position).flatten()
velocity = np.transpose(velocity)
velocity = np.array(velocity).flatten()
velocity = velocity / 86400
state = np.array([position, velocity])
return np.array(state)
class Tests(TestCase):
def setUp(self):
import de421
self.e = Ephemeris(de421)
def check0(self, xyz, xyzdot=None):
eq = partial(self.assertAlmostEqual, delta=1.0)
x, y, z = xyz
eq(x, 39705023.28)
eq(y, 131195345.65)
eq(z, 56898495.41)
if xyzdot is None:
return
dx, dy, dz = xyzdot
eq(dx, -2524248.19)
eq(dy, 619970.11)
eq(dz, 268928.26)
def check1(self, xyz, xyzdot=None):
eq = partial(self.assertAlmostEqual, delta=1.0)
x, y, z = xyz
eq(x, -144692624.00)
eq(y, -32707965.14)
eq(z, -14207167.26)
if xyzdot is None:
return
dx, dy, dz = xyzdot
eq(dx, 587334.38)
eq(dy, -2297419.36)
eq(dz, -996628.74)
def test_names(self):
self.assertEqual(self.e.names, (
'earthmoon', 'jupiter', 'librations', 'mars', 'mercury',
'moon', 'neptune', 'nutations', 'pluto', 'saturn', 'sun',
'uranus', 'venus',
))
def test_scalar_tdb(self):
self.check0(self.e.position('earthmoon', 2414994.0))
self.check1(self.e.position('earthmoon', 2415112.5))
def test_scalar_tdb2(self):
self.check0(self.e.position('earthmoon', 2414990.0, 4.0))
self.check1(self.e.position('earthmoon', 2415110.0, 2.5))
def test_scalar_tdb_keyword(self):
self.check0(self.e.position('earthmoon', tdb=2414994.0))
self.check1(self.e.position('earthmoon', tdb=2415112.5))
def test_scalar_tdb2_keyword(self):
self.check0(self.e.position('earthmoon', tdb=2414990.0, tdb2=4.0))
self.check1(self.e.position('earthmoon', tdb=2415110.0, tdb2=2.5))
def check_2d_result(self, name, tdb, tdb2):
p = self.e.position(name, tdb + tdb2)
self.check0(p[:,0])
self.check1(p[:,1])
p = self.e.position(name, tdb, tdb2)
self.check0(p[:,0])
self.check1(p[:,1])
p, v = self.e.position_and_velocity(name, tdb + tdb2)
self.check0(p[:,0], v[:,0])
self.check1(p[:,1], v[:,1])
p, v = self.e.position_and_velocity(name, tdb, tdb2)
self.check0(p[:,0], v[:,0])
self.check1(p[:,1], v[:,1])
def test_array_tdb(self):
tdb = np.array([2414994.0, 2415112.5])
tdb2 = 0.0
self.check_2d_result('earthmoon', tdb, tdb2)
def test_array_tdb_scalar_tdb2(self):
tdb = np.array([2414991.5, 2415110.0])
tdb2 = 2.5
self.check_2d_result('earthmoon', tdb, tdb2)
def test_scalar_tdb_array_tdb2(self):
tdb = 2414990.0
d = 2415112.5 - tdb
tdb2 = np.array([4.0, d])
self.check_2d_result('earthmoon', tdb, tdb2)
def test_array_tdb_array_tdb2(self):
tdb = np.array([2414990.0, 2415110.0])
tdb2 = np.array([4.0, 2.5])
self.check_2d_result('earthmoon', tdb, tdb2)
def test_legacy_compute_method(self):
pv = self.e.compute('earthmoon', 2414994.0)
self.check0(pv[:3], pv[3:])
pv = self.e.compute('earthmoon', np.array([2414994.0, 2415112.5]))
self.check0(pv[:3,0], pv[3:,0])
self.check1(pv[:3,1], pv[3:,1])
def test_ephemeris_end_date(self):
x, y, z = self.e.position('earthmoon', self.e.jomega)
self.assertAlmostEqual(x, -94189805.73967789, delta=1.0)
self.assertAlmostEqual(y, 1.05103857e+08, delta=1.0)
self.assertAlmostEqual(z, 45550861.44383482, delta=1.0)
def test_too_early_date(self):
tdb = self.e.jalpha - 0.01
self.assertRaises(DateError, self.e.position, 'earthmoon', tdb)
def test_too_late_date(self):
tdb = self.e.jomega + 16.01
self.assertRaises(DateError, self.e.position, 'earthmoon', tdb)
class pos(object):
def __init__(self):
self.trajectory_positions = []
axtl = 23.43929*DEG2RAD # Earth axial tlit
# Macierz przejscia z ECI do helio
self.mactran = matrix([ [1, 0, 0],
[0, cos(axtl), sin(axtl)],
[0, -sin(axtl), cos(axtl)] ])
self.day = 86400.0
def positions_lambert(self, l, sol=0, units = 1.0, index = 0):
"""
Plots a particular solution to a Lambert's problem
USAGE: plot_lambert(ax,l, N=60, sol=0, units = 'PyKEP.AU', legend = 'False')
* l: PyKEP.lambert_problem object
* sol: solution to the Lambert's problem we want to plot (must be in 0..Nmax*2)
where Nmax is the maximum number of revolutions for which there exist a solution.
* units: the length unit to be used in the plot
"""
from PyKEP import propagate_lagrangian, AU
if sol > l.get_Nmax()*2:
raise ValueError("sol must be in 0 .. NMax*2 \n * Nmax is the maximum number of revolutions for which there exist a solution to the Lambert's problem \n * You can compute Nmax calling the get_Nmax() method of the lambert_problem object")
#We extract the relevant information from the Lambert's problem
r = l.get_r1()
v = l.get_v1()[sol]
T = l.get_tof()
mu = l.get_mu()
#We define the integration time ...
if T/86400. < 1:
N = int(T) #...compute number of points...
dt = T / (N-1.)
else:
N = int(2*T/86400.) #...compute number of points...
dt = T / (N-1.)
timetuple = [i*dt for i in range(N)]
#... and alocate the cartesian components for r
x = [0.0]*N
y = [0.0]*N
z = [0.0]*N
#We calculate the spacecraft position at each dt
for i in range(N):
x[i] = r[0]/units
y[i] = r[1]/units
z[i] = r[2]/units
r,v = propagate_lagrangian(r,v,dt,mu)
self.trajectory_positions.append([index, x, y, z, timetuple])
def positions_kepler(self, r,v,t,mu, units = 1, index = 0):
"""
Plots the result of a keplerian propagation
USAGE: plot_kepler(ax,r,v,t,mu, N=60, units = 1, color = 'b', legend = False):
* r: initial position (cartesian coordinates)
* v: initial velocity (cartesian coordinates)
* t: propagation time
* mu: gravitational parameter
* units: the length unit to be used in the plot
"""
from PyKEP import propagate_lagrangian
#We define the integration time ...
if t/86400. < 1:
N = int(t) #...compute number of points...
dt = t / (N-1.)
else:
N = int(2*t/86400.) #...compute number of points...
dt = t / (N-1.)
timetuple = [i*dt for i in range(N)]
#... and calcuate the cartesian components for r
x = [0.0]*N
y = [0.0]*N
z = [0.0]*N
#We calculate the spacecraft position at each dt
for i in range(N):
x[i] = r[0]/units
y[i] = r[1]/units
z[i] = r[2]/units
r,v = propagate_lagrangian(r,v,dt,mu)
self.trajectory_positions.append([index, x, y, z, timetuple])
def return_sc_positions(self):
return self.trajectory_positions
def set_launch_epoch(self, mjd2000_epoch):
self.Lepoch = mjd2000_epoch
def rework_time(self):
T = self.trajectory_positions
n = len(T)
ep = self.Lepoch
timespans = [T[i][4][-1]/86400. for i in range(n)]
beginings = [ep + sum(timespans[:i]) for i in range(n)]
# initialize lists...
t = []
x = []
y = []
z = []
# ...and join values, correcting for time
for g in range(n):
t = t + [beginings[g]+i/86400. for i in T[g][4]]
x = x + T[g][1]
y = y + T[g][2]
z = z + T[g][3]
# save spacecraft state
self.sc_state = [x, y, z, t]
def eq2eclipt(self, xyz):
macxyz = matrix(xyz)
return self.mactran.dot(macxyz)
def planets_pos(self):
from jplephem import Ephemeris
import de421
from PyKEP import epoch
self.eph = Ephemeris(de421)
earthpos = []
marspos = []
venuspos = []
for ep in self.sc_state[3]:
posSun, __ = self.eph.position_and_velocity('sun', epoch(ep, epoch.epoch_type.MJD2000).jd)
positione, __ = self.eph.position_and_velocity('earthmoon', epoch(ep, epoch.epoch_type.MJD2000).jd)
positione = self.eq2eclipt(positione - posSun)
earthpos.append(positione)
positionm, __ = self.eph.position_and_velocity('mars', epoch(ep, epoch.epoch_type.MJD2000).jd)
positionm = self.eq2eclipt(positionm - posSun)
marspos.append(positionm)
positionv, __ = self.eph.position_and_velocity('venus', epoch(ep, epoch.epoch_type.MJD2000).jd)
positionv = self.eq2eclipt(positionv - posSun)
venuspos.append(positionv)
self.earthpos_km = [earthpos[i].reshape((1,3)).tolist()[0] for i in range(len(earthpos))]
self.marspos_km = [marspos[i].reshape((1,3)).tolist()[0] for i in range(len(earthpos))]
self.venuspos_km = [venuspos[i].reshape((1,3)).tolist()[0] for i in range(len(earthpos))]
def distance_to_planets(self):
dre = []
drm = []
drv = []
for i in range(len(self.sc_state[3])):
ep = self.earthpos_km[i]
dist = [ep[0] - self.sc_state[0][i] / 1000.,
ep[1] - self.sc_state[1][i] / 1000.,
ep[2] - self.sc_state[2][i] / 1000.]
dre.append((sum([g**2 for g in dist]))**.5)
mp = self.marspos_km[i]
dist = [mp[0] - self.sc_state[0][i] / 1000.,
mp[1] - self.sc_state[1][i] / 1000.,
mp[2] - self.sc_state[2][i] / 1000.]
drm.append((sum([g**2 for g in dist]))**.5)
vp = self.venuspos_km[i]
dist = [vp[0] - self.sc_state[0][i] / 1000.,
vp[1] - self.sc_state[1][i] / 1000.,
vp[2] - self.sc_state[2][i] / 1000.]
drv.append((sum([g**2 for g in dist]))**.5)
return dre,drm, drv, self.sc_state[3]
