def test_update_volatile_parameters_with_depth1(self):
parameters = {'s': 10, 'not': 13}
s = VolatileRepetitionCount(expression=ExpressionScalar('s'),
scope=DictScope(values=FrozenDict(s=3),
volatile=set('s')))
wf_1 = DummyWaveform(defined_channels={'A'}, duration=1)
wf_2 = DummyWaveform(defined_channels={'A'}, duration=1)
program = Loop(children=[
Loop(waveform=wf_1, repetition_count=s),
Loop(waveform=wf_2, repetition_count=4),
Loop(waveform=wf_1, repetition_count=1)
],
repetition_count=1)
t_program = TaborProgram(program,
channels=(None, 'A'),
markers=(None, None),
device_properties=self.instr_props,
**self.program_entry_kwargs)
self.assertEqual(t_program.get_sequencer_tables(),
[[(TableDescription(3, 0, 0), s.volatile_property),
(TableDescription(4, 1, 0), None),
(TableDescription(1, 0, 0), None)]])
self.assertEqual(t_program.get_advanced_sequencer_table(),
[TableDescription(1, 1, 0)])
modifications = t_program.update_volatile_parameters(parameters)
expected_seq = VolatileRepetitionCount(
expression=ExpressionScalar('s'),
scope=DictScope(values=FrozenDict(s=10), volatile=set('s')))
expected_modifications = {(0, 0): TableDescription(10, 0, 0)}
self.assertEqual(
t_program.get_sequencer_tables(),
[[(TableDescription(10, 0, 0), expected_seq.volatile_property),
(TableDescription(4, 1, 0), None),
(TableDescription(1, 0, 0), None)]])
self.assertEqual(t_program.get_advanced_sequencer_table(),
[TableDescription(1, 1, 0)])
self.assertEqual(modifications, expected_modifications)
def test_is_compatible_warnings(self):
wf = DummyWaveform(duration=1)
volatile_repetition_count = VolatileRepetitionCount(ExpressionScalar('x'),
DictScope.from_kwargs(x=3, volatile={'x'}))
volatile_leaf = Loop(waveform=wf, repetition_count=volatile_repetition_count)
with self.assertWarns(VolatileModificationWarning):
self.assertEqual(_CompatibilityLevel.action_required, _is_compatible(volatile_leaf, min_len=3, quantum=1,
sample_rate=time_from_float(1.)))
volatile_node = Loop(children=[Loop(waveform=wf)], repetition_count=volatile_repetition_count)
with self.assertWarns(VolatileModificationWarning):
self.assertEqual(_CompatibilityLevel.action_required, _is_compatible(volatile_node, min_len=3, quantum=1,
sample_rate=time_from_float(1.)))
def complex_program_as_loop(unique_wfs, wf_same):
root = Loop(repetition_count=12)
for wf_unique in unique_wfs:
root.append_child(children=[
Loop(repetition_count=42, waveform=wf_unique),
Loop(repetition_count=98, waveform=wf_same)
],
repetition_count=10)
root.append_child(waveform=unique_wfs[0], repetition_count=21)
root.append_child(waveform=wf_same, repetition_count=23)
volatile_repetition = VolatileRepetitionCount(
ExpressionScalar('n + 4'), DictScope.from_kwargs(n=3, volatile={'n'}))
root.append_child(waveform=wf_same, repetition_count=volatile_repetition)
return root
def _merge_single_child(self):
"""Lift the single child to current level. Requires _has_single_child_that_can_be_merged to be true"""
assert len(
self) == 1, "bug: _merge_single_child called on loop with len != 1"
child = cast(Loop, self[0])
# if the child has a fixed repetition count of 1 the measurements can be merged
mergable_measurements = child.repetition_count == 1 and not child.volatile_repetition
assert not self._measurements or mergable_measurements, "bug: _merge_single_child called on loop with measurements"
assert not self._waveform, "bug: _merge_single_child called on loop with children and waveform"
measurements = child._measurements
if self._measurements:
if measurements:
measurements.extend(self._measurements)
else:
measurements = self._measurements
if not self.volatile_repetition and not child.volatile_repetition:
# simple integer multiplication
repetition_definition = self.repetition_count * child.repetition_count
elif not self.volatile_repetition:
repetition_definition = child._repetition_definition * self.repetition_count
elif not child.volatile_repetition:
repetition_definition = self._repetition_definition * child.repetition_count
else:
# create a new expression that depends on both
expression = 'parent_repetition_count * child_repetition_count'
repetition_definition = VolatileRepetitionCount.operation(
expression=expression,
parent_repetition_count=self._repetition_definition,
child_repetition_count=child._repetition_definition)
self[:] = iter(child)
self._waveform = child._waveform
self._repetition_definition = repetition_definition
self._measurements = measurements
self._invalidate_duration()
return True
def test_roll_constant_waveforms(self):
root = Loop(waveform=ConstantWaveform.from_mapping(
16, {
'A': 1.,
'B': 0.5
}),
repetition_count=4)
expected = copy.deepcopy(root)
roll_constant_waveforms(root, 1, 16, TimeType.from_fraction(1, 1))
self.assertEqual(root, expected)
root = Loop(waveform=ConstantWaveform.from_mapping(
32, {
'A': 1.,
'B': 0.5
}),
repetition_count=4)
expected = Loop(waveform=ConstantWaveform.from_mapping(
16, {
'A': 1.,
'B': 0.5
}),
repetition_count=8)
roll_constant_waveforms(root, 1, 16, TimeType.from_fraction(1, 1))
self.assertEqual(root, expected)
root = Loop(waveform=ConstantWaveform.from_mapping(
16 * 3, {
'A': 1.,
'B': 0.5
}),
repetition_count=4)
expected = Loop(waveform=ConstantWaveform.from_mapping(
16, {
'A': 1.,
'B': 0.5
}),
repetition_count=12)
roll_constant_waveforms(root, 1, 16, TimeType.from_fraction(1, 1))
self.assertEqual(root, expected)
root = Loop(waveform=ConstantWaveform.from_mapping(
16 * 3, {
'A': 1.,
'B': 0.5
}),
repetition_count=4)
expected = copy.deepcopy(root)
roll_constant_waveforms(root, 2, 16, TimeType.from_fraction(1, 1))
self.assertEqual(root, expected)
root = Loop(waveform=ConstantWaveform.from_mapping(
16 * 5, {
'A': 1.,
'B': 0.5
}),
repetition_count=4)
expected = copy.deepcopy(root)
roll_constant_waveforms(root, 2, 16, TimeType.from_fraction(1, 1))
self.assertEqual(root, expected)
root = Loop(children=[
Loop(waveform=ConstantWaveform.from_mapping(
32, {
'A': 1.,
'B': 0.5
}),
repetition_count=4),
Loop(waveform=ConstantWaveform.from_mapping(
16, {
'A': 1.,
'B': 0.3
}),
repetition_count=4),
Loop(waveform=ConstantWaveform.from_mapping(
128, {
'A': .1,
'B': 0.5
}),
repetition_count=2)
])
expected = Loop(children=[
Loop(waveform=ConstantWaveform.from_mapping(
16, {
'A': 1.,
'B': 0.5
}),
repetition_count=8),
Loop(waveform=ConstantWaveform.from_mapping(
16, {
'A': 1.,
'B': 0.3
}),
repetition_count=4),
Loop(waveform=ConstantWaveform.from_mapping(
16, {
'A': .1,
'B': 0.5
}),
repetition_count=2 * 128 // 16)
])
roll_constant_waveforms(root, 1, 16, TimeType.from_fraction(1, 1))
self.assertEqual(root, expected)
not_constant_wf = DummyWaveform(sample_output=np.array([.1, .2, .3]),
duration=TimeType.from_fraction(32, 1),
defined_channels={'A', 'B'})
root = Loop(waveform=not_constant_wf, repetition_count=4)
expected = copy.deepcopy(root)
roll_constant_waveforms(root, 1, 16, TimeType.from_fraction(1, 1))
self.assertEqual(root, expected)
scope = DictScope.from_mapping({'a': 4, 'b': 3}, volatile={'a'})
rep_count = VolatileRepetitionCount(expression=ExpressionScalar('a+b'),
scope=scope)
root = Loop(waveform=ConstantWaveform.from_mapping(
32, {
'A': 1.,
'B': 0.5
}),
repetition_count=rep_count)
expected = Loop(waveform=ConstantWaveform.from_mapping(
16, {
'A': 1.,
'B': 0.5
}),
repetition_count=rep_count * 2)
self.assertNotEqual(root.repetition_count, expected.repetition_count)
roll_constant_waveforms(root, 1, 16, TimeType.from_fraction(1, 1))
self.assertEqual(root, expected)