{ "cells": [ { "cell_type": "markdown", "id": "02353d81", "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": "e0197903", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1885/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": "2fa526a9", "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": "1a7b2452", "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": "fba2acd0", "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": "bc12a122", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "41f9f114", "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": "dcd16e66", "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": "214ebaf6", "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": "5ccdb9dc", "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.003907 -0.01159 ... -0.001616 -0.01527\n",
       "    y1       (dim_0) float64 8kB 0.003588 -0.0007438 ... -0.003927 0.005494\n",
       "Attributes:\n",
       "    tuid:                             20260204-174717-701-ff83de\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.003907 -0.01159 ... -0.001616 -0.01527\n", " y1 (dim_0) float64 8kB 0.003588 -0.0007438 ... -0.003927 0.005494\n", "Attributes:\n", " tuid: 20260204-174717-701-ff83de\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": "0f509cff", "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": "b2d33087", "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": "6d04babd", "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": "ee6c07ec", "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": "cdf22342", "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": "cbfaf7bb", "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": "e3890c43", "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": "91b2ca08", "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": "0269c8e4", "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": "9ee51e01", "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": "e2681309", "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": "ea7a5d34", "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": "2bf00539", "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": "c4d30601", "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": "b24720ef", "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": "5c000ac9", "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 }