def test_plot_with_parameter_value_being_expression_string(self) -> None:
"""This is currently not supported but probably should be?"""
sine_measurements = [('M', 't_duration/2', 't_duration')]
sine = FunctionPulseTemplate('a*sin(omega*t)',
't_duration',
measurements=sine_measurements)
sine_channel_mapping = dict(default='sin_channel')
sine_measurement_mapping = dict(M='M_sin')
remapped_sine = MappingPulseTemplate(
sine,
measurement_mapping=sine_measurement_mapping,
channel_mapping=sine_channel_mapping)
cos_measurements = [('M', 0, 't_duration/2')]
cos = FunctionPulseTemplate('a*cos(omega*t)',
't_duration',
measurements=cos_measurements)
cos_channel_mapping = dict(default='cos_channel')
cos_measurement_mapping = dict(M='M_cos')
remapped_cos = MappingPulseTemplate(
cos,
channel_mapping=cos_channel_mapping,
measurement_mapping=cos_measurement_mapping)
both = AtomicMultiChannelPulseTemplate(remapped_sine, remapped_cos)
parameter_values = dict(omega=1.0, a=1.0, t_duration="2*pi")
_ = plot(both, parameters=parameter_values, sample_rate=100)
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 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')])
def test_parameter_names(self):
fpt = FunctionPulseTemplate('k*r*sin(x)',
'1.14*d',
parameter_constraints={'x < hugo'},
measurements=[('meas', 'f', 1)])
self.assertEqual(fpt.parameter_names,
{'k', 'r', 'x', 'd', 'hugo', 'f'})
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_serializer_integration_old(self):
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"FunctionPT does not issue warning for old serialization routines."
):
before = FunctionPulseTemplate(
expression=self.s,
duration_expression=self.s2,
channel='A',
measurements=self.meas_list,
parameter_constraints=self.constraints,
identifier='my_tpt',
registry=dict())
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 test_deserialize_old(self) -> None:
# test for deprecated version during transition period, remove after final switch
with self.assertWarnsRegex(
DeprecationWarning,
"deprecated",
msg=
"FunctionPT does not issue warning for old serialization routines."
):
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 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_issue_612_for_loop_duration(self):
fpt = FunctionPulseTemplate('sin(2*pi*i*t*f)', '1/f')
pt = ForLoopPulseTemplate(fpt, 'i', 'floor(total_time*f)')
self.assertEqual((500 + 501) // 2,
pt.duration.evaluate_in_scope({
'f': 1.,
'total_time': 500
}))
def test_plotting_two_channel_function_pulse_after_two_channel_table_pulse_crash(
self) -> None:
""" successful if no crash -> no asserts """
template = TablePulseTemplate(entries={
'A': [(0, 0), ('ta', 'va', 'hold'), ('tb', 'vb', 'linear'),
('tend', 0, 'jump')],
'B': [(0, 0), ('ta', '-va', 'hold'), ('tb', '-vb', 'linear'),
('tend', 0, 'jump')]
},
measurements=[('m', 0, 'ta'),
('n', 'tb', 'tend-tb')])
parameters = {
'ta': 2,
'va': 2,
'tb': 4,
'vb': 3,
'tc': 5,
'td': 11,
'tend': 6
}
_ = plot(template,
parameters,
sample_rate=100,
show=False,
plot_measurements={'m', 'n'})
repeated_template = RepetitionPulseTemplate(template, 'n_rep')
sine_template = FunctionPulseTemplate('sin_a*sin(t)', '2*3.1415')
two_channel_sine_template = AtomicMultiChannelPulseTemplate(
(sine_template, {
'default': 'A'
}), (sine_template, {
'default': 'B'
}, {
'sin_a': 'sin_b'
}))
sequence_template = SequencePulseTemplate(repeated_template,
two_channel_sine_template)
#sequence_template = SequencePulseTemplate(two_channel_sine_template, repeated_template) # this was working fine
sequence_parameters = dict(
parameters) # we just copy our parameter dict from before
sequence_parameters[
'n_rep'] = 4 # and add a few new values for the new params from the sine wave
sequence_parameters['sin_a'] = 1
sequence_parameters['sin_b'] = 2
_ = plot(sequence_template,
parameters=sequence_parameters,
sample_rate=100,
show=False)
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 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)
def tpt_constructor(measurements=None):
return FunctionPulseTemplate('a*t',
'duration',
parameter_constraints=['a < b'],
measurements=measurements)
def test_as_expression(self):
pulse = FunctionPulseTemplate('sin(0.5*t+b)', '2*Tmax')
expr = sympy.sin(0.5 * pulse._AS_EXPRESSION_TIME + sympy.sympify('b'))
self.assertEqual({'default': Expression.make(expr)},
pulse._as_expression())
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_integral(self) -> None:
pulse = FunctionPulseTemplate('sin(0.5*t+b)', '2*Tmax')
self.assertEqual(
{'default': Expression('2.0*cos(b) - 2.0*cos(1.0*Tmax+b)')},
pulse.integral)
def tpt_constructor(parameter_constraints=None):
return FunctionPulseTemplate(
'a*t',
'duration',
parameter_constraints=parameter_constraints,
measurements=[('M', 'n', 1)])
