def test_duration(self) -> None: entries = [ TableWaveformEntry(0, 0, HoldInterpolationStrategy()), TableWaveformEntry(5, 1, HoldInterpolationStrategy()) ] waveform = TableWaveform('A', entries) self.assertEqual(5, waveform.duration)
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_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_get_entries_instantiated_two_entries_float_float_declaration_float( self) -> None: table = TablePulseTemplate({0: [('foo', -2.)]}) instantiated_entries = table.get_entries_instantiated({'foo': 2})[0] self.assertEqual([(0, -2., HoldInterpolationStrategy()), (2, -2., HoldInterpolationStrategy())], instantiated_entries)
def test_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_instantiate(self): ppe = PointPulseEntry('t', 'V', HoldInterpolationStrategy()) l = ppe.instantiate({'t': 1., 'V': np.arange(3.)}, 3) expected = (PointWaveformEntry(1., 0, HoldInterpolationStrategy()), PointWaveformEntry(1., 1, HoldInterpolationStrategy()), PointWaveformEntry(1., 2, HoldInterpolationStrategy())) self.assertEqual(l, expected)
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_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_scalar_expansion(self): ppe = PointPulseEntry('t', 'V', HoldInterpolationStrategy()) l = ppe.instantiate({'t': 1., 'V': 0.}, 3) self.assertEqual( l, (PointWaveformEntry(1., 0., HoldInterpolationStrategy()), PointWaveformEntry(1., 0., HoldInterpolationStrategy()), PointWaveformEntry(1., 0., HoldInterpolationStrategy())))
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_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_multi(self) -> None: pulse = TablePulseTemplate(channels=2) pulse.add_entry(1,1, channel=0) pulse.add_entry(1,1, channel=1) entries = [[(0,0,HoldInterpolationStrategy()), (1,1,HoldInterpolationStrategy())], [(0,0,HoldInterpolationStrategy()), (1,1,HoldInterpolationStrategy())]] self.assertEqual(entries, pulse.entries)
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_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_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_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_get_instantiated_entries_multi_same_time_param(self) -> None: table = TablePulseTemplate({ 0: [(1, 3), ('foo', 'bar'), (7, 3)], 1: [(0, -5), (0.5, -2), ('foo', 0), (5, 'bar')] }) parameters = {'foo': 2.7, 'bar': -3.3} entries = table.get_entries_instantiated(parameters) expected = { 0: [ TableEntry(0, 3, HoldInterpolationStrategy()), TableEntry(1, 3, HoldInterpolationStrategy()), TableEntry(2.7, -3.3, HoldInterpolationStrategy()), TableEntry(7, 3, HoldInterpolationStrategy()), ], 1: [ TableEntry(0, -5, HoldInterpolationStrategy()), TableEntry(0.5, -2, HoldInterpolationStrategy()), TableEntry(2.7, 0, HoldInterpolationStrategy()), TableEntry(5, -3.3, HoldInterpolationStrategy()), TableEntry(7, -3.3, HoldInterpolationStrategy()) ] } self.assertEqual(expected, entries)
def test_get_instantiated_entries_multi_same_time_param(self) -> None: table = TablePulseTemplate(channels=2) table.add_entry(1, 3) table.add_entry('foo', 'bar') table.add_entry(7, 3) table.add_entry(0, -5, channel=1) table.add_entry(0.5, -2, channel=1) table.add_entry('foo', 0, channel=1) table.add_entry(5, 'bar', channel=1) parameters = {'foo': 2.7, 'bar': -3.3} entries = table.get_entries_instantiated(parameters) expected = [ [ TableEntry(0, 0, HoldInterpolationStrategy()), TableEntry(1, 3, HoldInterpolationStrategy()), TableEntry(2.7, -3.3, HoldInterpolationStrategy()), TableEntry(7, 3, HoldInterpolationStrategy()), ], [ TableEntry(0, -5, HoldInterpolationStrategy()), TableEntry(0.5, -2, HoldInterpolationStrategy()), TableEntry(2.7, 0, HoldInterpolationStrategy()), TableEntry(5, -3.3, HoldInterpolationStrategy()), TableEntry(7, -3.3, HoldInterpolationStrategy()) ] ] self.assertEqual(expected, entries)
def test_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 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_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_get_entries_instantiated_two_equal_entries(self) -> None: table = TablePulseTemplate() table.add_entry(0, 0) table.add_entry(1, 5) table.add_entry(3, 5) table.add_entry(5, 1) entries = table.get_entries_instantiated({}) expected = [[ TableEntry(0, 0, HoldInterpolationStrategy()), TableEntry(1, 5, HoldInterpolationStrategy()), TableEntry(3, 5, HoldInterpolationStrategy()), TableEntry(5, 1, HoldInterpolationStrategy()) ]] self.assertEqual(expected, entries)
def test_repr_str(self): #Test hash strategies = {LinearInterpolationStrategy():("linear","<Linear Interpolation>"), HoldInterpolationStrategy(): ("hold", "<Hold Interpolation>"), JumpInterpolationStrategy(): ("jump", "<Jump Interpolation>")} for strategy in strategies: repr_ = strategies[strategy][1] str_ = strategies[strategy][0] self.assertEqual(repr(strategy), repr_) self.assertEqual(str(strategy), str_) self.assertTrue(LinearInterpolationStrategy()!=HoldInterpolationStrategy()) self.assertTrue(LinearInterpolationStrategy()!=JumpInterpolationStrategy()) self.assertTrue(JumpInterpolationStrategy()!=HoldInterpolationStrategy())
def test_build_waveform_single_channel(self): ppt = PointPulseTemplate([('t1', 'A'), ('t2', 0., 'hold'), ('t1+t2', 'B+C', 'linear')], [0]) parameters = {'t1': 0.1, 't2': 1., 'A': 1., 'B': 2., 'C': 19.} wf = ppt.build_waveform(parameters=parameters, channel_mapping={0: 1}) expected = PointWaveform(1, [(0, 1., HoldInterpolationStrategy()), (0.1, 1., HoldInterpolationStrategy()), (1., 0., HoldInterpolationStrategy()), (1.1, 21., LinearInterpolationStrategy())]) self.assertIsInstance(wf, PointWaveform) self.assertEqual(wf, expected)
def __init__(self, channels: int = 1, measurement=False, identifier: Optional[str] = None) -> None: """Create a new TablePulseTemplate. Args: channels (int): The number of channels defined in this TablePulseTemplate (default = 1). measurement (bool): True, if this TablePulseTemplate shall define a measurement window. (optional, default = False). identifier (str): A unique identifier for use in serialization. (optional) """ super().__init__(identifier) self.__identifier = identifier self.__interpolation_strategies = { 'linear': LinearInterpolationStrategy(), 'hold': HoldInterpolationStrategy(), 'jump': JumpInterpolationStrategy() } self.__entries = [] for _ in range(channels): self.__entries.append( [TableEntry(0, 0, self.__interpolation_strategies['hold'])]) self.__time_parameter_declarations = { } # type: Dict[str, ParameterDeclaration] self.__voltage_parameter_declarations = { } # type: Dict[str, ParameterDeclaration] self.__is_measurement_pulse = measurement # type: bool self.__channels = channels # type: int
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_validate_input_duplicate_removal(self): validated = TableWaveform._validate_input([ TableWaveformEntry(0.0, 0.2, HoldInterpolationStrategy()), TableWaveformEntry(0.1, 0.2, LinearInterpolationStrategy()), TableWaveformEntry(0.1, 0.3, JumpInterpolationStrategy()), TableWaveformEntry(0.1, 0.3, HoldInterpolationStrategy()), TableWaveformEntry(0.2, 0.3, LinearInterpolationStrategy()), TableWaveformEntry(0.3, 0.3, JumpInterpolationStrategy()) ]) self.assertEqual( validated, (TableWaveformEntry(0.0, 0.2, HoldInterpolationStrategy()), TableWaveformEntry(0.1, 0.2, LinearInterpolationStrategy()), TableWaveformEntry(0.1, 0.3, HoldInterpolationStrategy()), TableWaveformEntry(0.3, 0.3, JumpInterpolationStrategy())))
def test_add_entry_time_and_voltage_same_declaration(self) -> None: table = TablePulseTemplate() with self.assertRaises(ValueError): table.add_entry('foo', 'foo') self.assertEquals([[TableEntry(0, 0, HoldInterpolationStrategy())]], table.entries) self.assertFalse(table.parameter_names) self.assertFalse(table.parameter_declarations)