def test_requires_stop(self) -> None:
condition = DummyCondition(requires_stop=False)
conditions = {'foo_cond': condition}
body = DummyPulseTemplate(requires_stop=False)
t = LoopPulseTemplate('foo_cond', body)
self.assertFalse(t.requires_stop({}, conditions))
condition.requires_stop_ = True
self.assertTrue(t.requires_stop({}, conditions))
body.requires_stop_ = True
condition.requires_stop_ = False
self.assertFalse(t.requires_stop({}, conditions))
def test_requires_stop(self) -> None:
condition = DummyCondition(requires_stop=False)
conditions = {'foo_cond': condition}
body = DummyPulseTemplate(requires_stop=False)
t = WhileLoopPulseTemplate('foo_cond', body)
self.assertFalse(t.requires_stop({}, conditions))
condition.requires_stop_ = True
self.assertTrue(t.requires_stop({}, conditions))
body.requires_stop_ = True
condition.requires_stop_ = False
self.assertFalse(t.requires_stop({}, conditions))
def test_requires_stop_condition_missing(self) -> None:
conditions = dict(bar_condition=DummyCondition(requires_stop=True))
parameters = dict(foo=DummyParameter(326.272),
bar=DummyParameter(-2624.23),
hugo=DummyParameter(3.532))
with self.assertRaises(ConditionMissingException):
self.template.requires_stop(parameters, conditions)
def test_build_sequence_declaration_parameter_missing(self) -> None:
parameters = {}
conditions = dict(foo=DummyCondition(requires_stop=True))
with self.assertRaises(ParameterNotProvidedException):
self.template.build_sequence(self.sequencer, parameters,
conditions, {}, {}, self.block)
self.assertFalse(self.sequencer.sequencing_stacks)
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_requires_stop_declaration(self) -> None:
body = DummyPulseTemplate(requires_stop=False)
t = RepetitionPulseTemplate(body, ParameterDeclaration('foo'))
parameter = DummyParameter()
parameters = dict(foo=parameter)
condition = DummyCondition()
conditions = dict(foo=condition)
for body_requires_stop in [True, False]:
for condition_requires_stop in [True, False]:
for parameter_requires_stop in [True, False]:
body.requires_stop_ = body_requires_stop
condition.requires_stop_ = condition_requires_stop
parameter.requires_stop_ = parameter_requires_stop
self.assertEqual(parameter_requires_stop, t.requires_stop(parameters, conditions))
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 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_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_m2_i0_i2_tt_m2_i0_i0_two_elements_custom_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)
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)
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_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_requires_stop_declaration(self) -> None:
body = DummyPulseTemplate(requires_stop=False)
t = RepetitionPulseTemplate(body, ParameterDeclaration('foo'))
parameter = DummyParameter()
parameters = dict(foo=parameter)
condition = DummyCondition()
conditions = dict(foo=condition)
for body_requires_stop in [True, False]:
for condition_requires_stop in [True, False]:
for parameter_requires_stop in [True, False]:
body.requires_stop_ = body_requires_stop
condition.requires_stop_ = condition_requires_stop
parameter.requires_stop_ = parameter_requires_stop
self.assertEqual(parameter_requires_stop, t.requires_stop(parameters, conditions))
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_parameter_names_and_declarations(self) -> None:
condition = DummyCondition()
body = DummyPulseTemplate()
t = WhileLoopPulseTemplate(condition, body)
self.assertEqual(body.parameter_names, t.parameter_names)
body.parameter_names_ = {'foo', 't', 'bar'}
self.assertEqual(body.parameter_names, t.parameter_names)
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_is_interruptable(self) -> None:
condition = DummyCondition()
body = DummyPulseTemplate(is_interruptable=False)
t = WhileLoopPulseTemplate(condition, body)
self.assertFalse(t.is_interruptable)
body.is_interruptable_ = True
self.assertTrue(t.is_interruptable)
def test_integral(self) -> None:
condition = DummyCondition()
body = DummyPulseTemplate(defined_channels={'A', 'B'})
pulse = WhileLoopPulseTemplate(condition, body)
self.assertEqual(
{
'A': ExpressionScalar('nan'),
'B': ExpressionScalar('nan')
}, pulse.integral)
def test_build_sequence_declaration_success(self) -> None:
parameters = dict(foo=3)
conditions = dict(foo=DummyCondition(requires_stop=True))
self.template.build_sequence(self.sequencer, parameters, conditions, 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)],
self.sequencer.sequencing_stacks[body_block])
self.assertEqual([REPJInstruction(parameters['foo'], InstructionPointer(body_block, 0))], self.block.instructions)
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_sequence_constant(self) -> None:
repetitions = 3
t = RepetitionPulseTemplate(self.body, repetitions)
parameters = {}
conditions = dict(foo=DummyCondition(requires_stop=True))
t.build_sequence(self.sequencer, parameters, conditions, 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)], self.sequencer.sequencing_stacks[body_block])
self.assertEqual([REPJInstruction(repetitions, InstructionPointer(body_block, 0))], self.block.instructions)
def test_push_float_params(self) -> None:
sequencer = Sequencer()
ps = {'foo': 1, 'bar': 7.3}
cs = {'foo': DummyCondition()}
elem = DummySequencingElement()
sequencer.push(elem, ps, cs)
self.assertFalse(sequencer.has_finished())
sequencer.build()
self.assertIsInstance(elem.parameters['foo'], ConstantParameter)
self.assertIsInstance(elem.parameters['bar'], ConstantParameter)
self.assertEqual(cs, elem.conditions)
def test_build_path_o2_m2_i2_tt_t_i2_tf_m2_i0_i1_f_two_elements_custom_block_last_requires_stop_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(True)
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.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.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_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_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_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:
condition = DummyCondition()
body = DummyPulseTemplate()
t = LoopPulseTemplate('foo_cond', body)
sequencer = DummySequencer()
block = DummyInstructionBlock()
parameters = {}
conditions = {'foo_cond': condition}
t.build_sequence(sequencer, parameters, conditions, block)
expected_data = dict(delegator=t,
body=body,
sequencer=sequencer,
parameters=parameters,
conditions=conditions,
instruction_block=block)
self.assertEqual(expected_data, condition.loop_call_data)
self.assertFalse(condition.branch_call_data)
self.assertFalse(sequencer.sequencing_stacks)
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_build_sequence_parameter_missing(self) -> None:
foo_condition = DummyCondition()
conditions = dict(foo_condition=foo_condition)
parameters = dict(foo=DummyParameter(326.272),
bar=DummyParameter(-2624.23))
self.template.build_sequence(self.sequencer, parameters, conditions, self.block)
self.assertFalse(foo_condition.loop_call_data)
self.assertEqual(
dict(
delegator=self.template,
if_branch=self.if_dummy,
else_branch=self.else_dummy,
sequencer=self.sequencer,
parameters=parameters,
conditions=conditions,
instruction_block=self.block
),
foo_condition.branch_call_data
)
self.assertFalse(self.sequencer.sequencing_stacks)
self.assertFalse(self.block.instructions)
def test_build_sequence(self) -> None:
condition = DummyCondition()
body = DummyPulseTemplate()
t = WhileLoopPulseTemplate('foo_cond', body)
sequencer = DummySequencer()
block = DummyInstructionBlock()
parameters = {}
conditions = {'foo_cond': condition}
measurement_mapping = {'swag': 'aufdrehen'}
channel_mapping = {}
t.build_sequence(sequencer, parameters, conditions,
measurement_mapping, channel_mapping, block)
expected_data = dict(delegator=t,
body=body,
sequencer=sequencer,
parameters=parameters,
conditions=conditions,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
instruction_block=block)
self.assertEqual(expected_data, condition.loop_call_data)
self.assertFalse(condition.branch_call_data)
self.assertFalse(sequencer.sequencing_stacks)
def test_requires_stop(self) -> None:
point = PointPulseTemplate([('foo', 'v'), ('bar', 0)], [0])
test_sets = [(False, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(False)}),
(False, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(True)}),
(True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(False)}),
(True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(True)}),
(True, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(False)}),
(True, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(True)}),
(True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, True), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(False)}),
(True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, True), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(True)})]
for expected_result, parameter_set, condition_set in test_sets:
self.assertEqual(expected_result, point.requires_stop(parameter_set, condition_set))
def test_build_sequence_declaration_exceeds_bounds(self) -> None:
parameters = dict(foo=9)
conditions = dict(foo=DummyCondition(requires_stop=True))
with self.assertRaises(ParameterValueIllegalException):
self.template.build_sequence(self.sequencer, parameters, conditions, self.block)
self.assertFalse(self.sequencer.sequencing_stacks)
