def test_add_entry_for_interpolation(self) -> None:
table = TablePulseTemplate()
strategies = ["linear","hold","jump","hold"]
for i,strategy in enumerate(strategies):
table.add_entry(2*(i+1), i+1, strategy)
self.assertRaises(ValueError, table.add_entry, 1,2, "bar")
def generate_TablePulseTemplates(self,number_of_entries,max_dist=RANGE):
while 1:
x = TablePulseTemplate()
name = "TablePulseTemplate_{}".format(self.__TablePulseTemplateOffset)
self.__TablePulseTemplateOffset +=1
if bool(random.getrandbits(1)):
x.identifier = name
previous_min = 0
previous_max = 0
parameter_names = []
for i in range(number_of_entries):
dict_ = {}
for j in ["time","voltage"]:
a = random.choice(["float","str","ParameterDeclaration"])
if a == "float":
if j == "time":
dict_[j] = random.uniform(previous_max,previous_max+max_dist)
previous_min = dict_[j]
previous_max = dict_[j]
else:
dict_[j] = random.uniform(-RANGE,RANGE)
elif a == "str":
dict_[j] = "_".join([name,"str",str(i),str(j)])
parameter_names.append(dict_[j])
elif a == "ParameterDeclaration":
if j == "time":
dict_[j] = self.generate_ParameterDeclaration(previous_min, previous_min+max_dist, name, previous_max).__next__()
previous_min = dict_[j].min_value
previous_max = dict_[j].max_value
else:
dict_[j] = self.generate_ParameterDeclaration().__next__()
parameter_names.append(dict_[j].name)
x.add_entry(time=dict_["time"],voltage=dict_["voltage"],interpolation=random.choice(INTERPOLATION_STRATEGIES))
yield x
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_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)
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_known_interpolation_strategies(self) -> None:
table = TablePulseTemplate()
strategies = ["linear", "hold", "jump"]
for i,strategy in enumerate(strategies):
table.add_entry(i, i, strategy)
manual = [(0,0,LinearInterpolationStrategy()), (1,1,HoldInterpolationStrategy()), (2,2,JumpInterpolationStrategy())]
self.assertEqual(manual, table.entries)
def test_add_entry_time_float_after_declaration_smaller_bound(self) -> None:
table = TablePulseTemplate()
decl = ParameterDeclaration('t', min=1.0, max=1.3)
table.add_entry(decl, 7.1)
table.add_entry(2.1, 5.5)
self.assertEqual([(0, 0, HoldInterpolationStrategy()), (decl, 7.1, HoldInterpolationStrategy()), (2.1, 5.5, HoldInterpolationStrategy())], table.entries)
self.assertEqual({'t'}, table.parameter_names)
self.assertEqual({decl}, table.parameter_declarations)
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_add_entry_empty_time_is_declaration(self) -> None:
table = TablePulseTemplate()
decl = ParameterDeclaration('foo')
table.add_entry(decl, 0)
decl.min_value = 0
self.assertEqual([(0, 0, HoldInterpolationStrategy()), (decl, 0, HoldInterpolationStrategy())], table.entries)
self.assertEqual({'foo'}, table.parameter_names)
self.assertEqual({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)
self.assertRaises(ParameterValueIllegalException, table.get_entries_instantiated, {'v1': -5, 't': 0, 'v2': 20})
self.assertRaises(ParameterValueIllegalException, table.get_entries_instantiated, {'v1': -5, 't': 1, 'v2': -20})
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)
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_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)
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_float_after_declaration_greater_bound(self) -> None:
table = TablePulseTemplate()
decl = ParameterDeclaration('t', max=3.4)
table.add_entry(decl, 7.1)
decl.min_value = 0
self.assertRaises(ValueError, table.add_entry, 2.1, 5.5)
self.assertEqual([(0, 0, HoldInterpolationStrategy()), (decl, 7.1, HoldInterpolationStrategy())], table.entries)
self.assertEqual({'t'}, table.parameter_names)
self.assertEqual({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_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')
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)
class SequencePulseTemplateSerializationTests(unittest.TestCase):
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')
def test_get_serialization_data(self) -> None:
sequence = SequencePulseTemplate([(self.table_foo, self.foo_mappings), (self.table, {})],
['ilse', 'albert', 'voltage'],
identifier='foo')
expected_data = dict(
type=self.serializer.get_type_identifier(sequence),
external_parameters=['albert', 'ilse', 'voltage'],
is_interruptable=True,
subtemplates = [
dict(template=str(id(self.table_foo)), mappings=self.foo_mappings),
dict(template=str(id(self.table)), mappings=dict())
]
)
data = sequence.get_serialization_data(self.serializer)
self.assertEqual(expected_data, data)
def test_deserialize(self) -> None:
data = dict(
external_parameters={'ilse', 'albert', 'voltage'},
is_interruptable=True,
subtemplates = [
dict(template=str(id(self.table_foo)), mappings=self.foo_mappings),
dict(template=str(id(self.table)), mappings=dict())
],
identifier='foo'
)
# prepare dependencies for deserialization
self.serializer.subelements[str(id(self.table_foo))] = self.table_foo
self.serializer.subelements[str(id(self.table))] = self.table
# deserialize
sequence = SequencePulseTemplate.deserialize(self.serializer, **data)
# compare!
self.assertEqual(data['external_parameters'], sequence.parameter_names)
self.assertEqual({ParameterDeclaration('ilse'), ParameterDeclaration('albert'), ParameterDeclaration('voltage')},
sequence.parameter_declarations)
self.assertIs(self.table_foo, sequence.subtemplates[0][0])
self.assertIs(self.table, sequence.subtemplates[1][0])
self.assertEqual(self.foo_mappings, {k: m.string for k,m in sequence.subtemplates[0][1].items()})
self.assertEqual(dict(), sequence.subtemplates[1][1])
self.assertEqual(data['identifier'], sequence.identifier)
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)
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 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_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_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_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_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_add_entry_time_float_after_float(self) -> None:
table = TablePulseTemplate()
table.add_entry(1.2, -3.8)
# expect ValueError if next float is smaller or equal than previous
self.assertRaises(ValueError, table.add_entry, 0.423, 0)
self.assertRaises(ValueError, table.add_entry, 1.2, 0)
# adding a higher value as next entry should work
table.add_entry(3.7, 1.34875)
self.assertEqual([(0, 0, HoldInterpolationStrategy()), (1.2, -3.8, HoldInterpolationStrategy()), (3.7, 1.34875, HoldInterpolationStrategy())], table.entries)
self.assertFalse(table.parameter_names)
self.assertFalse(table.parameter_declarations)
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_add_entry_time_float_after_float(self) -> None:
table = TablePulseTemplate()
table.add_entry(1.2, -3.8)
# expect ValueError if next float is smaller than previous
with self.assertRaises(ValueError):
table.add_entry(0.423, 0)
# adding a higher value or equal value as last entry should work
table.add_entry(1.2, 2.5252)
table.add_entry(3.7, 1.34875)
self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (1.2, 2.5252, HoldInterpolationStrategy()), (3.7, 1.34875, HoldInterpolationStrategy())]], table.entries)
self.assertFalse(table.parameter_names)
self.assertFalse(table.parameter_declarations)
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')
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_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_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='tpt')
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='tpt',
channel_names=['A', 'B', 'C'])
self.assertEqual(tpt.entries, entries)
self.assertEqual(tpt.identifier, 'tpt')
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='tpt')
self.assertEqual(tpt.entries, entries)
class TablePulseTemplateSerializationTests(unittest.TestCase):
def setUp(self) -> None:
self.serializer = DummySerializer(lambda x: dict(name=x.name), lambda x: x.name, lambda x: x['name'])
self.template = TablePulseTemplate(measurement=True, identifier='foo')
self.expected_data = dict(type=self.serializer.get_type_identifier(self.template))
def test_get_serialization_data(self) -> None:
self.template.add_entry('foo', 2)
self.template.add_entry('hugo', 'ilse', interpolation='linear')
self.expected_data['is_measurement_pulse'] = True
self.expected_data['time_parameter_declarations'] = [dict(name='foo'), dict(name='hugo')]
self.expected_data['voltage_parameter_declarations'] = [dict(name='ilse')]
self.expected_data['entries'] = [[(0, 0, 'hold'), ('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')]]
data = self.template.get_serialization_data(self.serializer)
self.assertEqual(self.expected_data, data)
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 setUp(self) -> None:
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'])
self.expected_data = dict(
type=self.serializer.get_type_identifier(self.template))
self.maxDiff = None
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 __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Setup test data
self.square = TablePulseTemplate()
self.square.add_entry('up', 'v', 'hold')
self.square.add_entry('down', 0, 'hold')
self.square.add_entry('length', 0)
self.mapping1 = {
'up': 'uptime',
'down': 'uptime + length',
'v': 'voltage',
'length': '0.5 * pulse_length'
}
self.outer_parameters = ['uptime', 'length', 'pulse_length', 'voltage']
self.parameters = {}
self.parameters['uptime'] = ConstantParameter(5)
self.parameters['length'] = ConstantParameter(10)
self.parameters['pulse_length'] = ConstantParameter(100)
self.parameters['voltage'] = ConstantParameter(10)
self.sequence = SequencePulseTemplate([(self.square, self.mapping1)], self.outer_parameters)
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(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 __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),
external_parameters=self.outer_parameters)
class TablePulseTemplateSerializationTests(unittest.TestCase):
def setUp(self) -> None:
self.serializer = DummySerializer(lambda x: dict(name=x.name), lambda x: x.name, lambda x: x['name'])
self.template = TablePulseTemplate(measurement=True, identifier='foo')
self.expected_data = dict(type=self.serializer.get_type_identifier(self.template))
def test_get_serialization_data(self) -> None:
self.template.add_entry('foo', 2)
self.template.add_entry('hugo', 'ilse', interpolation='linear')
self.expected_data['is_measurement_pulse'] = True
self.expected_data['time_parameter_declarations'] = [dict(name='foo'), dict(name='hugo')]
self.expected_data['voltage_parameter_declarations'] = [dict(name='ilse')]
self.expected_data['entries'] = [(0, 0, 'hold'), ('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')]
self.assertEqual(self.expected_data, self.template.get_serialization_data(self.serializer))
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)
class SequencePulseTemplateTest(unittest.TestCase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Setup test data
self.square = TablePulseTemplate()
self.square.add_entry('up', 'v', 'hold')
self.square.add_entry('down', 0, 'hold')
self.square.add_entry('length', 0)
self.mapping1 = {
'up': 'uptime',
'down': 'uptime + length',
'v': 'voltage',
'length': '0.5 * pulse_length'
}
self.outer_parameters = ['uptime', 'length', 'pulse_length', 'voltage']
self.parameters = {}
self.parameters['uptime'] = ConstantParameter(5)
self.parameters['length'] = ConstantParameter(10)
self.parameters['pulse_length'] = ConstantParameter(100)
self.parameters['voltage'] = ConstantParameter(10)
self.sequence = SequencePulseTemplate([(self.square, self.mapping1)], self.outer_parameters)
def test_missing_mapping(self):
mapping = self.mapping1
mapping.pop('v')
subtemplates = [(self.square, mapping)]
with self.assertRaises(MissingMappingException):
SequencePulseTemplate(subtemplates, self.outer_parameters)
def test_unnecessary_mapping(self):
mapping = self.mapping1
mapping['unnecessary'] = 'voltage'
subtemplates = [(self.square, mapping)]
with self.assertRaises(UnnecessaryMappingException):
SequencePulseTemplate(subtemplates, self.outer_parameters)
def test_identifier(self):
identifier = 'some name'
pulse = SequencePulseTemplate([], [], identifier=identifier)
self.assertEqual(identifier, pulse.identifier)
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_from_array(self) -> None:
times = numpy.array([0, 1, 3])
voltages = numpy.array([5, 0, 5])
pulse = TablePulseTemplate.from_array(times, voltages)
entries = []
for (time, voltage) in zip(times, voltages):
entries.append((time, voltage, HoldInterpolationStrategy()))
self.assertEqual(entries, pulse.entries)
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)
entries = [[]]
for (time, voltage) in zip(times, voltages):
entries[0].append(TableEntry(time, voltage, HoldInterpolationStrategy()))
self.assertEqual(entries, pulse.entries)
def test_get_entries_instantiated_removal_for_three_subsequent_equal_entries(self) -> None:
table = TablePulseTemplate()
table.add_entry(1, 5)
table.add_entry(1.5, 5)
table.add_entry(2, 5)
table.add_entry(3, 0)
entries = table.get_entries_instantiated({})
expected = [[
TableEntry(0, 0, HoldInterpolationStrategy()),
TableEntry(1, 5, HoldInterpolationStrategy()),
TableEntry(2, 5, HoldInterpolationStrategy()),
TableEntry(3, 0, HoldInterpolationStrategy())
]]
self.assertEqual(expected, entries)
def test_no_measurement_windows(self) -> None:
pulse = TablePulseTemplate(measurement=False)
pulse.add_entry(1, 1)
pulse.add_entry(3, 0)
pulse.add_entry(5, 0)
windows = pulse.get_measurement_windows()
self.assertEqual([], windows)
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 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')
def test_concatenation_sequence_table_pulse_double_parameter(self):
a = TablePulseTemplate()
a.add_entry('t', 'a')
b = TablePulseTemplate()
b.add_entry('t', 'a')
subtemplates = [(b, {'t': 't', 'a': 'a'})]
seq = SequencePulseTemplate(subtemplates, ['t', 'a'])
with self.assertRaises(DoubleParameterNameException) as e:
concat = seq @ a
def test_get_entries_instantiated_removal_for_three_subsequent_equal_entries_does_not_destroy_linear_interpolation(self) -> None:
table = TablePulseTemplate()
table.add_entry(0, 5)
table.add_entry(2, 5, 'linear')
table.add_entry(5, 5)
table.add_entry(10, 0, 'linear')
entries = table.get_entries_instantiated({})
expected = [
TableEntry(0, 5, HoldInterpolationStrategy()),
TableEntry(5, 5, HoldInterpolationStrategy()),
TableEntry(10, 0, LinearInterpolationStrategy())
]
self.assertEqual(expected, entries)
result_sampled = TableWaveform(entries).sample(numpy.linspace(0, 10, 11), 0)
self.assertEqual([5, 5, 5, 5, 5, 5, 4, 3, 2, 1, 0], result_sampled.tolist())
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_from_array_multi(self) -> None:
times = numpy.array([0, 1, 3])
voltages = numpy.array([[1,2,3],
[2,3,4]]).T # todo: why transposed??
pulse = TablePulseTemplate.from_array(times, voltages)
entries = [[],[]]
for i, channel in enumerate(voltages.T):
for (time, voltage) in zip(times, channel):
entries[i].append(TableEntry(time, voltage, HoldInterpolationStrategy()))
self.assertEqual(entries, pulse.entries)
def test_get_entries_instantiated_two_channels_one_empty(self) -> None:
table = TablePulseTemplate(channels=2)
table.add_entry('foo', 4)
parameters = {'foo': 10}
entries = table.get_entries_instantiated(parameters)
expected = [
[
TableEntry(0, 0, HoldInterpolationStrategy()),
TableEntry(10, 4, HoldInterpolationStrategy()),
],
[
TableEntry(0, 0, HoldInterpolationStrategy()),
TableEntry(10, 0, HoldInterpolationStrategy())
]
]
self.assertEqual(expected, entries)
class TablePulseTemplateSerializationTests(unittest.TestCase):
def setUp(self) -> None:
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'])
self.expected_data = dict(
type=self.serializer.get_type_identifier(self.template))
self.maxDiff = None
def test_get_serialization_data(self) -> None:
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(self) -> None:
data = dict(measurements=self.measurements,
entries=self.entries,
parameter_constraints=['ilse>2', 'k>foo'],
identifier='foo')
# deserialize
template = TablePulseTemplate.deserialize(self.serializer, **data)
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(self):
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_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_serialization_and_deserialization_combined(self) -> None:
table_foo = TablePulseTemplate(identifier='foo')
table_foo.add_entry('hugo', 2)
table_foo.add_entry(ParameterDeclaration('albert', max=9.1), 'voltage')
table = TablePulseTemplate(measurement=True)
foo_mappings = dict(hugo='ilse', albert='albert', voltage='voltage')
sequence = SequencePulseTemplate([(table_foo, foo_mappings), (table, {})], ['ilse', 'albert', 'voltage'], identifier=None)
storage = DummyStorageBackend()
serializer = Serializer(storage)
serializer.serialize(sequence)
serialized_foo = storage.stored_items['foo']
serialized_sequence = storage.stored_items['main']
deserialized_sequence = serializer.deserialize('main')
storage.stored_items = dict()
serializer.serialize(deserialized_sequence)
self.assertEqual(serialized_foo, storage.stored_items['foo'])
self.assertEqual(serialized_sequence, storage.stored_items['main'])
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_no_measurement_windows(self) -> None:
pulse = TablePulseTemplate(measurement=False)
pulse.add_entry(1, 1)
pulse.add_entry(3, 0)
pulse.add_entry(5, 0)
windows = pulse.get_measurement_windows()
self.assertEqual([], windows)
def test_get_entries_instantiated_removal_for_three_subsequent_equal_entries(self) -> None:
table = TablePulseTemplate()
table.add_entry(1, 5)
table.add_entry(1.5, 5)
table.add_entry(2, 5)
table.add_entry(3, 0)
entries = table.get_entries_instantiated({})
expected = [
TableEntry(0, 0, HoldInterpolationStrategy()),
TableEntry(1, 5, HoldInterpolationStrategy()),
TableEntry(2, 5, HoldInterpolationStrategy()),
TableEntry(3, 0, HoldInterpolationStrategy())
]
self.assertEqual(expected, entries)
def test_external_constraints(self):
table = TablePulseTemplate(
{
0: [(1, 'v'), (2, 'w')],
1: [('t', 'x'), ('t+2', 'y')]
},
parameter_constraints=['x<h', 'y<w', 't<1'])
self.assertEqual(table.parameter_names, {'v', 'w', 't', 'x', 'y', 'h'})
with self.assertRaises(ParameterConstraintViolation):
table.build_waveform(parameters=dict(v=1.,
w=2,
t=0.1,
x=2.2,
y=1,
h=1),
channel_mapping={
0: 0,
1: 1
})
table.build_waveform(parameters=dict(v=1., w=2, t=0.1, x=1.2, y=1,
h=2),
channel_mapping={
0: 0,
1: 1
})
def setUp(self) -> None:
self.serializer = DummySerializer()
self.table_foo = TablePulseTemplate(
{'default': [('hugo', 2), ('albert', 'voltage')]},
parameter_constraints=['albert<9.1'],
measurements=[('mw_foo', 'hugo', 'albert')],
identifier='foo')
self.foo_param_mappings = dict(hugo='ilse',
albert='albert',
voltage='voltage')
self.foo_meas_mappings = dict(mw_foo='mw_bar')
def test_add_entry_for_interpolation(self) -> None:
table = TablePulseTemplate()
strategies = ["linear","hold","jump","hold"]
for i,strategy in enumerate(strategies):
table.add_entry(2*(i+1), i+1, strategy)
with self.assertRaises(ValueError):
table.add_entry(1,2, "bar")
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)
