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