def test_defined_channels(self): self.assertEqual( PointPulseTemplate([(1, 'A')], [0]).defined_channels, {0}) self.assertEqual( PointPulseTemplate([(1, 'A')], [0, 'asd']).defined_channels, {0, 'asd'})
def test_build_waveform_none_channel(self): ppt = PointPulseTemplate([('t1', 'A'), ('t2', 0., 'hold'), ('t1+t2', 'B+C', 'linear')], [0, 'A', 'C'], measurements=[('M', 'n', 1), ('L', 'n', 1)]) parameters = { 't1': 0.1, 't2': 1., 'A': np.ones(3), 'B': np.arange(3), 'C': 19., 'n': 0.2 } self.assertIsNone( ppt.build_waveform(parameters, { 0: None, 'A': None, 'C': None })) wf = ppt.build_waveform(parameters, {0: 1, 'A': None, 'C': None}) self.assertIsInstance(wf, PointWaveform) self.assertEqual(wf.defined_channels, {1}) wf = ppt.build_waveform(parameters, {0: 1, 'A': 2, 'C': None}) self.assertIsInstance(wf, MultiChannelWaveform) self.assertEqual(wf.defined_channels, {1, 2})
def setUp(self): self.template = PointPulseTemplate( **PointPulseTemplateSerializationTests().make_kwargs()) self.parameter_sets = [ { 'foo': 1., 'hugo': 2., 'sudo': 3., 'A': 4., 'B': 5., 'a': 6., 'ilse': 7., 'k': 8. }, { 'foo': 1.1, 'hugo': 2.6, 'sudo': 2.7, 'A': np.array([3., 4.]), 'B': 5., 'a': 6., 'ilse': 7., 'k': 8. }, ]
def test_build_waveform_multi_channel_vectorized(self): ppt = PointPulseTemplate([('t1', 'A'), ('t2', 0., 'hold'), ('t1+t2', 'B+C', 'linear')], [0, 'A'], measurements=[('M', 'n', 1), ('L', 'n', 1)]) parameters = { 't1': 0.1, 't2': 1., 'A': np.ones(2), 'B': np.arange(2), 'C': 19., 'n': 0.2 } wf = ppt.build_waveform(parameters=parameters, channel_mapping={ 0: 1, 'A': 'A' }) expected_1 = PointWaveform(1, [(0, 1., HoldInterpolationStrategy()), (0.1, 1., HoldInterpolationStrategy()), (1., 0., HoldInterpolationStrategy()), (1.1, 19., LinearInterpolationStrategy())]) expected_A = PointWaveform('A', [(0, 1., HoldInterpolationStrategy()), (0.1, 1., HoldInterpolationStrategy()), (1., 0., HoldInterpolationStrategy()), (1.1, 20., LinearInterpolationStrategy())]) self.assertEqual(wf.defined_channels, {1, 'A'}) self.assertEqual(wf._sub_waveforms[0].defined_channels, {1}) self.assertEqual(wf._sub_waveforms[0], expected_1) self.assertEqual(wf._sub_waveforms[1].defined_channels, {'A'}) self.assertEqual(wf._sub_waveforms[1], expected_A)
def setUp(self) -> None: self.entries = [('foo', 2, 'hold'), ('hugo', 'A + B', 'linear'), ('sudo', [1, 'a'], 'jump')] self.measurements = [('m', 1, 1), ('foo', 'z', 'o')] self.template = PointPulseTemplate(time_point_tuple_list=self.entries, channel_names=[0, 'A'], measurements=self.measurements, identifier='foo', parameter_constraints=['ilse>2', 'k>foo'], registry=dict()) self.maxDiff = None
def test_build_waveform_single_channel_with_measurements(self): ppt = PointPulseTemplate([('t1', 'A'), ('t2', 0., 'hold'), ('t1+t2', 'B+C', 'linear')], [0], measurements=[('M', 'n', 1), ('L', 'n', 1)]) parameters = {'t1': 0.1, 't2': 1., 'A': 1., 'B': 2., 'C': 19., 'n': 0.2} 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.assertEqual(wf, expected)
def test_requires_stop(self) -> None: point = PointPulseTemplate([('foo', 'v'), ('bar', 0)], [0]) test_sets = [(False, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(False)}), (False, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(True)}), (True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(False)}), (True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(True)}), (True, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(False)}), (True, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(True)}), (True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, True), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(False)}), (True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, True), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(True)})] for expected_result, parameter_set, condition_set in test_sets: self.assertEqual(expected_result, point.requires_stop(parameter_set, condition_set))
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.from_table( 1, [(0, 1., HoldInterpolationStrategy()), (0.1, 1., HoldInterpolationStrategy()), (1., 0., HoldInterpolationStrategy()), (1.1, 21., LinearInterpolationStrategy())]) self.assertIsInstance(wf, PointWaveform) self.assertEqual(wf, expected)
def test_deserialize_old(self) -> None: # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex( DeprecationWarning, "deprecated", msg= "PointPT does not issue warning for old serialization routines." ): data = dict(measurements=self.measurements, time_point_tuple_list=self.entries, channel_names=(0, 'A'), parameter_constraints=['ilse>2', 'k>foo'], identifier='foo') # deserialize serializer = DummySerializer(lambda x: dict(name=x.name), lambda x: x.name, lambda x: x['name']) template = PointPulseTemplate.deserialize(serializer, **data) self.assertEqual(template.point_pulse_entries, self.template.point_pulse_entries) self.assertEqual(template.measurement_declarations, self.template.measurement_declarations) self.assertEqual(template.parameter_constraints, self.template.parameter_constraints)
def test_build_waveform_empty(self): self.assertIsNone( PointPulseTemplate([('t1', 'A')], [0]).build_waveform(parameters={ 't1': 0, 'A': 1 }, channel_mapping={0: 1}))
class PointPulseTemplateOldSerializationTests(unittest.TestCase): def setUp(self) -> None: self.entries = [('foo', 2, 'hold'), ('hugo', 'A + B', 'linear'), ('sudo', [1, 'a'], 'jump')] self.measurements = [('m', 1, 1), ('foo', 'z', 'o')] self.template = PointPulseTemplate(time_point_tuple_list=self.entries, channel_names=[0, 'A'], measurements=self.measurements, identifier='foo', parameter_constraints=['ilse>2', 'k>foo'], registry=dict()) self.maxDiff = None def test_get_serialization_data_old(self) -> None: # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex(DeprecationWarning, "deprecated", msg="PointPT does not issue warning for old serialization routines."): expected_data = dict(measurements=self.measurements, time_point_tuple_list=self.entries, channel_names=(0, 'A'), parameter_constraints=[str(Expression('ilse>2')), str(Expression('k>foo'))]) serializer = DummySerializer(lambda x: dict(name=x.name), lambda x: x.name, lambda x: x['name']) data = self.template.get_serialization_data(serializer) self.assertEqual(expected_data, data) def test_deserialize_old(self) -> None: # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex(DeprecationWarning, "deprecated", msg="PointPT does not issue warning for old serialization routines."): data = dict(measurements=self.measurements, time_point_tuple_list=self.entries, channel_names=(0, 'A'), parameter_constraints=['ilse>2', 'k>foo'], identifier='foo') # deserialize serializer = DummySerializer(lambda x: dict(name=x.name), lambda x: x.name, lambda x: x['name']) template = PointPulseTemplate.deserialize(serializer, **data) self.assertEqual(template.point_pulse_entries, self.template.point_pulse_entries) self.assertEqual(template.measurement_declarations, self.template.measurement_declarations) self.assertEqual(template.parameter_constraints, self.template.parameter_constraints) def test_serializer_integration_old(self): registry = dict() # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex(DeprecationWarning, "deprecated", msg="PointPT does not issue warning for old serialization routines."): serializer = Serializer(DummyStorageBackend()) serializer.serialize(self.template) template = serializer.deserialize('foo') self.assertIsInstance(template, PointPulseTemplate) self.assertEqual(template.point_pulse_entries, self.template.point_pulse_entries) self.assertEqual(template.measurement_declarations, self.template.measurement_declarations) self.assertEqual(template.parameter_constraints, self.template.parameter_constraints)
def test_integral(self) -> None: pulse = PointPulseTemplate( [(1, (2, 'b'), 'linear'), (3, (0, 0), 'jump'), (4, (2, 'c'), 'hold'), (5, (8, 'd'), 'hold')], [0, 'other_channel'] ) self.assertEqual({0: ExpressionScalar('6'), 'other_channel': ExpressionScalar('b + 2*c')}, pulse.integral) pulse = PointPulseTemplate( [(1, ('2', 'b'), 'linear'), ('t0', (0, 0), 'jump'), (4, (2.0, 'c'), 'hold'), ('g', (8, 'd'), 'hold')], ['symbolic', 1] ) self.assertEqual({'symbolic': ExpressionScalar('2.0*g - 1.0*t0 - 1.0'), 1: ExpressionScalar('b*(t0 - 1) / 2 + c*(g - 4) + c*(-t0 + 4)')}, pulse.integral) ppt = PointPulseTemplate([(0, 0), ('t_init', 0)], ['X', 'Y']) self.assertEqual(ppt.integral, {'X': 0, 'Y': 0})
def test_integral(self) -> None: pulse = PointPulseTemplate([(1, (2, 'b'), 'hold'), (3, (0, 0), 'linear'), (4, (2, 'c'), 'jump'), (5, (8, 'd'), 'hold')], [0, 'other_channel']) self.assertEqual( { 0: ExpressionScalar('2 + 6'), 'other_channel': ExpressionScalar('b + b + 2*c') }, pulse.integral) pulse = PointPulseTemplate([(1, ('2', 'b'), 'hold'), ('t0', (0, 0), 'linear'), (4, (2.0, 'c'), 'jump'), ('g', (8, 'd'), 'hold')], ['symbolic', 1]) self.assertEqual( { 'symbolic': ExpressionScalar('2 + 2.0*g - 1.0*t0 - 1.0'), 1: ExpressionScalar( 'b + b*(t0 - 1) / 2 + c*(g - 4) + c*(-t0 + 4)') }, pulse.integral) ppt = PointPulseTemplate([(0, 0), ('t_init', 0)], ['X', 'Y']) self.assertEqual(ppt.integral, {'X': 0, 'Y': 0}) ppt = PointPulseTemplate([(0., 'a'), ('t_1', 'b', 'linear'), ('t_2', (0, 0))], ('X', 'Y')) parameters = {'a': (3.4, 4.1), 'b': 4, 't_1': 2, 't_2': 5} integral = { ch: v.evaluate_in_scope(parameters) for ch, v in ppt.integral.items() } self.assertEqual( { 'X': 2 * (3.4 + 4) / 2 + (5 - 2) * 4, 'Y': 2 * (4.1 + 4) / 2 + (5 - 2) * 4 }, integral)
def test_integral(self) -> None: pulse = PointPulseTemplate([(1, (2, 'b'), 'linear'), (3, (0, 0), 'jump'), (4, (2, 'c'), 'hold'), (5, (8, 'd'), 'hold')], [0, 'other_channel']) self.assertEqual( { 0: ExpressionScalar(6), 'other_channel': ExpressionScalar('1.0*b + 2.0*c') }, pulse.integral) pulse = PointPulseTemplate([(1, ('2', 'b'), 'linear'), ('t0', (0, 0), 'jump'), (4, (2, 'c'), 'hold'), ('g', (8, 'd'), 'hold')], ['symbolic', 1]) self.assertEqual( { 'symbolic': ExpressionScalar('2.0*g - t0 - 1.0'), 1: ExpressionScalar( 'b*(0.5*t0 - 0.5) + c*(g - 4.0) + c*(-t0 + 4.0)') }, pulse.integral)
def test_requires_stop_missing_param(self) -> None: table = PointPulseTemplate([('foo', 'v')], [0]) with self.assertRaises(ParameterNotProvidedException): table.requires_stop({'foo': DummyParameter(0, False)}, {})
def test_parameter_names(self): self.assertEqual({'a', 'b', 'n', 'A', 'B', 't', 'C'}, PointPulseTemplate([(1, 'A'), ('t+6', 'B+C')], [0, 'asd'], measurements=[('M', 'n', 1)], parameter_constraints=['a < b']).parameter_names)
def test_point_parameters(self): self.assertEqual(PointPulseTemplate([(1, 'A'), ('t+6', 'B+C')], [0, 'asd']).point_parameters, {'A', 'B', 't', 'C'})
def test_duration(self): self.assertEqual(PointPulseTemplate([(1, 'A')], [0]).duration, 1) self.assertEqual(PointPulseTemplate([(1, 'A'), ('t+6', 'B')], [0, 'asd']).duration, 't+6')
def tpt_constructor(measurements=None): return PointPulseTemplate([('t', 'V', 'hold')], channel_names=[0], parameter_constraints=['a < b'], measurements=measurements)
def ppt_constructor(parameter_constraints=None): return PointPulseTemplate([('t', 'V', 'hold')], channel_names=[0], parameter_constraints=parameter_constraints, measurements=[('M', 'n', 1)])
class PointPulseExpressionIntegralTests(unittest.TestCase): def setUp(self): self.template = PointPulseTemplate( **PointPulseTemplateSerializationTests().make_kwargs()) self.parameter_sets = [ { 'foo': 1., 'hugo': 2., 'sudo': 3., 'A': 4., 'B': 5., 'a': 6., 'ilse': 7., 'k': 8. }, { 'foo': 1.1, 'hugo': 2.6, 'sudo': 2.7, 'A': np.array([3., 4.]), 'B': 5., 'a': 6., 'ilse': 7., 'k': 8. }, ] def test_integral_as_expression_compatible(self): import sympy t = self.template._AS_EXPRESSION_TIME as_expression = self.template._as_expression() integral = self.template.integral duration = self.template.duration.underlying_expression self.assertEqual(self.template.defined_channels, integral.keys()) self.assertEqual(self.template.defined_channels, as_expression.keys()) for channel in self.template.defined_channels: ch_expr = as_expression[channel].underlying_expression ch_int = integral[channel].underlying_expression symbolic = sympy.integrate(ch_expr, (t, 0, duration)) symbolic = sympy.simplify(symbolic) scalar_from_as_expr = ExpressionScalar(symbolic) scalar_from_integral = ExpressionScalar(ch_int) for parameters in self.parameter_sets: num_from_expr = scalar_from_as_expr.evaluate_in_scope( parameters) num_from_in = scalar_from_integral.evaluate_in_scope( parameters) np.testing.assert_almost_equal(num_from_in, num_from_expr) # TODO: the following fails even with a lot of assumptions in sympy 1.6 # self.assertEqual(ch_int, symbolic) def test_as_expression_wf_and_sample_compatible(self): as_expression = self.template._as_expression() for parameters in self.parameter_sets: wf = self.template.build_waveform( parameters, {c: c for c in self.template.defined_channels}) ts = np.linspace(0, float(wf.duration), num=33) sampled = { ch: wf.get_sampled(ch, ts) for ch in self.template.defined_channels } from_expr = {} for ch, expected_vs in sampled.items(): ch_expr = as_expression[ch] ch_from_expr = [] for t, expected in zip(ts, expected_vs): result_expr = ch_expr.evaluate_symbolic({ **parameters, self.template._AS_EXPRESSION_TIME: t }) ch_from_expr.append(result_expr.sympified_expression) from_expr[ch] = ch_from_expr np.testing.assert_almost_equal(expected_vs, ch_from_expr)