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