{ "cells": [ { "cell_type": "markdown", "id": "e72a07c9", "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": "b9dbc372", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "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": "76eccaa6", "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": "c10b7659", "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": "a1d7984c", "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": "fd19e78c", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "b2075685", "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": "e9ed4d64", "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": "a83d3bc3", "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 = 0\n", " else:\n", " thres = 1\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=thres, avg_cnt=0)\n", "\n", "\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", "n_points = 500\n", "\n", "# Generate random samples\n", "x0_samples = np.random.normal(x0, xs0, n_points)\n", "y0_samples = np.random.normal(y0, ys0, n_points)\n", "x1_samples = np.random.normal(x1, xs1, n_points)\n", "y1_samples = np.random.normal(y1, ys1, n_points)\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] * 500)\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), 0, 0)\n", " for re, im in zip(x, y)\n", " ],\n", ")\n", "\n", "cluster.start_sequencer = lambda: start_dummy_cluster_armed_sequencers(ic_cluster)" ] }, { "cell_type": "code", "execution_count": 6, "id": "b8311165", "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.008366 -0.01293 ... -0.001399 -0.01093\n",
       "    y1       (dim_0) float64 8kB 0.00233 0.002139 ... 0.002065 0.002102\n",
       "Attributes:\n",
       "    tuid:                             20250119-041226-109-c75198\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.008366 -0.01293 ... -0.001399 -0.01093\n", " y1 (dim_0) float64 8kB 0.00233 0.002139 ... 0.002065 0.002102\n", "Attributes:\n", " tuid: 20250119-041226-109-c75198\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\": prepared_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=200,\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": "168cc297", "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": "63fcb4a9", "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": "248e73ad", "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": "1cb24ca1", "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": "58662768", "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": "c55e6b2c", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "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(\n", " float(re), float(im), acq_rotation, acq_threshold\n", " )\n", " for re, im in zip(x, y)\n", " ],\n", ")\n", "\n", "cluster.start_sequencer = lambda: start_dummy_cluster_armed_sequencers(ic_cluster)" ] }, { "cell_type": "code", "execution_count": 10, "id": "b65b1169", "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\": prepared_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=200,\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": "c2920438", "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 }}. When using multiple consecutive {{ ConditionalReset }} on the same qubit, we need to increment the `acq_index` for each one, similar to when adding multiple {{ Measure }} to the schedule. We also need to ensure that all acquisition protocols in the schedule are equal to `\"ThresholdedAcquisition\"`." ] }, { "cell_type": "code", "execution_count": 11, "id": "d165a920", "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, acq_index=i),\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_index=i, 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_index=i,\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": "8c783d41", "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": "e5e761e3", "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": "7fc42f17", "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": "aab341c9", "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": "c7fd76aa", "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": "cfca5f29", "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": "e376a68c", "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.21" }, "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, 255, 287, 297, 305, 309, 318, 325, 345, 386, 407, 458, 471, 527, 553, 562, 568, 574 ] }, "nbformat": 4, "nbformat_minor": 5 }