def main(): sim_config = simulation_configuration() sim_config.doppler_resolution = 50 # Hz sim_config.delay_resolution = 0.2/gps_ca_chips_per_second # seconds delay_increment_start = sim_config.delay_increment_start delay_increment_end = sim_config.delay_increment_end delay_resolution = sim_config.delay_resolution doppler_increment_start = sim_config.doppler_increment_start doppler_increment_end = sim_config.doppler_increment_end doppler_resolution = sim_config.doppler_resolution delay_chip = sim_config.delay_chip # Delay Doppler grid delay_increment_values = list(np.arange( delay_increment_start, delay_increment_end, delay_resolution )) doppler_increment_values = list(np.arange( doppler_increment_start, doppler_increment_end, doppler_resolution )) doppler_specular_point = eq_doppler_absolute_shift(np.array([0,0,0]), sim_config) doppler_absolute_values = doppler_increment_values + doppler_specular_point delay_grid, doppler_grid = np.meshgrid(delay_increment_values, doppler_absolute_values) # Sigma sigma_matrix = sigma(delay_grid, doppler_grid, sim_config) # Plot fig_sigma, ax_sigma = plt.subplots(1,figsize=(10, 4)) ax_sigma.set_title('Sigma') im = ax_sigma.imshow(sigma_matrix, cmap='viridis', extent=(delay_increment_start/delay_chip, delay_increment_end/delay_chip, doppler_increment_start, doppler_increment_end), aspect="auto" ) plt.show()
def add_thermal_noise(n_rows, n_cols, n_incoherent, noise_temperature, ddm_power, sim_config): sim_config = simulation_configuration() delay_start = sim_config.delay_increment_start delay_end = sim_config.delay_increment_end delay_resolution = (delay_end - delay_start) / n_cols k_b = 1.38e-23 # J/K #T_r = 225.7 # K T_r = noise_temperature delay_values = list(np.arange(delay_start, delay_end, delay_resolution)) covariance = np.zeros((len(delay_values), len(delay_values))) for i, col in enumerate(covariance): for j, val in enumerate(col): covariance[i, j] = 2 / 1e-3 * 2 * k_b * T_r * waf_delay( delay_values[j] - delay_values[i], sim_config) fig_covar, ax_covar = plt.subplots(1, figsize=(10, 4)) contour_ddm = ax_covar.imshow(covariance, cmap='jet', aspect="auto") ddm_noise = np.zeros((n_rows, len(delay_values))) for i in range(n_incoherent): print("i: {0}".format(i)) ddm_noise_i = np.power( np.random.multivariate_normal(np.zeros(len(delay_values)), covariance, (n_rows)), 2) ddm_noise += ddm_noise_i / np.sqrt(n_incoherent) + ddm_power ddm_noise /= n_incoherent fig_ddm_noise, ax_ddm_noise = plt.subplots(1, figsize=(10, 4)) contour_ddm_noise = ax_ddm_noise.imshow(ddm_noise, cmap='jet', aspect="auto") cbar = fig_ddm_noise.colorbar(contour_ddm_noise, label='Power') return ddm_noise
def main(): sim_config = simulation_configuration() sim_config.set_scenario_local_ref( h_t=13.82e6, # m h_r=50000e3, # meters elevation=60.0 * np.pi / 180, v_t=np.array([-2684.911, 1183.799, -671.829]), # m/s v_r=np.array([20, 20, 20]) # m/s ) sim_config.rcs = lambda p1, p2: target_rcs.radar_cross_section(p1, 0, p2) sim_config.u_10 = 8.0 # m/s #sim_config.delay_chip = 1/gps_ca_chips_per_second # seconds delay_chip = sim_config.delay_chip sim_config.doppler_increment_start = -50 sim_config.doppler_increment_end = 50 sim_config.doppler_resolution = 0.5 sim_config.delay_increment_start = -0.5 * delay_chip sim_config.delay_increment_end = 2 * delay_chip sim_config.delay_resolution = 0.01 * delay_chip sim_config.coherent_integration_time = 2e-2 # sec delay_increment_start = sim_config.delay_increment_start delay_increment_end = sim_config.delay_increment_end delay_resolution = sim_config.delay_resolution doppler_increment_start = sim_config.doppler_increment_start doppler_increment_end = sim_config.doppler_increment_end doppler_resolution = sim_config.doppler_resolution doppler_specular_point = eq_doppler_absolute_shift(np.array([0, 0, 0]), sim_config) number_of_delay_pixels = 128 - 50 number_of_doppler_pixels = 20 + 50 rescaled_doppler_resolution = ( doppler_increment_end - doppler_increment_start) / number_of_doppler_pixels rescaled_delay_resolution_chips = ( delay_increment_end - delay_increment_start) / delay_chip / number_of_delay_pixels print("doppler res: {0}".format(rescaled_doppler_resolution)) print("delay res: {0}".format(rescaled_delay_resolution_chips)) # Surface mesh x_0 = 0 x_1 = 6e3 # meters n_x = 800 y_0 = -1e3 y_1 = 6e3 # meters n_y = 800 x_grid, y_grid = np.meshgrid(np.linspace(x_0, x_1, n_x), np.linspace(y_0, y_1, n_y)) r = np.array([x_grid, y_grid, 0]) # Isolines and RCS z_grid_delay_chip = eq_delay_incremet(r, sim_config) / delay_chip doppler_specular_point = eq_doppler_absolute_shift(np.array([0, 0, 0]), sim_config) z_grid_doppler_increment = eq_doppler_absolute_shift( r, sim_config) - doppler_specular_point z_rcs = sim_config.rcs(r, sim_config) # Plot fig_rcs, ax_rcs = plt.subplots(1, figsize=(10, 4)) #contour_delay_chip = ax_rcs.contour( # x_grid, y_grid, z_grid_delay_chip, # np.arange(0, 2, 0.1), # cmap='winter', alpha = 0.3 # ) #contour_doppler = ax_rcs.contour( # x_grid, y_grid, z_grid_doppler_increment, # np.arange(-50, 50, 1), # cmap='jet', alpha = 0.3 # ) contour_rcs = ax_rcs.contourf(x_grid, y_grid, z_rcs, 55, cmap='jet', alpha=0.8) ax_rcs.set_title('RCS') plt.xlabel('[km]') plt.ylabel('[km]') #fig_rcs.colorbar(contour_delay_chip, label='C/A chips') #fig_rcs.colorbar(contour_doppler, label='Hz') fig_rcs.colorbar(contour_rcs, label='Gain') target_delay_increment = 0.54 target_doppler_increment = 17.35 target_delay = 1.26 target_doppler = 22 target_iso_delay = ax_rcs.contour( x_grid, y_grid, z_grid_delay_chip, #[target_delay_increment-0.1], [target_delay - rescaled_delay_resolution_chips], colors='red', linewidths=2.5, linestyles='dashed', ) target_iso_delay = ax_rcs.contour( x_grid, y_grid, z_grid_delay_chip, #[target_delay_increment+0.1], [target_delay + rescaled_delay_resolution_chips], colors='red', linewidths=2.5, linestyles='dashed', ) target_iso_delay = ax_rcs.contour( x_grid, y_grid, z_grid_doppler_increment, #[target_doppler_increment-0.5], [target_doppler - rescaled_doppler_resolution], colors='red', linewidths=2.5, linestyles='dashed', ) target_iso_delay = ax_rcs.contour( x_grid, y_grid, z_grid_doppler_increment, #[target_doppler_increment+0.5], [target_doppler + rescaled_doppler_resolution], colors='red', linewidths=2.5, linestyles='dashed', ) ticks_y = ticker.FuncFormatter(lambda y, pos: '{0:g}'.format(y / 1000)) ticks_x = ticker.FuncFormatter(lambda x, pos: '{0:g}'.format(x / 1000)) ax_rcs.xaxis.set_major_formatter(ticks_x) ax_rcs.yaxis.set_major_formatter(ticks_y) # DDM ddm_sim = np.copy(simulate_ddm(sim_config)) sim_config.rcs = sea_rcs.radar_cross_section #sim_config.rcs = lambda p1,p2: target_rcs.radar_cross_section(p1, 0, p2) sim_config.u_10 = 8.0 # m/s ddm_sim_1 = np.copy(simulate_ddm(sim_config)) T_noise_receiver = 225 k_b = 1.38e-23 # J/K y_noise = sim_config.coherent_integration_time * k_b * T_noise_receiver ddm_diff_snr = 10 * np.log10(np.abs(ddm_sim - ddm_sim_1) / y_noise) fig_diff, ax_diff = plt.subplots(1, figsize=(10, 4)) plt.title('DDM diff simulation') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_diff_snr = ax_diff.imshow( ddm_diff_snr, cmap='jet', extent=(delay_increment_start / delay_chip, delay_increment_end / delay_chip, doppler_increment_end, doppler_increment_start), aspect="auto") fig_diff.colorbar(contour_diff_snr, label='SNR [dB]') fig_ddm, ax_ddm = plt.subplots(1, figsize=(10, 4)) plt.title('DDM original simulation') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_sim = ax_ddm.imshow(ddm_sim, cmap='jet', extent=(delay_increment_start / delay_chip, delay_increment_end / delay_chip, doppler_increment_end, doppler_increment_start), aspect="auto") fig_ddm.colorbar(contour_sim, label='Correlated Power [W]') # Image downscaling to desired resolution: # TODO: This is just an average of the pixels around the area # This is not valid, summation i srequired: # Di Simone > From a physical viewpoint, # such an approach should call for summation instead of averaging # https://stackoverflow.com/questions/48121916/numpy-resize-rescale-image fig_ddm_rescaled, ax_ddm_rescaled = plt.subplots(1, figsize=(10, 4)) plt.title('Simulation') plt.xlabel('C/A chips') plt.ylabel('Hz') #ddm_rescaled = rescale(ddm_diff, number_of_doppler_pixels, number_of_delay_pixels) ddm_sim_res = rescale(ddm_sim, number_of_doppler_pixels, number_of_delay_pixels) ddm_sim_1_res = rescale(ddm_sim_1, number_of_doppler_pixels, number_of_delay_pixels) ddm_diff_res = np.abs(ddm_sim_res - ddm_sim_1_res) contour_diff_res = ax_ddm_rescaled.imshow( ddm_diff_res, cmap='jet', extent=(delay_increment_start / delay_chip, delay_increment_end / delay_chip, doppler_increment_end, doppler_increment_start), aspect='auto') fig_ddm_rescaled.colorbar(contour_diff_res, label='Correlated Power [W]') plt.show()
def main(): sim_config = simulation_configuration() #sim_config.jacobian_type = 'spherical' sim_config.receiver_antenna_gain = lambda p1,p2: 12.589 sim_config.set_scenario_local_ref( h_t = 18e6, # m h_r = 20e3, # meters elevation = 70.0*np.pi/180, v_t = np.array([-2684.911, 1183.799, -671.829]), # m/s v_r = np.array([20, 20, 20]) # m/s ) #sim_config.rcs = sea_rcs.radar_cross_section sim_config.rcs = lambda p1,p2: target_rcs.radar_cross_section(p1, 0.0, p2) sim_config.u_10 = 5.0 # m/s #sim_config.delay_chip = 1/gps_ca_chips_per_second # seconds delay_chip = sim_config.delay_chip sim_config.doppler_increment_start = -100 sim_config.doppler_increment_end = 100 sim_config.delay_increment_start = -0.2*delay_chip sim_config.delay_increment_end = 3*delay_chip sim_config.coherent_integration_time = 2e-2 # sec delay_increment_start = sim_config.delay_increment_start delay_increment_end = sim_config.delay_increment_end delay_resolution = sim_config.delay_resolution doppler_increment_start = sim_config.doppler_increment_start doppler_increment_end = sim_config.doppler_increment_end doppler_resolution = sim_config.doppler_resolution doppler_specular_point = eq_doppler_absolute_shift(np.array([0,0,0]), sim_config) number_of_delay_pixels = 128 - 50 number_of_doppler_pixels = 20 + 50 rescaled_doppler_resolution = (doppler_increment_end - doppler_increment_start)/number_of_doppler_pixels rescaled_delay_resolution_chips = (delay_increment_end - delay_increment_start)/number_of_delay_pixels sim_config.delay_resolution = rescaled_delay_resolution_chips/4 sim_config.doppler_resolution = rescaled_doppler_resolution/4 print("doppler res: {0}".format(rescaled_doppler_resolution)) print("delay res: {0}".format(rescaled_delay_resolution_chips)) # Surface mesh x_0 = 0 x_1 = 6e3 # meters n_x = 800 y_0 = -1e3 y_1 = 6e3 # meters n_y = 800 x_grid, y_grid = np.meshgrid( np.linspace(x_0, x_1, n_x), np.linspace(y_0, y_1, n_y) ) r = np.array([x_grid, y_grid, 0]) # Isolines and RCS z_grid_delay_chip = eq_delay_incremet(r, sim_config)/delay_chip doppler_specular_point = eq_doppler_absolute_shift(np.array([0,0,0]), sim_config) z_grid_doppler_increment = eq_doppler_absolute_shift(r, sim_config) - doppler_specular_point z_rcs = sim_config.rcs(r, sim_config) # Plot fig_rcs, ax_rcs = plt.subplots(1,figsize=(10, 4)) #contour_delay_chip = ax_rcs.contour( # x_grid, y_grid, z_grid_delay_chip, # np.arange(0, 2, 0.1), # cmap='winter', alpha = 0.3 # ) #contour_doppler = ax_rcs.contour( # x_grid, y_grid, z_grid_doppler_increment, # np.arange(-50, 50, 1), # cmap='jet', alpha = 0.3 # ) contour_rcs = ax_rcs.contourf(x_grid, y_grid, z_rcs, 55, cmap='jet', alpha = 0.8) ax_rcs.set_title('RCS') plt.xlabel('[km]') plt.ylabel('[km]') #fig_rcs.colorbar(contour_delay_chip, label='C/A chips') #fig_rcs.colorbar(contour_doppler, label='Hz') fig_rcs.colorbar(contour_rcs, label='Gain') target_delay_increment = 0.54 target_doppler_increment = 17.35 target_delay = 1.26 target_doppler = 22 target_iso_delay = ax_rcs.contour(x_grid, y_grid, z_grid_delay_chip, #[target_delay_increment-0.1], [target_delay - rescaled_delay_resolution_chips/delay_chip], colors='red', linewidths = 2.5, linestyles='dashed', ) target_iso_delay = ax_rcs.contour(x_grid, y_grid, z_grid_delay_chip, #[target_delay_increment+0.1], [target_delay + rescaled_delay_resolution_chips/delay_chip], colors='red', linewidths = 2.5, linestyles='dashed', ) target_iso_delay = ax_rcs.contour(x_grid, y_grid, z_grid_doppler_increment, #[target_doppler_increment-0.5], [target_doppler - rescaled_doppler_resolution], colors='red', linewidths = 2.5, linestyles='dashed', ) target_iso_delay = ax_rcs.contour(x_grid, y_grid, z_grid_doppler_increment, #[target_doppler_increment+0.5], [target_doppler + rescaled_doppler_resolution], colors='red', linewidths = 2.5, linestyles='dashed', ) ticks_y = ticker.FuncFormatter(lambda y, pos: '{0:g}'.format(y/1000)) ticks_x = ticker.FuncFormatter(lambda x, pos: '{0:g}'.format(x/1000)) ax_rcs.xaxis.set_major_formatter(ticks_x) ax_rcs.yaxis.set_major_formatter(ticks_y) # DDM Noise T_noise_receiver = 225 k_b = 1.38e-23 # J/K y_noise = 1/sim_config.coherent_integration_time*k_b*T_noise_receiver print("y_noise: {0}".format(y_noise)) # DDM ddm_sim = np.copy(simulate_ddm(sim_config)) ddm_sim_snr = np.copy(10*np.log10(np.abs(ddm_sim)/y_noise)) sim_config_1 = (sim_config) sim_config_1.rcs = sea_rcs.radar_cross_section #sim_config.rcs = lambda p1,p2: target_rcs.radar_cross_section(p1, 0, p2) sim_config_1.u_10 = 5.0 ddm_sim_1 = np.copy(simulate_ddm(sim_config_1)) ddm_diff = np.copy(np.abs(ddm_sim - ddm_sim_1)) ddm_diff_snr = np.copy(10*np.log10(np.abs(ddm_sim - ddm_sim_1)/y_noise)) ddm_sim_res = rescale(ddm_sim, number_of_doppler_pixels, number_of_delay_pixels) ddm_sim_1_res = rescale(ddm_sim_1, number_of_doppler_pixels, number_of_delay_pixels) ddm_diff_res = np.abs(ddm_sim_res - ddm_sim_1_res) # Plotting fig_ddm, ax_ddm = plt.subplots(1,figsize=(10, 4)) plt.title('DDM simulation') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_sim = ax_ddm.imshow(ddm_sim, cmap='jet', extent=( delay_increment_start/delay_chip, delay_increment_end/delay_chip, doppler_increment_end, doppler_increment_start), aspect="auto" ) fig_ddm.colorbar(contour_sim, label='Correlated Power [W]') # Plotting fig_ddm_1, ax_ddm_1 = plt.subplots(1,figsize=(10, 4)) plt.title('DDM simulation 1') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_sim_1 = ax_ddm.imshow(ddm_sim_1, cmap='jet', extent=( delay_increment_start/delay_chip, delay_increment_end/delay_chip, doppler_increment_end, doppler_increment_start), aspect="auto" ) fig_ddm_1.colorbar(contour_sim_1, label='Correlated Power [W]') fig_ddm_snr, ax_ddm_snr = plt.subplots(1,figsize=(10, 4)) plt.title('DDM simulation SNR') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_sim_snr = ax_ddm_snr.imshow(ddm_sim_snr, cmap='jet', extent=( delay_increment_start/delay_chip, delay_increment_end/delay_chip, doppler_increment_end, doppler_increment_start), aspect="auto" ) fig_ddm_snr.colorbar(contour_sim_snr, label='Correlated Power [W]') fig_diff, ax_diff = plt.subplots(1,figsize=(10, 4)) plt.title('DDM diff') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_diff = ax_diff.imshow(ddm_diff, cmap='jet', extent=( delay_increment_start/delay_chip, delay_increment_end/delay_chip, doppler_increment_end, doppler_increment_start), aspect="auto" ) fig_diff.colorbar(contour_diff, label='SNR [dB]') fig_diff_snr, ax_diff_snr = plt.subplots(1,figsize=(10, 4)) plt.title('DDM diff SNR') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_diff_snr = ax_diff_snr.imshow(ddm_diff_snr, cmap='jet', extent=( delay_increment_start/delay_chip, delay_increment_end/delay_chip, doppler_increment_end, doppler_increment_start), aspect="auto" ) fig_diff_snr.colorbar(contour_diff_snr, label='SNR [dB]') fig_ddm_rescaled, ax_ddm_rescaled = plt.subplots(1,figsize=(10, 4)) plt.title('DDM dif Rescaled') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_diff_res = ax_ddm_rescaled.imshow(ddm_diff_res, cmap='jet', extent=( delay_increment_start/delay_chip, delay_increment_end/delay_chip, doppler_increment_end, doppler_increment_start), aspect='auto' ) fig_ddm_rescaled.colorbar(contour_diff_res, label='Correlated Power [W]') plt.show()
def main(): sim_config = simulation_configuration() sim_config.set_scenario_local_ref( h_t=13.82e6, # m h_r=20e3, # meters elevation=80.0 * np.pi / 180, v_t=np.array([-2684.911, 1183.799, -671.829]), # m/s v_r=np.array([20, 20, 20]) # m/s ) sim_config.jacobian_type = 'spherical' sim_config.receiver_antenna_gain = lambda p1, p2: 12.589 sim_config.rcs = lambda p1, p2: target_rcs.radar_cross_section(p1, 0, p2) sim_config.target_x = 5e3 sim_config.target_y = 0.5e3 u_10 = 10.0 sim_config.u_10 = u_10 sim_config.delay_chip /= 10 delay_chip = sim_config.delay_chip number_of_delay_pixels = 128 - 50 number_of_doppler_pixels = 20 + 50 #number_of_delay_pixels = (128 - 50)*2 #number_of_doppler_pixels = (20 + 50)*2 sim_config.doppler_increment_start = -70 sim_config.doppler_increment_end = 70 sim_config.doppler_resolution = ( sim_config.doppler_increment_end - sim_config.doppler_increment_start) / number_of_doppler_pixels / 4 sim_config.delay_increment_start = -1 * delay_chip sim_config.delay_increment_end = 30 * delay_chip #sim_config.delay_resolution = 0.01*delay_chip sim_config.delay_resolution = ( sim_config.delay_increment_end - sim_config.delay_increment_start) / number_of_delay_pixels / 4 sim_config.coherent_integration_time = 20e-3 # sec delay_increment_start = sim_config.delay_increment_start delay_increment_end = sim_config.delay_increment_end delay_resolution = sim_config.delay_resolution doppler_increment_start = sim_config.doppler_increment_start doppler_increment_end = sim_config.doppler_increment_end doppler_resolution = sim_config.doppler_resolution doppler_specular_point = eq_doppler_absolute_shift(np.array([0, 0, 0]), sim_config) rescaled_doppler_resolution = ( doppler_increment_end - doppler_increment_start) / number_of_doppler_pixels rescaled_delay_resolution_chips = ( delay_increment_end - delay_increment_start) / delay_chip / number_of_delay_pixels print("doppler res: {0}".format(rescaled_doppler_resolution)) print("delay res: {0}".format(rescaled_delay_resolution_chips)) # Surface mesh x_0 = -1e3 x_1 = 8e3 # meters n_x = 800 y_0 = 1e3 y_1 = -8e3 # meters n_y = 800 x_grid, y_grid = np.meshgrid(np.linspace(x_0, x_1, n_x), np.linspace(y_0, y_1, n_y)) r = np.array([x_grid, y_grid, 0]) # Isolines and RCS z_grid_delay_chip = eq_delay_incremet(r, sim_config) / delay_chip doppler_specular_point = eq_doppler_absolute_shift(np.array([0, 0, 0]), sim_config) z_grid_doppler_increment = eq_doppler_absolute_shift( r, sim_config) - doppler_specular_point z_rcs = sim_config.rcs(r, sim_config) # Plot fig_rcs, ax_rcs = plt.subplots(1, figsize=(10, 4)) #contour_delay_chip = ax_rcs.contour( # x_grid, y_grid, z_grid_delay_chip, # np.arange(0, 2, 0.1), # cmap='winter', alpha = 0.3 # ) #contour_doppler = ax_rcs.contour( # x_grid, y_grid, z_grid_doppler_increment, # np.arange(-50, 50, 1), # cmap='jet', alpha = 0.3 # ) contour_rcs = ax_rcs.contourf(x_grid, y_grid, z_rcs, 55, cmap='jet', alpha=0.8) ax_rcs.set_title('RCS') plt.xlabel('[km]') plt.ylabel('[km]') #fig_rcs.colorbar(contour_delay_chip, label='C/A chips') #fig_rcs.colorbar(contour_doppler, label='Hz') fig_rcs.colorbar(contour_rcs, label='Radar Cross Section') target_delay = 2.1 target_doppler = 29 target_iso_delay = ax_rcs.contour( x_grid, y_grid, z_grid_delay_chip, #[target_delay_increment-0.1], [target_delay - rescaled_delay_resolution_chips], colors='red', linewidths=2.5, linestyles='dashed', ) target_iso_delay = ax_rcs.contour( x_grid, y_grid, z_grid_delay_chip, #[target_delay_increment+0.1], [target_delay + rescaled_delay_resolution_chips], colors='red', linewidths=2.5, linestyles='dashed', ) target_iso_delay = ax_rcs.contour( x_grid, y_grid, z_grid_doppler_increment, #[target_doppler_increment-0.5], [target_doppler - rescaled_doppler_resolution], colors='red', linewidths=2.5, linestyles='dashed', ) target_iso_delay = ax_rcs.contour( x_grid, y_grid, z_grid_doppler_increment, #[target_doppler_increment+0.5], [target_doppler + rescaled_doppler_resolution], colors='red', linewidths=2.5, linestyles='dashed', ) ticks_y = ticker.FuncFormatter(lambda y, pos: '{0:g}'.format(y / 1000)) ticks_x = ticker.FuncFormatter(lambda x, pos: '{0:g}'.format(x / 1000)) ax_rcs.xaxis.set_major_formatter(ticks_x) ax_rcs.yaxis.set_major_formatter(ticks_y) # DDM ddm_sim = np.copy(simulate_ddm(sim_config)) sim_config.rcs = sea_rcs.radar_cross_section #sim_config.rcs = lambda p1,p2: target_rcs.radar_cross_section(p1, 0, p2) sim_config.u_10 = 10.0 ddm_sim_1 = np.copy(simulate_ddm(sim_config)) ddm_diff = np.abs(ddm_sim - ddm_sim_1) fig_diff, ax_diff = plt.subplots(1, figsize=(10, 4)) plt.title('DDM diff simulation') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_diff = ax_diff.imshow(ddm_diff, cmap='jet', extent=(delay_increment_start / delay_chip, delay_increment_end / delay_chip, doppler_increment_end, doppler_increment_start), aspect="auto") fig_diff.colorbar(contour_diff, label='Correlated Power [Watts]') fig_ddm, ax_ddm = plt.subplots(1, figsize=(10, 4)) plt.title('DDM original simulation') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_sim = ax_ddm.imshow(ddm_sim, cmap='jet', extent=(delay_increment_start / delay_chip, delay_increment_end / delay_chip, doppler_increment_end, doppler_increment_start), aspect="auto") fig_ddm.colorbar(contour_sim, label='Correlated Power [Watts]') fig_ddm_1, ax_ddm_1 = plt.subplots(1, figsize=(10, 4)) plt.title('DDM original simulation 1') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_sim_1 = ax_ddm_1.imshow(ddm_sim_1, cmap='jet', extent=(delay_increment_start / delay_chip, delay_increment_end / delay_chip, doppler_increment_end, doppler_increment_start), aspect="auto") fig_ddm_1.colorbar(contour_sim_1, label='Correlated Power [Watts]') # Image downscaling to desired resolution: # TODO: This is just an average of the pixels around the area # This is not valid, summation i srequired: # Di Simone > From a physical viewpoint, # such an approach should call for summation instead of averaging # https://stackoverflow.com/questions/48121916/numpy-resize-rescale-image fig_ddm_rescaled_diff, ax_ddm_rescaled_diff = plt.subplots(1, figsize=(10, 4)) plt.title('Wake to Sea Clutter DDM Difference') plt.xlabel('C/A chips') plt.ylabel('Hz') #ddm_rescaled = rescale(ddm_diff, number_of_doppler_pixels, number_of_delay_pixels) ddm_sim_res = rescale(ddm_sim, number_of_doppler_pixels, number_of_delay_pixels) ddm_sim_1_res = rescale(ddm_sim_1, number_of_doppler_pixels, number_of_delay_pixels) ddm_diff_res = np.abs(ddm_sim_res - ddm_sim_1_res) contour_diff = ax_ddm_rescaled_diff.imshow( ddm_diff_res, cmap='jet', extent=(delay_increment_start / delay_chip, delay_increment_end / delay_chip, doppler_increment_end, doppler_increment_start), aspect='auto') fig_ddm_rescaled_diff.colorbar(contour_diff, label='Correlated Power [Watts]') fig_ddm_rescaled, ax_ddm_rescaled = plt.subplots(1, figsize=(10, 4)) plt.title('Ship Wake DDM Simulation') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_rescaled = ax_ddm_rescaled.imshow( ddm_sim_res, cmap='jet', extent=(delay_increment_start / delay_chip, delay_increment_end / delay_chip, doppler_increment_end, doppler_increment_start), aspect='auto') fig_ddm_rescaled.colorbar(contour_rescaled, label='Correlated Power [Watts]') # SNR T_noise_receiver = 232.09 + 246.85 k_b = 1.38e-23 # J/K y_noise = 2 / sim_config.coherent_integration_time * k_b * T_noise_receiver print("expected SNR: {}".format(y_noise)) fig_snr, ax_snr = plt.subplots(1, figsize=(10, 4)) plt.title('SNR') plt.xlabel('C/A chips') plt.ylabel('Hz') ddm_snr = 10 * np.log10(np.abs(ddm_diff_res) / y_noise) #np.place(ddm_snr, ddm_snr < -5.2, np.nan) contour_snr = ax_snr.imshow(ddm_snr, cmap='jet', extent=(delay_increment_start / delay_chip, delay_increment_end / delay_chip, doppler_increment_end, doppler_increment_start), aspect='auto') fig_snr.colorbar(contour_snr, label='Correlated Power [Watts]') plt.show()
def main(): sim_config = simulation_configuration() delay_chip = sim_config.delay_chip delay_increment_start = sim_config.delay_increment_start delay_increment_end = sim_config.delay_increment_end delay_resolution = sim_config.delay_resolution doppler_increment_start = sim_config.doppler_increment_start doppler_increment_end = sim_config.doppler_increment_end doppler_resolution = sim_config.doppler_resolution doppler_specular_point = eq_doppler_absolute_shift(np.array([0,0,0]), sim_config) # Surface mesh x_0 = -150e3 # meters x_1 = 150e3 # meters n_x = 500 y_0 = -150e3 # meters y_1 = 150e3 # meters n_y = 500 x_grid, y_grid = np.meshgrid( np.linspace(x_0, x_1, n_x), np.linspace(y_0, y_1, n_y) ) r = np.array([x_grid, y_grid, 0]) # Isolines and Antenna gain z_grid_delay_chip = eq_delay_incremet(r, sim_config)/delay_chip doppler_specular_point = eq_doppler_absolute_shift(np.array([0,0,0]), sim_config) z_grid_doppler_increment = eq_doppler_absolute_shift(r, sim_config) - doppler_specular_point z_antenna = receiver_antenna_gain(r, sim_config) # Plot fig_antenna, ax_antenna = plt.subplots(1,figsize=(10, 4)) contour_delay_chip = ax_antenna.contour( x_grid, y_grid, z_grid_delay_chip, np.arange(0, delay_increment_end/delay_chip, 1), cmap='winter', alpha = 0.8 ) contour_doppler = ax_antenna.contour( x_grid, y_grid, z_grid_doppler_increment, np.arange(doppler_increment_start, doppler_increment_end, 500), cmap='jet', alpha = 0.8 ) contour_antenna = ax_antenna.contourf(x_grid, y_grid, z_antenna, 55, cmap='jet', alpha = 0.5) ax_antenna.set_title('Antenna') plt.xlabel('[km]') plt.ylabel('[km]') fig_antenna.colorbar(contour_delay_chip, label='C/A chips') fig_antenna.colorbar(contour_doppler, label='Hz') fig_antenna.colorbar(contour_antenna, label='Gain') ticks_y = ticker.FuncFormatter(lambda y, pos: '{0:g}'.format(y/1000)) ticks_x = ticker.FuncFormatter(lambda x, pos: '{0:g}'.format(x/1000)) ax_antenna.xaxis.set_major_formatter(ticks_x) ax_antenna.yaxis.set_major_formatter(ticks_y) plt.show()
def main(): sim_config = simulation_configuration() sim_config.set_scenario_local_ref( h_t=13.82e6, # m h_r=20e3, # meters elevation=50.0 * np.pi / 180, v_t=np.array([-2684.911, 1183.799, -671.829]), # m/s v_r=np.array([20, 20, 20]) # m/s ) sim_config.u_10 = 10 sim_config.phi_0 = 0 delay_chip = sim_config.delay_chip delay_increment_start = sim_config.delay_increment_start delay_increment_end = sim_config.delay_increment_end delay_resolution = sim_config.delay_resolution doppler_increment_start = sim_config.doppler_increment_start doppler_increment_end = sim_config.doppler_increment_end doppler_resolution = sim_config.doppler_resolution doppler_specular_point = eq_doppler_absolute_shift(np.array([0, 0, 0]), sim_config) # Surface mesh x_0 = -40e3 # meters x_1 = 40e3 # meters n_x = 500 y_0 = -40e3 # meters y_1 = 40e3 # meters n_y = 500 x_grid, y_grid = np.meshgrid(np.linspace(x_0, x_1, n_x), np.linspace(y_0, y_1, n_y)) r = np.array([x_grid, y_grid, 0]) # Isolines and Antenna gain z_grid_delay_chip = eq_delay_incremet(r, sim_config) / delay_chip doppler_specular_point = eq_doppler_absolute_shift(np.array([0, 0, 0]), sim_config) z_grid_doppler_increment = eq_doppler_absolute_shift( r, sim_config) - doppler_specular_point z_rcs = sim_config.rcs(r, sim_config) # Iso lines plot fig_isolines, ax_isolines = plt.subplots(1, figsize=(10, 4)) #contour_rcs = ax_isolines.contourf(x_grid, y_grid, z_rcs, 55, cmap='jet', alpha = 0.8) contour_delay_chip = ax_isolines.contour(x_grid, y_grid, z_grid_delay_chip, np.arange(0, 11, 0.14), cmap='summer', alpha=0.6) contour_doppler = ax_isolines.contour(x_grid, y_grid, z_grid_doppler_increment, np.arange(-70, 80, 2), cmap='winter', alpha=0.8) #fig_isolines.colorbar(contour_rcs, label='Radar Cross Section') fig_isolines.colorbar(contour_delay_chip, label='Delay [C/A chips]') fig_isolines.colorbar(contour_doppler, label='Doppler [Hz]') ''' test_delay = np.array([3*delay_chip]) test_doppler = np.array([1000]) + doppler_specular_point print('Finding intersection for d:{0}, f:{1}'.format(test_delay, test_delay)) x_s_1 = x_delay_doppler_1(test_delay, test_doppler, sim_config) y_s_1 = y_delay_doppler_1(test_delay, test_doppler, sim_config) x_s_2 = x_delay_doppler_2(test_delay, test_doppler, sim_config) y_s_2 = y_delay_doppler_2(test_delay, test_doppler, sim_config) ax_isolines.scatter(x_s_1, y_s_1, s=70, marker=(5, 2), zorder=4) ax_isolines.scatter(x_s_2, y_s_2, s=70, marker=(5, 2), zorder=4) fig_isolines.colorbar(contour_delay_chip, label='C/A chips') fig_isolines.colorbar(contour_doppler, label='Hz') ''' ticks_y = ticker.FuncFormatter(lambda y, pos: '{0:g}'.format(y / 1000)) ticks_x = ticker.FuncFormatter(lambda x, pos: '{0:g}'.format(x / 1000)) ax_isolines.xaxis.set_major_formatter(ticks_x) ax_isolines.yaxis.set_major_formatter(ticks_y) plt.xlabel('[km]') plt.ylabel('[km]') plt.show()
def main(): sim_config = simulation_configuration() sim_config.jacobian_type = 'spherical' delay_chip = sim_config.delay_chip # Decent noise results file_root_name = '2017-03-12-H18' target = targets['hibernia'] group = '000035' index = 675 - 15 tds = tds_data(file_root_name, group, index) mean_wind = tds.get_wind() p = target_processor_power() n = 1 p.n = n for i in range(index - n, index + 2): tds.set_group_index(group, i) ddm_i = normalize(tds.rootgrp.groups[group].variables['DDM'] [i].data) * tds.peak_power() p.process_ddm(ddm_i) wind = tds.get_wind() if (wind != None): print("wind: {0}".format(wind)) mean_wind += wind mean_wind /= 2 ddm_tds = np.copy(p.sea_clutter) print("mean wind: {0}".format(mean_wind)) sim_config.u_10 = 15 sim_config.phi_0 = -200 * np.pi / 180 # Plot TDS DDM sea clutter tds.set_group_index(group, index) r_sp, lat_sp, lon_sp = tds.find_sp() datenum = tds.rootgrp.groups[ tds.group].variables['IntegrationMidPointTime'][tds.index] string = str(datenum_to_pytime(float(datenum))) \ + ' Lat: ' + "{0:.2f}".format(tds.lat_sp_tds) \ + ' Lon: ' + "{0:.2f}".format(tds.lon_sp_tds) tds_number_of_delay_pixels = tds.metagrp.groups[ tds.group].NumberOfDelayPixels tds_number_of_doppler_pixels = tds.metagrp.groups[ tds.group].NumberOfDopplerPixels tds_delay_start = tds.calculate_delay_increment_chips(0) tds_delay_end = tds.calculate_delay_increment_chips( tds_number_of_delay_pixels - 1) tds_delay_resolution = (tds_delay_end - tds_delay_start) / 128 tds_doppler_start = tds.calculate_doppler_increment( -np.floor(tds_number_of_doppler_pixels / 2)) tds_doppler_end = tds.calculate_doppler_increment( np.floor(tds_number_of_doppler_pixels / 2 - 0.5)) tds_doppler_resolution = 500 fig_tds, ax_tds = plt.subplots(1, figsize=(10, 4)) plt.title('TDS-1 Experimental Data') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_tds = ax_tds.imshow( ddm_tds, cmap='jet', extent=(tds_delay_start, tds_delay_end, tds_doppler_end, tds_doppler_start), aspect=(tds_number_of_doppler_pixels / tds_number_of_delay_pixels) / np.abs(tds_doppler_start / tds_delay_start)) t = plt.text(0.01, 0.85, string, { 'color': 'w', 'fontsize': 12 }, transform=ax_tds.transAxes) cbar = fig_tds.colorbar(contour_tds, label='Power') # Load TDS Geometry in simulation configuration n_z = unit_vector(ellip_norm(tds.r_sp_tds)) n_x = unit_vector(np.cross(n_z, tds.r_sp_tds - tds.r_t)) n_y = unit_vector(np.cross(n_z, n_x)) v_tx = np.dot(tds.v_t, n_x) v_ty = np.dot(tds.v_t, n_y) v_tz = np.dot(tds.v_t, n_z) v_rx = np.dot(tds.v_r, n_x) v_ry = np.dot(tds.v_r, n_y) v_rz = np.dot(tds.v_r, n_z) sim_config.set_scenario_local_ref( h_r=np.dot((tds.r_r - tds.r_sp_tds), n_z), h_t=np.dot((tds.r_t - tds.r_sp_tds), n_z), elevation=angle_between(n_y, tds.r_t - tds.r_sp_tds), v_t=np.array([v_tx, v_ty, v_tz]), v_r=np.array([v_rx, v_ry, v_rz])) # DDM sim_config.delay_increment_start = tds_delay_start * delay_chip sim_config.delay_increment_end = tds_delay_end * delay_chip sim_config.delay_resolution = ( sim_config.delay_increment_end - sim_config.delay_increment_start) / tds_number_of_delay_pixels / 3 sim_config.doppler_increment_start = tds_doppler_start sim_config.doppler_increment_end = tds_doppler_end + tds_doppler_resolution sim_config.doppler_resolution = ( sim_config.doppler_increment_end - sim_config.doppler_increment_start) / tds_number_of_doppler_pixels / 3 ddm_sim = (simulate_ddm(sim_config)) fig_ddm, ax_ddm = plt.subplots(1, figsize=(10, 4)) plt.title('DDM original simulation') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_ddm = ax_ddm.imshow(ddm_sim, cmap='jet', extent=(sim_config.delay_increment_start, sim_config.delay_increment_end, sim_config.doppler_increment_end, sim_config.doppler_increment_start), aspect="auto") cbar = fig_ddm.colorbar(contour_ddm, label='Normalized Power') # Image downscaling to desired resolution: fig_ddm_rescaled, ax_ddm_rescaled = plt.subplots(1, figsize=(10, 4)) plt.title('Simulation Rescaled') plt.xlabel('C/A chips') plt.ylabel('Hz') ddm_rescaled = rescale(ddm_sim, tds_number_of_doppler_pixels, tds_number_of_delay_pixels) ddm_rescaled[0, :] = ddm_rescaled[2, :] ddm_rescaled[1, :] = ddm_rescaled[2, :] ddm_rescaled[:, 0] = ddm_rescaled[:, 2] ddm_rescaled[:, 1] = ddm_rescaled[:, 2] # Noise waf_delay_increment_values = list( np.arange( -tds_delay_end * delay_chip, tds_delay_end * delay_chip + tds_delay_resolution * delay_chip, tds_delay_resolution * delay_chip)) waf_doppler_increment_values = list( np.arange(tds_doppler_start, tds_doppler_end + tds_doppler_resolution, tds_doppler_resolution)) waf_delay_grid, waf_doppler_grid = np.meshgrid( waf_delay_increment_values, waf_doppler_increment_values) waf_matrix = woodward_ambiguity_function(waf_delay_grid, waf_doppler_grid, sim_config)**2 T_noise_receiver = 225 k_b = 1.38e-23 # J/K y_noise = 1 / sim_config.coherent_integration_time * k_b * T_noise_receiver p1 = target_processor_power() n = 500 p1.n = n p1.tau = 0.08 ddm_noise = np.zeros(ddm_rescaled.shape) for i in range(n + 1): print("i: {0}".format(i)) noise_i = y_noise * (np.random.rand(ddm_rescaled.shape[0], ddm_rescaled.shape[1])) ddm_noise_i = np.abs( signal.convolve2d(noise_i, waf_matrix, mode='same')) p1.process_ddm(np.abs(ddm_rescaled + ddm_noise_i)) ddm_rescaled = p1.sea_clutter contour_res = ax_ddm_rescaled.imshow( ddm_rescaled, cmap='jet', extent=(tds_delay_start, tds_delay_end, tds_doppler_end, tds_doppler_start), aspect=(tds_number_of_doppler_pixels / tds_number_of_delay_pixels) / np.abs(tds_doppler_start / tds_delay_start)) cbar = fig_ddm_rescaled.colorbar(contour_res, label='Normalized Power', shrink=0.35) fig_diff, ax_diff = plt.subplots(1, figsize=(10, 4)) plt.title('Difference') plt.xlabel('C/A chips') plt.ylabel('Hz') ddm_diff = np.copy(ddm_rescaled) for row_i, row in enumerate(ddm_diff): for col_i, val in enumerate(row): val_tds = ddm_tds[row_i, col_i] val = ddm_rescaled[row_i, col_i] ddm_diff[row_i, col_i] = np.abs((val - val_tds) / val_tds) #np.place(ddm_diff, ddm_diff < 0, np.nan) im = ax_diff.imshow( ddm_diff, cmap='jet', extent=(tds_delay_start, tds_delay_end, tds_doppler_end, tds_doppler_start), aspect=(tds_number_of_doppler_pixels / tds_number_of_delay_pixels) / np.abs(tds_doppler_start / tds_delay_start)) cbar = fig_diff.colorbar(im, label='Normalized Power', shrink=0.35) plt.show()
def main(): sim_config = simulation_configuration() sim_config.doppler_resolution = 20 # Hz sim_config.delay_resolution = 0.1/gps_ca_chips_per_second # seconds sim_config.delay_increment_start = -3/gps_ca_chips_per_second sim_config.delay_increment_end = 10/gps_ca_chips_per_second sim_config.doppler_increment_start = -3000 sim_config.doppler_increment_end = 3000 delay_increment_start = sim_config.delay_increment_start delay_increment_end = sim_config.delay_increment_end delay_resolution = sim_config.delay_resolution doppler_increment_start = sim_config.doppler_increment_start doppler_increment_end = sim_config.doppler_increment_end doppler_resolution = sim_config.doppler_resolution delay_chip = sim_config.delay_chip # WAF waf_delay_increment_values = list(np.arange( -delay_increment_end, delay_increment_end, delay_resolution )) waf_doppler_increment_values = list(np.arange( doppler_increment_start, doppler_increment_end, doppler_resolution )) waf_delay_grid, waf_doppler_grid = np.meshgrid(waf_delay_increment_values, waf_doppler_increment_values) waf_matrix = woodward_ambiguity_function(waf_delay_grid, waf_doppler_grid, sim_config)**2 fig_waf, ax_waf = plt.subplots(1,figsize=(10, 4)) ax_waf.set_title('WAF') im = ax_waf.imshow(waf_matrix, cmap='jet', extent=(-delay_increment_end/delay_chip, delay_increment_end/delay_chip, doppler_increment_start, doppler_increment_end), aspect="auto" ) cbar = fig_waf.colorbar(im) fig_waf_delay, ax_waf_delay = plt.subplots(1,figsize=(10, 4)) waf_delay_result = waf_delay(np.array(waf_delay_increment_values), sim_config)**2 ax_waf_delay.plot([i/delay_chip for i in waf_delay_increment_values], waf_delay_result) ax_waf_delay.fill_between([i/delay_chip for i in waf_delay_increment_values], 0, waf_delay_result) ax_waf_delay.set_title('waf_delay') fig_waf_frequency, ax_waf_frequency = plt.subplots(1,figsize=(10, 4)) waf_frequency_result = waf_frequency(np.array(waf_doppler_increment_values), sim_config)**2 ax_waf_frequency.plot(waf_doppler_increment_values, waf_frequency_result) ax_waf_frequency.fill_between(waf_doppler_increment_values, 0, waf_frequency_result, cmap='jet') ax_waf_frequency.set_title('waf_freq') fig_waf_frequency_2, ax_waf_frequency_2 = plt.subplots(1,figsize=(10, 4)) xx=np.array(waf_delay_increment_values)/delay_chip yy=waf_delay_result path = Path(np.array([xx,yy]).transpose()) patch = PathPatch(path, facecolor='none') plt.gca().add_patch(patch) im = plt.imshow(xx.reshape(yy.size,1), cmap='jet', origin='lower',extent=[-delay_increment_end/delay_chip, delay_increment_end/delay_chip,0,1.05],aspect="auto", clip_path=patch, clip_on=True) plt.grid(linestyle='dotted') fig_waf_frequency_2, ax_waf_frequency_2 = plt.subplots(1,figsize=(10, 4)) xx_doppler=np.array(waf_doppler_increment_values) yy_doppler=waf_frequency_result path = Path(np.array([xx_doppler,yy_doppler]).transpose()) patch = PathPatch(path, facecolor='none') plt.gca().add_patch(patch) im = plt.imshow(xx_doppler.reshape(yy_doppler.size,1), cmap='jet', origin='lower',extent=[-3000,3000,0,1.05],aspect="auto", clip_path=patch, clip_on=True) plt.grid(linestyle='dotted') plt.show()
def main(): sim_config = simulation_configuration() #sim_config.jacobian_type = 'spherical' delay_chip = sim_config.delay_chip # Really good #sim_config.u_10 = 4 #sim_config.phi_0 = 35*np.pi/180 #sim_config.u_10 = 4 #sim_config.phi_0 = 38*np.pi/180 sim_config.u_10 = 3 sim_config.phi_0 = -83 * np.pi / 180 file_root_name = '2015-04-01-H00' target = targets['hibernia'] group = '000095' index = 415 tds = tds_data(file_root_name, group, index) # Load TDS Geometry in simulation configuration number_of_delay_pixels = tds.metagrp.groups[tds.group].NumberOfDelayPixels number_of_doppler_pixels = tds.metagrp.groups[ tds.group].NumberOfDopplerPixels delay_start = tds.calculate_delay_increment_chips(0) delay_end = tds.calculate_delay_increment_chips(number_of_delay_pixels - 1) doppler_start = tds.calculate_doppler_increment( -np.floor(number_of_doppler_pixels / 2)) doppler_end = tds.calculate_doppler_increment( np.floor(number_of_doppler_pixels / 2 - 0.5)) delay_increment_start = sim_config.delay_increment_start delay_increment_end = sim_config.delay_increment_end delay_resolution = sim_config.delay_resolution sim_config.delay_increment_start = delay_start * delay_chip + 2 * delay_resolution sim_config.delay_increment_end = delay_end * delay_chip sim_config.doppler_increment_start = -5000 sim_config.doppler_increment_end = 5000 doppler_increment_start = sim_config.doppler_increment_start doppler_increment_end = sim_config.doppler_increment_end doppler_resolution = sim_config.doppler_resolution r_sp, lat_sp, lon_sp = tds.find_sp() n_z = unit_vector(ellip_norm(r_sp)) n_x = unit_vector(np.cross(n_z, r_sp - tds.r_t)) n_y = unit_vector(np.cross(n_z, n_x)) v_tx = np.dot(tds.v_t, n_x) v_ty = np.dot(tds.v_t, n_y) v_tz = np.dot(tds.v_t, n_z) v_rx = np.dot(tds.v_r, n_x) v_ry = np.dot(tds.v_r, n_y) v_rz = np.dot(tds.v_r, n_z) #sim_config.set_scenario_local_ref( # h_r = np.dot((tds.r_r - r_sp), n_z), # h_t = np.dot((tds.r_t - r_sp), n_z), # elevation = angle_between(n_y, tds.r_t-r_sp), # v_t = np.array([v_tx,v_ty,v_tz]), # v_r = np.array([v_rx,v_ry,v_rz]) # ) # DDM ddm_sim = simulate_ddm(sim_config) fig_ddm, ax_ddm = plt.subplots(1, figsize=(10, 4)) plt.title('DDM simulation') plt.xlabel('C/A chips') plt.ylabel('Hz') contour = ax_ddm.imshow(ddm_sim, cmap='jet', extent=(delay_start, delay_end, doppler_end, doppler_start), aspect="auto") cbar = fig_ddm.colorbar(contour, label='Power [Watt]') T_noise_receiver = 225 k_b = 1.38e-23 # J/K y_noise = 1 / sim_config.coherent_integration_time * k_b * T_noise_receiver ddm_sim_snr = np.copy(10 * np.log10(np.abs(ddm_sim) / y_noise)) fig_ddm_snr, ax_ddm_snr = plt.subplots(1, figsize=(10, 4)) plt.title('DDM SNR simulation') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_snr = ax_ddm_snr.imshow(ddm_sim_snr, cmap='jet', extent=(delay_start, delay_end, doppler_end, doppler_start), aspect="auto") cbar = fig_ddm_snr.colorbar(contour_snr, label='SNR [dB]') plt.show()
def main(): sim_config = simulation_configuration() sim_config.set_scenario_local_ref( h_t=13.82e6, # m h_r=20e3, # meters elevation=60.0 * np.pi / 180, v_t=np.array([-2684.911, 1183.799, -671.829]), # m/s v_r=np.array([25, 25, 25]) # m/s ) #sim_config.jacobian_type = 'spherical' sim_config.receiver_antenna_gain = lambda p1, p2: 12.589 sim_config.rcs = lambda x, y: target_rcs.radar_cross_section_military( x, 0, y) sim_config.u_10 = 5.0 # m/s #sim_config.delay_chip = 1/10.23e6 # s sim_config.delay_chip = 1 / gps_ca_chips_per_second / 10 # seconds delay_chip = sim_config.delay_chip sim_config.doppler_increment_start = -70 sim_config.doppler_increment_end = 70 sim_config.doppler_resolution = 0.5 sim_config.delay_increment_start = -0.2 * delay_chip sim_config.delay_increment_end = 8 * delay_chip sim_config.delay_resolution = 0.05 * delay_chip sim_config.coherent_integration_time = 2e-2 # sec delay_increment_start = sim_config.delay_increment_start delay_increment_end = sim_config.delay_increment_end delay_resolution = sim_config.delay_resolution doppler_increment_start = sim_config.doppler_increment_start doppler_increment_end = sim_config.doppler_increment_end doppler_resolution = sim_config.doppler_resolution doppler_specular_point = eq_doppler_absolute_shift(np.array([0, 0, 0]), sim_config) # Surface mesh x_0 = 0 x_1 = 4e3 # meters n_x = 800 y_0 = 0 y_1 = 4e3 # meters n_y = 800 x_grid, y_grid = np.meshgrid(np.linspace(x_0, x_1, n_x), np.linspace(y_0, y_1, n_y)) r = np.array([x_grid, y_grid, 0]) # Isolines and RCS z_grid_delay_chip = eq_delay_incremet(r, sim_config) / delay_chip doppler_specular_point = eq_doppler_absolute_shift(np.array([0, 0, 0]), sim_config) z_grid_doppler_increment = eq_doppler_absolute_shift( r, sim_config) - doppler_specular_point z_rcs = sim_config.rcs(r, sim_config) # Plot fig_rcs, ax_rcs = plt.subplots(1, figsize=(10, 4)) contour_delay_chip = ax_rcs.contour( x_grid, y_grid, z_grid_delay_chip, np.arange(0, delay_increment_end / delay_chip, delay_resolution / delay_chip), cmap='winter', alpha=0.4) contour_doppler = ax_rcs.contour(x_grid, y_grid, z_grid_doppler_increment, np.arange(doppler_increment_start, doppler_increment_end, doppler_resolution), cmap='jet', alpha=0.4) contour_rcs = ax_rcs.contourf(x_grid, y_grid, z_rcs, 55, cmap='jet', alpha=0.8) ax_rcs.set_title('RCS') plt.xlabel('[km]') plt.ylabel('[km]') #fig_rcs.colorbar(contour_delay_chip, label='C/A chips') #fig_rcs.colorbar(contour_doppler, label='Hz') fig_rcs.colorbar(contour_rcs, label='Gain') target_delay_increment = 0.54 target_doppler_increment = 17.35 target_iso_delay = ax_rcs.contour( x_grid, y_grid, z_grid_delay_chip, #[target_delay_increment-0.1], [3.6], colors='red', linewidths=2.5, linestyles='dashed', ) target_iso_delay = ax_rcs.contour( x_grid, y_grid, z_grid_delay_chip, #[target_delay_increment+0.1], [3.7], colors='red', linewidths=2.5, linestyles='dashed', ) target_iso_delay = ax_rcs.contour( x_grid, y_grid, z_grid_doppler_increment, #[target_doppler_increment-0.5], [16], colors='red', linewidths=2.5, linestyles='dashed', ) target_iso_delay = ax_rcs.contour( x_grid, y_grid, z_grid_doppler_increment, #[target_doppler_increment+0.5], [18], colors='red', linewidths=2.5, linestyles='dashed', ) ticks_y = ticker.FuncFormatter(lambda y, pos: '{0:g}'.format(y / 1000)) ticks_x = ticker.FuncFormatter(lambda x, pos: '{0:g}'.format(x / 1000)) ax_rcs.xaxis.set_major_formatter(ticks_x) ax_rcs.yaxis.set_major_formatter(ticks_y) # DDM ddm_sim = simulate_ddm(sim_config) #sim_config.rcs = lambda x,y: target_rcs.radar_cross_section_military(x, 0.5, y) sim_config.rcs = sea_rcs.radar_cross_section sim_config.u_10 = 5.0 ddm_sim_1 = simulate_ddm(sim_config) ddm_diff = np.abs((ddm_sim) - (ddm_sim_1)) fig_diff, ax_diff = plt.subplots(1, figsize=(10, 4)) plt.title('DDM diff simulation') plt.xlabel('chips') plt.ylabel('Hz') contour_diff = ax_diff.imshow(ddm_diff, cmap='jet', extent=(delay_increment_start / delay_chip, delay_increment_end / delay_chip, doppler_increment_end, doppler_increment_start), aspect="auto") fig_diff.colorbar(contour_diff) fig_ddm, ax_ddm = plt.subplots(1, figsize=(10, 4)) plt.title('DDM original simulation') plt.xlabel('chips') plt.ylabel('Hz') contour_sim = ax_ddm.imshow(ddm_sim, cmap='jet', extent=(delay_increment_start / delay_chip, delay_increment_end / delay_chip, doppler_increment_end, doppler_increment_start), aspect="auto") fig_ddm.colorbar(contour_sim) fig_ddm_rescaled, ax_ddm_rescaled = plt.subplots(1, figsize=(10, 4)) plt.title('Rescaled Diff') plt.xlabel('chips') plt.ylabel('Hz') number_of_delay_pixels = 128 - 50 number_of_doppler_pixels = 20 + 50 ddm_sim_res = rescale(ddm_sim, number_of_doppler_pixels, number_of_delay_pixels) ddm_sim_1_res = rescale(ddm_sim_1, number_of_doppler_pixels, number_of_delay_pixels) ddm_diff_res = np.abs((ddm_sim_res) - (ddm_sim_1_res)) contour_rescaled = ax_ddm_rescaled.imshow( ddm_sim_res, cmap='jet', extent=(delay_increment_start / delay_chip, delay_increment_end / delay_chip, doppler_increment_end, doppler_increment_start), aspect='auto') fig_ddm_rescaled.colorbar(contour_rescaled) fig_ddm_rescaled_diff, ax_ddm_rescaled_diff = plt.subplots(1, figsize=(10, 4)) plt.title('Rescaled Diff') plt.xlabel('chips') plt.ylabel('Hz') number_of_delay_pixels = 128 number_of_doppler_pixels = 20 contour_rescaled_diff = ax_ddm_rescaled_diff.imshow( ddm_diff_res, cmap='jet', extent=(delay_increment_start / delay_chip, delay_increment_end / delay_chip, doppler_increment_end, doppler_increment_start), aspect='auto') fig_ddm_rescaled_diff.colorbar(contour_rescaled_diff) plt.show()
def main(): ''' sim_config = simulation_configuration() h = 540e3; h0 = 20e6; Vt = np.array([-1e3,1e3,0]); Vr = np.array([500,1000,1e2]); gamma = 70*np.pi/180; wavelength = light_speed/sim_config.f_carrier Re = 6371e3; r = np.array([100, -57, 0]); r[2] = np.sqrt(Re**2 - r[0]**2 - r[1]**2) - Re; Rt = np.array([0, h0/np.tan(gamma), h0]); Rr = np.array([0, -h/np.tan(gamma), h]); ni = -(Rt-r)/np.linalg.norm(Rt-r); ns = (Rr-r)/np.linalg.norm(Rr-r); sim_config.set_scenario_local_ref( h_t = h0, # m h_r = h, # m elevation = gamma, # radians v_t = Vt, # m/s v_r = Vr # m/s ) delay = np.array(sim_config.delay_chip*1) doppler_specular_point = np.array(eq_doppler_absolute_shift(np.array([0,0,0]), sim_config)) fd = doppler_specular_point spherical.compute_transformation(delay, fd, sim_config) ''' sim_config = simulation_configuration() delay_chip = sim_config.delay_chip delay_increment_start = sim_config.delay_increment_start delay_increment_end = sim_config.delay_increment_end delay_resolution = sim_config.delay_resolution doppler_increment_start = sim_config.doppler_increment_start doppler_increment_end = sim_config.doppler_increment_end doppler_resolution = sim_config.doppler_resolution doppler_specular_point = eq_doppler_absolute_shift(np.array([0, 0, 0]), sim_config) # Surface mesh x_0 = -150e3 # meters x_1 = 150e3 # meters n_x = 500 y_0 = -150e3 # meters y_1 = 150e3 # meters n_y = 500 x_grid, y_grid = np.meshgrid(np.linspace(x_0, x_1, n_x), np.linspace(y_0, y_1, n_y)) r = np.array([x_grid, y_grid, 0]) # Isolines and Antenna gain z_grid_delay_chip = eq_delay_incremet(r, sim_config) / delay_chip doppler_specular_point = eq_doppler_absolute_shift(np.array([0, 0, 0]), sim_config) z_grid_doppler_increment = eq_doppler_absolute_shift( r, sim_config) - doppler_specular_point # Iso lines plot fig_isolines, ax_isolines = plt.subplots(1, figsize=(10, 4)) contour_delay_chip = ax_isolines.contour( x_grid, y_grid, z_grid_delay_chip, np.arange(0, delay_increment_end / delay_chip, 1), cmap='winter', alpha=0.6) contour_doppler = ax_isolines.contour(x_grid, y_grid, z_grid_doppler_increment, np.arange(doppler_increment_start, doppler_increment_end, 500), cmap='jet', alpha=0.8) test_delay = np.array([1 * delay_chip]) test_doppler = np.array([500]) + doppler_specular_point print('Finding intersection for d:{0}, f:{1}'.format( test_delay, test_delay)) ''' x_s_1 = planar.x_delay_doppler_1(test_delay, test_doppler, sim_config) y_s_1 = planar.y_delay_doppler_1(test_delay, test_doppler, sim_config) x_s_2 = planar.x_delay_doppler_2(test_delay, test_doppler, sim_config) y_s_2 = planar.y_delay_doppler_2(test_delay, test_doppler, sim_config) ''' r_1, r_2 = spherical.delay_doppler_to_local_surface( test_delay, test_doppler, sim_config) x_s_1 = r_1[0] y_s_1 = r_1[1] x_s_2 = r_2[0] y_s_2 = r_2[1] ax_isolines.scatter(x_s_1, y_s_1, s=70, marker=(5, 2), zorder=4) ax_isolines.scatter(x_s_2, y_s_2, s=70, marker=(5, 2), zorder=4) fig_isolines.colorbar(contour_delay_chip, label='C/A chips') fig_isolines.colorbar(contour_doppler, label='Hz') ticks_y = ticker.FuncFormatter(lambda y, pos: '{0:g}'.format(y / 1000)) ticks_x = ticker.FuncFormatter(lambda x, pos: '{0:g}'.format(x / 1000)) ax_isolines.xaxis.set_major_formatter(ticks_x) ax_isolines.yaxis.set_major_formatter(ticks_y) plt.xlabel('[km]') plt.ylabel('[km]') plt.show()
def compute_snr(parallel_input): print("parallel_input: {}".format(parallel_input)) x_pos, y_pos, x_val, y_val = parallel_input sim_config = simulation_configuration() sim_config.set_scenario_local_ref( h_t = 13.82e6, # m h_r = 20e3, # meters elevation = 70.0*np.pi/180, v_t = np.array([-2684.911, 1183.799, -671.829]), # m/s v_r = np.array([20, 20, 20]) # m/s ) #sim_config.jacobian_type = 'spherical' sim_config.convolve_type = 'fft' sim_config.receiver_antenna_gain = lambda p1,p2: 1 sim_config.rcs = lambda p1,p2: target_rcs.radar_cross_section(p1, 0, p2) sim_config.u_10 = 10.00 sim_config.fresnel = 0.65 #sim_config.delay_chip = 1/gps_ca_chips_per_second # seconds delay_chip = sim_config.delay_chip number_of_delay_pixels = 128 - 50 number_of_doppler_pixels = 20 + 50 sim_config.doppler_increment_start = -70 sim_config.doppler_increment_end = 70 sim_config.doppler_resolution = (sim_config.doppler_increment_end - sim_config.doppler_increment_start)/number_of_doppler_pixels/8 sim_config.delay_increment_start = -1*delay_chip sim_config.delay_increment_end = 10*delay_chip sim_config.delay_resolution = (sim_config.delay_increment_end - sim_config.delay_increment_start)/number_of_delay_pixels/4 sim_config.coherent_integration_time = 20e-3 # sec delay_increment_start = sim_config.delay_increment_start delay_increment_end = sim_config.delay_increment_end delay_resolution = sim_config.delay_resolution doppler_increment_start = sim_config.doppler_increment_start doppler_increment_end = sim_config.doppler_increment_end doppler_resolution = sim_config.doppler_resolution doppler_specular_point = eq_doppler_absolute_shift(np.array([0,0,0]), sim_config) rescaled_doppler_resolution = (doppler_increment_end - doppler_increment_start)/number_of_doppler_pixels rescaled_delay_resolution_chips = (delay_increment_end - delay_increment_start)/delay_chip/number_of_delay_pixels doppler_specular_point = eq_doppler_absolute_shift(np.array([0,0,0]), sim_config) sim_config.target_x = x_val sim_config.target_y = y_val # DDM sim_config.rcs = lambda p1,p2: target_rcs.radar_cross_section(p1, 0, p2) ddm_sim = np.copy(simulate_ddm(sim_config)) sim_config.rcs = sea_rcs.radar_cross_section ddm_sim_1 = np.copy(simulate_ddm(sim_config)) ddm_sim_res = rescale(ddm_sim, number_of_doppler_pixels, number_of_delay_pixels) ddm_sim_1_res = rescale(ddm_sim_1, number_of_doppler_pixels, number_of_delay_pixels) ddm_diff_res = np.abs(ddm_sim_res - ddm_sim_1_res) # DDM Noise T_noise_receiver = 232.09 + 246.85 k_b = 1.38e-23 # J/K y_noise = 2/sim_config.coherent_integration_time*k_b*T_noise_receiver ddm_snr = np.copy(10*np.log10(np.abs(ddm_diff_res)/y_noise)) np.place(ddm_snr, ddm_snr == np.nan, -1000) np.place(ddm_snr, ddm_snr == np.inf, -1000) np.place(ddm_snr, ddm_snr == -np.inf, -1000) max_indices = np.where(ddm_snr == np.amax(ddm_snr)) snr_max = np.amax(ddm_snr) delay_target = delay_increment_start/delay_chip + (delay_increment_end/delay_chip - delay_increment_start/delay_chip)/number_of_delay_pixels*max_indices[1] doppler_target = doppler_increment_start + (doppler_increment_end - doppler_increment_start)/number_of_doppler_pixels*max_indices[0] + doppler_specular_point x_snr_1 = x_delay_doppler_1(delay_target, doppler_target, sim_config) y_snr_1 = y_delay_doppler_1(delay_target, doppler_target, sim_config) x_snr_2 = x_delay_doppler_2(delay_target, doppler_target, sim_config) y_snr_2 = y_delay_doppler_2(delay_target, doppler_target, sim_config) if (x_snr_1.size > 1 or x_snr_2.size > 1): snr_max = np.nan return x_pos, y_pos, snr_max
def main(): sim_config = simulation_configuration() delay_chip = sim_config.delay_chip # Really good #sim_config.u_10 = 4 #sim_config.phi_0 = 35*np.pi/180 #sim_config.u_10 = 4 #sim_config.phi_0 = 38*np.pi/180 sim_config.u_10 = 14.04 sim_config.phi_0 = -83*np.pi/180 file_root_name = 'raw/L1B/2015-04-01-H00' target = targets['hibernia'] group = '000095' index = 515 tds = tds_data(file_root_name, group, index) # Sea clutter estimation. #p = target_processor(); #for i in range(index - 30, index + 5): # ddm = tds.rootgrp.groups[group].variables['DDM'][i].data # p.process_ddm(ddm) # Plot TDS DDM sea clutter datenum = tds.rootgrp.groups[tds.group].variables['IntegrationMidPointTime'][tds.index] string = str(datenum_to_pytime(float(datenum))) \ + ' Lat: ' + "{0:.2f}".format(tds.lat_sp_tds) \ + ' Lon: ' + "{0:.2f}".format(tds.lon_sp_tds) number_of_delay_pixels = tds.metagrp.groups[tds.group].NumberOfDelayPixels number_of_doppler_pixels = tds.metagrp.groups[tds.group].NumberOfDopplerPixels delay_start = tds.calculate_delay_increment_chips(0) delay_end = tds.calculate_delay_increment_chips(number_of_delay_pixels-1) doppler_start = tds.calculate_doppler_increment(-np.floor(number_of_doppler_pixels/2)) doppler_end = tds.calculate_doppler_increment(np.floor(number_of_doppler_pixels/2 - 0.5)) delay_increment_start = sim_config.delay_increment_start delay_increment_end = sim_config.delay_increment_end delay_resolution = sim_config.delay_resolution sim_config.delay_increment_start = delay_start*delay_chip + 2*delay_resolution sim_config.delay_increment_end = delay_end*delay_chip sim_config.doppler_increment_start = -5000 sim_config.doppler_increment_end = 5000 doppler_increment_start = sim_config.doppler_increment_start doppler_increment_end = sim_config.doppler_increment_end doppler_resolution = sim_config.doppler_resolution fig_tds, ax_tds = plt.subplots(1,figsize=(10, 4)) plt.title('TDS-1 Experimental Data') plt.xlabel('C/A chips') plt.ylabel('Hz') im = ax_tds.imshow(p.sea_clutter, cmap='jet', extent=(delay_start, delay_end, doppler_end, doppler_start), aspect=(number_of_doppler_pixels/number_of_delay_pixels)/np.abs(doppler_start/delay_start) ) t = plt.text(0.01, 0.85, string, {'color': 'w', 'fontsize': 12}, transform=ax_tds.transAxes) # Load TDS Geometry in simulation configuration r_sp, lat_sp, lon_sp = tds.find_sp(); n_z = unit_vector(ellip_norm(r_sp)) n_x = unit_vector(np.cross(n_z, r_sp-tds.r_t)) n_y = unit_vector(np.cross(n_z, n_x)) v_tx = np.dot(tds.v_t, n_x) v_ty = np.dot(tds.v_t, n_y) v_tz = np.dot(tds.v_t, n_z) v_rx = np.dot(tds.v_r, n_x) v_ry = np.dot(tds.v_r, n_y) v_rz = np.dot(tds.v_r, n_z) sim_config.set_scenario_local_ref( h_r = np.dot((tds.r_r - r_sp), n_z), h_t = np.dot((tds.r_t - r_sp), n_z), elevation = angle_between(n_y, tds.r_t-r_sp), v_t = np.array([v_tx,v_ty,v_tz]), v_r = np.array([v_rx,v_ry,v_rz]) ) # DDM ddm_sim = normalize(simulate_ddm(sim_config)) fig_ddm, ax_ddm = plt.subplots(1,figsize=(10, 4)) plt.title('DDM original simulation') plt.xlabel('C/A chips') plt.ylabel('Hz') im = ax_ddm.imshow(ddm_sim, cmap='jet', extent=(delay_start, delay_end, doppler_end, doppler_start), aspect="auto" ) # Image downscaling to desired resolution: # TODO: This is just an average of the pixels around the area # This is not valid, summation i srequired: # Di Simone > From a physical viewpoint, # such an approach should call for summation instead of averaging # https://stackoverflow.com/questions/48121916/numpy-resize-rescale-image fig_ddm_rescaled, ax_ddm_rescaled = plt.subplots(1,figsize=(10, 4)) plt.title('Simulation') plt.xlabel('C/A chips') plt.ylabel('Hz') rescaled_doppler_resolution = tds.doppler_resolution rescaled_delay_resolution_chips = tds.time_delay_resolution/delay_chip ddm_rescaled = cv2.resize(ddm_sim, dsize=( 128, 20 ), interpolation=cv2.INTER_AREA ) ddm_rescaled = ddm_rescaled + 0.02*np.max(ddm_rescaled)*np.random.rand(ddm_rescaled.shape[0],ddm_rescaled.shape[1]) im = ax_ddm_rescaled.imshow(ddm_rescaled, cmap='jet', extent=(delay_start, delay_end, doppler_end, doppler_start), aspect=(number_of_doppler_pixels/number_of_delay_pixels)/np.abs(doppler_start/delay_start) ) fig_diff, ax_diff = plt.subplots(1,figsize=(10, 4)) plt.title('Difference') plt.xlabel('C/A chips') plt.ylabel('Hz') ddm_diff = np.abs(ddm_rescaled-p.sea_clutter) ddm_diff[0,0] = 0.35 im = ax_diff.imshow(ddm_diff, cmap='jet', extent=(delay_start, delay_end, doppler_end, doppler_start), aspect=(number_of_doppler_pixels/number_of_delay_pixels)/np.abs(doppler_start/delay_start) ) cbar = fig_diff.colorbar(im, label='Normalized Power', shrink=0.35) plt.show()
def main(): P_t = 26.61 # W G_t = 20 G_r = 25 wavelength = 0.19 # m h_t = 13.82e6 # m h_r = 20e3 # m k_b = 1.38e-23 # J/K T_r = 2*260 # K T_i = 1e-3 # s sigma_target = 12 # From Gleason page 76 P_n = k_b*T_r/T_i # Processed power Y_n = 1/T_i*k_b*T_r print("Y_n = {0}".format(Y_n)) std = np.sqrt(k_b*T_r/T_i) x = np.random.normal(0,std,1000) print("x: {0}".format(np.sqrt(np.mean(np.power(x,2))))) sim_config = simulation_configuration() delay_chip = 1/1.023*1e-6 delay_values = list(np.arange( -5*delay_chip, 5*delay_chip, 0.1*delay_chip )) x = np.zeros((len(delay_values),len(delay_values))) ''' for i, col in enumerate(x): for j, val in enumerate(col): x[i,j] = (2/1e-3*2*k_b*T_r*waf_delay(delay_values[j] - delay_values[i], sim_config)) ''' for i, col in enumerate(x): x[i,:] = (2/1e-3*2*k_b*T_r*waf_delay(delay_values - delay_values[i], sim_config)) fig_covar, ax_covar = plt.subplots(1,figsize=(10, 4)) contour_covar = ax_covar.imshow(x, cmap='jet', extent=[ delay_values[0]/delay_chip, delay_values[-1]/delay_chip, delay_values[0]/delay_chip, delay_values[-1]/delay_chip ], aspect="auto" ) #ticks_x = ticker.FuncFormatter(lambda x, pos: '{0:g}'.format(delax_values[pos]/delax_chip)) #ticks_y = ticker.FuncFormatter(lambda y, pos: '{0:g}'.format(delay_values[pos]/delay_chip)) #ax_covar.xaxis.set_major_formatter(ticks_x) #ax_covar.yaxis.set_major_formatter(ticks_y) fig_covar.colorbar(contour_covar, label='[Watts]') plt.xlabel('C/A chips') plt.ylabel('C/A chips') ''' ddm_noise = np.zeros((40, len(delay_values))) for i in range(40): import pdb; pdb.set_trace() # break ddm_noise[i,:] = np.random.normal(0,x) ''' fig_ddm_noise, ax_ddm_noise = plt.subplots(1,figsize=(10, 4)) ddm_noise = np.zeros((50,len(delay_values))) ddm_noise_integrated = np.copy(ddm_noise) n_int = 1 for i in range(n_int): n = 1000 for i in range(n): print("i: {0}".format(i)) ddm_noise_i = np.power(np.random.multivariate_normal(np.zeros(len(delay_values)),x, (50)),2) ddm_noise += ddm_noise_i ddm_noise /= n ddm_noise -= np.mean(ddm_noise) ddm_noise = np.abs(ddm_noise) ddm_noise_integrated += ddm_noise ddm_noise_integrated /= n_int print("mean cleaned noise expected: {}".format(2/1e-3*2*k_b*T_r/np.sqrt(n))) print("mean cleaned noise: {}".format(np.mean(ddm_noise_integrated))) contour_ddm = ax_ddm_noise.imshow(ddm_noise_integrated, cmap='jet', aspect="auto" ) fig_ddm_noise_i, ax_ddm_noise_i = plt.subplots(1,figsize=(10, 4)) ddm_noise_i = np.power(np.random.multivariate_normal(np.zeros(len(delay_values)),x, (50)),2) contour_ddm = ax_ddm_noise_i.imshow(ddm_noise_integrated - ddm_noise_i/np.sqrt(n), cmap='jet', aspect="auto" ) P_r = (P_t*G_t*wavelength**2*sigma_target*G_r) / ( (4*np.pi)**3 * (h_t*h_r)**2 \ ) print("P_r = {0}".format(P_r)) print("P_n = {0}".format(P_n)) print("SNR = {0}".format(10*np.log10(P_r/P_n))) plt.show()
def main(): sim_config = simulation_configuration() sim_config.jacobian_type = 'spherical' delay_chip = sim_config.delay_chip file_root_name = '2015-12-04-H18' target = targets['devils_tower'] group = '000066' index = 385 - 10 tds = tds_data(file_root_name, group, index) #sim_config.receiver_antenna_gain = lambda p1,p2: 12 ''' p = target_processor_power(); p.n = n for i in range(index - n, index + 2): tds.set_group_index(group, i) ddm_i = normalize(tds.rootgrp.groups[group].variables['DDM'][i].data)*tds.peak_power() p.process_ddm(ddm_i) wind = tds.get_wind() if (wind != None): print("wind: {0}".format(wind)) mean_wind += wind mean_wind /= 2 ddm_tds = np.copy(p.sea_clutter) print("mean wind: {0}".format(mean_wind)) ''' sim_config.fresnel_coefficient = 0.8 n_tds = 20 n = n_tds ddm_tds = np.zeros( tds.rootgrp.groups[group].variables['DDM'][index].data.shape) mean_wind = 0 n_wind = 0 noise_antenna_mean = 0 noise_rx_mean = 0 for i in range(n): print("i: {0}".format(i)) tds.set_group_index(group, index + i) power_i, noise_i = tds.peak_power() ddm_i = normalize( tds.rootgrp.groups[group].variables['DDM'][index + i].data) * power_i print("noise power estimate: {0}".format(noise_i)) ddm_tds += ddm_i wind = tds.get_wind() noise_antenna_mean_i = tds.metagrp.groups[group].variables[ 'AntennaTemperature'][tds.index].data if (np.isnan(noise_antenna_mean_i)): noise_antenna_mean_i = tds.metagrp.groups[group].variables[ 'AntennaTemperatureExtRef'][tds.index].data if (np.isnan(noise_antenna_mean_i)): noise_antenna_mean_i = 225.7 noise_rx_mean_i = tds.metagrp.variables['RxTemperature'][ tds.index_meta].data if (np.isnan(noise_rx_mean_i)): noise_rx_mean_i = 232.09 noise_antenna_mean += noise_antenna_mean_i noise_rx_mean += noise_rx_mean_i print("noise antenna : {}".format(noise_antenna_mean_i)) if (wind != None): print("wind: {0}".format(wind)) mean_wind += wind n_wind += 1 mean_wind /= n_wind ddm_tds /= n #np.flip(ddm_tds) noise_antenna_mean /= n noise_rx_mean /= n noise_antenna_mean = 246.85 noise_rx_mean = 252.09 print("noise_antenna_mean: {0}".format(noise_antenna_mean)) print("noise_rx_mean: {0}".format(noise_rx_mean)) print("mean wind: {0}".format(mean_wind)) sim_config.u_10 = 2.35 #sim_config.phi_0 = 130*np.pi/180 # 0.547 sim_config.phi_0 = 45 * np.pi / 180 # max power diff: 0.58 # Plot TDS DDM sea clutter tds.set_group_index(group, index) r_sp, lat_sp, lon_sp = tds.find_sp() datenum = tds.rootgrp.groups[ tds.group].variables['IntegrationMidPointTime'][tds.index] string = str(datenum_to_pytime(float(datenum))) \ + ' Lat: ' + "{0:.2f}".format(tds.lat_sp_tds) \ + ' Lon: ' + "{0:.2f}".format(tds.lon_sp_tds) tds_number_of_delay_pixels = tds.metagrp.groups[ tds.group].NumberOfDelayPixels tds_number_of_doppler_pixels = tds.metagrp.groups[ tds.group].NumberOfDopplerPixels tds_delay_start = tds.calculate_delay_increment_chips(0) tds_delay_end = tds.calculate_delay_increment_chips( tds_number_of_delay_pixels - 1) tds_delay_resolution = (tds_delay_end - tds_delay_start) / 128 tds_doppler_start = tds.calculate_doppler_increment( -np.floor(tds_number_of_doppler_pixels / 2)) tds_doppler_end = tds.calculate_doppler_increment( np.floor(tds_number_of_doppler_pixels / 2 - 0.5)) tds_doppler_resolution = 500 fig_tds, ax_tds = plt.subplots(1, figsize=(10, 4)) plt.title('TDS-1 Experimental Data') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_tds = ax_tds.imshow( ddm_tds, cmap='jet', extent=(tds_delay_start, tds_delay_end, tds_doppler_end, tds_doppler_start), #aspect=(tds_number_of_doppler_pixels/tds_number_of_delay_pixels)/np.abs(tds_doppler_start/tds_delay_start) aspect='auto') t = plt.text(0.01, 0.85, string, { 'color': 'w', 'fontsize': 12 }, transform=ax_tds.transAxes) cbar = fig_tds.colorbar(contour_tds, label='Power') # Load TDS Geometry in simulation configuration n_z = unit_vector(ellip_norm(tds.r_sp_tds)) n_x = unit_vector(np.cross(n_z, tds.r_sp_tds - tds.r_t)) n_y = unit_vector(np.cross(n_z, n_x)) v_tx = np.dot(tds.v_t, n_x) v_ty = np.dot(tds.v_t, n_y) v_tz = np.dot(tds.v_t, n_z) v_rx = np.dot(tds.v_r, n_x) v_ry = np.dot(tds.v_r, n_y) v_rz = np.dot(tds.v_r, n_z) h_r = np.dot((tds.r_r - tds.r_sp_tds), n_z) h_t = np.dot((tds.r_t - tds.r_sp_tds), n_z) elevation = angle_between(n_y, tds.r_t - tds.r_sp_tds) v_t = np.array([v_tx, v_ty, v_tz]) v_r = np.array([v_rx, v_ry, v_rz]) print("h_r: {}".format(h_r)) print("h_t: {}".format(h_t)) print("elevation: {}".format(elevation)) print("v_r: {}".format(np.linalg.norm(v_r))) print("v_t: {}".format(np.linalg.norm(v_t))) sim_config.set_scenario_local_ref( h_r=np.dot((tds.r_r - tds.r_sp_tds), n_z), h_t=np.dot((tds.r_t - tds.r_sp_tds), n_z), elevation=angle_between(n_y, tds.r_t - tds.r_sp_tds), v_t=np.array([v_tx, v_ty, v_tz]), v_r=np.array([v_rx, v_ry, v_rz])) # DDM sim_config.delay_increment_start = tds_delay_start * delay_chip sim_config.delay_increment_end = tds_delay_end * delay_chip sim_config.delay_resolution = ( sim_config.delay_increment_end - sim_config.delay_increment_start) / tds_number_of_delay_pixels / 4 sim_config.doppler_increment_start = tds_doppler_start sim_config.doppler_increment_end = tds_doppler_end + tds_doppler_resolution sim_config.doppler_resolution = ( sim_config.doppler_increment_end - sim_config.doppler_increment_start) / tds_number_of_doppler_pixels / 4 ddm_sim = (simulate_ddm(sim_config)) fig_ddm, ax_ddm = plt.subplots(1, figsize=(10, 4)) plt.title('DDM original simulation') plt.xlabel('C/A chips') plt.ylabel('Hz') contour_ddm = ax_ddm.imshow(ddm_sim, cmap='jet', extent=(sim_config.delay_increment_start, sim_config.delay_increment_end, sim_config.doppler_increment_end, sim_config.doppler_increment_start), aspect="auto") cbar = fig_ddm.colorbar(contour_ddm, label='Correlated Power [Watts]') # DDM Rescaled fig_ddm_rescaled, ax_ddm_rescaled = plt.subplots(1, figsize=(10, 4)) plt.title('Simulation Rescaled') plt.xlabel('C/A chips') plt.ylabel('Hz') ddm_rescaled = rescale(ddm_sim, tds_number_of_doppler_pixels, tds_number_of_delay_pixels) # Noise waf_delay_increment_values = list( np.arange( -tds_delay_end * delay_chip, tds_delay_end * delay_chip + tds_delay_resolution * delay_chip, tds_delay_resolution * delay_chip)) waf_doppler_increment_values = list( np.arange(tds_doppler_start, tds_doppler_end + tds_doppler_resolution, tds_doppler_resolution)) waf_delay_grid, waf_doppler_grid = np.meshgrid( waf_delay_increment_values, waf_doppler_increment_values) waf_matrix = woodward_ambiguity_function(waf_delay_grid, waf_doppler_grid, sim_config)**2 noise_temperature = noise_antenna_mean + noise_rx_mean ddm_rescaled = add_thermal_noise(tds_number_of_doppler_pixels, tds_number_of_delay_pixels, 1 * 1000, noise_temperature, ddm_rescaled, sim_config) contour_res = ax_ddm_rescaled.imshow( ddm_rescaled, cmap='jet', extent=(tds_delay_start, tds_delay_end, tds_doppler_end, tds_doppler_start), #aspect=(tds_number_of_doppler_pixels/tds_number_of_delay_pixels)/np.abs(tds_doppler_start/tds_delay_start) aspect='auto') cbar = fig_ddm_rescaled.colorbar(contour_res, label='Correlated Power [Watts]') # Difference fig_diff, ax_diff = plt.subplots(1, figsize=(10, 4)) plt.title('Difference') plt.xlabel('C/A chips') plt.ylabel('Hz') ddm_diff = np.copy(ddm_rescaled) for row_i, row in enumerate(ddm_diff): for col_i, val in enumerate(row): col_i_shift = col_i row_i_shift = row_i col_shift = 1 row_shift = 0 if (col_i + col_shift) >= 0 and (col_i + col_shift) < 128: col_i_shift += col_shift if (row_i + row_shift) >= 0 and (row_i + row_shift) < 20: row_i_shift += row_shift val_tds = ddm_tds[row_i_shift, col_i_shift] val = ddm_rescaled[row_i, col_i] if row_i == 0: ddm_diff[row_i, col_i] = 0 elif col_i == 0: ddm_diff[row_i, col_i] = 0 else: rel = np.abs((val - val_tds) / val_tds) ddm_diff[row_i, col_i] = rel ddm_diff[:, -1] = 0 ddm_diff[0, 0] = 0 ddm_diff[0, 1] = 1 np.place(ddm_diff, np.abs(ddm_diff) > 2, 0.1) print(file_root_name) print("h_r: {}".format(h_r)) print("h_t: {}".format(h_t)) print("elevation: {}".format(elevation * 180 / np.pi)) print("v_r: {}".format(np.linalg.norm(v_r))) print("v_t: {}".format(np.linalg.norm(v_t))) print("max diff: {}".format(np.max(ddm_diff[1:, 1:]))) im = ax_diff.imshow( ddm_diff, cmap='jet', extent=(tds_delay_start, tds_delay_end, tds_doppler_end, tds_doppler_start), #aspect=(tds_number_of_doppler_pixels/tds_number_of_delay_pixels)/np.abs(tds_doppler_start/tds_delay_start) aspect='auto') cbar = fig_diff.colorbar(im, label='Relative error') # SNR fig_snr, ax_snr = plt.subplots(1, figsize=(10, 4)) plt.title('SNR') plt.xlabel('C/A chips') plt.ylabel('Hz') T_noise_receiver = noise_antenna_mean + noise_rx_mean k_b = 1.38e-23 # J/K y_noise = 4 / sim_config.coherent_integration_time * k_b * T_noise_receiver / np.sqrt( 1000) ddm_rescaled_snr = rescale(ddm_sim, tds_number_of_doppler_pixels, tds_number_of_delay_pixels) ddm_snr = np.copy(10 * np.log10(np.abs(ddm_rescaled_snr) / y_noise)) contour_snr = ax_snr.imshow( ddm_snr, cmap='jet', extent=(tds_delay_start, tds_delay_end, tds_doppler_end, tds_doppler_start), #aspect=(tds_number_of_doppler_pixels/tds_number_of_delay_pixels)/np.abs(tds_doppler_start/tds_delay_start) aspect='auto') cbar = fig_snr.colorbar(contour_snr, label='dB') plt.show()
def main(): sim_config = simulation_configuration() delay_chip = sim_config.delay_chip delay_increment_start = sim_config.delay_increment_start delay_increment_end = sim_config.delay_increment_end delay_resolution = sim_config.delay_resolution doppler_increment_start = sim_config.doppler_increment_start doppler_increment_end = sim_config.doppler_increment_end doppler_resolution = sim_config.doppler_resolution doppler_specular_point = eq_doppler_absolute_shift(np.array([0, 0, 0]), sim_config) # Surface mesh x_0 = -150e3 # meters x_1 = 150e3 # meters n_x = 500 y_0 = -150e3 # meters y_1 = 150e3 # meters n_y = 500 x_grid, y_grid = np.meshgrid(np.linspace(x_0, x_1, n_x), np.linspace(y_0, y_1, n_y)) r = np.array([x_grid, y_grid, 0]) # Isolines and Antenna gain z_grid_delay_chip = eq_delay_incremet(r, sim_config) / delay_chip doppler_specular_point = eq_doppler_absolute_shift(np.array([0, 0, 0]), sim_config) z_grid_doppler_increment = eq_doppler_absolute_shift( r, sim_config) - doppler_specular_point # Iso lines plot fig_isolines, ax_isolines = plt.subplots(1, figsize=(10, 4)) contour_delay_chip = ax_isolines.contour( x_grid, y_grid, z_grid_delay_chip, np.arange(0, delay_increment_end / delay_chip, 1), cmap='winter', alpha=0.6) contour_doppler = ax_isolines.contour(x_grid, y_grid, z_grid_doppler_increment, np.arange(doppler_increment_start, doppler_increment_end, 500), cmap='jet', alpha=0.8) test_delay = np.array([3 * delay_chip]) test_doppler = np.array([1000]) + doppler_specular_point print('Finding intersection for d:{0}, f:{1}'.format( test_delay, test_delay)) x_s_1 = x_delay_doppler_1(test_delay, test_doppler, sim_config) y_s_1 = y_delay_doppler_1(test_delay, test_doppler, sim_config) x_s_2 = x_delay_doppler_2(test_delay, test_doppler, sim_config) y_s_2 = y_delay_doppler_2(test_delay, test_doppler, sim_config) ax_isolines.scatter(x_s_1, y_s_1, s=70, marker=(5, 2), zorder=4) ax_isolines.scatter(x_s_2, y_s_2, s=70, marker=(5, 2), zorder=4) fig_isolines.colorbar(contour_delay_chip, label='C/A chips') fig_isolines.colorbar(contour_doppler, label='Hz') ticks_y = ticker.FuncFormatter(lambda y, pos: '{0:g}'.format(y / 1000)) ticks_x = ticker.FuncFormatter(lambda x, pos: '{0:g}'.format(x / 1000)) ax_isolines.xaxis.set_major_formatter(ticks_x) ax_isolines.yaxis.set_major_formatter(ticks_y) plt.xlabel('[km]') plt.ylabel('[km]') plt.show()
def main(): # Di Simone file_root_name = '2015-04-01-H00' target = targets['hibernia'] group = '000095' index = 525 # Hibernia # Really good detection #file_root_name = 'raw/L1B/2017-03-12-H18' #target = targets['hibernia'] #group = '000035' #index = 681 # Devils Tower #file_root_name = 'raw/L1B/2015-12-04-H18' #target = targets['devils_tower'] #group = '000066' #index = 376 #file_root_name = 'raw/L1B/2016-11-14-H06' #target = targets['petronius'] #group = '000057' #index = 0 # 0.5 deg error approx 55 km error if index == 0: search_error = 0.7 cdf4_search(file_root_name, target, search_error) target_delay_increment = 4 target_doppler_increment = 2000 tds = tds_data(file_root_name, group, index) tds.set_group_index(group, index) tds.plot_ddm() print("t vel: {}".format(np.linalg.norm(tds.v_t))) r_sp, lat_sp, lon_sp = tds.find_sp() n_z = unit_vector(ellip_norm(r_sp)) n_x = unit_vector(np.cross(n_z, r_sp - tds.r_t)) n_y = unit_vector(np.cross(n_z, n_x)) #TODO: imporve sp auto calculation h_r = np.dot((tds.r_r - r_sp), n_z) print("h_r: {}".format(h_r)) h_t = np.dot((tds.r_t - r_sp), n_z) print("h_t: {}".format(h_t)) elev = angle_between(n_y, tds.r_t - r_sp) print("elev: {}".format(elev)) print("elev tds: {}".format(90 - tds.sp_incidence_tds)) print("elve: {0} elev: {1}".format( elev * 180 / np.pi, angle_between(-n_y, tds.r_r - r_sp) * 180 / np.pi)) print("h_r: {0} h_t: {1}".format(h_r, h_t)) def z_sp(x, y): R = np.linalg.norm(r_sp) print("r: {}".format(R)) return (R**2 - x**2 - y**2)**(1 / 2) - R light_speed = 299792458 # m/s def time_inc_eq(x, y): return (np.sqrt(x**2 + (y + h_r / np.tan(elev))**2 + h_r**2) - h_r / np.sin(elev) - y * np.cos(elev)) / light_speed def doppler_eq(x, y): # GPS L1 center frequency f_0 = 10.23e6 # Hz f_carrier = 154 * f_0 # 1575.42e6 Hz v_tx = np.dot(tds.v_t, n_x) v_ty = np.dot(tds.v_t, n_y) v_tz = np.dot(tds.v_t, n_z) v_rx = np.dot(tds.v_r, n_x) v_ry = np.dot(tds.v_r, n_y) v_rz = np.dot(tds.v_r, n_z) # With the very far way transmitter approximation: f_D_0 = f_carrier / light_speed * ( -v_ty * np.cos(elev) - v_tz * np.sin(elev) + (v_rx * x + v_ry * (y + h_r / np.tan(elev)) - v_rz * h_r) * (x**2 + (y + h_r / np.tan(elev))**2 + h_r**2)**(-0.1e1 / 0.2e1)) return f_D_0 def doppler_inc_eq(x, y): return doppler_eq(x, y) - doppler_eq(0, 0) extent = 200e3 extent_x0 = -extent extent_x1 = extent extent_y0 = -extent extent_y1 = extent linsapce_delta = 500 X, Y = np.meshgrid(np.linspace(extent_x0, extent_x1, linsapce_delta), np.linspace(extent_y0, extent_y1, linsapce_delta)) delay_chip = 1 / 1.023e6 # seconds Z_time_chip = time_inc_eq(X, Y) / delay_chip Z_doppler = doppler_inc_eq(X, Y) fig_surface, ax_surface = plt.subplots(1, figsize=(10, 4)) plt.xlabel('[km]') plt.ylabel('[km]') ticks_x = ticker.FuncFormatter(lambda x, pos: '{0:g}'.format(x / 1000)) ticks_y = ticker.FuncFormatter(lambda y, pos: '{0:g}'.format(y / 1000)) ax_surface.xaxis.set_major_formatter(ticks_x) ax_surface.yaxis.set_major_formatter(ticks_y) # Iso-Delay Contour ax_surface.set_title('Time Delay Contour') contour_delay = ax_surface.contour(X, Y, Z_time_chip, np.arange(0, 15, 0.5), cmap='viridis') fig_surface.colorbar(contour_delay, label='C/A chips') ax_surface.grid(c='k', ls='-', alpha=0.3) plt.show(block=False) # Iso-Doppler Contour ax_surface.set_title('Doppler Shift Contour') plt.xlabel('[km]') plt.ylabel('[km]') contour_doppler = ax_surface.contour(X, Y, Z_doppler, np.arange(-5000, 5000, 500), cmap='viridis') fig_surface.colorbar(contour_doppler, label='Hz') ax_surface.grid(c='k', ls='-', alpha=0.3) target_iso_delay = ax_surface.contour(X, Y, Z_time_chip, [target_delay_increment], colors='red', linewidths=2.5, linestyles='dashed', extent=(extent_x0, extent_x1, extent_y0, extent_y1)) target_iso_doppler = ax_surface.contour(X, Y, Z_doppler, [target_doppler_increment], colors='red', linewidths=2.5, linestyles='dashed', extent=(extent_x0, extent_x1, extent_y0, extent_y1)) # TDS specular point in local coordinates x_sp_tds = np.dot(n_x, (tds.r_sp_tds - r_sp)) y_sp_tds = np.dot(n_y, (tds.r_sp_tds - r_sp)) ax_surface.scatter(x_sp_tds, x_sp_tds, s=70, marker=(5, 2), zorder=4, color='green') # Target in ECEF coordinates target_lat = target.lat_deg * np.pi / 180 target_lon = target.lon_deg * np.pi / 180 r_target_x = np.linalg.norm(r_sp) * np.cos(target_lat) * np.cos(target_lon) r_target_y = np.linalg.norm(r_sp) * np.cos(target_lat) * np.sin(target_lon) r_target_z = np.linalg.norm(r_sp) * np.sin(target_lat) r_target = np.array([r_target_x, r_target_y, r_target_z]) # Target in local coordinates x_target = np.dot(n_x, (r_target - r_sp)) y_target = np.dot(n_y, (r_target - r_sp)) ax_surface.scatter(x_target, y_target, s=70, zorder=4, color='black') lon = np.arctan2(r_target[1], r_target[0]) * 180 / np.pi lat = np.arcsin(abs(r_target[2] / np.linalg.norm(r_target))) * 180 / np.pi print("lat target: {0} lon target: {1}".format(lat, lon)) # Intersection of target iso-delay and iso-doppler intersections intersections = find_contour_intersection(target_iso_delay, target_iso_doppler) try: for i in intersections: ax_surface.scatter(i.x, i.y, s=70, zorder=4, color='orange') r_i = np.array([i.x, i.y]) r_target = np.array([x_target, y_target]) print("error: {0}".format(np.linalg.norm(r_target - r_i) / 1e3)) r_sol = r_sp + n_x * i.x + n_y * i.y lon = np.arctan2(r_sol[1], r_sol[0]) * 180 / np.pi lat = np.arcsin(abs( r_sol[2] / np.linalg.norm(r_sol))) * 180 / np.pi print("lat: {0} lon: {1}".format(lat, lon)) except TypeError as te: print('No intersections') n_z = unit_vector(ellip_norm(tds.r_sp_tds)) n_x = unit_vector(np.cross(n_z, tds.r_sp_tds - tds.r_t)) n_y = unit_vector(np.cross(n_z, n_x)) v_tx = np.dot(tds.v_t, n_x) v_ty = np.dot(tds.v_t, n_y) v_tz = np.dot(tds.v_t, n_z) v_rx = np.dot(tds.v_r, n_x) v_ry = np.dot(tds.v_r, n_y) v_rz = np.dot(tds.v_r, n_z) sim_config = simulation_configuration() sim_config.set_scenario_local_ref( h_r=np.dot((tds.r_r - tds.r_sp_tds), n_z), h_t=np.dot((tds.r_t - tds.r_sp_tds), n_z), elevation=angle_between(n_y, tds.r_t - tds.r_sp_tds), v_t=np.array([v_tx, v_ty, v_tz]), v_r=np.array([v_rx, v_ry, v_rz])) doppler_specular_point = eq_doppler_absolute_shift(np.array([0, 0, 0]), sim_config) delay = np.array([4 * delay_chip]) f_doppler = np.array([doppler_specular_point + 1800]) r_1, r_2 = spherical.delay_doppler_to_local_surface( delay, f_doppler, sim_config) print(r_1) print(r_2) ax_surface.scatter(r_1[0], r_1[1], s=70, zorder=4, color='blue') ax_surface.scatter(r_2[0], r_2[1], s=70, zorder=4, color='blue') plt.show(block=False) plt.show()
def main(): P_t = 26.61 # W G_t = 20 G_r = 25 wavelength = 0.19 # m h_t = 13.82e6 # m h_r = 20e3 # m k_b = 1.38e-23 # J/K T_r = 225.7 # K T_i = 1e-3 # s sigma_target = 12 # From Gleason page 76 P_n = k_b * T_r / T_i # Processed power Y_n = 1 / T_i * k_b * T_r print("Y_n = {0}".format(Y_n)) print("Y_n amplitude = {0}".format(np.sqrt(Y_n * 12))) std = np.sqrt(k_b * T_r / T_i) x = np.random.normal(0, std, 1000) print("x: {0}".format(np.sqrt(np.mean(np.power(x, 2))))) sim_config = simulation_configuration() delay_chip = 1 / 1.023 * 1e-6 delay_values = list( np.arange(-15 * delay_chip, 15 * delay_chip, (15 * delay_chip - (-15 * delay_chip)) / 128)) doppler_values = list( np.arange(-5000 * delay_chip, 5000 * delay_chip, (5000 * delay_chip - (-5000 * delay_chip)) / 20)) doppler_specular_point = eq_doppler_absolute_shift(np.array([0, 0, 0]), sim_config) ''' ddm_noise = np.zeros((40, len(delay_values))) for i in range(40): import pdb; pdb.set_trace() # break ddm_noise[i,:] = np.random.normal(0,x) ''' n_row = 20 ddm_noise = np.zeros((n_row, len(delay_values))) n_incoh = 10 x_0 = np.zeros((len(delay_values), len(delay_values)), dtype=np.complex_) for i, col in enumerate(x_0): tau_increment = delay_values - delay_values[i] a1 = 1 / 1e-3 * 1 * k_b * T_r * waf_delay(tau_increment, sim_config) x_0[i, :] = a1 for i_incoh in range(n_incoh): print("i: {0}".format(i_incoh)) ddm_noise_i = np.zeros((n_row, len(delay_values))) for i_row in range(n_row): x = np.zeros((len(delay_values), len(delay_values)), dtype=np.complex_) for i, col in enumerate(x): tau_increment = delay_values - delay_values[i] a1 = x_0[i, :] a2 = np.exp(-2j * np.pi * (doppler_values[i_row] + doppler_specular_point) * tau_increment) a = np.multiply(a1, a2) x[i, :] = a ''' fig_var, ax_var = plt.subplots(1,figsize=(10, 4)) contour_ddm_noise = ax_var.imshow(np.absolute(x), cmap='jet', aspect="auto" ) plt.show() ''' ddm_noise_i[i_row, :] = np.power( np.absolute( np.random.multivariate_normal(np.zeros(len(delay_values)), x)), 2) ddm_noise += ddm_noise_i ddm_noise /= n_incoh fig_ddm_noise, ax_ddm_noise = plt.subplots(1, figsize=(10, 4)) contour_ddm_noise = ax_ddm_noise.imshow(ddm_noise, cmap='jet', aspect="auto") cbar = fig_ddm_noise.colorbar(contour_ddm_noise, label='Power') P_r = (P_t*G_t*wavelength**2*sigma_target*G_r) / ( (4*np.pi)**3 * (h_t*h_r)**2 \ ) print("P_r = {0}".format(P_r)) print("P_n = {0}".format(P_n)) print("SNR = {0}".format(10 * np.log10(P_r / P_n))) plt.show()