content/ex4/ex4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 4 - Transmon qubit\n",
    "\n",
    "## Historical background\n",
    "\n",
    "In quantum computing, a qubit is the basic unit of quantum information. It is essentially a two-level quantum mechanical system, can be implemented in many physical systems, including natural systems such as electron spins (spin qubit), atomic levels in ions (trapped ion qubits) or artificial systems such as states in a superconducting circuit (superconducting qubit).\n",
    "\n",
    "The original superconducting qubit was the Cooper Pair Box debuted in 1999[1], in which a well-defined number of Cooper pairs (bound electrons in a superconductor) occupy an island of superconductor weakly coupled to a lead by a Josephson junction. In Cooper pair box qubit, the energy difference between the $|0\\rangle$ state (no Cooper Pairs) and $|1\\rangle$ state (a single Cooper Pair)is strongly dependent on any stray or applied electrostatic charges in or around the system. This sensitivity to charge noise leads to qubit dephasing. The qubit dephasing time ($T_2$) for Cooper pair box qubit is typically limited to ~ 1$\\mu s$.\n",
    "\n",
    "The key discovery behind the transmon qubit, first proposed in 2007[2], is that this energy dependence on voltage (known as dispersion) is periodic. By introducing a shunting capacitor, the ratio between the Josephson energy and charging energy $E_J/E_c$ become very large ~ 50, leading to a flat charge dispersion. While Cooper pair box is very sensitive to the charge noise (i.e. uncertainty in x axis position in Fig. 1a), it is largely suppressed in transmon qubit (Fig. 1d). The qubit dephasing time ($T_2$) for transmon qubit is improved significantly. In IBM Quantum systems, $T_2$ is typically ~ 100 $\\mu s$. See [`ibmq_santiago`](https://quantum-computing.ibm.com/services?skip=0&systems=all&system=ibmq_santiago) for example.\n",
    "\n",
    "<figure>\n",
    "    <img src=\"resources/transmon-charge-dispersion.png\" alt=\"Transmon charge dispersion\" style=\"width:50%\">\n",
    "    <center><figcaption><b>Fig. 1</b> Charge dispersion of qubit for different ratios $E_J/E_c$. (from Ref [2])</figcaption></center>\n",
    "</figure>\n",
    "\n",
    "In this exercise, you will investigate the characteristic energies of the transmon qubit by performing spectroscopy with a real IBM Quantum system. The ratio between the Josephson energy and charging energy $E_J/E_c$ is the key to solving the charge noise problem of its predecessor, the Cooper Pair Box qubit.\n",
    "\n",
    "### References\n",
    "\n",
    "1. Nakamura, Yasunobu, Yu A. Pashkin, and Jaw Shen Tsai. \"Coherent control of macroscopic quantum states in a single-Cooper-pair box.\" Nature 398.6730 (1999): 786-788.\n",
    "2. Koch, Jens, et al. \"Charge-insensitive qubit design derived from the Cooper pair box.\" Physical Review A 76.4 (2007): 042319.\n",
    "3. Krantz, Philip, et al. \"A quantum engineer's guide to superconducting qubits.\" Applied Physics Reviews 6.2 (2019): 021318."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Energy levels and characteristic energies of the transmon qubit\n",
    "\n",
    "The Hamiltonian of quantum harmonic oscillator (QHO) can be obtained by quantizing the Hamiltonian of a linear LC circuit. Its energy levels are equally spaced (Fig. 2c). By introducing a non-linear circuit element, the Josephson junction, the energy levels of the transmon qubit is modified (Fig. 2d). The energy levels are no longer equally spaced. Higher energy level spacing is smaller than those of lower energies. The anharmonicity $\\delta$ is defined as the energy difference between $|1\\rangle \\rightarrow |2\\rangle$ and $|0\\rangle \\rightarrow |1\\rangle$ transition: $\\delta = \\hbar \\omega_{12} - \\hbar \\omega_{01}$ or simply $\\omega_{12} - \\omega_{01}$ (we'll set $\\hbar \\equiv 1$ for the remainder of this discussion). By tuning the microwave frequency to $\\omega_{01}$, we can effectively address the multi-level transmon as a two-level system, i.e. a qubit.\n",
    "\n",
    "<figure>\n",
    "    <img src=\"resources/transmon-energy-levels.png\" alt=\"Transmon energy levels\" style=\"width:50%\">\n",
    "    <center><figcaption><b>Fig. 2</b> Energy potential for a quantum harmonic oscillator and a trasmon qubit. (from Ref [3])</figcaption></center>\n",
    "</figure>\n",
    "\n",
    "In superconductors, electrons form Cooper pairs with the effective charge of $2e$, where $e$ is the charge of a single electron. The charging energy $E_c$ is the energy cost of adding a single Cooper pair to the qubit and is related to the capacitance of the superconducting circuit. The Josephson energy $E_J$ is the energy of the Cooper pairs tunneling through the Josephson junction. In transmon qubits, the inductive energy is wholly provided by the Josephson junction, but this is not true of other styles of superconducting qubit (for information on the design and analysis of superconducting qubits, [Qiskit Metal](https://qiskit.org/metal/) has recently been released!).\n",
    "\n",
    "By deriving the Duffing oscillator Hamiltonian from the Cooper Pair Box Hamiltonian, these energies can be related to the relevant transmon frequencies as\n",
    "\n",
    "$$\n",
    "f_{01} = \\sqrt{8 E_c E_J} - E_c \\qquad E_c = -\\delta = f_{01} - f_{12},\n",
    "$$\n",
    "\n",
    "We will use $f$ to replace $\\omega$ as the symbol for frequency for the rest of the notebook, because it is more commonly used for microwave. The anharmonicity $\\delta$ is wholly provided by the charging energy $E_c$. Physically, this is incorporated as a large *shunting* (parallel) capacitor to the junction. This addition allows well-separated transmon levels while suppressing susceptibility to the charge noise. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Qiskit Pulse overview\n",
    "\n",
    "So far, you have been playing with qubits in the abstract quantum circuit level. Physically the quantum gates in circuits are implemented as microwave pulses. Qiskit Pulse provides you pulse level access to manipulate the microwave pulses sending to IBM Quantum system.\n",
    "\n",
    "As a brief overview, Qiskit Pulse schedules (experiments) consist of Instructions (e.g., Play) acting on Channels (e.g., the drive channel). Here is a summary table of available Instructions and Channels:\n",
    "\n",
    "![image](resources/pulse-instr.png)\n",
    "\n",
    "For more details, this table summarizes the interaction of the channels with the actual quantum hardware:\n",
    "\n",
    "![image](resources/pulse-user-device-layers.png)\n",
    "\n",
    "You can learn more about Qiskit Pulse on [Qiskit documentation](https://qiskit.org/documentation/apidoc/pulse.html). However, we find it is more instructive to begin with guided programming in Pulse. Below you will learn how to create pulses, schedules, and run experiments on a real quantum system. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's get started!\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "**Goal**\n",
    "    \n",
    "Find $|1\\rangle \\rightarrow |2\\rangle$ transition frequency $f_{12}$.\n",
    "    \n",
    "**Plan**\n",
    "    \n",
    "1. **(Tutorial) Find $|0\\rangle \\rightarrow |1\\rangle$ transition frequency $f_{01}$** using spectroscopy (sweeping frequency).\n",
    "1. **(Tutorial) Calibrate X-180 pulse amplitude** using Rabi oscillation (sweeping amplitude).\n",
    "1. **(Problem) Find $|1\\rangle \\rightarrow |2\\rangle$ transition frequency $f_{12}$** using the calibrated X-180 pulse and spectroscopy (sweeping frequency).\n",
    "    \n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "\n",
    "**You will only need to <a href=\"#problem\">modify one cell</a> within this notebook.** You may also need to <a href=\"#fit-f12\">modify the fitting parameters</a> to get a good fit. But other than that, in rest of the cells, nothing needs to be modified. However, you will need to execute the cells by pressing `shift+Enter` in each code block. \n",
    "\n",
    "</div>\n",
    "\n",
    "In order to keep things tidy and focus on the important aspects of Qiskit Pulse, the following cells make use of methods from the `helper` module. For the gory details, please refer to the [Investigating Quantum Hardware Using Microwave Pulses\n",
    "](https://qiskit.org/textbook/ch-quantum-hardware/index-pulses.html) chapter of the Qiskit Textbook and Lectures 16-21, Labs 6-7 of the [Qiskit Global Summer School](https://qiskit.org/learn/intro-qc-qh/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import helper module from local folder\n",
    "import sys\n",
    "import os\n",
    "sys.path.append(os.getcwd()) \n",
    "from resources import helper\n",
    "\n",
    "# Numerical and plotting tools\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Import SI unit conversion factors\n",
    "from resources.helper import GHz, MHz, kHz, us, ns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    " \n",
    "**Special provider**\n",
    "    \n",
    "We have reserved a brand new `ibmq_jakarta` quantum system for the challenge. Participants will have exclusive access to the system during the challenge period (May 20 - 26, 2021) through a special [provider](https://quantum-computing.ibm.com/composer/docs/iqx/manage/provider/#providers). You need to **complete at least one of the five exercises** in the challenge to get assigned to a special provider for the challenge. When you do, you will receive an email with header `You have been added to a new project in IBM Quantum` in the email address associated with your IBM Quantum account. If everything work properly, you should be able to see the information of the special provider in [your account details page](https://quantum-computing.ibm.com/account).\n",
    "    \n",
    "Your IBM Quantum account needs to be associated with an IBMid. Otherwise, you will encounter this error `Login with some authorized required.`. Please [register a new IBMid](https://auth.quantum-computing.ibm.com/auth/idaas) using the SAME email address associated with your IBM Quantum account and login to [IBM Quantum](https://quantum-computing.ibm.com) again.\n",
    "    \n",
    "**Note: It may take up to 12 hours to get assigned to the provider upon completion of other exercises.** If you face any issues, please reach out to us in [#iqc2021](https://qiskit.slack.com/archives/C021UTFN9GE) channel. Join the Qiskit Slack workspace [here](https://ibm.co/joinqiskitslack) if you haven't already.\n",
    "    \n",
    "</div>\n",
    "\n",
    "Run the cell below to check if you have been assigned to a special provider. If you are added to a special provider, you should be able to see in the output a provider looks like this `<AccountProvider for IBMQ(hub='iqc2021-n', group='challenge-m', project='ex4')>` where `n` is a number goes from `1` to `10` and `m` is a number goes from `1` to `1000`. You will need this information to get access to `ibmq_jakarta` quantum system reserved for the challenge. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing standard Qiskit libraries\n",
    "from qiskit import IBMQ\n",
    "from qiskit.tools.jupyter import *\n",
    "\n",
    "# Loading your IBM Quantum account\n",
    "IBMQ.load_account()\n",
    "IBMQ.providers() # see a list of providers you have access to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the special provider assigned to you using information from the output above\n",
    "hub_name = 'YOUR_HUB_NAME' # e.g. 'iqc2021-1'\n",
    "group_name = 'YOUR_GROUP_NAME' # e.g. 'challenge-1'\n",
    "project_name = 'ex4' # Your project name should be 'ex4'\n",
    "provider = IBMQ.get_provider(hub=hub_name, group=group_name, project=project_name)\n",
    "\n",
    "# Get `ibmq_jakarta` backend from the provider\n",
    "backend_name = 'ibmq_jakarta'\n",
    "backend = provider.get_backend(backend_name)\n",
    "backend # See details of the `ibmq_jakarta` quantum system"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instantiate channels and retrieve measurement schedule\n",
    "\n",
    "We will use the same measurement schedule throughout, whereas the drive schedules will vary. For any backend, we can ask for its default measurement pulse instead of calibrating it separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import pulse\n",
    "from qiskit.pulse import Play, Schedule, DriveChannel\n",
    "\n",
    "# Please use qubit 0 throughout the notebook\n",
    "qubit = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, save the backend configuration and the sampling time $dt$. We will exclude the `AcquireChannel`s when plotting for clarity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "backend_config = backend.configuration()\n",
    "exc_chans = helper.get_exc_chans(globals())\n",
    "dt = backend_config.dt\n",
    "print(f\"Sampling time: {dt*1e9} ns\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `instruction_schedule_map` provides the parameters of the default calibrated pulses used by the backend. In particular, we see that this \"native gate set\" consists of a subset of operations you can perform on a [`QuantumCircuit`](https://qiskit.org/documentation/apidoc/circuit.html#gates-and-instructions), and is the gate set that the `QuantumCircuit` is transpiled to by Qiskit. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "backend_defaults = backend.defaults()\n",
    "center_frequency = backend_defaults.qubit_freq_est\n",
    "inst_sched_map = backend_defaults.instruction_schedule_map \n",
    "inst_sched_map.instructions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The instructions consist of the native gate set of the backend: single-qubit gates square-root of $X$, `sx`, and parameterized rotation about the $Z$-axis, `rz(θ)`, and the two-qubit controlled-NOT, `cx`. There are several other gates listed here, in particular the soon-to-be deprecated [\"U-gates\"](https://qiskit.org/textbook/ch-states/single-qubit-gates.html#generalU3) based on Euler angles, summarized below for completeness\n",
    "\n",
    "Basis Gate | Operation\n",
    " --- | ---\n",
    " `u1(λ)` | `rz(λ)`\n",
    " `u2(φ,λ)` | `rz(φ+π/2) sx rz(λ-π/2)`\n",
    " `u3(θ,φ,λ)` | `rz(φ+π) sx rz(θ+π) sx rz(λ)`\n",
    " `id` | identity\n",
    " `x` | $X$ for echoes in dynamical decoupling\n",
    " `measure` | measurement\n",
    "\n",
    "One thing to note is that each `sx` consists of one physical pulse and the `rz`s are implemented in software by [frame changes](https://arxiv.org/abs/1612.00858). From the `instruction_schedule_map` we can retrieve the default measurement pulse instead of building it from scratch. This also serves as a useful starting point from retrieving calibrated pulses and manipulating them further."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Retrieve calibrated measurement pulse from backend\n",
    "meas = inst_sched_map.get('measure', qubits=[qubit])\n",
    "meas.exclude(channels=exc_chans).draw(time_range=[0,1000])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "## Step 1 (Tutorial): Find $|0\\rangle \\rightarrow |1\\rangle$ transition\n",
    "    \n",
    "You don't need to modify any code in this section. Just go through all the cells and make sure you understand the steps. Pay close attention to how `spec01_scheds` is built. You will need to build similar pulse schedules in <a href=\"#problem\">the final problem</a>. You can learn more about how to build pulse schedule in [this tutorial](https://qiskit.org/documentation/tutorials/circuits_advanced/06_building_pulse_schedules.html).\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.pulse import DriveChannel, Gaussian\n",
    "\n",
    "# The same spec pulse for both 01 and 12 spec\n",
    "drive_amp = 0.25\n",
    "drive_duration = inst_sched_map.get('x', qubits=[qubit]).duration\n",
    "\n",
    "# Calibrated backend pulse use advanced DRAG pulse to reduce leakage to the |2> state.\n",
    "# Here we will use simple Gaussian pulse\n",
    "\n",
    "drive_sigma = drive_duration // 4 # DRAG pulses typically 4*sigma long. \n",
    "spec_pulse = Gaussian(duration=drive_duration, amp=drive_amp, \n",
    "                        sigma=drive_sigma, name=f\"Spec drive amplitude = {drive_amp}\")\n",
    "\n",
    "# Construct an np array of the frequencies for our experiment\n",
    "spec_freqs_GHz = helper.get_spec01_freqs(center_frequency, qubit)\n",
    "\n",
    "# Create the base schedule\n",
    "# Start with drive pulse acting on the drive channel\n",
    "spec01_scheds = []\n",
    "for freq in spec_freqs_GHz:\n",
    "    with pulse.build(name=\"Spec Pulse at %.3f GHz\" % freq) as spec01_sched:\n",
    "        with pulse.align_sequential():\n",
    "            # Pay close attention to this part to solve the problem at the end\n",
    "            pulse.set_frequency(freq*GHz, DriveChannel(qubit))\n",
    "            pulse.play(spec_pulse, DriveChannel(qubit))\n",
    "            pulse.call(meas)\n",
    "            \n",
    "    spec01_scheds.append(spec01_sched)\n",
    "\n",
    "# Draw spec01 schedule\n",
    "spec01_scheds[-1].exclude(channels=exc_chans).draw(time_range=[0,1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.tools.monitor import job_monitor\n",
    "\n",
    "# Run the job on a real backend\n",
    "spec01_job = backend.run(spec01_scheds, job_name=\"Spec 01\", **helper.job_params) \n",
    "\n",
    "print(spec01_job.job_id())\n",
    "job_monitor(spec01_job)\n",
    "\n",
    "# If the queuing time is too long, you can save the job id \n",
    "# And retrieve the job after it's done\n",
    "# Replace 'JOB_ID' with the the your job id and uncomment to line below\n",
    "#spec01_job = backend.retrieve_job('JOB_ID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fit the Spectroscopy Data\n",
    "\n",
    "We will fit the spectroscopy signal to a *Lorentzian* function of the form\n",
    "\n",
    "$$ \\frac{AB}{\\pi[(f-f_{01})^2 + B^2]} + C $$\n",
    "\n",
    "to find the qubit frequency $f_{01}$ with these fitting parameters:\n",
    "\n",
    "\n",
    "Parameter | Corresponds to\n",
    " --- | ---\n",
    " $A$ | amplitude\n",
    " $f_{01}$ | 01 frequency guess (GHz)\n",
    " $B$ | scale\n",
    " $C$ | offset\n",
    "\n",
    " \n",
    " We will use the `SpecFitter` from the `helper` module that is based on the fitters from `qiskit.ignis.characterization.fitters` library.\n",
    " \n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "\n",
    "**Note:** You may need to modify the fitting parameters below to get a good fit.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from resources.helper import SpecFitter\n",
    "\n",
    "amp_guess = 5e6\n",
    "f01_guess = 5\n",
    "B = 1\n",
    "C = 0\n",
    "fit_guess = [amp_guess, f01_guess, B, C]\n",
    "\n",
    "fit = SpecFitter(spec01_job.result(), spec_freqs_GHz, qubits=[qubit], fit_p0=fit_guess)\n",
    "fit.plot(0, series='z')\n",
    "f01 = fit.spec_freq(0, series='z')\n",
    "print(\"Spec01 frequency is %.6f GHz\" % f01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compare your result with the calibrated qubit frequency from the backend! If things are working properly, your result should be very close to the calibrated value ($\\pm$1 MHz)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Retrieve qubit frequency from backend properties\n",
    "f01_calibrated = backend.properties().frequency(qubit) / GHz \n",
    "f01_error = abs(f01-f01_calibrated) * 1000 # error in MHz\n",
    "print(\"Qubit frequency error is %.6f MHz\" % f01_error) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🎉 Congratulations! You have successfully ran your first pulse experiment on a real quantum system and analyzed the data. This was not possible without access to an advanced research lab before [less than two years ago](https://www.ibm.com/blogs/research/2019/12/qiskit-openpulse/), when we released Qiskit Pulse and provided pulse access in our open quantum system `ibmq_armonk`. Now you can do experimental quantum physics on your laptop in the comfort of your home. This is incredible!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "## Step 2 (Tutorial): Calibrate X-180 pulse amplitude using Rabi oscillation\n",
    "\n",
    "You don't need to modify any code in this section. Just go through all the cells and make sure you understand the steps. \n",
    "</div>\n",
    "\n",
    "### Build Rabi schedule from measured frequency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_rabi_amp = 0.75\n",
    "rabi_amps = helper.get_rabi_amps(max_rabi_amp)\n",
    "\n",
    "rabi_scheds = []\n",
    "for ridx, amp in enumerate(rabi_amps):\n",
    "    with pulse.build(name=\"rabisched_%d_0\" % ridx) as sched: # '0' corresponds to Rabi\n",
    "        with pulse.align_sequential():\n",
    "            pulse.set_frequency(f01*GHz, DriveChannel(qubit))\n",
    "            rabi_pulse = Gaussian(duration=drive_duration, amp=amp, \\\n",
    "                              sigma=drive_sigma, name=f\"Rabi drive amplitude = {amp}\")\n",
    "            pulse.play(rabi_pulse, DriveChannel(qubit))\n",
    "            pulse.call(meas)\n",
    "    rabi_scheds.append(sched)\n",
    "\n",
    "# Draw rabi schedule\n",
    "rabi_scheds[-1].exclude(channels=exc_chans).draw(time_range=[0,1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run the job on a real device\n",
    "rabi_job = backend.run(rabi_scheds, job_name=\"Rabi\", **helper.job_params)\n",
    "\n",
    "print(rabi_job.job_id())\n",
    "job_monitor(rabi_job)\n",
    "\n",
    "# If the queuing time is too long, you can save the job id \n",
    "# And retrieve the job after it's done\n",
    "# Replace 'JOB_ID' with the the your job id and uncomment to line below\n",
    "#rabi_job = backend.retrieve_job('JOB_ID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fit the Rabi Data\n",
    "\n",
    "We will fit the Rabi signal to a sinusoidal function of the form\n",
    "\n",
    "$$ a \\cos(2\\pi f x + \\phi) + c $$\n",
    "\n",
    "to find the Rabi period $T = 2\\pi/f$ with these fitting parameters:\n",
    "\n",
    "\n",
    "Parameter | Corresponds to\n",
    " --- | ---\n",
    " $a$ | amplitude\n",
    " $f$ | Rabi drive frequency\n",
    " $\\phi$ | phase offset\n",
    " $c$ | offset\n",
    "\n",
    "\n",
    "We will use the `RabiFitter` from the `qiskit.ignis.characterization.calibration.fitters` library.\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "\n",
    "**Note:** You may need to modify the fitting parameters below to get a good fit.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.ignis.characterization.calibrations.fitters import RabiFitter\n",
    "\n",
    "amp_guess = 5e7\n",
    "fRabi_guess = 2\n",
    "phi_guess = 0.5\n",
    "c_guess = 0\n",
    "fit_guess = [amp_guess, fRabi_guess, phi_guess, c_guess]\n",
    "\n",
    "fit = RabiFitter(rabi_job.result(), rabi_amps, qubits=[qubit], fit_p0=fit_guess)\n",
    "fit.plot(qind=0, series='0')\n",
    "x180_amp = fit.pi_amplitude()\n",
    "print(\"Pi amplitude is %.3f\" % x180_amp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='problem'></div>\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "## Step 3 (Problem): Find $|1\\rangle \\rightarrow |2\\rangle$ transition frequency\n",
    "    \n",
    "In order to observe the transition between the $|1\\rangle$ and $|2\\rangle$ states of the transmon, you need to: \n",
    "\n",
    "1. Apply an $X_\\pi$ pulse to transition the qubit from $|0\\rangle$ to $|1\\rangle$.\n",
    "1. Apply a second pulse with varying frequency to find the $|1\\rangle \\rightarrow |2\\rangle$ transition.\n",
    "\n",
    "</div>\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "The cell below is the only one you need to modify in the entire notebook. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define pi pulse\n",
    "x_pulse = Gaussian(duration=drive_duration,\n",
    "                     amp=x180_amp, \n",
    "                     sigma=drive_sigma,\n",
    "                     name='x_pulse')\n",
    "\n",
    "def build_spec12_pulse_schedule(freq, anharm_guess_GHz):    \n",
    "    with pulse.build(name=\"Spec Pulse at %.3f GHz\" % (freq+anharm_guess_GHz)) as spec12_schedule:\n",
    "        with pulse.align_sequential():            \n",
    "            # WRITE YOUR CODE BETWEEN THESE LINES - START\n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "    \n",
    "            # WRITE YOUR CODE BETWEEN THESE LINES - END\n",
    "    return spec12_schedule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The anharmonicity of our transmon qubits is typically around $-300$ MHz, so we will sweep around that value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "anharmonicity_guess_GHz = -0.3 # your anharmonicity guess\n",
    "freqs_GHz = helper.get_spec12_freqs(f01, qubit)\n",
    "\n",
    "# Now vary the sideband frequency for each spec pulse\n",
    "spec12_scheds = []\n",
    "for freq in freqs_GHz:\n",
    "    spec12_scheds.append(build_spec12_pulse_schedule(freq, anharmonicity_guess_GHz))\n",
    "\n",
    "# Draw spec12 schedule   \n",
    "spec12_scheds[-1].exclude(channels=exc_chans).draw(time_range=[0,1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run the job on a real device\n",
    "spec12_job = backend.run(spec12_scheds, job_name=\"Spec 12\", **helper.job_params)\n",
    "\n",
    "print(spec12_job.job_id())\n",
    "job_monitor(spec12_job)\n",
    "\n",
    "# If the queuing time is too long, you can save the job id \n",
    "# And retrieve the job after it's done\n",
    "# Replace 'JOB_ID' with the the your job id and uncomment to line below\n",
    "#spec12_job = backend.retrieve_job('JOB_ID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fit the Spectroscopy Data\n",
    "\n",
    "<div id='fit-f12'></div>\n",
    "\n",
    "We will again fit the spectroscopy signal to a Lorentzian function of the form\n",
    "\n",
    "$$ \\frac{AB}{\\pi[(f-f_{12})^2 + B^2]} + C $$\n",
    "\n",
    "to find the frequency of the $|1\\rangle \\to |2\\rangle$ transition $f_{12}$ with these fitting parameters:\n",
    "\n",
    "Parameter | Corresponds to\n",
    " --- | ---\n",
    " $A$ | amplitude\n",
    " $f_{12}$ | 12 frequency guess (GHz)\n",
    " $B$ | scale\n",
    " $C$ | offset\n",
    " \n",
    " \n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "\n",
    "**Note:** You may need to modify the fitting parameters below to get a good fit.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "amp_guess = 2e7\n",
    "f12_guess = f01 - 0.3\n",
    "B = .1\n",
    "C = 0\n",
    "fit_guess = [amp_guess, f12_guess, B, C]\n",
    "\n",
    "fit = SpecFitter(spec12_job.result(), freqs_GHz+anharmonicity_guess_GHz, qubits=[qubit], fit_p0=fit_guess)\n",
    "fit.plot(0, series='z')\n",
    "f12 = fit.spec_freq(0, series='z')\n",
    "print(\"Spec12 frequency is %.6f GHz\" % f12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check your answer using following code\n",
    "from qc_grader import grade_ex4\n",
    "grade_ex4(f12,qubit,backend_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Submit your answer. You can re-submit at any time.\n",
    "from qc_grader import submit_ex4\n",
    "submit_ex4(f12,qubit,backend_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculating $E_J/E_c$\n",
    "\n",
    "Modifying the equations in the introduction section, we can calculate $E_c$ and $E_J$ using $f_{01}$ and $f_{12}$ obtained from the pulse experiments:\n",
    "\n",
    "$$\n",
    "E_c = -\\delta = f_{01} - f_{12} \\qquad E_J = \\frac{(2f_{01}-f_{12})^2}{8(f_{01}-f_{12})}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ec = f01 - f12\n",
    "Ej = (2*f01-f12)**2/(8*(f01-f12))\n",
    "print(f\"Ej/Ec: {Ej/Ec:.2f}\") # This value is typically ~ 30 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additional information\n",
    "\n",
    "**Created by:** Nick Brønn, Junye Huang\n",
    "\n",
    "**Version:** 1.0.0"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}