{ "cells": [ { "cell_type": "markdown", "id": "a4355b55", "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": "866bf83a", "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": "2ee92a6d", "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": "8d4b9b54", "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": "ef60ee80", "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": "871a74ce", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "742287be", "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": "88bce753", "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": "018c16ce", "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": "dd42addf", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/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 0.004417 -0.01709 ... -0.00174 -0.01619\n",
       "    y1       (dim_0) float64 8kB 0.003471 0.004526 ... 0.005961 0.002266\n",
       "Attributes:\n",
       "    tuid:                             20250702-042955-300-466108\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.004417 -0.01709 ... -0.00174 -0.01619\n", " y1 (dim_0) float64 8kB 0.003471 0.004526 ... 0.005961 0.002266\n", "Attributes:\n", " tuid: 20250702-042955-300-466108\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": "4c3f84b4", "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": "57451f63", "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": "a7b1d8ac", "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": "60b48626", "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": "7f1f4a1a", "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": "8d0ca413", "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": "1529d31c", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/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": "30e540d2", "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": "fccf0d89", "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": "3b30fe8f", "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": "54f08585", "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": "fc5a8e87", "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": "e92cdc12", "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": "f32d85bc", "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": "184d2ec1", "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": "9ccd0802", "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 }