def test_beam_angles_algorithm_01(self):
"""
beam angles algorithm test #01
------------------------------
"""
# load the expected data object
expected = TestDataLoader(self.expected_01, delim=' ')
# load the input data
input_data = TestDataLoader(self.input_01, delim=' ')
self.initialise_algorithm(input_data)
# create surface location objects
surfs = []
for i, surf_num in enumerate(input_data["surface_counter"]):
surf = SurfaceData(
self.cst,
self.chd,
surf_num,
# time_surf=input_data["time_surf"][i],
x_surf=input_data["x_surf"][i],
y_surf=input_data["y_surf"][i],
z_surf=input_data["z_surf"][i],
)
surfs.append(surf)
# create packet object
packet = L1AProcessingData(
self.cst,
self.chd,
time_sar_ku=input_data["time_sar_ku"],
x_sar_sat=input_data["x_sar_sat"],
y_sar_sat=input_data["y_sar_sat"],
z_sar_sat=input_data["z_sar_sat"],
x_vel_sat_sar=input_data["x_vel_sat_sar"],
y_vel_sat_sar=input_data["y_vel_sat_sar"],
z_vel_sat_sar=input_data["z_vel_sat_sar"],
pri_sar_pre_dat=input_data["pri_sar_pre_dat"],
doppler_angle_sar_sat=input_data["doppler_angle_sar_sat"])
work_loc = input_data["working_surface_location_counter"]
# execute beam angles algorithm
self.beam_angles_algorithm(surfs, packet, surfs[work_loc])
# confirm correct number of surfaces seen
self.assertEqual(len(self.beam_angles_algorithm.surfaces_seen),
expected["surfaces_seen"])
# confirm the working surface location is seen
self.assertTrue(self.beam_angles_algorithm.work_location_seen,
msg="working location seen")
# check beam angles are correct
self.assertTrue(np.allclose(self.beam_angles_algorithm.beam_angles,
expected["beam_ang"]),
msg="Beam Angles values are not correct")
# check surface indicies are correct
self.assertTrue(np.array_equal(
self.beam_angles_algorithm.surfaces_seen,
expected["surf_loc_index"]),
msg="Surface Indicies are not correct")
def test_surface_location_algorithm_04(self):
"""
surface location algorithm test 04
----------------------------------
loads multiple input ISPs and two input surface locations.
expected result is for the surface location algorithm to
generate a new surface location and focus the position of the previous
one towards the target position. The attributes of these
surface locations are then validated against the expected
values.
"""
# load the expected data
expected_data = TestDataLoader(self.expected_04, delim=' ')
# load the input data
inputs = TestDataLoader(self.inputs_04, delim=' ')
self.initialise_algorithm(inputs)
# create all input packet objects
isps = [
L1AProcessingData(self.cst, self.chd, i,
time_sar_ku=time,
lat_sar_sat=inputs["lat_sar_sat"][i],
lon_sar_sat=inputs["lon_sar_sat"][i],
alt_sar_sat=inputs["alt_sar_sat"][i],
win_delay_sar_ku=inputs["win_delay_sar_ku"][i],
x_sar_sat=inputs["x_sar_sat"][i],
y_sar_sat=inputs["y_sar_sat"][i],
z_sar_sat=inputs["z_sar_sat"][i],
alt_rate_sat_sar=0,
roll_sar=inputs["roll_sar"][i],
pitch_sar=inputs["pitch_sar"][i],
yaw_sar=inputs["yaw_sar"][i],
x_vel_sat_sar=inputs["x_vel_sat_sar"][i],
y_vel_sat_sar=inputs["y_vel_sat_sar"][i],
z_vel_sat_sar=inputs["z_vel_sat_sar"][i],
days=inputs["time_sar_ku"] // self.cst.sec_in_day,
seconds=inputs["time_sar_ku"] % self.cst.sec_in_day) \
for i, time in enumerate(inputs["time_sar_ku"])
]
# calculate surface position for each packet
for packet in isps:
packet.compute_location_sar_surf()
surfs = []
# create the prior surface location object
for i, time in enumerate(inputs["time_surf"]):
surf = SurfaceData(
self.cst, self.chd,
time_surf=time,
x_surf=inputs["x_surf"][i],
y_surf=inputs["y_surf"][i],
z_surf=inputs["z_surf"][i],
lat_surf=inputs["lat_surf"][i],
lon_surf=inputs["lon_surf"][i],
alt_surf=inputs["alt_surf"][i],
x_sat=inputs["x_sat"][i],
y_sat=inputs["y_sat"][i],
z_sat=inputs["z_sat"][i],
lat_sat=inputs["lat_sat"][i],
lon_sat=inputs["lon_sat"][i],
alt_sat=inputs["alt_sat"][i],
x_vel_sat=inputs["x_vel_sat"][i],
y_vel_sat=inputs["y_vel_sat"][i],
z_vel_sat=inputs["z_vel_sat"][i],
focus_target_distance=inputs["focus_target_distance"][i],
win_delay_surf=inputs["win_delay_surf"][i]
)
surf.compute_surf_sat_vector()
surf.compute_angular_azimuth_beam_resolution(
inputs["pri_sar_pre_dat"][i]
)
surfs.append(surf)
# execute the surface location algorithm
new_surf = self.surface_location_algorithm(surfs, isps)
# confirm new surface has been created
self.assertTrue(new_surf, msg="failed to create new surface")
# retreive properties of the surface location
surf = surfs[1]
# validate properties
self.assertAlmostEqual(surf.time_surf, expected_data["time_surf"])
self.assertAlmostEqual(surf.x_surf, expected_data["x_surf"], delta=1e-5)
self.assertAlmostEqual(surf.y_surf, expected_data["y_surf"], delta=1e-5)
self.assertAlmostEqual(surf.z_surf, expected_data["z_surf"], delta=1e-5)
self.assertAlmostEqual(surf.lat_surf, expected_data["lat_surf"], delta=1e-12)
self.assertAlmostEqual(surf.lon_surf, expected_data["lon_surf"], delta=1e-12)
self.assertAlmostEqual(surf.alt_surf, expected_data["alt_surf"], delta=1e-4)
self.assertAlmostEqual(surf.win_delay_surf, expected_data["win_delay_surf"])
def multilooking_tests(self, input_data, expected):
"""
:param input_data:
:param expected:
:return:
"""
self.initialise_algorithm(input_data)
zp_fact_range = input_data['zp_fact_range_cnf']
data_stack_size = input_data['data_stack_size']
input_stack_mask_vector = input_data['stack_mask_vector']
n_samples_max = self.chd.n_samples_sar * zp_fact_range
stack_mask = np.reshape(
input_data['stack_mask'],
(data_stack_size, n_samples_max)
)
beams_masked = np.reshape(
input_data['beams_masked'],
(data_stack_size, n_samples_max)
)
working_location = SurfaceData(
self.cst, self.chd,
data_stack_size=data_stack_size,
beam_angles_surf=input_data['beam_angles_surf'],
look_angles_surf=input_data['look_angles_surf'],
pointing_angles_surf=input_data['pointing_angles_surf'],
doppler_angles_surf=input_data['doppler_angles_surf'],
stack_mask_vector=input_stack_mask_vector,
stack_mask=stack_mask,
beams_masked=beams_masked
)
self.multilooking_algorithm.zp_fact_range =\
input_data['zp_fact_range_cnf']
self.multilooking_algorithm.flag_avoid_zeros_in_multilooking =\
input_data['flag_avoid_zeros_in_multilooking']
self.multilooking_algorithm.n_looks_stack =\
input_data['n_looks_stack_cnf']
self.multilooking_algorithm(working_location)
expected_waveform = expected['wfm_ml_sar']
for sample_index in range(n_samples_max):
self.assertEqual(
expected_waveform[sample_index],
self.multilooking_algorithm.waveform_multilooked[sample_index]
)
self.zero_float_assertion(
expected['stack_skewness'],
self.multilooking_algorithm.stack_skewness
)
self.zero_float_assertion(
expected['stack_kurtosis'],
self.multilooking_algorithm.stack_kurtosis
)
self.zero_float_assertion(
expected['stack_std'],
self.multilooking_algorithm.stack_std
)
self.zero_float_assertion(
expected['stack_look_angle_centre'],
self.multilooking_algorithm.look_angle_centre
)
self.zero_float_assertion(
expected['stack_pointing_angle_centre'],
self.multilooking_algorithm.pointing_angle_centre
)
# look angle
self.assertEqual(
expected['start_look_angle'],
self.multilooking_algorithm.start_look_angle
)
self.assertEqual(
expected['stop_look_angle'],
self.multilooking_algorithm.stop_look_angle
)
# doppler angle
self.assertEqual(
expected['start_doppler_angle'],
self.multilooking_algorithm.start_doppler_angle
)
self.assertEqual(
expected['stop_doppler_angle'],
self.multilooking_algorithm.stop_doppler_angle
)
# pointing angle
self.assertEqual(
expected['start_pointing_angle'],
self.multilooking_algorithm.start_pointing_angle
)
self.assertEqual(
expected['stop_pointing_angle'],
self.multilooking_algorithm.stop_pointing_angle
)
# beams contributing
self.assertEqual(
expected['n_beams_multilooking'],
self.multilooking_algorithm.n_beams_multilooking
)
self.assertEqual(
expected['n_beams_start_stop'],
self.multilooking_algorithm.n_beams_start_stop
)
for expect, actual in zip(expected['stack_mask_vector_start_stop'],
self.multilooking_algorithm.stack_mask_vector_start_stop):
self.assertEqual(expect, actual)
self.assertEqual(
len(expected['stack_mask_vector_start_stop']),
len(self.multilooking_algorithm.stack_mask_vector_start_stop)
)
def test_stacking_algorithm_01(self):
"""
stack_gathering algorithm test 01
--------------------------
"""
input_data = TestDataLoader(self.inputs_01, delim=' ')
expected = TestDataLoader(self.expected_01, delim=' ')
self.initialise_algorithm(input_data)
all_stack_size = input_data["all_stack_size"]
input_beam_angles_list = np.reshape(
input_data["beam_angles_list"],
(all_stack_size, self.chd.n_ku_pulses_burst))
isps = []
for stack_index in range(all_stack_size):
beams_focused = np.zeros(
(self.chd.n_ku_pulses_burst, self.chd.n_samples_sar))
pid = PacketPid.echo_sar if input_data['isp_pid'][
stack_index] == 7 else PacketPid.echo_rmc
packet = L1AProcessingData(
self.cst,
self.chd,
stack_index,
t0_sar=input_data["T0_sar"][stack_index],
doppler_angle_sar_sat=input_data["doppler_angle_sar_sat"]
[stack_index],
pitch_sar=input_data["pitch_sar"][stack_index],
beam_angles_list=input_beam_angles_list[stack_index, :],
beams_focused=beams_focused,
isp_pid=pid)
isps.append(packet)
working_loc = SurfaceData(self.cst, self.chd, stack_all_bursts=isps)
for beam_index in input_data["stack_all_beam_indexes"]:
working_loc.add_stack_beam_index(beam_index, 0, 0)
self.stacking_algorithm(working_loc)
self.assertEqual(self.stacking_algorithm.data_stack_size,
expected["data_stack_size"])
self.assertEqual(self.stacking_algorithm.surface_type,
SurfaceType(expected["surface_type"]))
# beam_angles_surf
self.assertTrue(np.allclose(self.stacking_algorithm.beam_angles_surf,
expected["beam_angles_surf"]),
msg="beam_angles_surf do not match expected values")
# t0_surf
self.assertTrue(np.allclose(self.stacking_algorithm.t0_surf,
expected["t0_surf"]),
msg="t0_surf do not match expected values")
# doppler_angles_surf
self.assertTrue(np.allclose(
self.stacking_algorithm.doppler_angles_surf,
expected["doppler_angles_surf"]),
msg="doppler_angles_surf do not match expected values")
# look_angles_surf
self.assertTrue(np.allclose(self.stacking_algorithm.look_angles_surf,
expected["look_angles_surf"]),
msg="look_angles_surf do not match expected values")
# pointing_angles_surf
self.assertTrue(
np.allclose(self.stacking_algorithm.pointing_angles_surf,
expected["pointing_angles_surf"]),
msg="pointing_angles_surf do not match expected values")
def test_surface_location_algorithm_03(self):
"""
surface location algorithm test 03
----------------------------------
loads multiple input ISPs and one input surface location.
expected result is for the surface location algorithm to
generate a new surface location. The attributes of this
new surface location are then validated against the expected
values.
"""
# load the expected data
expected_data = TestDataLoader(self.expected_03, delim=' ')
# load the input data
inputs = TestDataLoader(self.input_03, delim=' ')
self.initialise_algorithm(inputs)
# create all input packet objects
isps = [
L1AProcessingData(self.cst, self.chd, i,
time_sar_ku=time,
lat_sar_sat=inputs["lat_sar_sat"][i],
lon_sar_sat=inputs["lon_sar_sat"][i],
alt_sar_sat=inputs["alt_sar_sat"][i],
win_delay_sar_ku=inputs["win_delay_sar_ku"][i],
x_sar_sat=0,
y_sar_sat=0,
z_sar_sat=0,
alt_rate_sat_sar=0,
roll_sar=0,
pitch_sar=0,
yaw_sar=0,
x_vel_sat_sar=0,
y_vel_sat_sar=0,
z_vel_sat_sar=0,
days=inputs["time_sar_ku"] // self.cst.sec_in_day,
seconds=inputs["time_sar_ku"] % self.cst.sec_in_day) \
for i, time in enumerate(inputs["time_sar_ku"])
]
# calculate surface position for each packet
for packet in isps:
packet.compute_location_sar_surf()
# create the prior surface location object
surf = SurfaceData(self.cst,
self.chd,
time_surf=inputs["time_surf"],
x_surf=inputs["x_surf"],
y_surf=inputs["y_surf"],
z_surf=inputs["z_surf"],
x_sat=inputs["x_sat"],
y_sat=inputs["y_sat"],
z_sat=inputs["z_sat"],
x_vel_sat=inputs["x_vel_sat"],
y_vel_sat=inputs["y_vel_sat"],
z_vel_sat=inputs["z_vel_sat"])
# compute properties of the surface location
surf.compute_surf_sat_vector()
surf.compute_angular_azimuth_beam_resolution(inputs["pri_sar_pre_dat"])
# execute the surface location algorithm
new_surf = self.surface_location_algorithm([surf], isps)
# confirm new surface has been created
self.assertTrue(new_surf, msg="failed to create new surface")
# retreive properties of the surface location
surf = self.surface_location_algorithm.get_surface()
# validate properties
self.assertAlmostEqual(surf["time_surf"], expected_data["time_surf"])
self.assertAlmostEqual(surf["x_surf"],
expected_data["x_surf"],
delta=1e-5)
self.assertAlmostEqual(surf["y_surf"],
expected_data["y_surf"],
delta=1e-5)
self.assertAlmostEqual(surf["z_surf"],
expected_data["z_surf"],
delta=1e-5)
self.assertAlmostEqual(surf["lat_surf"],
expected_data["lat_surf"],
delta=1e-12)
self.assertAlmostEqual(surf["lon_surf"],
expected_data["lon_surf"],
delta=1e-12)
self.assertAlmostEqual(surf["alt_surf"],
expected_data["alt_surf"],
delta=1e-4)
def _geometry_corrections_algorithm_tests(self, input_data, expected):
self.initialize_algorithm(input_data)
# create stack of ISPs
isps = []
stack_size = input_data["data_stack_size"]
for stack_index in range(stack_size):
packet = L1AProcessingData(
self.cst, self.chd,
x_vel_sat_sar=input_data["x_vel_sat_sar"][stack_index],
y_vel_sat_sar=input_data["y_vel_sat_sar"][stack_index],
z_vel_sat_sar=input_data["z_vel_sat_sar"][stack_index],
x_sar_sat=input_data["x_sar_sat"][stack_index],
y_sar_sat=input_data["y_sar_sat"][stack_index],
z_sar_sat=input_data["z_sar_sat"][stack_index],
win_delay_sar_ku=input_data["win_delay_sar_ku"][stack_index]
)
isps.append(packet)
# create working surface location
beams_surf = np.reshape(
input_data["beams_surf"],
(stack_size, self.chd.n_samples_sar)
)
working_loc = SurfaceData(
self.cst, self.chd,
stack_bursts=isps,
data_stack_size=stack_size,
win_delay_surf=input_data["win_delay_surf"],
x_surf=input_data["x_surf"],
y_surf=input_data["y_surf"],
z_surf=input_data["z_surf"],
beam_angles_surf=input_data["beam_angles_surf"],
t0_surf=input_data["T0_surf"],
beams_surf=beams_surf
)
# TODO: add window delay alignment method selection
self.geometry_corrections_algorithm(working_loc, input_data["wv_length_ku"])
self.assertTrue(
np.allclose(
self.geometry_corrections_algorithm.doppler_corrections,
expected["doppler_corrections"]
),
msg="Doppler corrections do not match"
)
self.assertTrue(
np.allclose(
self.geometry_corrections_algorithm.range_sat_surf,
expected["range_sat_surf"]
),
msg="Range Sat Surf does not match"
)
self.assertTrue(
np.allclose(
self.geometry_corrections_algorithm.slant_range_corrections,
expected["slant_range_corrections"], atol=1e-8
),
msg="Slant Range Corrections do not match"
)
self.assertTrue(
np.allclose(
self.geometry_corrections_algorithm.win_delay_corrections,
expected["win_delay_corrections"]
),
msg="window delay corrections do not match"
)
flat_corr = np.ravel(self.geometry_corrections_algorithm.beams_geo_corr)
components = zip(np.real(flat_corr), np.imag(flat_corr))
for index, (i, q) in enumerate(components):
expected_i = expected["beams_geo_corr_i"][index]
expected_q = expected["beams_geo_corr_q"][index]
if expected_i == 0:
self.assertEqual(
expected_i, i
)
else:
rel_err = abs((expected_i - i) / expected_i)
self.assertLess(rel_err, 2e-4)
if expected_q == 0:
self.assertEqual(
expected_q, q
)
else:
rel_err = abs((expected_q - q) / expected_q)
self.assertLess(rel_err, 2e-4)
