def make_kwargs(self): return { 'entries': dict(A=[('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')], B=[(0, 5, 'hold'), (1, 7, 'jump'), ('k', 't', 'hold')]), 'measurements': [('m', 1, 1), ('foo', 'z', 'o')], 'parameter_constraints': [str(ParameterConstraint('ilse>2')), str(ParameterConstraint('k>foo'))] }
def test_ordering(self): constraint = ParameterConstraint('a <= b') self.assertEqual(constraint.affected_parameters, {'a', 'b'}) self.assertTrue(constraint.is_fulfilled(dict(a=1, b=2))) self.assertTrue(constraint.is_fulfilled(dict(a=2, b=2))) self.assertFalse(constraint.is_fulfilled(dict(a=2, b=1)))
def test_get_serialization_data(self) -> None: # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex(DeprecationWarning, "deprecated", msg="SequencePT does not issue warning for old serialization routines."): dummy_pt = DummyPulseTemplate(defined_channels={'foo'}, measurement_names={'meas'}, parameter_names={'hugo', 'herbert', 'ilse'}) mpt = MappingPulseTemplate( template=dummy_pt, parameter_mapping={'hugo': Expression('2*k+c'), 'herbert': Expression('c-1.5'), 'ilse': Expression('ilse')}, measurement_mapping={'meas': 'seam'}, channel_mapping={'foo': 'default_channel'}, parameter_constraints=[str(ParameterConstraint('c > 0'))] ) serializer = DummySerializer() expected_data = { 'template': serializer.dictify(dummy_pt), 'parameter_mapping': {'hugo': str(Expression('2*k+c')), 'herbert': str(Expression('c-1.5')), 'ilse': str(Expression('ilse'))}, 'measurement_mapping': {'meas': 'seam'}, 'channel_mapping': {'foo': 'default_channel'}, 'parameter_constraints': [str(ParameterConstraint('c > 0'))] } data = mpt.get_serialization_data(serializer=serializer) self.assertEqual(expected_data, data)
def make_kwargs(self): return { 'time_point_tuple_list': [('foo', 2, 'hold'), ('hugo', 'A + B', 'linear'), ('sudo', [1, 'a'], 'jump')], 'channel_names': (0, 'A'), 'measurements': [('m', 1, 1), ('foo', 'z', 'o')], 'parameter_constraints': [str(ParameterConstraint('ilse>2')), str(ParameterConstraint('k>foo'))] }
def test_str_and_serialization(self): self.assertEqual(str(ParameterConstraint('a < b')), 'a < b') self.assertEqual( ParameterConstraint('a < b').get_serialization_data(), 'a < b') self.assertEqual(str(ParameterConstraint('a==b')), 'a==b') self.assertEqual( ParameterConstraint('a==b').get_serialization_data(), 'a==b')
def test_parameter_constraints(self): to_test = self.to_test_constructor() self.assertEqual(to_test.parameter_constraints, []) to_test = self.to_test_constructor(['a < b']) self.assertEqual(to_test.parameter_constraints, [ParameterConstraint('a < b')]) to_test = self.to_test_constructor(['a < b', 'c < 1']) self.assertEqual(to_test.parameter_constraints, [ParameterConstraint('a < b'), ParameterConstraint('c < 1')])
def make_kwargs(self): return { 'expression': Expression('a + b * t'), 'duration_expression': Expression('c'), 'channel': 'A', 'measurements': [('mw', 1, 1), ('mw', 'x', 'z'), ('drup', 'j', 'u')], 'parameter_constraints': [str(ParameterConstraint('a < b')), str(ParameterConstraint('c > 1')), str(ParameterConstraint('d > c'))] }
def make_kwargs(self): return { 'subtemplates': [ DummyPulseTemplate(duration='t1', defined_channels={'A'}, parameter_names={'a', 'b'}), DummyPulseTemplate(duration='t1', defined_channels={'B'}, parameter_names={'a', 'c'}) ], 'parameter_constraints': [ str(ParameterConstraint('ilse>2')), str(ParameterConstraint('k>foo')) ] }
def test_deserialize_all_features_old(self) -> None: # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex( DeprecationWarning, "deprecated", msg= "RepetitionPT does not issue warning for old serialization routines." ): serializer = DummySerializer( deserialize_callback=lambda x: x['name']) body = DummyPulseTemplate() data = dict(repetition_count='foo', body=dict(name=str(id(body))), identifier='foo', parameter_constraints=['foo < 3'], measurements=[('a', 0, 1), ('b', 1, 1)]) # prepare dependencies for deserialization serializer.subelements[str(id(body))] = body # deserialize template = RepetitionPulseTemplate.deserialize(serializer, **data) # compare! self.assertIs(body, template.body) self.assertEqual('foo', template.repetition_count) self.assertEqual(template.parameter_constraints, [ParameterConstraint('foo < 3')]) self.assertEqual(template.measurement_declarations, data['measurements'])
def make_kwargs(self): return { 'subtemplates': [DummyPulseTemplate(), DummyPulseTemplate()], 'parameter_constraints': [str(ParameterConstraint('a<b'))], 'measurements': [('m', 0, 1)] }
def test_deserialize_old(self) -> None: # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex(DeprecationWarning, "deprecated", msg="AtomicMultiChannelPT does not issue warning for old serialization routines."): sts = [DummyPulseTemplate(duration='t1', defined_channels={'A'}, parameter_names={'a', 'b'}), DummyPulseTemplate(duration='t1', defined_channels={'B'}, parameter_names={'a', 'c'})] def deserialization_callback(ident: str): self.assertIn(ident, ('0', '1')) if ident == '0': return 0 else: return 1 serializer = DummySerializer(deserialize_callback=deserialization_callback) serializer.subelements = sts data = dict(subtemplates=['0', '1'], parameter_constraints=['a < d']) template = AtomicMultiChannelPulseTemplate.deserialize(serializer, **data) self.assertIs(template.subtemplates[0], sts[0]) self.assertIs(template.subtemplates[1], sts[1]) self.assertEqual(template.parameter_constraints, [ParameterConstraint('a < d')])
def test_deserialize_old(self) -> None: # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex( DeprecationWarning, "deprecated", msg= "SequencePT does not issue warning for old serialization routines." ): dummy1 = DummyPulseTemplate() dummy2 = DummyPulseTemplate() serializer = DummySerializer( serialize_callback=lambda x: str(id(x))) data = dict(subtemplates=[ serializer.dictify(dummy1), serializer.dictify(dummy2) ], identifier='foo', parameter_constraints=['a < b'], measurements=[('m', 0, 1)]) template = SequencePulseTemplate.deserialize(serializer, **data) self.assertEqual(template.subtemplates, [dummy1, dummy2]) self.assertEqual(template.parameter_constraints, [ParameterConstraint('a<b')]) self.assertEqual(template.measurement_declarations, [('m', 0, 1)])
def make_kwargs(self): return { 'body': DummyPulseTemplate(), 'repetition_count': 3, 'parameter_constraints': [str(ParameterConstraint('a<b'))], 'measurements': [('m', 0, 1)] }
def make_kwargs(self): return { 'body': DummyPulseTemplate(parameter_names={'i'}), 'loop_index': 'i', 'loop_range': ('A', 'B', 1), 'parameter_constraints': [str(ParameterConstraint('foo < 3'))], 'measurements': [('a', 0, 1), ('b', 1, 1)] }
def make_kwargs(self): return { 'template': DummyPulseTemplate(defined_channels={'foo'}, measurement_names={'meas'}, parameter_names={'hugo', 'herbert', 'ilse'}), 'parameter_mapping': {'hugo': Expression('2*k+c'), 'herbert': Expression('c-1.5'), 'ilse': Expression('ilse')}, 'measurement_mapping': {'meas': 'seam'}, 'channel_mapping': {'foo': 'default_channel'}, 'parameter_constraints': [str(ParameterConstraint('c > 0'))] }
def test_deserialize(self) -> None: # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex( DeprecationWarning, "deprecated", msg= "SequencePT does not issue warning for old serialization routines." ): dummy_pt = DummyPulseTemplate( defined_channels={'foo'}, measurement_names={'meas'}, parameter_names={'hugo', 'herbert', 'ilse'}) serializer = DummySerializer() data = { 'template': serializer.dictify(dummy_pt), 'parameter_mapping': { 'hugo': str(Expression('2*k+c')), 'herbert': str(Expression('c-1.5')), 'ilse': str(Expression('ilse')) }, 'measurement_mapping': { 'meas': 'seam' }, 'channel_mapping': { 'foo': 'default_channel' }, 'parameter_constraints': [str(ParameterConstraint('c > 0'))] } deserialized = MappingPulseTemplate.deserialize( serializer=serializer, **data) self.assertIsInstance(deserialized, MappingPulseTemplate) self.assertEqual(data['parameter_mapping'], deserialized.parameter_mapping) self.assertEqual(data['channel_mapping'], deserialized.channel_mapping) self.assertEqual(data['measurement_mapping'], deserialized.measurement_mapping) self.assertEqual( data['parameter_constraints'], [str(pc) for pc in deserialized.parameter_constraints]) self.assertIs(deserialized.template, dummy_pt)
def test_repr(self): pc = ParameterConstraint('a < b') self.assertEqual("ParameterConstraint('a < b')", repr(pc))
def test_no_relation(self): with self.assertRaises(ValueError): ParameterConstraint('a*b') ParameterConstraint('1 < 2')
def test_expressions(self): constraint = ParameterConstraint('Max(a, b) < a*c') self.assertEqual(constraint.affected_parameters, {'a', 'b', 'c'}) self.assertTrue(constraint.is_fulfilled(dict(a=2, b=2, c=3))) self.assertFalse(constraint.is_fulfilled(dict(a=3, b=5, c=1)))
def test_str(self): self.assertEqual(str(ParameterConstraint('a < b')), 'a < b') self.assertEqual(str(ParameterConstraint('a==b')), 'a==b')