def test_serialize(self):
sts = [DummyPulseTemplate(duration='t1', defined_channels={'A'}, parameter_names={'a', 'b'}),
DummyPulseTemplate(duration='t1', defined_channels={'B'}, parameter_names={'a', 'c'})]
constraints = ['a < d']
template = AtomicMultiChannelPulseTemplate(*sts,
parameter_constraints=constraints)
expected_data = dict(subtemplates=['0', '1'], parameter_constraints=['a < d'])
def serialize_callback(obj) -> str:
self.assertIn(obj, sts)
return str(sts.index(obj))
serializer = DummySerializer(serialize_callback=serialize_callback, identifier_callback=serialize_callback)
data = template.get_serialization_data(serializer=serializer)
self.assertEqual(expected_data, data)
def test_mapping_template_mixed_conversion(self):
subtemp_args = [
(self.subtemplates[0], self.param_maps[0], self.chan_maps[0]),
MappingPulseTemplate(self.subtemplates[1], parameter_mapping=self.param_maps[1], channel_mapping=self.chan_maps[1]),
(self.subtemplates[2], self.param_maps[2], self.chan_maps[2])
]
template = AtomicMultiChannelPulseTemplate(*subtemp_args)
for st, pm, cm in zip(template.subtemplates, self.param_maps, self.chan_maps):
self.assertEqual(st.parameter_names, set(pm.values()))
self.assertEqual(st.defined_channels, set(cm.values()))
def test_external_parameters(self):
sts = [DummyPulseTemplate(duration='t1', defined_channels={'A'}, parameter_names={'a', 'b'}),
DummyPulseTemplate(duration='t1', defined_channels={'B'}, parameter_names={'a', 'c'})]
constraints = ['a < d']
template = AtomicMultiChannelPulseTemplate(*sts,
parameter_constraints=constraints,
external_parameters={'a', 'b', 'c', 'd'})
with self.assertRaises(MissingParameterDeclarationException):
AtomicMultiChannelPulseTemplate(*sts,
external_parameters={'a', 'c', 'd'},
parameter_constraints=constraints)
with self.assertRaises(MissingParameterDeclarationException):
AtomicMultiChannelPulseTemplate(*sts, external_parameters={'a', 'b', 'd'},
parameter_constraints=constraints)
with self.assertRaises(MissingParameterDeclarationException):
AtomicMultiChannelPulseTemplate(*sts, external_parameters={'b', 'c', 'd'},
parameter_constraints=constraints)
with self.assertRaises(MissingParameterDeclarationException):
AtomicMultiChannelPulseTemplate(*sts, external_parameters={'a', 'c', 'b'},
parameter_constraints=constraints)
with self.assertRaises(MissingMappingException):
AtomicMultiChannelPulseTemplate(*sts, external_parameters={'a', 'b', 'c', 'd', 'e'},
parameter_constraints=constraints)
self.assertEqual(template.parameter_names, {'a', 'b', 'c', 'd'})
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_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_measurement_names(self):
sts = [DummyPulseTemplate(duration='t1', defined_channels={'A'}, parameter_names={'a', 'b'}, measurement_names={'A', 'C'}),
DummyPulseTemplate(duration='t1', defined_channels={'B'}, parameter_names={'a', 'c'}, measurement_names={'A', 'B'})]
self.assertEqual(AtomicMultiChannelPulseTemplate(*sts).measurement_names, {'A', 'B', 'C'})
def test_defined_channels(self):
subtemp_args = [*zip(self.subtemplates, self.param_maps, self.chan_maps)]
template = AtomicMultiChannelPulseTemplate(*subtemp_args)
self.assertEqual(template.defined_channels, {'cc1', 'cc2', 'cc3'})
def test_channel_intersection(self):
chan_maps = self.chan_maps.copy()
chan_maps[-1]['c3'] = 'cc1'
with self.assertRaises(ChannelMappingException):
AtomicMultiChannelPulseTemplate(*zip(self.subtemplates, self.param_maps, chan_maps))
def test_mapping_template_pure_conversion(self):
template = AtomicMultiChannelPulseTemplate(*zip(self.subtemplates, self.param_maps, self.chan_maps))
for st, pm, cm in zip(template.subtemplates, self.param_maps, self.chan_maps):
self.assertEqual(st.parameter_names, set(pm.values()))
self.assertEqual(st.defined_channels, set(cm.values()))