def test_get_orbit_cart(self):
p = PropagatorKepler()
self._gen_cart(p)
ecefs = p.get_orbit_cart(self.t, **self.init_data_cart)
self.assertEqual(ecefs.shape, (6,len(self.t)))
def test_orbit_kep_cart_correspondance(self):
mjd0 = dpt.jd_to_mjd(2457126.2729)
orb_init_list = self._gen_orbits(100)
prop = PropagatorKepler(
in_frame='EME',
out_frame='EME',
)
t = n.linspace(0, 12*3600, num=100, dtype=n.float)
for kep in orb_init_list:
state_ref = dpt.kep2cart(kep, m=self.init_data['m'], M_cent=M_earth, radians=False)
state_kep = prop.get_orbit(
t=t, mjd0=mjd0,
a=kep[0], e=kep[1], inc=kep[2],
raan=kep[4], aop=kep[3], mu0=dpt.true2mean(kep[5], kep[1], radians=False),
m=self.init_data['m'],
radians=False,
)
state_cart = prop.get_orbit_cart(
t=t, mjd0=mjd0,
x=state_ref[0], y=state_ref[1], z=state_ref[2],
vx=state_ref[3], vy=state_ref[4], vz=state_ref[5],
m=self.init_data['m'],
)
state_diff1 = n.abs(state_kep - state_cart)
nt.assert_array_less(state_diff1[:3,:], n.full((3,t.size), 1e-5, dtype=state_diff1.dtype))
nt.assert_array_less(state_diff1[3:,:], n.full((3,t.size), 1e-7, dtype=state_diff1.dtype))
def test_orbit_inverse_error_kep(self):
mjd0 = dpt.jd_to_mjd(2457126.2729)
orb_init_list = self._gen_orbits(1000)
prop = PropagatorKepler(
in_frame='EME',
out_frame='EME',
)
t = n.array([0.0])
for kep in orb_init_list:
state_ref = dpt.kep2cart(kep, m=self.init_data['m'], M_cent=M_earth, radians=False)
state = prop.get_orbit(
t=t, mjd0=mjd0,
a=kep[0], e=kep[1], inc=kep[2],
raan=kep[4], aop=kep[3], mu0=dpt.true2mean(kep[5], kep[1], radians=False),
m=self.init_data['m'],
radians=False,
)
state_diff1 = n.abs(state_ref - state[:,0])
nt.assert_array_less(state_diff1[:3], n.full((3,), 1e-5, dtype=state_diff1.dtype))
nt.assert_array_less(state_diff1[3:], n.full((3,), 1e-7, dtype=state_diff1.dtype))
def test_orbit_inverse_error_cart(self):
mjd0 = dpt.jd_to_mjd(2457126.2729)
orb_init_list = self._gen_orbits(1000)
prop = PropagatorKepler(
in_frame='TEME',
out_frame='TEME',
)
t = n.array([0.0])
orbs_done = 0
for kep in orb_init_list:
state_ref = dpt.kep2cart(kep, m=self.init_data['m'], M_cent=M_earth, radians=False)
state = prop.get_orbit_cart(
t=t, mjd0=mjd0,
x=state_ref[0], y=state_ref[1], z=state_ref[2],
vx=state_ref[3], vy=state_ref[4], vz=state_ref[5],
m=self.init_data['m'],
)
state_diff1 = n.abs(state_ref - state[:,0])
if n.linalg.norm(state_diff1[:3]) > 1e-5:
print(kep)
print(orbs_done)
nt.assert_array_less(state_diff1[:3], n.full((3,), 1e-5, dtype=state_diff1.dtype))
nt.assert_array_less(state_diff1[3:], n.full((3,), 1e-7, dtype=state_diff1.dtype))
orbs_done += 1
def tryBackwards():
prop = PropagatorKepler(in_frame='ITRF', out_frame='ITRF')
init_data = {
'mjd0': 57125.7729,
'C_D': 2.3,
'C_R': 1.0,
'm': 3.0,
'A': np.pi * (0.5 * 0.5)**2,
}
state0 = [
2721793.785377, 1103261.736653, 6427506.515945, 6996.001258,
-171.659563, -2926.43233
]
x, y, z, vx, vy, vz = state0
t = np.linspace(0, 24 * 3600.0, num=5000, dtype=np.float)
ecefs1 = prop.get_orbit_cart(t, x, y, z, vx, vy, vz, **init_data)
x, y, z, vx, vy, vz = ecefs1[:, -1].tolist()
init_data['mjd0'] += t[-1] / (3600.0 * 24.0)
ecefs2 = prop.get_orbit_cart(-t, x, y, z, vx, vy, vz, **init_data)
print('Position diff: {} m'.format(ecefs1[:3, 0] - ecefs2[:3, -1]))
print('Velocity diff: {} m/s'.format(ecefs1[3:, 0] - ecefs2[3:, -1]))
dr = np.sqrt(np.sum((ecefs1[:3, ::-1] - ecefs2[:3, :])**2, axis=0))
dv = np.sqrt(np.sum((ecefs1[3:, ::-1] - ecefs2[3:, :])**2, axis=0))
fig = plt.figure(figsize=(15, 15))
ax = fig.add_subplot(211)
ax.plot(t / 3600.0, dr * 1e-3)
ax.set_xlabel('Time [h]')
ax.set_ylabel('Position difference [km]')
ax.set_title('Propagation backwards and forwards error')
ax = fig.add_subplot(212)
ax.plot(t / 3600.0, dv * 1e-3)
ax.set_xlabel('Time [h]')
ax.set_ylabel('Velocity difference [km/s]')
fig = plt.figure(figsize=(15, 15))
ax = fig.add_subplot(111, projection='3d')
plothelp.draw_earth_grid(ax)
ax.plot(ecefs1[0, :],
ecefs1[1, :],
ecefs1[2, :],
"-",
color="green",
alpha=0.5)
ax.plot(ecefs2[0, :],
ecefs2[1, :],
ecefs2[2, :],
"-",
color="red",
alpha=0.5)
plt.show()
def test_circ_orbit(self):
p = PropagatorKepler(in_frame='TEME', out_frame='TEME')
self.init_data['a'] = 36000e3
ecefs = p.get_orbit(self.t, **self.init_data)
rn = n.sum(ecefs[:3,:]**2, axis=0)/36000.0e3**2
nt.assert_array_almost_equal(rn, n.ones(rn.shape, dtype=ecefs.dtype), decimal=4)
def test_kep_cart(self):
p = PropagatorKepler(
in_frame='EME',
out_frame='EME',
)
ecefs = p.get_orbit(self.t0, **self.init_data)
ecefs2 = p.get_orbit_cart(self.t0,
ecefs[0], ecefs[1], ecefs[2],
ecefs[3], ecefs[4], ecefs[5],
mjd0=self.init_data['mjd0'],
m=self.init_data['m'],
)
nt.assert_array_almost_equal(ecefs/ecefs2, n.ones(ecefs.shape, dtype=ecefs.dtype), decimal=7)
def setUp(self):
self.p = PropagatorKepler(in_frame='EME', out_frame='ITRF')
self.radar = mock_radar()
self.big_radar = mock_radar_mult()
self.orbit = {
'a': 7500,
'e': 0,
'i': 90.0,
'raan': 0,
'aop': 0,
'mu0': 0.0,
'mjd0': 57125.7729,
'm': 0,
}
self.T = n.pi * 2.0 * n.sqrt(7500e3**3 / MU_earth)
self.o = SpaceObject(C_D=2.3,
A=1.0,
C_R=1.0,
oid=42,
d=1.0,
propagator=PropagatorKepler,
propagator_options={
'in_frame': 'EME',
'out_frame': 'ITRF',
},
**self.orbit)
#from pen and paper geometry we know that for a circular orbit and the radius of the earth at pole
#that the place where object enters FOV is
#true = mean = arccos(R_E / semi major)
self.rise_ang = 90.0 - n.degrees(n.arccos(wgs84_a / 7500e3))
self.fall_ang = 180.0 - self.rise_ang
#then we can find the time as a fraction of the orbit traversal from the angle
self.rise_T = self.rise_ang / 360.0 * self.T
self.fall_T = self.fall_ang / 360.0 * self.T
self.num = simulate_tracking.find_linspace_num(t0=0.0,
t1=self.T,
a=7500e3,
e=0.0,
max_dpos=1e3)
self.full_t = n.linspace(0, self.T, num=self.num)
import time
import numpy as np
import matplotlib.pyplot as plt
import plothelp
from propagator_kepler import PropagatorKepler
from propagator_sgp4 import MU_earth
prop = PropagatorKepler()
def try1():
init_data = {
'a': 7000e3,
'e': 0.05,
'inc': 90.0,
'raan': 10,
'aop': 10,
'mu0': 90.0,
'mjd0': 57125.7729,
'radians': False,
'm': 8000,
}
period = np.pi * 2.0 * np.sqrt(init_data['a']**3 / MU_earth)
t = np.linspace(0, 2 * period, endpoint=True, num=1000, dtype=np.float)
print('period: {} hours'.format(period / 3600.0))
def test_options_frames(self):
p = PropagatorKepler(
in_frame='ITRF',
out_frame='EME',
)
ecefs = p.get_orbit(self.t0, **self.init_data)
def test_get_orbit_kep(self):
p = PropagatorKepler()
ecefs = p.get_orbit(self.t, **self.init_data)
self.assertEqual(ecefs.shape, (6,len(self.t)))