{ "cells": [ { "cell_type": "markdown", "id": "a9cc1e84", "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": "68f59e24", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1435/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": "8f228e3c", "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": "23c50301", "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": "de9e20a9", "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": "96a7cdc1", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "d8028fcc", "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": "d99a7340", "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": "f05c8ed0", "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": "4bcab0c6", "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.004757 -0.01097 ... -0.003883 -0.01432\n",
       "    y1       (dim_0) float64 8kB 0.003342 0.003918 ... 0.005053 -0.0001562\n",
       "Attributes:\n",
       "    tuid:                             20260619-152332-209-c13060\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.004757 -0.01097 ... -0.003883 -0.01432\n", " y1 (dim_0) float64 8kB 0.003342 0.003918 ... 0.005053 -0.0001562\n", "Attributes:\n", " tuid: 20260619-152332-209-c13060\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": "1f59471c", "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": "ae3bac6f", "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": "3af37578", "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": "dc025828", "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": "195ece44", "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": "5e419983", "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": "aecff69d", "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": "df1e3f21", "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": "ccfee1e5", "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": "57a6d80e", "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": "0a3d2d37", "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": "7019072d", "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": "3c69a343", "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": "a8c7f5bd", "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": "70f3fd99", "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": "ad6b8f76", "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 }