def test_measurement_windows(self) -> None: pulse = FunctionPulseTemplate(5, 5, measurements=[('mw', 0, 5)]) windows = pulse.get_measurement_windows( parameters={}, measurement_mapping={'mw': 'asd'}) self.assertEqual([('asd', 0, 5)], windows) self.assertEqual(pulse.measurement_declarations, [('mw', 0, 5)])
def setUp(self) -> None: self.maxDiff = None self.s = 'a + b * t' self.s2 = 'c' self.fpt = FunctionPulseTemplate(self.s, self.s2) self.pars = dict(a=DummyParameter(1), b=DummyParameter(2), c=DummyParameter(136.78))
def test_measurement_windows_with_parameters(self) -> None: pulse = FunctionPulseTemplate(5, 'length', measurements=[('mw', 1, '(1+length)/2')]) parameters = dict(length=100) windows = pulse.get_measurement_windows( parameters, measurement_mapping={'mw': 'asd'}) self.assertEqual(windows, [('asd', 1, 101 / 2)]) declared = pulse.measurement_declarations self.assertEqual(declared, [('mw', 1, '(1+length)/2')])
class FunctionPulseSequencingTest(unittest.TestCase): def setUp(self): unittest.TestCase.setUp(self) self.f = "a * t" self.duration = "y" self.args = dict(a=3,y=1) self.fpt = FunctionPulseTemplate(self.f, self.duration) def test_build_sequence(self): ib = InstructionBlock() seq = Sequencer() cond = None self.fpt.build_sequence(seq, self.args, cond, ib)
def test_multiple_measurement_windows(self) -> None: pulse = FunctionPulseTemplate(5, 'length', measurements=[('A', 0, '(1+length)/2'), ('A', 1, 3), ('B', 'begin', 2)]) parameters = dict(length=5, begin=1) measurement_mapping = dict(A='A', B='C') windows = pulse.get_measurement_windows( parameters=parameters, measurement_mapping=measurement_mapping) expected = [('A', 0, 3), ('A', 1, 3), ('C', 1, 2)] self.assertEqual(sorted(windows), sorted(expected)) self.assertEqual(pulse.measurement_declarations, [('A', 0, '(1+length)/2'), ('A', 1, 3), ('B', 'begin', 2)])
def test_parameter_names_and_declarations_string_input(self) -> None: template = FunctionPulseTemplate("3 * foo + bar * t", "5 * hugo") expected_parameter_names = {'foo', 'bar', 'hugo'} self.assertEqual(expected_parameter_names, template.parameter_names) self.assertEqual( {ParameterDeclaration(name) for name in expected_parameter_names}, template.parameter_declarations)
class FunctionPulseTest(unittest.TestCase): def setUp(self): self.s = 'a + b' self.s2 = 'c' self.pars = dict(a=1, b=2, c=3) self.fpt = FunctionPulseTemplate(self.s, self.s2) def test_get_pulse_length(self): self.assertEqual(self.fpt.get_pulse_length(self.pars), 3) def test_get_measurement_windows(self): self.assertEqual(self.fpt.get_measurement_windows(self.pars), None) fpt2 = FunctionPulseTemplate(self.s, self.s2, measurement=True) self.assertEqual(fpt2.get_measurement_windows(self.pars), [(0, 3)]) def test_serialization_data(self): expected_data = dict(type='FunctionPulseTemplate', parameter_names=set(['a', 'b', 'c']), duration_expression=self.s2, expression=self.s, measurement=False) self.assertEqual(expected_data, self.fpt.get_serialization_data(DummySerializer()))
class FunctionPulseSequencingTest(unittest.TestCase): def setUp(self) -> None: unittest.TestCase.setUp(self) self.f = "a * t" self.duration = "y" self.args = dict(a=DummyParameter(3), y=DummyParameter(1)) self.fpt = FunctionPulseTemplate(self.f, self.duration) def test_build_waveform(self) -> None: wf = self.fpt.build_waveform(self.args) self.assertIsNotNone(wf) self.assertIsInstance(wf, FunctionWaveform) expected_waveform = FunctionWaveform(dict(a=3, y=1), Expression(self.f), Expression(self.duration)) self.assertEqual(expected_waveform, wf) def test_requires_stop(self) -> None: parameters = dict(a=DummyParameter(36.126), y=DummyParameter(247.9543)) self.assertFalse(self.fpt.requires_stop(parameters, dict())) parameters = dict(a=DummyParameter(36.126), y=DummyParameter(247.9543, requires_stop=True)) self.assertTrue(self.fpt.requires_stop(parameters, dict()))
def test_deserialize(self) -> None: basic_data = dict(duration_expression=str(self.s2), expression=str(self.s), measurement=False, identifier='hugo') serializer = DummySerializer(serialize_callback=lambda x: str(x)) serializer.subelements[str(self.s2)] = Expression(self.s2) serializer.subelements[str(self.s)] = Expression(self.s) template = FunctionPulseTemplate.deserialize(serializer, **basic_data) self.assertEqual('hugo', template.identifier) self.assertEqual({'a', 'b', 'c'}, template.parameter_names) self.assertEqual( {ParameterDeclaration(name) for name in {'a', 'b', 'c'}}, template.parameter_declarations) serialized_data = template.get_serialization_data(serializer) del basic_data['identifier'] self.assertEqual(basic_data, serialized_data)
def test_deserialize(self) -> None: basic_data = dict(duration_expression=str(self.s2), expression=self.s, channel='A', identifier='hugo', measurement_declarations=self.meas_list, parameter_constraints=self.constraints) serializer = DummySerializer( serialize_callback=lambda x: x.original_expression) serializer.subelements[self.s2] = Expression(self.s2) serializer.subelements[self.s] = Expression(self.s) template = FunctionPulseTemplate.deserialize(serializer, **basic_data) self.assertEqual('hugo', template.identifier) self.assertEqual({'a', 'b', 'c', 'x', 'z', 'j', 'u', 'd'}, template.parameter_names) self.assertEqual(template.measurement_declarations, self.meas_list) serialized_data = template.get_serialization_data(serializer) del basic_data['identifier'] self.assertEqual(basic_data, serialized_data)
def test_serializer_integration(self): before = FunctionPulseTemplate(expression=self.s, duration_expression=self.s2, channel='A', measurements=self.meas_list, parameter_constraints=self.constraints, identifier='my_tpt') serializer = Serializer(DummyStorageBackend()) serializer.serialize(before) after = serializer.deserialize('my_tpt') self.assertIsInstance(after, FunctionPulseTemplate) self.assertEqual(before.expression, after.expression) self.assertEqual(before.duration, after.duration) self.assertEqual(before.defined_channels, after.defined_channels) self.assertEqual(before.measurement_declarations, after.measurement_declarations) self.assertEqual(before.parameter_constraints, after.parameter_constraints)
def setUp(self) -> None: self.maxDiff = None self.s = 'a + b * t' self.s2 = 'c' self.meas_list = [('mw', 1, 1), ('mw', 'x', 'z'), ('drup', 'j', 'u')] self.constraints = ['a < b', 'c > 1', 'd > c'] self.valid_par_vals = dict(a=1, b=2, c=14.5, d=15, x=0.1, z=0.2, j=0.3, u=0.4) self.invalid_par_vals = dict(a=1, b=2, c=14.5, d=14, x=0.1, z=0.2, j=0.3, u=0.4) self.fpt = FunctionPulseTemplate( self.s, self.s2, channel='A', measurements=self.meas_list, parameter_constraints=self.constraints) self.pars = dict(a=DummyParameter(1), b=DummyParameter(2), c=DummyParameter(136.78))
def test_get_measurement_windows(self): self.assertEqual(self.fpt.get_measurement_windows(self.pars), None) fpt2 = FunctionPulseTemplate(self.s, self.s2, measurement=True) self.assertEqual(fpt2.get_measurement_windows(self.pars), [(0, 3)])
def setUp(self): unittest.TestCase.setUp(self) self.f = "a * t" self.duration = "y" self.args = dict(a=3,y=1) self.fpt = FunctionPulseTemplate(self.f, self.duration)
class FunctionPulseTest(unittest.TestCase): def setUp(self) -> None: self.maxDiff = None self.s = 'a + b * t' self.s2 = 'c' self.fpt = FunctionPulseTemplate(self.s, self.s2) self.pars = dict(a=DummyParameter(1), b=DummyParameter(2), c=DummyParameter(136.78)) def test_get_pulse_length(self) -> None: self.assertEqual(136.78, self.fpt.get_pulse_length(self.pars)) def test_get_pulse_length_missing_parameter(self) -> None: with self.assertRaises(ParameterNotProvidedException): self.fpt.get_pulse_length(dict(b=DummyParameter(26.3267))) def test_is_interruptable(self) -> None: self.assertFalse(self.fpt.is_interruptable) def test_num_channels(self) -> None: self.assertEqual(1, self.fpt.num_channels) def test_parameter_names_and_declarations_expression_input(self) -> None: template = FunctionPulseTemplate(Expression("3 * foo + bar * t"), Expression("5 * hugo")) expected_parameter_names = {'foo', 'bar', 'hugo'} self.assertEqual(expected_parameter_names, template.parameter_names) self.assertEqual( {ParameterDeclaration(name) for name in expected_parameter_names}, template.parameter_declarations) def test_parameter_names_and_declarations_string_input(self) -> None: template = FunctionPulseTemplate("3 * foo + bar * t", "5 * hugo") expected_parameter_names = {'foo', 'bar', 'hugo'} self.assertEqual(expected_parameter_names, template.parameter_names) self.assertEqual( {ParameterDeclaration(name) for name in expected_parameter_names}, template.parameter_declarations) def test_serialization_data(self) -> None: expected_data = dict(duration_expression=str(self.s2), expression=str(self.s), measurement=False) self.assertEqual( expected_data, self.fpt.get_serialization_data( DummySerializer(serialize_callback=lambda x: str(x)))) def test_deserialize(self) -> None: basic_data = dict(duration_expression=str(self.s2), expression=str(self.s), measurement=False, identifier='hugo') serializer = DummySerializer(serialize_callback=lambda x: str(x)) serializer.subelements[str(self.s2)] = Expression(self.s2) serializer.subelements[str(self.s)] = Expression(self.s) template = FunctionPulseTemplate.deserialize(serializer, **basic_data) self.assertEqual('hugo', template.identifier) self.assertEqual({'a', 'b', 'c'}, template.parameter_names) self.assertEqual( {ParameterDeclaration(name) for name in {'a', 'b', 'c'}}, template.parameter_declarations) serialized_data = template.get_serialization_data(serializer) del basic_data['identifier'] self.assertEqual(basic_data, serialized_data)
def test_parameter_names_and_declarations_string_input(self) -> None: template = FunctionPulseTemplate("3 * foo + bar * t", "5 * hugo", channel='A') expected_parameter_names = {'foo', 'bar', 'hugo'} self.assertEqual(expected_parameter_names, template.parameter_names)
def test_parameter_names_and_declarations_expression_input(self) -> None: template = FunctionPulseTemplate(Expression("3 * foo + bar * t"), Expression("5 * hugo")) expected_parameter_names = {'foo', 'bar', 'hugo'} self.assertEqual(expected_parameter_names, template.parameter_names)
def setUp(self): self.s = 'a + b' self.s2 = 'c' self.pars = dict(a=1, b=2, c=3) self.fpt = FunctionPulseTemplate(self.s, self.s2)
def tpt_constructor(measurements=None): return FunctionPulseTemplate('a*t', 'duration', parameter_constraints=['a < b'], measurements=measurements)
def tpt_constructor(parameter_constraints=None): return FunctionPulseTemplate( 'a*t', 'duration', parameter_constraints=parameter_constraints, measurements=[('M', 'n', 1)])
def setUp(self) -> None: unittest.TestCase.setUp(self) self.f = "a * t" self.duration = "y" self.args = dict(a=DummyParameter(3), y=DummyParameter(1)) self.fpt = FunctionPulseTemplate(self.f, self.duration)
def test_no_measurement_windows(self) -> None: pulse = FunctionPulseTemplate(5, 5) windows = pulse.get_measurement_windows({}, {'mw': 'asd'}) self.assertEqual([], windows) self.assertEqual([], pulse.measurement_declarations)