{ "cells": [ { "cell_type": "markdown", "id": "e4421f35", "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": "06a84940", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1884/40710294.py:4: DeprecationWarning: This package has reached its end of life. It is no longer maintained and will not receive any further updates or support. For further developments, please refer to the new Quantify repository: https://gitlab.com/quantify-os/quantify.All existing functionalities can be accessed via the new Quantify repository.\n", " from quantify_core.analysis import base_analysis as ba\n" ] } ], "source": [ "\"\"\"Disable transparent backgrounds for analysis figures to make them look nicer\n", "in both dark and bright mode on the website.\"\"\"\n", "\n", "from quantify_core.analysis import base_analysis as ba\n", "\n", "ba.settings[\"mpl_transparent_background\"] = False" ] }, { "cell_type": "code", "execution_count": 2, "id": "48a1e174", "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": "85bdea53", "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": "490ee4a8", "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": "58a6c0a5", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "6487a59f", "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": "b3324d08", "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": "b4215363", "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": "c72e291d", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/compiler_abc.py:769: 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.001125 -0.01486 ... -0.004201 -0.01266\n",
       "    y1       (dim_0) float64 8kB 0.00172 -0.0002391 ... 0.001575 0.001427\n",
       "Attributes:\n",
       "    tuid:                             20260303-103944-256-600709\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.001125 -0.01486 ... -0.004201 -0.01266\n", " y1 (dim_0) float64 8kB 0.00172 -0.0002391 ... 0.001575 0.001427\n", "Attributes:\n", " tuid: 20260303-103944-256-600709\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": "10c1c534", "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": "106dd82d", "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": "cbf04150", "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": "d7cfd208", "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": "17c201bb", "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": "799b9266", "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": "bf9b4e9e", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/compiler_abc.py:769: 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": "210e6aba", "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": "e3f27f21", "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": "a78088f7", "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": "9998f95c", "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": "480f148e", "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": "b30c0e7a", "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": "9e5a7698", "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": "476798ff", "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": "e144de03", "metadata": {}, "source": [ "```{note}\n", "Often, we can use an `Analysis` class on datasets to visualize the data and extract relevant parameters such as {{ T1Analysis }}\n", "```\n", "\n", "### Note on Execution Order\n", "\n", "Parallel {{ ConditionalReset }} operations are not supported. For example, compiling the following schedule will raise a {{ RuntimeError }}:\n", "\n", "```{code-block} python\n", "schedule = Schedule(\"\")\n", "schedule.add(ConditionalReset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q1\"), ref_pt=\"start\")\n", "```\n", "\n", "and will have to be scheduled sequentially,\n", "\n", "```{code-block} python\n", "schedule = Schedule(\"\")\n", "schedule.add(ConditionalReset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q1\"))\n", "```\n", "\n", "\n", "## Closing Remarks\n", "\n", "You can find more technical information and explanations of the different limitations in our [reference guide](sec-qblox-conditional-playback)." ] } ], "metadata": { "file_format": "mystnb", "kernelspec": { "display_name": "python3", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.25" }, "myst": { "substitutions": { "BasicTransmonElement": "{class}`~quantify_scheduler.device_under_test.transmon_element.BasicTransmonElement`", "Cluster": "{class}`~qblox_instruments.Cluster`", "ConditionalReset": "{class}`~quantify_scheduler.backends.qblox.operations.gate_library.ConditionalReset`", "Measure": "{class}`~quantify_scheduler.operations.gate_library.Measure`", "MeasurementControl": "{class}`~quantify_core.measurement.control.MeasurementControl`", "QuantumDevice": "{class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice`", "ReadoutCalibrationAnalysis": "{class}`~quantify_core.analysis.readout_calibration_analysis.ReadoutCalibrationAnalysis`", "Reset": "{class}`~quantify_scheduler.operations.gate_library.Reset`", "RuntimeError": "{class}`~RuntimeError`", "Schedule": "{class}`~quantify_scheduler.schedules.schedule.Schedule`", "ScheduleGettable": "{class}`~quantify_scheduler.gettables.ScheduleGettable`", "T1Analysis": "{class}`~quantify_core.analysis.single_qubit_timedomain.T1Analysis`", "ThresholdedAcquisition": "{class}`~quantify_scheduler.operations.acquisition_library.ThresholdedAcquisition`", "readout_calibration_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.readout_calibration_sched`", "t1_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.t1_sched`" } }, "source_map": [ 23, 69, 82, 123, 130, 147, 151, 184, 194, 255, 287, 297, 305, 309, 318, 325, 345, 386, 407, 458, 471, 527, 553, 562, 568, 574 ] }, "nbformat": 4, "nbformat_minor": 5 }