{ "cells": [ { "cell_type": "markdown", "id": "1bbfa60a", "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": "f6487119", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1884/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": "0e79221b", "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": "8c2f7e17", "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": "dfdfcb04", "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": "a81abaf2", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "8bd6a5e1", "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": "04501201", "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": "d2ddc7b1", "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": "aba30a1e", "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.003772 -0.01472 ... -0.005886 -0.01334\n",
       "    y1       (dim_0) float64 8kB -0.0008844 0.003788 ... 0.005242 0.002135\n",
       "Attributes:\n",
       "    tuid:                             20251106-100437-971-aaeb3f\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.003772 -0.01472 ... -0.005886 -0.01334\n", " y1 (dim_0) float64 8kB -0.0008844 0.003788 ... 0.005242 0.002135\n", "Attributes:\n", " tuid: 20251106-100437-971-aaeb3f\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": "89cc7d3e", "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": "f981c144", "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": "e995562e", "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": "5cb48ecd", "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": "50b141b0", "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": "94a85e8a", "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": "1155b45a", "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": "9a82b74b", "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": "308a3f02", "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": "ccc946dd", "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": "126eb595", "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": "343ca220", "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": "93e19a7a", "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": "087d4e37", "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": "9eaa0034", "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": "8933c040", "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.25" }, "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 }