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_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))