{ "cells": [ { "cell_type": "markdown", "id": "6da81a9b", "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": "2ac85c04", "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": "ada9b7ad", "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": "6f873993", "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": "b8f26d48", "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": "211ce2c0", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "c2f8d2a6", "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": "cf9cc203", "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": "614bb8a8", "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": "f7762d02", "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.002257 -0.01543 ... -0.003023 -0.01241\n",
       "    y1       (dim_0) float64 8kB 0.003228 -0.003572 ... 0.004915 0.004513\n",
       "Attributes:\n",
       "    tuid:                             20250428-110325-321-879e47\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.002257 -0.01543 ... -0.003023 -0.01241\n", " y1 (dim_0) float64 8kB 0.003228 -0.003572 ... 0.004915 0.004513\n", "Attributes:\n", " tuid: 20250428-110325-321-879e47\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": "a346fc9e", "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": "b84c8384", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/uncertainties/core.py:1024: UserWarning: Using UFloat objects with std_dev==0 may give unexpected results.\n", " warn(\"Using UFloat objects with std_dev==0 may give unexpected results.\")\n" ] }, { "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": "06a6cdd0", "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": "b8ee1f1d", "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": "1aa4b5c2", "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": "23d0863e", "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": "e0bbdba7", "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": "998f516f", "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": "43198c5d", "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": "b3cf8e77", "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": "e6766c42", "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": "4c680cd6", "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": "74a64bc2", "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": "7e35687f", "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": "79b213e3", "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": "2164bc77", "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.22" }, "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 }