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