{ "cells": [ { "cell_type": "markdown", "id": "fead2e7a", "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": "e215196b", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1413/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": "8e26890e", "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": "9a905598", "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": "554bef4f", "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": "7d0bf5d7", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "6408f299", "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": "f9fba21c", "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": "aba7abca", "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": "1ab1aad9", "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.0003757 -0.01798 ... -0.005976 -0.01701\n",
       "    y1       (dim_0) float64 8kB 0.0003916 -0.003116 ... 0.001334 0.003264\n",
       "Attributes:\n",
       "    tuid:                             20251113-194449-394-82cf7f\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.0003757 -0.01798 ... -0.005976 -0.01701\n", " y1 (dim_0) float64 8kB 0.0003916 -0.003116 ... 0.001334 0.003264\n", "Attributes:\n", " tuid: 20251113-194449-394-82cf7f\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": "37980372", "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": "2dc0fa96", "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": "3b05648b", "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": "ca7aa062", "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": "52e5d0e7", "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": "0c8f6cd6", "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": "097f058d", "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": "237cc4c1", "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": "81109794", "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": "2eea39e1", "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": "da27a623", "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": "75ddedd6", "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": "c9284f83", "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": "89a66971", "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": "30e585b2", "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": "dabf7a46", "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 }