def test_get_channels(self): """Test requesting channels from the system.""" self.assertEqual(self.config.drive(0), DriveChannel(0)) self.assertEqual(self.config.measure(1), MeasureChannel(1)) self.assertEqual(self.config.acquire(0), AcquireChannel(0)) with self.assertRaises(BackendConfigurationError): # Check that an error is raised if the system doesn't have that many qubits self.assertEqual(self.config.acquire(10), AcquireChannel(10)) self.assertEqual(self.config.control(qubits=[0, 1]), [ControlChannel(0)]) with self.assertRaises(BackendConfigurationError): # Check that an error is raised if key not found in self._qubit_channel_map self.config.control(qubits=(10, 1))
def test_persistent_value(self): """Test converted qobj from PersistentValueInstruction.""" cmd = PersistentValue(value=0.1j) instruction = cmd(ControlChannel(1)) qobj = PulseQobjInstruction(name='pv', ch='u1', t0=0, val=0.1j) converted_instruction = self.converter(qobj) self.assertEqual(converted_instruction.timeslots, instruction.timeslots) self.assertEqual(converted_instruction.instructions[0][-1].command, cmd)
def test_constant_pulse_instruction(self): """Test that parametric pulses are correctly converted to PulseQobjInstructions.""" converter = InstructionToQobjConverter(PulseQobjInstruction, meas_level=2) instruction = Play(Constant(duration=25, amp=1), ControlChannel(2)) valid_qobj = PulseQobjInstruction( name='parametric_pulse', pulse_shape='constant', ch='u2', t0=20, parameters={'duration': 25, 'amp': 1}) self.assertEqual(converter(20, instruction), valid_qobj)
def setUp(self): qubits = [ Qubit(0, drive_channels=[DriveChannel(0, 1.2)], control_channels=[ControlChannel(0)]), Qubit(1, drive_channels=[DriveChannel(1, 3.4)], acquire_channels=[AcquireChannel(1)]) ] registers = [RegisterSlot(i) for i in range(2)] mem_slots = [MemorySlot(i) for i in range(2)] self.two_qubit_device = DeviceSpecification(qubits, registers, mem_slots)
def test_creation_from_backend_with_zero_u_channels(self): """Test creation of device specification from backend. """ backend = FakeOpenPulse2Q() device = PulseChannelSpec.from_backend(backend) self.assertEqual(device.drives[0], DriveChannel(0)) self.assertEqual(device.controls[0], ControlChannel(0)) self.assertEqual(device.measures[0], MeasureChannel(0)) self.assertEqual(device.acquires[0], AcquireChannel(0)) self.assertEqual(device.registers[0], RegisterSlot(0)) self.assertEqual(device.memoryslots[0], MemorySlot(0))
def test_persistent_value(self): """Test converted qobj from PersistentValueInstruction.""" with self.assertWarns(DeprecationWarning): cmd = PersistentValue(value=0.1j) with self.assertWarns(DeprecationWarning): instruction = cmd(ControlChannel(1)) qobj = PulseQobjInstruction(name='pv', ch='u1', t0=0, val=0.1j) with self.assertWarns(DeprecationWarning): converted_instruction = self.converter(qobj) self.assertEqual(converted_instruction.timeslots, instruction.timeslots) self.assertEqual(converted_instruction.instructions[0][-1], instruction)
def test_get_qubit_channels(self): """Test to get all channels operated on a given qubit.""" self.assertTrue( self._test_lists_equal( actual=self.config.get_qubit_channels(qubit=(1, )), expected=[ DriveChannel(1), MeasureChannel(1), AcquireChannel(1) ], )) self.assertTrue( self._test_lists_equal( actual=self.config.get_qubit_channels(qubit=1), expected=[ ControlChannel(0), ControlChannel(1), AcquireChannel(1), DriveChannel(1), MeasureChannel(1), ], )) backend_3q = self.provider.get_backend("fake_openpulse_3q") self.assertTrue( self._test_lists_equal( actual=backend_3q.configuration().get_qubit_channels(1), expected=[ MeasureChannel(1), ControlChannel(0), ControlChannel(2), AcquireChannel(1), DriveChannel(1), ControlChannel(1), ], )) with self.assertRaises(BackendConfigurationError): # Check that an error is raised if key not found in self._channel_qubit_map self.config.get_qubit_channels(10)
def setUp(self): @functional_pulse def linear(duration, slope, intercept): x = np.linspace(0, duration - 1, duration) return slope * x + intercept self.linear = linear qubits = [Qubit(0, DriveChannel(0), AcquireChannel(0), MeasureChannel(0), control_channels=[ControlChannel(0)]), Qubit(1, DriveChannel(1), MeasureChannel(0), AcquireChannel(1))] registers = [RegisterSlot(i) for i in range(2)] mem_slots = [MemorySlot(i) for i in range(2)] self.two_qubit_device = DeviceSpecification(qubits, registers, mem_slots)
def test_parameterized_persistent_value(self): """Test converted qobj from PersistentValueInstruction.""" cmd = PersistentValue(value=0.5+0.j) instruction = cmd(ControlChannel(1)) << 10 qobj = PulseQobjInstruction(name='pv', ch='u1', t0=10, val='P1*cos(np.pi*P2)') converted_instruction = self.converter(qobj) self.assertIsInstance(converted_instruction, ParameterizedSchedule) evaluated_instruction = converted_instruction.bind_parameters(P1=0.5, P2=0.) self.assertEqual(evaluated_instruction.timeslots, instruction.timeslots) self.assertEqual(evaluated_instruction.instructions[0][-1].command, cmd)
def test_parameterized_gate(self): """Test for parameterized pulse gate.""" amp = Parameter("amp") angle = Parameter("angle") mygate = Gate("mygate", 2, [amp, angle]) with builder.build() as caldef: builder.play(Constant(100, amp * np.exp(1j * angle)), ControlChannel(0)) qc = QuantumCircuit(2) qc.append(mygate, [0, 1]) qc.add_calibration(mygate, (0, 1), caldef) self.assert_roundtrip_equal(qc)
def setUp(self): super().setUp() qubits = [ Qubit(0, DriveChannel(0), AcquireChannel(0), MeasureChannel(0), control_channels=[ControlChannel(0)]), Qubit(1, DriveChannel(1), MeasureChannel(0), AcquireChannel(1)) ] registers = [RegisterSlot(i) for i in range(2)] mem_slots = [MemorySlot(i) for i in range(2)] self.two_qubit_device = DeviceSpecification(qubits, registers, mem_slots)
def setUp(self): self.schedule = Schedule() self.qubits = [ Qubit(0, drive_channel=DriveChannel(0), control_channels=[ControlChannel(0)], measure_channel=MeasureChannel(0), acquire_channel=AcquireChannel(0)), Qubit(1, drive_channel=DriveChannel(1), acquire_channel=AcquireChannel(1), measure_channel=MeasureChannel(1)) ] self.registers = [RegisterSlot(i) for i in range(2)] self.mem_slots = [MemorySlot(i) for i in range(2)] self.device = DeviceSpecification(self.qubits, self.registers, self.mem_slots)
def test_constant_pulse_instruction(self): """Test that parametric pulses are correctly converted to PulseQobjInstructions.""" converter = InstructionToQobjConverter(PulseQobjInstruction, meas_level=2) instruction = Play(Constant(duration=25, amp=1), ControlChannel(2)) valid_qobj = PulseQobjInstruction( name="parametric_pulse", pulse_shape="constant", ch="u2", t0=20, parameters={ "duration": 25, "amp": 1 }, ) self.assertEqual(converter(20, instruction), valid_qobj)
def test_parameterized_persistent_value(self): """Test converted qobj from PersistentValueInstruction.""" with self.assertWarns(DeprecationWarning): cmd = PersistentValue(value=0.5+0.j) with self.assertWarns(DeprecationWarning): instruction = cmd(ControlChannel(1)) << 10 qobj = PulseQobjInstruction(name='pv', ch='u1', t0=10, val='P1*cos(np.pi*P2)') converted_instruction = self.converter(qobj) self.assertIsInstance(converted_instruction, ParameterizedSchedule) with self.assertWarns(DeprecationWarning): evaluated_instruction = converted_instruction.bind_parameters(P1=0.5, P2=0.) self.assertEqual(evaluated_instruction.start_time, instruction.start_time) self.assertEqual(evaluated_instruction.duration, instruction.duration) self.assertEqual(evaluated_instruction.instructions[0][-1].command, cmd)
def control(self, qubit: int) -> ControlChannel: """ Return the secondary drive channel for the given qubit -- typically utilized for controlling multiqubit interactions. This channel is derived from other channels. Raises: BackendConfigurationError: If the qubit is not a part of the system. Returns: Qubit control channel. """ # TODO: Determine this from the hamiltonian. warnings.warn( "The control channel appropriate for an interaction should be determined " "from the hamiltonian. This will be determined for you in the future." ) if qubit > self.n_qubits: raise BackendConfigurationError( "This system does not have {} qubits.".format(qubit)) return ControlChannel(qubit)
def test_barrier(self): """Test barrier.""" with builder.build() as test_sched: builder.barrier(DriveChannel(0), DriveChannel(1), ControlChannel(2)) self.assert_roundtrip_equal(test_sched)
def test_default(self): """Test default control channel.""" control_channel = ControlChannel(123) self.assertEqual(control_channel.index, 123) self.assertEqual(control_channel.name, "u123")