def test_unsafe_sample(self) -> None:
sample_times = numpy.linspace(98.5, 103.5, num=11)
samples_a = numpy.linspace(4, 5, 11)
samples_b = numpy.linspace(2, 3, 11)
dwf_a = DummyWaveform(duration=3.2, sample_output=samples_a, defined_channels={'A'})
dwf_b = DummyWaveform(duration=3.2, sample_output=samples_b, defined_channels={'B', 'C'})
waveform = MultiChannelWaveform((dwf_a, dwf_b))
result_a = waveform.unsafe_sample('A', sample_times)
numpy.testing.assert_equal(result_a, samples_a)
result_b = waveform.unsafe_sample('B', sample_times)
numpy.testing.assert_equal(result_b, samples_b)
self.assertEqual(len(dwf_a.sample_calls), 1)
self.assertEqual(len(dwf_b.sample_calls), 1)
numpy.testing.assert_equal(sample_times, dwf_a.sample_calls[0][1])
numpy.testing.assert_equal(sample_times, dwf_b.sample_calls[0][1])
self.assertEqual('A', dwf_a.sample_calls[0][0])
self.assertEqual('B', dwf_b.sample_calls[0][0])
self.assertIs(dwf_a.sample_calls[0][2], None)
self.assertIs(dwf_b.sample_calls[0][2], None)
reuse_output = numpy.empty_like(samples_a)
result_a = waveform.unsafe_sample('A', sample_times, reuse_output)
self.assertEqual(len(dwf_a.sample_calls), 2)
self.assertIs(result_a, reuse_output)
self.assertIs(result_a, dwf_a.sample_calls[1][2])
numpy.testing.assert_equal(result_b, samples_b)
def test_const_propagation(self):
lhs = MultiChannelWaveform([
DummyWaveform(duration=1.5, defined_channels={'a', 'c', 'd', 'i'}),
ConstantWaveform.from_mapping(1.5, {'e': 1.2, 'f': 1.3, 'h': 4.6})
])
rhs = MultiChannelWaveform([
DummyWaveform(duration=1.5, defined_channels={'a', 'b', 'e'}),
ConstantWaveform.from_mapping(1.5, {'f': 2.5, 'g': 3.5, 'i': 6.4})
])
wf = ArithmeticWaveform(lhs, '-', rhs)
assert_constant_consistent(self, wf)
expected = {'a': None,
'b': None,
'c': None,
'd': None,
'e': None,
'f': 1.3-2.5,
'g': -3.5,
'h': 4.6,
'i': None}
actual = {ch: wf.constant_value(ch) for ch in wf.defined_channels}
self.assertEqual(expected, actual)
def test_equality(self) -> None:
dwf_a = DummyWaveform(duration=246.2, defined_channels={'A'})
dwf_b = DummyWaveform(duration=246.2, defined_channels={'B'})
dwf_c = DummyWaveform(duration=246.2, defined_channels={'C'})
waveform_a1 = MultiChannelWaveform([dwf_a, dwf_b])
waveform_a2 = MultiChannelWaveform([dwf_a, dwf_b])
waveform_a3 = MultiChannelWaveform([dwf_a, dwf_c])
self.assertEqual(waveform_a1, waveform_a1)
self.assertEqual(waveform_a1, waveform_a2)
self.assertNotEqual(waveform_a1, waveform_a3)
def test_from_parallel(self):
dwf_a = DummyWaveform(duration=2.2, defined_channels={'A'})
dwf_b = DummyWaveform(duration=2.2, defined_channels={'B'})
dwf_c = DummyWaveform(duration=2.2, defined_channels={'C'})
self.assertIs(dwf_a, MultiChannelWaveform.from_parallel([dwf_a]))
wf_ab = MultiChannelWaveform.from_parallel([dwf_a, dwf_b])
self.assertEqual(wf_ab, MultiChannelWaveform([dwf_a, dwf_b]))
wf_abc = MultiChannelWaveform.from_parallel([wf_ab, dwf_c])
self.assertEqual(wf_abc, MultiChannelWaveform([dwf_a, dwf_b, dwf_c]))
def build_waveform(
self, parameters: Dict[str, numbers.Real],
channel_mapping: Dict[ChannelID, Optional[ChannelID]]
) -> Optional[Waveform]:
self.validate_parameter_constraints(parameters=parameters)
sub_waveforms = []
for subtemplate in self.subtemplates:
sub_waveform = subtemplate.build_waveform(
parameters, channel_mapping=channel_mapping)
if sub_waveform is not None:
sub_waveforms.append(sub_waveform)
if len(sub_waveforms) == 0:
return None
if len(sub_waveforms) == 1:
waveform = sub_waveforms[0]
else:
waveform = MultiChannelWaveform(sub_waveforms)
if self._duration:
expected_duration = self._duration.evaluate_numeric(**parameters)
if not isclose(expected_duration, waveform.duration):
raise ValueError(
'The duration does not '
'equal the expected duration', expected_duration,
waveform.duration)
return waveform
def test_from_mapping(self):
from_single = ConstantWaveform.from_mapping(1., {'A': 2.})
expected_single = ConstantWaveform(duration=1., amplitude=2., channel='A')
self.assertEqual(expected_single, from_single)
from_multi = ConstantWaveform.from_mapping(1., {'A': 2., 'B': 3.})
expected_from_multi = MultiChannelWaveform([ConstantWaveform(duration=1., amplitude=2., channel='A'),
ConstantWaveform(duration=1., amplitude=3., channel='B')])
self.assertEqual(expected_from_multi, from_multi)
def test_constant_default_impl(self):
wf_non_const_a = DummyWaveform(defined_channels={'A'}, duration=3)
wf_non_const_b = DummyWaveform(defined_channels={'B'}, duration=3)
wf_const_c = ConstantWaveform(channel='C', amplitude=2.2, duration=3)
wf_const_d = ConstantWaveform(channel='D', amplitude=3.3, duration=3)
wf_const = MultiChannelWaveform.from_parallel((wf_const_c, wf_const_d))
wf_non_const = MultiChannelWaveform.from_parallel((wf_non_const_b, wf_non_const_a))
wf_mixed = MultiChannelWaveform.from_parallel((wf_non_const_a, wf_const_c))
assert_constant_consistent(self, wf_const)
assert_constant_consistent(self, wf_non_const)
assert_constant_consistent(self, wf_mixed)
self.assertEqual(wf_const.constant_value_dict(), {'C': 2.2, 'D': 3.3})
self.assertIsNone(wf_non_const.constant_value_dict())
self.assertIsNone(wf_mixed.constant_value_dict())
self.assertEqual(wf_mixed.constant_value('C'), 2.2)
def test_init_several_channels(self) -> None:
dwf_a = DummyWaveform(duration=2.2, defined_channels={'A'})
dwf_b = DummyWaveform(duration=2.2, defined_channels={'B'})
dwf_c = DummyWaveform(duration=2.3, defined_channels={'C'})
waveform = MultiChannelWaveform([dwf_a, dwf_b])
self.assertEqual({'A', 'B'}, waveform.defined_channels)
self.assertEqual(TimeType.from_float(2.2), waveform.duration)
with self.assertRaises(ValueError):
MultiChannelWaveform([dwf_a, dwf_c])
with self.assertRaises(ValueError):
MultiChannelWaveform([waveform, dwf_c])
with self.assertRaises(ValueError):
MultiChannelWaveform((dwf_a, dwf_a))
dwf_c_valid = DummyWaveform(duration=2.2, defined_channels={'C'})
waveform_flat = MultiChannelWaveform((waveform, dwf_c_valid))
self.assertEqual(len(waveform_flat.compare_key), 3)
def test_get_item(self):
dwf_a = DummyWaveform(duration=2.2, defined_channels={'A'})
dwf_b = DummyWaveform(duration=2.2, defined_channels={'B'})
dwf_c = DummyWaveform(duration=2.2, defined_channels={'C'})
wf = MultiChannelWaveform([dwf_a, dwf_b, dwf_c])
self.assertIs(wf['A'], dwf_a)
self.assertIs(wf['B'], dwf_b)
self.assertIs(wf['C'], dwf_c)
with self.assertRaises(KeyError):
wf['D']
def test_unsafe_get_subset_for_channels(self):
dwf_a = DummyWaveform(duration=246.2, defined_channels={'A'})
dwf_b = DummyWaveform(duration=246.2, defined_channels={'B'})
dwf_c = DummyWaveform(duration=246.2, defined_channels={'C'})
mcwf = MultiChannelWaveform((dwf_a, dwf_b, dwf_c))
with self.assertRaises(KeyError):
mcwf.unsafe_get_subset_for_channels({'D'})
with self.assertRaises(KeyError):
mcwf.unsafe_get_subset_for_channels({'A', 'D'})
self.assertIs(mcwf.unsafe_get_subset_for_channels({'A'}), dwf_a)
self.assertIs(mcwf.unsafe_get_subset_for_channels({'B'}), dwf_b)
self.assertIs(mcwf.unsafe_get_subset_for_channels({'C'}), dwf_c)
sub_ab = mcwf.unsafe_get_subset_for_channels({'A', 'B'})
self.assertEqual(sub_ab.defined_channels, {'A', 'B'})
self.assertIsInstance(sub_ab, MultiChannelWaveform)
self.assertIs(sub_ab.unsafe_get_subset_for_channels({'A'}), dwf_a)
self.assertIs(sub_ab.unsafe_get_subset_for_channels({'B'}), dwf_b)
def test_init_single_channel(self) -> None:
dwf = DummyWaveform(duration=1.3, defined_channels={'A'})
waveform = MultiChannelWaveform([dwf])
self.assertEqual({'A'}, waveform.defined_channels)
self.assertEqual(TimeType.from_float(1.3), waveform.duration)
def test_init_no_args(self) -> None:
with self.assertRaises(ValueError):
MultiChannelWaveform(dict())
with self.assertRaises(ValueError):
MultiChannelWaveform(None)
def test_const_value(self):
mixed_wf = MultiChannelWaveform([DummyWaveform(1.5, defined_channels={'A'}),
ConstantWaveform(1.5, 1.1, 'B')])
wf = FunctorWaveform(mixed_wf, {'A': np.negative, 'B': np.negative})
self.assertIsNone(wf.constant_value('A'))
self.assertEqual(-1.1, wf.constant_value('B'))
