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.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() #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 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