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)