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_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 integral(self) -> Dict[ChannelID, ExpressionScalar]:
expressions = {}
shape = (len(self.defined_channels),)
for i, channel in enumerate(self._channels):
def value_trafo(v):
try:
return v.underlying_expression[i]
except TypeError:
return IndexedBroadcast(v.underlying_expression, shape, i)
pre_entry = TableEntry(0, self._entries[0].v, None)
entries = [pre_entry] + self._entries
expressions[channel] = TableEntry._sequence_integral(entries, expression_extractor=value_trafo)
return expressions
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_from_array_1D(self) -> None:
times = numpy.array([0, 1, 3])
voltages = numpy.array([5, 0, 5])
pulse = TablePulseTemplate.from_array(times, voltages, [0])
entries = []
for (time, voltage) in zip(times, voltages):
entries.append(TableEntry(time, voltage, HoldInterpolationStrategy()))
self.assertEqual({0: entries}, pulse.entries)
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_known_interpolation_strategies(self):
strategies = [("linear", LinearInterpolationStrategy()),
("hold", HoldInterpolationStrategy()),
("jump", JumpInterpolationStrategy())]
for strat_name, strat_val in strategies:
entry = TableEntry('a', Expression('b'), strat_name)
self.assertEqual(entry.t, Expression('a'))
self.assertEqual(entry.v, Expression('b'))
self.assertEqual(entry.interp, strat_val)
def _as_expression(self) -> Dict[ChannelID, ExpressionScalar]:
t = self._AS_EXPRESSION_TIME
shape = (len(self.defined_channels),)
expressions = {}
for i, channel in enumerate(self._channels):
def value_trafo(v):
try:
return v.underlying_expression[i]
except TypeError:
return IndexedBroadcast(v.underlying_expression, shape, i)
pre_value = value_trafo(self._entries[0].v)
post_value = value_trafo(self._entries[-1].v)
pw = TableEntry._sequence_as_expression(self._entries,
expression_extractor=value_trafo,
t=t,
post_value=post_value,
pre_value=pre_value)
expressions[channel] = pw
return expressions
def test_unknown_interpolation_strategy(self):
with self.assertRaises(KeyError):
TableEntry(0, 0, 'foo')
def test_slots(self):
entry = TableEntry('a', Expression.make('b'), 'hold')
self.assertFalse(hasattr(entry, '__dict__'))
def test_sequence_as_expression(self):
def get_sympy(v):
return v.sympified_expression
t = sympy.Dummy('t')
times = {
t: 0.5,
't0': 0.3,
't1': 0.7,
't2': 1.3,
}
entries = [TableEntry(0, 0, None), TableEntry(1, 0, 'hold')]
self.assertEqual(
ExpressionScalar(0),
TableEntry._sequence_as_expression(
entries, get_sympy, t, pre_value=None,
post_value=None).sympified_expression.subs(times))
entries = [TableEntry(0, 1, None), TableEntry(1, 1, 'hold')]
self.assertEqual(
ExpressionScalar(1),
TableEntry._sequence_as_expression(
entries, get_sympy, t, pre_value=None,
post_value=None).sympified_expression.subs(times))
entries = [TableEntry(0, 0, None), TableEntry(1, 1, 'linear')]
self.assertEqual(
ExpressionScalar(.5),
TableEntry._sequence_as_expression(
entries, get_sympy, t, pre_value=None,
post_value=None).sympified_expression.subs(times))
entries = [
TableEntry('t0', 'a', 'linear'),
TableEntry('t1', 'b', 'linear'),
TableEntry('t2', 'c', 'hold')
]
self.assertEqual(
ExpressionScalar('(a+b)*.5'),
TableEntry._sequence_as_expression(
entries, get_sympy, t, pre_value=None,
post_value=None).sympified_expression.subs(times))
def test_sequence_integral(self):
def get_sympy(v):
return v.sympified_expression
entries = [TableEntry(0, 0), TableEntry(1, 0, 'hold')]
self.assertEqual(ExpressionScalar(0),
TableEntry._sequence_integral(entries, get_sympy))
entries = [TableEntry(0, 1), TableEntry(1, 1, 'hold')]
self.assertEqual(ExpressionScalar(1),
TableEntry._sequence_integral(entries, get_sympy))
entries = [TableEntry(0, 0), TableEntry(1, 1, 'linear')]
self.assertEqual(ExpressionScalar(.5),
TableEntry._sequence_integral(entries, get_sympy))
entries = [
TableEntry('t0', 'a', 'linear'),
TableEntry('t1', 'b', 'linear'),
TableEntry('t2', 'c', 'hold')
]
self.assertEqual(ExpressionScalar('(t1-t0)*(a+b)/2 + (t2-t1)*b'),
TableEntry._sequence_integral(entries, get_sympy))
