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)
