def test_cal1_algorithm_01(self) -> None: """ CAL1 algorithm test #01 ----------------------- """ expected = TestDataLoader(self.expected_01, delim=' ') input_data = TestDataLoader(self.inputs_01, delim=' ') self.initialise_algorithm(input_data) waveform_shape = (self.chd.n_ku_pulses_burst, self.chd.n_samples_sar) wfm_i = np.reshape(input_data["wfm_cal_gain_uncorrected_i"], waveform_shape) wfm_q = np.reshape(input_data["wfm_cal_gain_uncorrected_q"], waveform_shape) waveform_input = wfm_i + 1j*wfm_q burst = L1AProcessingData( self.cst, self.chd, cal1_power=input_data['burst_power_cor_ku_l1a_echo_sar_ku'], cal1_phase=input_data['burst_phase_cor_ku_l1a_echo_sar_ku'], sig0_cal_ku=input_data['sig0_cal_ku_l1a_echo_sar_ku'], agc_ku=input_data['agc_ku_l1a_echo_sar_ku'], waveform_cor_sar=waveform_input ) self.cal1_algorithm(burst) wfm_i = np.reshape(expected["wfm_gain_cal1_corrected_i"], waveform_shape) wfm_q = np.reshape(expected["wfm_gain_cal1_corrected_q"], waveform_shape) waveform_expected = wfm_i + 1j*wfm_q self.assertTrue( np.allclose(np.real(burst.waveform_cor_sar), np.real(waveform_expected)) ) self.assertTrue( np.allclose(np.imag(burst.waveform_cor_sar), np.imag(waveform_expected)) )
def __call__(self, burst: L1AProcessingData) -> None: if self.cnf.flag_cal2_correction: pulses = np.ones((self.chd.n_ku_pulses_burst, 1)) correction = burst.cal2_array[np.newaxis, :] * pulses wfm_fft = fftshift(fft(burst.waveform_cor_sar, self.chd.n_samples_sar, 1), 1) burst.waveform_cor_sar = ifft(ifftshift(wfm_fft / np.sqrt(correction), 1), self.chd.n_samples_sar, 1)
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_sigma0_algorithm_01(self): input_data = TestDataLoader(self.inputs_01, delim=' ') expected = TestDataLoader(self.expected_01, delim=' ') self.initialise_algorithm(input_data) data_stack_size = input_data['data_stack_size'] isps = [] x_vel = input_data['x_vel_sat_sar'] y_vel = input_data['y_vel_sat_sar'] z_vel = input_data['z_vel_sat_sar'] pri_sar = input_data['pri_sar_pre_dat'] for stack_index in range(data_stack_size): packet = L1AProcessingData(self.cst, self.chd, x_vel_sat_sar=x_vel[stack_index], y_vel_sat_sar=y_vel[stack_index], z_vel_sat_sar=z_vel[stack_index], pri_sar_pre_dat=pri_sar[stack_index]) isps.append(packet) working_loc = SurfaceData(self.cst, self.chd, data_stack_size=data_stack_size, range_sat_surf=input_data['range_sat_surf'], stack_bursts=np.asarray(isps)) sig0_scale_factor = self.sigma0_algorithm(working_loc, input_data['wv_length_ku'], input_data['chirp_slope_ku']) self.assertAlmostEqual( expected['sigma0_scaling_factor'], sig0_scale_factor, )
def test_beam_angles_algorithm_02(self): """ beam angles algorithm test #02 ----------------------------- """ # load the expected data object expected = TestDataLoader(self.expected_02, delim=' ') # load the input data input_data = TestDataLoader(self.input_02, 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"]) work_loc = input_data["working_surface_location_counter"] # execute beam angles algorithm self.beam_angles_algorithm(surfs, packet, 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 not seen self.assertFalse(self.beam_angles_algorithm.work_location_seen, msg="working location erroneously 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_output(self): # load input and expected data data = TestDataLoader(self._input_data, delim=' ') # create L1BWriter writer = L1BWriter(chd=self.chd, cnf=self.cnf, cst=self.cst, filename=self._output_fname) writer.open() # write outputs for i in range(data["count"]): burst = L1AProcessingData( cst=self.cst, chd=self.chd, seq_num=i, isp_coarse_time=data["isp_coarse_time"][i], isp_fine_time=data["isp_fine_time"][i], sral_fine_time=data["sral_fine_time"][i], flag_time_status=data["flag_time_status"][i], nav_bul_status=data["nav_bul_status"][i], nav_bul_source=data["nav_bul_source"][i], source_seq_count=data["source_seq_count"][i], oper_instr=data["oper_instr"][i], SAR_mode=data["SAR_mode"][i], cl_gain=data["cl_gain"][i], acq_stat=data["acq_stat"][i], dem_eeprom=data["dem_eeprom"][i], loss_track=data["loss_track"][i], h0_nav_dem=data["h0_nav_dem"][i], h0_applied=data["h0_applied"][i], cor2_nav_dem=data["cor2_nav_dem"][i], cor2_applied=data["cor2_applied"][i], dh0=data["dh0"][i], agccode_ku=data["agccode_ku"][i], int_path_cor_ku=data["int_path_cor_ku"][i], agc_ku=data["agc_ku"][i], sig0_cal_ku=data["sig0_cal_ku"][i], surf_type=data["surface_type"][i], uso_cor=data["uso_cor"][i]) surf = SurfaceData( chd=self.chd, cst=self.cst, time_surf=data["time_surf"][i], prev_tai=0, prev_utc_secs=0, prev_utc_days=0, curr_day_length=60 * 60 * 24, gps_time_surf=data["gps_time_surf"][i], lat_surf=data["lat_surf"][i], lon_surf=data["lon_surf"][i], alt_sat=data["alt_sat"][i], alt_rate_sat=data["alt_rate_sat"][i], x_sat=data["x_sat"][i], y_sat=data["y_sat"][i], z_sat=data["z_sat"][i], x_vel_sat=data["x_vel_sat"][i], y_vel_sat=data["y_vel_sat"][i], z_vel_sat=data["z_vel_sat"][i], sigma0_scaling_factor=data["sigma0_scaling_factor"][i], data_stack_size=data["data_stack_size"][i], stack_std=data["stack_std"][i], stack_skewness=data["stack_skewness"][i], stack_kurtosis=data["stack_kurtosis"][i], look_angles_surf=data["beam_angles_surf"], waveform_multilooked=data["waveform_multilooked"][i] * np.ones( (256)), stack_max=data["stack_max"][i], closest_burst_index=0, stack_bursts=[burst], win_delay_surf=data["win_delay_surf"][i]) writer.write_record(surf) # close writer writer.close() # open output file output = nc.Dataset(self._output_fname) # compare to expected values expected = TestDataLoader(self._expected_data, delim=' ') for i in range(expected["count"]): self.assertAlmostEqual(output.variables["time_l1b_echo_sar_ku"][i], expected["time_l1b_echo_sar_ku"][i]) self.assertAlmostEqual( output.variables["UTC_day_l1b_echo_sar_ku"][i], expected["UTC_day_l1b_echo_sar_ku"][i]) self.assertAlmostEqual( output.variables["UTC_sec_l1b_echo_sar_ku"][i], expected["UTC_sec_l1b_echo_sar_ku"][i]) # 630719981 is the time-delta between GPS & UTC self.assertAlmostEqual( output.variables["GPS_time_l1b_echo_sar_ku"][i], expected["GPS_time_l1b_echo_sar_ku"][i] + 630719981) # these are limited to 6 places because of errors caused # by all the conversions from rads to deg & back again self.assertAlmostEqual(output.variables["lat_l1b_echo_sar_ku"][i], degrees(expected["lat_l1b_echo_sar_ku"][i]), places=6) self.assertAlmostEqual(output.variables["lon_l1b_echo_sar_ku"][i], degrees(expected["lon_l1b_echo_sar_ku"][i]), places=6) self.assertAlmostEqual( output.variables["orb_alt_rate_l1b_echo_sar_ku"][i], expected["orb_alt_rate_l1b_echo_sar_ku"][i]) self.assertAlmostEqual( output.variables["x_pos_l1b_echo_sar_ku"][i], expected["x_pos_l1b_echo_sar_ku"][i]) self.assertAlmostEqual( output.variables["y_pos_l1b_echo_sar_ku"][i], expected["y_pos_l1b_echo_sar_ku"][i]) self.assertAlmostEqual( output.variables["z_pos_l1b_echo_sar_ku"][i], expected["z_pos_l1b_echo_sar_ku"][i]) self.assertAlmostEqual( output.variables["x_vel_l1b_echo_sar_ku"][i], expected["x_vel_l1b_echo_sar_ku"][i]) self.assertAlmostEqual( output.variables["y_vel_l1b_echo_sar_ku"][i], expected["y_vel_l1b_echo_sar_ku"][i]) self.assertAlmostEqual( output.variables["z_vel_l1b_echo_sar_ku"][i], expected["z_vel_l1b_echo_sar_ku"][i]) self.assertAlmostEqual( output.variables["surf_type_l1b_echo_sar_ku"][i], expected["surf_type_l1b_echo_sar_ku"][i]) self.assertAlmostEqual( output.variables["scale_factor_ku_l1b_echo_sar_ku"][i], expected["scale_factor_ku_l1b_echo_sar_ku"][i]) self.assertAlmostEqual( output.variables["nb_stack_l1b_echo_sar_ku"][i], expected["nb_stack_l1b_echo_sar_ku"][i]) self.assertAlmostEqual( output.variables["stdev_stack_l1b_echo_sar_ku"][i], expected["stdev_stack_l1b_echo_sar_ku"][i]) self.assertAlmostEqual( output.variables["skew_stack_l1b_echo_sar_ku"][i], expected["skew_stack_l1b_echo_sar_ku"][i]) self.assertAlmostEqual( output.variables["kurt_stack_l1b_echo_sar_ku"][i], expected["kurt_stack_l1b_echo_sar_ku"][i]) # TODO: multi-dimension arrays # self.assertAlmostEqual( # output.variables["beam_ang_l1b_echo_sar_ku"][i], # expected["beam_ang_l1b_echo_sar_ku"][i] # ) for j in range(256): self.assertAlmostEqual( output.variables["i2q2_meas_ku_l1b_echo_sar_ku"][i, j], expected["i2q2_meas_ku_l1b_echo_sar_ku"][i], places=3)
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_azimuth_processing_algorithm_01(self): """ azimuth processing algorithm test 01 ------------------------------------ tests the azimuth processing algorithm approximate method """ expected = TestDataLoader(self.expected_01, delim=' ') input_data = TestDataLoader(self.inputs_01, delim=' ') self.initialise_algorithm(input_data) # construct complex waveform waveform_shape = (self.chd.n_ku_pulses_burst, self.chd.n_samples_sar) wfm_i = np.reshape(input_data["wfm_cor_sar_i"], waveform_shape) wfm_q = np.reshape(input_data["wfm_cor_sar_q"], waveform_shape) wv_len = input_data["wv_length_ku"] # create input packet packet = L1AProcessingData( self.cst, self.chd, time_sar_ku=input_data["time_sar_ku"], 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"], beam_angles_list=input_data["beam_angles_list"], waveform_cor_sar=wfm_i+1j*wfm_q ) # compute beam angles trend for packet packet.calculate_beam_angles_trend( input_data["beam_angles_list_size_previous_burst"], input_data["beam_angles_trend_previous_burst"] ) # execute azimuth processing algorithm self.azimuth_processing_algorithm(packet, wv_len) beams_focused = self.azimuth_processing_algorithm.beams_focused # construct focused beams waveform wfm_i = np.reshape(expected["beams_focused_i"], waveform_shape) wfm_q = np.reshape(expected["beams_focused_q"], waveform_shape) for pulse_index in range(self.chd.n_ku_pulses_burst): for sample_index in range(self.chd.n_samples_sar): pos = "\nstack: {}/{}, sample: {}/{}".format( pulse_index, self.chd.n_ku_pulses_burst, sample_index, self.chd.n_samples_sar ) expected_val = wfm_i[pulse_index, sample_index] actual_val = beams_focused[pulse_index, sample_index].real if expected_val == 0: self.assertEqual( expected_val, actual_val, msg=pos ) else: rel_err = abs((expected_val - actual_val) / expected_val) self.assertLess(rel_err, 2e-10, msg=pos) expected_val = wfm_q[pulse_index, sample_index] actual_val = beams_focused[pulse_index, sample_index].imag if expected_val == 0: self.assertEqual( expected_val, actual_val, msg=pos ) else: rel_err = abs((expected_val - actual_val) / expected_val) self.assertLess(rel_err, 2e-10, msg=pos)
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_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 __getitem__(self, index: int) -> L1AProcessingData: # convert scale factor to linear value # scale_factor = pow(10, (-self.get_value(L1AVariables.scale_factor_ku_l1a_echo_sar_ku, index) / 20.)) scale_factor = 20 * log10( self.get_value(L1AVariables.scale_factor_ku_l1a_echo_sar_ku, index)) # construct waveform waveform = scale_factor * ( self.get_value(L1AVariables.i_meas_ku_l1a_echo_sar_ku, index) + 1j * self.get_value(L1AVariables.q_meas_ku_l1a_echo_sar_ku, index)) packet = L1AProcessingData( self.cst, self.chd, index, isp_pid=PacketPid.echo_sar, time_sar_ku=self.get_value(L1AVariables.time_l1a_echo_sar_ku, index), isp_coarse_time=self.get_value( L1AVariables.isp_coarse_time_l1a_echo_sar_ku, index), isp_fine_time=self.get_value( L1AVariables.isp_fine_time_l1a_echo_sar_ku, index), sral_fine_time=self.get_value( L1AVariables.sral_fine_time_l1a_echo_sar_ku, index), days=self.get_value(L1AVariables.UTC_day_l1a_echo_sar_ku, index), seconds=self.get_value(L1AVariables.UTC_sec_l1a_echo_sar_ku, index), inst_id_sar_isp=0, pri_sar_pre_dat=self.chd.pri_sar, ambiguity_order_sar=0, burst_sar_ku=self.get_value( L1AVariables.burst_count_prod_l1a_echo_sar_ku, index), lat_sar_sat=radians( self.get_value(L1AVariables.lat_l1a_echo_sar_ku, index)), lon_sar_sat=radians( self.get_value(L1AVariables.lon_l1a_echo_sar_ku, index)), alt_sar_sat=self.get_value(L1AVariables.alt_l1a_echo_sar_ku, index), alt_rate_sat_sar=self.get_value( L1AVariables.orb_alt_rate_l1a_echo_sar_ku, index), x_vel_sat_sar=self.get_value(L1AVariables.x_vel_l1a_echo_sar_ku, index), y_vel_sat_sar=self.get_value(L1AVariables.y_vel_l1a_echo_sar_ku, index), z_vel_sat_sar=self.get_value(L1AVariables.z_vel_l1a_echo_sar_ku, index), roll_sar=radians( self.get_value( L1AVariables.roll_sral_mispointing_l1a_echo_sar_ku, index)), pitch_sar=radians( self.get_value( L1AVariables.pitch_sral_mispointing_l1a_echo_sar_ku, index)), yaw_sar=radians( self.get_value( L1AVariables.yaw_sral_mispointing_l1a_echo_sar_ku, index)), h0_sar=self.get_value(L1AVariables.h0_applied_l1a_echo_sar_ku, index), t0_sar=self.chd. t0_nom, # * (1. + 2. * self.uso_cor_l1a_echo_sar_ku[index] / self.cst.c), cor2_sar=self.get_value(L1AVariables.cor2_applied_l1a_echo_sar_ku, index), win_delay_sar_ku=self.get_value( L1AVariables.range_ku_l1a_echo_sar_ku, index) * 2 / self.cst.c, x_sar_sat=self.get_value(L1AVariables.x_pos_l1a_echo_sar_ku, index), y_sar_sat=self.get_value(L1AVariables.y_pos_l1a_echo_sar_ku, index), z_sar_sat=self.get_value(L1AVariables.z_pos_l1a_echo_sar_ku, index), waveform_cor_sar=waveform, beams_focused=None, flag_time_status=self.get_value( L1AVariables.flag_time_status_l1a_echo_sar_ku, index), nav_bul_status=self.get_value( L1AVariables.nav_bul_status_l1a_echo_sar_ku, index), nav_bul_source=self.get_value( L1AVariables.nav_bul_source_l1a_echo_sar_ku, index), source_seq_count=self.get_value( L1AVariables.seq_count_l1a_echo_sar_ku, index), oper_instr=self.get_value(L1AVariables.oper_instr_l1a_echo_sar_ku, index), SAR_mode=self.get_value(L1AVariables.SAR_mode_l1a_echo_sar_ku, index), cl_gain=self.get_value(L1AVariables.cl_gain_l1a_echo_sar_ku, index), acq_stat=self.get_value(L1AVariables.acq_stat_l1a_echo_sar_ku, index), dem_eeprom=self.get_value(L1AVariables.dem_eeprom_l1a_echo_sar_ku, index), loss_track=self.get_value(L1AVariables.loss_track_l1a_echo_sar_ku, index), h0_nav_dem=self.get_value(L1AVariables.h0_nav_dem_l1a_echo_sar_ku, index), h0_applied=self.get_value(L1AVariables.h0_applied_l1a_echo_sar_ku, index), cor2_nav_dem=self.get_value( L1AVariables.cor2_nav_dem_l1a_echo_sar_ku, index), cor2_applied=self.get_value( L1AVariables.cor2_applied_l1a_echo_sar_ku, index), dh0=self.get_value(L1AVariables.dh0_l1a_echo_sar_ku, index), agccode_ku=self.get_value(L1AVariables.agccode_ku_l1a_echo_sar_ku, index), range_ku=self.get_value(L1AVariables.range_ku_l1a_echo_sar_ku, index), int_path_cor_ku=self.get_value( L1AVariables.int_path_cor_ku_l1a_echo_sar_ku, index), agc_ku=self.get_value(L1AVariables.agc_ku_l1a_echo_sar_ku, index), sig0_cal_ku=self.get_value( L1AVariables.sig0_cal_ku_l1a_echo_sar_ku, index)) packet.compute_location_sar_surf() packet.compute_doppler_angle() return packet
def test_output(self): # load input and expected data data = TestDataLoader( self._input_data, delim=' ' ) # create L1BSWriter writer = L1BSWriter( chd=self.chd, cnf=self.cnf, cst=self.cst, filename=self._output_fname ) writer.open() # write outputs # stack_data = np.reshape( # data["beams_range_compr_iq"], (data["count"], 240, 256) # ) a, b = np.meshgrid( np.linspace(-10, 10, 256), np.linspace(-5, 5, 240) ) stack_data = a + 1j * b for i in range(data["count"]): burst = L1AProcessingData( cst=self.cst, chd=self.chd, seq_num=i, ) surf = SurfaceData( chd=self.chd, cst=self.cst, time_surf=data["time_surf"][i], prev_tai=0, prev_utc_secs=0, prev_utc_days=0, curr_day_length=60 * 60 * 24, lat_surf=data["lat_surf"][i], lon_surf=data["lon_surf"][i], surface_type=SurfaceType(data["surface_type"][i] % 3), alt_sat=data["alt_sat"][i], alt_rate_sat=data["alt_rate_sat"][i], x_sat=data["x_sat"][i], y_sat=data["y_sat"][i], z_sat=data["z_sat"][i], x_vel_sat=data["x_vel_sat"][i], y_vel_sat=data["y_vel_sat"][i], z_vel_sat=data["z_vel_sat"][i], x_surf=data["x_surf"][i], y_surf=data["y_surf"][i], z_surf=data["z_surf"][i], roll_sat=data["roll_sat"][i], pitch_sat=data["pitch_sat"][i], yaw_sat=data["yaw_sat"][i], waveform_multilooked=data["waveform_multilooked"][i] * np.ones((256)), stack_std=data["stack_std"][i], stack_skewness=data["stack_skewness"][i], stack_kurtosis=data["stack_kurtosis"][i], beams_range_compr_iq=stack_data * data["beams_range_compr_iq"][i], win_delay_surf=data["win_delay_surf"][i], closest_burst_index=0, stack_bursts=[burst] ) writer.write_record(surf) # close writer writer.close() # open output file output = nc.Dataset(self._output_fname) # compare to expected values expected = TestDataLoader( self._expected_data, delim=' ' ) for i in range(expected["count"]): self.assertAlmostEqual( output.variables["time_l1bs_echo_sar_ku"][i], expected["time_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["UTC_day_l1bs_echo_sar_ku"][i], expected["UTC_day_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["UTC_sec_l1bs_echo_sar_ku"][i], expected["UTC_sec_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["lat_l1bs_echo_sar_ku"][i], degrees(expected["lat_l1bs_echo_sar_ku"][i]), places=6 ) self.assertAlmostEqual( output.variables["lon_l1bs_echo_sar_ku"][i], degrees(expected["lon_l1bs_echo_sar_ku"][i]), places=6 ) self.assertAlmostEqual( output.variables["surf_type_l1bs_echo_sar_ku"][i], expected["surf_type_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["orb_alt_rate_l1bs_echo_sar_ku"][i], expected["orb_alt_rate_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["x_pos_l1bs_echo_sar_ku"][i], expected["x_pos_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["y_pos_l1bs_echo_sar_ku"][i], expected["y_pos_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["z_pos_l1bs_echo_sar_ku"][i], expected["z_pos_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["x_vel_l1bs_echo_sar_ku"][i], expected["x_vel_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["y_vel_l1bs_echo_sar_ku"][i], expected["y_vel_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["z_vel_l1bs_echo_sar_ku"][i], expected["z_vel_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["meas_x_pos_l1bs_echo_sar_ku"][i], expected["meas_x_pos_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["meas_y_pos_l1bs_echo_sar_ku"][i], expected["meas_y_pos_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["meas_z_pos_l1bs_echo_sar_ku"][i], expected["meas_z_pos_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["stdev_stack_l1bs_echo_sar_ku"][i], expected["stdev_stack_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["skew_stack_l1bs_echo_sar_ku"][i], expected["skew_stack_l1bs_echo_sar_ku"][i] ) self.assertAlmostEqual( output.variables["kurt_stack_l1bs_echo_sar_ku"][i], expected["kurt_stack_l1bs_echo_sar_ku"][i] ) for j in range(256): self.assertAlmostEqual( output.variables["i2q2_meas_ku_l1bs_echo_sar_ku"][i, j], expected["i2q2_meas_ku_l1bs_echo_sar_ku"][i] ) for k in range(240): self.assertAlmostEqual( output.variables["i_echoes_ku_l1bs_echo_sar_ku"][i, j, k], expected["i_echoes_ku_l1bs_echo_sar_ku"][i] * stack_data[k, j].real ) self.assertAlmostEqual( output.variables["q_echoes_ku_l1bs_echo_sar_ku"][i, j, k], expected["q_echoes_ku_l1bs_echo_sar_ku"][i] * stack_data[j, k].imag )
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)
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"])