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]