def test_render_loop_compare(self) -> None:
wf1 = DummyWaveform(duration=19)
wf2 = DummyWaveform(duration=21)
block = InstructionBlock()
block.add_instruction_exec(wf1)
block.add_instruction_meas([('asd', 0, 1), ('asd', 1, 1)])
block.add_instruction_exec(wf2)
mcp = MultiChannelProgram(block)
loop = next(iter(mcp.programs.values()))
block_times, block_voltages, _ = render(block, sample_rate=0.5)
loop_times, loop_voltages, _ = render(loop, sample_rate=0.5)
numpy.testing.assert_equal(block_times, loop_times)
numpy.testing.assert_equal(block_voltages, loop_voltages)
block_times, block_voltages, block_measurements = render(
block, sample_rate=0.5, render_measurements=True)
loop_times, loop_voltages, loop_measurements = render(
loop, sample_rate=0.5, render_measurements=True)
numpy.testing.assert_equal(block_times, loop_times)
numpy.testing.assert_equal(block_voltages, loop_voltages)
self.assertEqual(block_measurements, loop_measurements)
def test_render(self) -> None:
with self.assertWarnsRegex(DeprecationWarning, ".*InstructionBlock.*"):
wf1 = DummyWaveform(duration=19)
wf2 = DummyWaveform(duration=21)
block = InstructionBlock()
block.add_instruction_exec(wf1)
block.add_instruction_meas([('asd', 0, 1)])
block.add_instruction_exec(wf2)
wf1_expected = ('A', [0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
wf2_expected = ('A', [
x - 19 for x in [20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40]
])
wf1_output_array_len_expected = len(wf1_expected[1])
wf2_output_array_len_expected = len(wf2_expected[1])
wf1.sample_output = numpy.linspace(start=4,
stop=5,
num=len(wf1_expected[1]))
wf2.sample_output = numpy.linspace(6, 7, num=len(wf2_expected[1]))
expected_times = numpy.arange(start=0, stop=42, step=2)
expected_result = numpy.concatenate(
(wf1.sample_output, wf2.sample_output))
times, voltages, _ = render(block, sample_rate=0.5)
self.assertEqual(len(wf1.sample_calls), 1)
self.assertEqual(len(wf2.sample_calls), 1)
self.assertEqual(wf1_expected[0], wf1.sample_calls[0][0])
self.assertEqual(wf2_expected[0], wf2.sample_calls[0][0])
numpy.testing.assert_almost_equal(wf1_expected[1],
wf1.sample_calls[0][1])
numpy.testing.assert_almost_equal(wf2_expected[1],
wf2.sample_calls[0][1])
self.assertEqual(wf1_output_array_len_expected,
len(wf1.sample_calls[0][2]))
self.assertEqual(wf2_output_array_len_expected,
len(wf2.sample_calls[0][2]))
self.assertEqual(voltages.keys(), dict(A=0).keys())
numpy.testing.assert_almost_equal(expected_times, times)
numpy.testing.assert_almost_equal(expected_result, voltages['A'])
self.assertEqual(expected_result.shape, voltages['A'].shape)
times, voltages, measurements = render(block,
sample_rate=0.5,
render_measurements=True)
self.assertEqual(voltages.keys(), dict(A=0).keys())
numpy.testing.assert_almost_equal(expected_times, times)
numpy.testing.assert_almost_equal(expected_result, voltages['A'])
self.assertEqual(expected_result.shape, voltages['A'].shape)
self.assertEqual(measurements, [('asd', 19, 1)])
def test_render_warning(self) -> None:
wf1 = DummyWaveform(duration=19)
wf2 = DummyWaveform(duration=21)
block = InstructionBlock()
block.add_instruction_exec(wf1)
block.add_instruction_meas([('asd', 0, 1)])
block.add_instruction_exec(wf2)
with self.assertWarns(UserWarning):
render(block, sample_rate=0.51314323423)
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_render_block_time_slice(self) -> None:
with self.assertWarnsRegex(DeprecationWarning, ".*InstructionBlock.*"):
with self.assertRaises(ValueError):
wf1 = DummyWaveform(duration=19)
wf2 = DummyWaveform(duration=21)
block = InstructionBlock()
block.add_instruction_exec(wf1)
block.add_instruction_exec(wf2)
times, voltages, _ = render(block,
sample_rate=0.5,
time_slice=(1, 16))
def test_run_program(self):
wf = DummyWaveform(duration=1.1, defined_channels={'A', 'B'})
block = InstructionBlock()
block.add_instruction_meas([('m1', 0., 1.)])
block.add_instruction_exec(wf)
awg1 = DummyAWG()
awg2 = DummyAWG()
awg3 = DummyAWG()
dac1 = DummyDAC()
dac2 = DummyDAC()
setup = HardwareSetup()
setup.set_channel('A', PlaybackChannel(awg1, 0))
setup.set_channel('B', MarkerChannel(awg2, 0))
setup.set_channel('C', MarkerChannel(awg3, 0))
setup.set_measurement('m1', MeasurementMask(dac1, 'DAC_1'))
setup.set_measurement('m2', MeasurementMask(dac2, 'DAC_2'))
class ProgStart:
def __init__(self):
self.was_started = False
def __call__(self):
self.was_started = True
program_started = ProgStart()
setup.register_program('test', block, run_callback=program_started)
self.assertIsNone(awg1._armed)
self.assertIsNone(awg2._armed)
self.assertIsNone(awg3._armed)
self.assertIsNone(dac1._armed_program)
self.assertIsNone(dac2._armed_program)
setup.run_program('test')
self.assertEqual(awg1._armed, 'test')
self.assertEqual(awg2._armed, 'test')
self.assertIsNone(awg3._armed)
self.assertEqual(dac1._armed_program, 'test')
self.assertIsNone(dac2._armed_program)
self.assertTrue(program_started.was_started)
def test_add_instruction_exec(self) -> None:
block = InstructionBlock()
expected_instructions = []
waveforms = [DummyWaveform(), DummyWaveform(), DummyWaveform()]
LOOKUP = [0, 1, 1, 0, 2, 1, 0, 0, 0, 1, 2, 2]
for id in LOOKUP:
waveform = waveforms[id]
instruction = EXECInstruction(waveform)
expected_instructions.append(instruction)
block.add_instruction_exec(waveform)
expected_compiled_instructions = expected_instructions.copy()
expected_compiled_instructions.append(STOPInstruction())
self.__verify_block(block, expected_instructions,
expected_compiled_instructions, None)
def test_build_sequence(self):
wfs = [
DummyWaveform(duration=1.1, defined_channels={'A'}),
DummyWaveform(duration=1.1, defined_channels={'B'})
]
sts = [
DummyPulseTemplate(duration='t1',
defined_channels={'A'},
waveform=wfs[0],
measurements=[('m', 0, 1)]),
DummyPulseTemplate(duration='t1',
defined_channels={'B'},
waveform=wfs[1]),
DummyPulseTemplate(duration='t1',
defined_channels={'C'},
waveform=None)
]
pt = AtomicMultiChannelPulseTemplate(*sts,
parameter_constraints=['a < b'],
measurements=[('n', .1, .2)])
params = dict(a=ConstantParameter(1.0), b=ConstantParameter(1.1))
measurement_mapping = dict(m='foo', n='bar')
channel_mapping = {'A': 'A', 'B': 'B', 'C': None}
block = InstructionBlock()
pt.build_sequence(None,
parameters=params,
conditions={},
measurement_mapping=measurement_mapping,
channel_mapping=channel_mapping,
instruction_block=block)
expected_waveform = MultiChannelWaveform(wfs)
expected_block = InstructionBlock()
measurements = [('bar', .1, .2), ('foo', 0, 1)]
expected_block.add_instruction_meas(measurements)
expected_block.add_instruction_exec(waveform=expected_waveform)
self.assertEqual(len(block.instructions),
len(expected_block.instructions))
self.assertEqual(block.instructions[0].compare_key,
expected_block.instructions[0].compare_key)
self.assertEqual(block.instructions[1].compare_key,
expected_block.instructions[1].compare_key)
def test_remove_program(self):
wf_1 = DummyWaveform(duration=1.1, defined_channels={'A', 'B'})
wf_2 = DummyWaveform(duration=1.1, defined_channels={'A', 'C'})
block_1 = InstructionBlock()
block_2 = InstructionBlock()
block_1.add_instruction_meas([('m1', 0., 1.)])
block_1.add_instruction_exec(wf_1)
block_2.add_instruction_meas([('m2', 0., 1.)])
block_2.add_instruction_exec(wf_2)
awg1 = DummyAWG()
awg2 = DummyAWG()
awg3 = DummyAWG()
dac1 = DummyDAC()
dac2 = DummyDAC()
setup = HardwareSetup()
setup.set_channel('A', PlaybackChannel(awg1, 0))
setup.set_channel('B', MarkerChannel(awg2, 0))
setup.set_channel('C', MarkerChannel(awg3, 0))
setup.set_measurement('m1', MeasurementMask(dac1, 'DAC_1'))
setup.set_measurement('m2', MeasurementMask(dac2, 'DAC_2'))
setup.register_program('test_1', block_1)
setup.register_program('test_2', block_2)
setup.arm_program('test_1')
setup.remove_program('test_1')
self.assertEqual(setup.registered_programs.keys(), {'test_2'})
self.assertIsNone(awg1._armed)
self.assertIsNone(awg2._armed)
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 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_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))
def test_multiple_nested_block_construction(self) -> None:
main_block = InstructionBlock()
blocks = []
waveforms = [DummyWaveform(), DummyWaveform(), DummyWaveform()]
main_block.add_instruction_exec(waveforms[0])
block = InstructionBlock()
trigger = Trigger()
main_block.add_instruction_cjmp(trigger, block)
block.return_ip = InstructionPointer(main_block, len(main_block))
blocks.append(block)
block = InstructionBlock()
trigger = Trigger()
main_block.add_instruction_cjmp(trigger, block)
block.return_ip = InstructionPointer(main_block, len(main_block))
blocks.append(block)
WAVEFORM_LOOKUP = [[2, 2, 1, 1], [0, 1, 1, 0, 2, 1]]
for i in [0, 1]:
block = blocks[i]
lookup = WAVEFORM_LOOKUP[i]
for id in lookup:
waveform = waveforms[id]
block.add_instruction_exec(waveform)
block = InstructionBlock()
blocks[0].add_instruction_cjmp(trigger, block)
block.return_ip = InstructionPointer(blocks[0], len(blocks[0]))
blocks.append(block)
for id in [1, 2, 0, 2]:
waveform = waveforms[id]
block.add_instruction_exec(waveform)
context = dict()
immutable_block = ImmutableInstructionBlock(main_block, context)
self.__verify_block(main_block, immutable_block, context.copy())
def test_clear_programs(self) -> None:
setup = HardwareSetup()
awg1 = DummyAWG(num_channels=2, num_markers=0)
awg2 = DummyAWG(num_channels=1, num_markers=1)
dac1 = DummyDAC()
dac2 = DummyDAC()
setup.set_channel('A', PlaybackChannel(awg1, 0))
setup.set_channel('B', PlaybackChannel(awg1, 1))
setup.set_channel('C', PlaybackChannel(awg2, 0))
setup.set_channel('M1', MarkerChannel(awg2, 0))
wf1 = DummyWaveform(duration=1.1, defined_channels={'C'})
wf2 = DummyWaveform(duration=7.2, defined_channels={'A'})
wf3 = DummyWaveform(duration=3.7, defined_channels={'B', 'C'})
setup.set_measurement('m1', MeasurementMask(dac1, 'DAC_1'))
setup.set_measurement('m2', MeasurementMask(dac2, 'DAC_2'))
block1 = InstructionBlock()
block1.add_instruction_exec(wf1)
block2 = InstructionBlock()
block2.add_instruction_meas([('m1', 0., 1.)])
block2.add_instruction_exec(wf2)
block3 = InstructionBlock()
block3.add_instruction_meas([('m2', 2., 3.)])
block3.add_instruction_exec(wf3)
setup.register_program('prog1', block1)
setup.register_program('prog2', block2)
setup.register_program('prog3', block3)
self.assertTrue(setup.registered_programs)
setup.clear_programs()
self.assertFalse(setup.registered_programs)
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 test_nested_block_construction(self) -> None:
main_block = InstructionBlock()
expected_instructions = [[], [], [], []]
expected_compiled_instructions = [[], [], [], []]
expected_return_ips = [None]
blocks = []
waveforms = [DummyWaveform(), DummyWaveform(), DummyWaveform()]
main_block.add_instruction_exec(waveforms[0])
expected_instructions[0].append(EXECInstruction(waveforms[0]))
block = InstructionBlock()
trigger = Trigger()
ip = InstructionPointer(block)
main_block.add_instruction_cjmp(trigger, block)
expected_instructions[0].append(CJMPInstruction(trigger, ip))
block.return_ip = InstructionPointer(main_block, len(main_block))
expected_return_ips.append(
InstructionPointer(main_block, len(main_block)))
blocks.append(block)
block = InstructionBlock()
trigger = Trigger()
ip = InstructionPointer(block)
main_block.add_instruction_cjmp(trigger, block)
expected_instructions[0].append(CJMPInstruction(trigger, ip))
block.return_ip = InstructionPointer(main_block, len(main_block))
expected_return_ips.append(
InstructionPointer(main_block, len(main_block)))
blocks.append(block)
WAVEFORM_LOOKUP = [[2, 2, 1, 1], [0, 1, 1, 0, 2, 1]]
for i in [0, 1]:
block = blocks[i]
lookup = WAVEFORM_LOOKUP[i]
for id in lookup:
waveform = waveforms[id]
expected_instructions[i + 1].append(EXECInstruction(waveform))
block.add_instruction_exec(waveform)
block = InstructionBlock()
ip = InstructionPointer(block)
blocks[0].add_instruction_cjmp(trigger, block)
expected_instructions[1].append(CJMPInstruction(trigger, ip))
block.return_ip = InstructionPointer(blocks[0], len(blocks[0]))
expected_return_ips.append(
InstructionPointer(blocks[0], len(blocks[0])))
blocks.append(block)
for id in [1, 2, 0, 2]:
waveform = waveforms[id]
expected_instructions[3].append(EXECInstruction(waveform))
block.add_instruction_exec(waveform)
for i in [0, 1, 2, 3]:
expected_compiled_instructions[i] = expected_instructions[i].copy()
expected_compiled_instructions[0].append(STOPInstruction())
for i in [0, 1, 2]:
expected_compiled_instructions[i + 1].append(
GOTOInstruction(blocks[i].return_ip))
positions = [0, None, None, None]
positions[3] = len(expected_compiled_instructions[1])
self.__verify_block(blocks[2], expected_instructions[3],
expected_compiled_instructions[3],
expected_return_ips[3])
self.__verify_block(blocks[1], expected_instructions[2],
expected_compiled_instructions[2],
expected_return_ips[2])
self.__verify_block(blocks[0], expected_instructions[1],
expected_compiled_instructions[1],
expected_return_ips[1])
self.__verify_block(main_block, expected_instructions[0],
expected_compiled_instructions[0],
expected_return_ips[0])
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 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