space_o = space_object.SpaceObject(
a=7000,
e=0.0,
i=69,
raan=0,
aop=0,
mu0=0,
C_D=2.3,
A=1.0,
m=1.0,
C_R=1.0,
oid=42,
d=0.1,
mjd0=57125.7729,
)
print(space_o)
radars = [
radar_library.eiscat_uhf(),
radar_library.eiscat_3d(),
]
radars[0]._tx[0].scan.keyword_arguments(el=45.0)
for radar in radars:
plot_detections(radar, space_o, t_end=24.0 * 3600.0)
plt.show()
def get_t_obs(o,
radar,
n_tracklets=1,
track_length=600.0,
n_points=3,
debug=False,
h0=0.0,
h1=24.0,
half_track=False,
sort_by_length=False,
n_points0=50):
"""
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.
"""
e3d = rl.eiscat_3d(beam='gauss')
# time in seconds after mjd0
t_all = n.linspace(h0 * 3600, h1 * 3600.0, num=1000 * (h1 - h0))
passes, _, _, _, _ = st.find_pass_interval(t_all, o, e3d)
if debug:
print("number of possible tracklets %d" % (len(passes[0])))
if n_tracklets == None:
n_tracklets = len(passes[0])
tracklet_idx = n.arange(len(passes[0]))
n_tracklets = n.min([n_tracklets, len(passes[0])])
tracklet_lengths = []
for pi in tracklet_idx:
p = passes[0][pi]
tracklet_lengths.append(p[1] - p[0])
tracklet_lengths = n.array(tracklet_lengths)
if sort_by_length:
idx = n.argsort(tracklet_lengths)[::-1]
else:
idx = n.arange(len(tracklet_lengths))
# select n_tracklets longest tracklets
tracklet_idx = tracklet_idx[idx[0:n_tracklets]]
t_obss = []
t_means = []
for pii, pi in enumerate(tracklet_idx):
p = passes[0][pi]
mean_t = 0.5 * (p[1] + p[0])
t_means.append(mean_t)
if debug:
print("duration %1.2f" % (p[1] - p[0]))
if p[1] - p[0] > 5.0:
if n_points == 1:
t_obs = n.array([mean_t])
elif pii == 0 and half_track:
# maximize track length, but only observe half of the pass (simulate initial discovery follow-up measurments)
t_obs = n.linspace(mean_t,
n.min([p[1], mean_t + track_length / 2]),
num=n_points0)
else:
# maximize track length
t_obs = n.linspace(n.max([p[0], mean_t - track_length / 2]),
n.min([p[1], mean_t + track_length / 2]),
num=n_points)
t_obss = n.concatenate([t_obss, t_obs])
return (t_obss, n_tracklets, n.array(t_means),
tracklet_lengths[0:n_tracklets])
# space object population
o = so.SpaceObject(a=6670.0,
e=1e-4,
i=89.0,
raan=12.0,
aop=23.0,
mu0=32.0,
A=10**(-2.0),
m=1.0,
d=1.0)
atmospheric_errors(o, a_err_std=0.05)
exit(0)
# radar network
r = rl.eiscat_3d()
error_sweep_time(o, r, a_err_std=0.05)
# error_sweep_n_meas_constn(o,r)
# error_sweep_n_meas(o,r)
# error_sweep_track_length(o,r)
# error_sweep_n(o,r)
#error_sweep_n(o,r)
#error_sweep(o,r)
# create measurements that match specifications
tracklets = create_measurements(o,
r,
track_length=1000.0,
n_tracklets=1,
n_meas=100)
print(tracklets)
def test_tracklets():
# Unit test
#
# Create tracklets and perform orbit determination
#
import population_library as plib
import radar_library as rlib
import simulate_tracking
import simulate_tracklet as st
import os
os.system("rm -Rf /tmp/test_tracklets")
os.system("mkdir /tmp/test_tracklets")
m = plib.master_catalog(sort=False)
# Envisat
o = m.get_object(145128)
print(o)
e3d = rlib.eiscat_3d(beam='gauss')
# time in seconds after mjd0
t_all = n.linspace(0, 24 * 3600, num=1000)
passes, _, _, _, _ = simulate_tracking.find_pass_interval(t_all, o, e3d)
print(passes)
for p in passes[0]:
# 100 observations of each pass
mean_t = 0.5 * (p[1] + p[0])
print("duration %1.2f" % (p[1] - p[0]))
if p[1] - p[0] > 10.0:
t_obs = n.linspace(mean_t - 10, mean_t + 10, num=10)
print(t_obs)
meas, fnames, ecef_stdevs = st.create_tracklet(
o,
e3d,
t_obs,
hdf5_out=True,
ccsds_out=True,
dname="/tmp/test_tracklets")
fl = glob.glob("/tmp/test_tracklets/*")
for f in fl:
print(f)
fl2 = glob.glob("%s/*.h5" % (f))
print(fl2)
fl2.sort()
start_times = []
for f2 in fl2:
start_times.append(re.search("(.*/track-.*)-._..h5", f2).group(1))
start_times = n.unique(start_times)
print("n_tracks %d" % (len(start_times)))
for t_pref in start_times[0:1]:
fl2 = glob.glob("%s*.h5" % (t_pref))
n_static = len(fl2)
if n_static == 3:
print("Fitting track %s" % (t_pref))
f0 = "%s-0_0.h5" % (t_pref)
f1 = "%s-0_1.h5" % (t_pref)
f2 = "%s-0_2.h5" % (t_pref)
print(f0)
print(f1)
print(f2)
h0 = h5py.File(f0, "r")
h1 = h5py.File(f1, "r")
h2 = h5py.File(f2, "r")
r_meas0 = h0["m_range"].value
rr_meas0 = h0["m_range_rate"].value
r_meas1 = h1["m_range"].value
rr_meas1 = h1["m_range_rate"].value
r_meas2 = h2["m_range"].value
rr_meas2 = h2["m_range_rate"].value
n_t = len(r_meas0)
if len(r_meas1) != n_t or len(r_meas2) != n_t:
print(
"non-overlapping measurements, tbd, align measurement")
continue
p_rx = n.zeros([3, 3])
p_rx[:, 0] = h0["rx_loc"].value / 1e3
p_rx[:, 1] = h1["rx_loc"].value / 1e3
p_rx[:, 2] = h2["rx_loc"].value / 1e3
for ti in range(n_t):
if h0["m_time"][ti] != h1["m_time"][ti] or h2["m_time"][
ti] != h0["m_time"][ti]:
print("non-aligned measurement")
continue
m_r = n.array([r_meas0[ti], r_meas1[ti], r_meas2[ti]])
m_rr = n.array([rr_meas0[ti], rr_meas1[ti], rr_meas2[ti]])
ecef_state = orbital_estimation.estimate_state(
m_r, m_rr, p_rx)
true_state = h0["true_state"].value[ti, :]
r_err = 1e3 * n.linalg.norm(ecef_state[0:3] -
true_state[0:3])
v_err = 1e3 * n.linalg.norm(ecef_state[3:6] -
true_state[3:6])
print("pos error %1.3f (m) vel error %1.3f (m/s)" %
(1e3 * n.linalg.norm(ecef_state[0:3] -
true_state[0:3]), 1e3 *
n.linalg.norm(ecef_state[3:6] - true_state[3:6])))
assert r_err < 100.0
assert v_err < 50.0
h0.close()
h1.close()
h2.close()
os.system("rm -Rf /tmp/test_tracklets")
if __name__ == "__main__":
test_envisat()
exit(0)
import population_library as plib
import radar_library as rlib
import simulate_tracking
m = plib.master_catalog()
o = m.get_object(13)
o.diam = 1.0
e3d = rlib.eiscat_3d(beam='gauss')
# time in seconds after mjd0
t_all = n.linspace(0, 24 * 3600, num=1000)
passes, _, _, _, _ = simulate_tracking.find_pass_interval(t_all, o, e3d)
t_mid = (passes[0][0][0] + passes[0][0][1]) * 0.5
t_obs = n.arange(t_mid, t_mid + 2, 0.2)
meas, fnames, ecef_stdevs = create_tracklet(
o,
e3d,
t_obs,
hdf5_out=True,
import radar_scan_library as rslib
import scheduler_library as schlib
import antenna_library as alib
import rewardf_library as rflib
from propagator_neptune import PropagatorNeptune
####### RUN CONFIG #######
part = 4
SIM_TIME = 24.0 * 7.0
##########################
sim_root = '/ZFS_DATA/SORTSpp/FP_sims/E3D_neptune'
#initialize the radar setup
radar = rlib.eiscat_3d(beam='interp', stage=1)
radar.set_FOV(max_on_axis=90.0, horizon_elevation=30.0)
radar.set_SNR_limits(min_total_SNRdb=10.0, min_pair_SNRdb=1.0)
radar.set_TX_bandwith(bw=1.0e6)
#load the input population
pop = plib.master_catalog_factor(
input_file="./data/celn_100.sim",
mjd0=54952.0,
master_base=None,
treshhold=0.01,
seed=None,
propagator=PropagatorNeptune,
propagator_options={},
)
plt.axvline(t / 3600.0, color="C3")
plt.title(
"oid=%d a=%1.0f km log$_{10}$(e)=%1.1f\n mean error %1.1f (m) i=%1.0f d=%1.2f log$_{10}(A/m)=%1.1f$"
% (o.oid, o.a, n.log10(o.e), mean_error, o.i, o.d, n.log10(o.A / o.m)))
plt.xlabel("Time (h)")
plt.ylabel("Position error standard deviation (m)")
plt.show()
if __name__ == "__main__":
h = h5py.File("master/drag_info.h5", "r")
dx = 0.1
dvx = 0.01
dc = 0.01
radar_e3d = rl.eiscat_3d(beam='interp', stage=1)
# space object population
pop_e3d = plib.filtered_master_catalog_factor(
radar=radar_e3d,
treshhold=0.01, # min diam
min_inc=50,
prop_time=48.0,
)
t = n.linspace(0, 24 * 3600, num=1000)
for o in pop_e3d.object_generator():
# get drag info
idx = n.where(h["oid"].value == o.oid)[0]
o.alpha = h["alpha"].value[idx]
o.t1 = h["t1"].value[idx]
def example_err_cov():
radar_e3d = rl.eiscat_3d(beam='interp', stage=1)
o = so.SpaceObject(a=7000.0,
e=1e-3,
i=69,
raan=89,
aop=12,
mu0=47,
d=1.0,
A=1.0,
m=1.0)
t_obs, n_tracklets, t_means, t_lens = get_t_obs(o,
radar_e3d,
n_tracklets=1,
track_length=3600.0,
n_points=3,
h0=0,
h1=24,
sort_by_length=True)
o1 = change_of_epoch_test(o, t_obs[0], plot=False)
o1.alpha = 4.1
o1.beta = 7.8
o1.t1 = 8943.65
t_obs, n_tracklets, t_means, t_lens = get_t_obs(o1,
radar_e3d,
n_tracklets=1,
track_length=3600.0,
n_points=3,
h0=-1,
h1=1,
sort_by_length=True)
error_cov, range_0 = linearized_errors(o1,
radar_e3d,
t_obs,
include_drag=True)
mean_error, last_error = sample_orbit(
o1,
error_cov,
t_obs, # mean measurement times
plot_t_means=t_obs, # where to plot lines for measurement times
plot=True,
t_obs=n.linspace(-12 * 3600, 12 * 3600, num=1000),
use_atmospheric_errors=False,
fname="report_plots/err_cov_ex1.png")
t_obs, n_tracklets, t_means, t_lens = get_t_obs(o1,
radar_e3d,
n_tracklets=2,
track_length=3600.0,
n_points=3,
h0=-12,
h1=12,
sort_by_length=True)
error_cov, range_0 = linearized_errors(o1,
radar_e3d,
t_obs,
include_drag=True)
mean_error, last_error = sample_orbit(
o1,
error_cov,
t_means, # mean measurement times
plot_t_means=t_obs, # where to plot lines for measurement times
plot=True,
t_obs=n.linspace(-12 * 3600, 12 * 3600, num=1000),
use_atmospheric_errors=False,
fname="report_plots/err_cov_ex2.png")
t_obs, n_tracklets, t_means, t_lens = get_t_obs(o1,
radar_e3d,
n_tracklets=10,
track_length=3600.0,
n_points=3,
h0=-12,
h1=12,
sort_by_length=True)
error_cov, range_0 = linearized_errors(o1,
radar_e3d,
t_obs,
include_drag=True)
mean_error, last_error = sample_orbit(o1,
error_cov,
t_means,
plot_t_means=t_obs,
plot=True,
t_obs=n.linspace(-12 * 3600,
12 * 3600,
num=1000),
use_atmospheric_errors=False,
fname="report_plots/err_cov_ex3.png")
mean_error, last_error = sample_orbit(o1,
error_cov,
t_means,
plot_t_means=t_obs,
plot=True,
t_obs=n.linspace(-96 * 3600,
96 * 3600,
num=1000),
use_atmospheric_errors=True,
fname="report_plots/err_cov_ex4.png")
def wls_state_est(mcmc=False, n_tracklets=1, track_length=600.0, n_points=3, oid=145128, N_samples=5000):
"""
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
m = plib.master_catalog(sort=False)
o = m.get_object(oid)
dname="./test_tracklets_%d"%(oid)
print(o)
# figure out epoch in unix seconds
t0_unix = dpt.jd_to_unix(dpt.mjd_to_jd(o.mjd0))
if rank == 0:
os.system("rm -Rf %s"%(dname))
os.system("mkdir %s"%(dname))
e3d = rlib.eiscat_3d(beam='gauss')
# time in seconds after mjd0
t_all = n.linspace(0, 24*3600, num=1000)
passes, _, _, _, _ = simulate_tracking.find_pass_interval(t_all, o, e3d)
print(passes)
if n_tracklets == None:
n_tracklets = len(passes[0])
n_tracklets = n.min([n_tracklets,len(passes[0])])
for pi in range(n_tracklets):
p = passes[0][pi]
mean_t=0.5*(p[1]+p[0])
print("duration %1.2f"%(p[1]-p[0]))
if p[1]-p[0] > 50.0:
if n_points == 1:
t_obs=n.array([mean_t])
else:
t_obs=n.linspace(n.max([p[0],mean_t-track_length/2]), n.min([p[1],mean_t+track_length/2]),num=n_points)
print(t_obs)
meas, fnames, ecef_stdevs = st.create_tracklet(o, e3d, t_obs, hdf5_out=True, ccsds_out=True, dname=dname)
# then we read these measurements
comm.Barrier()
fl=glob.glob("%s/*"%(dname))
for f in fl:
print(f)
fl2=glob.glob("%s/*.h5"%(f))
print(fl2)
fl2.sort()
true_states=[]
all_r_meas=[]
all_rr_meas=[]
all_t_meas=[]
all_true_states=[]
tx_locs=[]
rx_locs=[]
range_stds=[]
range_rate_stds=[]
for mf in fl2:
h=h5py.File(mf,"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_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()
# determine orbital elements
o_prior = m.get_object(oid)
# 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)
#!/usr/bin/env python
import numpy as np
import matplotlib.pyplot as plt
import population_library as plib
import radar_library as rlib
from propagator_orekit import PropagatorOrekit
from sorts_config import p as default_propagator
radars = [
rlib.eiscat_3d(),
#rlib.eiscat_3d(stage = 2),
rlib.eiscat_3d_module(),
]
master_in = "./master/celn_20090501_00.sim"
SNRs = [1.0, 10.0]
for SNR_lim in SNRs:
for radar in radars:
radar.set_SNR_limits(SNR_lim, SNR_lim)
ofname = master_in[:-4]\
+ '_' + radar.name.replace(' ', '_')\
+ '_' + default_propagator.__name__\
+ '_' + str(int(np.round(radar.min_SNRdb))) + 'SNRdB'\
+ '.h5'
print('Output file: {}'.format(ofname))
def validate_simulation(root):
sim_root = root + '/tests/tmp_test_data/ENVISAT_TRACKING'
SIM_TIME = 15.0
pop = gen_pop()
#initialize the radar setup
radar = rlib.eiscat_3d(beam='interp', stage=1)
radar.set_FOV(max_on_axis=90.0, horizon_elevation=30.0)
radar.set_SNR_limits(min_total_SNRdb=10.0, min_pair_SNRdb=1.0)
radar.set_TX_bandwith(bw = 1.0e6)
sim = Simulation(
radar = radar,
population = pop,
root = sim_root,
scheduler = schlib.dynamic_scheduler,
simulation_name = 'ENVISAT validation',
)
sim.set_log_level(logging.INFO)
sim.observation_parameters(
duty_cycle=0.25,
SST_fraction=1.0,
tracking_fraction=1.0,
SST_time_slice=0.2,
)
sim.simulation_parameters(
tracklet_noise=True,
max_dpos=50e3,
auto_synchronize=True,
)
#We know all!
sim.catalogue.maintain(slice(None))
################## RUNNING #####################
sim.run_observation(SIM_TIME)
sim.status(fout='{}h_to_{}h'.format(0, int(SIM_TIME)))
sim.print_maintenance()
sim.print_detections()
sim.set_scheduler_args(
reward_function = rflib.rewardf_exp_peak_SNR_tracklet_len,
reward_function_config = {
'sigma_t': 60.0*5.0,
'lambda_N': 50.0,
},
logger = sim.logger,
)
sim.run_scheduler()
sim.print_tracks()
sim.print_tracklets()
sim.status(fout='{}h_to_{}h_scheduler'.format(0, int(SIM_TIME)))
sim.generate_tracklets()
sim.generate_priors()
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_envisat():
import dpt_tools as dpt
import space_object as so
import radar_library as rl
import stuffr
mass = 0.8111E+04
diam = 0.8960E+01
m_to_A = 128.651
a = 7159.5
e = 0.0001
i = 98.55
raan = 248.99
aop = 90.72
M = 47.37
A = mass / m_to_A
# epoch in unix seconds
ut0 = 1241136000.0
# modified julian day epoch
mjd0 = dpt.unix_to_jd(ut0) - 2400000.5
print(mjd0)
o = so.SpaceObject(a=a,
e=e,
i=i,
raan=raan,
aop=aop,
mu0=M,
C_D=2.3,
A=A,
m=mass,
diam=diam,
mjd0=mjd0)
e3d = rl.eiscat_3d()
print("EISCAT Skibotn location x,y,z ECEF (meters)")
print(e3d._tx[0].ecef)
ski_ecef = e3d._tx[0].ecef
print("EISCAT Skibotn location %1.3f %1.3f %1.3f (lat,lon,alt)" %
(e3d._tx[0].lat, e3d._tx[0].lon, 0.0))
t_obs = n.linspace(4440, 5280, num=100) + 31.974890
t_obs2 = n.linspace(4440, 5280, num=100) + 31.974890 + 1.0
# t_obs=n.linspace(0,5280,num=100)
# t_obs2=n.linspace(0,5280,num=100)+1
print(
"MJD %1.10f %sZ" %
(mjd0 + t_obs[0] / 3600.0 / 24.0, stuffr.unix2datestr(ut0 + t_obs[0])))
ecef = o.get_state(t_obs)
ecef2 = o.get_state(t_obs2)
print("ECEF state x,y,z,vx,vy,vz (km and km/s)")
print(ecef[:, 0] / 1e3)
print(
"Time (UTC) Range (km) Vel (km/s) ECEF X (km) ECEF Y (km) ECEF Z (km)"
)
for i in range(len(t_obs)):
dist = n.linalg.norm(ecef[0:3, i] - ski_ecef)
dist2 = n.linalg.norm(ecef2[0:3, i] - ski_ecef)
vel = (dist2 - dist) / 1.0
print("%s %1.3f %1.3f %1.3f %1.3f %1.3f" %
(stuffr.unix2datestr(ut0 + t_obs[i]), dist / 1e3, vel / 1e3,
ecef[0, i] / 1e3, ecef[1, i] / 1e3, ecef[2, i] / 1e3))
def initial_discovery(beam_width=1.0):
"""
Simulate the process of object acquisition into a catalog.
"""
lost_threshold = 10e3
mean_error_threshold = 100.0
h = h5py.File("master/drag_info.h5", "r")
radar_e3d = rl.eiscat_3d(beam='interp', stage=1)
# space object population
pop_e3d = plib.filtered_master_catalog_factor(
radar=radar_e3d,
treshhold=0.01, # min diam
min_inc=50,
prop_time=48.0,
)
t = n.linspace(0, 24 * 3600, num=1000)
mean_error_l = []
oid_l = []
n_tracklets_l = []
n_tracklets_per_day_l = []
n_points_l = []
o_idx_c = 0
objs = []
okay_ids = []
okay_errs = []
all_ids = []
for o in pop_e3d.object_generator():
objs.append(o)
for oi in range(comm.rank, len(objs), comm.size):
o = objs[oi]
all_ids.append(o.oid)
# get drag info
idx = n.where(h["oid"].value == o.oid)[0]
o.alpha = h["alpha"].value[idx]
o.t1 = h["t1"].value[idx]
o.beta = h["beta"].value[idx]
n_tracklets = 0
# get measurement times
try:
all_t_obs, all_n_tracklets, all_t_means, all_t_lens = get_t_obs(
o,
radar_e3d,
n_tracklets=24,
track_length=3600.0,
n_points=1,
h0=0.0,
h1=48,
sort_by_length=False)
ho = h5py.File("iods/iods_info_%02d.h5" % (comm.rank), "w")
ho["okay"] = okay_ids
ho["okay_errs"] = okay_errs
ho["all"] = all_ids
ho.close()
for ti, t0 in enumerate(all_t_means):
print("initial discovery simulation oid %d, iod %d" %
(o.oid, ti))
t_obs, n_tracklets, t_means, t_lens = get_t_obs(
o,
radar_e3d,
n_tracklets=1,
track_length=3600.0,
n_points=1,
h0=t0 / 3600 - 1.0,
h1=49,
sort_by_length=False)
initial_t0 = t_obs[0]
# change epoch to discovery, so that at detection t=0
o2 = change_of_epoch_test(o, t_obs[0], plot=False)
o2.alpha = o.alpha
o2.t1 = o.t1
o2.beta = o.beta
o2.oid = o.oid
# drag not important for a < 10 minute interval
error_cov, range_0 = linearized_errors(o2,
radar_e3d,
t_obs - initial_t0,
include_drag=False)
lost_threshold = range_0 * n.sin(
n.pi * beam_width / 180.0) * 1e3
print("range_0 %f km lost_threshold %f (m)" %
(range_0, lost_threshold))
mean_error, last_error, max_error = sample_orbit(
o2,
error_cov,
t_means - initial_t0,
plot_t_means=t_obs - initial_t0,
plot=True,
t_obs=n.linspace(0, t_lens[0], num=200),
use_atmospheric_errors=False,
fname="iods/iod_%d_%03d_00.png" % (o.oid, ti),
max_error=lost_threshold)
if last_error > lost_threshold:
print("object lost")
continue
t_obs_next, n_tracklets_next, t_means_next, t_lens_next = get_t_obs(
o,
radar_e3d,
n_tracklets=24,
track_length=3600.0,
n_points=1,
h0=initial_t0 / 3600.0 + 1.0,
h1=48 + initial_t0 / 3600.0,
sort_by_length=False,
n_points0=50)
for nti in range(n_tracklets_next):
next_pass_hour = (t_obs_next[nti] - initial_t0) / 3600.0
t_obs, n_tracklets, t_means, t_lens = get_t_obs(
o,
radar_e3d,
n_tracklets=nti + 1,
track_length=3600.0,
n_points=10,
h0=initial_t0 / 3600.0 - 1.0,
h1=49 + initial_t0 / 3600.0,
half_track=True,
sort_by_length=False,
n_points0=50)
error_cov, range_0 = linearized_errors(o2,
radar_e3d,
t_obs - initial_t0,
include_drag=True)
mean_error, last_error, max_error = sample_orbit(
o2,
error_cov,
t_means - initial_t0,
plot_t_means=t_obs - initial_t0,
plot=True,
t_obs=n.linspace(0, next_pass_hour * 3600.0, num=1000),
fname="iods/iod_%d_%03d_%02d.png" %
(o.oid, ti, nti + 1),
max_error=lost_threshold,
use_atmospheric_errors=True)
print("%d th pass %f mean_error %f" %
(nti + 1, next_pass_hour, mean_error))
if last_error > lost_threshold:
print("object lost")
break
print(nti)
if nti == (n_tracklets_next - 1) and (n_tracklets_next > 2):
okay_ids.append(o.oid)
okay_errs.append(mean_error)
print("object acquired")
break
except:
print("problem.")
pass
def gen_simulation(part = 4):
import time
import sys
import os
import logging
import glob
import shutil
import pymc3 as pm
import h5py
import scipy
from mpi4py import MPI
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
# SORTS imports CORE
import population_library as plib
from simulation import Simulation
from population import Population
#SORTS Libraries
import radar_library as rlib
import population_library as plib
import radar_scan_library as rslib
import scheduler_library as schlib
import antenna_library as alib
import rewardf_library as rflib
import plothelp
import dpt_tools as dpt
import ccsds_write
sim_root = './tests/tmp_test_data/test_sim2'
np.random.seed(12345) #NEEDED
SIM_TIME = 24.0*4
pop = plib.master_catalog()
pop.objs = pop.objs[:10]
#initialize the radar setup
radar = rlib.eiscat_3d(beam='interp', stage=1)
radar.set_FOV(max_on_axis=90.0, horizon_elevation=30.0)
radar.set_SNR_limits(min_total_SNRdb=10.0, min_pair_SNRdb=1.0)
radar.set_TX_bandwith(bw = 1.0e6)
sim = Simulation(
radar = radar,
population = pop,
root = sim_root,
scheduler = schlib.dynamic_scheduler,
simulation_name = 'OD validation',
)
#sim.set_log_level(logging.DEBUG)
sim.observation_parameters(
duty_cycle=0.25,
SST_fraction=1.0,
tracking_fraction=1.0,
SST_time_slice=0.2,
)
sim.simulation_parameters(
tracklet_noise=True,
max_dpos=50e3,
auto_synchronize=True,
)
#We know all!
sim.catalogue.maintain(slice(None))
################## RUNNING #####################
if part == 1:
sim.run_observation(SIM_TIME)
sim.status(fout='{}h_to_{}h'.format(0, int(SIM_TIME)))
sim.print_maintenance()
sim.print_detections()
sim.set_scheduler_args(
reward_function = rflib.rewardf_exp_peak_SNR_tracklet_len,
reward_function_config = {
'sigma_t': 60.0*5.0,
'lambda_N': 50.0,
},
logger = sim.logger,
)
sim.run_scheduler()
sim.print_tracks()
sim.print_tracklets()
sim.status(fout='{}h_to_{}h_scheduler'.format(0, int(SIM_TIME)))
if part == 2:
sim.load()
sim.generate_tracklets()
if part == 3:
sim.load()
sim.generate_priors(
frame_transformation='TEME',
tracklet_truncate = slice(None, None, 20),
)
if part == 4:
sim.load()
sim.run_orbit_determination(
frame_transformation = 'TEME',
error_samp = 500,
steps = 10000,
max_zenith_error = 0.9,
tracklet_truncate = slice(None, None, 400),
tune = 1000,
)
def catalogue_maintenance(mean_error_threshold=100.0):
"""
figure out:
- what are times of observations of objects
- how many pulses are needed in order to maintain the objects
- store results
This can be used to "design" measurements for catalog objects.
"""
h = h5py.File("master/drag_info.h5", "r")
radar_e3d = rl.eiscat_3d(beam='interp', stage=1)
# space object population
pop_e3d = plib.filtered_master_catalog_factor(
radar=radar_e3d,
treshhold=0.01, # min diam
min_inc=50,
prop_time=48.0,
)
objs = []
for o in pop_e3d.object_generator():
objs.append(o)
all_ids = []
t = n.linspace(-12 * 3600, (24 + 12) * 3600, num=1000)
for oi in range(comm.rank, len(objs), comm.size):
o = objs[oi]
all_ids.append(o.oid)
# get drag info
idx = n.where(h["oid"].value == o.oid)[0]
o.alpha = h["alpha"].value[idx]
o.t1 = h["t1"].value[idx]
o.beta = h["beta"].value[idx]
for n_points in [1, 3, 10]:
t_obs, n_tracklets, t_means, t_lens = get_t_obs(
o,
radar_e3d,
n_tracklets=100,
track_length=3600.0,
n_points=n_points,
h0=-12,
h1=24 + 12,
sort_by_length=True)
error_cov, range_0 = linearized_errors(o,
radar_e3d,
t_obs,
include_drag=True)
mean_error, last_error, max_error = sample_orbit(
o,
error_cov,
t_means,
plot_t_means=t_obs,
plot=True,
use_atmospheric_errors=True,
save_if_okay=False,
fname="tracks/track-%d.png" % (o.oid),
mean_error_threshold=mean_error_threshold,
t_obs=t)
print(
"rank %d oid %d a %1.0f n_passes per day %f n_points %d mean_error %f (m)"
% (comm.rank, o.oid, o.a, n_tracklets / 2.0, n_points,
mean_error))
ho = h5py.File("tracks/track-%d.h5" % (o.oid), "w")
ho["t_obs"] = t_obs
ho["n_points"] = n_points
ho["n_tracklets"] = n_tracklets
ho["t_means"] = t_means
ho["t_lens"] = t_lens
ho["mean_error"] = mean_error
ho["last_error"] = last_error
ho["max_error"] = max_error
ho.close()
if mean_error < mean_error_threshold:
break
import sys
sys.path.insert(0, "/home/danielk/IRF/IRF_GITLAB/SORTSpp")
# SORTS imports CORE
import population as p
#SORTS Libraries
import radar_library as rl
import radar_scan_library as rslib
import scheduler_library as sch
import antenna_library as alib
import space_object as so
import simulate_tracking
#initialize the radar setup
radar = rl.eiscat_3d()
radar.set_FOV(max_on_axis=25.0, horizon_elevation=30.0)
radar.set_SNR_limits(min_total_SNRdb=10.0, min_pair_SNRdb=0.0)
radar.set_TX_bandwith(bw = 1.0e6)
radar.set_beam('TX', alib.e3d_array_beam_stage1(opt='dense') )
radar.set_beam('RX', alib.e3d_array_beam() )
o = so.space_object(
a=7000, e=0.0, i=72,
raan=0, aop=0, mu0=0,
C_D=2.3, A=1.0, diam=0.7,
m=1.0,
)
#Get detections for 1 d
sys.path.insert(0, "/home/danielk/SORTSpp")
# SORTS imports CORE
import population as p
import simulation as s
#SORTS Libraries
import radar_library as rl
import radar_scan_library as rslib
import scheduler_library as sch
import antenna_library as alib
sim_root = '/home/danielk/maint_test'
#initialize the radar setup
e3d = rl.eiscat_3d()
e3d.set_FOV(max_on_axis=25.0, horizon_elevation=30.0)
e3d.set_SNR_limits(min_total_SNRdb=10.0, min_pair_SNRdb=0.0)
e3d.set_TX_bandwith(bw=1.0e6)
e3d.set_beam(
'TX',
alib.planar_beam(az0=0.0,
el0=90.0,
lat=60,
lon=19,
f=233e6,
I_0=10**4.2,
a0=40.0,
az1=0,
el1=90.0))
plt.legend()
plt.show()
if __name__ == "__main__":
import radar_library as rl
from propagator_sgp4 import PropagatorSGP4
import radar_scan_library as rslib
import antenna_library as alib
import logging_setup
import logging
t0 = time.time()
#radar=rl.eiscat_3d(beam='array')
radar = rl.eiscat_3d(beam='gauss')
# get all detections for this space object
obj = so.SpaceObject(
a=7000,
e=0.0,
i=72,
raan=0,
aop=0,
mu0=0,
C_D=2.3,
A=1.0,
m=1.0,
d=0.7,
propagator=PropagatorSGP4,
propagator_options={'polar_motion': False},
