def test_make_compatible(self):
program = Loop()
pub_kwargs = dict(minimal_waveform_length=5,
waveform_quantum=10,
sample_rate=TimeType.from_float(1.))
priv_kwargs = dict(min_len=5, quantum=10, sample_rate=TimeType.from_float(1.))
with mock.patch('qupulse._program._loop._is_compatible',
return_value=_CompatibilityLevel.incompatible_too_short) as mocked:
with self.assertRaisesRegex(ValueError, 'too short'):
make_compatible(program, **pub_kwargs)
mocked.assert_called_once_with(program, **priv_kwargs)
with mock.patch('qupulse._program._loop._is_compatible',
return_value=_CompatibilityLevel.incompatible_fraction) as mocked:
with self.assertRaisesRegex(ValueError, 'not an integer'):
make_compatible(program, **pub_kwargs)
mocked.assert_called_once_with(program, **priv_kwargs)
with mock.patch('qupulse._program._loop._is_compatible',
return_value=_CompatibilityLevel.incompatible_quantum) as mocked:
with self.assertRaisesRegex(ValueError, 'not a multiple of quantum'):
make_compatible(program, **pub_kwargs)
mocked.assert_called_once_with(program, **priv_kwargs)
with mock.patch('qupulse._program._loop._is_compatible',
return_value=_CompatibilityLevel.action_required) as is_compat:
with mock.patch('qupulse._program._loop._make_compatible') as make_compat:
make_compatible(program, **pub_kwargs)
is_compat.assert_called_once_with(program, **priv_kwargs)
make_compat.assert_called_once_with(program, **priv_kwargs)
def test_make_compatible_partial_unroll(self):
wf1 = DummyWaveform(duration=1.5)
wf2 = DummyWaveform(duration=2.0)
program = Loop(children=[Loop(waveform=wf1, repetition_count=2),
Loop(waveform=wf2)])
_make_compatible(program, min_len=1, quantum=1, sample_rate=TimeType.from_float(1.))
self.assertIsNone(program.waveform)
self.assertEqual(len(program), 2)
self.assertIsInstance(program[0].waveform, RepetitionWaveform)
self.assertIs(program[0].waveform._body, wf1)
self.assertEqual(program[0].waveform._repetition_count, 2)
self.assertIs(program[1].waveform, wf2)
program = Loop(children=[Loop(waveform=wf1, repetition_count=2),
Loop(waveform=wf2)], repetition_count=2)
_make_compatible(program, min_len=5, quantum=1, sample_rate=TimeType.from_float(1.))
self.assertIsInstance(program.waveform, SequenceWaveform)
self.assertEqual(list(program.children), [])
self.assertEqual(program.repetition_count, 2)
self.assertEqual(len(program.waveform._sequenced_waveforms), 2)
self.assertIsInstance(program.waveform._sequenced_waveforms[0], RepetitionWaveform)
self.assertIs(program.waveform._sequenced_waveforms[0]._body, wf1)
self.assertEqual(program.waveform._sequenced_waveforms[0]._repetition_count, 2)
self.assertIs(program.waveform._sequenced_waveforms[1], wf2)
def test_is_compatible_leaf(self):
self.assertEqual(_is_compatible(Loop(waveform=DummyWaveform(duration=1.1), repetition_count=10),
min_len=11, quantum=1, sample_rate=TimeType.from_float(1.)),
_CompatibilityLevel.action_required)
self.assertEqual(_is_compatible(Loop(waveform=DummyWaveform(duration=1.1), repetition_count=10),
min_len=11, quantum=1, sample_rate=TimeType.from_float(10.)),
_CompatibilityLevel.compatible)
def test_is_compatible_node(self):
program = Loop(children=[Loop(waveform=DummyWaveform(duration=1.5), repetition_count=2),
Loop(waveform=DummyWaveform(duration=2.0))])
self.assertEqual(_is_compatible(program, min_len=1, quantum=1, sample_rate=TimeType.from_float(2.)),
_CompatibilityLevel.compatible)
self.assertEqual(_is_compatible(program, min_len=1, quantum=1, sample_rate=TimeType.from_float(1.)),
_CompatibilityLevel.action_required)
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 setUp(self) -> None:
self.channels = ('A', None, 'C')
self.marker = (None, 'M')
self.amplitudes = (1., 1., .5)
self.offset = (0., .5, .0)
self.voltage_transformations = (mock.Mock(wraps=lambda x: x),
mock.Mock(wraps=lambda x: x),
mock.Mock(wraps=lambda x: x))
self.sample_rate = TimeType.from_float(1)
N = 100
t = np.arange(N)
self.sampled = [
dict(A=np.linspace(-.1, .1, num=N),
C=.1 * np.sin(t),
M=np.arange(N) % 2),
dict(A=np.linspace(.1, -.1, num=N // 2),
C=.1 * np.cos(t[::2]),
M=np.arange(N // 2) % 3)
]
self.waveforms = [
wf for wf in (DummyWaveform(sample_output=sampled,
duration=sampled['A'].size)
for sampled in self.sampled)
]
self.loop = Loop(children=[Loop(waveform=wf)
for wf in self.waveforms] * 2)
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 __init__(self,
duration: float = 0,
sample_output: Union[numpy.ndarray, dict] = None,
defined_channels={'A'}) -> None:
super().__init__()
self.duration_ = TimeType.from_float(duration)
self.sample_output = sample_output
self.defined_channels_ = defined_channels
self.sample_calls = []
def __init__(self, duration: Union[float, TimeType]=0, sample_output: Union[numpy.ndarray, dict]=None, defined_channels=None) -> None:
super().__init__(duration=duration if isinstance(duration, TimeType) else TimeType.from_float(duration))
self.sample_output = sample_output
if defined_channels is None:
if isinstance(sample_output, dict):
defined_channels = set(sample_output.keys())
else:
defined_channels = {'A'}
self.defined_channels_ = defined_channels
self.sample_calls = []
def test_build_waveform_time_type(self):
from qupulse.utils.types import TimeType
table = TablePulseTemplate({0: [(0, 0),
('foo', 'v', 'linear'),
('bar', 0, 'jump')]},
parameter_constraints=['foo>1'],
measurements=[('M', 'b', 'l'),
('N', 1, 2)])
parameters = {'v': 2.3,
'foo': TimeType.from_float(1.), 'bar': TimeType.from_float(4),
'b': TimeType.from_float(2), 'l': TimeType.from_float(1)}
channel_mapping = {0: 'ch'}
with self.assertRaises(ParameterConstraintViolation):
table.build_waveform(parameters=parameters,
channel_mapping=channel_mapping)
parameters['foo'] = TimeType.from_float(1.1)
waveform = table.build_waveform(parameters=parameters,
channel_mapping=channel_mapping)
self.assertIsInstance(waveform, TableWaveform)
self.assertEqual(waveform._table,
((0, 0, HoldInterpolationStrategy()),
(TimeType.from_float(1.1), 2.3, LinearInterpolationStrategy()),
(4, 0, JumpInterpolationStrategy())))
self.assertEqual(waveform._channel_id,
'ch')
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 __init__(self, expression: ExpressionScalar, duration: float,
channel: ChannelID) -> None:
"""Creates a new FunctionWaveform instance.
Args:
expression: The function represented by this FunctionWaveform
as a mathematical expression where 't' denotes the time variable. It must not have other variables
duration: The duration of the waveform
measurement_windows: A list of measurement windows
channel: The channel this waveform is played on
"""
super().__init__()
if set(expression.variables) - set('t'):
raise ValueError(
'FunctionWaveforms may not depend on anything but "t"')
self._expression = expression
self._duration = TimeType.from_float(duration)
self._channel_id = channel
def test_make_compatible_complete_unroll(self):
wf1 = DummyWaveform(duration=1.5)
wf2 = DummyWaveform(duration=2.0)
program = Loop(children=[Loop(waveform=wf1, repetition_count=2),
Loop(waveform=wf2, repetition_count=1)], repetition_count=2)
_make_compatible(program, min_len=5, quantum=10, sample_rate=TimeType.from_float(1.))
self.assertIsInstance(program.waveform, RepetitionWaveform)
self.assertEqual(program.children, [])
self.assertEqual(program.repetition_count, 1)
self.assertIsInstance(program.waveform, RepetitionWaveform)
self.assertIsInstance(program.waveform._body, SequenceWaveform)
body_wf = program.waveform._body
self.assertEqual(len(body_wf._sequenced_waveforms), 2)
self.assertIsInstance(body_wf._sequenced_waveforms[0], RepetitionWaveform)
self.assertIs(body_wf._sequenced_waveforms[0]._body, wf1)
self.assertEqual(body_wf._sequenced_waveforms[0]._repetition_count, 2)
self.assertIs(body_wf._sequenced_waveforms[1], wf2)
def duration(self) -> TimeType:
return TimeType.from_float(self._table[-1].t,
absolute_error=PULSE_TO_WAVEFORM_ERROR)
def duration(self) -> TimeType:
return TimeType.from_float(self._table[-1].t)
def test_duration(self):
wf = RepetitionWaveform(DummyWaveform(duration=2.2), 3)
self.assertEqual(wf.duration, TimeType.from_float(2.2) * 3)
def test_duration(self) -> None:
wf = FunctionWaveform(expression=Expression('2*t'), duration=4/5,
channel='A')
self.assertEqual(TimeType.from_float(4/5), wf.duration)
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)