{ "cells": [ { "cell_type": "markdown", "id": "7913afb0", "metadata": {}, "source": [ "(sec-tutorial-conditional-reset)=\n", "\n", "\n", "```{seealso}\n", "The complete source code of this tutorial can be found in\n", "\n", "{nb-download}`Conditional Reset.ipynb`\n", "\n", "```\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": "1c1b930e", "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": "019cc26b", "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.device_under_test.quantum_device import QuantumDevice\n", "from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement\n", "from quantify_scheduler.instrument_coordinator import InstrumentCoordinator\n", "from quantify_scheduler.instrument_coordinator.components.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": "d47eb089", "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": "a53aaa46", "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": "da88b534", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "02867c3b", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "hardware_cfg = {\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}.module2.complex_output_0\", \"q0:mw\"),\n", " ]\n", " },\n", "}\n", "\n", "single_qubit_device.hardware_config(hardware_cfg)" ] }, { "cell_type": "markdown", "id": "3e72addf", "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": "4abfb6da", "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.helpers.qblox_dummy_instrument import (\n", " start_dummy_cluster_armed_sequencers,\n", ")\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": "f86278a0", "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.0004568 -0.01343 ... -0.001208 -0.009998\n",
       "    y1       (dim_0) float64 8kB 0.006868 0.005883 ... 0.003216 -0.0008591\n",
       "Attributes:\n",
       "    tuid:                             20241014-165455-111-6672b9\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.0004568 -0.01343 ... -0.001208 -0.009998\n", " y1 (dim_0) float64 8kB 0.006868 0.005883 ... 0.003216 -0.0008591\n", "Attributes:\n", " tuid: 20241014-165455-111-6672b9\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.gettables import ScheduleGettable\n", "from quantify_scheduler.operations.gate_library import Measure\n", "from quantify_scheduler.schedules.schedule import Schedule\n", "from quantify_scheduler.schedules.timedomain_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": "e22666a6", "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": "493a7249", "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": "dd96e0ef", "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": "e98518e9", "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": "6959c308", "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": "a8f0fb3e", "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": "e8c0a980", "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": "06383c0e", "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": "37fd8373", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.backends.qblox.operations.gate_library import ConditionalReset\n", "from quantify_scheduler.operations.gate_library 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": "7339afea", "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": "3e28ef1e", "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": "0d96c092", "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": "7f9d84f4", "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": "1eb5c165", "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": "6f28142d", "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": "32828bb0", "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.20" }, "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, 125, 132, 149, 153, 184, 194, 257, 290, 300, 308, 312, 321, 328, 348, 389, 410, 461, 474, 530, 556, 565, 571, 577 ] }, "nbformat": 4, "nbformat_minor": 5 }