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)