{ "cells": [ { "cell_type": "markdown", "id": "d225522b", "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": "b158b611", "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": "e82ae37d", "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": "ba63d640", "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": "f25eb39d", "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": "fe810160", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "c6efb556", "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": "8f3007b0", "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": "444fca97", "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": "9a2a176d", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/gabor/projects/quantify-scheduler/quantify_scheduler/backends/qblox/compiler_abc.py:768: RuntimeWarning: Number of instructions (16012) compiled for 'seq0' of QRMRFCompiler 'cluster_module1' exceeds the maximum supported number of instructions in Q1ASM programs for QRMRFCompiler (12288).\n", " warnings.warn(\n" ] }, { "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 -8.18e-05 -0.01011 ... -0.005303 -0.01309\n",
       "    y1       (dim_0) float64 8kB 0.002245 -0.0007542 ... 0.004126 0.002067\n",
       "Attributes:\n",
       "    tuid:                             20250620-151033-222-651948\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 -8.18e-05 -0.01011 ... -0.005303 -0.01309\n", " y1 (dim_0) float64 8kB 0.002245 -0.0007542 ... 0.004126 0.002067\n", "Attributes:\n", " tuid: 20250620-151033-222-651948\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": "d33e8b74", "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": "09801907", "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": "5ba40fae", "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": "3c1310b3", "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": "a8aca573", "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": "520ec334", "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": "144e86bc", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/gabor/projects/quantify-scheduler/quantify_scheduler/backends/qblox/compiler_abc.py:768: RuntimeWarning: Number of instructions (16012) compiled for 'seq0' of QRMRFCompiler 'cluster_module1' exceeds the maximum supported number of instructions in Q1ASM programs for QRMRFCompiler (12288).\n", " warnings.warn(\n" ] }, { "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": "52da109d", "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": "021ecc6e", "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": "e55d646d", "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": "214c0480", "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": "c8ea2272", "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": "ead907a6", "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": "99332ddf", "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": "4e5d8ab8", "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": "a3df9b02", "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.23" }, "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 }