{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "290fa254",
   "metadata": {},
   "source": [
    "# The Cross Resonance (CR) Gate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "776a5a9c",
   "metadata": {},
   "source": [
    "> 💡 **Using this tutorial without the Qt GUI**\n",
    "> \n",
    "> This tutorial uses the desktop `MetalGUI`. To follow along on Colab, Binder, JupyterHub, or any environment where Qt isn't available, **replace any `gui.rebuild()` / `gui.screenshot()` call with `qm.view(design)`** — it renders the design to a matplotlib `Figure` you can display inline or save with `fig.savefig(...)`.\n",
    "> \n",
    "> See [1.4 Headless quick view](../1-Overview/1.4-Headless-quick-view-%28no-Qt-GUI%29.ipynb) for a complete runnable walkthrough and [`docs/headless-usage.rst`](../../../docs/headless-usage.rst) for the full reference."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c806b8fd",
   "metadata": {},
   "source": [
    "Here's what we'll work through in this tutorial notebook:\n",
    "\n",
    "*  Introduce and describe the basic operation of the cross-resonance (CR) gate \n",
    "*  Construct the time-dependent Hamiltonian of a representative CR gate consisting of two qubits coupled via a CPW resonator. \n",
    "*  Look at the time-evolution of the two qubits in a CR gate \n",
    "*  Show how to build a representative physical design of a CR gate using qiskit metal. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59b2896a",
   "metadata": {},
   "source": [
    "### What is the CR Gate?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee31f028",
   "metadata": {},
   "source": [
    "The cross-resonance (CR) gate consists of two fixed-frequency qubits connected via a resonator. One of the qubits (the \"control\" qubit) is driven at the transition frequency of the second qubit (the \"target\" qubit) which results in Rabi oscillations in the target qubit. \n",
    "\n",
    "Some helpful background papers on the CR gate: \n",
    "\n",
    "* C. Rigetti and M. Devoret, Phys. Rev. B 81, 134507 (2010)\n",
    "* M. Malekakhlagh et al., Phys. Rev. A 102, 042605 (2020)\n",
    "* E. Magesan and J.M. Gambetta, Phys. Rev. A 101, 052308 (2020)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6481708",
   "metadata": {},
   "source": [
    "### What does the Hamiltonian of the CR gate look like? \n",
    "\n",
    "We can composite Hamiltonian of the CR gate consists of the non-interacting Hamiltonians of the two qubits, a coupling term between the two qubits and the drive term applied to the control qubit:\n",
    "\n",
    "$H = H_{Q1} + H_{Q2} + H_{Coupling} + H_{Drive}   $ \n",
    "\n",
    "where $H_{Coupling}$ is the coupling between qubit 1 and qubit 2, and $H_{Drive}$ is the driving microwave signal applies to qubit 1 (at the frequency of qubit 2). The first three terms are time-independent while the drive term has time-dependence in the form a cosine wave. \n",
    "\n",
    "In a simplistic approach using Pauli matrices ($\\sigma_z = a^{+}a $ , $\\sigma_x = a + a^{+} $) for each qubit, we can write the individual components as follows:\n",
    "\n",
    "$H_{Q1} = 0.5 \\omega_1 \\sigma_1^{z} $\n",
    "\n",
    "$H_{Q2} = 0.5 \\omega_2 \\sigma_2^{z} $\n",
    "\n",
    "$H_{Coupling} = 0.5 \\omega_{xx} \\sigma_1^{x} \\sigma_2^{x}$\n",
    "\n",
    "$H_{Drive} = \\Omega cos(\\omega_1^{RF} t + \\phi) \\sigma_1^{x}   $\n",
    "\n",
    "By setting $\\omega_1^{RF} = \\omega_2$, we are driving qubit 1 at the frequency of qubit 2. \n",
    "\n",
    "The full Hamiltonian can thus be written as: \n",
    "\n",
    "$H = 0.5 \\omega_1 \\sigma_1^{z} + 0.5 \\omega_2 \\sigma_2^{z} + 0.5 \\omega_{xx} \\sigma_1^{x} \\sigma_2^{x} +  \\Omega cos(\\omega_1^{RF} t + \\phi) \\sigma_1^{x}  $"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19e8997d",
   "metadata": {},
   "source": [
    "### Constructing the CR Gate Hamiltonian Using QuTiP & Qiskit Metal "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dba55f35",
   "metadata": {},
   "source": [
    "Let's start by loading the required modules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36d53fe9",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%config IPCompleter.greedy = True\n",
    "%matplotlib inline\n",
    "%config Completer.use_jedi = False\n",
    "%config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "from qiskit_metal.analyses.hamiltonian.transmon_charge_basis import Hcpb\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from qutip import *\n",
    "from math import *"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e683d2e",
   "metadata": {},
   "source": [
    "The CR gate uses fixed-frequency qubits, so we'll define the two qubit frequencies as well as the coupling strength between them. We'll use similar values to those published in the original CR gate paper from Rigetti & Devoret: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de72a384",
   "metadata": {},
   "outputs": [],
   "source": [
    "w1 = 12.8\n",
    "w2 = 16.1\n",
    "g = 0.13"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5e283e1",
   "metadata": {},
   "source": [
    "Now, let's define the initial states of the two qubits and then construct the tensor product for the composite wavefunction of the initial state. We'll consider two states for each qubit, hence we'll use \"basis(2,N)\" where N represents the index of the state. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d119051",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initial States of Qubit1 and Qubit2\n",
    "Psi1_initial = basis(2, 0)  # ground state of qubit 1\n",
    "Psi2_initial = basis(2, 1)  # excited state of qubit 2\n",
    "\n",
    "# Tensor Product of Composite Initial Wavefunction\n",
    "Psi0 = tensor(Psi1_initial, Psi2_initial)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc0940f4",
   "metadata": {},
   "source": [
    "### Time-independent Hamiltonian"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f5c9900",
   "metadata": {},
   "source": [
    "Now let's build the operators that will go into the Hamiltonian. Notice that the two tensor products below have the location of the identity matrix (\"qeye\") swapped, since in the first case we're writing the operator for qubit 1 in the basis of qubit 2, and the second case we're writing the operator for qubit 2 in the basis of qubit 1. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fcf64ba9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ladder operator for qubit 1 (\"a\")\n",
    "a = tensor(destroy(2), qeye(2))\n",
    "\n",
    "# ladder operator for qubit 2 (\"b\")\n",
    "b = tensor(qeye(2), destroy(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b7525f1",
   "metadata": {},
   "source": [
    "Now let's construct the tensor products for occupation probability operators (for n=0 and n=1) for each qubit. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1176b351",
   "metadata": {},
   "outputs": [],
   "source": [
    "# QUBIT 1\n",
    "\n",
    "# this defines the ground state |n=0>\n",
    "c0 = basis(2, 0)\n",
    "# now take the product |n=0><n=0|\n",
    "n0_qubit1 = c0 * c0.dag()\n",
    "# and lastly the tensor product in the basis of qubit 2\n",
    "n0_qubit1 = tensor(n0_qubit1, qeye(2))\n",
    "\n",
    "# this defines the first excited state |n=1>\n",
    "c1 = basis(2, 1)\n",
    "# take the product |n=1><n=1|\n",
    "n1_qubit1 = c1 * c1.dag()\n",
    "# and lastly the tensor product in the basis of qubit 2\n",
    "n1_qubit1 = tensor(n1_qubit1, qeye(2))\n",
    "\n",
    "# QUBIT 2\n",
    "# (same operations as above)\n",
    "\n",
    "c0 = basis(2, 0)\n",
    "n0_qubit2 = c0 * c0.dag()\n",
    "n0_qubit2 = tensor(qeye(2), n0_qubit2)\n",
    "\n",
    "c1 = basis(2, 1)\n",
    "n1_qubit2 = c1 * c1.dag()\n",
    "n1_qubit2 = tensor(qeye(2), n1_qubit2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6002ce36",
   "metadata": {},
   "source": [
    "Now we can build the time-independent Hamiltonian of the two-qubit system and verify that it is a 4x4 matrix describing two qubits each with their own 2x2 non-interacting Hamiltonians:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "311d9904",
   "metadata": {},
   "outputs": [],
   "source": [
    "# time independent Hamiltonian\n",
    "H0 = w1 * a.dag() * a + w2 * b.dag() * b + g * (a + a.dag()) * (b + b.dag())\n",
    "H0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71fd1544",
   "metadata": {},
   "source": [
    "### Time Evolution of the Time-Independent Hamiltonian"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7cd8b08",
   "metadata": {},
   "source": [
    "Even though our Hamiltonian is time-independent (missing the time-dependent driving term), the interaction term between the two qubits will still give some non-trivial time evoluation. \n",
    "\n",
    "We can use the master equation solver in QuTiP to solve for the time evolution, giving Hamiltonian H0 and initial state Psi0 that we've defined above. As output, we'll calculate the occupation probabilities of each qubit at each timestep. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e27e22a",
   "metadata": {},
   "outputs": [],
   "source": [
    "tlist = tlist = np.linspace(0, 25, 101)  # time between t=0 and t=25 with 101 increments\n",
    "dissipation = []  # no dissipation\n",
    "# output = mesolve(H0, Psi0, tlist, c_ops, [n0_qubit1, n1_qubit1, n0_qubit2, n1_qubit2]) # time evolution\n",
    "output = mesolve(\n",
    "    H0, Psi0, tlist, dissipation, [n0_qubit1, n1_qubit1, n0_qubit2, n1_qubit2]\n",
    ")  # time evolution\n",
    "\n",
    "n0_qubit1 = output.expect[0]\n",
    "n1_qubit1 = output.expect[1]\n",
    "n0_qubit2 = output.expect[2]\n",
    "n1_qubit2 = output.expect[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a580b46",
   "metadata": {},
   "source": [
    "Let's plot the occupation probabilities for the n=0 and n=1 states of each qubit. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fda848d",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(1, figsize=(10, 5))\n",
    "plt.subplot(121)\n",
    "plt.plot(tlist, n0_qubit1, label=\"n=0\")\n",
    "plt.plot(tlist, n1_qubit1, label=\"n=1\")\n",
    "plt.legend(loc=0)\n",
    "plt.xlabel(\"Time\")\n",
    "plt.ylabel(\"Occupation Probability\")\n",
    "plt.title(\"Qubit1\")\n",
    "\n",
    "plt.subplot(122)\n",
    "plt.plot(tlist, n0_qubit2, label=\"n=0\")\n",
    "plt.plot(tlist, n1_qubit2, label=\"n=1\")\n",
    "plt.legend(loc=0)\n",
    "plt.xlabel(\"Time\")\n",
    "plt.ylabel(\"Occupation Probability\")\n",
    "plt.title(\"Qubit2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1f18f1b",
   "metadata": {},
   "source": [
    "We see that qubit1 is in the ground state (n=0) while qubit 2 is the first excited state (n=1) just as we had defined earlier. Note the the slight oscillations in occupation probability, which would be absent without the coupling term in the Hamiltonian. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07e54942",
   "metadata": {},
   "source": [
    "### Adding Time-Dependence to the Hamiltonian"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec3ca659",
   "metadata": {},
   "source": [
    "Now we will add the time-dependent term to the Hamiltonian representing the operation of a CR gate. We will add a drive term to qubit 1, driving at the frequency of qubit 2. Recall that the drive term has the form: \n",
    "\n",
    "$H_{Drive} = \\Omega cos(\\omega_1^{RF} t + \\phi) \\sigma_1^{x}   $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9677d7ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "amp = 0.5  # amplitude of driving force (Omega)\n",
    "phi = 0.0  # set the phase equal to zero\n",
    "\n",
    "H_drive = amp * (a + a.dag())  # this is the time-independent part of the driving term\n",
    "\n",
    "\n",
    "# add the explicit time-dependence here:\n",
    "def H_time(t, args=None):\n",
    "    return np.cos(w2 * t + phi)\n",
    "\n",
    "\n",
    "# combine time-independent and time-dependent terms:\n",
    "H = [H0, [H_drive, H_time]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aab96666",
   "metadata": {},
   "source": [
    "Since we already defined, populated and plotted the occupation operators in the time-independent analysis above, let's re-define them here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ac7c61f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Re-define our occupation probability operators\n",
    "\n",
    "c0 = basis(2, 0)\n",
    "n0_qubit1 = c0 * c0.dag()\n",
    "n0_qubit1 = tensor(n0_qubit1, qeye(2))\n",
    "\n",
    "c1 = basis(2, 1)\n",
    "n1_qubit1 = c1 * c1.dag()\n",
    "n1_qubit1 = tensor(n1_qubit1, qeye(2))\n",
    "\n",
    "c0 = basis(2, 0)\n",
    "n0_qubit2 = c0 * c0.dag()\n",
    "n0_qubit2 = tensor(qeye(2), n0_qubit2)\n",
    "\n",
    "c1 = basis(2, 1)\n",
    "n1_qubit2 = c1 * c1.dag()\n",
    "n1_qubit2 = tensor(qeye(2), n1_qubit2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c713857",
   "metadata": {},
   "source": [
    "Now let's solve the master equation again for the time-dependent Hamiltonian:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7f48f0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "tlist = tlist = np.linspace(\n",
    "    0, 201, 101\n",
    ")  # time between t=0 and t=201 with 101 increments\n",
    "c_ops = []  # dissipation terms; none\n",
    "output = mesolve(\n",
    "    H,\n",
    "    Psi0,\n",
    "    tlist,\n",
    "    c_ops,\n",
    "    [\n",
    "        n0_qubit1,\n",
    "        n1_qubit1,\n",
    "        a.dag() * a,\n",
    "        a + a.dag(),\n",
    "        n0_qubit2,\n",
    "        n1_qubit2,\n",
    "        b.dag() * b,\n",
    "        b + b.dag(),\n",
    "    ],\n",
    ")  # time evolution\n",
    "\n",
    "# expectation values\n",
    "n_qubit1 = output.expect[0]\n",
    "m_qubit1 = output.expect[1]\n",
    "ham_qubit1 = output.expect[2]\n",
    "num_qubit1 = output.expect[3]\n",
    "\n",
    "n_qubit2 = output.expect[4]\n",
    "m_qubit2 = output.expect[5]\n",
    "ham_qubit2 = output.expect[6]\n",
    "num_qubit2 = output.expect[7]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65423937",
   "metadata": {},
   "source": [
    "And now let's plot the results again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34de987c",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(1, figsize=(10, 5))\n",
    "plt.subplot(121)\n",
    "plt.plot(tlist, n_qubit1, label=\"n=0\")\n",
    "plt.plot(tlist, m_qubit1, label=\"n=1\")\n",
    "plt.legend(loc=0)\n",
    "plt.xlabel(\"Time\")\n",
    "plt.ylabel(\"Occupation Probability\")\n",
    "plt.title(\"Qubit1\")\n",
    "\n",
    "plt.subplot(122)\n",
    "plt.plot(tlist, n_qubit2, label=\"n=0\")\n",
    "plt.plot(tlist, m_qubit2, label=\"n=1\")\n",
    "plt.legend(loc=0)\n",
    "plt.xlabel(\"Time\")\n",
    "plt.ylabel(\"Occupation Probability\")\n",
    "plt.title(\"Qubit2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3870d12c",
   "metadata": {},
   "source": [
    "Here we can see that by applying a driving force to the first qubit, we observe an inversion in the occupation probability of the second qubit. This highlights the basic operational principle of the CR gate. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3531f51f",
   "metadata": {},
   "source": [
    "## Physical Design of the CR Gate "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fae4b09",
   "metadata": {},
   "source": [
    "The physical design of a CR gate consists simply of two qubits connected via a bus resonator. For a concrete example of what this design may look like, we can use the example in H. Park et al. Proc. IEEE IEDM (2020). \n",
    "\n",
    "Link: https://ieeexplore.ieee.org/abstract/document/9371955?casa_token=V3vN91zwr4EAAAAA:OwS7ixnZTFZlL0mnIf5idc5l0P_sufOJAnEh0TLxPZ7HB6EJAwS2Y-XVrW3j5R3-gifZrX6JF63Azg\n",
    "\n",
    "This paper shows show different designs for a CR-gate. We'll construct a design very similar to the first one. \n",
    "\n",
    "Let's open up the qiskit metal design GUI:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67dfd082",
   "metadata": {},
   "outputs": [],
   "source": [
    "import qiskit_metal as metal\n",
    "from qiskit_metal import designs, draw\n",
    "from qiskit_metal import MetalGUI, Dict, open_docs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57550871",
   "metadata": {},
   "source": [
    "While one could construct a CR gate using any transmon qubit design, we'll use the generic transmon pocket to be consistent with the paper:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a434cafe",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_metal.qlibrary.qubits.transmon_pocket_6 import TransmonPocket6\n",
    "\n",
    "design = metal.designs.DesignPlanar()\n",
    "gui = metal.MetalGUI(design)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f37b970d",
   "metadata": {},
   "outputs": [],
   "source": [
    "design.overwrite_enabled = True\n",
    "design.chips.main"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83ceb7b9",
   "metadata": {},
   "source": [
    "For each of the two transmon qubits, we'll include two capacitively coupled pads (\"readout\" and \"bus\"). We'll put one of htem at (-1,0) and the other at (1,0) with the second one being rotated 90 degrees relative to the first. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed84e1ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q1 = TransmonPocket6(\n",
    "    design,\n",
    "    \"Q1\",\n",
    "    options=dict(\n",
    "        pos_x=\"-1mm\",\n",
    "        pos_y=\"0mm\",\n",
    "        pad_width=\"425 um\",\n",
    "        pocket_height=\"650um\",\n",
    "        connection_pads=dict(\n",
    "            readout=dict(loc_W=1, loc_H=-1, pad_width=\"100um\", pad_gap=\"50um\"),\n",
    "            bus_01=dict(loc_W=1, loc_H=1, pad_width=\"100um\", pad_gap=\"50um\"),\n",
    "        ),\n",
    "    ),\n",
    ")\n",
    "\n",
    "Q2 = TransmonPocket6(\n",
    "    design,\n",
    "    \"Q2\",\n",
    "    options=dict(\n",
    "        pos_x=\"1mm\",\n",
    "        pos_y=\"0mm\",\n",
    "        orientation=-90,\n",
    "        pad_width=\"425 um\",\n",
    "        pocket_height=\"650um\",\n",
    "        connection_pads=dict(\n",
    "            readout=dict(loc_W=-1, loc_H=-1, pad_width=\"100um\", pad_gap=\"50um\"),\n",
    "            bus_01=dict(loc_W=-1, loc_H=1, pad_width=\"100um\", pad_gap=\"50um\"),\n",
    "        ),\n",
    "    ),\n",
    ")\n",
    "\n",
    "\n",
    "gui.rebuild()\n",
    "gui.autoscale()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a574182c",
   "metadata": {},
   "source": [
    "Here's a screenshot showing the two qubits:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b3b48ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "gui.screenshot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afe0bc26",
   "metadata": {},
   "source": [
    "Now we just have to connect these two transmon qubits with a CPW. We'll use the RouteMeader to do this, connecting the \"readout\" island of the first qubit to the \"readout\" island of the second qubit. We'll also specify a series of left-hand and right-hand turns in order to mimc the shape of the CPW resonator that we see in the paper: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e81dbf9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength\n",
    "from qiskit_metal.qlibrary.tlines.meandered import RouteMeander\n",
    "from qiskit_metal.qlibrary.tlines.pathfinder import RoutePathfinder\n",
    "from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors\n",
    "\n",
    "from collections import OrderedDict\n",
    "\n",
    "jogs_start = OrderedDict()\n",
    "jogs_start[0] = [\"R\", \"1200um\"]\n",
    "jogs_start[1] = [\"R\", \"200um\"]\n",
    "jogs_start[2] = [\"R\", \"700um\"]\n",
    "jogs_start[3] = [\"L\", \"200um\"]\n",
    "jogs_start[4] = [\"L\", \"700um\"]\n",
    "jogs_start[5] = [\"R\", \"200um\"]\n",
    "jogs_start[6] = [\"R\", \"750um\"]\n",
    "jogs_start[7] = [\"L\", \"200um\"]\n",
    "jogs_start[8] = [\"L\", \"1200um\"]\n",
    "jogs_start[9] = [\"L\", \"1800um\"]\n",
    "jogs_start[10] = [\"L\", \"2500um\"]\n",
    "\n",
    "jogs_end = OrderedDict()\n",
    "jogs_end[0] = [\"R\", \"200um\"]\n",
    "\n",
    "bus_01 = RouteMeander(\n",
    "    design,\n",
    "    \"Coupler\",\n",
    "    options=dict(\n",
    "        hfss_wire_bonds=True,\n",
    "        pin_inputs=Dict(\n",
    "            start_pin=Dict(component=\"Q1\", pin=\"readout\"),\n",
    "            end_pin=Dict(component=\"Q2\", pin=\"readout\"),\n",
    "        ),\n",
    "        lead=Dict(\n",
    "            start_straight=\"100um\",  #'125um',\n",
    "            start_jogged_extension=jogs_start,\n",
    "            end_straight=\"100um\",  #  '225um'\n",
    "        ),\n",
    "        meander=Dict(asymmetry=\"0um\"),  #'1305um'),\n",
    "        fillet=\"99um\",\n",
    "        total_length=\"10mm\",\n",
    "    ),\n",
    ")\n",
    "gui.rebuild()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5f4b2cc",
   "metadata": {},
   "source": [
    "And here's a screenshot showing the meandering CPW connection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0d8460a",
   "metadata": {},
   "outputs": [],
   "source": [
    "gui.rebuild()\n",
    "gui.autoscale()\n",
    "gui.screenshot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "781aa704",
   "metadata": {},
   "source": [
    "Voila! Now you know not only how a CR gate behaves physically but what it looks like in physical design! "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "metal_qamp_v2",
   "language": "python",
   "name": "metal_qamp_v2"
  },
  "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}