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_build_sequence(self) -> None:
sub1 = DummyPulseTemplate(requires_stop=False)
sub2 = DummyPulseTemplate(requires_stop=True, parameter_names={'foo'})
parameters = {'foo': DummyNoValueParameter()}
sequencer = DummySequencer()
block = DummyInstructionBlock()
seq = SequencePulseTemplate(sub1, (sub2, {
'foo': 'foo'
}),
external_parameters={'foo'},
measurements=[('a', 0, 1)])
seq.build_sequence(sequencer,
parameters,
conditions=dict(),
channel_mapping={'default': 'a'},
measurement_mapping={'a': 'b'},
instruction_block=block)
self.assertEqual(2, len(sequencer.sequencing_stacks[block]))
self.assertEqual(block.instructions[0], MEASInstruction([('b', 0, 1)]))
sequencer = DummySequencer()
block = DummyInstructionBlock()
seq = SequencePulseTemplate((sub2, {
'foo': 'foo'
}),
sub1,
external_parameters={'foo'})
seq.build_sequence(sequencer, parameters, {}, {}, {}, block)
self.assertEqual(2, len(sequencer.sequencing_stacks[block]))
def test_internal_create_program_both_children_no_duration(self) -> None:
sub1 = DummyPulseTemplate(duration=0, waveform=None, measurements=[('b', 1, 2)], defined_channels={'A'})
sub2 = DummyPulseTemplate(duration=0, waveform=None, parameter_names={'foo'}, defined_channels={'A'})
parameters = {'foo': DummyNoValueParameter()}
measurement_mapping = {'a': 'a', 'b': 'b'}
channel_mapping = dict()
seq = SequencePulseTemplate(sub1, sub2, measurements=[('a', 0, 1)])
loop = Loop(measurements=None)
seq._internal_create_program(parameters=parameters,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
global_transformation=None,
to_single_waveform=set(),
parent_loop=loop)
self.assertEqual(1, loop.repetition_count)
self.assertIsNone(loop.waveform)
self.assertEqual([], loop.children)
self.assertIsNone(loop._measurements)
# ensure same result as from Sequencer
sequencer = Sequencer()
sequencer.push(seq, parameters=parameters, conditions={}, window_mapping=measurement_mapping, channel_mapping=channel_mapping)
block = sequencer.build()
old_program = MultiChannelProgram(block, channels={'A'})
old_loop = old_program.programs[frozenset({'A'})]
self.assertEqual(old_loop.waveform, loop.waveform)
self.assertEqual(old_loop.children, loop.children)
def test_internal_create_program_no_measurement_mapping(self) -> None:
sub1 = DummyPulseTemplate(duration=3, waveform=DummyWaveform(duration=3), measurements=[('b', 1, 2)])
sub2 = DummyPulseTemplate(duration=2, waveform=DummyWaveform(duration=2), parameter_names={'foo'})
parameters = {'foo': DummyNoValueParameter()}
seq = SequencePulseTemplate(sub1, sub2, measurements=[('a', 0, 1)])
children = [Loop(waveform=DummyWaveform())]
loop = Loop(measurements=[], children=children)
with self.assertRaises(KeyError):
seq._internal_create_program(parameters=parameters,
measurement_mapping=dict(),
channel_mapping=dict(),
global_transformation=None,
to_single_waveform=set(),
parent_loop=loop)
self.assertFalse(sub1.create_program_calls)
self.assertFalse(sub2.create_program_calls)
self.assertEqual(children, loop.children)
self.assertEqual(1, loop.repetition_count)
self.assertIsNone(loop.waveform)
self.assert_measurement_windows_equal({}, loop.get_measurement_windows())
# test for child level measurements (does not guarantee to leave parent_loop unchanged in this case)
with self.assertRaises(KeyError):
seq._internal_create_program(parameters=parameters,
measurement_mapping=dict(a='a'),
channel_mapping=dict(),
global_transformation=None,
to_single_waveform=set(),
parent_loop=loop)
def test_create_program_internal(self) -> None:
sub1 = DummyPulseTemplate(duration=3, waveform=DummyWaveform(duration=3), measurements=[('b', 1, 2)], defined_channels={'A'})
sub2 = DummyPulseTemplate(duration=2, waveform=DummyWaveform(duration=2), parameter_names={'foo'}, defined_channels={'A'})
parameters = {'foo': DummyNoValueParameter()}
measurement_mapping = {'a': 'a', 'b': 'b'}
channel_mapping = dict()
seq = SequencePulseTemplate(sub1, sub2, measurements=[('a', 0, 1)])
loop = Loop()
seq._internal_create_program(parameters=parameters,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
global_transformation=None,
to_single_waveform=set(),
parent_loop=loop)
self.assertEqual(1, loop.repetition_count)
self.assertIsNone(loop.waveform)
self.assertEqual([Loop(repetition_count=1, waveform=sub1.waveform),
Loop(repetition_count=1, waveform=sub2.waveform)],
loop.children)
self.assert_measurement_windows_equal({'a': ([0], [1]), 'b': ([1], [2])}, loop.get_measurement_windows())
# ensure same result as from Sequencer
sequencer = Sequencer()
sequencer.push(seq, parameters=parameters, conditions={}, window_mapping=measurement_mapping, channel_mapping=channel_mapping)
block = sequencer.build()
old_program = MultiChannelProgram(block, channels={'A'})
self.assertEqual(old_program.programs[frozenset({'A'})], loop)
### test again with inverted sequence
seq = SequencePulseTemplate(sub2, sub1, measurements=[('a', 0, 1)])
loop = Loop()
seq._internal_create_program(parameters=parameters,
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
global_transformation=None,
to_single_waveform=set(),
parent_loop=loop)
self.assertEqual(1, loop.repetition_count)
self.assertIsNone(loop.waveform)
self.assertEqual([Loop(repetition_count=1, waveform=sub2.waveform),
Loop(repetition_count=1, waveform=sub1.waveform)],
loop.children)
self.assert_measurement_windows_equal({'a': ([0], [1]), 'b': ([3], [2])}, loop.get_measurement_windows())
# ensure same result as from Sequencer
sequencer = Sequencer()
sequencer.push(seq, parameters=parameters, conditions={}, window_mapping=measurement_mapping, channel_mapping=channel_mapping)
block = sequencer.build()
old_program = MultiChannelProgram(block, channels={'A'})
self.assertEqual(old_program.programs[frozenset({'A'})], loop)
def test_requires_stop(self) -> None:
sub1 = (DummyPulseTemplate(requires_stop=False), {}, {})
sub2 = (DummyPulseTemplate(requires_stop=True, parameter_names={'foo'}), {'foo': 'foo'}, {})
parameters = {'foo': DummyNoValueParameter()}
seq = SequencePulseTemplate(sub1)
self.assertFalse(seq.requires_stop(parameters, {}))
seq = SequencePulseTemplate(sub2)
self.assertFalse(seq.requires_stop(parameters, {}))
seq = SequencePulseTemplate(sub1, sub2)
self.assertFalse(seq.requires_stop(parameters, {}))
seq = SequencePulseTemplate(sub2, sub1)
self.assertFalse(seq.requires_stop(parameters, {}))
def test_build_sequence(self) -> None:
sub1 = DummyPulseTemplate(requires_stop=False)
sub2 = DummyPulseTemplate(requires_stop=True, parameter_names={'foo'})
parameters = {'foo': DummyNoValueParameter()}
sequencer = DummySequencer()
block = DummyInstructionBlock()
seq = SequencePulseTemplate([(sub1, {}), (sub2, {
'foo': 'foo'
})], {'foo'})
seq.build_sequence(sequencer, parameters, {}, block)
self.assertEqual(2, len(sequencer.sequencing_stacks[block]))
sequencer = DummySequencer()
block = DummyInstructionBlock()
seq = SequencePulseTemplate([(sub2, {
'foo': 'foo'
}), (sub1, {})], {'foo'})
seq.build_sequence(sequencer, parameters, {}, block)
self.assertEqual(2, len(sequencer.sequencing_stacks[block]))
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)