def test_get_entries_instantiated_two_entries_parameter_missing(self) -> None:
table = TablePulseTemplate()
t_decl = ParameterDeclaration('t', min=1, max=2)
v2_decl = ParameterDeclaration('v2', min=10, max=30)
table.add_entry(t_decl, v2_decl)
with self.assertRaises(ParameterNotProvidedException):
table.get_entries_instantiated(dict())
def test_deserialize(self) -> None:
data = dict(is_measurement_pulse=True,
time_parameter_declarations=[dict(name='hugo'), dict(name='foo')],
voltage_parameter_declarations=[dict(name='ilse')],
entries=[[(0, 0, 'hold'), ('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')]],
identifier='foo')
# prepare dependencies for deserialization
self.serializer.subelements['foo'] = ParameterDeclaration('foo')
self.serializer.subelements['hugo'] = ParameterDeclaration('hugo')
self.serializer.subelements['ilse'] = ParameterDeclaration('ilse')
# deserialize
template = TablePulseTemplate.deserialize(self.serializer, **data)
# prepare expected parameter declarations
self.serializer.subelements['foo'].min_value = 0
self.serializer.subelements['foo'].max_value = self.serializer.subelements['hugo']
all_declarations = set(self.serializer.subelements.values())
# prepare expected entries
entries = [[(0, 0, HoldInterpolationStrategy()),
(self.serializer.subelements['foo'], 2, HoldInterpolationStrategy()),
(self.serializer.subelements['hugo'], self.serializer.subelements['ilse'], LinearInterpolationStrategy())]]
# compare!
self.assertEqual(all_declarations, template.parameter_declarations)
self.assertEqual({'foo', 'hugo', 'ilse'}, template.parameter_names)
self.assertEqual(entries, template.entries)
self.assertEqual('foo', template.identifier)
def test_add_entry_time_float_after_declaration_greater_bound(self) -> None:
table = TablePulseTemplate()
decl = ParameterDeclaration('t', max=3.4)
table.add_entry(decl, 7.1)
table.add_entry(2.1, 5.5)
expected_decl = ParameterDeclaration('t', min=0, max=2.1)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (expected_decl, 7.1, HoldInterpolationStrategy()), (2.1, 5.5, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'t'}, table.parameter_names)
self.assertEqual({expected_decl}, table.parameter_declarations)
def test_add_entry_time_declaration_lower_bound_after_declaration_upper_bound(self) -> None:
table = TablePulseTemplate()
bar_decl = ParameterDeclaration('bar', min=1, max=2)
foo_decl = ParameterDeclaration('foo', min=1)
table.add_entry(bar_decl, -3)
table.add_entry(foo_decl, 0.1)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (bar_decl, -3, HoldInterpolationStrategy()), (foo_decl, 0.1, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'foo', 'bar'}, table.parameter_names)
self.assertEqual({foo_decl, bar_decl}, table.parameter_declarations)
def test_get_entries_instantiated_two_entries_invalid_parameters(self) -> None:
table = TablePulseTemplate()
table.add_entry(0, 'v1')
t_decl = ParameterDeclaration('t', min=1, max=2)
v2_decl = ParameterDeclaration('v2', min=10, max=30)
table.add_entry(t_decl, v2_decl)
with self.assertRaises(ParameterValueIllegalException):
table.get_entries_instantiated({'v1': -5, 't': 0, 'v2': 20})
with self.assertRaises(ParameterValueIllegalException):
table.get_entries_instantiated({'v1': -5, 't': 1, 'v2': -20})
def test_internal_set_value_exception_branches(self) -> None:
foo = ParameterDeclaration('foo', min=2.1, max=2.6)
bar = ParameterDeclaration('bar', min=foo, max=foo)
with self.assertRaises(ValueError):
ParameterDeclaration('foobar', min=3.1, max=bar)
bar = ParameterDeclaration('bar', min=foo, max=foo)
foobar = ParameterDeclaration('foobar', max=1.1)
with self.assertRaises(ValueError):
self.__assign_min_value(foobar, bar)
def test_add_entry_time_declaration_lower_bound_upper_bound_too_small_after_declaration(self) -> None:
table = TablePulseTemplate()
bar_decl = ParameterDeclaration('bar', min=1, max=2)
foo_decl = ParameterDeclaration('foo', min=1, max=1.5)
table.add_entry(bar_decl, -3)
with self.assertRaises(ValueError):
table.add_entry(foo_decl, 0.1)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (bar_decl, -3, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'bar'}, table.parameter_names)
self.assertEqual({bar_decl}, table.parameter_declarations)
def test_add_entry_time_declaration_after_declaration_no_upper_bound(self) -> None:
table = TablePulseTemplate()
table.add_entry('bar', 72.14)
table.add_entry('foo', 0)
bar_decl = ParameterDeclaration('bar', min=0)
foo_decl = ParameterDeclaration('foo')
foo_decl.min_value = bar_decl
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (bar_decl, 72.14, HoldInterpolationStrategy()), (foo_decl, 0, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'bar', 'foo'}, table.parameter_names)
self.assertEqual({bar_decl, foo_decl}, table.parameter_declarations)
def test_get_entries_instantiated_unlinked_time_declarations(self) -> None:
table = TablePulseTemplate()
foo_decl = ParameterDeclaration('foo', min=1, max=2)
bar_decl = ParameterDeclaration('bar', min=1.5, max=4)
table.add_entry(foo_decl, 'v', 'linear')
table.add_entry(bar_decl, 0, 'jump')
instantiated_entries = table.get_entries_instantiated({'v': 2.3, 'foo': 1, 'bar': 4})
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (1, 2.3, LinearInterpolationStrategy()), (4, 0, JumpInterpolationStrategy())]], instantiated_entries)
with self.assertRaises(Exception):
table.get_entries_instantiated({'v': 2.3, 'foo': 2, 'bar': 1.5})
def test_add_entry_time_parmeter_name_in_use_as_time(self) -> None:
table = TablePulseTemplate()
table.add_entry('foo', 'bar')
foo_decl = ParameterDeclaration('foo', min=0)
bar_decl = ParameterDeclaration('bar')
with self.assertRaises(ValueError):
table.add_entry(ParameterDeclaration('foo'), 3.4)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (foo_decl, bar_decl, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'foo', 'bar'}, table.parameter_names)
self.assertEqual({foo_decl, bar_decl}, table.parameter_declarations)
def test_get_serialization_data_min_max_references(self) -> None:
bar_min = ParameterDeclaration('bar_min')
bar_max = ParameterDeclaration('bar_max')
self.declaration.min_value = bar_min
self.declaration.max_value = bar_max
self.expected_data['min_value'] = 'bar_min'
self.expected_data['max_value'] = 'bar_max'
self.expected_data['default_value'] = None
self.assertEqual(
self.expected_data,
self.declaration.get_serialization_data(self.serializer))
def test_add_entry_time_declaration_invalid_bounds(self) -> None:
table = TablePulseTemplate()
bar_decl = ParameterDeclaration('bar')
foo_decl = ParameterDeclaration('foo')
foo_decl.min_value = bar_decl
with self.assertRaises(ValueError):
table.add_entry(foo_decl, 23857.23)
with self.assertRaises(ValueError):
table.add_entry(bar_decl, -4967.1)
self.assertEquals([[TableEntry(0, 0, HoldInterpolationStrategy())]], table.entries)
self.assertFalse(table.parameter_names)
self.assertFalse(table.parameter_declarations)
def test_requires_stop_true_mapped_parameters(self) -> None:
dummy = DummyPulseTemplate(parameter_names={'foo'}, requires_stop=True)
pulse = MultiChannelPulseTemplate([(dummy, dict(foo='2*bar'), [0]),
(dummy, dict(foo='rab-5'), [1])],
{'bar', 'rab'})
self.assertEqual({'bar', 'rab'}, pulse.parameter_names)
self.assertEqual(
{ParameterDeclaration('bar'),
ParameterDeclaration('rab')}, pulse.parameter_declarations)
parameters = dict(bar=ConstantParameter(-3.6),
rab=ConstantParameter(35.26))
self.assertTrue(pulse.requires_stop(parameters, dict()))
def test_add_entry_voltage_declaration_reuse(self) -> None:
table = TablePulseTemplate()
foo_decl = ParameterDeclaration('foo', min=0, max=3.3)
bar_decl = ParameterDeclaration('bar', min=-3.3, max=1.15)
table.add_entry(0, foo_decl)
table.add_entry(1.51, bar_decl)
table.add_entry(3, 'foo')
table.add_entry('t', foo_decl)
t_decl = ParameterDeclaration('t', min=3)
self.assertEqual([[(0, foo_decl, HoldInterpolationStrategy()), (1.51, bar_decl, HoldInterpolationStrategy()),
(3, foo_decl, HoldInterpolationStrategy()), (t_decl, foo_decl, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'foo', 'bar', 't'}, table.parameter_names)
self.assertEqual({foo_decl, bar_decl, t_decl}, table.parameter_declarations)
def test_deserialize(self) -> None:
dummy1 = DummyPulseTemplate(parameter_names={'foo'}, num_channels=2)
dummy2 = DummyPulseTemplate(parameter_names={}, num_channels=1)
exp = Expression("bar - 35")
data = dict(external_parameters=['bar'],
subtemplates=[
dict(template=str(id(dummy1)),
parameter_mappings=dict(foo=str(exp)),
channel_mappings=[0, 2]),
dict(template=str(id(dummy2)),
parameter_mappings=dict(),
channel_mappings=[1])
])
serializer = DummySerializer(serialize_callback=lambda x: str(x) if
isinstance(x, Expression) else str(id(x)))
serializer.subelements[str(id(dummy1))] = dummy1
serializer.subelements[str(id(dummy2))] = dummy2
serializer.subelements[str(exp)] = exp
template = MultiChannelPulseTemplate.deserialize(serializer, **data)
self.assertEqual(set(data['external_parameters']),
template.parameter_names)
self.assertEqual({ParameterDeclaration('bar')},
template.parameter_declarations)
recovered_data = template.get_serialization_data(serializer)
self.assertEqual(data, recovered_data)
def test_add_entry_empty_time_is_str(self) -> None:
table = TablePulseTemplate()
table.add_entry('t', 0)
decl = ParameterDeclaration('t', min=0)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (decl, 0, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'t'}, table.parameter_names)
self.assertEqual({decl}, table.parameter_declarations)
def test_add_entry_empty_time_is_0_voltage_is_parameter(self) -> None:
table = TablePulseTemplate()
table.add_entry(0, 'foo')
decl = ParameterDeclaration('foo')
self.assertEqual([[(0, decl, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'foo'}, table.parameter_names)
self.assertEqual({decl}, table.parameter_declarations)
def test_requires_stop(self) -> None:
table = TablePulseTemplate()
foo_decl = ParameterDeclaration('foo', min=1)
bar_decl = ParameterDeclaration('bar')
table.add_entry(foo_decl, 'v', 'linear')
table.add_entry(bar_decl, 0, 'jump')
test_sets = [(False, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(False)}),
(False, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(True)}),
(True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(False)}),
(True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(True)}),
(True, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(False)}),
(True, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(True)}),
(True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, True), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(False)}),
(True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, True), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(True)})]
for expected_result, parameter_set, condition_set in test_sets:
self.assertEqual(expected_result, table.requires_stop(parameter_set, condition_set))
def test_add_entry_time_declaration_higher_min_after_float(self) -> None:
table = TablePulseTemplate()
table.add_entry(3.2, 92.1)
decl = ParameterDeclaration('t', min=4.5)
table.add_entry(decl, 1.2)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (3.2, 92.1, HoldInterpolationStrategy()), (decl, 1.2, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'t'}, table.parameter_names)
self.assertEqual({decl}, table.parameter_declarations)
def test_parameter_names_and_declarations_string_input(self) -> None:
template = FunctionPulseTemplate("3 * foo + bar * t", "5 * hugo")
expected_parameter_names = {'foo', 'bar', 'hugo'}
self.assertEqual(expected_parameter_names, template.parameter_names)
self.assertEqual(
{ParameterDeclaration(name)
for name in expected_parameter_names},
template.parameter_declarations)
def test_build_sequence(self) -> None:
table = TablePulseTemplate()
foo_decl = ParameterDeclaration('foo', min=1)
bar_decl = ParameterDeclaration('bar')
table.add_entry(foo_decl, 'v', 'linear')
table.add_entry(bar_decl, 0, 'jump')
parameters = {'v': 2.3, 'foo': 1, 'bar': 4}
instantiated_entries = tuple(table.get_entries_instantiated(parameters))
waveform = table.build_waveform(parameters)
sequencer = DummySequencer()
instruction_block = DummyInstructionBlock()
table.build_sequence(sequencer, parameters, {}, instruction_block)
expected_waveform = TableWaveform(instantiated_entries)
self.assertEqual(1, len(instruction_block.instructions))
instruction = instruction_block.instructions[0]
self.assertIsInstance(instruction, EXECInstruction)
self.assertEqual(expected_waveform, instruction.waveform)
self.assertEqual(expected_waveform, waveform)
def test_add_entry_time_declaration_lower_min_after_float(self) -> None:
table = TablePulseTemplate()
table.add_entry(3.2, 92.1)
decl = ParameterDeclaration('t', min=0.1)
with self.assertRaises(ValueError):
table.add_entry(decl, 1.2)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (3.2, 92.1, HoldInterpolationStrategy())]], table.entries)
self.assertFalse(table.parameter_names)
self.assertFalse(table.parameter_declarations)
def test_add_entry_voltage_declaration_in_use_as_time(self) -> None:
table = TablePulseTemplate()
foo_decl = ParameterDeclaration('foo', min=0, max=2)
table.add_entry(foo_decl, 0)
with self.assertRaises(ValueError):
table.add_entry(4, foo_decl)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (foo_decl, 0, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'foo'}, table.parameter_names)
self.assertEqual({foo_decl}, table.parameter_declarations)
def test_add_entry_time_float_after_declaration_smaller_than_min_bound(self) -> None:
table = TablePulseTemplate()
decl = ParameterDeclaration('t', min=1.2, max=83456.2)
table.add_entry(decl, 2.2)
with self.assertRaises(ValueError):
table.add_entry(1.1, -6.3)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (decl, 2.2, HoldInterpolationStrategy())]], table.entries)
self.assertEqual({'t'}, table.parameter_names)
self.assertEqual({decl}, table.parameter_declarations)
def test_get_serialization_data_declaration(self) -> None:
repetition_count = ParameterDeclaration('foo')
template = RepetitionPulseTemplate(self.body, repetition_count)
expected_data = dict(
type=self.serializer.get_type_identifier(template),
body=str(id(self.body)),
repetition_count=str(id(repetition_count))
)
data = template.get_serialization_data(self.serializer)
self.assertEqual(expected_data, data)
def __test_valid_values(self, **kwargs):
expected_values = {
'min': float('-inf'),
'max': float('+inf'),
'default': None
}
for k in kwargs:
expected_values[k] = kwargs[k]
expected_values['absolute_min'] = expected_values['min']
expected_values['absolute_max'] = expected_values['max']
if isinstance(expected_values['absolute_min'], ParameterDeclaration):
expected_values['absolute_min'] = expected_values[
'absolute_min'].absolute_min_value
if isinstance(expected_values['absolute_max'], ParameterDeclaration):
expected_values['absolute_max'] = expected_values[
'absolute_max'].absolute_max_value
decl = ParameterDeclaration('test', **kwargs)
self.assertEqual('test', decl.name)
self.assertEqual(expected_values['min'], decl.min_value)
self.assertEqual(expected_values['max'], decl.max_value)
self.assertEqual(expected_values['default'], decl.default_value)
self.assertEqual(expected_values['absolute_min'],
decl.absolute_min_value)
self.assertEqual(expected_values['absolute_max'],
decl.absolute_max_value)
decl = ParameterDeclaration('test', default=expected_values['default'])
if 'min' in kwargs:
decl.min_value = kwargs['min']
if 'max' in kwargs:
decl.max_value = kwargs['max']
self.assertEqual(expected_values['min'], decl.min_value)
self.assertEqual(expected_values['max'], decl.max_value)
self.assertEqual(expected_values['default'], decl.default_value)
self.assertEqual(expected_values['absolute_min'],
decl.absolute_min_value)
self.assertEqual(expected_values['absolute_max'],
decl.absolute_max_value)
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 = ParameterDeclaration('foo')
t = RepetitionPulseTemplate(body, repetition_count)
self.assertEqual(repetition_count, t.repetition_count)
self.assertEqual(body, t.body)
def test_get_serialization_data_all_floats(self) -> None:
self.declaration = ParameterDeclaration('foo',
min=-3.1,
max=4.3,
default=0.2)
self.expected_data['min_value'] = -3.1
self.expected_data['max_value'] = 4.3
self.expected_data['default_value'] = 0.2
self.assertEqual(
self.expected_data,
self.declaration.get_serialization_data(self.serializer))
def test_add_entry_time_parameter_name_in_use_as_voltage(self) -> None:
table = TablePulseTemplate()
table.add_entry(0, 'foo')
foo_decl = ParameterDeclaration('foo')
self.assertEqual({'foo'}, table.parameter_names)
self.assertEqual({foo_decl}, table.parameter_declarations)
with self.assertRaises(ValueError):
table.add_entry('foo', 4.3)
self.assertEqual({'foo'}, table.parameter_names)
self.assertEqual({foo_decl}, table.parameter_declarations)
self.assertEqual([[(0, foo_decl, HoldInterpolationStrategy())]], table.entries)
def setUp(self) -> None:
self.serializer = DummySerializer()
self.table_foo = TablePulseTemplate(identifier='foo')
self.table_foo.add_entry('hugo', 2)
self.table_foo.add_entry(ParameterDeclaration('albert', max=9.1),
'voltage')
self.table = TablePulseTemplate(measurement=True)
self.foo_mappings = dict(hugo='ilse',
albert='albert',
voltage='voltage')
