{ "cells": [ { "cell_type": "markdown", "id": "b0c7a637", "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": "24d57db8", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1885/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": "6b8de02e", "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": "f8dbaacb", "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": "6bfe6dc7", "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": "dd826b0b", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "f2e60613", "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": "fd2d2438", "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": "292f5c45", "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 = 1\n", " else:\n", " thres = 0\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=thres, avg_cnt=0)\n", "\n", "\n", "def setup_dummy_data(theta: float, threshold: float):\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", " max_batch_size = 60\n", "\n", " # Generate random samples\n", " x0_samples = np.random.normal(x0, xs0, max_batch_size)\n", " y0_samples = np.random.normal(y0, ys0, max_batch_size)\n", " x1_samples = np.random.normal(x1, xs1, max_batch_size)\n", " y1_samples = np.random.normal(y1, ys1, max_batch_size)\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] * max_batch_size)\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), theta, threshold)\n", " for re, im in zip(x, y)\n", " ],\n", " )\n", "\n", "def setup_dummy_and_start_sequencer(theta: float, threshold: float):\n", " setup_dummy_data(theta, threshold)\n", " start_dummy_cluster_armed_sequencers(ic_cluster)\n", "\n", "cluster.start_sequencer = lambda: setup_dummy_and_start_sequencer(0, 0)" ] }, { "cell_type": "code", "execution_count": 6, "id": "083143f7", "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.007908 -0.01142 ... -0.001321 -0.01237\n",
       "    y1       (dim_0) float64 8kB 0.006804 0.002644 ... 0.00598 0.0008445\n",
       "Attributes:\n",
       "    tuid:                             20260209-152254-275-8c3265\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.007908 -0.01142 ... -0.001321 -0.01237\n", " y1 (dim_0) float64 8kB 0.006804 0.002644 ... 0.00598 0.0008445\n", "Attributes:\n", " tuid: 20260209-152254-275-8c3265\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\": 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=60,\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": "c6a9eda8", "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": "88991579", "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": "ce855b8c", "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": "0b81a667", "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": "5cb12df9", "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": "eac192ad", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "cluster.delete_dummy_binned_acquisition_data(1)\n", "\n", "cluster.start_sequencer = lambda: setup_dummy_and_start_sequencer(acq_rotation, acq_threshold)" ] }, { "cell_type": "code", "execution_count": 10, "id": "bddf42ab", "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\": 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=60,\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": "756649e9", "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 }}. We need to ensure that all acquisition protocols in the schedule are equal to `\"ThresholdedAcquisition\"`." ] }, { "cell_type": "code", "execution_count": 11, "id": "c25e7a78", "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),\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_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_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": "c2a6cbe3", "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": "1ac70239", "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": "3f6c42aa", "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": "3a8f364e", "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": "1ff74574", "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": "e819f981", "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": "dc7afa3e", "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, 260, 292, 302, 310, 314, 323, 330, 339, 380, 401, 451, 464, 520, 546, 555, 561, 567 ] }, "nbformat": 4, "nbformat_minor": 5 }