def test_from_repetition_count(self):
dwf = DummyWaveform()
self.assertEqual(RepetitionWaveform(dwf, 3), RepetitionWaveform.from_repetition_count(dwf, 3))
cwf = ConstantWaveform(duration=3, amplitude=2.2, channel='A')
with mock.patch.object(ConstantWaveform, 'from_mapping', return_value=mock.sentinel) as from_mapping:
self.assertIs(from_mapping.return_value, RepetitionWaveform.from_repetition_count(cwf, 5))
from_mapping.assert_called_once_with(15, {'A': 2.2})
def test_float_sample_time(self):
# issue 624
body_wf = FunctionWaveform.from_expression(ExpressionScalar('sin(t)'), 1./3., channel='a')
rwf = RepetitionWaveform(body_wf, 2)
sample_times = np.arange(160) / 80. / 3.
sampled = rwf.unsafe_sample(sample_times=sample_times, channel='a')
inner_sample_times = np.concatenate((sample_times[:80], sample_times[80:] - 1./3.))
np.testing.assert_equal(sampled, np.sin(inner_sample_times))
def test_init(self):
body_wf = DummyWaveform()
with self.assertRaises(ValueError):
RepetitionWaveform(body_wf, -1)
with self.assertRaises(ValueError):
RepetitionWaveform(body_wf, 1.1)
wf = RepetitionWaveform(body_wf, 3)
self.assertIs(wf._body, body_wf)
self.assertEqual(wf._repetition_count, 3)
def test_unsafe_sample(self):
body_wf = DummyWaveform(duration=7)
rwf = RepetitionWaveform(body=body_wf, repetition_count=10)
sample_times = np.arange(80) * 70./80.
inner_sample_times = (sample_times.reshape((10, -1)) - (7 * np.arange(10))[:, np.newaxis]).ravel()
result = rwf.unsafe_sample(channel='A', sample_times=sample_times)
np.testing.assert_equal(result, inner_sample_times)
output_expected = np.empty_like(sample_times)
output_received = rwf.unsafe_sample(channel='A', sample_times=sample_times, output_array=output_expected)
self.assertIs(output_expected, output_received)
np.testing.assert_equal(output_received, inner_sample_times)
def to_waveform(program: Loop) -> Waveform:
if program.is_leaf():
if program.repetition_count == 1:
return program.waveform
else:
return RepetitionWaveform(program.waveform, program.repetition_count)
else:
if len(program) == 1:
sequenced_waveform = to_waveform(cast(Loop, program[0]))
else:
sequenced_waveform = SequenceWaveform([to_waveform(cast(Loop, sub_program))
for sub_program in program])
if program.repetition_count > 1:
return RepetitionWaveform(sequenced_waveform, program.repetition_count)
else:
return sequenced_waveform
def test_unsafe_get_subset_for_channels(self):
body_wf = DummyWaveform(defined_channels={'a', 'b'})
chs = {'a'}
subset = RepetitionWaveform(body_wf, 3).get_subset_for_channels(chs)
self.assertIsInstance(subset, RepetitionWaveform)
self.assertIsInstance(subset._body, DummyWaveform)
self.assertIs(subset._body.defined_channels, chs)
self.assertEqual(subset._repetition_count, 3)
def test_compare_key(self):
body_wf = DummyWaveform(defined_channels={'a'})
wf = RepetitionWaveform(body_wf, 2)
self.assertEqual(wf.compare_key, (body_wf.compare_key, 2))
def test_defined_channels(self):
body_wf = DummyWaveform(defined_channels={'a'})
self.assertIs(
RepetitionWaveform(body_wf, 2).defined_channels,
body_wf.defined_channels)
def test_duration(self):
wf = RepetitionWaveform(DummyWaveform(duration=2.2), 3)
self.assertEqual(wf.duration, TimeType.from_float(2.2) * 3)
def test_repr(self):
body_wf = ConstantWaveform(amplitude=1.1, duration=1.3, channel='3')
wf = RepetitionWaveform(body_wf, 3)
r = repr(wf)
self.assertEqual(wf, eval(r))
