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