def test_requires_stop(self) -> None:
condition = DummyCondition(requires_stop=False)
conditions = {'foo_cond': condition}
body = DummyPulseTemplate(requires_stop=False)
t = LoopPulseTemplate('foo_cond', body)
self.assertFalse(t.requires_stop({}, conditions))
condition.requires_stop_ = True
self.assertTrue(t.requires_stop({}, conditions))
body.requires_stop_ = True
condition.requires_stop_ = False
self.assertFalse(t.requires_stop({}, conditions))
def test_build_waveform_none(self):
wfs = [
DummyWaveform(duration=1.1, defined_channels={'A'}),
DummyWaveform(duration=1.1, defined_channels={'B'})
]
sts = [
DummyPulseTemplate(duration='t1',
defined_channels={'A'},
waveform=wfs[0]),
DummyPulseTemplate(duration='t1',
defined_channels={'B'},
waveform=wfs[1]),
DummyPulseTemplate(duration='t1',
defined_channels={'C'},
waveform=None)
]
pt = AtomicMultiChannelPulseTemplate(*sts,
parameter_constraints=['a < b'])
parameters = dict(a=2.2, b=1.1, c=3.3)
channel_mapping = dict(A=6)
with self.assertRaises(ParameterConstraintViolation):
# parameter constraints are checked before channel mapping is applied
pt.build_waveform(parameters, channel_mapping=dict())
parameters['a'] = 0.5
wf = pt.build_waveform(parameters, channel_mapping=channel_mapping)
self.assertIs(wf['A'], wfs[0])
self.assertIs(wf['B'], wfs[1])
sts[1].waveform = None
wf = pt.build_waveform(parameters, channel_mapping=channel_mapping)
self.assertIs(wf, wfs[0])
sts[0].waveform = None
wf = pt.build_waveform(parameters, channel_mapping=channel_mapping)
self.assertIsNone(wf)
def test_get_serialization_data(self) -> None:
body = DummyPulseTemplate()
condition_name = 'foo_cond'
identifier = 'foo_loop'
t = LoopPulseTemplate(condition_name, body, identifier=identifier)
serializer = DummySerializer()
expected_data = dict(type=serializer.get_type_identifier(t),
body=str(id(body)),
condition=condition_name)
data = t.get_serialization_data(serializer)
self.assertEqual(expected_data, data)
def test_deserialize(self):
sts = [DummyPulseTemplate(duration='t1', defined_channels={'A'}, parameter_names={'a', 'b'}),
DummyPulseTemplate(duration='t1', defined_channels={'B'}, parameter_names={'a', 'c'})]
def deserialization_callback(ident: str):
self.assertIn(ident, ('0', '1'))
if ident == '0':
return 0
else:
return 1
serializer = DummySerializer(deserialize_callback=deserialization_callback)
serializer.subelements = sts
data = dict(subtemplates=['0', '1'], parameter_constraints=['a < d'])
template = AtomicMultiChannelPulseTemplate.deserialize(serializer, **data)
self.assertIs(template.subtemplates[0], sts[0])
self.assertIs(template.subtemplates[1], sts[1])
self.assertEqual(template.parameter_constraints, [ParameterConstraint('a < d')])
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_subtemplate_none(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=None,
duration=0,
parameter_names={'t'})
st = MappingPulseTemplate(template,
parameter_mapping=parameter_mapping,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping)
pre_parameters = {'k': ConstantParameter(5)}
pre_measurement_mapping = {'meas2': 'meas3'}
pre_channel_mapping = {'default': 'A'}
program = Loop()
st._internal_create_program(
parameters=pre_parameters,
measurement_mapping=pre_measurement_mapping,
channel_mapping=pre_channel_mapping,
to_single_waveform=set(),
global_transformation=None,
parent_loop=program)
self.assertEqual(1, len(template.create_program_calls))
self.assertEqual(
(st.map_parameters(pre_parameters),
st.get_updated_measurement_mapping(pre_measurement_mapping),
st.get_updated_channel_mapping(pre_channel_mapping), program),
template.create_program_calls[-1])
self.assertEqual(1, program.repetition_count)
self.assertEqual(0, len(program.children))
self.assertIsNone(program._measurements)
# ensure same result as from Sequencer
sequencer = Sequencer()
sequencer.push(st,
parameters=pre_parameters,
conditions={},
window_mapping=pre_measurement_mapping,
channel_mapping=pre_channel_mapping)
block = sequencer.build()
program_old = MultiChannelProgram(
block, channels={'A'}).programs[frozenset({'A'})]
self.assertEqual(program_old, program)
def test_init(self):
lhs = DummyPulseTemplate(duration=4, defined_channels={'a', 'b'}, parameter_names={'x', 'y'})
rhs = DummyPulseTemplate(duration=4, defined_channels={'a', 'c'}, parameter_names={'x', 'z'})
with self.assertRaisesRegex(TypeError, 'needs to be a pulse template'):
ArithmeticPulseTemplate('a', '+', 'b')
with self.assertRaisesRegex(TypeError, 'two PulseTemplates'):
ArithmeticPulseTemplate(lhs, '+', rhs)
with self.assertRaisesRegex(ValueError, r'Operands \(scalar, PulseTemplate\) require'):
ArithmeticPulseTemplate(4, '/', rhs)
with self.assertRaisesRegex(ValueError, r'Operands \(PulseTemplate, scalar\) require'):
ArithmeticPulseTemplate(lhs, '%', 4)
scalar = mock.Mock()
non_pt = mock.Mock()
with mock.patch.object(ArithmeticPulseTemplate, '_parse_operand',
return_value=scalar) as parse_operand:
arith = ArithmeticPulseTemplate(lhs, '/', non_pt)
parse_operand.assert_called_once_with(non_pt, lhs.defined_channels)
self.assertEqual(lhs, arith.lhs)
self.assertEqual(scalar, arith.rhs)
self.assertEqual(lhs, arith._pulse_template)
self.assertEqual(scalar, arith._scalar)
self.assertEqual('/', arith._arithmetic_operator)
with mock.patch.object(ArithmeticPulseTemplate, '_parse_operand',
return_value=scalar) as parse_operand:
arith = ArithmeticPulseTemplate(non_pt, '-', rhs)
parse_operand.assert_called_once_with(non_pt, rhs.defined_channels)
self.assertEqual(scalar, arith.lhs)
self.assertEqual(rhs, arith.rhs)
self.assertEqual(rhs, arith._pulse_template)
self.assertEqual(scalar, arith._scalar)
self.assertEqual('-', arith._arithmetic_operator)
def test_get_updated_channel_mapping(self):
template = DummyPulseTemplate(defined_channels={'foo', 'bar'})
st = MappingPulseTemplate(template, channel_mapping={'bar': 'kneipe'})
with self.assertRaises(KeyError):
st.get_updated_channel_mapping(dict())
self.assertEqual(
st.get_updated_channel_mapping({
'kneipe': 'meas1',
'foo': 'meas2',
'troet': 'meas3'
}), {
'foo': 'meas2',
'bar': 'meas1'
})
def test_drop_channel(self):
dummy = DummyPulseTemplate(defined_channels={'A', 'B', 'C', 'D'},
parameter_names={'k', 'f', 'b'})
pulse = MappingPulseTemplate(dummy,
parameter_mapping={
'k': 'f',
'b': 2.3
},
channel_mapping={
'A': 'a',
'C': None,
'D': None
})
self.assertEqual({'a', 'B'}, pulse.defined_channels)
def test_init(self) -> None:
body = DummyPulseTemplate()
repetition_count = 3
t = RepetitionPulseTemplate(body, repetition_count)
self.assertEqual(repetition_count, t.repetition_count)
self.assertEqual(body, t.body)
repetition_count = 'foo'
t = RepetitionPulseTemplate(body, repetition_count)
self.assertEqual(repetition_count, t.repetition_count)
self.assertEqual(body, t.body)
with self.assertRaises(ValueError):
RepetitionPulseTemplate(body, Expression(-1))
def test_build_sequence(self) -> None:
dummy_wf1 = DummyWaveform(duration=2.3, num_channels=2)
dummy_wf2 = DummyWaveform(duration=2.3, num_channels=1)
dummy1 = DummyPulseTemplate(parameter_names={'foo'},
num_channels=2,
waveform=dummy_wf1)
dummy2 = DummyPulseTemplate(parameter_names={},
num_channels=1,
waveform=dummy_wf2)
pulse = MultiChannelPulseTemplate([(dummy1, {
'foo': '2*bar'
}, [2, 1]), (dummy2, {}, [0])], {'bar'})
result = pulse.build_waveform({'bar': ConstantParameter(3)})
expected = MultiChannelWaveform([(dummy_wf1, [2, 1]),
(dummy_wf2, [0])])
self.assertEqual(expected, result)
self.assertEqual([{
'foo':
MappedParameter(Expression("2*bar"), {'bar': ConstantParameter(3)})
}], dummy1.build_waveform_calls)
self.assertEqual([{}], dummy2.build_waveform_calls)
def test_concatenation_sequence_table_pulse(self):
a = DummyPulseTemplate(parameter_names={'foo'}, defined_channels={'A'})
b = DummyPulseTemplate(parameter_names={'bar'}, defined_channels={'A'})
c = DummyPulseTemplate(parameter_names={'snu'}, defined_channels={'A'})
d = DummyPulseTemplate(parameter_names={'snu'}, defined_channels={'A'})
seq1 = SequencePulseTemplate(a, b, external_parameters=['foo', 'bar'])
seq2 = SequencePulseTemplate(c, d, external_parameters=['snu'])
seq = seq1 @ c
self.assertTrue(len(seq.subtemplates) == 3)
for st, expected in zip(seq.subtemplates, [a, b, c]):
self.assertTrue(st, expected)
seq = c @ seq1
self.assertTrue(len(seq.subtemplates) == 3)
for st, expected in zip(seq.subtemplates, [c, a, b]):
self.assertTrue(st, expected)
seq = seq1 @ seq2
self.assertTrue(len(seq.subtemplates) == 4)
for st, expected in zip(seq.subtemplates, [a, b, c, d]):
self.assertTrue(st, expected)
def test_integral(self):
integrals_lhs = dict(a=ExpressionScalar('a_lhs'),
b=ExpressionScalar('b'))
integrals_rhs = dict(a=ExpressionScalar('a_rhs'),
c=ExpressionScalar('c'))
lhs = DummyPulseTemplate(duration=4,
defined_channels={'a', 'b'},
parameter_names={'x', 'y'},
integrals=integrals_lhs)
rhs = DummyPulseTemplate(duration=4,
defined_channels={'a', 'c'},
parameter_names={'x', 'z'},
integrals=integrals_rhs)
expected_plus = dict(a=ExpressionScalar('a_lhs + a_rhs'),
b=ExpressionScalar('b'),
c=ExpressionScalar('c'))
expected_minus = dict(a=ExpressionScalar('a_lhs - a_rhs'),
b=ExpressionScalar('b'),
c=ExpressionScalar('-c'))
self.assertEqual(expected_plus, (lhs + rhs).integral)
self.assertEqual(expected_minus, (lhs - rhs).integral)
def test_build_waveform(self):
wfs = [
DummyWaveform(duration=1.1, defined_channels={'A'}),
DummyWaveform(duration=1.1, defined_channels={'B'})
]
sts = [
DummyPulseTemplate(duration='t1',
defined_channels={'A'},
parameter_names={'a', 'b'},
measurement_names={'A', 'C'},
waveform=wfs[0]),
DummyPulseTemplate(duration='t1',
defined_channels={'B'},
parameter_names={'a', 'c'},
measurement_names={'A', 'B'},
waveform=wfs[1])
]
pt = AtomicMultiChannelPulseTemplate(*sts,
parameter_constraints=['a < b'])
parameters = dict(a=2.2, b=1.1, c=3.3)
channel_mapping = dict()
with self.assertRaises(ParameterConstraintViolation):
pt.build_waveform(parameters, channel_mapping=dict())
parameters['a'] = 0.5
wf = pt.build_waveform(parameters, channel_mapping=channel_mapping)
self.assertEqual(wf['A'], wfs[0])
self.assertEqual(wf['B'], wfs[1])
for st in sts:
self.assertEqual(st.build_waveform_calls,
[(parameters, channel_mapping)])
self.assertIs(parameters, st.build_waveform_calls[0][0])
self.assertIs(channel_mapping, st.build_waveform_calls[0][1])
def test_get_serialization_data_old(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"SequencePT does not issue warning for old serialization routines."
):
dummy1 = DummyPulseTemplate()
dummy2 = DummyPulseTemplate()
sequence = SequencePulseTemplate(dummy1,
dummy2,
parameter_constraints=['a<b'],
measurements=[('m', 0, 1)],
registry=dict())
serializer = DummySerializer(serialize_callback=lambda x: str(x))
expected_data = dict(subtemplates=[str(dummy1),
str(dummy2)],
parameter_constraints=['a < b'],
measurements=[('m', 0, 1)])
data = sequence.get_serialization_data(serializer)
self.assertEqual(expected_data, data)
def test_unlink(self):
apt = AbstractPulseTemplate(identifier='my_apt')
dummy = DummyPulseTemplate()
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
apt.unlink()
self.assertFalse(w)
apt.link_to(dummy)
with self.assertWarns(UnlinkWarning):
apt.unlink()
self.assertIsNone(apt._linked_target)
def test_as_expression(self):
sts = [
DummyPulseTemplate(duration='t1',
defined_channels={'A'},
integrals={'A': ExpressionScalar('2+k')}),
DummyPulseTemplate(duration='t1',
defined_channels={'B', 'C'},
integrals={
'B': ExpressionScalar('t1-t0*3.1'),
'C': ExpressionScalar('l')
})
]
pulse = AtomicMultiChannelPulseTemplate(*sts)
self.assertEqual(
{
'A':
ExpressionScalar(
sympify('(2+k) / t1') * pulse._AS_EXPRESSION_TIME),
'B':
ExpressionScalar(
sympify('(t1-t0*3.1)/t1') * pulse._AS_EXPRESSION_TIME),
'C':
ExpressionScalar(sympify('l/t1') * pulse._AS_EXPRESSION_TIME)
}, pulse._as_expression())
def test_integral(self) -> None:
dummy = DummyPulseTemplate(integrals=['foo+2', 'k*3+x**2'])
template = RepetitionPulseTemplate(dummy, 7)
self.assertEqual([Expression('7*(foo+2)'),
Expression('7*(k*3+x**2)')], template.integral)
template = RepetitionPulseTemplate(dummy, '2+m')
self.assertEqual(
[Expression('(2+m)*(foo+2)'),
Expression('(2+m)*(k*3+x**2)')], template.integral)
template = RepetitionPulseTemplate(dummy, Expression('2+m'))
self.assertEqual(
[Expression('(2+m)*(foo+2)'),
Expression('(2+m)*(k*3+x**2)')], template.integral)
def test_init_broken_mappings(self) -> None:
st1 = DummyPulseTemplate(parameter_names={'foo'},
is_interruptable=True,
num_channels=2,
duration=1.3)
st2 = DummyPulseTemplate(parameter_names={'bar'},
is_interruptable=True,
num_channels=1,
duration=6.34)
with self.assertRaises(MissingMappingException):
MultiChannelPulseTemplate([(st1, {
'foo': "bar"
}, [0, 2]), (st2, {}, [1])], {'bar'})
with self.assertRaises(MissingMappingException):
MultiChannelPulseTemplate([(st1, {}, [0, 2]),
(st2, {
'bar': "bar"
}, [1])], {'bar'})
with self.assertRaises(MissingParameterDeclarationException):
MultiChannelPulseTemplate([(st1, {
'foo': "2.3 ** bar"
}, [0, 2]), (st2, {
'bar': "bar"
}, [1])], {})
def test_internal_create_program_no_measurement_mapping(self) -> None:
sub1 = DummyPulseTemplate(duration=3,
waveform=DummyWaveform(duration=3),
measurements=[('b', 1, 2)])
sub2 = DummyPulseTemplate(duration=2,
waveform=DummyWaveform(duration=2),
parameter_names={'foo'})
scope = DictScope.from_kwargs()
seq = SequencePulseTemplate(sub1, sub2, measurements=[('a', 0, 1)])
children = [Loop(waveform=DummyWaveform())]
loop = Loop(measurements=[], children=children)
with self.assertRaises(KeyError):
seq._internal_create_program(scope=scope,
measurement_mapping=dict(),
channel_mapping=dict(),
global_transformation=None,
to_single_waveform=set(),
parent_loop=loop)
self.assertFalse(sub1.create_program_calls)
self.assertFalse(sub2.create_program_calls)
self.assertEqual(children, list(loop.children))
self.assertEqual(1, loop.repetition_count)
self.assertIsNone(loop.waveform)
self.assert_measurement_windows_equal({},
loop.get_measurement_windows())
# test for child level measurements (does not guarantee to leave parent_loop unchanged in this case)
with self.assertRaises(KeyError):
seq._internal_create_program(scope=scope,
measurement_mapping=dict(a='a'),
channel_mapping=dict(),
global_transformation=None,
to_single_waveform=set(),
parent_loop=loop)
def test_internal_create_program_parameter_constraint_violations(
self) -> None:
sub1 = DummyPulseTemplate(duration=3,
waveform=DummyWaveform(duration=3),
measurements=[('b', 1, 2)])
sub2 = DummyPulseTemplate(duration=2,
waveform=DummyWaveform(duration=2),
parameter_names={'foo'})
scope = DictScope.from_kwargs(foo=7)
seq = SequencePulseTemplate(sub1,
sub2,
measurements=[('a', 0, 1)],
parameter_constraints={'foo < 2'})
loop = Loop()
with self.assertRaises(ParameterConstraintViolation):
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_init(self):
template = DummyPulseTemplate(duration='t1', defined_channels={'X', 'Y'}, parameter_names={'a', 'b'}, measurement_names={'M'})
overwritten_channels = {'Y': 'c', 'Z': 'a'}
expected_overwritten_channels = {'Y': ExpressionScalar('c'), 'Z': ExpressionScalar('a')}
pccpt = ParallelConstantChannelPulseTemplate(template, overwritten_channels)
self.assertIs(template, pccpt.template)
self.assertEqual(expected_overwritten_channels, pccpt.overwritten_channels)
self.assertEqual({'X', 'Y', 'Z'}, pccpt.defined_channels)
self.assertEqual({'a', 'b', 'c'}, pccpt.parameter_names)
self.assertEqual({'M'}, pccpt.measurement_names)
self.assertEqual({'a', 'c'}, pccpt.transformation_parameters)
self.assertIs(template.duration, pccpt.duration)
def test_nested_mapping_avoidance(self):
template = DummyPulseTemplate(parameter_names={'foo', 'bar'})
st_1 = MappingPulseTemplate(template, parameter_mapping={'foo': 't*k'}, allow_partial_parameter_mapping=True)
st_2 = MappingPulseTemplate(st_1, parameter_mapping={'bar': 't*l'}, allow_partial_parameter_mapping=True)
self.assertIs(st_2.template, template)
self.assertEqual(st_2.parameter_mapping, {'foo': 't*k', 'bar': 't*l'})
st_3 = MappingPulseTemplate(template,
parameter_mapping={'foo': 't*k'},
allow_partial_parameter_mapping=True,
identifier='käse')
st_4 = MappingPulseTemplate(st_3, parameter_mapping={'bar': 't*l'}, allow_partial_parameter_mapping=True)
self.assertIs(st_4.template, st_3)
self.assertEqual(st_4.parameter_mapping, {'t': 't', 'k': 'k', 'bar': 't*l'})
def test_integral(self) -> None:
dummy = DummyPulseTemplate(defined_channels={'A', 'B'},
parameter_names={'t1', 'i'},
integrals={
'A': ExpressionScalar('t1-i*3.1'),
'B': ExpressionScalar('i')
})
pulse = ForLoopPulseTemplate(dummy, 'i', (1, 8, 2))
expected = {
'A': ExpressionScalar('Sum(t1-3.1*(1+2*i), (i, 0, 3))'),
'B': ExpressionScalar('Sum((1+2*i), (i, 0, 3))')
}
self.assertEqual(expected, pulse.integral)
def test_init_single_subtemplate_requires_stop_external_params(
self) -> None:
subtemplate = DummyPulseTemplate(parameter_names={'foo'},
requires_stop=True,
num_channels=2,
duration=1.3)
template = MultiChannelPulseTemplate([(subtemplate, {
'foo': "2.3 ** bar"
}, [1, 0])], {'bar'})
self.assertEqual({'bar'}, template.parameter_names)
self.assertEqual({ParameterDeclaration('bar')},
template.parameter_declarations)
self.assertFalse(template.is_interruptable)
self.assertTrue(
template.requires_stop(dict(bar=ConstantParameter(3.5)), dict()))
self.assertEqual(2, template.num_channels)
def test_get_scalar_value(self):
lhs = 'x + y'
rhs = DummyPulseTemplate(defined_channels={'u', 'v', 'w'})
arith = ArithmeticPulseTemplate(lhs, '-', rhs)
parameters = dict(x=3, y=5, z=8)
channel_mapping = dict(u='a', v='b', w=None)
expected = dict(a=8, b=8)
self.assertEqual(expected, arith._get_scalar_value(parameters=parameters,
channel_mapping=channel_mapping))
lhs = {'u': 1., 'w': 3.}
arith = ArithmeticPulseTemplate(lhs, '-', rhs)
expected = dict(a=1.)
self.assertEqual(expected, arith._get_scalar_value(parameters=parameters,
channel_mapping=channel_mapping))
def test_get_overwritten_channels_values(self):
template = DummyPulseTemplate(duration='t1',
defined_channels={'X', 'Y'},
parameter_names={'a', 'b'},
measurement_names={'M'})
overwritten_channels = {'Y': 'c', 'Z': 'a'}
expected_overwritten_channel_values = {'Y': 1.2, 'Z': 3.4}
pccpt = ParallelConstantChannelPulseTemplate(template,
overwritten_channels)
real_parameters = {'c': 1.2, 'a': 3.4}
self.assertEqual(
expected_overwritten_channel_values,
pccpt._get_overwritten_channels_values(real_parameters))
def test_non_atomic_subtemplates(self):
non_atomic_pt = PulseTemplateStub(duration='t1', defined_channels={'A'}, parameter_names=set())
atomic_pt = DummyPulseTemplate(defined_channels={'B'}, duration='t1')
non_atomic_mapping = MappingPulseTemplate(non_atomic_pt)
with self.assertRaises(TypeError):
AtomicMultiChannelPulseTemplate(non_atomic_pt)
with self.assertRaises(TypeError):
AtomicMultiChannelPulseTemplate(non_atomic_pt, atomic_pt)
with self.assertRaises(TypeError):
AtomicMultiChannelPulseTemplate(non_atomic_mapping, atomic_pt)
with self.assertRaises(TypeError):
AtomicMultiChannelPulseTemplate((non_atomic_pt, {'A': 'C'}), atomic_pt)
def test_get_serialization_data_minimal(self):
dt = DummyPulseTemplate(parameter_names={'i'})
flt = ForLoopPulseTemplate(body=dt, loop_index='i', loop_range=('A', 'B'))
def check_dt(to_dictify) -> str:
self.assertIs(to_dictify, dt)
return 'dt'
serializer = DummySerializer(serialize_callback=check_dt)
data = flt.get_serialization_data(serializer)
expected_data = dict(body='dt',
loop_range=('A', 'B', 1),
loop_index='i')
self.assertEqual(data, expected_data)
def test_requires_stop_declaration(self) -> None:
body = DummyPulseTemplate(requires_stop=False)
t = RepetitionPulseTemplate(body, ParameterDeclaration('foo'))
parameter = DummyParameter()
parameters = dict(foo=parameter)
condition = DummyCondition()
conditions = dict(foo=condition)
for body_requires_stop in [True, False]:
for condition_requires_stop in [True, False]:
for parameter_requires_stop in [True, False]:
body.requires_stop_ = body_requires_stop
condition.requires_stop_ = condition_requires_stop
parameter.requires_stop_ = parameter_requires_stop
self.assertEqual(parameter_requires_stop, t.requires_stop(parameters, conditions))
