type='mean',
)
print('Initial orbit:')
print(orb)
def H_to_D(H, pV):
return 10**(3.1236 - 0.5 * np.log10(pV) - 0.2 * H)
obj = sorts.SpaceObject(
sorts.propagator.Rebound,
propagator_options=propagator_options,
state=orb,
epoch=epoch,
parameters=dict(
H=jpl_el['H'].data[0],
d=H_to_D(jpl_el['H'].data[0], 0.14),
geometric_albedo=0.14,
spin_period=(3600.0 * 24.0) / 1e3,
),
)
print(obj)
t = np.arange(0, 3600.0 * 24.0 * days, dt)
states, massive_states = obj.get_state(t)
interpolator = sorts.interpolation.Legendre8(states, t)
from schedulers import TrackingScheduler
scheduler = TrackingScheduler(radar, t, states, t_slice=t_slice)
#!/usr/bin/env python
import pathlib
import numpy as np
import sorts
obj = sorts.SpaceObject(
sorts.propagator.SGP4,
propagator_options=dict(settings=dict(
in_frame='TEME',
out_frame='ITRS',
), ),
a=7200e3,
e=0.05,
i=75,
raan=79,
aop=0,
mu0=0,
epoch=53005.0,
parameters=dict(d=0.1, ),
)
epoch = obj.epoch
radar = sorts.radars.eiscat3d
t = np.arange(0, 3600 * 24, 5.0)
states = obj.get_state(t)
passes = radar.find_passes(t, states)
passes = sorts.passes.group_passes(passes)[0][0] #pick first pass
for ind, ps in enumerate(passes):
def iterative_det_od(self, index, **kwargs):
no_cache = kwargs.get('no_cache', False)
if not no_cache:
data_path = self.get_path(f'calc/{index}_data.pickle').resolve()
_data = self.load_pickle(data_path)
if _data is not None:
return _data
obj = self.pop.get_object(index)
sigmas = []
print('RUNNING CALC')
print(obj)
scheduler = self.sched_cls(
radar=radar,
scan=scan,
epoch=epoch,
timeslice=0.1,
end_time=3600.0 * end_hours,
logger=self.logger,
profiler=profiler,
)
self.scheduler = scheduler
t, states, passes, data = detect.get_detections(scheduler,
obj,
self.logger,
profiler,
t_samp=10.0)
if len(data) == 0:
return None
try:
datas_scan, Sigma_orb_scan = detect.orbit_determination(
data_select_all,
scheduler,
obj,
passes,
error_cache_path,
self.logger,
profiler,
)
except Exception as e:
self.logger.info('Cannot do IOD')
self.logger.exception(e)
return None
Sigma_orb_scan__ = 0.5 * (Sigma_orb_scan + Sigma_orb_scan.T)
sigmas.append(Sigma_orb_scan__)
try:
datas, Sigma_orb = detect.orbit_determination(
data_select,
scheduler,
obj,
passes,
error_cache_path,
self.logger,
profiler,
)
except Exception as e:
self.logger.info('Cannot do IOD')
self.logger.exception(e)
return None
Sigma_orb__ = 0.5 * (Sigma_orb + Sigma_orb.T)
sigmas.append(Sigma_orb__)
t_iod = datas[0]['t'][datas[0]['data_select']]
#first detection is IOD state
init_epoch = epoch + TimeDelta(t_iod.min(), format='sec')
#sample IOD covariance
init_orb = np.random.multivariate_normal(datas[0]['states'][:, 0],
Sigma_orb__)
init_orb = sorts.frames.convert(
init_epoch,
init_orb,
in_frame='ITRS',
out_frame='TEME',
)
init_object = sorts.SpaceObject(x=init_orb[0],
y=init_orb[1],
z=init_orb[2],
vx=init_orb[3],
vy=init_orb[4],
vz=init_orb[5],
epoch=init_epoch,
**pop_kw)
true_orb = sorts.frames.convert(
init_epoch,
datas[0]['states'][:, 0],
in_frame='ITRS',
out_frame='TEME',
)
true_object = sorts.SpaceObject(x=true_orb[0],
y=true_orb[1],
z=true_orb[2],
vx=true_orb[3],
vy=true_orb[4],
vz=true_orb[5],
epoch=init_epoch,
**pop_kw)
chase_schdeule_time = t_iod.max() + tracker_delay
scheduler.update(init_object, start_track=chase_schdeule_time)
if update_interval is not None:
updates = np.floor(
(passes[0].end() - passes[0].start()) / update_interval)
for update_num in range(1, int(updates)):
delta_t = chase_schdeule_time + update_interval * update_num
scheduler.stop_calc_time = delta_t
def update_data_select(data):
if len(data['t']) == 0:
return np.empty((0, ), dtype=np.int)
else:
return np.argwhere(
data['t'] < data['t'].min() + delta_t).flatten()
try:
datas, Sigma_orb = detect.orbit_determination(
update_data_select,
scheduler,
obj,
passes,
error_cache_path,
self.logger,
profiler,
Sigma_orb0=Sigma_orb__,
)
except Exception as e:
self.logger.info('Cannot do IOD')
self.logger.exception(e)
return None
Sigma_orb__ = 0.5 * (Sigma_orb + Sigma_orb.T)
sigmas.append(Sigma_orb__)
#sample OD covariance
update_orb = np.random.multivariate_normal(
datas[0]['states'][:, 0], Sigma_orb__)
update_orb = sorts.frames.convert(
init_epoch,
update_orb,
in_frame='ITRS',
out_frame='TEME',
)
update_object = sorts.SpaceObject(x=update_orb[0],
y=update_orb[1],
z=update_orb[2],
vx=update_orb[3],
vy=update_orb[4],
vz=update_orb[5],
epoch=init_epoch,
**pop_kw)
scheduler.update_tracker(
update_object,
delta_t,
start_track=chase_schdeule_time,
)
scheduler.stop_calc_time = None
scan_and_chase_datas = scheduler.observe_passes(
passes,
linear_list=True,
space_object=obj,
snr_limit=True,
epoch=scheduler.epoch,
)
_data = Sigma_orb__, scan_and_chase_datas, t, states, passes, data, chase_schdeule_time, init_object.state, true_object.state, sigmas
if not no_cache:
self.save_pickle(data_path, _data)
return _data
import matplotlib.pyplot as plt
import sorts
from observe import logger, observe_objects, eiscat3d
objs = [
sorts.SpaceObject(
sorts.propagator.SGP4,
propagator_options=dict(settings=dict(
in_frame='TEME',
out_frame='ITRF',
), ),
a=8500e3,
e=0.01,
i=75,
raan=79,
aop=0,
mu0=60,
epoch=53005.0,
parameters=dict(d=1.0, ),
oid=1,
logger=logger,
),
]
t_find = np.arange(0, 3600 * 12.0, 10.0)
passes = eiscat3d.find_passes(t_find,
objs[0].get_state(t_find),
cache_data=False)
import matplotlib.pyplot as plt
import sorts
from observe import logger, observe_objects, eiscat3d
objs = [
sorts.SpaceObject(
sorts.propagator.SGP4,
propagator_options=dict(settings=dict(
in_frame='TEME',
out_frame='ITRF',
), ),
a=7200e3,
e=0.1,
i=75,
raan=79,
aop=0,
mu0=mu0,
epoch=53005.0,
parameters=dict(d=0.05, ),
oid=oid,
logger=logger,
) for oid, mu0 in enumerate([62.0, 61.8])
]
t_find = np.arange(0, 3600 * 12.0, 10.0)
passes = eiscat3d.find_passes(t_find,
objs[0].get_state(t_find),
cache_data=False)
'''
Atmospheric drag variation
================================
'''
import pathlib
import numpy as np
import matplotlib.pyplot as plt
from astropy.time import Time
import sorts
obj = sorts.SpaceObject(sorts.propagator.SGP4,
propagator_options=dict(settings=dict(
in_frame='GCRS',
out_frame='ITRS',
), ),
a=6800e3,
e=0.0,
i=69,
raan=0,
aop=0,
mu0=0,
epoch=Time(57125.7729, format='mjd'),
parameters=dict(A=2.0, ))
hour0, offset, t1, alpha = sorts.errors.atmospheric_drag.atmospheric_errors(
obj, plot=True)
plt.show()