About halfway through measurement explanations!

Author: lcapelluto

qiskit/advanced/terra/programming_with_pulses/adding_measurements.ipynb

@@ -4,39 +4,136 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Measurement\n",
+    "# Adding measurements to `Schedule`s\n",
     "\n",
-    "TODO\n",
+    "Measurement is clearly a very important part of building a Pulse schedule -- this is how we get the results of our program execution! The powerful low-level control we are granted by Pulse gives us more freedom than `QuantumCircuit`s in specifying how the measurement should be done, enabling the user to explore readout error mitigation. This power of course comes with responsibility: we have to understand how measurement works, and accomodate certain hardware constraints.\n",
     "\n",
-    "TODO: I think measure should _just_ return a schedule."
+    "On this page, we will explore in depth how to create measurements, using several different approaches of increasing complexity.\n",
+    "\n",
+    "**Note: Pulse allows you to receive raw, kerneled, and disciminated readout data (whereas circuits will only return discriminated data). Documentation for these options can be found here-COMING SOON.**\n",
+    "\n",
+    "### Quick reference for adding a backend-default measurement\n",
+    "There is a feature that allows you to add measurements as easily to `Schedule`s as to `QuantumCircuit`s, with just the qubits you want to measure (below, qubits 0 and 1) and your OpenPulse-enabled `backend`:\n",
+    "\n",
+    "```\n",
+    "# Appending a measurement schedule to a Schedule, sched\n",
+    "from qiskit.pulse import measure\n",
+    "sched += measure([0, 1], backend) << sched.duration\n",
+    "```\n",
+    "The `backend` contains a default definition for measurement. Compare this to adding measurements to a `QuantumCircuit`, `qc`:\n",
+    "```\n",
+    "qc.measure(quantum_reg[0], classical_reg[0])\n",
+    "qc.measure(quantum_reg[1], classical_reg[1])\n",
+    "```\n",
+    "\n",
+    "### Basic measurement pattern\n",
+    "Let's use the default measurement feature to inspect a measurement and learn what each pulse does."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x864 with 1 Axes>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# from qiskit.pulse import measure, Schedule\n",
     "from qiskit import IBMQ\n",
+    "from qiskit.pulse import Schedule\n",
+    "from qiskit.scheduler.utils import measure_all\n",
     "\n",
-    "# backend = IBMQ.load_account().backends(open_pulse=True)\n",
+    "backend = IBMQ.load_account().backends(open_pulse=True)[0]\n",
     "\n",
-    "# sched = Schedule(name=\"Measurement scheduling example\")\n",
-    "# sched = measure_all(backend)\n",
+    "sched = Schedule(name=\"Measurement scheduling example\")\n",
+    "sched += measure_all(backend)\n",
     "\n",
-    "# sched.draw()"
+    "sched.draw()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Each qubit has two channels related to readout. These are the readout transmit `MeasureChannel`s, and the readout receive `AcquireChannel`s. In superconducting qubit architectures, qubits are coupled to readout resonators. The coupling hybridizes the state between the qubit and the readout resonator. The `MeasureChannel` and `AcquireChannel`s label signal lines which connect to the readout resonator. When a stimulus pulse is sent to the The effect is that the signal reflected  \n",
+    "\n",
+    "#### Additional options on `measure`\n",
+    "\n",
+    "`qubit_mem_slots`\n",
+    "TODO explain how to do qubit mapping to mem slots"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((0,\n",
+       "  AcquireInstruction(Acquire(duration=16000, kernel=acq0, discriminator=None, name=\"None\"), AcquireChannel(0), MemorySlot(1))),\n",
+       " (0,\n",
+       "  PulseInstruction(SamplePulse(samples=array([0.00295201+0.j, 0.00597357+0.j, 0.00906536+0.j, ...,\n",
+       "         0.00906536+0.j, 0.00597357+0.j, 0.00295201+0.j]), name=\"M_m0_5e3c\"), MeasureChannel(0))))"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from qiskit.scheduler.utils import measure\n",
+    "\n",
+    "sched = measure(qubits=[0], backend=backend, qubit_mem_slots={0: 1})\n",
+    "\n",
+    "sched.instructions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
-    "# sched += measure(qubits=(0, 1), backend=backend, qubit_mem_slots={0:1, 1:0})\n",
+    "TODO other custom args for `measure`\n",
     "\n",
-    "# sched.draw()"
+    "`inst_map`\n",
+    "\n",
+    "`meas_map`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Measurement map `meas_map`\n",
+    "\n",
+    "Due to control rack hardware constraints, some qubits may need to be acquired together. This can be the case for qubits whose readout channels are multiplexed. The OpenPulse backend will provide a `meas_map` to notify the user of this.\n",
+    "\n",
+    "For instance, if we see this for a 5-qubit `backend`\n",
+    "\n",
+    "```\n",
+    "backend.configuration().meas_map\n",
+    "\n",
+    "Out: [[0, 1, 2, 3, 4]]\n",
+    "```\n",
+    "\n",
+    "then we know that all the qubits on this device must be acquired together. On the other hand, if we see this\n",
+    "\n",
+    "```\n",
+    "Out: [[0], [1], [2], [3, 4]]\n",
+    "```\n",
+    "\n",
+    "this tells us that qubits 0, 1 and 2 can be acquired independently, but qubits 3 and 4 must be acquired together."
    ]
   },
   {
@@ -48,7 +145,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -58,37 +155,28 @@
        "<Figure size 720x864 with 1 Axes>"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "from qiskit.pulse import GaussianSquare, MeasureChannel, Acquire, AcquireChannel, MemorySlot\n",
     "\n",
-    "measure_tx = GaussianSquare(duration=1200, amp=0.2, sigma=10, width=1150)(MeasureChannel(0))\n",
-    "measure_tx += GaussianSquare(duration=1200, amp=0.2, sigma=10, width=1150)(MeasureChannel(1))\n",
-    "# TODO\n",
-    "measure_rx = Acquire(1200)([AcquireChannel(0), AcquireChannel(1)],\n",
-    "                           [MemorySlot(1), MemorySlot(0)])\n",
+    "duration = 1200\n",
+    "\n",
+    "measure_tx = GaussianSquare(duration=duration, amp=0.2, sigma=10, width=duration - 50)(MeasureChannel(0))\n",
+    "measure_tx += GaussianSquare(duration=duration, amp=0.2, sigma=10, width=duration - 50)(MeasureChannel(1))\n",
+    "\n",
+    "acquire = Acquire(duration)\n",
+    "measure_rx = acquire(AcquireChannel(0), MemorySlot(0))\n",
+    "measure_rx += acquire(AcquireChannel(1), MemorySlot(1))\n",
     "\n",
     "measure_sched = measure_tx + measure_rx\n",
     "\n",
     "measure_sched.draw()"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# from qiskit.pulse import measure_schedule\n",
-    "\n",
-    "# measure_schedule(qubit_mem_slot_map={0:1, 1:0}, measure_map=[[0, 1, 2]],\n",
-    "#                  duration=1200, meas_amp=1, meas_sigma=10, meas_width=1100)\n"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,