def __init__(self, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
# Setup test data
self.square = TablePulseTemplate()
self.square.add_entry('up', 'v', 'hold')
self.square.add_entry('down', 0, 'hold')
self.square.add_entry('length', 0)
self.mapping1 = {
'up': 'uptime',
'down': 'uptime + length',
'v': 'voltage',
'length': '0.5 * pulse_length'
}
self.outer_parameters = ['uptime', 'length', 'pulse_length', 'voltage']
self.parameters = {}
self.parameters['uptime'] = ConstantParameter(5)
self.parameters['length'] = ConstantParameter(10)
self.parameters['pulse_length'] = ConstantParameter(100)
self.parameters['voltage'] = ConstantParameter(10)
self.sequence = SequencePulseTemplate([(self.square, self.mapping1)],
self.outer_parameters)
def test_build_path_o2_m2_i0_i1_t_m2_i0_i0_one_element_custom_block(
self) -> None:
sequencer = Sequencer()
ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)}
cs = {'foo': DummyCondition()}
wm = {'foo': 'bar'}
cm = {'A': 'B'}
target_block = InstructionBlock()
elem = DummySequencingElement(False)
sequencer.push(elem,
ps,
cs,
window_mapping=wm,
channel_mapping=cm,
target_block=target_block)
sequencer.build()
self.assertTrue(sequencer.has_finished())
self.assertIs(target_block, elem.target_block)
self.assertEqual(ps, elem.parameters)
self.assertEqual(cs, elem.conditions)
self.assertEqual(wm, elem.window_mapping)
self.assertEqual(cm, elem.channel_mapping)
self.assertEqual(1, elem.requires_stop_call_counter)
self.assertEqual(1, elem.build_call_counter)
def test_build_path_o2_m1_i2_tt_m1_i0_two_elements_main_block(
self) -> None:
sequencer = Sequencer()
ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)}
cs = {'foo': DummyCondition()}
elem1 = DummySequencingElement(False)
elem2 = DummySequencingElement(False)
sequencer.push(elem2, ps, cs)
sequencer.push(elem1, ps, cs)
sequence = sequencer.build()
self.assertTrue(sequencer.has_finished())
self.assertIs(elem1, sequence[0].elem)
self.assertEqual(ps, elem1.parameters)
self.assertEqual(cs, elem1.conditions)
self.assertEqual(1, elem1.requires_stop_call_counter)
self.assertEqual(1, elem1.build_call_counter)
self.assertIs(elem2, sequence[1].elem)
self.assertEqual(ps, elem2.parameters)
self.assertEqual(cs, elem2.conditions)
self.assertEqual(1, elem2.requires_stop_call_counter)
self.assertEqual(1, elem2.build_call_counter)
self.assertEqual(STOPInstruction(), sequence[2])
self.assertEqual(3, len(sequence))
def __init__(self, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
# Setup test data
self.square = TablePulseTemplate(
{
'default': [(0, 0), ('up', 'v', 'hold'), ('down', 0, 'hold'),
('length', 0)]
},
measurements=[('mw1', 'up', 'length-up')])
self.mapping1 = {
'up': 'uptime',
'down': 'uptime + length',
'v': 'voltage',
'length': '0.5 * pulse_length'
}
self.window_name_mapping = {'mw1': 'test_window'}
self.outer_parameters = {'uptime', 'length', 'pulse_length', 'voltage'}
self.parameters = dict()
self.parameters['uptime'] = ConstantParameter(5)
self.parameters['length'] = ConstantParameter(10)
self.parameters['pulse_length'] = ConstantParameter(100)
self.parameters['voltage'] = ConstantParameter(10)
self.sequence = SequencePulseTemplate(
MappingPulseTemplate(self.square,
parameter_mapping=self.mapping1,
measurement_mapping=self.window_name_mapping),
external_parameters=self.outer_parameters)
def test_build_path_o2_m2_i1_t_i1_t_m2_i0_i0_one_element_custom_block_one_element_main_block(
self) -> None:
sequencer = Sequencer()
ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)}
cs = {'foo': DummyCondition()}
elem_main = DummySequencingElement(False)
sequencer.push(elem_main, ps, cs)
target_block = InstructionBlock()
elem_cstm = DummySequencingElement(False)
sequencer.push(elem_cstm, ps, cs, target_block)
sequence = sequencer.build()
self.assertTrue(sequencer.has_finished())
self.assertIs(elem_main, sequence[0].elem)
self.assertEqual(ps, elem_main.parameters)
self.assertEqual(cs, elem_main.conditions)
self.assertEqual(1, elem_main.requires_stop_call_counter)
self.assertEqual(1, elem_main.build_call_counter)
self.assertIs(target_block, elem_cstm.target_block)
self.assertEqual(ps, elem_cstm.parameters)
self.assertEqual(cs, elem_cstm.conditions)
self.assertEqual(1, elem_cstm.requires_stop_call_counter)
self.assertEqual(1, elem_cstm.build_call_counter)
self.assertEqual(STOPInstruction(), sequence[1])
self.assertEqual(2, len(sequence))
def test_build_path_o2_m1_i2_tf_m2_i1_f_i1_f_two_elements_main_block_last_requires_stop_add_one_element_requires_stop_new_block(
self) -> None:
sequencer = Sequencer()
ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)}
cs = {'foo': DummyCondition()}
new_block = InstructionBlock()
new_elem = DummySequencingElement(True)
elem1 = DummySequencingElement(False, (new_block, [new_elem]))
elem2 = DummySequencingElement(True)
sequencer.push(elem2, ps, cs)
sequencer.push(elem1, ps, cs)
sequence = sequencer.build()
self.assertFalse(sequencer.has_finished())
self.assertIs(elem1, sequence[0].elem)
self.assertEqual(ps, elem1.parameters)
self.assertEqual(cs, elem1.conditions)
self.assertEqual(1, elem1.requires_stop_call_counter)
self.assertEqual(1, elem1.build_call_counter)
self.assertEqual(ps, elem2.parameters)
self.assertEqual(cs, elem2.conditions)
self.assertEqual(2, elem2.requires_stop_call_counter)
self.assertEqual(0, elem2.build_call_counter)
self.assertEqual(ps, new_elem.parameters)
self.assertEqual(cs, new_elem.conditions)
self.assertEqual(1, new_elem.requires_stop_call_counter)
self.assertEqual(0, new_elem.build_call_counter)
self.assertEqual(STOPInstruction(), sequence[1])
self.assertEqual(2, len(sequence))
def test_get_serialization_data(self) -> None:
constant_parameter = ConstantParameter(-0.2)
serializer = DummySerializer()
data = constant_parameter.get_serialization_data(serializer)
self.assertEqual(
dict(type=serializer.get_type_identifier(constant_parameter),
constant=-0.2), data)
def test_build_path_o1_m2_i1_f_i1_f_one_element_custom_and_main_block_requires_stop(
self) -> None:
sequencer = Sequencer()
ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)}
cs = {'foo': DummyCondition()}
elem_main = DummySequencingElement(True)
sequencer.push(elem_main, ps, cs)
elem_cstm = DummySequencingElement(True)
target_block = InstructionBlock()
sequencer.push(elem_cstm, ps, cs, target_block)
sequencer.build()
self.assertFalse(sequencer.has_finished())
self.assertEqual(ps, elem_main.parameters)
self.assertEqual(cs, elem_main.conditions)
self.assertEqual(1, elem_main.requires_stop_call_counter)
self.assertEqual(0, elem_main.build_call_counter)
self.assertEqual(ps, elem_cstm.parameters)
self.assertEqual(cs, elem_cstm.conditions)
self.assertEqual(1, elem_cstm.requires_stop_call_counter)
self.assertEqual(0, elem_cstm.build_call_counter)
def test_build_path_o2_m2_i1_f_i2_tf_m2_i1_f_i1_f_two_elements_custom_block_last_requires_stop_one_element_requires_stop_main_block(
self) -> None:
sequencer = Sequencer()
ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)}
cs = {'foo': DummyCondition()}
target_block = InstructionBlock()
elem2 = DummySequencingElement(True)
sequencer.push(elem2, ps, cs, target_block)
elem1 = DummySequencingElement(False)
sequencer.push(elem1, ps, cs, target_block)
elem_main = DummySequencingElement(True)
sequencer.push(elem_main, ps, cs)
sequencer.build()
self.assertFalse(sequencer.has_finished())
self.assertIs(target_block, elem1.target_block)
self.assertEqual(ps, elem1.parameters)
self.assertEqual(cs, elem1.conditions)
self.assertEqual(1, elem1.requires_stop_call_counter)
self.assertEqual(1, elem1.build_call_counter)
self.assertEqual(ps, elem2.parameters)
self.assertEqual(cs, elem2.conditions)
self.assertEqual(2, elem2.requires_stop_call_counter)
self.assertEqual(0, elem2.build_call_counter)
self.assertEqual(ps, elem_main.parameters)
self.assertEqual(cs, elem_main.conditions)
self.assertEqual(2, elem_main.requires_stop_call_counter)
self.assertEqual(0, elem_main.build_call_counter)
def test_push(self) -> None:
sequencer = Sequencer()
ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)}
cs = {'foo': DummyCondition()}
elem = DummySequencingElement()
sequencer.push(elem, ps, cs)
self.assertFalse(sequencer.has_finished())
sequencer.build()
self.assertEqual(ps, elem.parameters)
def test_build_path_o2_m2_i2_tt_t_i2_tt_m2_i0_i0_two_elements_custom_block_two_element_main_block(
self) -> None:
sequencer = Sequencer()
ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)}
cs = {'foo': DummyCondition()}
wm = {'foo': 'bar'}
target_block = InstructionBlock()
elem2 = DummySequencingElement(False)
sequencer.push(elem2,
ps,
cs,
window_mapping=wm,
target_block=target_block)
elem1 = DummySequencingElement(False)
sequencer.push(elem1,
ps,
cs,
window_mapping=wm,
target_block=target_block)
elem_main2 = DummySequencingElement(False)
sequencer.push(elem_main2, ps, cs)
elem_main1 = DummySequencingElement(False)
sequencer.push(elem_main1, ps, cs)
sequence = sequencer.build()
self.assertTrue(sequencer.has_finished())
self.assertIs(target_block, elem1.target_block)
self.assertEqual(ps, elem1.parameters)
self.assertEqual(cs, elem1.conditions)
self.assertEqual(1, elem1.requires_stop_call_counter)
self.assertEqual(1, elem1.build_call_counter)
self.assertIs(target_block, elem2.target_block)
self.assertEqual(ps, elem2.parameters)
self.assertEqual(cs, elem2.conditions)
self.assertEqual(1, elem2.requires_stop_call_counter)
self.assertEqual(1, elem2.build_call_counter)
self.assertIs(elem_main1, sequence[0].elem)
self.assertEqual(ps, elem_main1.parameters)
self.assertEqual(cs, elem_main1.conditions)
self.assertEqual(1, elem_main1.requires_stop_call_counter)
self.assertEqual(1, elem_main1.build_call_counter)
self.assertIs(elem_main2, sequence[1].elem)
self.assertEqual(ps, elem_main2.parameters)
self.assertEqual(cs, elem_main2.conditions)
self.assertEqual(1, elem_main2.requires_stop_call_counter)
self.assertEqual(1, elem_main2.build_call_counter)
self.assertEqual(STOPInstruction(), sequence[2])
self.assertEqual(3, len(sequence))
def test_requires_stop_true_mapped_parameters(self) -> None:
dummy = DummyPulseTemplate(parameter_names={'foo'}, requires_stop=True)
pulse = MultiChannelPulseTemplate([(dummy, dict(foo='2*bar'), [0]),
(dummy, dict(foo='rab-5'), [1])],
{'bar', 'rab'})
self.assertEqual({'bar', 'rab'}, pulse.parameter_names)
self.assertEqual(
{ParameterDeclaration('bar'),
ParameterDeclaration('rab')}, pulse.parameter_declarations)
parameters = dict(bar=ConstantParameter(-3.6),
rab=ConstantParameter(35.26))
self.assertTrue(pulse.requires_stop(parameters, dict()))
def test_insert_measurement_instruction(self):
pulse = self.to_test_constructor(measurements=[('mw', 'a', 'd')])
parameters = {'a': ConstantParameter(0), 'd': ConstantParameter(0.9)}
measurement_mapping = {'mw': 'as'}
block = InstructionBlock()
pulse.insert_measurement_instruction(
instruction_block=block,
parameters=parameters,
measurement_mapping=measurement_mapping)
expected_block = [MEASInstruction([('as', 0, 0.9)])]
self.assertEqual(block.instructions, expected_block)
def test_map_parameters(self) -> None:
map = PulseTemplateParameterMapping({'bar', 'barbar'})
dummy = DummyPulseTemplate(parameter_names={'foo', 'hugo'})
map.add(dummy, 'hugo', '4*bar')
map.add(dummy, 'foo', Expression('barbar'))
mapped = map.map_parameters(
dummy, dict(bar=ConstantParameter(3), barbar=ConstantParameter(5)))
self.assertEqual(
dict(hugo=MappedParameter(Expression('4*bar'),
dict(bar=ConstantParameter(3))),
foo=MappedParameter(Expression('barbar'),
dict(barbar=ConstantParameter(5)))),
mapped)
def test_build_path_o1_m1_i1_f_single_element_requires_stop_main_block(
self) -> None:
sequencer = Sequencer()
elem = DummySequencingElement(True)
ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)}
cs = {'foo': DummyCondition()}
sequencer.push(elem, ps, cs)
sequencer.build()
self.assertFalse(sequencer.has_finished())
self.assertEqual(ps, elem.parameters)
self.assertEqual(cs, elem.conditions)
self.assertEqual(1, elem.requires_stop_call_counter)
self.assertEqual(0, elem.build_call_counter)
def test_map_parameters_not_provided(self) -> None:
map = PulseTemplateParameterMapping({'bar', 'barbar'})
dummy = DummyPulseTemplate(parameter_names={'foo', 'hugo'})
map.add(dummy, 'hugo', '4*bar')
map.add(dummy, 'foo', Expression('barbar'))
with self.assertRaises(ParameterNotProvidedException):
map.map_parameters(dummy, dict(bar=ConstantParameter(3)))
def test_build_sequence_declaration_exceeds_bounds(self) -> None:
parameters = dict(foo=ConstantParameter(9))
conditions = dict(foo=DummyCondition(requires_stop=True))
with self.assertRaises(ParameterConstraintViolation):
self.template.build_sequence(self.sequencer, parameters,
conditions, {}, {}, self.block)
self.assertFalse(self.sequencer.sequencing_stacks)
def test_build_sequence(self):
measurement_mapping = {'meas1': 'meas2'}
parameter_mapping = {'t': 'k'}
template = DummyPulseTemplate(
measurement_names=set(measurement_mapping.keys()),
parameter_names=set(parameter_mapping.keys()))
st = MappingPulseTemplate(template,
parameter_mapping=parameter_mapping,
measurement_mapping=measurement_mapping)
sequencer = DummySequencer()
block = DummyInstructionBlock()
pre_parameters = {'k': ConstantParameter(5)}
pre_measurement_mapping = {'meas2': 'meas3'}
pre_channel_mapping = {'default': 'A'}
conditions = dict(a=True)
st.build_sequence(sequencer, pre_parameters, conditions,
pre_measurement_mapping, pre_channel_mapping, block)
self.assertEqual(template.build_sequence_calls, 1)
forwarded_args = template.build_sequence_arguments[0]
self.assertEqual(forwarded_args[0], sequencer)
self.assertEqual(forwarded_args[1], st.map_parameters(pre_parameters))
self.assertEqual(forwarded_args[2], conditions)
self.assertEqual(
forwarded_args[3],
st.get_updated_measurement_mapping(pre_measurement_mapping))
self.assertEqual(forwarded_args[4],
st.get_updated_channel_mapping(pre_channel_mapping))
self.assertEqual(forwarded_args[5], block)
def test_build_sequence_declaration_parameter_value_not_whole(
self) -> None:
parameters = dict(foo=ConstantParameter(3.3))
conditions = dict(foo=DummyCondition(requires_stop=True))
with self.assertRaises(ParameterNotIntegerException):
self.template.build_sequence(self.sequencer, parameters,
conditions, {}, {}, self.block)
self.assertFalse(self.sequencer.sequencing_stacks)
def test_build_sequence(self):
dt = DummyPulseTemplate(parameter_names={'i'})
flt = ForLoopPulseTemplate(body=dt, loop_index='i', loop_range=('a', 'b', 'c'),
measurements=[('A', 0, 1)], parameter_constraints=['c > 1'])
sequencer = DummySequencer()
block = DummyInstructionBlock()
invalid_parameters = {'a': ConstantParameter(1), 'b': ConstantParameter(4), 'c': ConstantParameter(1)}
parameters = {'a': ConstantParameter(1), 'b': ConstantParameter(4), 'c': ConstantParameter(2)}
measurement_mapping = dict(A='B')
channel_mapping = dict(C='D')
with self.assertRaises(ParameterConstraintViolation):
flt.build_sequence(sequencer, invalid_parameters, dict(), measurement_mapping, channel_mapping, block)
self.assertEqual(block.instructions, [])
self.assertNotIn(block, sequencer.sequencing_stacks)
flt.build_sequence(sequencer, parameters, dict(), measurement_mapping, channel_mapping, block)
self.assertEqual(block.instructions, [MEASInstruction(measurements=[('B', 0, 1)])])
expected_stack = [(dt, {'i': ConstantParameter(3)}, dict(), measurement_mapping, channel_mapping),
(dt, {'i': ConstantParameter(1)}, dict(), measurement_mapping, channel_mapping)]
self.assertEqual(sequencer.sequencing_stacks[block], expected_stack)
def test_get_value(self) -> None:
decl = ParameterDeclaration('foo')
foo_param = ConstantParameter(2.1)
self.assertEqual(foo_param.get_value(), decl.get_value({'foo': foo_param}))
self.assertRaises(ParameterNotProvidedException, decl.get_value, {})
decl = ParameterDeclaration('foo', default=2.7)
self.assertEqual(decl.default_value, decl.get_value({}))
decl = ParameterDeclaration('foo', min=1.3)
self.assertEqual(1.4, decl.get_value({'foo': ConstantParameter(1.4)}))
self.assertEqual(1.3, decl.get_value({'foo': ConstantParameter(1.3)}))
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'foo': ConstantParameter(1.1)})
decl = ParameterDeclaration('foo', max=2.3)
self.assertTrue(1.4, decl.get_value({'foo': ConstantParameter(1.4)}))
self.assertTrue(2.3, decl.get_value({'foo': ConstantParameter(2.3)}))
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'foo': ConstantParameter(3.1)})
decl = ParameterDeclaration('foo', min=1.3, max=2.3)
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'foo': ConstantParameter(0.9)})
self.assertEqual(1.3, decl.get_value({'foo': ConstantParameter(1.3)}))
self.assertEqual(1.4, decl.get_value({'foo': ConstantParameter(1.4)}))
self.assertEqual(2.3, decl.get_value({'foo': ConstantParameter(2.3)}))
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'foo': ConstantParameter(3.1)})
min_decl = ParameterDeclaration('min', min=1.2, max=2.3)
max_decl = ParameterDeclaration('max', min=1.2, max=5.1)
min_param = ConstantParameter(1.3)
max_param = ConstantParameter(2.3)
decl = ParameterDeclaration('foo', min=min_decl, max=max_decl)
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(0.9)})
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(1.2)})
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(1.25)})
self.assertEqual(1.3, decl.get_value({'min': min_param, 'max': max_param, 'foo': ConstantParameter(1.3)}))
self.assertEqual(1.7, decl.get_value({'min': min_param, 'max': max_param, 'foo': ConstantParameter(1.7)}))
self.assertEqual(2.3, decl.get_value({'min': min_param, 'max': max_param, 'foo': ConstantParameter(2.3)}))
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(3.5)})
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(5.1)})
self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(17.2)})
def test_integration_table_and_function_template(self) -> None:
from qctoolkit.pulses import TablePulseTemplate, FunctionPulseTemplate, Sequencer, EXECInstruction, STOPInstruction
table_template = TablePulseTemplate(channels=2)
table_template.add_entry(1, 4, channel=0)
table_template.add_entry('foo', 'bar', channel=0)
table_template.add_entry(10, 0, channel=0)
table_template.add_entry('foo', 2.7, interpolation='linear', channel=1)
table_template.add_entry(9, 'bar', interpolation='linear', channel=1)
function_template = FunctionPulseTemplate('sin(t)', '10')
template = MultiChannelPulseTemplate(
[(function_template, dict(), [1]),
(table_template, dict(foo='5', bar='2 * hugo'), [2, 0])],
{'hugo'})
sample_times = numpy.linspace(98.5, 103.5, num=11)
function_template_samples = function_template.build_waveform(
dict()).sample(sample_times)
table_template_samples = table_template.build_waveform(
dict(foo=ConstantParameter(5),
bar=ConstantParameter(2 * (-1.3)))).sample(sample_times)
template_waveform = template.build_waveform(
dict(hugo=ConstantParameter(-1.3)))
template_samples = template_waveform.sample(sample_times)
self.assertTrue(
numpy.all(table_template_samples[0] == template_samples[2]))
self.assertTrue(
numpy.all(table_template_samples[1] == template_samples[0]))
self.assertTrue(
numpy.all(function_template_samples[0] == template_samples[1]))
sequencer = Sequencer()
sequencer.push(template, parameters=dict(hugo=-1.3), conditions=dict())
instructions = sequencer.build()
self.assertEqual(2, len(instructions))
self.assertIsInstance(instructions[0], EXECInstruction)
self.assertIsInstance(instructions[1], STOPInstruction)
def test_build_path_o1_m2_i1_f_i0_one_element_custom_block_requires_stop(
self) -> None:
sequencer = Sequencer()
elem = DummySequencingElement(True)
ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)}
cs = {'foo': DummyCondition()}
wm = {}
target_block = InstructionBlock()
sequencer.push(elem,
ps,
cs,
window_mapping=wm,
target_block=target_block)
sequencer.build()
self.assertFalse(sequencer.has_finished())
self.assertEqual(ps, elem.parameters)
self.assertEqual(cs, elem.conditions)
self.assertEqual(1, elem.requires_stop_call_counter)
self.assertEqual(0, elem.build_call_counter)
def test_build_sequence(self) -> None:
dummy_wf1 = DummyWaveform(duration=2.3, num_channels=2)
dummy_wf2 = DummyWaveform(duration=2.3, num_channels=1)
dummy1 = DummyPulseTemplate(parameter_names={'foo'},
num_channels=2,
waveform=dummy_wf1)
dummy2 = DummyPulseTemplate(parameter_names={},
num_channels=1,
waveform=dummy_wf2)
pulse = MultiChannelPulseTemplate([(dummy1, {
'foo': '2*bar'
}, [2, 1]), (dummy2, {}, [0])], {'bar'})
result = pulse.build_waveform({'bar': ConstantParameter(3)})
expected = MultiChannelWaveform([(dummy_wf1, [2, 1]),
(dummy_wf2, [0])])
self.assertEqual(expected, result)
self.assertEqual([{
'foo':
MappedParameter(Expression("2*bar"), {'bar': ConstantParameter(3)})
}], dummy1.build_waveform_calls)
self.assertEqual([{}], dummy2.build_waveform_calls)
def test_parameter_not_provided(self):
parameters = dict(foo=ConstantParameter(4))
conditions = dict(foo=DummyCondition(requires_stop=True))
measurement_mapping = dict(moth='fire')
channel_mapping = dict(asd='f')
template = RepetitionPulseTemplate(self.body,
'foo*bar',
parameter_constraints=['foo<9'])
with self.assertRaises(ParameterNotProvidedException):
template.build_sequence(self.sequencer, parameters, conditions,
measurement_mapping, channel_mapping,
self.block)
def test_map_parameters(self):
template = DummyPulseTemplate(parameter_names={'foo', 'bar'})
st = MappingPulseTemplate(template,
parameter_mapping={
'foo': 't*k',
'bar': 't*l'
})
parameters = {
't': ConstantParameter(3),
'k': ConstantParameter(2),
'l': ConstantParameter(7)
}
values = {'foo': 6, 'bar': 21}
for k, v in st.map_parameters(parameters).items():
self.assertEqual(v.get_value(), values[k])
parameters.popitem()
with self.assertRaises(ParameterNotProvidedException):
st.map_parameters(parameters)
parameters = dict(t=3, k=2, l=7)
values = {'foo': 6, 'bar': 21}
for k, v in st.map_parameters(parameters).items():
self.assertEqual(v, values[k])
def test_init_single_subtemplate_requires_stop_external_params(
self) -> None:
subtemplate = DummyPulseTemplate(parameter_names={'foo'},
requires_stop=True,
num_channels=2,
duration=1.3)
template = MultiChannelPulseTemplate([(subtemplate, {
'foo': "2.3 ** bar"
}, [1, 0])], {'bar'})
self.assertEqual({'bar'}, template.parameter_names)
self.assertEqual({ParameterDeclaration('bar')},
template.parameter_declarations)
self.assertFalse(template.is_interruptable)
self.assertTrue(
template.requires_stop(dict(bar=ConstantParameter(3.5)), dict()))
self.assertEqual(2, template.num_channels)
def test_crash(self) -> None:
table = TablePulseTemplate(
{
'default': [('ta', 'va', 'hold'), ('tb', 'vb', 'linear'),
('tend', 0, 'jump')]
},
identifier='foo')
external_parameters = ['ta', 'tb', 'tc', 'td', 'va', 'vb', 'tend']
first_mapping = {
'ta': 'ta',
'tb': 'tb',
'va': 'va',
'vb': 'vb',
'tend': 'tend'
}
second_mapping = {
'ta': 'tc',
'tb': 'td',
'va': 'vb',
'vb': 'va + vb',
'tend': '2 * tend'
}
sequence = SequencePulseTemplate(
(table, first_mapping, {}), (table, second_mapping, {}),
external_parameters=external_parameters)
parameters = {
'ta': ConstantParameter(2),
'va': ConstantParameter(2),
'tb': ConstantParameter(4),
'vb': ConstantParameter(3),
'tc': ConstantParameter(5),
'td': ConstantParameter(11),
'tend': ConstantParameter(6)
}
sequencer = DummySequencer()
block = DummyInstructionBlock()
self.assertFalse(sequence.requires_stop(parameters, {}))
sequence.build_sequence(sequencer,
parameters=parameters,
conditions={},
measurement_mapping={},
channel_mapping={'default': 'default'},
instruction_block=block)
from qctoolkit.pulses.sequencing import Sequencer
s = Sequencer()
s.push(sequence, parameters, channel_mapping={'default': 'EXAMPLE_A'})
s.build()
def _body_parameter_generator(self,
parameters: Dict[str, Parameter],
forward=True) -> Generator:
loop_range_parameters = dict(
(parameter_name, parameters[parameter_name].get_value())
for parameter_name in self._loop_range.parameter_names)
loop_range = self._loop_range.to_range(loop_range_parameters)
parameters = dict((parameter_name, parameters[parameter_name])
for parameter_name in self.body.parameter_names
if parameter_name != self._loop_index)
loop_range = loop_range if forward else reversed(loop_range)
for loop_index_value in loop_range:
local_parameters = parameters.copy()
local_parameters[self._loop_index] = ConstantParameter(
loop_index_value)
yield local_parameters
def test_build_sequence_declaration_success(self) -> None:
parameters = dict(foo=ConstantParameter(3))
conditions = dict(foo=DummyCondition(requires_stop=True))
measurement_mapping = dict(moth='fire')
channel_mapping = dict(asd='f')
self.template.build_sequence(self.sequencer, parameters, conditions,
measurement_mapping, channel_mapping,
self.block)
self.assertTrue(self.block.embedded_blocks)
body_block = self.block.embedded_blocks[0]
self.assertEqual({body_block},
set(self.sequencer.sequencing_stacks.keys()))
self.assertEqual([(self.body, parameters, conditions,
measurement_mapping, channel_mapping)],
self.sequencer.sequencing_stacks[body_block])
self.assertEqual(
[REPJInstruction(3, InstructionPointer(body_block, 0))],
self.block.instructions)
def test_crash(self) -> None:
table = TablePulseTemplate(identifier='foo')
table.add_entry('ta', 'va', interpolation='hold')
table.add_entry('tb', 'vb', interpolation='linear')
table.add_entry('tend', 0, interpolation='jump')
external_parameters = ['ta', 'tb', 'tc', 'td', 'va', 'vb', 'tend']
first_mapping = {
'ta': 'ta',
'tb': 'tb',
'va': 'va',
'vb': 'vb',
'tend': 'tend'
}
second_mapping = {
'ta': 'tc',
'tb': 'td',
'va': 'vb',
'vb': 'va + vb',
'tend': '2 * tend'
}
sequence = SequencePulseTemplate([(table, first_mapping),
(table, second_mapping)],
external_parameters)
parameters = {
'ta': ConstantParameter(2),
'va': ConstantParameter(2),
'tb': ConstantParameter(4),
'vb': ConstantParameter(3),
'tc': ConstantParameter(5),
'td': ConstantParameter(11),
'tend': ConstantParameter(6)
}
sequencer = DummySequencer()
block = DummyInstructionBlock()
self.assertFalse(sequence.requires_stop(parameters, {}))
sequence.build_sequence(sequencer, parameters, {}, block)
from qctoolkit.pulses.sequencing import Sequencer
s = Sequencer()
s.push(sequence, parameters)
s.build()
def __test_valid_params(self, value: float) -> None:
constant_parameter = ConstantParameter(value)
self.assertEqual(value, constant_parameter.get_value())
self.assertEqual(value, float(constant_parameter))
def test_get_serialization_data(self) -> None:
constant_parameter = ConstantParameter(-0.2)
serializer = DummySerializer()
data = constant_parameter.get_serialization_data(serializer)
self.assertEqual(dict(type=serializer.get_type_identifier(constant_parameter), constant=-0.2), data)
def test_deserialize(self) -> None:
serializer = DummySerializer()
constant_parameter = ConstantParameter.deserialize(serializer, constant=3.1)
self.assertEqual(3.1, constant_parameter.get_value())
self.assertIsNone(constant_parameter.identifier)