def test_read_real_file(self): with iisr_io.open_data_file(TEST_REAL_FILEPATH) as data_file: series_list = list(data_file) self.assertEqual(len(series_list), 100) first_series = series_list[0] # type: iisr_io.TimeSeries self.assertEqual(first_series.time_mark.year, 2015) self.assertEqual(first_series.time_mark.month, 6) self.assertEqual(first_series.time_mark.day, 6) unique_freqs = set() unique_len = set() unique_channels = set() for series in series_list: unique_freqs.add(series.parameters.frequency) unique_len.add(series.parameters.pulse_length) unique_channels.add(series.parameters.channel) for freq in [155.5, 155.8, 159.5, 159.8]: freq = Frequency(freq, 'MHz') self.assertIn(freq, unique_freqs) for len_ in [0, 200, 700, 900]: len_ = TimeUnit(len_, 'us') self.assertIn(len_, unique_len) for ch in [0, 1, 2, 3]: ch = Channel(ch) self.assertIn(ch, unique_channels)
def _prep_spectra_constants(self): n_spectra = self.n_spectra n_samples = self.active_parameters.n_samples dist = self.active_parameters.distance dist_mask = (dist['km'] > self.spectra_start_dist) & (dist['km'] < self.spectra_stop_dist) first_idx, last_idx = np.where(dist_mask)[0][[0, -1]] last_idx = min(last_idx, n_samples - self.n_fft) if n_spectra > 1: idx_step = (last_idx - first_idx) / (n_spectra - 1) sp_indexes = [int(first_idx + idx_step * i) for i in range(n_spectra)] else: sp_indexes = [first_idx] self.spectra_offset = TimeUnit(self.active_parameters.delays['us'][sp_indexes], 'us') # Create spectra slices with length equal to pulse length dt_us = 1 / self.active_parameters.sampling_frequency['MHz'] pulse_length_points = int(np.floor(self.active_parameters.pulse_length['us'] / dt_us)) for i in range(len(sp_indexes)): sp_indexes[i] = list(np.arange(sp_indexes[i], sp_indexes[i] + pulse_length_points)) self.sp_indexes = sp_indexes # Calculate mask that defines output frequencies if pulse_length_points >= self.n_fft: self.sp_center_mask = np.ones(pulse_length_points, dtype=bool) else: center = (self.n_fft + 1) // 2 left = center - (self.spectra_size - 1) // 2 right = center + self.spectra_size // 2 + 1 self.sp_center_mask = np.zeros(self.n_fft, dtype=bool) self.sp_center_mask[left:right] = True
def test_calc_delays(self): sampling_freq = Frequency(1, 'MHz') n_samples = 4096 total_delay = TimeUnit(1e-3, 's') test_delays = np.linspace(1e-3, 1e-3 + 4095 * 1e-6, 4096) delays = calc_delays(sampling_freq, total_delay, n_samples) np.testing.assert_almost_equal(test_delays, delays['s'])
def calc_delays(sampling_frequency: Frequency, total_delay: TimeUnit, n_samples: int) -> TimeUnit: """Calculate delays between transmission and reception time. Args: sampling_frequency: Sampling frequency. total_delay: Delay between transmission and start of reception. n_samples: Number of registered samples. Returns: delays: Delays. """ # Time between samples, us period = TimeUnit(1 / sampling_frequency['MHz'], 'us') stop_time = n_samples * period['us'] + total_delay['us'] delays = TimeUnit(np.arange(total_delay['us'], stop_time, period['us']), 'us') return delays
def test(self): trivial_filter = iisr_io.SeriesSelector() valid_params = { 'frequencies': [Frequency(155.5, 'MHz'), Frequency(159.5, 'MHz')], 'channels': [Channel(0), Channel(2)], 'pulse_lengths': [TimeUnit(200, 'us'), TimeUnit(700, 'us')], 'pulse_types': None, } specific_filter = iisr_io.SeriesSelector(**valid_params) for fr, ch, len_ in it.product([155500, 159500], [0, 2], [200, 700]): raw_params = get_test_raw_parameters(freq=fr, pulse_len=len_, channel=ch) self.assertTrue(trivial_filter.validate_parameters(raw_params)) self.assertTrue(specific_filter.validate_parameters(raw_params), 'fr={}, ch={}, len_={}'.format(fr, ch, len_)) for fr, ch, len_ in it.product([154000, 159400], [1, 3], [900]): raw_params = get_test_raw_parameters(freq=fr, pulse_len=len_, channel=ch) self.assertTrue(trivial_filter.validate_parameters(raw_params)) self.assertFalse(specific_filter.validate_parameters(raw_params), 'fr={}, ch={}, len_={}'.format(fr, ch, len_)) # Channel and type valid_params = { 'channels': [Channel(0), Channel(1)], 'pulse_types': 'long', } specific_filter = iisr_io.SeriesSelector(**valid_params) for fr, ch, len_ in it.product([155500, 159500], [0, 2], [200, 700]): raw_params = get_test_raw_parameters(freq=fr, pulse_len=len_, channel=ch) self.assertEqual(ch == 0, specific_filter.validate_parameters(raw_params), 'fr={}, ch={}, len_={}'.format(fr, ch, len_))
def get_active_params(n_samples=2048): global_parameters = get_global_params(n_samples=n_samples) params_dict = { 'global_parameters': global_parameters, 'pulse_type': 'short', 'pulse_length': TimeUnit(700, 'us'), 'frequency': Frequency(158, 'MHz'), 'channels': [Channel(1), Channel(3)], 'phase_code': 5, } return params_dict, ActiveParameters(**params_dict)
def get_test_parameters(n_samples=2048, freq=155.5, pulse_len=700, sampling_freq=1., channel=0, phase_code=0, total_delay=1000, antenna_end='st1', file_info=None) -> iisr_io.SeriesParameters: if file_info is None: file_info = get_file_info() global_params = iisr_io.ExperimentParameters( Frequency(sampling_freq, 'MHz'), n_samples, TimeUnit(total_delay, 'us')) test_parameters = iisr_io.SeriesParameters(file_info, global_params, Channel(channel), Frequency(freq, 'MHz'), TimeUnit(pulse_len, 'us'), phase_code, antenna_end=antenna_end) return test_parameters
def test_read_with_selector(self): valid_params = { 'frequencies': [Frequency(155.5, 'MHz')], 'channels': [Channel(0), Channel(2)], 'pulse_lengths': [TimeUnit(200, 'us')], 'pulse_types': ['long'], } filter_ = iisr_io.SeriesSelector(**valid_params) test_parameters = [] for fr, ch, len_ in it.product([155.5, 159.5], [0, 2], [200, 700]): test_parameters.append( get_test_parameters(freq=fr, pulse_len=len_, channel=ch)) with tempfile.TemporaryDirectory() as dirname: test_filepath = Path(dirname) / DUMMY_FILE_NAME with iisr_io.open_data_file(test_filepath, 'w') as data_file: for param in test_parameters: n_samples = param.n_samples test_quad_i = np.random.randint(-2**15 + 1, 2**15, n_samples) test_quad_q = np.random.randint(-2**15 + 1, 2**15, n_samples) test_quadratures = test_quad_i + 1j * test_quad_q series = iisr_io.TimeSeries(DEFAULT_DATETIME, param, test_quadratures) package = iisr_io.TimeSeriesPackage( DEFAULT_DATETIME, [series]) data_file.write(package) # Check if selector correct with iisr_io.open_data_file(test_filepath, series_selector=filter_) as reader: series_list = list(reader) self.assertEqual(len(series_list), 2) for series in series_list: self.assertEqual(series.parameters.frequency, valid_params['frequencies'][0]) self.assertIn(series.parameters.channel, valid_params['channels']) self.assertEqual(series.parameters.pulse_length, valid_params['pulse_lengths'][0]) self.assertEqual(series.parameters.pulse_type, valid_params['pulse_types'][0])
def test_processing(self): global_params = get_global_params() freq = Frequency(155.5, 'MHz') pulse_len = TimeUnit(700, 'us') pulse_type = 'long' channels = [Channel(0), Channel(2)] phase_code = 0 params = ActiveParameters(global_params, channels, pulse_type, frequency=freq, pulse_length=pulse_len, phase_code=phase_code) handler = ActiveHandler(active_parameters=params, eval_power=True, eval_coherence=True) n_series = 4 n_acc = 3 n_samples = global_params.n_samples ref_dt = datetime(2015, 1, 2, 14) time_marks = [] experiment_quadratures = [] for i in range(n_series): time_marks.append( np.array([ ref_dt + timedelta(minutes=m, days=i) for m in range(n_acc) ])) quadratures = {} for ch in channels: quadratures[ch] = \ np.random.randn(n_acc, global_params.n_samples) \ + 1j * np.random.randn(n_acc, global_params.n_samples) experiment_quadratures.append(quadratures) # 2 channels, calculate coherence and power for i in range(n_series): handler.handle( ActiveBatch(time_marks[i], experiment_quadratures[i])) results = handler.finish() self.assertIsInstance(results, ActiveResult) self.assertEqual(results.parameters, params) self.assertEqual(len(results.time_marks), n_series) self.assertIsNotNone(results.power) self.assertEqual(len(results.power), len(channels)) for ch in channels: self.assertIn(ch, results.power) self.assertIsInstance(results.power[ch], np.ndarray) self.assertEqual(results.power[ch].shape, (n_series, n_samples)) self.assertIsNotNone(results.coherence) self.assertIsInstance(results.coherence, np.ndarray) self.assertTrue(np.iscomplexobj(results.coherence)) self.assertEqual(results.coherence.shape, (n_series, n_samples)) # 1 channel, calculate power channels = [Channel(0)] # Create new, single channel quadratures experiment_quadratures = [{ ch: q } for quads in experiment_quadratures for ch, q in quads.items() if ch == channels[0]] params = ActiveParameters(global_params, channels, pulse_type, frequency=freq, pulse_length=pulse_len, phase_code=phase_code) handler = ActiveHandler(params, eval_power=True, eval_coherence=False) for i in range(n_series): handler.handle( ActiveBatch(time_marks[i], experiment_quadratures[i])) results = handler.finish() self.assertIsNone(results.coherence) self.assertIsNotNone(results.power) # 1 channel, calculate coherence raises error handler = ActiveHandler(params, eval_power=True, eval_coherence=True) with self.assertRaises(EvalCoherenceError): handler.handle( ActiveBatch(time_marks[0], experiment_quadratures[0]))
def get_global_params(n_samples=2048, sampling_frequency=Frequency(1, 'MHz'), total_delay=TimeUnit(3000, 'us')): return ExperimentParameters(sampling_frequency, n_samples, total_delay)
def test_calc_distance(self): n = 10000 delays = TimeUnit(np.linspace(1000, 5000, n, endpoint=False), 'ms') test_distances = delays['s'] * 3e8 / 2 distances = delays2distance(delays) np.testing.assert_almost_equal(test_distances, distances['m'])
def parse_time_units(time_units_values_us: str) -> List[TimeUnit]: return [TimeUnit(float(val), 'us') for val in parse_list(time_units_values_us)]