def load(self):
path = self.path.data
odata, ometa = ccsds_write.read_ccsds(path)
sort_obs = np.argsort(odata['date'])
odata = odata[sort_obs]
data = np.empty(odata.shape, dtype=TrackletSource.dtype)
data['date'] = odata['date']
data['r'] = odata['range'] * 1e3
data['v'] = odata['doppler_instantaneous'] * 1e3
#for ind in range(len(data)):
# lt = 0.5*data['r'][ind]/scipy.constants.c
# lt = np.timedelta64( int(lt*1e9),'ns')
# data['date'][ind] += lt
data['r_sd'] = odata['range_err'] * 1e3
data['v_sd'] = odata['doppler_instantaneous_err'] * 1e3
_cm = ometa['COMMENT'].split('\n')
for com in _cm:
tx_ind = com.find('TX_ECEF')
rx_ind = com.find('RX_ECEF')
if tx_ind != -1:
tx_ecef = com[com.find('(') + 1:com.find(')')].split(',')
tx_ecef = np.array([float(x) for x in tx_ecef],
dtype=np.float64)
elif rx_ind != -1:
rx_ecef = com[com.find('(') + 1:com.find(')')].split(',')
rx_ecef = np.array([float(x) for x in rx_ecef],
dtype=np.float64)
ometa['fname'] = path.split(os.path.sep)[-1]
ometa['tx_ecef'] = tx_ecef
ometa['rx_ecef'] = rx_ecef
self.index = int(float(ometa['PARTICIPANT_2']))
self.meta = ometa
self.data = data
def test_envisat_detection():
from mpi4py import MPI
# SORTS imports CORE
import population_library as plib
from simulation import Simulation
#SORTS Libraries
import radar_library as rlib
import radar_scan_library as rslib
import scheduler_library as schlib
import antenna_library as alib
import rewardf_library as rflib
#SORTS functions
import ccsds_write
import dpt_tools as dpt
sim_root = './tests/tmp_test_data/envisat_sim_test'
radar = rlib.eiscat_uhf()
radar.set_FOV(max_on_axis=30.0, horizon_elevation=25.0)
scan = rslib.beampark_model(
lat=radar._tx[0].lat,
lon=radar._tx[0].lon,
alt=radar._tx[0].alt,
az=90.0,
el=75.0,
)
radar.set_scan(scan)
#tle files for envisat in 2016-09-05 to 2016-09-07 from space-track.
TLEs = [
('1 27386U 02009A 16249.14961597 .00000004 00000-0 15306-4 0 9994',
'2 27386 98.2759 299.6736 0001263 83.7600 276.3746 14.37874511760117'
),
('1 27386U 02009A 16249.42796553 .00000002 00000-0 14411-4 0 9997',
'2 27386 98.2759 299.9417 0001256 82.8173 277.3156 14.37874515760157'
),
('1 27386U 02009A 16249.77590267 .00000010 00000-0 17337-4 0 9998',
'2 27386 98.2757 300.2769 0001253 82.2763 277.8558 14.37874611760201'
),
('1 27386U 02009A 16250.12384028 .00000006 00000-0 15974-4 0 9995',
'2 27386 98.2755 300.6121 0001252 82.5872 277.5467 14.37874615760253'
),
('1 27386U 02009A 16250.75012691 .00000017 00000-0 19645-4 0 9999',
'2 27386 98.2753 301.2152 0001254 82.1013 278.0311 14.37874790760345'
),
]
pop = plib.tle_snapshot(TLEs, sgp4_propagation=True)
pop['d'] = n.sqrt(4 * 2.3 * 4 / n.pi)
pop['m'] = 2300.
pop['C_R'] = 1.0
pop['C_D'] = 2.3
pop['A'] = 4 * 2.3
ccsds_file = './data/uhf_test_data/events/2002-009A-2016-09-06_08:27:08.tdm'
obs_data = ccsds_write.read_ccsds(ccsds_file)
jd_obs = dpt.mjd_to_jd(dpt.npdt2mjd(obs_data['date']))
jd_sort = jd_obs.argsort()
jd_obs = jd_obs[jd_sort]
jd_det = jd_obs[0]
pop.delete([0, 1, 2, 4]) #now just best ID left
jd_pop = dpt.mjd_to_jd(pop['mjd0'][0])
tt_obs = (jd_obs - jd_pop) * 3600.0 * 24.0
sim = Simulation(
radar=radar,
population=pop,
root=sim_root,
scheduler=schlib.dynamic_scheduler,
)
sim.observation_parameters(
duty_cycle=0.125,
SST_fraction=1.0,
tracking_fraction=0.0,
SST_time_slice=0.2,
)
sim.run_observation(jd_obs[-1] - jd_pop + 1.0)
sim.print_maintenance()
sim.print_detections()
sim.set_scheduler_args(logger=sim.logger, )
sim.run_scheduler()
sim.print_tracks()
print(sim.catalogue.tracklets[0]['t'])
print(jd_obs)
shutil.rmtree(sim_root)
assert False
#propagator = PropagatorOrekit,
#propagator_options = {
# 'in_frame': 'TEME',
# 'out_frame': 'ITRF',
#},
)
#it seems to around 25m^2 area
d = np.sqrt(25.0 * 4 / np.pi)
pop['d'] = d
measurement_file = './data/uhf_test_data/events/pass-1473150428660000.h5'
#ccsds_file = './data/uhf_test_data/events/2002-009A-1473150428.tdm'
ccsds_file = './data/uhf_test_data/events/2002-009A-2016-09-06_08:27:08.tdm'
obs_data = ccsds_write.read_ccsds(ccsds_file)
jd_obs = dpt.mjd_to_jd(dpt.npdt2mjd(obs_data['date']))
date_obs = obs_data['date']
sort_obs = np.argsort(date_obs)
date_obs = date_obs[sort_obs]
r_obs = obs_data['range'][sort_obs] * 0.5
v_obs = obs_data['doppler_instantaneous'][sort_obs]
#print(v_obs)
#exit()
#TO DEBUG
#jd_obs = jd_obs[:3]
#date_obs = date_obs[:3]
#r_obs = r_obs[:3]
def wls_state_est_files(dname, mcmc=False, N_samples=5000, propagator = default_propagator, propagator_options = {}):
"""
Weighted linear least squares estimation of orbital elements
Simulate measurements using create tracklet and estimate
orbital parameters, which include six keplerian and area to mass ratio.
Use fmin search.
Optionally utilize MCMC to sample the distribution of parameters.
number of tracklets, tracklet length, and number of tracklet points per tracklet are
user definable, allowing one to try out different measurement strategies.
"""
# first we shall simulate some measurement
# Envisat
raise NotImplementedError()
fl_tdm = glob.glob(dname + "/*.tdm")
fl_h5 = glob.glob(dname + "/*.h5")
fl_oem = glob.glob(dname + "/*.oem")
file_data = []
for ftdm in fl_tdm:
data = ftdm.split('/')[-1].split('-')
file_data.append({
'unix': float(data[1]),
'oid': int(data[2]),
'tx': int(data[3][0]),
'rx': int(data[3][2]),
})
fsort = n.argsort(n.array([x['unix'] for x in file_data])).tolist()
all_r_meas=[]
all_rr_meas=[]
all_t_meas=[]
all_true_states=[]
tx_locs=[]
rx_locs=[]
range_stds=[]
range_rate_stds=[]
prior_data, prior_meta = ccsds_write.read_oem(fl_oem[0])
x, y, z = prior_data[0]['x'], prior_data[0]['y'], prior_data[0]['z']
vx, vy, vz = prior_data[0]['vx'], prior_data[0]['vy'], prior_data[0]['vz']
prior_date = prior_data[0]['date']
prior_mjd = dpt.npdt2mjd(prior_date)
#prior_jd = dpt.mjd_to_jd(prior_mjd)
o_prior = spo.SpaceObject.cartesian(
x, y, z, vx, vy, vz,
mjd0=prior_mjd,
oid=42,
C_R = 1.0,
propagator = propagator,
propagator_options = propagator_options,
)
for ind in fsort:
ftdm, fh5 = fl_tdm[ind], fl_h5[ind]
obs_data = ccsds_write.read_ccsds(ftdm)
obs_date = prior_data[0]['date']
#obs_mjd = dpt.npdt2mjd(obs_date)
#obs_jd = dpt.mjd_to_jd(obs_mjd)
h=h5py.File(fh5,"r")
#all_r_meas.append(n.copy(h["m_range"].value))
#all_rr_meas.append(n.copy(h["m_range_rate"].value))
#all_t_meas.append(n.copy(h["m_time"].value-t0_unix))
all_r_meas.append(obs_data['range']*1e3)
all_rr_meas.append(obs_data['doppler_instantaneous']*1e3)
all_t_meas.append( (obs_date - prior_date)/n.timedelta64(1, 's') )
all_true_states.append(n.copy(h["true_state"].value))
tx_locs.append(n.copy(h["tx_loc"].value))
rx_locs.append(n.copy(h["rx_loc"].value))
range_stds.append(n.copy(h["m_range_rate_std"].value))
range_rate_stds.append(h["m_range_std"].value)
h.close()
# get best fit space object
o_fit=mcmc_od(all_t_meas, all_r_meas, all_rr_meas, range_stds, range_rate_stds, tx_locs, rx_locs, o_prior, mcmc=mcmc, odir=dname, N_samples=N_samples)
def test_OD(root, sub_path):
import orbit_determination
import TLE_tools as tle
import dpt_tools as dpt
import radar_library as rlib
import propagator_sgp4
#import propagator_orekit
#import propagator_neptune
import ccsds_write
radar = rlib.eiscat_3d(beam='interp', stage=1)
radar.set_FOV(max_on_axis=90.0, horizon_elevation=10.0)
radar.set_SNR_limits(min_total_SNRdb=10.0, min_pair_SNRdb=1.0)
radar.set_TX_bandwith(bw = 1.0e6)
#prop = propagator_neptune.PropagatorNeptune()
prop = propagator_sgp4.PropagatorSGP4()
mass=0.8111E+04
diam=0.8960E+01
m_to_A=128.651
params = dict(
A = {
'dist': None,
'val': mass/m_to_A,
},
d = {
'dist': None,
'val': diam,
},
m = {
'dist': None,
'val': mass,
},
C_D = {
'dist': None,
'val': 2.3,
},
)
fname = glob.glob(root + sub_path + '*.oem')[0]
prior_data, prior_meta = ccsds_write.read_oem(fname)
prior_sort = np.argsort(prior_data['date'])
prior_data = prior_data[prior_sort][0]
prior_mjd = dpt.npdt2mjd(prior_data['date'])
prior_jd = dpt.mjd_to_jd(prior_mjd)
state0 = np.empty((6,), dtype=np.float64)
state0[0] = prior_data['x']
state0[1] = prior_data['y']
state0[2] = prior_data['z']
state0[3] = prior_data['vx']
state0[4] = prior_data['vy']
state0[5] = prior_data['vz']
#state0_ITRF = state0.copy()
state0 = tle.ITRF_to_TEME(state0, prior_jd, 0.0, 0.0)
#state0_TEME = state0.copy()
#state0_ITRF_ref = tle.TEME_to_ITRF(state0_TEME, prior_jd, 0.0, 0.0)
#print(state0_ITRF_ref - state0_ITRF)
#exit()
data_folder = root + sub_path
data_h5 = glob.glob(data_folder + '*.h5')
data_h5_sort = np.argsort(np.array([int(_h.split('/')[-1].split('-')[1]) for _h in data_h5])).tolist()
true_prior_h5 = data_h5[data_h5_sort[0]]
true_obs_h5 = data_h5[data_h5_sort[1]]
print(true_prior_h5)
print(true_obs_h5)
with h5py.File(true_prior_h5, 'r') as hf:
true_prior = hf['true_state'].value.T*1e3
true_prior_jd = dpt.unix_to_jd(hf['true_time'].value)
print('-- True time diff prior [s] --')
prior_match_ind = np.argmin(np.abs(true_prior_jd-prior_jd))
jd_diff = prior_jd - true_prior_jd[prior_match_ind]
state0_true = true_prior[:,prior_match_ind]
state0_true = tle.ITRF_to_TEME(state0_true, true_prior_jd[prior_match_ind], 0.0, 0.0)
print(prior_match_ind)
print(jd_diff*3600.0*24.0)
with h5py.File(true_obs_h5, 'r') as hf:
true_obs = hf['true_state'].value.T*1e3
true_obs_jd = dpt.unix_to_jd(hf['true_time'].value)
data_tdm = glob.glob(data_folder + '*.tdm')
#this next line i wtf, maybe clean up
data_tdm_sort = np.argsort(np.array([int(_h.split('/')[-1].split('-')[-1][2]) for _h in data_tdm])).tolist()
ccsds_files = [data_tdm[_tdm] for _tdm in data_tdm_sort]
print('prior true vs prior mean')
print(state0_true - state0)
for _fh in ccsds_files:
print(_fh)
r_obs_v = []
r_sig_v = []
v_obs_v = []
v_sig_v = []
t_obs_v = []
for ccsds_file in ccsds_files:
obs_data = ccsds_write.read_ccsds(ccsds_file)
sort_obs = np.argsort(obs_data['date'])
obs_data = obs_data[sort_obs]
jd_obs = dpt.mjd_to_jd(dpt.npdt2mjd(obs_data['date']))
date_obs = obs_data['date']
sort_obs = np.argsort(date_obs)
date_obs = date_obs[sort_obs]
r_obs = obs_data['range'][sort_obs]*1e3 #to m
v_obs = -obs_data['doppler_instantaneous'][sort_obs]*1e3 #to m/s
#v_obs = obs_data['doppler_instantaneous'][sort_obs]*1e3 #to m/s
r_sig = 2.0*obs_data['range_err'][sort_obs]*1e3 #to m
v_sig = 2.0*obs_data['doppler_instantaneous_err'][sort_obs]*1e3 #to m/s
#TRUNCATE FOR DEBUG
inds = np.linspace(0,len(jd_obs)-1,num=10,dtype=np.int64)
jd_obs = jd_obs[inds]
r_obs = r_obs[inds]
v_obs = v_obs[inds]
r_sig = r_sig[inds]
v_sig = v_sig[inds]
if ccsds_file.split('/')[-1].split('.')[0] == true_obs_h5.split('/')[-1].split('.')[0]:
print('-- True time diff obs [s] --')
jd_diff = jd_obs - true_obs_jd[inds]
print(jd_diff*3600.0*24.0)
#r_sig = np.full(r_obs.shape, 100.0, dtype=r_obs.dtype)
#v_sig = np.full(v_obs.shape, 10.0, dtype=v_obs.dtype)
r_obs_v.append(r_obs)
r_sig_v.append(r_sig)
v_obs_v.append(v_obs)
v_sig_v.append(v_sig)
t_obs = (jd_obs - prior_jd)*(3600.0*24.0)
#correct for light time approximently
lt_correction = r_obs*0.5/scipy.constants.c
t_obs -= lt_correction
t_obs_v.append(t_obs)
print('='*10 + 'Dates' + '='*10)
print('{:<8}: {} JD'.format('Prior', prior_jd))
for ind, _jd in enumerate(jd_obs):
print('Obs {:<4}: {} JD'.format(ind, _jd))
print('='*10 + 'Observations' + '='*10)
print(len(jd_obs))
prior = {}
prior['cov'] = np.diag([1e3, 1e3, 1e3, 1e1, 1e1, 1e1])*1.0
prior['mu'] = state0
print('='*10 + 'Prior Mean' + '='*10)
print(prior['mu'])
print('='*10 + 'Prior Covariance' + '='*10)
print(prior['cov'])
rx_ecef = []
for rx in radar._rx:
rx_ecef.append(rx.ecef)
tx_ecef = radar._tx[0].ecef
tune = 0
trace = orbit_determination.determine_orbit(
num = 2000,
r = r_obs_v,
sd_r = r_sig_v,
v = v_obs_v,
sd_v = v_sig_v,
grad_dx = [10.0]*3 + [1.0]*3,
rx_ecef = rx_ecef,
tx_ecef = tx_ecef,
t = t_obs_v,
mjd0 = prior_mjd,
params = params,
prior = prior,
propagator = prop,
step = 'Metropolis',
step_opts = {
'scaling': 0.75,
},
pymc_opts = {
'tune': tune,
'discard_tuned_samples': True,
'cores': 1,
'chains': 1,
'parallelize': True,
},
)
#if comm.rank != 0:
# exit()
var = ['$X$ [km]', '$Y$ [km]', '$Z$ [km]', '$V_X$ [km/s]', '$V_Y$ [km/s]', '$V_Z$ [km/s]']
fig = plt.figure(figsize=(15,15))
for ind in range(6):
ax = fig.add_subplot(231+ind)
ax.plot(trace['state'][:,ind]*1e-3)
ax.set(
xlabel='Iteration',
ylabel='{}'.format(var[ind]),
)
state1 = np.mean(trace['state'], axis=0)
print('='*10 + 'Trace summary' + '='*10)
print(pm.summary(trace))
_form = '{:<10}: {}'
print('='*10 + 'Prior Mean' + '='*10)
for ind in range(6):
print(_form.format(var[ind], state0[ind]*1e-3))
print('='*10 + 'Posterior state mean' + '='*10)
for ind in range(6):
print(_form.format(var[ind], state1[ind]*1e-3))
stated = state1 - state0
print('='*10 + 'State shift' + '='*10)
for ind in range(6):
print(_form.format(var[ind], stated[ind]*1e-3))
print('='*10 + 'True posterior' + '='*10)
for ind in range(6):
print(_form.format(var[ind], state0_true[ind]*1e-3))
print('='*10 + 'Posterior error' + '='*10)
for ind in range(6):
print(_form.format(var[ind],(state1[ind] - state0_true[ind])*1e-3))
print('='*10 + 'Parameter shift' + '='*10)
theta0 = {}
theta1 = {}
for key, val in params.items():
if val['dist'] is not None:
theta0[key] = val['mu']
theta1[key] = np.mean(trace[key], axis=0)[0]
print('{}: {}'.format(key, theta1[key] - theta0[key]))
else:
theta0[key] = val['val']
theta1[key] = val['val']
range_v_prior = []
vel_v_prior = []
range_v = []
vel_v = []
range_v_true = []
vel_v_true = []
for rxi in range(len(rx_ecef)):
t_obs = t_obs_v[rxi]
print('Generating tracklet simulated data RX {}: {} points'.format(rxi, len(t_obs)))
states0 = orbit_determination.propagate_state(state0, t_obs, dpt.jd_to_mjd(prior_jd), prop, theta0)
states1 = orbit_determination.propagate_state(state1, t_obs, dpt.jd_to_mjd(prior_jd), prop, theta1)
states0_true = orbit_determination.propagate_state(state0_true, t_obs, dpt.jd_to_mjd(prior_jd), prop, theta1)
range_v_prior += [np.empty((len(t_obs), ), dtype=np.float64)]
vel_v_prior += [np.empty((len(t_obs), ), dtype=np.float64)]
range_v += [np.empty((len(t_obs), ), dtype=np.float64)]
vel_v += [np.empty((len(t_obs), ), dtype=np.float64)]
range_v_true += [np.empty((len(t_obs), ), dtype=np.float64)]
vel_v_true += [np.empty((len(t_obs), ), dtype=np.float64)]
for ind in range(len(t_obs)):
range_v_prior[rxi][ind], vel_v_prior[rxi][ind] = orbit_determination.generate_measurements(states0[:,ind], rx_ecef[rxi], tx_ecef)
range_v[rxi][ind], vel_v[rxi][ind] = orbit_determination.generate_measurements(states1[:,ind], rx_ecef[rxi], tx_ecef)
range_v_true[rxi][ind], vel_v_true[rxi][ind] = orbit_determination.generate_measurements(states0_true[:, ind], rx_ecef[rxi], tx_ecef)
prop_states = orbit_determination.propagate_state(
state0,
np.linspace(0, (np.max(jd_obs) - prior_jd)*(3600.0*24.0), num=1000),
dpt.jd_to_mjd(prior_jd),
prop,
theta1,
)
'''
pop = gen_pop()
obj = pop.get_object(0)
t_obs_pop = t_obs + (dpt.jd_to_mjd(prior_jd) - obj.mjd0)*3600.0*24.0
states0_true2 = obj.get_state(t_obs_pop)
print(states0_true2)
print(states0_true2 - states0_true)
'''
fig = plt.figure(figsize=(15,15))
ax = fig.add_subplot(111, projection='3d')
plothelp.draw_earth_grid(ax)
for ind, ecef in enumerate(rx_ecef):
if ind == 0:
ax.plot([ecef[0]], [ecef[1]], [ecef[2]], 'or', label='EISCAT 3D RX')
else:
ax.plot([ecef[0]], [ecef[1]], [ecef[2]], 'or')
ax.plot(states0[0,:], states0[1,:], states0[2,:], 'xb', label = 'Prior', alpha = 0.75)
ax.plot(states1[0,:], states1[1,:], states1[2,:], 'xr', label = 'Posterior', alpha = 0.75)
ax.plot(prop_states[0,:], prop_states[1,:], prop_states[2,:], '-k', label = 'Prior-propagation', alpha = 0.5)
ax.plot(true_prior[0,:], true_prior[1,:], true_prior[2,:], '-b', label = 'Prior-True', alpha = 0.75)
ax.plot(true_obs[0,:], true_obs[1,:], true_obs[2,:], '-r', label = 'Posterior-True', alpha = 0.75)
ax.legend()
for rxi in range(len(rx_ecef)):
fig = plt.figure(figsize=(15,15))
t_obs_h = t_obs_v[rxi]/3600.0
ax = fig.add_subplot(221)
lns = []
line1 = ax.plot(t_obs_h, (r_obs_v[rxi] - range_v[rxi])*1e-3, '-b', label='Maximum a posteriori: RX{}'.format(rxi))
line0 = ax.plot(t_obs_h, (r_obs_v[rxi] - range_v_true[rxi])*1e-3, '.b', label='True prior: RX{}'.format(rxi))
ax.set(
xlabel='Time [h]',
ylabel='2-way-Range residuals [km]',
)
ax2 = ax.twinx()
line2 = ax2.plot(t_obs_h, (r_obs_v[rxi] - range_v_prior[rxi])*1e-3, '-k', label='Maximum a priori: RX{}'.format(rxi))
ax.tick_params(axis='y', labelcolor='b')
ax2.tick_params(axis='y', labelcolor='k')
lns += line0+line1+line2
labs = [l.get_label() for l in lns]
ax.legend(lns, labs, loc=0)
ax = fig.add_subplot(222)
lns = []
line1 = ax.plot(t_obs_h, (v_obs_v[rxi] - vel_v[rxi])*1e-3, '-b', label='Maximum a posteriori: RX{}'.format(rxi))
line0 = ax.plot(t_obs_h, (v_obs_v[rxi] - vel_v_true[rxi])*1e-3, '.b', label='True prior: RX{}'.format(rxi))
ax.set(
xlabel='Time [h]',
ylabel='2-way-Velocity residuals [km/s]',
)
ax2 = ax.twinx()
line2 = ax2.plot(t_obs_h, (v_obs_v[rxi] - vel_v_prior[rxi])*1e-3, '-k', label='Maximum a priori: RX{}'.format(rxi))
ax.tick_params(axis='y', labelcolor='b')
ax2.tick_params(axis='y', labelcolor='k')
lns += line0+line1+line2
labs = [l.get_label() for l in lns]
ax.legend(lns, labs, loc=0)
ax = fig.add_subplot(223)
ax.errorbar(t_obs_h, r_obs_v[rxi]*1e-3, yerr=r_sig_v[rxi]*1e-3, label='Measurements: RX{}'.format(rxi))
ax.plot(t_obs_h, range_v[rxi]*1e-3, label='Maximum a posteriori: RX{}'.format(rxi))
ax.plot(t_obs_h, range_v_prior[rxi]*1e-3, label='Maximum a priori: RX{}'.format(rxi))
ax.set(
xlabel='Time [h]',
ylabel='2-way-Range [km]',
)
ax.legend()
ax = fig.add_subplot(224)
ax.errorbar(t_obs_h, v_obs_v[rxi]*1e-3, yerr=v_sig_v[rxi]*1e-3, label='Measurements: RX{}'.format(rxi))
ax.plot(t_obs_h, vel_v[rxi]*1e-3, label='Maximum a posteriori: RX{}'.format(rxi))
ax.plot(t_obs_h, vel_v_prior[rxi]*1e-3, label='Maximum a priori: RX{}'.format(rxi))
ax.set(
xlabel='Time [h]',
ylabel='2-way-Velocity [km/s]',
)
ax.legend()
#dpt.posterior(trace['state']*1e-3, var, show=False)
plt.show()
def test_create_tracklet(self):
radar = rlib.eiscat_uhf()
radar.set_FOV(30.0, 25.0)
#tle files for envisat in 2016-09-05 to 2016-09-07 from space-track.
TLEs = [
('1 27386U 02009A 16249.14961597 .00000004 00000-0 15306-4 0 9994',
'2 27386 98.2759 299.6736 0001263 83.7600 276.3746 14.37874511760117'
),
('1 27386U 02009A 16249.42796553 .00000002 00000-0 14411-4 0 9997',
'2 27386 98.2759 299.9417 0001256 82.8173 277.3156 14.37874515760157'
),
('1 27386U 02009A 16249.77590267 .00000010 00000-0 17337-4 0 9998',
'2 27386 98.2757 300.2769 0001253 82.2763 277.8558 14.37874611760201'
),
('1 27386U 02009A 16250.12384028 .00000006 00000-0 15974-4 0 9995',
'2 27386 98.2755 300.6121 0001252 82.5872 277.5467 14.37874615760253'
),
('1 27386U 02009A 16250.75012691 .00000017 00000-0 19645-4 0 9999',
'2 27386 98.2753 301.2152 0001254 82.1013 278.0311 14.37874790760345'
),
]
pop = population_library.tle_snapshot(TLEs, sgp4_propagation=True)
#it seems to around 25m^2 area
d = n.sqrt(25.0 * 4 / n.pi)
pop.add_column('d', space_object_uses=True)
pop['d'] = d
ccsds_file = './data/uhf_test_data/events/2002-009A-1473150428.tdm'
obs_data = ccsds_write.read_ccsds(ccsds_file)
jd_obs = dpt.mjd_to_jd(dpt.npdt2mjd(obs_data['date']))
date_obs = obs_data['date']
sort_obs = n.argsort(date_obs)
date_obs = date_obs[sort_obs]
r_obs = obs_data['range'][sort_obs]
jd_sort = jd_obs.argsort()
jd_obs = jd_obs[jd_sort]
jd_det = jd_obs[0]
jd_pop = dpt.mjd_to_jd(pop['mjd0'])
pop_id = n.argmin(n.abs(jd_pop - jd_det))
obj = pop.get_object(pop_id)
print(obj)
jd_obj = dpt.mjd_to_jd(obj.mjd0)
print('Day difference detection - TLE: {}'.format(jd_det - jd_obj))
t_obs = (jd_obs - jd_obj) * (3600.0 * 24.0)
meas, fnames, ecef_stdevs = simulate_tracklet.create_tracklet(
obj,
radar,
t_obs,
hdf5_out=True,
ccsds_out=True,
dname="./tests/tmp_test_data",
noise=False,
)
out_h5 = fnames[0] + '.h5'
out_ccsds = fnames[0] + '.tdm'
print('FILES: ', fnames)
with h5py.File(out_h5, 'r') as h_det:
assert 'm_range' in h_det
assert 'm_range_rate' in h_det
assert 'm_time' in h_det
sim_data = ccsds_write.read_ccsds(out_ccsds)
date_sim = sim_data['date']
sort_sim = n.argsort(date_sim)
date_sim = date_sim[sort_sim]
r_sim = sim_data['range'][sort_sim]
v_sim = sim_data['doppler_instantaneous'][sort_sim]
lt_correction = n.round(r_sim / scipy.constants.c * 1e6).astype(
n.int64).astype('timedelta64[us]')
date_sim_cor = date_sim + lt_correction
t_sim = dpt.jd_to_unix(dpt.mjd_to_jd(dpt.npdt2mjd(date_sim_cor)))
for ind in range(len(date_sim)):
time_df = (dpt.npdt2mjd(date_sim_cor[ind]) -
dpt.npdt2mjd(date_obs[ind])) * 3600.0 * 24.0
assert time_df < 0.01
assert len(r_obs) == len(r_sim)
dat = {
't': t_sim,
'r': r_sim * 1e3,
'v': v_sim * 1e3,
}
cdat = correlator.correlate(
data=dat,
station=radar._rx[0],
population=pop,
metric=correlator.residual_distribution_metric,
n_closest=1,
out_file=None,
verbose=False,
MPI_on=False,
)
self.assertLess(n.abs(cdat[0]['stat'][0]), 5.0)
self.assertLess(n.abs(cdat[0]['stat'][1]), 50.0)
self.assertLess(n.abs(cdat[0]['stat'][2]), 5.0)
self.assertLess(n.abs(cdat[0]['stat'][3]), 50.0)
nt.assert_array_less(n.abs(r_sim - r_obs), 1.0)
os.remove(out_h5)
print('removed "{}"'.format(out_h5))
os.remove(out_ccsds)
print('removed "{}"'.format(out_ccsds))
sat_folder = os.sep.join(fnames[0].split(os.sep)[:-1])
os.rmdir(sat_folder)
print('removed "{}"'.format(sat_folder))