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