def build_sequence_branch(self, delegator: SequencingElement, if_branch: SequencingElement, else_branch: SequencingElement, sequencer: Sequencer, parameters: Dict[str, Parameter], conditions: Dict[str, Condition], measurement_mapping: Dict[str, str], channel_mapping: Dict[ChannelID, ChannelID], instruction_block: InstructionBlock) -> None: if_block = InstructionBlock() else_block = InstructionBlock() instruction_block.add_instruction_cjmp(self.__trigger, if_block) sequencer.push(if_branch, parameters, conditions, window_mapping=measurement_mapping, channel_mapping=channel_mapping, target_block=if_block) instruction_block.add_instruction_goto(else_block) sequencer.push(else_branch, parameters, conditions, window_mapping=measurement_mapping, channel_mapping=channel_mapping, target_block=else_block) if_block.return_ip = InstructionPointer(instruction_block, len(instruction_block.instructions)) else_block.return_ip = if_block.return_ip
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_create_embedded_block(self) -> None: parent_block = InstructionBlock() block = InstructionBlock() block.return_ip = InstructionPointer(parent_block, 18) self.__verify_block( block, [], [GOTOInstruction(InstructionPointer(parent_block, 18))], InstructionPointer(parent_block, 18)) self.__verify_block(parent_block, [], [STOPInstruction()], None)
def test_add_instruction_stop(self) -> None: block = InstructionBlock() expected_instructions = [STOPInstruction(), STOPInstruction()] block.add_instruction_stop() block.add_instruction_stop() expected_compiled_instructions = expected_instructions.copy() expected_compiled_instructions.append(STOPInstruction()) self.__verify_block(block, expected_instructions, expected_compiled_instructions, None)
def test_empty_returning_block(self) -> None: return_block = InstructionBlock() block = InstructionBlock() block.return_ip = InstructionPointer(return_block, 7) context = { return_block: ImmutableInstructionBlock(return_block, dict()) } immutable_block = ImmutableInstructionBlock(block, context) self.__verify_block(block, immutable_block, context)
def test_equality(self) -> None: blocks = [InstructionBlock(), InstructionBlock()] blocks.append(InstructionBlock()) ips = [] for block in blocks: for offset in [0, 1, 2352]: ip = InstructionPointer(block, offset) self.assertEqual(ip, ip) for other in ips: self.assertNotEqual(ip, other) self.assertNotEqual(other, ip) self.assertNotEqual(hash(ip), hash(other)) ips.append(ip)
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_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_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 __init__(self) -> None: """Create a Sequencer.""" super().__init__() self.__waveforms = dict() # type: Dict[int, Waveform] self.__main_block = InstructionBlock() self.__sequencing_stacks = \ {self.__main_block: []} # type: Dict[InstructionBlock, List[Sequencer.StackElement]]
def test_build_path_o2_m1_i1_t_m2_i0_i1_f_one_element_main_block_adds_one_element_requires_stop_new_block(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} new_block = InstructionBlock() new_elem = DummySequencingElement(True) elem = DummySequencingElement(False, (new_block, [new_elem])) sequencer.push(elem, ps, cs) sequence = sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertIs(elem, sequence[0].elem) self.assertEqual(ps, elem.parameters) self.assertEqual(cs, elem.conditions) self.assertEqual(1, elem.requires_stop_call_counter) self.assertEqual(1, elem.build_call_counter) self.assertEqual(ps, new_elem.parameters) self.assertEqual(cs, new_elem.conditions) self.assertEqual(1, new_elem.requires_stop_call_counter) self.assertEqual(0, new_elem.build_call_counter) self.assertEqual(STOPInstruction(), sequence[1]) self.assertEqual(2, len(sequence))
def test_build_path_o1_m2_i1_f_i1_f_one_element_custom_and_main_block_requires_stop(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} wm = {} cm = {} elem_main = DummySequencingElement(True) sequencer.push(elem_main, ps, cs, channel_mapping=cm) elem_cstm = DummySequencingElement(True) target_block = InstructionBlock() sequencer.push(elem_cstm, ps, cs, window_mapping=wm, channel_mapping=cm, target_block=target_block) sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertEqual(ps, elem_main.parameters) self.assertEqual(cs, elem_main.conditions) self.assertEqual(1, elem_main.requires_stop_call_counter) self.assertEqual(0, elem_main.build_call_counter) self.assertEqual(ps, elem_cstm.parameters) self.assertEqual(cs, elem_cstm.conditions) self.assertEqual(1, elem_cstm.requires_stop_call_counter) self.assertEqual(0, elem_cstm.build_call_counter)
def test_build_path_o2_m2_i1_f_i2_tf_m2_i1_f_i1_f_two_elements_custom_block_last_requires_stop_one_element_requires_stop_main_block(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} wm = {'foo': 'bar'} target_block = InstructionBlock() elem2 = DummySequencingElement(True) sequencer.push(elem2, ps, cs, window_mapping=wm, target_block=target_block) elem1 = DummySequencingElement(False) sequencer.push(elem1, ps, cs, window_mapping=wm, target_block=target_block) elem_main = DummySequencingElement(True) sequencer.push(elem_main, ps, cs) sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertIs(target_block, elem1.target_block) self.assertEqual(ps, elem1.parameters) self.assertEqual(cs, elem1.conditions) self.assertEqual(1, elem1.requires_stop_call_counter) self.assertEqual(1, elem1.build_call_counter) self.assertEqual(ps, elem2.parameters) self.assertEqual(cs, elem2.conditions) self.assertEqual(2, elem2.requires_stop_call_counter) self.assertEqual(0, elem2.build_call_counter) self.assertEqual(ps, elem_main.parameters) self.assertEqual(cs, elem_main.conditions) self.assertEqual(2, elem_main.requires_stop_call_counter) self.assertEqual(0, elem_main.build_call_counter)
def test_build_path_o2_m2_i1_t_i1_t_m2_i0_i0_one_element_custom_block_one_element_main_block(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} elem_main = DummySequencingElement(False) sequencer.push(elem_main, ps, cs) target_block = InstructionBlock() elem_cstm = DummySequencingElement(False) sequencer.push(elem_cstm, ps, cs, target_block=target_block) sequence = sequencer.build() self.assertTrue(sequencer.has_finished()) self.assertIs(elem_main, sequence[0].elem) self.assertEqual(ps, elem_main.parameters) self.assertEqual(cs, elem_main.conditions) self.assertEqual(1, elem_main.requires_stop_call_counter) self.assertEqual(1, elem_main.build_call_counter) self.assertIs(target_block, elem_cstm.target_block) self.assertEqual(ps, elem_cstm.parameters) self.assertEqual(cs, elem_cstm.conditions) self.assertEqual(1, elem_cstm.requires_stop_call_counter) self.assertEqual(1, elem_cstm.build_call_counter) self.assertEqual(STOPInstruction(), sequence[1]) self.assertEqual(2, len(sequence))
def test_build_path_o2_m1_i2_tf_m2_i1_f_i1_f_two_elements_main_block_last_requires_stop_add_one_element_requires_stop_new_block(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} new_block = InstructionBlock() new_elem = DummySequencingElement(True) elem1 = DummySequencingElement(False, (new_block, [new_elem])) elem2 = DummySequencingElement(True) sequencer.push(elem2, ps, cs) sequencer.push(elem1, ps, cs) instr, stop = sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertIs(elem1, instr.elem) self.assertEqual(ps, elem1.parameters) self.assertEqual(cs, elem1.conditions) self.assertEqual(1, elem1.requires_stop_call_counter) self.assertEqual(1, elem1.build_call_counter) self.assertEqual(ps, elem2.parameters) self.assertEqual(cs, elem2.conditions) self.assertEqual(2, elem2.requires_stop_call_counter) self.assertEqual(0, elem2.build_call_counter) self.assertEqual(ps, new_elem.parameters) self.assertEqual(cs, new_elem.conditions) self.assertEqual(1, new_elem.requires_stop_call_counter) self.assertEqual(0, new_elem.build_call_counter) self.assertEqual(STOPInstruction(), stop)
def test_initialization(self) -> None: block = InstructionBlock() trigger = Trigger() for offset in [0, 1, 23]: instr = CJMPInstruction(trigger, InstructionPointer(block, offset)) self.assertEqual(trigger, instr.trigger) self.assertEqual(block, instr.target.block) self.assertEqual(offset, instr.target.offset)
def build_sequence_loop(self, delegator: SequencingElement, body: SequencingElement, sequencer: Sequencer, parameters: Dict[str, Parameter], conditions: Dict[str, Condition], measurement_mapping: Dict[str, str], channel_mapping: Dict[ChannelID, ChannelID], instruction_block: InstructionBlock) -> None: body_block = InstructionBlock() body_block.return_ip = InstructionPointer(instruction_block, len(instruction_block.instructions)) instruction_block.add_instruction_cjmp(self.__trigger, body_block) sequencer.push(body, parameters, conditions, window_mapping=measurement_mapping, channel_mapping=channel_mapping, target_block=body_block)
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_initialization(self) -> None: block = InstructionBlock() for count in [0, 1, 47]: for offset in [0, 1, 23]: instr = REPJInstruction(count, InstructionPointer(block, offset)) self.assertEqual(count, instr.count) self.assertEqual(block, instr.target.block) self.assertEqual(offset, instr.target.offset)
def test_equality(self) -> None: blocks = [InstructionBlock(), InstructionBlock()] for offset in [0, 1, 23]: instrA = GOTOInstruction(InstructionPointer(blocks[0], offset)) instrB = GOTOInstruction(InstructionPointer(blocks[0], offset)) self.assertEqual(instrA, instrB) self.assertEqual(instrB, instrA) instrs = [] for block in blocks: for offset in [0, 17]: instruction = GOTOInstruction(InstructionPointer( block, offset)) self.assertEqual(instruction, instruction) for other in instrs: self.assertNotEqual(instruction, other) self.assertNotEqual(other, instruction) self.assertNotEqual(hash(instruction), hash(other)) instrs.append(instruction)
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_nested_goto(self) -> None: parent_block = InstructionBlock() block = InstructionBlock() block.return_ip = InstructionPointer(parent_block, 1) parent_block.add_instruction_goto(block) context = dict() immutable_block = ImmutableInstructionBlock(parent_block, context) self.__verify_block(parent_block, immutable_block, context)
def test_iterable_empty_return(self) -> None: parent_block = InstructionBlock() block = AbstractInstructionBlockStub([], InstructionPointer( parent_block, 13)) count = 0 for instruction in block: self.assertEqual(0, count) self.assertIsInstance(instruction, GOTOInstruction) self.assertEqual(InstructionPointer(parent_block, 13), instruction.target) count += 1
def test_insert_measurement_instruction(self): pulse = self.to_test_constructor(measurements=[('mw', 'a', 'd')]) parameters = {'a': ConstantParameter(0), 'd': ConstantParameter(0.9)} measurement_mapping = {'mw': 'as'} block = InstructionBlock() pulse.insert_measurement_instruction( instruction_block=block, parameters=parameters, measurement_mapping=measurement_mapping) expected_block = [MEASInstruction([('as', 0, 0.9)])] self.assertEqual(block.instructions, expected_block)
def test_item_access_empty_return(self) -> None: parent_block = InstructionBlock() block = AbstractInstructionBlockStub([], InstructionPointer( parent_block, 84)) self.assertEqual(GOTOInstruction(InstructionPointer(parent_block, 84)), block[0]) with self.assertRaises(IndexError): block[1] self.assertEqual(GOTOInstruction(InstructionPointer(parent_block, 84)), block[-1]) with self.assertRaises(IndexError): block[-2]
def test_nested_no_context_argument(self) -> None: parent_block = InstructionBlock() block = InstructionBlock() block.return_ip = InstructionPointer(parent_block, 1) parent_block.add_instruction_goto(block) immutable_block = ImmutableInstructionBlock(parent_block) context = { parent_block: immutable_block, block: immutable_block.instructions[0].target.block } self.__verify_block(parent_block, immutable_block, context)
def test_iterable_return(self) -> None: parent_block = InstructionBlock() wf = DummyWaveform() block = AbstractInstructionBlockStub([EXECInstruction(wf)], InstructionPointer( parent_block, 11)) count = 0 for expected_instruction, instruction in zip([ EXECInstruction(wf), GOTOInstruction(InstructionPointer(parent_block, 11)) ], block): self.assertEqual(expected_instruction, instruction) count += 1 self.assertEqual(2, count)
def test_item_access_return(self) -> None: wf = DummyWaveform() parent_block = InstructionBlock() block = AbstractInstructionBlockStub([EXECInstruction(wf)], InstructionPointer( parent_block, 29)) self.assertEqual(EXECInstruction(wf), block[0]) self.assertEqual(GOTOInstruction(InstructionPointer(parent_block, 29)), block[1]) with self.assertRaises(IndexError): block[2] self.assertEqual(GOTOInstruction(InstructionPointer(parent_block, 29)), block[-1]) self.assertEqual(EXECInstruction(wf), block[-2]) with self.assertRaises(IndexError): block[-3]