def test_build_waveform(self):
template = DummyPulseTemplate(duration='t1',
defined_channels={'X', 'Y'},
parameter_names={'a', 'b'},
measurement_names={'M'},
waveform=DummyWaveform())
overwritten_channels = {'Y': 'c', 'Z': 'a'}
channel_mapping = {'X': 'X', 'Y': 'K'}
pccpt = ParallelConstantChannelPulseTemplate(template,
overwritten_channels)
parameters = {'c': 1.2, 'a': 3.4}
expected_overwritten_channels = {'Y': 1.2, 'Z': 3.4}
expected_transformation = ParallelConstantChannelTransformation(
expected_overwritten_channels)
expected_waveform = TransformingWaveform(template.waveform,
expected_transformation)
resulting_waveform = pccpt.build_waveform(parameters.copy(),
channel_mapping.copy())
self.assertEqual(expected_waveform, resulting_waveform)
self.assertEqual([(parameters, channel_mapping)],
template.build_waveform_calls)
template.waveform = None
resulting_waveform = pccpt.build_waveform(parameters.copy(),
channel_mapping.copy())
self.assertEqual(None, resulting_waveform)
self.assertEqual([(parameters, channel_mapping),
(parameters, channel_mapping)],
template.build_waveform_calls)
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)
template._is_interruptable = mock.Mock()
self.assertIs(pccpt.is_interruptable, template.is_interruptable)
rs_arg = object()
return_value = object()
template.requires_stop = mock.Mock(return_value=return_value)
self.assertIs(return_value, pccpt.requires_stop(rs_arg))
template.requires_stop.assert_called_once_with(rs_arg)
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_integral(self):
template = DummyPulseTemplate(duration='t1', defined_channels={'X', 'Y'}, parameter_names={'a', 'b'},
measurement_names={'M'},
integrals={'X': ExpressionScalar('a'), 'Y': ExpressionScalar(4)})
overwritten_channels = {'Y': 'c', 'Z': 'a'}
pccpt = ParallelConstantChannelPulseTemplate(template, overwritten_channels)
expected_integral = {'X': ExpressionScalar('a'),
'Y': ExpressionScalar('c*t1'),
'Z': ExpressionScalar('a*t1')}
self.assertEqual(expected_integral, pccpt.integral)
def test_missing_implementations(self):
pccpt = ParallelConstantChannelPulseTemplate(DummyPulseTemplate(), {})
with self.assertRaises(NotImplementedError):
pccpt.get_serialization_data(object())
with self.assertRaises(NotImplementedError):
pccpt.build_sequence()
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_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_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)
parameters = {'c': ConstantParameter(1.2), 'a': ConstantParameter(3.4)}
kwargs = {
**other_kwargs, 'parameters': parameters.copy(),
'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
}
template._create_program = mock.Mock()
pccpt._internal_create_program(**kwargs)
template._create_program.assert_called_once_with(**expected_kwargs)
global_transformation = LinearTransformation(numpy.zeros((0, 0)), [],
[])
expected_transformation = chain_transformations(
global_transformation, expected_transformation)
kwargs = {
**other_kwargs, 'parameters': parameters.copy(),
'global_transformation': global_transformation
}
expected_kwargs = {
**kwargs, 'global_transformation': expected_transformation
}
template._create_program = mock.Mock()
pccpt._internal_create_program(**kwargs)
template._create_program.assert_called_once_with(**expected_kwargs)