def test_build_waveform_single_channel(self):
table = TablePulseTemplate({0: [(0, 0),
('foo', 'v', 'linear'),
('bar', 0, 'jump')]},
parameter_constraints=['foo>1'],
measurements=[('M', 'b', 'l'),
('N', 1, 2)])
parameters = {'v': 2.3, 'foo': 1, 'bar': 4, 'b': 2, 'l': 1}
channel_mapping = {0: 'ch'}
with self.assertRaises(ParameterConstraintViolation):
table.build_waveform(parameters=parameters,
channel_mapping=channel_mapping)
parameters['foo'] = 1.1
waveform = table.build_waveform(parameters=parameters,
channel_mapping=channel_mapping)
self.assertIsInstance(waveform, TableWaveform)
self.assertEqual(waveform._table,
((0, 0, HoldInterpolationStrategy()),
(1.1, 2.3, LinearInterpolationStrategy()),
(4, 0, JumpInterpolationStrategy())))
self.assertEqual(waveform._channel_id,
'ch')
def test_get_entries_instantiated_two_entries_float_float_declaration_float(
self) -> None:
table = TablePulseTemplate({0: [('foo', -2.)]})
instantiated_entries = table.get_entries_instantiated({'foo': 2})[0]
self.assertEqual([(0, -2., HoldInterpolationStrategy()),
(2, -2., HoldInterpolationStrategy())],
instantiated_entries)
def test_build_waveform_multi_channel(self):
table = TablePulseTemplate(
{
0: [(0, 0), ('foo', 'v', 'linear'), ('bar', 0, 'jump')],
3: [(0, 1), ('bar+foo', 0, 'linear')]
},
parameter_constraints=['foo>1'],
measurements=[('M', 'b', 'l'), ('N', 1, 2)])
parameters = {'v': 2.3, 'foo': 1, 'bar': 4, 'b': 2, 'l': 1}
channel_mapping = {0: 'ch', 3: 'oh'}
with self.assertRaises(ParameterConstraintViolation):
table.build_waveform(parameters=parameters,
channel_mapping=channel_mapping)
parameters['foo'] = 1.1
waveform = table.build_waveform(parameters=parameters,
channel_mapping=channel_mapping)
self.assertIsInstance(waveform, MultiChannelWaveform)
expected_waveforms = [
TableWaveform.from_table(
'ch', ((0, 0, HoldInterpolationStrategy()),
(1.1, 2.3, LinearInterpolationStrategy()),
(4, 0, JumpInterpolationStrategy()),
(5.1, 0, HoldInterpolationStrategy()))),
TableWaveform.from_table(
'oh', ((0, 1, HoldInterpolationStrategy()),
(5.1, 0, LinearInterpolationStrategy()))),
]
self.assertEqual(waveform._sub_waveforms, tuple(expected_waveforms))
def test_issue_584_uninitialized_table_sample(self):
"""issue 584"""
d = 598.3333333333334 - 480
tpt = TablePulseTemplate(
entries={'P': [(0, 1.0, 'hold'), (d, 1.0, 'hold')]})
with mock.patch('qupulse._program.waveforms.PULSE_TO_WAVEFORM_ERROR',
1e-6):
wf = to_waveform(tpt.create_program())
self.assertTrue(isclose(d, wf.duration, abs_tol=1e-6))
start_time = 0.
end_time = wf.duration
sample_rate = 3.
sample_count = (end_time - start_time) * sample_rate + 1
times = np.linspace(float(start_time),
float(wf.duration),
num=int(sample_count),
dtype=float)
times[-1] = np.nextafter(times[-1], times[-2])
out = np.full_like(times, fill_value=np.nan)
sampled = wf.get_sampled(channel='P',
sample_times=times,
output_array=out)
expected = np.full_like(times, fill_value=1.)
np.testing.assert_array_equal(expected, sampled)
def test_internal_constraints(self):
table = TablePulseTemplate(
{
0: [(1, 'v'), (2, 'w')],
1: [('t', 'x'), ('t+2', 'y')]
},
parameter_constraints=['x<2', 'y<w', 't<1'])
self.assertEqual(table.parameter_names, {'v', 'w', 't', 'x', 'y'})
with self.assertRaises(ParameterConstraintViolation):
table.build_waveform(parameters=dict(v=1, w=2, t=0.1, x=2.2, y=1),
channel_mapping={
0: 0,
1: 1
})
with self.assertRaises(ParameterConstraintViolation):
table.build_waveform(parameters=dict(v=1, w=2, t=0.1, x=1.2, y=2),
channel_mapping={
0: 0,
1: 1
})
with self.assertRaises(ParameterConstraintViolation):
table.build_waveform(parameters=dict(v=1, w=2, t=3, x=1.2, y=1),
channel_mapping={
0: 0,
1: 1
})
table.build_waveform(parameters=dict(v=1, w=2, t=0.1, x=1.2, y=1),
channel_mapping={
0: 0,
1: 1
})
def test_get_instantiated_entries_multi_same_time_param(self) -> None:
table = TablePulseTemplate({
0: [(1, 3), ('foo', 'bar'), (7, 3)],
1: [(0, -5), (0.5, -2), ('foo', 0), (5, 'bar')]
})
parameters = {'foo': 2.7, 'bar': -3.3}
entries = table.get_entries_instantiated(parameters)
expected = {
0: [
TableEntry(0, 3, HoldInterpolationStrategy()),
TableEntry(1, 3, HoldInterpolationStrategy()),
TableEntry(2.7, -3.3, HoldInterpolationStrategy()),
TableEntry(7, 3, HoldInterpolationStrategy()),
],
1: [
TableEntry(0, -5, HoldInterpolationStrategy()),
TableEntry(0.5, -2, HoldInterpolationStrategy()),
TableEntry(2.7, 0, HoldInterpolationStrategy()),
TableEntry(5, -3.3, HoldInterpolationStrategy()),
TableEntry(7, -3.3, HoldInterpolationStrategy())
]
}
self.assertEqual(expected, entries)
def test_time_is_0_on_instantiation(self):
table = TablePulseTemplate({0: [('a', 1)]})
self.assertEqual(table.duration, Expression('a'))
self.assertEqual(table.parameter_names, {'a'})
self.assertIsNone(
table.build_waveform(parameters=dict(a=0), channel_mapping={0: 0}))
def setUp(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"TablePT does not issue warning for old serialization routines."
):
self.serializer = DummySerializer(lambda x: dict(name=x.name),
lambda x: x.name,
lambda x: x['name'])
self.entries = dict(A=[('foo', 2, 'hold'),
('hugo', 'ilse', 'linear')],
B=[(0, 5, 'hold'), (1, 7, 'jump'),
('k', 't', 'hold')])
self.measurements = [('m', 1, 1), ('foo', 'z', 'o')]
self.template = TablePulseTemplate(
entries=self.entries,
measurements=self.measurements,
identifier='foo',
parameter_constraints=['ilse>2', 'k>foo'],
registry=dict())
self.expected_data = dict(
type=self.serializer.get_type_identifier(self.template))
self.maxDiff = None
def test_build_waveform_time_type(self):
from qupulse.utils.types import TimeType
table = TablePulseTemplate({0: [(0, 0),
('foo', 'v', 'linear'),
('bar', 0, 'jump')]},
parameter_constraints=['foo>1'],
measurements=[('M', 'b', 'l'),
('N', 1, 2)])
parameters = {'v': 2.3,
'foo': TimeType.from_float(1.), 'bar': TimeType.from_float(4),
'b': TimeType.from_float(2), 'l': TimeType.from_float(1)}
channel_mapping = {0: 'ch'}
with self.assertRaises(ParameterConstraintViolation):
table.build_waveform(parameters=parameters,
channel_mapping=channel_mapping)
parameters['foo'] = TimeType.from_float(1.1)
waveform = table.build_waveform(parameters=parameters,
channel_mapping=channel_mapping)
self.assertIsInstance(waveform, TableWaveform)
self.assertEqual(waveform._table,
((0, 0, HoldInterpolationStrategy()),
(TimeType.from_float(1.1), 2.3, LinearInterpolationStrategy()),
(4, 0, JumpInterpolationStrategy())))
self.assertEqual(waveform._channel_id,
'ch')
def test_triple_concatenation(self):
tpt_1 = TablePulseTemplate({
'A': [(0, 1), ('a', 5, 'linear')],
'B': [(0, 2), ('b', 7)]
})
tpt_2 = TablePulseTemplate({
'A': [('c', 9), ('a', 10, 'jump')],
'B': [(0, 6), ('b', 8)]
})
tpt_3 = TablePulseTemplate({
'A': [('fg', 19), ('ab', 110, 'jump')],
'B': [('df', 16), ('ab', 18)]
})
expected = TablePulseTemplate({
'A': [(0, 1), ('a', 5, 'linear'), ('Max(a, b)', 5),
('Max(a, b)', 9), ('Max(a, b) + c', 9),
('Max(a, b) + a', 10, 'jump'), ('2*Max(a, b)', 10),
('2*Max(a, b)', 19), ('2*Max(a, b) + fg', 19),
('2*Max(a, b) + ab', 110, 'jump')],
'B': [(0, 2), ('b', 7), ('Max(a, b)', 7, 'hold'), ('Max(a, b)', 6),
('Max(a, b) + b', 8), ('2*Max(a, b)', 8),
('2*Max(a, b)', 16), ('2*Max(a, b) + df', 16),
('2*Max(a, b) + ab', 18)]
})
concatenated = concatenate(tpt_1, tpt_2, tpt_3, identifier='asdf')
self.assertEqual(expected.entries, concatenated.entries)
self.assertEqual(concatenated.identifier, 'asdf')
def test_wrong_channels(self):
tpt_1 = TablePulseTemplate({'A': [(0, 1), ('a', 5, 'linear')],
'B': [(0, 2), ('b', 7)]})
tpt_2 = TablePulseTemplate({'A': [('c', 9), ('a', 10, 'jump')],
'C': [(0, 6), ('b', 8)]})
with self.assertRaisesRegex(ValueError, 'differing defined channels'):
concatenate(tpt_1, tpt_2)
def test_time_is_0_on_construction(self) -> None:
with self.assertWarns(ZeroDurationTablePulseTemplate):
warnings.simplefilter('default', ZeroDurationTablePulseTemplate)
table = TablePulseTemplate({0: [(0, 1.4)]})
self.assertTrue(table.duration == 0)
self.assertTrue(table.duration == 0)
self.assertIsNone(
table.build_waveform(parameters=dict(), channel_mapping={0: 0}))
def test_get_entries_instantiated_multiple_parameters_missing(
self) -> None:
table = TablePulseTemplate({0: [(0, 'v1'), ('t', 'v2')]})
with self.assertRaises(ParameterNotProvidedException):
table.get_entries_instantiated(dict())
with self.assertRaises(ParameterNotProvidedException):
table.get_entries_instantiated(dict(v1=1))
with self.assertRaises(ParameterNotProvidedException):
table.get_entries_instantiated(dict(v1=1, t=2))
table.get_entries_instantiated(dict(v1=1, t=2, v2=2))
def test_get_entries_instantiated_two_equal_entries(self) -> None:
table = TablePulseTemplate({0: [(0, 0), (1, 5), (3, 5), (5, 1)]})
entries = table.get_entries_instantiated(dict())
expected = [
TableEntry(0, 0, HoldInterpolationStrategy()),
TableEntry(1, 5, HoldInterpolationStrategy()),
TableEntry(3, 5, HoldInterpolationStrategy()),
TableEntry(5, 1, HoldInterpolationStrategy())
]
self.assertEqual({0: expected}, entries)
def test_time_is_negative(self) -> None:
with self.assertRaises(ValueError):
TablePulseTemplate({0: [(1, 2),
(2, 3),
(-1, 3)]})
with self.assertRaises(ValueError):
TablePulseTemplate({0: [(-1, 2),
(2, 3),
(3, 3)]})
def test_get_entries_instantiated_two_entries_float_declaraton_declaration_declaration(
self) -> None:
table = TablePulseTemplate({0: [(0, 'v1'), ('t', 'v2')]})
instantiated_entries = table.get_entries_instantiated({
'v1': -5,
'v2': 5,
't': 3
})[0]
self.assertEqual([(0, -5, HoldInterpolationStrategy()),
(3, 5, HoldInterpolationStrategy())],
instantiated_entries)
def test_inconsistent_parameters(self):
with self.assertRaises(ValueError):
TablePulseTemplate({0: [('a', 1), (2, 0)], 1: [(3, 6), ('a', 7)]})
with self.assertRaises(ValueError):
TablePulseTemplate({0: [('a', 1), (2, 0)]},
parameter_constraints=['a>3'])
with self.assertRaises(ValueError):
TablePulseTemplate({0: [('a', 1), (2, 0)]},
parameter_constraints=['2>3'])
def test_get_entries_auto_insert(self) -> None:
table = TablePulseTemplate({0: [('foo', 'v', 'linear'),
('bar', 0, 'jump')],
1: [(0, 3, 'linear'),
('bar+foo', 2, 'linear')]})
instantiated_entries = table.get_entries_instantiated({'v': 2.3, 'foo': 1, 'bar': 4})
self.assertEqual({0: [(0, 2.3, HoldInterpolationStrategy()),
(1, 2.3, LinearInterpolationStrategy()),
(4, 0, JumpInterpolationStrategy()),
(5, 0, HoldInterpolationStrategy())],
1: [(0, 3, LinearInterpolationStrategy()),
(5, 2, LinearInterpolationStrategy())]}, instantiated_entries)
def test_duplication(self):
tpt = TablePulseTemplate({'A': [(0, 1), ('a', 5)],
'B': [(0, 2), ('b', 3)]})
concatenated = concatenate(tpt, tpt)
self.assertIsNot(concatenated.entries, tpt.entries)
expected = TablePulseTemplate({'A': [(0, 1), ('a', 5), ('Max(a, b)', 5), ('Max(a, b)', 1), ('Max(a, b) + a', 5)],
'B': [(0, 2), ('b', 3), ('Max(a, b)', 3), ('Max(a, b)', 2), ('Max(a, b) + b', 3)]})
self.assertEqual(expected.entries, concatenated.entries)
def test_from_entry_list(self):
entries = {
0: [(0, 9, HoldInterpolationStrategy()),
(1, 2, HoldInterpolationStrategy()),
(4, 1, LinearInterpolationStrategy())],
1: [(0, 8, HoldInterpolationStrategy()),
(1, 1, HoldInterpolationStrategy()),
(4, 2, LinearInterpolationStrategy())],
2: [(0, 7, HoldInterpolationStrategy()),
(1, 3, HoldInterpolationStrategy()),
(4, 3, LinearInterpolationStrategy())]
}
tpt = TablePulseTemplate.from_entry_list([(0, 9, 8, 7),
(1, 2, 1, 3, 'hold'),
(4, 1, 2, 3, 'linear')],
identifier='tpt')
self.assertEqual(tpt.entries, entries)
self.assertEqual(tpt.identifier, 'tpt')
tpt = TablePulseTemplate.from_entry_list([(0, 9, 8, 7, 'hold'),
(1, 2, 1, 3, 'hold'),
(4, 1, 2, 3, 'linear')],
identifier='tpt2')
self.assertEqual(tpt.entries, entries)
entries = {k: entries[i] for k, i in zip('ABC', [0, 1, 2])}
tpt = TablePulseTemplate.from_entry_list([(0, 9, 8, 7),
(1, 2, 1, 3, 'hold'),
(4, 1, 2, 3, 'linear')],
identifier='tpt3',
channel_names=['A', 'B', 'C'])
self.assertEqual(tpt.entries, entries)
self.assertEqual(tpt.identifier, 'tpt3')
entries = {
0: [(0, 9, HoldInterpolationStrategy()),
(1, 2, HoldInterpolationStrategy()),
(4, 1, HoldInterpolationStrategy())],
1: [(0, 8, HoldInterpolationStrategy()),
(1, 1, HoldInterpolationStrategy()),
(4, 2, HoldInterpolationStrategy())],
2: [(0, 7, HoldInterpolationStrategy()),
(1, 3, HoldInterpolationStrategy()),
(4, 3, HoldInterpolationStrategy())]
}
tpt = TablePulseTemplate.from_entry_list([(0, 9, 8, 7), (1, 2, 1, 3),
(4, 1, 2, 3)],
identifier='tpt4')
self.assertEqual(tpt.entries, entries)
class TablePulseTemplateOldSerializationTests(unittest.TestCase):
def setUp(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(DeprecationWarning, "deprecated",
msg="TablePT does not issue warning for old serialization routines."):
self.serializer = DummySerializer(lambda x: dict(name=x.name), lambda x: x.name, lambda x: x['name'])
self.entries = dict(A=[('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')],
B=[(0, 5, 'hold'), (1, 7, 'jump'), ('k', 't', 'hold')])
self.measurements = [('m', 1, 1), ('foo', 'z', 'o')]
self.template = TablePulseTemplate(entries=self.entries,
measurements=self.measurements,
identifier='foo', parameter_constraints=['ilse>2', 'k>foo'],
registry=dict())
self.expected_data = dict(type=self.serializer.get_type_identifier(self.template))
self.maxDiff = None
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="TablePT does not issue warning for old serialization routines."):
expected_data = dict(measurements=self.measurements,
entries=self.entries,
parameter_constraints=[str(Expression('ilse>2')), str(Expression('k>foo'))])
data = self.template.get_serialization_data(self.serializer)
self.assertEqual(expected_data, data)
def test_deserialize_old(self) -> None:
registry = dict()
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(DeprecationWarning, "deprecated",
msg="TablePT does not issue warning for old serialization routines."):
data = dict(measurements=self.measurements,
entries=self.entries,
parameter_constraints=['ilse>2', 'k>foo'],
identifier='foo')
# deserialize
template = TablePulseTemplate.deserialize(self.serializer, **data, registry=registry)
self.assertEqual(template.entries, self.template.entries)
self.assertEqual(template.measurement_declarations, self.template.measurement_declarations)
self.assertEqual(template.parameter_constraints, self.template.parameter_constraints)
def test_serializer_integration_old(self):
registry = dict()
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(DeprecationWarning, "deprecated",
msg="TablePT does not issue warning for old serialization routines."):
serializer = Serializer(DummyStorageBackend())
serializer.serialize(self.template)
template = serializer.deserialize('foo')
self.assertIsInstance(template, TablePulseTemplate)
self.assertEqual(template.entries, self.template.entries)
self.assertEqual(template.measurement_declarations, self.template.measurement_declarations)
self.assertEqual(template.parameter_constraints, self.template.parameter_constraints)
def test_wrong_type(self):
dummy = DummyPulseTemplate()
tpt = TablePulseTemplate({'A': [(0, 1), ('a', 5, 'linear')],
'B': [(0, 2), ('b', 7)]})
with self.assertRaisesRegex(TypeError, 'not a TablePulseTemplate'):
concatenate(dummy, tpt)
def test_bug_422_mock(self):
pt = TablePulseTemplate({'X': [(0, 1), (100, 1)]})
program = pt.create_program()
mock_program = mock.Mock(spec=dir(program))
for attr in dir(Loop):
if not attr.endswith('_'):
setattr(mock_program, attr, getattr(program, attr))
mock_program.__len__ = lambda x: 1
mock_program.__iter__ = lambda x: iter(program)
mock_program.__getitem__ = lambda x, idx: program[idx]
self.assertNotIsInstance(mock_program, Loop)
render(mock_program, sample_rate=1)
def __init__(self, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
# Setup test data
self.square = TablePulseTemplate(
{
'default': [(0, 0), ('up', 'v', 'hold'), ('down', 0, 'hold'),
('length', 0)]
},
measurements=[('mw1', 'up', 'length-up')])
self.mapping1 = {
'up': 'uptime',
'down': 'uptime + length',
'v': 'voltage',
'length': '0.5 * pulse_length'
}
self.window_name_mapping = {'mw1': 'test_window'}
self.outer_parameters = {'uptime', 'length', 'pulse_length', 'voltage'}
self.parameters = dict()
self.parameters['uptime'] = ConstantParameter(5)
self.parameters['length'] = ConstantParameter(10)
self.parameters['pulse_length'] = ConstantParameter(100)
self.parameters['voltage'] = ConstantParameter(10)
self.sequence = SequencePulseTemplate(
MappingPulseTemplate(self.square,
parameter_mapping=self.mapping1,
measurement_mapping=self.window_name_mapping))
def test_single_channel_no_parameters(self):
raw_entries = [(0., 1.1), (1.1, 2.), (2.2, 2.4)]
table = TablePulseTemplate({0: raw_entries})
expected = [TableEntry(*entry) for entry in raw_entries]
self.assertEqual(table.entries, dict([(0, expected)]))
self.assertEqual(table.duration, 2.2)
self.assertEqual(table.parameter_names, set())
def test_deserialize_old(self) -> None:
registry = dict()
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"TablePT does not issue warning for old serialization routines."
):
data = dict(measurements=self.measurements,
entries=self.entries,
parameter_constraints=['ilse>2', 'k>foo'],
identifier='foo')
# deserialize
template = TablePulseTemplate.deserialize(self.serializer,
**data,
registry=registry)
self.assertEqual(template.entries, self.template.entries)
self.assertEqual(template.measurement_declarations,
self.template.measurement_declarations)
self.assertEqual(template.parameter_constraints,
self.template.parameter_constraints)
def test_from_array_1D(self) -> None:
times = numpy.array([0, 1, 3])
voltages = numpy.array([5, 0, 5])
pulse = TablePulseTemplate.from_array(times, voltages, [0])
entries = []
for (time, voltage) in zip(times, voltages):
entries.append(TableEntry(time, voltage, HoldInterpolationStrategy()))
self.assertEqual({0: entries}, pulse.entries)
def test_from_array_multi_one_voltage(self) -> None:
times = numpy.array([[0, 1, 3], [2, 3, 4]])
voltages = numpy.array([1, 2, 3])
pulse = TablePulseTemplate.from_array(times, voltages, [0, 1])
entries = {
i: [TableEntry(time, voltage, HoldInterpolationStrategy())
for (time, voltage) in zip(times[i, :], voltages)]
for i in range(2)}
self.assertEqual(entries, pulse.entries)
def test_add_entry_multi_same_time_param(self) -> None:
pulse = TablePulseTemplate({0: [(1, 3),
('foo', 'bar'),
(7, 3)],
1: [(0, -5),
(0.5, -2),
('foo', 0),
(5, 'bar')]})
self.assertEqual({'foo', 'bar'}, pulse.parameter_names)
def test_integral(self) -> None:
pulse = TablePulseTemplate(entries={0: [(1, 2, 'linear'), (3, 0, 'jump'), (4, 2, 'hold'), (5, 8, 'hold')],
'other_channel': [(0, 7, 'linear'), (2, 0, 'hold'), (10, 0)],
'symbolic': [(3, 'a', 'hold'), ('b', 4, 'linear'), ('c', Expression('d'), 'hold')]})
expected = {0: Expression('6'),
'other_channel': Expression(7),
'symbolic': Expression('(b-3.)*a + (c-b)*(d+4.) / 2')}
self.assertEqual(expected, pulse.integral)
