def test_unsafe_sample(self):
dwfs = (DummyWaveform(duration=1.),
DummyWaveform(duration=3.),
DummyWaveform(duration=2.))
swf = SequenceWaveform(dwfs)
sample_times = np.arange(0, 60)*0.1
expected_output = np.concatenate((sample_times[:10], sample_times[10:40]-1, sample_times[40:]-4))
output = swf.unsafe_sample('A', sample_times=sample_times)
np.testing.assert_equal(expected_output, output)
output_2 = swf.unsafe_sample('A', sample_times=sample_times, output_array=output)
self.assertIs(output_2, output)
def test_unsafe_get_subset_for_channels(self):
dwf_1 = DummyWaveform(duration=2.2, defined_channels={'A', 'B', 'C'})
dwf_2 = DummyWaveform(duration=3.3, defined_channels={'A', 'B', 'C'})
wf = SequenceWaveform([dwf_1, dwf_2])
subset = {'A', 'C'}
sub_wf = wf.unsafe_get_subset_for_channels(subset)
self.assertIsInstance(sub_wf, SequenceWaveform)
self.assertEqual(len(sub_wf.compare_key), 2)
self.assertEqual(sub_wf.compare_key[0].defined_channels, subset)
self.assertEqual(sub_wf.compare_key[1].defined_channels, subset)
self.assertEqual(sub_wf.compare_key[0].duration, TimeType.from_float(2.2))
self.assertEqual(sub_wf.compare_key[1].duration, TimeType.from_float(3.3))
def test_sample_times_type(self) -> None:
with mock.patch.object(DummyWaveform, 'unsafe_sample') as unsafe_sample_patch:
dwfs = (DummyWaveform(duration=1.),
DummyWaveform(duration=3.),
DummyWaveform(duration=2.))
swf = SequenceWaveform(dwfs)
sample_times = np.arange(0, 60) * 0.1
expected_output = np.concatenate((sample_times[:10], sample_times[10:40] - 1, sample_times[40:] - 4))
expected_inputs = sample_times[0:10], sample_times[10:40] - 1, sample_times[40:] - 4
swf.unsafe_sample('A', sample_times=sample_times)
inputs = [call_args[1]['sample_times'] for call_args in unsafe_sample_patch.call_args_list] # type: List[np.ndarray]
np.testing.assert_equal(expected_inputs, inputs)
self.assertEqual([input.dtype for input in inputs], [np.float64 for _ in inputs])
def build_waveform(self,
parameters: Dict[str, Real],
channel_mapping: Dict[ChannelID, ChannelID]) -> SequenceWaveform:
self.validate_parameter_constraints(parameters=parameters)
return SequenceWaveform([sub_template.build_waveform(parameters,
channel_mapping=channel_mapping)
for sub_template in self.__subtemplates])
def test_init(self):
dwf_ab = DummyWaveform(duration=1.1, defined_channels={'A', 'B'})
dwf_abc = DummyWaveform(duration=2.2, defined_channels={'A', 'B', 'C'})
with self.assertRaises(ValueError):
SequenceWaveform([])
with self.assertRaises(ValueError):
SequenceWaveform((dwf_ab, dwf_abc))
swf1 = SequenceWaveform((dwf_ab, dwf_ab))
self.assertEqual(swf1.duration, 2 * dwf_ab.duration)
self.assertEqual(len(swf1.compare_key), 2)
swf2 = SequenceWaveform((swf1, dwf_ab))
self.assertEqual(swf2.duration, 3 * dwf_ab.duration)
self.assertEqual(len(swf2.compare_key), 3)
def test_from_sequence(self):
dwf = DummyWaveform(duration=1.1, defined_channels={'A'})
self.assertIs(dwf, SequenceWaveform.from_sequence((dwf,)))
swf1 = SequenceWaveform.from_sequence((dwf, dwf))
swf2 = SequenceWaveform.from_sequence((swf1, dwf))
assert_constant_consistent(self, swf1)
assert_constant_consistent(self, swf2)
self.assertEqual(3*(dwf,), swf2.sequenced_waveforms)
cwf_2_a = ConstantWaveform(duration=1.1, amplitude=2.2, channel='A')
cwf_3 = ConstantWaveform(duration=1.1, amplitude=3.3, channel='A')
cwf_2_b = ConstantWaveform(duration=1.1, amplitude=2.2, channel='A')
with mock.patch.object(ConstantWaveform, 'from_mapping', return_value=mock.sentinel) as from_mapping:
new_constant = SequenceWaveform.from_sequence((cwf_2_a, cwf_2_b))
self.assertIs(from_mapping.return_value, new_constant)
from_mapping.assert_called_once_with(2*TimeType.from_float(1.1), {'A': 2.2})
swf3 = SequenceWaveform.from_sequence((cwf_2_a, dwf))
self.assertEqual((cwf_2_a, dwf), swf3.sequenced_waveforms)
self.assertIsNone(swf3.constant_value('A'))
assert_constant_consistent(self, swf3)
swf3 = SequenceWaveform.from_sequence((cwf_2_a, cwf_3))
self.assertEqual((cwf_2_a, cwf_3), swf3.sequenced_waveforms)
self.assertIsNone(swf3.constant_value('A'))
assert_constant_consistent(self, swf3)
def _render_instruction_block(
sequence: AbstractInstructionBlock,
render_measurements=False
) -> Tuple[Optional[Waveform], List[MeasurementWindow]]:
"""Transform program into single waveform and measurement windows. The specific implementation of render for
InstructionBlock arguments."""
waveforms, measurements, total_time = iter_instruction_block(
sequence, render_measurements)
if not waveforms:
return None, measurements
sequence_waveform = SequenceWaveform(waveforms)
return sequence_waveform, measurements
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_repr(self):
cwf_2_a = ConstantWaveform(duration=1.1, amplitude=2.2, channel='A')
cwf_3 = ConstantWaveform(duration=1.1, amplitude=3.3, channel='A')
swf = SequenceWaveform([cwf_2_a, cwf_3])
r = repr(swf)
self.assertEqual(swf, eval(r))