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},