Note

This page was generated from tutorials/circuits_advanced/10_pulse_simulator_backend_model.ipynb.

Run interactively in the IBM Quantum lab.

Qiskit Aer: Pulse simulation of a backend model

This notebook shows how to use the Aer pulse simulator using a model generated from a backend. In particular, we run a Rabi experiment to find a \(\pi\)-pulse amplitude on a model of the Armonk one qubit backend, generated from the FakeArmonk mock backend.

Table of contents

1. Imports

2. Construct model from backend

3. Run Rabi experiments and fit :math:pi`-pulse amplitude <#rabi>`__

1. Imports

Import general libraries:

import numpy as np

Import Rabi experiment generator and fitter from Ignis, and other functions for job submission:

from qiskit.ignis.characterization.calibrations import rabi_schedules, RabiFitter

from qiskit.pulse import DriveChannel
from qiskit.compiler import assemble
from qiskit.qobj.utils import MeasLevel, MeasReturnType

Import PulseSimulator and PulseSystemModel for pulse simulation, as well as the mock Armonk backend:

# The pulse simulator
from qiskit.providers.aer import PulseSimulator

# Object for representing physical models
from qiskit.providers.aer.pulse import PulseSystemModel

# Mock Armonk backend
from qiskit.test.mock.backends.armonk.fake_armonk import FakeArmonk

2. Construct model from backend

This section demonstrates the use of the PulseSystemModel.from_backend function for generating PulseSystemModel objects from a backend.

Note: Hamiltonian parameters reported in the backends change over time. To stabilize this tutorial relative to these changes, after instantiating FakeArmonk, we manually override the Hamiltonian reported in the backend configuration to static values.

Instantiate mock backend:

armonk_backend = FakeArmonk()

Manually override Hamiltonian parameters:

freq_est = 4.97e9
drive_est = 6.35e7
armonk_backend.defaults().qubit_freq_est = [freq_est]
armonk_backend.configuration().hamiltonian['h_str']= ['wq0*0.5*(I0-Z0)', 'omegad0*X0||D0']
armonk_backend.configuration().hamiltonian['vars'] = {'wq0': 2 * np.pi * freq_est, 'omegad0': drive_est}
armonk_backend.configuration().hamiltonian['qub'] = {'0': 2}
armonk_backend.configuration().dt = 2.2222222222222221e-10

Generate model from backend:

armonk_model = PulseSystemModel.from_backend(armonk_backend)

3. Run Rabi experiments and fit \(\pi\)-pulse amplitude

Next, we run a Rabi experiments generated using Ignis on the simulator using the system model generated from the Armonk backend.

First, construct Rabi experiment schedules:

# qubit list
qubits = [0]

# drive amplitudes to use
num_exps = 64
drive_amps = np.linspace(0, 1.0, num_exps)

# drive shape parameters
drive_duration = 2048
drive_sigma = 256

# list of drive channels
drive_channels = [DriveChannel(0)]

# construct the schedules
rabi_schedules, xdata = rabi_schedules(amp_list=drive_amps,
                                       qubits=qubits,
                                       pulse_width=drive_duration,
                                       pulse_sigma=drive_sigma,
                                       drives=drive_channels,
                                       inst_map=armonk_backend.defaults().instruction_schedule_map,
                                       meas_map=armonk_backend.configuration().meas_map)

Assemble the qobj for job submission. When assembling pulse schedules to be used with the pulse simulator, pass the PulseSimulator as the backend.

backend_sim = PulseSimulator()

rabi_qobj = assemble(rabi_schedules,
                     backend=backend_sim,
                     meas_level=1,
                     meas_return='avg',
                     shots=512)

Run the simulation:

sim_result = backend_sim.run(rabi_qobj, armonk_model).result()

/home/computertreker/git/qiskit/qiskit-dup/.tox/docs/lib/python3.7/site-packages/qiskit/providers/aer/pulse/controllers/pulse_controller.py:140: UserWarning: Warning: qubit_lo_freq was not specified in PulseQobj and there is no default, so it is beign automatically determined from the drift Hamiltonian.
  warn('Warning: qubit_lo_freq was not specified in PulseQobj and there is no default, '

Generate the Rabi oscillation plot and find the \(\pi\)-pulse amplitude:

rabi_fit = RabiFitter(sim_result, xdata, qubits, fit_p0 = [1.5, 2, 0, 0])

# get the pi amplitude
pi_amp = rabi_fit.pi_amplitude(0)

# plot
rabi_fit.plot(0)
print('Pi Amp: %f'%pi_amp)

Pi Amp: 0.345526

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.24.1
Terra	0.16.4
Aer	0.7.6
Ignis	0.5.2
Aqua	0.8.2
IBM Q Provider	0.12.2
System information
Python	3.7.7 (default, Apr 22 2020, 19:15:10) [GCC 9.3.0]
OS	Linux
CPUs	32
Memory (Gb)	125.71903228759766
Tue May 25 15:15:16 2021 EDT

This code is a part of Qiskit

© Copyright IBM 2017, 2021.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.