def test_iter_instruction_block(self) -> None:
wf1 = DummyWaveform(duration=7)
wf2 = DummyWaveform(duration=5)
wf3 = DummyWaveform(duration=3)
repeated_block = InstructionBlock()
repeated_block.add_instruction_meas([('m', 1, 2)])
repeated_block.add_instruction_exec(wf2)
repeated_block.add_instruction_exec(wf1)
main_block = InstructionBlock()
main_block.add_instruction_exec(wf1)
main_block.add_instruction_repj(2, repeated_block)
main_block.add_instruction_exec(wf3)
waveforms, measurements, total_time = iter_instruction_block(
main_block, True)
for idx, (expected, received) in enumerate(
zip([wf1, wf2, wf1, wf2, wf1, wf3], waveforms)):
self.assertIs(expected,
received,
msg="Waveform {} is wrong".format(idx))
self.assertEqual([('m', 8, 2), ('m', 20, 2)], measurements)
self.assertEqual(total_time, 34)
def build_sequence(self,
sequencer: Sequencer,
parameters: Dict[str, Parameter],
conditions: Dict[str, Condition],
measurement_mapping: Dict[str, Optional[str]],
channel_mapping: Dict[ChannelID, Optional[ChannelID]],
instruction_block: InstructionBlock) -> None:
self.validate_parameter_constraints(parameters=parameters)
try:
real_parameters = {v: parameters[v].get_value() for v in self._repetition_count.variables}
except KeyError:
raise ParameterNotProvidedException(next(v for v in self.repetition_count.variables if v not in parameters))
self.insert_measurement_instruction(instruction_block,
parameters=parameters,
measurement_mapping=measurement_mapping)
repetition_count = self.get_repetition_count_value(real_parameters)
if repetition_count > 0:
body_block = InstructionBlock()
body_block.return_ip = InstructionPointer(instruction_block, len(instruction_block))
instruction_block.add_instruction_repj(repetition_count, body_block)
sequencer.push(self.body, parameters=parameters, conditions=conditions,
window_mapping=measurement_mapping, channel_mapping=channel_mapping, target_block=body_block)
def test_iter_waveform_exceptions(self) -> None:
wf1 = DummyWaveform(duration=7)
wf2 = DummyWaveform(duration=5)
wf3 = DummyWaveform(duration=3)
repeated_block = InstructionBlock()
repeated_block.add_instruction_meas([('m', 1, 2)])
repeated_block.add_instruction_exec(wf2)
repeated_block.add_instruction_exec(wf1)
main_block = InstructionBlock()
main_block.add_instruction_exec(wf1)
main_block.add_instruction_repj(2, repeated_block)
main_block.add_instruction_exec(wf3)
main_block.add_instruction_goto(repeated_block)
with self.assertRaises(NotImplementedError):
list(iter_waveforms(main_block))
repeated_block.add_instruction(DummyInstruction())
with self.assertRaises(NotImplementedError):
list(iter_waveforms(main_block))
main_block = InstructionBlock()
main_block.add_instruction_stop()
with self.assertRaises(StopIteration):
next(iter_waveforms(main_block))
def test_iter_instruction_block_exceptions(self) -> None:
wf1 = DummyWaveform(duration=7)
wf2 = DummyWaveform(duration=5)
wf3 = DummyWaveform(duration=3)
repeated_block = InstructionBlock()
repeated_block.add_instruction_meas([('m', 1, 2)])
repeated_block.add_instruction_exec(wf2)
main_block = InstructionBlock()
main_block.add_instruction_exec(wf1)
main_block.add_instruction_repj(2, repeated_block)
main_block.add_instruction_exec(wf3)
repeated_block.add_instruction_goto(main_block)
with self.assertRaises(NotImplementedError):
iter_instruction_block(main_block, False)
repeated_block = InstructionBlock()
repeated_block.add_instruction_meas([('m', 1, 2)])
repeated_block.add_instruction_exec(wf2)
repeated_block.add_instruction(DummyInstruction())
main_block = InstructionBlock()
main_block.add_instruction_exec(wf1)
main_block.add_instruction_repj(2, repeated_block)
main_block.add_instruction_exec(wf3)
with self.assertRaises(NotImplementedError):
iter_instruction_block(main_block, False)
def test_nested_repj(self) -> None:
parent_block = InstructionBlock()
block = InstructionBlock()
block.return_ip = InstructionPointer(parent_block, 1)
parent_block.add_instruction_repj(3, block)
context = dict()
immutable_block = ImmutableInstructionBlock(parent_block, context)
self.__verify_block(parent_block, immutable_block, context)
def test_empty_repj(self):
empty_block = InstructionBlock()
root_block = InstructionBlock()
root_block.add_instruction_repj(1, empty_block)
with self.assertRaisesRegex(ValueError, 'no defined channels'):
MultiChannelProgram(root_block)
empty_block.add_instruction_exec(DummyWaveform(duration=1, defined_channels={'A', 'B'}))
MultiChannelProgram(root_block)
def test_add_instruction_repj(self) -> None:
block = InstructionBlock()
expected_instructions = []
targets = [InstructionBlock(), InstructionBlock(), InstructionBlock()]
counts = [3, 8, 857]
LOOKUP = [(0, 0), (0, 1), (1, 1), (0, 2), (2, 0), (1, 0), (2, 2),
(2, 1), (1, 0), (1, 2)]
for i in LOOKUP:
block.add_instruction_repj(counts[i[0]], targets[i[1]])
expected_instructions.append(
REPJInstruction(counts[i[0]],
InstructionPointer(targets[i[1]], 0)))
expected_compiled_instructions = expected_instructions.copy()
expected_compiled_instructions.append(STOPInstruction())
self.__verify_block(block, expected_instructions,
expected_compiled_instructions, None)
def test_iter_waveforms(self) -> None:
wf1 = DummyWaveform(duration=7)
wf2 = DummyWaveform(duration=5)
wf3 = DummyWaveform(duration=3)
repeated_block = InstructionBlock()
repeated_block.add_instruction_meas([('m', 1, 2)])
repeated_block.add_instruction_exec(wf2)
repeated_block.add_instruction_exec(wf1)
main_block = InstructionBlock()
main_block.add_instruction_exec(wf1)
main_block.add_instruction_repj(2, repeated_block)
main_block.add_instruction_exec(wf3)
for idx, (expected, received) in enumerate(
zip([wf1, wf2, wf1, wf2, wf1, wf3],
iter_waveforms(main_block))):
self.assertIs(expected,
received,
msg="Waveform {} is wrong".format(idx))
class MultiChannelTests(unittest.TestCase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
wf = DummyWaveform()
self.descriptionA = \
"""\
LOOP 1 times:
->EXEC {} 1 times
->EXEC {} 50 times
->LOOP 17 times:
->LOOP 2 times:
->EXEC {} 1 times
->EXEC {} 1 times
->EXEC {} 1 times
->LOOP 3 times:
->EXEC {} 1 times
->EXEC {} 1 times
->LOOP 24 times:
->EXEC {} 7 times
->EXEC {} 8 times"""
self.descriptionB = \
"""\
LOOP 1 times:
->EXEC {} 1 times
->EXEC {} 50 times
->LOOP 17 times:
->LOOP 2 times:
->EXEC {} 1 times
->EXEC {} 1 times
->EXEC {} 1 times
->LOOP 3 times:
->EXEC {} 1 times
->EXEC {} 1 times
->LOOP 36 times:
->EXEC {} 10 times
->EXEC {} 11 times"""
def generate_waveform(channel):
return DummyWaveform(sample_output=None,
duration=1.,
defined_channels={channel})
def generate_multi_channel_waveform():
return MultiChannelWaveform(
[generate_waveform('A'),
generate_waveform('B')])
self.loop_block11 = InstructionBlock()
self.loop_block11.add_instruction_exec(
generate_multi_channel_waveform())
self.loop_block1 = InstructionBlock()
self.loop_block1.add_instruction_repj(
5, ImmutableInstructionBlock(self.loop_block11))
self.loop_block21 = InstructionBlock()
self.loop_block21.add_instruction_exec(
generate_multi_channel_waveform())
self.loop_block21.add_instruction_exec(
generate_multi_channel_waveform())
self.loop_block2 = InstructionBlock()
self.loop_block2.add_instruction_repj(
2, ImmutableInstructionBlock(self.loop_block21))
self.loop_block2.add_instruction_exec(
generate_multi_channel_waveform())
self.loop_block3 = InstructionBlock()
self.loop_block3.add_instruction_exec(
generate_multi_channel_waveform())
self.loop_block3.add_instruction_exec(
generate_multi_channel_waveform())
self.loop_block411 = InstructionBlock()
self.loop_block411.add_instruction_exec(
MultiChannelWaveform([generate_waveform('A')]))
self.loop_block412 = InstructionBlock()
self.loop_block412.add_instruction_exec(
MultiChannelWaveform([generate_waveform('A')]))
self.loop_block41 = InstructionBlock()
self.loop_block41.add_instruction_repj(
7, ImmutableInstructionBlock(self.loop_block411))
self.loop_block41.add_instruction_repj(
8, ImmutableInstructionBlock(self.loop_block412))
self.loop_block421 = InstructionBlock()
self.loop_block421.add_instruction_exec(
MultiChannelWaveform([generate_waveform('B')]))
self.loop_block422 = InstructionBlock()
self.loop_block422.add_instruction_exec(
MultiChannelWaveform([generate_waveform('B')]))
self.loop_block42 = InstructionBlock()
self.loop_block42.add_instruction_repj(
10, ImmutableInstructionBlock(self.loop_block421))
self.loop_block42.add_instruction_repj(
11, ImmutableInstructionBlock(self.loop_block422))
self.chan_block4A = InstructionBlock()
self.chan_block4A.add_instruction_repj(
6, ImmutableInstructionBlock(self.loop_block41))
self.chan_block4B = InstructionBlock()
self.chan_block4B.add_instruction_repj(
9, ImmutableInstructionBlock(self.loop_block42))
self.loop_block4 = InstructionBlock()
self.loop_block4.add_instruction_chan({
frozenset('A'):
ImmutableInstructionBlock(self.chan_block4A),
frozenset('B'):
ImmutableInstructionBlock(self.chan_block4B)
})
self.root_block = InstructionBlock()
self.root_block.add_instruction_exec(generate_multi_channel_waveform())
self.root_block.add_instruction_repj(
10, ImmutableInstructionBlock(self.loop_block1))
self.root_block.add_instruction_repj(
17, ImmutableInstructionBlock(self.loop_block2))
self.root_block.add_instruction_repj(
3, ImmutableInstructionBlock(self.loop_block3))
self.root_block.add_instruction_repj(
4, ImmutableInstructionBlock(self.loop_block4))
self.maxDiff = None
def get_mcp(self, channels):
program = MultiChannelProgram(self.root_block, ['A', 'B'])
return program[channels]
def test_init(self):
with self.assertRaises(ValueError):
MultiChannelProgram(InstructionBlock())
mcp = MultiChannelProgram(self.root_block, ['A', 'B'])
self.assertEqual(mcp.channels, {'A', 'B'})
with self.assertRaises(KeyError):
mcp['C']
def test_empty_repj(self):
empty_block = InstructionBlock()
root_block = InstructionBlock()
root_block.add_instruction_repj(1, empty_block)
with self.assertRaisesRegex(ValueError, 'no defined channels'):
MultiChannelProgram(root_block)
empty_block.add_instruction_exec(
DummyWaveform(duration=1, defined_channels={'A', 'B'}))
MultiChannelProgram(root_block)
def test_via_repr(self):
root_loopA = self.get_mcp('A')
root_loopB = self.get_mcp('B')
waveformsA = tuple(loop.waveform
for loop in root_loopA.get_depth_first_iterator()
if loop.is_leaf())
reprA = self.descriptionA.format(*waveformsA)
reprB = self.descriptionB.format(
*(loop.waveform for loop in root_loopB.get_depth_first_iterator()
if loop.is_leaf()))
self.assertEqual(root_loopA.__repr__(), reprA)
self.assertEqual(root_loopB.__repr__(), reprB)
def test_init_from_loop(self):
program = Loop(waveform=DummyWaveform(defined_channels={'A', 'B'}))
mcp = MultiChannelProgram(program)
self.assertEqual(mcp.programs, {frozenset('AB'): program})
with self.assertRaises(TypeError):
MultiChannelProgram(mcp)
def get_two_chan_test_block(wfg=WaveformGenerator(2)):
generate_waveform = wfg.generate_single_channel_waveform
generate_multi_channel_waveform = wfg.generate_multi_channel_waveform
loop_block11 = InstructionBlock()
loop_block11.add_instruction_exec(generate_multi_channel_waveform())
loop_block1 = InstructionBlock()
loop_block1.add_instruction_repj(5,
ImmutableInstructionBlock(loop_block11))
loop_block21 = InstructionBlock()
loop_block21.add_instruction_exec(generate_multi_channel_waveform())
loop_block21.add_instruction_exec(generate_multi_channel_waveform())
loop_block2 = InstructionBlock()
loop_block2.add_instruction_repj(2,
ImmutableInstructionBlock(loop_block21))
loop_block2.add_instruction_exec(generate_multi_channel_waveform())
loop_block3 = InstructionBlock()
loop_block3.add_instruction_exec(generate_multi_channel_waveform())
loop_block3.add_instruction_exec(generate_multi_channel_waveform())
loop_block411 = InstructionBlock()
loop_block411.add_instruction_exec(
MultiChannelWaveform([generate_waveform('A')]))
loop_block412 = InstructionBlock()
loop_block412.add_instruction_exec(
MultiChannelWaveform([generate_waveform('A')]))
loop_block41 = InstructionBlock()
loop_block41.add_instruction_repj(7,
ImmutableInstructionBlock(loop_block411))
loop_block41.add_instruction_repj(8,
ImmutableInstructionBlock(loop_block412))
loop_block421 = InstructionBlock()
loop_block421.add_instruction_exec(
MultiChannelWaveform([generate_waveform('B')]))
loop_block422 = InstructionBlock()
loop_block422.add_instruction_exec(
MultiChannelWaveform([generate_waveform('B')]))
loop_block42 = InstructionBlock()
loop_block42.add_instruction_repj(10,
ImmutableInstructionBlock(loop_block421))
loop_block42.add_instruction_repj(11,
ImmutableInstructionBlock(loop_block422))
chan_block4A = InstructionBlock()
chan_block4A.add_instruction_repj(6,
ImmutableInstructionBlock(loop_block41))
chan_block4B = InstructionBlock()
chan_block4B.add_instruction_repj(9,
ImmutableInstructionBlock(loop_block42))
loop_block4 = InstructionBlock()
loop_block4.add_instruction_chan({
frozenset('A'):
ImmutableInstructionBlock(chan_block4A),
frozenset('B'):
ImmutableInstructionBlock(chan_block4B)
})
root_block = InstructionBlock()
root_block.add_instruction_exec(generate_multi_channel_waveform())
root_block.add_instruction_repj(10, ImmutableInstructionBlock(loop_block1))
root_block.add_instruction_repj(17, ImmutableInstructionBlock(loop_block2))
root_block.add_instruction_repj(3, ImmutableInstructionBlock(loop_block3))
root_block.add_instruction_repj(4, ImmutableInstructionBlock(loop_block4))
return root_block