def test_overwrite(self):
inner = DictScope(FrozenDict({
'a': 0.5,
'i': 3
}),
volatile=frozenset(['a']))
fscope = _ForLoopScope(inner, 'i', 4)
self.assertIn('i', fscope)
self.assertIn('a', fscope)
self.assertNotIn('j', fscope)
equivalent = {'a': 0.5, 'i': 4}
self.assertEqual(equivalent, dict(fscope))
self.assertEqual(equivalent.items(), fscope.items())
self.assertEqual(equivalent.keys(), fscope.keys())
self.assertEqual(set(equivalent.values()), set(fscope.values()))
self.assertEqual(0.5, fscope['a'])
self.assertEqual(4, fscope['i'])
self.assertEqual(FrozenDict({'a': ExpressionScalar('a')}),
fscope.get_volatile_parameters())
inner = DictScope(FrozenDict({
'a': 0.5,
'i': 3
}),
volatile=frozenset(['a', 'i']))
fscope = _ForLoopScope(inner, 'i', 4)
self.assertEqual(FrozenDict({'a': ExpressionScalar('a')}),
fscope.get_volatile_parameters())
def test_from_kwargs(self):
m = {'a': 1, 'b': 2}
volatile = {'a'}
ds = DictScope.from_kwargs(a=1, b=2)
self.assertEqual(DictScope(FrozenDict(m)), ds)
ds = DictScope.from_kwargs(a=1, b=2, volatile=volatile.copy())
self.assertEqual(DictScope(FrozenDict(m), frozenset(volatile)), ds)
def test_get_parameter(self):
ds = DictScope(FrozenDict({'a': 1, 'b': 2}))
self.assertEqual(1, ds.get_parameter('a'))
self.assertEqual(2, ds.get_parameter('b'))
with self.assertRaises(ParameterNotProvidedException) as cm:
ds.get_parameter('c')
self.assertEqual('c', cm.exception.parameter_name)
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_create_program_missing_params(self) -> None:
dt = DummyPulseTemplate(parameter_names={'i'},
waveform=DummyWaveform(duration=4.0),
duration='t',
measurements=[('b', 2, 1)])
flt = ForLoopPulseTemplate(body=dt,
loop_index='i',
loop_range=('a', 'b', 'c'),
measurements=[('A', 'alph', 1)],
parameter_constraints=['c > 1'])
scope = DictScope.from_kwargs(a=1, b=4)
measurement_mapping = dict(A='B')
channel_mapping = dict(C='D')
children = [Loop(waveform=DummyWaveform(duration=2.0))]
program = Loop(children=children)
# test parameter in constraints
with self.assertRaises(ParameterNotProvidedException):
flt._internal_create_program(
scope=scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
parent_loop=program,
to_single_waveform=set(),
global_transformation=None)
# test parameter in measurement mappings
scope = DictScope.from_kwargs(a=1, b=4, c=2)
with self.assertRaises(ParameterNotProvidedException):
flt._internal_create_program(
scope=scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
parent_loop=program,
to_single_waveform=set(),
global_transformation=None)
# test parameter in duration
scope = DictScope.from_kwargs(a=1, b=4, c=2, alph=0)
with self.assertRaises(ParameterNotProvidedException):
flt._internal_create_program(
scope=scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
parent_loop=program,
to_single_waveform=set(),
global_transformation=None)
self.assertEqual(children, list(program.children))
self.assertEqual(1, program.repetition_count)
self.assertIsNone(program._measurements)
self.assert_measurement_windows_equal(
{}, program.get_measurement_windows())
def test_update_constants(self):
ds = DictScope.from_kwargs(a=1, b=2, c=3, volatile={'c'})
ds2 = DictScope.from_kwargs(a=1, b=2, c=4, volatile={'c'})
ms = MappedScope(ds, FrozenDict(x=ExpressionScalar('a * b'),
c=ExpressionScalar('a - b')))
ms2 = MappedScope(ds2, ms._mapping)
self.assertIs(ms, ms.change_constants({'f': 1}))
changes = {'c': 4}
ms_result = ms.change_constants(changes)
self.assertEqual(ms2, ms_result)
def test_init(self):
with self.assertRaises(AssertionError):
DictScope(dict())
fd = FrozenDict({'a': 2})
ds = DictScope(fd)
self.assertIs(fd, ds._values)
self.assertEqual(FrozenDict(), ds._volatile_parameters)
vp = frozenset('a')
ds = DictScope(fd, vp)
self.assertIs(fd, ds._values)
self.assertEqual(FrozenDict(a=ExpressionScalar('a')), ds._volatile_parameters)
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_internal_create_program(self):
lhs = 'x + y'
rhs = DummyPulseTemplate(defined_channels={'u', 'v', 'w'})
arith = ArithmeticPulseTemplate(lhs, '-', rhs)
scope = DictScope.from_kwargs(x=3,
y=5,
z=8,
volatile={'some_parameter'})
channel_mapping = dict(u='a', v='b', w=None)
measurement_mapping = dict(m1='m2')
global_transformation = OffsetTransformation({'unrelated': 1.})
to_single_waveform = {'something_else'}
parent_loop = mock.Mock()
expected_transformation = mock.Mock(spec=IdentityTransformation())
inner_trafo = mock.Mock(spec=IdentityTransformation())
inner_trafo.chain.return_value = expected_transformation
with mock.patch.object(rhs, '_create_program') as inner_create_program:
with mock.patch.object(
arith, '_get_transformation',
return_value=inner_trafo) as get_transformation:
arith._internal_create_program(
scope=scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
global_transformation=global_transformation,
to_single_waveform=to_single_waveform,
parent_loop=parent_loop)
get_transformation.assert_called_once_with(
parameters=scope, channel_mapping=channel_mapping)
inner_trafo.chain.assert_called_once_with(global_transformation)
inner_create_program.assert_called_once_with(
scope=scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
global_transformation=expected_transformation,
to_single_waveform=to_single_waveform,
parent_loop=parent_loop)
with self.assertRaisesRegex(NotImplementedError, 'volatile'):
arith._internal_create_program(
scope=DictScope.from_kwargs(x=3, y=5, z=8, volatile={'x'}),
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
global_transformation=global_transformation,
to_single_waveform=to_single_waveform,
parent_loop=parent_loop)
def test_create_program_constraint_on_loop_var_exception(self):
"""This test is to assure the status-quo behavior of ForLoopPT handling parameter constraints affecting the loop index
variable. Please see https://github.com/qutech/qupulse/issues/232 ."""
with self.assertWarnsRegex(UserWarning, "constraint on a variable shadowing the loop index",
msg="ForLoopPT did not issue a warning when constraining the loop index"):
flt = ForLoopPulseTemplate(body=DummyPulseTemplate(parameter_names={'k', 'i'}), loop_index='i',
loop_range=('a', 'b', 'c',), parameter_constraints=['k<=f', 'k>i'])
# loop index showing up in parameter_names because it appears in consraints
self.assertEqual(flt.parameter_names, {'f', 'k', 'a', 'b', 'c', 'i'})
scope = DictScope.from_kwargs(k=1, a=0, b=2, c=1, f=2)
# loop index not accessible in current build_sequence -> Exception
children = [Loop(waveform=DummyWaveform(duration=2.0))]
program = Loop(children=children)
with self.assertRaises(ParameterNotProvidedException):
flt._internal_create_program(scope=scope,
measurement_mapping=dict(),
channel_mapping=dict(),
parent_loop=program,
to_single_waveform=set(),
global_transformation=None)
self.assertEqual(children, list(program.children))
self.assertEqual(1, program.repetition_count)
self.assertIsNone(program._measurements)
self.assert_measurement_windows_equal({}, program.get_measurement_windows())
def test_internal_create_program(self):
template = DummyPulseTemplate(duration='t1', defined_channels={'X', 'Y'}, parameter_names={'a', 'b'},
measurement_names={'M'}, waveform=DummyWaveform())
overwritten_channels = {'Y': 'c', 'Z': 'a'}
parent_loop = object()
measurement_mapping = object()
channel_mapping = object()
to_single_waveform = object()
other_kwargs = dict(measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
to_single_waveform=to_single_waveform,
parent_loop=parent_loop)
pccpt = ParallelConstantChannelPulseTemplate(template, overwritten_channels)
scope = DictScope.from_kwargs(c=1.2, a=3.4)
kwargs = {**other_kwargs, 'scope': scope, 'global_transformation': None}
expected_overwritten_channels = {'Y': 1.2, 'Z': 3.4}
expected_transformation = ParallelConstantChannelTransformation(expected_overwritten_channels)
expected_kwargs = {**kwargs, 'global_transformation': expected_transformation}
with mock.patch.object(template, '_create_program', spec=template._create_program) as cp_mock:
pccpt._internal_create_program(**kwargs)
cp_mock.assert_called_once_with(**expected_kwargs)
global_transformation = LinearTransformation(numpy.zeros((0, 0)), [], [])
expected_transformation = chain_transformations(global_transformation, expected_transformation)
kwargs = {**other_kwargs, 'scope': scope, 'global_transformation': global_transformation}
expected_kwargs = {**kwargs, 'global_transformation': expected_transformation}
with mock.patch.object(template, '_create_program', spec=template._create_program) as cp_mock:
pccpt._internal_create_program(**kwargs)
cp_mock.assert_called_once_with(**expected_kwargs)
def test_body_scope_generator(self):
dt = DummyPulseTemplate(parameter_names={'i', 'k'})
flt = ForLoopPulseTemplate(body=dt,
loop_index='i',
loop_range=('a', 'b', 'c'))
expected_range = range(2, 17, 3)
outer_scope = DictScope.from_kwargs(k=5,
a=expected_range.start,
b=expected_range.stop,
c=expected_range.step,
volatile={'i', 'j'})
forward_scopes = list(
flt._body_scope_generator(outer_scope, forward=True))
backward_scopes = list(
flt._body_scope_generator(outer_scope, forward=False))
volatile_dict = FrozenDict(j=ExpressionScalar('j'))
self.assertEqual(forward_scopes, list(reversed(backward_scopes)))
for scope, i in zip(forward_scopes, expected_range):
self.assertEqual(volatile_dict, scope.get_volatile_parameters())
expected_dict_equivalent = dict(k=5,
i=i,
a=expected_range.start,
b=expected_range.stop,
c=expected_range.step)
self.assertEqual(expected_dict_equivalent, dict(scope.items()))
def test_create_program_invalid_measurement_mapping(self) -> None:
dt = DummyPulseTemplate(parameter_names={'i'}, waveform=DummyWaveform(duration=4.0), duration=4,
measurements=[('b', 2, 1)])
flt = ForLoopPulseTemplate(body=dt, loop_index='i', loop_range=('a', 'b', 'c'),
measurements=[('A', 0, 1)], parameter_constraints=['c > 1'])
invalid_scope = DictScope.from_kwargs(a=1, b=4, c=2)
measurement_mapping = dict()
channel_mapping = dict(C='D')
children = [Loop(waveform=DummyWaveform(duration=2.0))]
program = Loop(children=children)
with self.assertRaises(KeyError):
flt._internal_create_program(scope=invalid_scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
parent_loop=program,
to_single_waveform=set(),
global_transformation=None)
self.assertEqual(children, list(program.children))
self.assertEqual(1, program.repetition_count)
self.assertIsNone(program._measurements)
self.assert_measurement_windows_equal({}, program.get_measurement_windows())
# test for broken mapping on child level. no guarantee that parent_loop is not changed, only check for exception
measurement_mapping = dict(A='B')
with self.assertRaises(KeyError):
flt._internal_create_program(scope=invalid_scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
parent_loop=program,
to_single_waveform=set(),
global_transformation=None)
def test_create_program_append(self) -> None:
dt = DummyPulseTemplate(parameter_names={'i'}, waveform=DummyWaveform(duration=4.0), duration=4,
measurements=[('b', 2, 1)])
flt = ForLoopPulseTemplate(body=dt, loop_index='i', loop_range=('a', 'b', 'c'),
measurements=[('A', 0, 1)], parameter_constraints=['c > 1'])
scope = DictScope.from_kwargs(a=1, b=4, c=2, volatile={'inner'})
measurement_mapping = dict(A='B', b='b')
channel_mapping = dict(C='D')
children = [Loop(waveform=DummyWaveform(duration=2.0))]
program = Loop(children=children)
flt._internal_create_program(scope=scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
parent_loop=program,
to_single_waveform=set(),
global_transformation=None)
self.assertEqual(3, len(program.children))
self.assertIs(children[0], program.children[0])
self.assertEqual(dt.waveform, program.children[1].waveform)
self.assertEqual(dt.waveform, program.children[2].waveform)
self.assertEqual(1, program.children[1].repetition_count)
self.assertEqual(1, program.children[2].repetition_count)
self.assertEqual(1, program.repetition_count)
self.assert_measurement_windows_equal({'b': ([4, 8], [1, 1]), 'B': ([2], [1])}, program.get_measurement_windows())
def test_create_program_parameter_constraint_violation(self) -> None:
measurement_mapping = {'meas1': 'meas2'}
parameter_mapping = {'t': 'k'}
channel_mapping = {'B': 'default'}
template = DummyPulseTemplate(measurements=[('meas1', 0, 1)], measurement_names={'meas1'},
defined_channels={'B'},
waveform=DummyWaveform(duration=2.0),
duration=2,
parameter_names={'t'})
st = MappingPulseTemplate(template, parameter_mapping=parameter_mapping,
measurement_mapping=measurement_mapping, channel_mapping=channel_mapping,
parameter_constraints={'k > 6'})
pre_scope = DictScope.from_kwargs(k=5)
pre_measurement_mapping = {'meas2': 'meas3'}
pre_channel_mapping = {'default': 'A'}
program = Loop()
with self.assertRaises(ParameterConstraintViolation):
st._internal_create_program(scope=pre_scope,
measurement_mapping=pre_measurement_mapping,
channel_mapping=pre_channel_mapping,
to_single_waveform=set(),
global_transformation=None,
parent_loop=program)
def test_create_program_declaration_success(self) -> None:
repetitions = "foo"
body = DummyPulseTemplate(duration=2.0,
waveform=DummyWaveform(
duration=2, defined_channels={'A'}))
t = RepetitionPulseTemplate(body,
repetitions,
parameter_constraints=['foo<9'])
scope = DictScope.from_kwargs(foo=3)
measurement_mapping = dict(moth='fire')
channel_mapping = dict(asd='f')
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, program.repetition_count)
self.assertEqual(1, len(program.children))
internal_loop = program.children[0] # type: Loop
self.assertEqual(scope[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(
{}, program.get_measurement_windows())
def test_create_program_declaration_parameter_value_not_whole(
self) -> None:
repetitions = "foo"
body = DummyPulseTemplate(duration=2.0,
waveform=DummyWaveform(duration=2.0))
t = RepetitionPulseTemplate(body,
repetitions,
parameter_constraints=['foo<9'])
scope = DictScope.from_kwargs(foo=(3.3))
measurement_mapping = dict(moth='fire')
channel_mapping = dict(asd='f')
children = [Loop(waveform=DummyWaveform(duration=0))]
program = Loop(children=children)
with self.assertRaises(ParameterNotIntegerException):
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.assertFalse(body.create_program_calls)
self.assertEqual(1, program.repetition_count)
self.assertEqual(children, list(program.children))
self.assertIsNone(program.waveform)
self.assert_measurement_windows_equal(
{}, program.get_measurement_windows())
def test_create_program_rep_count_neg_declaration_with_measurements(
self) -> None:
repetitions = "foo"
body_program = Loop(waveform=DummyWaveform(duration=1.0))
body = DummyPulseTemplate(duration=2.0, program=body_program)
# suppress warning about 0 repetitions on construction here, we are only interested in correct behavior during sequencing (i.e., do nothing)
with warnings.catch_warnings(record=True):
t = RepetitionPulseTemplate(body,
repetitions,
measurements=[('moth', 0, 'meas_end')])
scope = DictScope.from_kwargs(foo=-1, meas_end=7.1)
measurement_mapping = dict(moth='fire')
channel_mapping = dict(asd='f')
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.assertFalse(body.create_program_calls)
self.assertFalse(program.children)
self.assertEqual(1, program.repetition_count)
self.assertEqual(None, program._measurements)
def test_mapping(self):
ds = DictScope.from_kwargs(a=1, b=2, c=3)
ms = MappedScope(ds, FrozenDict(x=ExpressionScalar('a * b'),
c=ExpressionScalar('a - b')))
self.assertEqual(4, len(ms))
self.assertEqual(set('abcx'), set(ms.keys()))
self.assertEqual([-1, 1, 2, 2], sorted(ms.values()))
self.assertEqual({('a', 1), ('b', 2), ('c', -1), ('x', 2)}, set(ms.items()))
self.assertEqual(set(ms), set(ms.keys()))
self.assertIn('a', ms)
self.assertIn('c', ms)
self.assertIn('x', ms)
self.assertNotIn('d', ms)
self.assertEqual(-1, ms['c'])
self.assertEqual(1, ms['a'])
self.assertEqual(2, ms['x'])
with self.assertRaises(TypeError):
ms['d'] = 9
with self.assertRaisesRegex(KeyError, 'd'):
_ = ms['d']
def test_create_program_body_none(self) -> None:
dt = DummyPulseTemplate(parameter_names={'i'},
waveform=None,
duration=0,
measurements=[('b', 2, 1)])
flt = ForLoopPulseTemplate(body=dt,
loop_index='i',
loop_range=('a', 'b', 'c'),
measurements=[('A', 0, 1)],
parameter_constraints=['c > 1'])
scope = DictScope.from_kwargs(a=1, b=4, c=2)
measurement_mapping = dict(A='B', b='b')
channel_mapping = dict(C='D')
program = Loop()
flt._internal_create_program(scope=scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
parent_loop=program,
to_single_waveform=set(),
global_transformation=None)
self.assertEqual(0, len(program.children))
self.assertEqual(1, program.repetition_count)
self.assertEqual([], list(program.children))
def test_eq(self):
ds1 = DictScope.from_kwargs(a=1, b=2, c=3, d=4)
ds2 = DictScope.from_kwargs(a=1, b=2, c=3, d=5)
mapping1 = FrozenDict(x=ExpressionScalar('a * b'),
c=ExpressionScalar('a - b'),
y=ExpressionScalar('c - a'))
mapping2 = FrozenDict(x=ExpressionScalar('a * b'),
c=ExpressionScalar('a - b'),
y=ExpressionScalar('d - a'))
self.assertEqual(MappedScope(ds1, mapping1), MappedScope(ds1, mapping1))
self.assertNotEqual(MappedScope(ds1, mapping1), MappedScope(ds1, mapping2))
self.assertNotEqual(MappedScope(ds2, mapping1), MappedScope(ds1, mapping1))
self.assertEqual(MappedScope(ds1, mapping2), MappedScope(ds1, mapping2))
def test_internal_create_program_no_waveform(self) -> None:
measurement_windows = [('M', 0, 5)]
template = AtomicPulseTemplateStub(measurements=measurement_windows,
parameter_names={'foo'})
scope = DictScope.from_kwargs(foo=3.5, bar=3, volatile={'bar'})
measurement_mapping = {'M': 'N'}
channel_mapping = {'B': 'A'}
program = Loop()
expected_program = Loop()
with mock.patch.object(template, 'build_waveform',
return_value=None) as build_waveform:
with mock.patch.object(template,
'get_measurement_windows',
wraps=template.get_measurement_windows
) as get_meas_windows:
template._internal_create_program(
scope=scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
parent_loop=program,
to_single_waveform=set(),
global_transformation=None)
build_waveform.assert_called_once_with(
parameters=scope, channel_mapping=channel_mapping)
get_meas_windows.assert_not_called()
self.assertEqual(expected_program, program)
def test_create_program_defaults(self) -> None:
template = PulseTemplateStub(defined_channels={'A', 'B'},
parameter_names={'foo'},
measurement_names={'hugo', 'foo'})
expected_internal_kwargs = dict(scope=DictScope.from_kwargs(),
measurement_mapping={
'hugo': 'hugo',
'foo': 'foo'
},
channel_mapping={
'A': 'A',
'B': 'B'
},
global_transformation=None,
to_single_waveform=set())
dummy_waveform = DummyWaveform()
expected_program = Loop(children=[Loop(waveform=dummy_waveform)])
with mock.patch.object(template,
'_internal_create_program',
wraps=get_appending_internal_create_program(
dummy_waveform,
True)) as _internal_create_program:
program = template.create_program()
_internal_create_program.assert_called_once_with(
**expected_internal_kwargs, parent_loop=program)
self.assertEqual(expected_program, program)
def test_internal_create_program(self) -> None:
measurement_windows = [('M', 0, 5)]
single_wf = DummyWaveform(duration=6, defined_channels={'A'})
wf = MultiChannelWaveform([single_wf])
template = AtomicPulseTemplateStub(measurements=measurement_windows,
parameter_names={'foo'})
scope = DictScope.from_kwargs(foo=7.2, volatile={'gutes_zeuch'})
measurement_mapping = {'M': 'N'}
channel_mapping = {'B': 'A'}
program = Loop()
expected_program = Loop(children=[Loop(waveform=wf)],
measurements=[('N', 0, 5)])
with mock.patch.object(template, 'build_waveform',
return_value=wf) as build_waveform:
template._internal_create_program(
scope=scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
parent_loop=program,
to_single_waveform=set(),
global_transformation=None)
build_waveform.assert_called_once_with(
parameters=scope, channel_mapping=channel_mapping)
self.assertEqual(expected_program, program)
# MultiChannelProgram calls cleanup
program.cleanup()
def test_create_program_none(self) -> None:
template = PulseTemplateStub(defined_channels={'A'},
parameter_names={'foo'})
parameters = {
'foo': ConstantParameter(2.126),
'bar': -26.2,
'hugo': 'exp(sin(pi/2))'
}
measurement_mapping = {'M': 'N'}
channel_mapping = {'A': 'B'}
volatile = {'hugo'}
scope = DictScope.from_kwargs(foo=2.126,
bar=-26.2,
hugo=math.exp(math.sin(math.pi / 2)),
volatile=volatile)
expected_internal_kwargs = dict(
scope=scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
global_transformation=None,
to_single_waveform=set())
with mock.patch.object(
template,
'_internal_create_program') as _internal_create_program:
program = template.create_program(
parameters=parameters,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
volatile=volatile)
_internal_create_program.assert_called_once_with(
**expected_internal_kwargs, parent_loop=Loop())
self.assertIsNone(program)
def test_internal_create_program_both_children_no_duration(self) -> None:
sub1 = DummyPulseTemplate(duration=0,
waveform=None,
measurements=[('b', 1, 2)],
defined_channels={'A'})
sub2 = DummyPulseTemplate(duration=0,
waveform=None,
parameter_names={'foo'},
defined_channels={'A'})
scope = DictScope.from_kwargs()
measurement_mapping = {'a': 'a', 'b': 'b'}
channel_mapping = dict()
seq = SequencePulseTemplate(sub1, sub2, measurements=[('a', 0, 1)])
loop = Loop(measurements=None)
seq._internal_create_program(scope=scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
global_transformation=None,
to_single_waveform=set(),
parent_loop=loop)
self.assertEqual(1, loop.repetition_count)
self.assertIsNone(loop.waveform)
self.assertEqual([], list(loop.children))
self.assertIsNone(loop._measurements)
def test_internal_create_program(self):
wf = DummyWaveform(duration=2.)
body = PulseTemplateStub()
rpt = RepetitionPulseTemplate(body,
'n_rep*mul',
measurements=[('m', 'a', 'b')])
scope = DictScope.from_kwargs(n_rep=3,
mul=2,
a=.1,
b=.2,
irrelevant=42)
measurement_mapping = {'m': 'l'}
channel_mapping = {'x': 'Y'}
global_transformation = TransformationStub()
to_single_waveform = {'to', 'single', 'waveform'}
program = Loop()
expected_program = Loop(
children=[Loop(children=[Loop(waveform=wf)], repetition_count=6)],
measurements=[('l', .1, .2)])
real_relevant_parameters = dict(n_rep=3, mul=2, a=0.1, b=0.2)
with mock.patch.object(body,
'_create_program',
wraps=get_appending_internal_create_program(
wf,
always_append=True)) as body_create_program:
with mock.patch.object(rpt, 'validate_scope') as validate_scope:
with mock.patch.object(
rpt, 'get_repetition_count_value',
return_value=6) as get_repetition_count_value:
with mock.patch.object(rpt,
'get_measurement_windows',
return_value=[('l', .1, .2)
]) as get_meas:
rpt._internal_create_program(
scope=scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
global_transformation=global_transformation,
to_single_waveform=to_single_waveform,
parent_loop=program)
self.assertEqual(program, expected_program)
body_create_program.assert_called_once_with(
scope=scope,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
global_transformation=global_transformation,
to_single_waveform=to_single_waveform,
parent_loop=program.children[0])
validate_scope.assert_called_once_with(scope)
get_repetition_count_value.assert_called_once_with(
scope)
get_meas.assert_called_once_with(
scope, measurement_mapping)
def test_volatile_parameters(self):
ds = DictScope.from_kwargs(a=1, b=2, c=3, d=4, volatile={'c', 'd'})
ms = MappedScope(ds, FrozenDict(x=ExpressionScalar('a * b'),
c=ExpressionScalar('a - b'),
y=ExpressionScalar('c - a')))
expected_volatile = FrozenDict(d=ExpressionScalar('d'), y=ExpressionScalar('c - 1'))
self.assertEqual(expected_volatile, ms.get_volatile_parameters())
self.assertIs(ms.get_volatile_parameters(), ms.get_volatile_parameters())
def test_eq(self):
ds = DictScope(FrozenDict({'a': 1, 'b': 2}), volatile=frozenset('a'))
ds1 = DictScope(FrozenDict({'a': 1, 'b': 2}), volatile=frozenset())
ds2 = DictScope(FrozenDict({'a': 1, 'b': 2}), volatile=frozenset('a'))
ds3 = DictScope(FrozenDict({'a': 1, 'b': 2}), volatile=frozenset('ab'))
ds4 = DictScope(FrozenDict({'a': 1, 'b': 2, 'c': 3}), volatile=frozenset('a'))
self.assertNotEqual(ds, ds1)
self.assertNotEqual(ds, ds3)
self.assertNotEqual(ds, ds4)
self.assertEqual(ds, ds2)
self.assertEqual(hash(ds), hash(ds2))
self.assertNotEqual(ds1, ds2)
self.assertNotEqual(ds2, ds3)
self.assertNotEqual(ds3, ds4)
def test_mapping(self):
ds = DictScope(FrozenDict({'a': 1, 'b': 2}))
self.assertIn('a', ds)
self.assertNotIn('c', ds)
self.assertEqual(set('ab'), set(ds.keys()))
self.assertEqual(set('ab'), set(ds))
self.assertEqual({1, 2}, set(ds.values()))
self.assertEqual({('a', 1), ('b', 2)}, set(ds.items()))
self.assertEqual({'a': 1, 'b': 2}, dict(ds))
self.assertEqual(1, ds['a'])
with self.assertRaises(KeyError):
ds['c']
with self.assertRaises(TypeError):
ds['a'] = 3
