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 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_requires_stop_and_get_value(self) -> None:
with self.assertWarns(DeprecationWarning):
p = MappedParameter(Expression("foo + bar * hugo"))
with self.assertRaises(ParameterNotProvidedException):
p.requires_stop
with self.assertRaises(ParameterNotProvidedException):
p.get_value()
foo = DummyParameter(-1.1)
bar = DummyParameter(0.5)
hugo = DummyParameter(5.2, requires_stop=True)
ilse = DummyParameter(2356.4, requires_stop=True)
p._namespace = {'foo': foo, 'bar': bar, 'ilse': ilse}
with self.assertRaises(ParameterNotProvidedException):
p.requires_stop
with self.assertRaises(ParameterNotProvidedException):
p.get_value()
p._namespace = {'foo': foo, 'bar': bar, 'hugo': hugo}
self.assertTrue(p.requires_stop)
hugo = DummyParameter(5.2, requires_stop=False)
p._namespace = {'foo': foo, 'bar': bar, 'hugo': hugo, 'ilse': ilse}
self.assertFalse(p.requires_stop)
self.assertEqual(1.5, p.get_value())
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_requires_stop(self):
parameters = dict(A=DummyParameter(requires_stop=False), B=DummyParameter(requires_stop=False))
dt = DummyPulseTemplate(parameter_names={'i'})
flt = ForLoopPulseTemplate(body=dt, loop_index='i', loop_range=('A', 'B'))
self.assertFalse(flt.requires_stop(parameters, dict()))
parameters['A'] = DummyParameter(requires_stop=True)
self.assertTrue(flt.requires_stop(parameters, dict()))
def test_table_sequence_sequencer_integration(self) -> None:
t1 = TablePulseTemplate()
t1.add_entry(2, 'foo')
t1.add_entry(5, 0)
t2 = TablePulseTemplate()
t2.add_entry(4, 0)
t2.add_entry(4.5, 'bar', 'linear')
t2.add_entry(5, 0)
seqt = SequencePulseTemplate([(t1, {'foo': 'foo'}), (t2, {'bar': '2 * hugo'})], {'foo', 'hugo'})
with self.assertRaises(ParameterNotProvidedException):
t1.requires_stop(dict(), dict())
with self.assertRaises(ParameterNotProvidedException):
t2.requires_stop(dict(), dict())
self.assertFalse(seqt.requires_stop({}, {}))
foo = DummyNoValueParameter()
bar = DummyNoValueParameter()
sequencer = Sequencer()
sequencer.push(seqt, {'foo': foo, 'hugo': bar})
instructions = sequencer.build()
self.assertFalse(sequencer.has_finished())
self.assertEqual(1, len(instructions))
foo = DummyParameter(value=1.1)
bar = DummyNoValueParameter()
sequencer = Sequencer()
sequencer.push(seqt, {'foo': foo, 'hugo': bar})
instructions = sequencer.build()
self.assertFalse(sequencer.has_finished())
self.assertEqual(2, len(instructions))
foo = DummyParameter(value=1.1)
bar = DummyNoValueParameter()
sequencer = Sequencer()
sequencer.push(seqt, {'foo': bar, 'hugo': foo})
instructions = sequencer.build()
self.assertFalse(sequencer.has_finished())
self.assertEqual(1, len(instructions))
foo = DummyParameter(value=1.1)
bar = DummyParameter(value=-0.2)
sequencer = Sequencer()
sequencer.push(seqt, {'foo': foo, 'hugo': bar})
instructions = sequencer.build()
self.assertTrue(sequencer.has_finished())
self.assertEqual(3, len(instructions))
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_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_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 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_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_requires_stop_missing_param(self) -> None:
table = PointPulseTemplate([('foo', 'v')], [0])
with self.assertRaises(ParameterNotProvidedException):
table.requires_stop({'foo': DummyParameter(0, False)}, {})
def test_table_sequence_sequencer_integration(self) -> None:
t1 = TablePulseTemplate(entries={'default': [(2, 'foo'), (5, 0)]},
measurements=[('foo', 2, 2)])
t2 = TablePulseTemplate(
entries={'default': [(4, 0), (4.5, 'bar', 'linear'), (5, 0)]},
measurements=[('foo', 4, 1)])
seqt = SequencePulseTemplate(
MappingPulseTemplate(t1, measurement_mapping={'foo': 'bar'}),
MappingPulseTemplate(t2, parameter_mapping={'bar': '2 * hugo'}))
with self.assertRaises(ParameterNotProvidedException):
t1.requires_stop(dict(), dict())
with self.assertRaises(ParameterNotProvidedException):
t2.requires_stop(dict(), dict())
self.assertFalse(
seqt.requires_stop(
{
'foo': DummyParameter(),
'hugo': DummyParameter()
}, {}))
foo = DummyNoValueParameter()
bar = DummyNoValueParameter()
sequencer = Sequencer()
sequencer.push(seqt, {
'foo': foo,
'hugo': bar
},
window_mapping=dict(bar='my', foo='thy'),
channel_mapping={'default': 'A'})
instructions = sequencer.build()
self.assertFalse(sequencer.has_finished())
self.assertEqual(1, len(instructions))
# stop after first TablePT
foo = DummyParameter(value=1.1)
bar = DummyNoValueParameter()
sequencer = Sequencer()
sequencer.push(seqt, {
'foo': foo,
'hugo': bar
},
window_mapping=dict(bar='my', foo='thy'),
channel_mapping={'default': 'A'})
block = sequencer.build()
instructions = block.instructions
self.assertFalse(sequencer.has_finished())
self.assertIsInstance(block, AbstractInstructionBlock)
self.assertEqual(2, len(instructions))
self.assertEqual(instructions[0], MEASInstruction([('my', 2, 2)]))
self.assertIsInstance(instructions[1], EXECInstruction)
# stop before first TablePT
foo = DummyParameter(value=1.1)
bar = DummyNoValueParameter()
sequencer = Sequencer()
sequencer.push(seqt, {
'foo': bar,
'hugo': foo
},
window_mapping=dict(bar='my', foo='thy'),
channel_mapping={'default': 'A'})
instructions = sequencer.build()
self.assertFalse(sequencer.has_finished())
self.assertEqual(1, len(instructions))
foo = DummyParameter(value=1.1)
bar = DummyParameter(value=-0.2)
sequencer = Sequencer()
sequencer.push(seqt, {
'foo': foo,
'hugo': bar
},
window_mapping=dict(bar='my', foo='thy'),
channel_mapping={'default': 'A'})
instructions = sequencer.build()
self.assertTrue(sequencer.has_finished())
self.assertEqual(4, len(instructions.instructions))
self.assertEqual(instructions[0], MEASInstruction([('my', 2, 2)]))
self.assertIsInstance(instructions[1], EXECInstruction)
self.assertEqual(instructions[2], MEASInstruction([('thy', 4, 1)]))
self.assertIsInstance(instructions[3], EXECInstruction)
def test_requires_stop(self) -> None:
table = TablePulseTemplate()
foo_decl = ParameterDeclaration('foo', min=1)
bar_decl = ParameterDeclaration('bar')
table.add_entry(foo_decl, 'v', 'linear')
table.add_entry(bar_decl, 0, 'jump')
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, table.requires_stop(parameter_set, condition_set))
def test_float_conversion_method(self) -> None:
parameter = DummyParameter()
self.assertEqual(parameter.value, float(parameter))
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_requires_stop_missing_param(self) -> None:
table = TablePulseTemplate()
foo_decl = ParameterDeclaration('foo')
table.add_entry(foo_decl, 'v', 'linear')
with self.assertRaises(ParameterNotProvidedException):
table.requires_stop({'foo': DummyParameter(0, False)}, {})
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_requires_stop_parameters_missing(self) -> None:
conditions = dict(foo_condition=DummyCondition(requires_stop=False))
parameters = dict(foo=DummyParameter(326.272),
hugo=DummyParameter(3.532))
self.assertFalse(self.template.requires_stop(parameters, conditions))
def test_requires_stop_parameters_do_conditions_do(self) -> None:
conditions = dict(foo_condition=DummyCondition(requires_stop=True))
parameters = dict(foo=DummyParameter(326.272, requires_stop=True),
bar=DummyParameter(-2624.23),
hugo=DummyParameter(3.532))
self.assertTrue(self.template.requires_stop(parameters, conditions))
