def test_from_mapping(self):
m = {'a': 1, 'b': 2}
volatile = {'a'}
ds = DictScope.from_mapping(m.copy())
self.assertEqual(m, dict(ds))
self.assertEqual(FrozenDict(), ds.get_volatile_parameters())
ds = DictScope.from_mapping(m.copy(), volatile=volatile.copy())
self.assertEqual(DictScope(FrozenDict(m), frozenset(volatile)), ds)
def test_internal_create_program_parameter_missing(self) -> None:
sub1 = DummyPulseTemplate(duration=3,
waveform=DummyWaveform(duration=3),
measurements=[('b', 1, 2)])
sub2 = DummyPulseTemplate(duration='d',
waveform=DummyWaveform(duration=2),
parameter_names={'foo'})
seq = SequencePulseTemplate(sub1,
sub2,
measurements=[('a', 'bar', 1)],
parameter_constraints={'foo < 2'})
loop = Loop()
# test parameter from constraints
scope = DictScope.from_kwargs()
with self.assertRaises(ParameterNotProvidedException):
seq._internal_create_program(scope=scope,
measurement_mapping={
'a': 'a',
'b': 'b'
},
channel_mapping=dict(),
global_transformation=None,
to_single_waveform=set(),
parent_loop=loop)
# test parameter from measurements
scope = DictScope.from_mapping({'foo': 1})
with self.assertRaises(ParameterNotProvidedException):
seq._internal_create_program(scope=scope,
measurement_mapping={
'a': 'a',
'b': 'b'
},
channel_mapping=dict(),
global_transformation=None,
to_single_waveform=set(),
parent_loop=loop)
# test parameter from duration
scope = DictScope.from_mapping({'foo': 1, 'bar': 0})
with self.assertRaises(ParameterNotProvidedException):
seq._internal_create_program(scope=scope,
measurement_mapping={
'a': 'a',
'b': 'b'
},
channel_mapping=dict(),
global_transformation=None,
to_single_waveform=set(),
parent_loop=loop)
def test_create_program_constant_success_measurements(self) -> None:
repetitions = 3
body = DummyPulseTemplate(duration=2.0,
waveform=DummyWaveform(
duration=2, defined_channels={'A'}),
measurements=[('b', 0, 1)])
t = RepetitionPulseTemplate(body,
repetitions,
parameter_constraints=['foo<9'],
measurements=[('my', 2, 2)])
scope = DictScope.from_mapping({'foo': 8})
measurement_mapping = {'my': 'thy', 'b': 'b'}
channel_mapping = {}
program = Loop()
t._internal_create_program(scope=scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
to_single_waveform=set(),
global_transformation=None,
parent_loop=program)
self.assertEqual(1, len(program.children))
internal_loop = program[0] # type: Loop
self.assertEqual(repetitions, internal_loop.repetition_count)
self.assertEqual(1, len(internal_loop))
self.assertEqual(
(scope, measurement_mapping, channel_mapping, internal_loop),
body.create_program_calls[-1])
self.assertEqual(body.waveform, internal_loop[0].waveform)
self.assert_measurement_windows_equal(
{
'b': ([0, 2, 4], [1, 1, 1]),
'thy': ([2], [2])
}, program.get_measurement_windows())
# done in MultiChannelProgram
program.cleanup()
self.assert_measurement_windows_equal(
{
'b': ([0, 2, 4], [1, 1, 1]),
'thy': ([2], [2])
}, program.get_measurement_windows())
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)
