{ "cells": [ { "cell_type": "markdown", "id": "85918592", "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": "f7703383", "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": "8edfcdc0", "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": "5341a3f6", "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": "f1d2414b", "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": "141f3008", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "8f8a7358", "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": "fa56f057", "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": "97491e19", "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": "5e2452b2", "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.003369 -0.01633 ... -0.0001657 -0.01604\n",
       "    y1       (dim_0) float64 8kB 0.001083 0.004569 ... 0.004165 0.005258\n",
       "Attributes:\n",
       "    tuid:                             20260319-141756-378-4e7c56\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.003369 -0.01633 ... -0.0001657 -0.01604\n", " y1 (dim_0) float64 8kB 0.001083 0.004569 ... 0.004165 0.005258\n", "Attributes:\n", " tuid: 20260319-141756-378-4e7c56\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": "c71bd7a9", "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": "0c5882f3", "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": "d238dbd2", "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": "4d377506", "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": "05aecaba", "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": "46fd2bc9", "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": "f5780e71", "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": "c626d052", "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": "31c9b74e", "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": "e8943239", "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": "d1f87600", "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": "a3b8dd66", "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": "80caafc6", "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": "4e8b2515", "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": "aeafffa7", "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": "5bd69328", "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 }