{ "cells": [ { "cell_type": "markdown", "id": "1cab45bd", "metadata": {}, "source": [ "```{seealso}\n", "The complete source code of this tutorial can be found in\n", "\n", "{nb-download}`Conditional Reset.ipynb`\n", "\n", "```\n", "\n", "(sec-tutorial-conditional-reset)=\n", "\n", "# Tutorial: Conditional Reset\n", "\n", "In this tutorial, we show how to perform a conditional reset using the [conditional control flow framework](sec-control-flow). A conditional reset consists of measuring the state of a qubit, and then:\n", "- sending a pulse to rotate the qubit to the ground state in case the qubit is found to be in an excited state\n", "- not sending any pulse if the qubit is found to be in the ground state\n", "\n", "This conditional reset is potentially much faster than an idle qubit reset (i.e. waiting for a time {math}`\\gg \\tau_1`).\n", "Quantify discriminates between excited and ground state at the `Measure` operation using a [thresholded acquisition](thresholded_acquisition_explanation), and uses a default {math}`\\pi` pulse to set the qubit to its ground state.\n", "In this tutorial, we demonstrate conditional reset using a Qblox cluster that contains a readout module (`QRM_RF`), responsible for the measurement of the qubit, and a control module (`QCM_RF`), responsible for conditionally sending out the {math}`\\pi` pulse.\n", "\n", "To run a conditional reset, we perform the following steps:\n", "\n", "1. Set up the quantum device, dummy hardware, and hardware configuration.\n", "2. Configure thresholded acquisition parameters to separate the {math}`|0\\rangle` and {math}`|1\\rangle` states.\n", "3. Verify that these parameters are set correctly.\n", "4. Run a conditional reset.\n", "\n", "\n", "```{note}\n", "Currently, the conditional reset is only implemented for the Qblox hardware.\n", "```\n", "\n", "(cond_reset_initial_setup)=\n", "\n", "## Initial Setup\n", "\n", "We follow here the same setup as in the {ref}`sec-tutorial-experiment` tutorial.\n", "\n", "First, we define a single transmon qubit as an element ({{ BasicTransmonElement }}) of the {{ QuantumDevice }} and populate the parameters with some reasonable values:\n", "\n", "```{seealso}\n", "If you want to learn more about how to set up the {{ QuantumDevice }} and hardware configuration, please see our other tutorials, in particular {ref}`sec-tutorial-experiment` and {ref}`sec-tutorial-compiling`.\n", "```" ] }, { "cell_type": "code", "execution_count": 1, "id": "52cc9917", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1412/40710294.py:4: DeprecationWarning: This package has reached its end of life. It is no longer maintained and will not receive any further updates or support. For further developments, please refer to the new Quantify repository: https://gitlab.com/quantify-os/quantify.All existing functionalities can be accessed via the new Quantify repository.\n", " from quantify_core.analysis import base_analysis as ba\n" ] } ], "source": [ "\"\"\"Disable transparent backgrounds for analysis figures to make them look nicer\n", "in both dark and bright mode on the website.\"\"\"\n", "\n", "from quantify_core.analysis import base_analysis as ba\n", "\n", "ba.settings[\"mpl_transparent_background\"] = False" ] }, { "cell_type": "code", "execution_count": 2, "id": "5556242b", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from qblox_instruments import Cluster, ClusterType\n", "import tempfile\n", "\n", "from quantify_core.data import handling as dh\n", "from quantify_core.measurement.control import MeasurementControl\n", "from quantify_scheduler import BasicTransmonElement, InstrumentCoordinator, QuantumDevice\n", "from quantify_scheduler.qblox import ClusterComponent\n", "\n", "measurement_control = MeasurementControl(\"measurement_control\")\n", "instrument_coordinator = InstrumentCoordinator(\"instrument_coordinator\")\n", "\n", "# Create a temporary directory for this tutorial\n", "temp_dir = tempfile.mkdtemp()\n", "\n", "# First, don't forget to set the data directory!\n", "dh.set_datadir(temp_dir)\n", "\n", "# Device parameters\n", "ACQ_DELAY = 100e-9\n", "FREQ_01 = 4e9\n", "READOUT_AMP = 0.1\n", "READOUT_FREQ = 4.3e9\n", "PI_PULSE_AMP = 0.15\n", "LO_FREQ_QUBIT = 3.9e9\n", "LO_FREQ_READOUT = 4.5e9\n", "\n", "single_qubit_device = QuantumDevice(\"single_qubit_device\")\n", "\n", "q0 = BasicTransmonElement(\"q0\")\n", "single_qubit_device.add_element(q0)\n", "\n", "# Assign device parameters to transmon element\n", "q0.measure.pulse_amp(READOUT_AMP)\n", "q0.clock_freqs.readout(READOUT_FREQ)\n", "q0.clock_freqs.f01(FREQ_01)\n", "q0.measure.acq_delay(ACQ_DELAY)\n", "q0.rxy.amp180(PI_PULSE_AMP)" ] }, { "cell_type": "markdown", "id": "be62d0f8", "metadata": {}, "source": [ "Next, we connect to a dummy {{ Cluster }}. If you are connecting to an actual cluster, you would provide the\n", " `identifier` argument (the IP address, device name or serial number) instead\n", " of the `dummy_cfg` argument." ] }, { "cell_type": "code", "execution_count": 3, "id": "5d440784", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "cluster = Cluster(\n", " \"cluster\",\n", " dummy_cfg={\n", " 1: ClusterType.CLUSTER_QRM_RF,\n", " 2: ClusterType.CLUSTER_QCM_RF,\n", " },\n", ")\n", "\n", "ic_cluster = ClusterComponent(cluster)\n", "\n", "instrument_coordinator.add_component(ic_cluster)\n", "\n", "single_qubit_device.instr_instrument_coordinator(instrument_coordinator.name)" ] }, { "cell_type": "markdown", "id": "d14a859d", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "72545b8b", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "hardware_cfg = {\n", " \"version\": \"0.2\",\n", " \"config_type\": \"quantify_scheduler.backends.qblox_backend.QbloxHardwareCompilationConfig\",\n", " \"hardware_description\": {\n", " f\"{cluster.name}\": {\n", " \"instrument_type\": \"Cluster\",\n", " \"modules\": {\n", " 1: {\"instrument_type\": \"QRM_RF\"},\n", " 2: {\"instrument_type\": \"QCM_RF\"},\n", " },\n", " \"ref\": \"internal\",\n", " }\n", " },\n", " \"hardware_options\": {\n", " \"modulation_frequencies\": {\n", " \"q0:res-q0.ro\": {\"lo_freq\": LO_FREQ_READOUT},\n", " \"q0:mw-q0.01\": {\"lo_freq\": LO_FREQ_QUBIT},\n", " }\n", " },\n", " \"connectivity\": {\n", " \"graph\": [\n", " (f\"{cluster.name}.module1.complex_output_0\", \"q0:res\"),\n", " (f\"{cluster.name}.module1.complex_input_0\", \"q0:res\"),\n", " (f\"{cluster.name}.module2.complex_output_0\", \"q0:mw\"),\n", " ]\n", " },\n", "}\n", "\n", "single_qubit_device.hardware_config(hardware_cfg)" ] }, { "cell_type": "markdown", "id": "e88638d9", "metadata": {}, "source": [ "(cond_reset_create_schedule)=\n", "\n", "## Readout Calibration\n", "\n", "To discriminate between the ground state and the excited state with {{ ConditionalReset }}, we first need to configure the {{ ThresholdedAcquisition }} parameters `acq_threshold` and `acq_rotation` (see [Tutorial: Acquisitions](thresholded_acquisition_explanation)). We do so by preparing a qubit in either its ground state or its excited state, performing a measurement, and repeating this process 500 times. In the measured IQ plane we expect to find all data points clustered in two distinct groups that correspond to the two different states, and the `acq_threshold` and `acq_rotation` parameters define the line between the two groups. \n", "\n", "We run this calibration using {{ MeasurementControl }} and a predefined {{ Schedule }} called {{ readout_calibration_sched }}:" ] }, { "cell_type": "code", "execution_count": 5, "id": "59d7f765", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "### Generate dummy data\n", "\n", "import numpy as np\n", "from qblox_instruments.ieee488_2.dummy_transport import DummyBinnedAcquisitionData\n", "from quantify_scheduler.qblox import start_dummy_cluster_armed_sequencers\n", "\n", "def get_dummy_binned_acquisition_data(\n", " real: float, imag: float, theta: float, threshold: float\n", "):\n", " angle = 2 * np.pi * theta / (360)\n", " threshold *= 1000 # different normalization (integration length) on qblox instruments\n", " if real * np.cos(angle) - imag * np.sin(angle) > threshold:\n", " thres = 1\n", " else:\n", " thres = 0\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=thres, avg_cnt=0)\n", "\n", "\n", "def setup_dummy_data(theta: float, threshold: float):\n", " # Means and standard deviations\n", " x0, xs0 = -2.7, 2.5\n", " y0, ys0 = 2.9, 2.5\n", " x1, xs1 = -14, 2.5\n", " y1, ys1 = 1.9, 2.5\n", "\n", " # Number of points per data cluster\n", " max_batch_size = 60\n", "\n", " # Generate random samples\n", " x0_samples = np.random.normal(x0, xs0, max_batch_size)\n", " y0_samples = np.random.normal(y0, ys0, max_batch_size)\n", " x1_samples = np.random.normal(x1, xs1, max_batch_size)\n", " y1_samples = np.random.normal(y1, ys1, max_batch_size)\n", "\n", " # interleave the random samples such that we get\n", " # x = [x0_samples[0], x1_samples[0], x0_samples[1],...]\n", " # y = [y0_samples[0], y1_samples[0], y0_samples[1],...]\n", "\n", " x = np.vstack((x0_samples, x1_samples)).reshape(-1, order=\"F\")\n", " y = np.vstack((y0_samples, y1_samples)).reshape(-1, order=\"F\")\n", " states = np.array([0, 1] * max_batch_size)\n", "\n", " # prepare cluster with dummy data that will be returned \n", " # after retrieving acquisitions.\n", " cluster.delete_dummy_binned_acquisition_data(1)\n", " cluster.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=\"0\",\n", " data=[\n", " get_dummy_binned_acquisition_data(float(re), float(im), theta, threshold)\n", " for re, im in zip(x, y)\n", " ],\n", " )\n", "\n", "def setup_dummy_and_start_sequencer(theta: float, threshold: float):\n", " setup_dummy_data(theta, threshold)\n", " start_dummy_cluster_armed_sequencers(ic_cluster)\n", "\n", "cluster.start_sequencer = lambda: setup_dummy_and_start_sequencer(0, 0)" ] }, { "cell_type": "code", "execution_count": 6, "id": "5afdadca", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 24kB\n",
       "Dimensions:  (dim_0: 1000)\n",
       "Coordinates:\n",
       "    x0       (dim_0) int64 8kB 0 1 0 1 0 1 0 1 0 1 0 1 ... 1 0 1 0 1 0 1 0 1 0 1\n",
       "Dimensions without coordinates: dim_0\n",
       "Data variables:\n",
       "    y0       (dim_0) float64 8kB -0.00338 -0.01558 ... -0.003804 -0.01406\n",
       "    y1       (dim_0) float64 8kB 0.002537 0.001391 ... 0.006538 -0.0009008\n",
       "Attributes:\n",
       "    tuid:                             20250919-041306-279-b6edcf\n",
       "    name:                             Readout Calibration\n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         False\n",
       "    1d_2_settables_uniformly_spaced:  False
" ], "text/plain": [ " Size: 24kB\n", "Dimensions: (dim_0: 1000)\n", "Coordinates:\n", " x0 (dim_0) int64 8kB 0 1 0 1 0 1 0 1 0 1 0 1 ... 1 0 1 0 1 0 1 0 1 0 1\n", "Dimensions without coordinates: dim_0\n", "Data variables:\n", " y0 (dim_0) float64 8kB -0.00338 -0.01558 ... -0.003804 -0.01406\n", " y1 (dim_0) float64 8kB 0.002537 0.001391 ... 0.006538 -0.0009008\n", "Attributes:\n", " tuid: 20250919-041306-279-b6edcf\n", " name: Readout Calibration\n", " grid_2d: False\n", " grid_2d_uniformly_spaced: False\n", " 1d_2_settables_uniformly_spaced: False" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "from qcodes import ManualParameter\n", "\n", "from quantify_scheduler import Schedule, ScheduleGettable\n", "from quantify_scheduler.operations import Measure\n", "from quantify_scheduler.schedules import readout_calibration_sched\n", "\n", "\n", "single_qubit_device.cfg_sched_repetitions(1)\n", "\n", "states = ManualParameter(name=\"States\", unit=\"\", label=\"\")\n", "states.batched = True\n", "\n", "prepared_states = np.asarray([0, 1] * 500)\n", "readout_calibration_kwargs = {\"qubit\": \"q0\", \"prepared_states\": states}\n", "gettable = ScheduleGettable(\n", " single_qubit_device,\n", " schedule_function=readout_calibration_sched,\n", " schedule_kwargs=readout_calibration_kwargs,\n", " real_imag=True,\n", " batched=True,\n", " max_batch_size=60,\n", ")\n", "\n", "measurement_control.settables(states)\n", "measurement_control.setpoints(prepared_states)\n", "measurement_control.gettables(gettable)\n", "measurement_control.verbose(False)\n", "\n", "dataset = measurement_control.run(\"Readout Calibration\")\n", "dataset" ] }, { "cell_type": "markdown", "id": "f030ecc1", "metadata": {}, "source": [ "```{seealso}\n", "More information on configuring {{ MeasurementControl }} can be found in the\n", "[user guide](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#measurement-control)\n", "of `quantify-core`, and in the tutorials [Running and Experiment](sec-tutorial-experiment) and [ScheduleGettable](sec-schedulegettable-2dsweep-usage)\n", "```\n", "\n", "To determine the qubit threshold parameters, we use the {{ ReadoutCalibrationAnalysis }}:" ] }, { "cell_type": "code", "execution_count": 7, "id": "55bcff17", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from quantify_core.analysis.readout_calibration_analysis import (\n", " ReadoutCalibrationAnalysis,\n", ")\n", "\n", "analysis = ReadoutCalibrationAnalysis(dataset)\n", "analysis.run()\n", "analysis.display_figs_mpl()" ] }, { "cell_type": "markdown", "id": "6ec46bc0", "metadata": {}, "source": [ "The image above shows that the measured IQ points are clustered in two groups as expected. We can now fit a line between the two groups and from there obtain the `acq_threshold` and the `acq_rotation` parameters, that we add to the qubit configuration:" ] }, { "cell_type": "code", "execution_count": 8, "id": "4e41adda", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "fit_results = analysis.fit_results[\"linear_discriminator\"].params\n", "acq_threshold = fit_results[\"acq_threshold\"].value\n", "acq_rotation = (np.rad2deg(fit_results[\"acq_rotation_rad\"].value)) % 360\n", "\n", "q0.measure.acq_threshold(acq_threshold)\n", "q0.measure.acq_rotation(acq_rotation)" ] }, { "cell_type": "markdown", "id": "92b616f9", "metadata": {}, "source": [ "## Verifying parameters\n", "\n", "We can quickly verify that the qubit parameters are set correctly by running again the {{ readout_calibration_sched }} schedule with `\"ThresholdedAcquisition\"` as acquisition protocol. If the calibration was done correctly, we expect that when the state is prepared in the {math}`|0\\rangle` state or {math}`|1\\rangle` state, the thresholded acquisition will return 0 or 1 respectively. The results are then verified using a confusion matrix:" ] }, { "cell_type": "code", "execution_count": 9, "id": "3c38d74e", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "cluster.delete_dummy_binned_acquisition_data(1)\n", "\n", "cluster.start_sequencer = lambda: setup_dummy_and_start_sequencer(acq_rotation, acq_threshold)" ] }, { "cell_type": "code", "execution_count": 10, "id": "948f6d79", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from sklearn.metrics import ConfusionMatrixDisplay\n", "import matplotlib.pyplot as plt\n", "\n", "single_qubit_device.cfg_sched_repetitions(1)\n", "\n", "states = ManualParameter(name=\"States\", unit=\"\", label=\"\")\n", "states.batched = True\n", "\n", "prepared_states = np.asarray([0, 1] * 500)\n", "readout_calibration_kwargs = {\n", " \"qubit\": \"q0\",\n", " \"prepared_states\": states,\n", " \"acq_protocol\": \"ThresholdedAcquisition\",\n", "}\n", "\n", "gettable = ScheduleGettable(\n", " single_qubit_device,\n", " schedule_function=readout_calibration_sched,\n", " schedule_kwargs=readout_calibration_kwargs,\n", " real_imag=True,\n", " batched=True,\n", " max_batch_size=60,\n", ")\n", "\n", "measurement_control.settables(states)\n", "measurement_control.setpoints(prepared_states)\n", "measurement_control.gettables(gettable)\n", "dataset = measurement_control.run(\"Readout Calibration Verification\")\n", "\n", "prepared_states = dataset.x0.values\n", "measured_states = dataset.y0.values\n", "\n", "ConfusionMatrixDisplay.from_predictions(\n", " prepared_states, measured_states, cmap=\"Blues\", normalize=None\n", ")\n", "plt.title(\"Confusion Matrix\")\n", "plt.xlabel(\"Measured State\")\n", "plt.ylabel(\"Prepared State\")\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "5d1ecae8", "metadata": {}, "source": [ "As expected, the threshold that we set did a good job of discriminating the qubit states (the discrimination is not perfect because the data points belonging to the two states slightly overlap).\n", "\n", "## Conditional Reset\n", "\n", "The conditional reset is implemented in Quantify as a gate. When we have a single {{ Reset }} at the beginning of a schedule, we simply replace the {{ Reset }} gate with the {{ ConditionalReset }} gate, for example\n", "\n", "```{code-block} python\n", "schedule = Schedule()\n", "#schedule.add(Reset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q0\"))\n", "...\n", "```\n", "\n", "In other cases, however, we need to pass extra arguments to {{ ConditionalReset }} that we illustrate below.\n", "\n", "### Example: Modifying the T1 schedule\n", "\n", "In this example, we use the schedule function {{ t1_sched }} using the {{ ConditionalReset }} instead of the standard {{ Reset }}. We need to ensure that all acquisition protocols in the schedule are equal to `\"ThresholdedAcquisition\"`." ] }, { "cell_type": "code", "execution_count": 11, "id": "d6f89eb5", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.qblox.operations import ConditionalReset\n", "from quantify_scheduler.operations import X, Reset\n", "\n", "\n", "# original T1 schedule\n", "def t1_sched(\n", " times: np.ndarray,\n", " qubit: str,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", "\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(Reset(qubit), label=f\"Reset {i}\")\n", " schedule.add(X(qubit), label=f\"pi {i}\")\n", " schedule.add(\n", " Measure(qubit),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule\n", "\n", "\n", "# updated T1 schedule\n", "def t1_sched(\n", " times: np.ndarray,\n", " qubit: str,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", "\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(\n", " ConditionalReset(qubit, acq_channel=0),\n", " label=f\"Reset {i}\",\n", " )\n", " schedule.add(X(qubit), label=f\"pi {i}\")\n", " schedule.add(\n", " Measure(\n", " qubit,\n", " acq_protocol=\"ThresholdedAcquisition\",\n", " acq_channel=1,\n", " ),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule" ] }, { "cell_type": "markdown", "id": "91033c2f", "metadata": {}, "source": [ "#### Running the T1 schedule using MeasurementControl\n", "\n", "The dataset returned by {{ MeasurementControl }} will in this case have four rows of data, which are: \n", "- `y0`: contains the data establishing whether a qubit was reset or not\n", "- `y1`: contains the actual (thresholded) measurement\n", "- `y2` and `y3`: filled with NaNs (currently {{ MeasurementControl }} expects {{ ScheduleGettable }} to return IQ values)\n", "\n", "Below we run {{ MeasurementControl }} again as before" ] }, { "cell_type": "code", "execution_count": 12, "id": "a4f13663", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "## generate dummy data for a fictitious T1 experiment\n", "\n", "import numpy as np\n", "\n", "tau = 1e-5\n", "runs = 1024\n", "times = np.array(list(np.linspace(start=1.6e-7, stop=4.976e-5, num=125)))\n", "num_samples = len(times)\n", "\n", "random_initial_states = np.mean(\n", " np.random.choice([0, 1], num_samples * runs).reshape(num_samples, runs), axis=1\n", ")\n", "\n", "\n", "def generate_random_numbers(times, tau, runs):\n", " times = np.array(times)\n", "\n", " probabilities = np.exp(-times / tau)\n", "\n", " random_results = np.random.rand(runs, len(times)) < probabilities\n", " average_results = random_results.mean(axis=0)\n", "\n", " return average_results\n", "\n", "\n", "average_T1_data = generate_random_numbers(times, tau, runs)\n", "\n", "cluster.delete_dummy_binned_acquisition_data(1)\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=f\"0\",\n", " data=[\n", " DummyBinnedAcquisitionData(data=(0, 0), thres=x, avg_cnt=0)\n", " for x in random_initial_states\n", " ],\n", ")\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=f\"1\",\n", " data=[\n", " DummyBinnedAcquisitionData(data=(0, 0), thres=x, avg_cnt=0)\n", " for x in average_T1_data\n", " ],\n", ")\n", "\n", "cluster.start_sequencer = lambda: start_dummy_cluster_armed_sequencers(ic_cluster)" ] }, { "cell_type": "code", "execution_count": 13, "id": "de16a57c", "metadata": {}, "outputs": [], "source": [ "single_qubit_device.cfg_sched_repetitions(1024) # run and average 1024 times\n", "\n", "# Configure the settable\n", "time = ManualParameter(\"sample\", label=\"Sample time\", unit=\"s\")\n", "time.batched = True\n", "\n", "times = np.array(list(np.linspace(start=1.6e-7, stop=4.976e-5, num=125)))\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=single_qubit_device,\n", " schedule_function=t1_sched,\n", " schedule_kwargs={\"qubit\": \"q0\", \"times\": times},\n", " batched=True,\n", " num_channels=2,\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables(time)\n", "measurement_control.setpoints(times)\n", "measurement_control.gettables(gettable)\n", "\n", "dataset = measurement_control.run(\"t1\")" ] }, { "cell_type": "code", "execution_count": 14, "id": "015dd35e", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "# we need to temporarily patch the dataset because I don't understand how to\n", "# pass average thresholds to DummyBinnedAcquisitionData such that\n", "# ScheduleGettable returns floats instead of ints\n", "dataset.y0.values = random_initial_states\n", "dataset.y1.values = average_T1_data" ] }, { "cell_type": "markdown", "id": "49169f77", "metadata": {}, "source": [ "Above we also passed `num_channels=2` to the {{ ScheduleGettable }} so that it knows to expect measurements on the same qubit, but separate acquisition channels.\n", "\n", "We now plot the contents of this dataset:" ] }, { "cell_type": "code", "execution_count": 15, "id": "4c7991a2", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(dataset.x0, np.abs(dataset.y1))\n", "plt.xlabel(\"time [s]\")\n", "plt.ylabel('Probability of |1⟩ state')\n", "plt.title('T1 Relaxation Experiment')\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "08f185c9", "metadata": {}, "source": [ "```{note}\n", "Often, we can use an `Analysis` class on datasets to visualize the data and extract relevant parameters such as {{ T1Analysis }}\n", "```\n", "\n", "### Note on Execution Order\n", "\n", "Parallel {{ ConditionalReset }} operations are not supported. For example, compiling the following schedule will raise a {{ RuntimeError }}:\n", "\n", "```{code-block} python\n", "schedule = Schedule(\"\")\n", "schedule.add(ConditionalReset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q1\"), ref_pt=\"start\")\n", "```\n", "\n", "and will have to be scheduled sequentially,\n", "\n", "```{code-block} python\n", "schedule = Schedule(\"\")\n", "schedule.add(ConditionalReset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q1\"))\n", "```\n", "\n", "\n", "## Closing Remarks\n", "\n", "You can find more technical information and explanations of the different limitations in our [reference guide](sec-qblox-conditional-playback)." ] } ], "metadata": { "file_format": "mystnb", "kernelspec": { "display_name": "python3", "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.9.23" }, "myst": { "substitutions": { "BasicTransmonElement": "{class}`~quantify_scheduler.device_under_test.transmon_element.BasicTransmonElement`", "Cluster": "{class}`~qblox_instruments.Cluster`", "ConditionalReset": "{class}`~quantify_scheduler.backends.qblox.operations.gate_library.ConditionalReset`", "Measure": "{class}`~quantify_scheduler.operations.gate_library.Measure`", "MeasurementControl": "{class}`~quantify_core.measurement.control.MeasurementControl`", "QuantumDevice": "{class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice`", "ReadoutCalibrationAnalysis": "{class}`~quantify_core.analysis.readout_calibration_analysis.ReadoutCalibrationAnalysis`", "Reset": "{class}`~quantify_scheduler.operations.gate_library.Reset`", "RuntimeError": "{class}`~RuntimeError`", "Schedule": "{class}`~quantify_scheduler.schedules.schedule.Schedule`", "ScheduleGettable": "{class}`~quantify_scheduler.gettables.ScheduleGettable`", "T1Analysis": "{class}`~quantify_core.analysis.single_qubit_timedomain.T1Analysis`", "ThresholdedAcquisition": "{class}`~quantify_scheduler.operations.acquisition_library.ThresholdedAcquisition`", "readout_calibration_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.readout_calibration_sched`", "t1_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.t1_sched`" } }, "source_map": [ 23, 69, 82, 123, 130, 147, 151, 184, 194, 260, 292, 302, 310, 314, 323, 330, 339, 380, 401, 451, 464, 520, 546, 555, 561, 567 ] }, "nbformat": 4, "nbformat_minor": 5 }