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 test_default(self): """Test default qubit. """ qubit = Qubit(1, DriveChannel(2), MeasureChannel(4), AcquireChannel(5), control_channels=[ControlChannel(3)]) self.assertEqual(qubit.drive, DriveChannel(2)) self.assertEqual(qubit.controls[0], ControlChannel(3)) self.assertEqual(qubit.measure, MeasureChannel(4)) self.assertEqual(qubit.acquire, AcquireChannel(5))
def test_get_channel_lo(self): """Test retrieving channel lo from LO config.""" channel = DriveChannel(0) lo_config = LoConfig({channel: 1.0}) self.assertEqual(lo_config.channel_lo(channel), 1.0) channel = MeasureChannel(0) lo_config = LoConfig({channel: 2.0}) self.assertEqual(lo_config.channel_lo(channel), 2.0) with self.assertRaises(PulseError): lo_config.channel_lo(MeasureChannel(1))
def test_default(self): """Test default qubit. """ qubit = Qubit(1, drive_channels=[DriveChannel(2, 1.2)], control_channels=[ControlChannel(3)], measure_channels=[MeasureChannel(4)], acquire_channels=[AcquireChannel(5)]) self.assertEqual(qubit.drive, DriveChannel(2, 1.2)) self.assertEqual(qubit.control, ControlChannel(3)) self.assertEqual(qubit.measure, MeasureChannel(4)) self.assertEqual(qubit.acquire, AcquireChannel(5))
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 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 test_default(self): """Test default device specification. """ qubits = [ Qubit(0, DriveChannel(0), MeasureChannel(0), AcquireChannel(0)), Qubit(1, DriveChannel(1), MeasureChannel(1), AcquireChannel(1)) ] registers = [RegisterSlot(i) for i in range(2)] mem_slots = [MemorySlot(i) for i in range(2)] spec = DeviceSpecification(qubits, registers, mem_slots) self.assertEqual(spec.q[0].drive, DriveChannel(0)) self.assertEqual(spec.q[1].acquire, AcquireChannel(1)) self.assertEqual(spec.mem[0], MemorySlot(0)) self.assertEqual(spec.c[1], RegisterSlot(1))
def test_default(self): """Test default measure channel. """ measure_channel = MeasureChannel(123) self.assertEqual(measure_channel.index, 123) self.assertEqual(measure_channel.name, 'm123')
def __init__(self, qobj_model, qubit_lo_freq, meas_lo_freq, qubit_lo_range=None, meas_lo_range=None, **run_config): """Create new converter. Args: qobj_model (PulseQobjExperimentConfig): qobj model for experiment config. qubit_lo_freq (list): List of default qubit lo frequencies in Hz. meas_lo_freq (list): List of default meas lo frequencies in Hz. qubit_lo_range (list): List of qubit lo ranges, each of form `[range_min, range_max]` in Hz. meas_lo_range (list): List of measurement lo ranges, each of form `[range_min, range_max]` in Hz. run_config (dict): experimental configuration. """ self.qobj_model = qobj_model self.qubit_lo_freq = qubit_lo_freq self.meas_lo_freq = meas_lo_freq self.run_config = run_config self.default_lo_config = LoConfig() if qubit_lo_range: for i, lo_range in enumerate(qubit_lo_range): self.default_lo_config.add_lo_range(DriveChannel(i), lo_range) if meas_lo_range: for i, lo_range in enumerate(meas_lo_range): self.default_lo_config.add_lo_range(MeasureChannel(i), lo_range)
def test_can_create_valid_user_lo_config(self): """Test if a LoConfig can be created with valid user_los.""" channel1 = DriveChannel(0) channel2 = MeasureChannel(0) user_lo_config = LoConfig({channel1: 1.4, channel2: 3.6}) self.assertEqual(1.4, user_lo_config.qubit_los[channel1]) self.assertEqual(3.6, user_lo_config.meas_los[channel2])
def sample_schedule(self): """Generate a sample schedule that includes the most common elements of pulse schedules.""" gp0 = library.gaussian(duration=20, amp=1.0, sigma=1.0) gp1 = library.gaussian(duration=20, amp=-1.0, sigma=2.0) gs0 = library.gaussian_square(duration=20, amp=-1.0, sigma=2.0, risefall=3) sched = Schedule(name='test_schedule') sched = sched.append(gp0(DriveChannel(0))) sched = sched.insert(0, Play(library.Constant(duration=60, amp=0.2 + 0.4j), ControlChannel(0))) sched = sched.insert(60, ShiftPhase(-1.57, DriveChannel(0))) sched = sched.insert(60, SetFrequency(8.0, DriveChannel(0))) sched = sched.insert(60, SetPhase(3.14, DriveChannel(0))) sched = sched.insert(70, ShiftFrequency(4.0e6, DriveChannel(0))) sched = sched.insert(30, Play(gp1, DriveChannel(1))) sched = sched.insert(60, Play(gp0, ControlChannel(0))) sched = sched.insert(60, Play(gs0, MeasureChannel(0))) sched = sched.insert(90, ShiftPhase(1.57, DriveChannel(0))) sched = sched.insert(90, Acquire(10, AcquireChannel(1), MemorySlot(1), RegisterSlot(1))) sched = sched.append(Delay(100, DriveChannel(0))) sched = sched + sched sched |= Snapshot("snapshot_1", "snap_type") << 60 sched |= Snapshot("snapshot_2", "snap_type") << 120 return sched
def test_buffering(self): """Test channel buffering.""" buffer_chan = DriveChannel(0, buffer=5) measure_chan = MeasureChannel(0, buffer=10) acquire_chan = AcquireChannel(0, buffer=10) memory_slot = MemorySlot(0) gp0 = pulse_lib.gaussian(duration=10, amp=0.7, sigma=3) fc_pi_2 = FrameChange(phase=1.57) # no initial buffer sched = Schedule() sched += gp0(buffer_chan) self.assertEqual(sched.duration, 10) # this pulse should be buffered sched += gp0(buffer_chan) self.assertEqual(sched.duration, 25) # should not be buffered as framechange sched += fc_pi_2(buffer_chan) self.assertEqual(sched.duration, 25) # use buffer with insert sched = sched.insert(sched.duration, gp0(buffer_chan), buffer=True) self.assertEqual(sched.duration, 40) sched = Schedule() sched = gp0(measure_chan) + Acquire(duration=10)(acquire_chan, memory_slot) self.assertEqual(sched.duration, 10)
def test_assemble_parametric(self): """Test that parametric pulses can be assembled properly into a PulseQobj.""" sched = pulse.Schedule(name='test_parametric') sched += Play(pulse.Gaussian(duration=25, sigma=4, amp=0.5j), DriveChannel(0)) sched += Play(pulse.Drag(duration=25, amp=0.2+0.3j, sigma=7.8, beta=4), DriveChannel(1)) sched += Play(pulse.Constant(duration=25, amp=1), DriveChannel(2)) sched += Play(pulse.GaussianSquare(duration=150, amp=0.2, sigma=8, width=140), MeasureChannel(0)) << sched.duration backend = FakeOpenPulse3Q() backend.configuration().parametric_pulses = ['gaussian', 'drag', 'gaussian_square', 'constant'] qobj = assemble(sched, backend) self.assertEqual(qobj.config.pulse_library, []) qobj_insts = qobj.experiments[0].instructions self.assertTrue(all(inst.name == 'parametric_pulse' for inst in qobj_insts)) self.assertEqual(qobj_insts[0].pulse_shape, 'gaussian') self.assertEqual(qobj_insts[1].pulse_shape, 'drag') self.assertEqual(qobj_insts[2].pulse_shape, 'constant') self.assertEqual(qobj_insts[3].pulse_shape, 'gaussian_square') self.assertDictEqual(qobj_insts[0].parameters, {'duration': 25, 'sigma': 4, 'amp': 0.5j}) self.assertDictEqual(qobj_insts[1].parameters, {'duration': 25, 'sigma': 7.8, 'amp': 0.2+0.3j, 'beta': 4}) self.assertDictEqual(qobj_insts[2].parameters, {'duration': 25, 'amp': 1}) self.assertDictEqual(qobj_insts[3].parameters, {'duration': 150, 'sigma': 8, 'amp': 0.2, 'width': 140}) self.assertEqual( qobj.to_dict()['experiments'][0]['instructions'][0]['parameters']['amp'], 0.5j)
def test_bell_schedule(self): """Test complex schedule to create a Bell state.""" with builder.build() as test_sched: with builder.align_sequential(): # H builder.shift_phase(-1.57, DriveChannel(0)) builder.play(Drag(160, 0.05, 40, 1.3), DriveChannel(0)) builder.shift_phase(-1.57, DriveChannel(0)) # ECR with builder.align_left(): builder.play(GaussianSquare(800, 0.05, 64, 544), DriveChannel(1)) builder.play(GaussianSquare(800, 0.1 - 0.2j, 64, 544), ControlChannel(0)) builder.play(Drag(160, 0.1, 40, 1.5), DriveChannel(0)) with builder.align_left(): builder.play(GaussianSquare(800, -0.05, 64, 544), DriveChannel(1)) builder.play(GaussianSquare(800, -0.1 + 0.2j, 64, 544), ControlChannel(0)) builder.play(Drag(160, 0.1, 40, 1.5), DriveChannel(0)) # Measure with builder.align_left(): builder.play(GaussianSquare(8000, 0.2, 64, 7744), MeasureChannel(0)) builder.acquire(8000, AcquireChannel(0), MemorySlot(0)) self.assert_roundtrip_equal(test_sched)
def sample_schedule(self): """Generate a sample schedule that includes the most common elements of pulse schedules.""" gp0 = pulse_lib.gaussian(duration=20, amp=1.0, sigma=1.0) gp1 = pulse_lib.gaussian(duration=20, amp=-1.0, sigma=2.0) gs0 = pulse_lib.gaussian_square(duration=20, amp=-1.0, sigma=2.0, risefall=3) fc_pi_2 = FrameChange(phase=1.57) acquire = Acquire(10) delay = Delay(100) sched = Schedule() sched = sched.append(gp0(DriveChannel(0))) sched = sched.insert( 0, pulse_lib.ConstantPulse(duration=60, amp=0.2 + 0.4j)(ControlChannel(0))) sched = sched.insert(60, FrameChange(phase=-1.57)(DriveChannel(0))) sched = sched.insert(60, SetFrequency(8.0, DriveChannel(0))) sched = sched.insert(30, gp1(DriveChannel(1))) sched = sched.insert(60, gp0(ControlChannel(0))) sched = sched.insert(60, gs0(MeasureChannel(0))) sched = sched.insert(90, fc_pi_2(DriveChannel(0))) sched = sched.insert( 90, acquire(AcquireChannel(1), MemorySlot(1), RegisterSlot(1))) sched = sched.append(delay(DriveChannel(0))) sched = sched + sched sched |= Snapshot("snapshot_1", "snap_type") << 60 sched |= Snapshot("snapshot_2", "snap_type") << 120 return sched
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_can_create_valid_user_lo_config(self): """Test if a LoConfig can be created with valid user_los. """ channel1 = DriveChannel(0, lo_freq=1.2, lo_freq_range=(1.0, 2.0)) channel2 = MeasureChannel(0, lo_freq=3.4, lo_freq_range=(3.0, 4.0)) user_lo_config = LoConfig({channel1: 1.4, channel2: 3.6}) self.assertEqual(1.4, user_lo_config._q_lo_freq[channel1]) self.assertEqual(3.6, user_lo_config._m_lo_freq[channel2])
def test_frame_change(self): """Test converted qobj from FrameChangeInstruction.""" qobj = PulseQobjInstruction(name='fc', ch='m0', t0=0, phase=0.1) converted_instruction = self.converter(qobj) instruction = ShiftPhase(0.1, MeasureChannel(0)) self.assertEqual(converted_instruction.timeslots, instruction.timeslots) self.assertEqual(converted_instruction.instructions[0][-1], instruction)
def test_set_phase(self): """Test converted qobj from SetPhase.""" qobj = PulseQobjInstruction(name='setp', ch='m0', t0=0, phase=3.14) converted_instruction = self.converter(qobj) instruction = SetPhase(3.14, MeasureChannel(0)) self.assertEqual(converted_instruction.start_time, 0) self.assertEqual(converted_instruction.duration, 0) self.assertEqual(converted_instruction.instructions[0][-1], instruction)
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(0), ControlChannel(0))
def test_meas_los(self): """Test measurement channel configuration.""" user_lo_config = LoConfig({MeasureChannel(0): 3.5e9}) converter = LoConfigConverter(PulseQobjExperimentConfig, [1.2e9], [3.4e9], [(0., 5e9)], [(0., 5e9)]) valid_qobj = PulseQobjExperimentConfig(meas_lo_freq=[3.5]) self.assertEqual(converter(user_lo_config), valid_qobj)
def setUp(self): self.device = DeviceSpecification(qubits=[ Qubit(0, drive_channels=[DriveChannel(0, 1.2)], measure_channels=[MeasureChannel(0, 3.4)], acquire_channels=[AcquireChannel(0)]) ], registers=[RegisterSlot(0)], mem_slots=[MemorySlot(0)])
def test_get_channel_qubits(self): """Test to get all qubits operated on a given channel.""" self.assertEqual(self.config.get_channel_qubits(channel=DriveChannel(0)), [0]) self.assertEqual(self.config.get_channel_qubits(channel=ControlChannel(0)), [0, 1]) backend_3q = self.provider.get_backend('fake_openpulse_3q') self.assertEqual(backend_3q.configuration().get_channel_qubits(ControlChannel(2)), [2, 1]) self.assertEqual(backend_3q.configuration().get_channel_qubits(ControlChannel(1)), [1, 0]) with self.assertRaises(BackendConfigurationError): # Check that an error is raised if key not found in self._channel_qubit_map self.config.get_channel_qubits(MeasureChannel(10))
def setUp(self): self.linear = SamplePulse(np.arange(0, 0.01), name='linear') self.pulse_library = [ PulseLibraryItem(name=self.linear.name, samples=self.linear.samples.tolist()) ] self.converter = QobjToInstructionConverter(self.pulse_library, buffer=0) self.device = DeviceSpecification( qubits=[ Qubit(0, DriveChannel(0), MeasureChannel(0), AcquireChannel(0)), Qubit(1, DriveChannel(1), MeasureChannel(1), AcquireChannel(1)), ], registers=[RegisterSlot(0), RegisterSlot(1)], mem_slots=[MemorySlot(0), MemorySlot(1)])
def test_frame_change(self): """Test converted qobj from FrameChangeInstruction.""" cmd = FrameChange(phase=0.1) instruction = cmd(MeasureChannel(0)) qobj = PulseQobjInstruction(name='fc', ch='m0', t0=0, phase=0.1) converted_instruction = self.converter(qobj) self.assertEqual(converted_instruction.timeslots, instruction.timeslots) self.assertEqual(converted_instruction.instructions[0][-1].command, cmd)
def test_frame_change(self): """Test converted qobj from ShiftPhase.""" qobj = PulseQobjInstruction(name="fc", ch="m0", t0=0, phase=0.1) converted_instruction = self.converter(qobj) instruction = ShiftPhase(0.1, MeasureChannel(0)) self.assertEqual(converted_instruction.start_time, 0) self.assertEqual(converted_instruction.duration, 0) self.assertEqual(converted_instruction.instructions[0][-1], instruction)
def setUp(self): self.device = DeviceSpecification( qubits=[ Qubit(0, DriveChannel(0), MeasureChannel(0), AcquireChannel(0)) ], registers=[ RegisterSlot(0) ], mem_slots=[ MemorySlot(0) ] )
def measure(self, qubit: int) -> MeasureChannel: """ Return the measure stimulus channel for the given qubit. Raises: BackendConfigurationError: If the qubit is not a part of the system. Returns: Qubit measurement stimulus line. """ if qubit > self.n_qubits: raise BackendConfigurationError("This system does not have {} qubits.".format(qubit)) return MeasureChannel(qubit)
def test_parameterized_set_phase(self): """Test converted qobj from SetPhase, with parameterized phase.""" qobj = PulseQobjInstruction(name='setp', ch='m0', t0=0, phase='p/2') converted_instruction = self.converter(qobj) self.assertIsInstance(converted_instruction, ParameterizedSchedule) evaluated_instruction = converted_instruction.bind_parameters(3.14) instruction = SetPhase(3.14 / 2, MeasureChannel(0)) self.assertEqual(evaluated_instruction.start_time, 0) self.assertEqual(evaluated_instruction.duration, 0) self.assertEqual(evaluated_instruction.instructions[0][-1], instruction)
def measure(self, qubit: int) -> MeasureChannel: """ Return the measure stimulus channel for the given qubit. Raises: BackendConfigurationError: If the qubit is not a part of the system. Returns: Qubit measurement stimulus line. """ if not 0 <= qubit < self.n_qubits: raise BackendConfigurationError("Invalid index for {}-qubit system.".format(qubit)) return MeasureChannel(qubit)