class SurfaceLocationAlgorithmTests(unittest.TestCase): expected_01 = "test_data/proc/surface_location_algorithm/surface_location_algorithm_01/expected/"\ "Hr_Algorithms.Surface_Location_Algorithm_Processing_01.Expected_01.txt" input_01 = "test_data/proc/surface_location_algorithm/surface_location_algorithm_01/input/"\ "inputs.txt" expected_02 = "test_data/proc/surface_location_algorithm/surface_location_algorithm_02/expected/" \ "Hr_Algorithms.Surface_Location_Algorithm_Processing_02.Expected_01.txt" input_02 = "test_data/proc/surface_location_algorithm/surface_location_algorithm_02/input/" \ "inputs.txt" expected_03 = "test_data/proc/surface_location_algorithm/surface_location_algorithm_03/expected/" \ "Hr_Algorithms.Surface_Location_Algorithm_Processing_03.Expected_01.txt" input_03 = "test_data/proc/surface_location_algorithm/surface_location_algorithm_03/input/" \ "inputs.txt" def initialise_algorithm(self, input_data): self.cnf = ConfigurationFile() self.cst = ConstantsFile( c_cst=input_data['c_cst'], pi_cst=input_data['pi_cst'], semi_major_axis_cst=input_data['semi_major_axis_cst'], flat_coeff_cst=input_data['flat_coeff_cst'], semi_minor_axis_cst=input_data['semi_minor_axis_cst'], sec_in_day_cst=60*60*24 ) self.chd = CharacterisationFile( self.cst, freq_ku_chd=input_data['freq_ku_chd'], N_ku_pulses_burst_chd=input_data['n_ku_pulses_burst_chd'], pri_sar_pre_dat=input_data['pri_sar_pre_dat'] ) self.surface_location_algorithm = SurfaceLocationAlgorithm(self.chd, self.cst, self.cnf) def test_surface_location_algorithm_01(self): """ surface location algorithm test 01 ---------------------------------- loads an input packet and passes it as an initial item to the surface location algorithm. expected result is for the algorithm to create an initial surface location. Values of this location are validated. """ # load expected data expected_data = TestDataLoader(self.expected_01, delim=' ') # load input data packet = TestDataLoader(self.input_01, delim=' ') self.initialise_algorithm(packet) # create packet object isps = [ L1AProcessingData( self.cst, self.chd, time_sar_ku=packet["time_sar_ku"], lat_sar_sat=packet["lat_sar_sat"], lon_sar_sat=packet["lon_sar_sat"], alt_sar_sat=packet["alt_sar_sat"], win_delay_sar_ku=packet["win_delay_sar_ku"], 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=packet["time_sar_ku"] // self.cst.sec_in_day, seconds=packet["time_sar_ku"] % self.cst.sec_in_day ) ] # execute surface location algorithm new_surf = self.surface_location_algorithm([], isps) # confirm new surface is created self.assertTrue(new_surf, msg="failed to create new surface") # retreive & validate surface properties surf = self.surface_location_algorithm.get_surface() self.assertAlmostEqual(surf["time_surf"], expected_data["time_surf"]) self.assertAlmostEqual(surf["x_surf"], expected_data["x_surf"]) self.assertAlmostEqual(surf["y_surf"], expected_data["y_surf"]) self.assertAlmostEqual(surf["z_surf"], expected_data["z_surf"]) self.assertAlmostEqual(surf["lat_surf"], expected_data["lat_surf"]) self.assertAlmostEqual(surf["lon_surf"], expected_data["lon_surf"]) self.assertAlmostEqual(surf["alt_surf"], expected_data["alt_surf"]) def test_surface_location_algorithm_02(self): """ surface location algorithm test 02 ---------------------------------- loads multiple input ISPs and one input surface location. expected result is for the surface location algorithm to determine that a new surface location should not yet be calculated """ # load input data inputs = TestDataLoader(self.input_02, delim=' ') self.initialise_algorithm(inputs) # generate 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]) \ for i, time in enumerate(inputs["time_sar_ku"]) ] for packet in isps: packet.compute_location_sar_surf() # create 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"] ) surf.compute_surf_sat_vector() surf.compute_angular_azimuth_beam_resolution( inputs["pri_sar_pre_dat"] ) # execute surface location algorithm new_surf = self.surface_location_algorithm([surf], isps) # confirm that no new surface is generated self.assertFalse(new_surf, msg="erroneously created new surface") 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)
class SurfaceLocationAlgorithmTests(unittest.TestCase): _root = os.path.join(os.path.dirname(__file__), '..', '..') _folder = os.path.join(_root, "test_data", "proc", "surface_location_algorithm") inputs_01 = os.path.join(_folder, "surface_location_algorithm_01", "input", "inputs.txt") expected_01 = os.path.join(_folder, "surface_location_algorithm_01", "expected", "Hr_Algorithms.Surface_Location_Algorithm_Processing_01.Expected_01.txt") inputs_02 = os.path.join(_folder, "surface_location_algorithm_02", "input", "inputs.txt") expected_02 = os.path.join(_folder, "surface_location_algorithm_02", "expected", "Hr_Algorithms.Surface_Location_Algorithm_Processing_02.Expected_01.txt") inputs_03 = os.path.join(_folder, "surface_location_algorithm_03", "input", "inputs.txt") expected_03 = os.path.join(_folder, "surface_location_algorithm_03", "expected", "Hr_Algorithms.Surface_Location_Algorithm_Processing_03.Expected_01.txt") inputs_04 = os.path.join(_folder, "surface_location_algorithm_04", "input", "inputs.txt") expected_04 = os.path.join(_folder, "surface_location_algorithm_04", "expected", "Hr_Algorithms.Surface_Location_Algorithm_Processing_04.Expected_01.txt") def initialise_algorithm(self, input_data: TestDataLoader): self.cnf = ConfigurationFile( flag_surface_focusing_cnf=input_data["flag_surface_focusing_cnf"], surface_focusing_lat_cnf=input_data.get("surface_focusing_lat_cnf"), surface_focusing_lon_cnf=input_data.get("surface_focusing_lon_cnf"), surface_focusing_alt_cnf=input_data.get("surface_focusing_alt_cnf") ) self.cst = ConstantsFile( c_cst=input_data['c_cst'], pi_cst=input_data['pi_cst'], semi_major_axis_cst=input_data['semi_major_axis_cst'], flat_coeff_cst=input_data['flat_coeff_cst'], semi_minor_axis_cst=input_data['semi_minor_axis_cst'], sec_in_day_cst=60*60*24 ) self.chd = CharacterisationFile( self.cst, freq_ku_chd=input_data['freq_ku_chd'], N_ku_pulses_burst_chd=input_data['n_ku_pulses_burst_chd'], pri_sar_pre_dat=input_data['pri_sar_pre_dat'] ) self.surface_location_algorithm = SurfaceLocationAlgorithm(self.chd, self.cst, self.cnf) def test_surface_location_algorithm_01(self): """ surface location algorithm test 01 ---------------------------------- loads an input packet and passes it as an initial item to the surface location algorithm. expected result is for the algorithm to create an initial surface location. Values of this location are validated. """ # load expected data expected_data = TestDataLoader(self.expected_01, delim=' ') # load input data packet = TestDataLoader(self.inputs_01, delim=' ') self.initialise_algorithm(packet) # create packet object isps = [ L1AProcessingData( self.cst, self.chd, time_sar_ku=packet["time_sar_ku"], lat_sar_sat=packet["lat_sar_sat"], lon_sar_sat=packet["lon_sar_sat"], alt_sar_sat=packet["alt_sar_sat"], win_delay_sar_ku=packet["win_delay_sar_ku"], 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=packet["time_sar_ku"] // self.cst.sec_in_day, seconds=packet["time_sar_ku"] % self.cst.sec_in_day ) ] # execute surface location algorithm new_surf = self.surface_location_algorithm([], isps) # confirm new surface is created self.assertTrue(new_surf, msg="failed to create new surface") # retreive & validate surface properties surf = self.surface_location_algorithm.get_surface() self.assertAlmostEqual(surf["time_surf"], expected_data["time_surf"]) self.assertAlmostEqual(surf["x_surf"], expected_data["x_surf"]) self.assertAlmostEqual(surf["y_surf"], expected_data["y_surf"]) self.assertAlmostEqual(surf["z_surf"], expected_data["z_surf"]) self.assertAlmostEqual(surf["lat_surf"], expected_data["lat_surf"]) self.assertAlmostEqual(surf["lon_surf"], expected_data["lon_surf"]) self.assertAlmostEqual(surf["alt_surf"], expected_data["alt_surf"]) def test_surface_location_algorithm_02(self): """ surface location algorithm test 02 ---------------------------------- loads multiple input ISPs and one input surface location. expected result is for the surface location algorithm to determine that a new surface location should not yet be calculated """ # load input data inputs = TestDataLoader(self.inputs_02, delim=' ') self.initialise_algorithm(inputs) # generate 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]) \ for i, time in enumerate(inputs["time_sar_ku"]) ] for packet in isps: packet.compute_location_sar_surf() # create 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"] ) surf.compute_surf_sat_vector() surf.compute_angular_azimuth_beam_resolution( inputs["pri_sar_pre_dat"] ) # execute surface location algorithm new_surf = self.surface_location_algorithm([surf], isps) # confirm that no new surface is generated self.assertFalse(new_surf, msg="erroneously created new surface") 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.inputs_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 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"])