{ "cells": [ { "cell_type": "markdown", "id": "5d1671a2", "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": "f631bfc5", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "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": "f7dd4da0", "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": "ac2fa380", "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": "3cfc4fee", "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": "746cb0c0", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "419c9b29", "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": "cb501748", "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": "09ebdb9c", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "### Generate dummy data\n", "\n", "import numpy as np\n", "from qblox_instruments.ieee488_2.dummy_transport import DummyBinnedAcquisitionData\n", "from quantify_scheduler.qblox import start_dummy_cluster_armed_sequencers\n", "\n", "def get_dummy_binned_acquisition_data(\n", " real: float, imag: float, theta: float, threshold: float\n", "):\n", " angle = 2 * np.pi * theta / (360)\n", " threshold *= 1000 # different normalization (integration length) on qblox instruments\n", " if real * np.cos(angle) + imag * np.sin(angle) > -threshold:\n", " thres = 0\n", " else:\n", " thres = 1\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=thres, avg_cnt=0)\n", "\n", "\n", "# Means and standard deviations\n", "x0, xs0 = -2.7, 2.5\n", "y0, ys0 = 2.9, 2.5\n", "x1, xs1 = -14, 2.5\n", "y1, ys1 = 1.9, 2.5\n", "\n", "# Number of points per data cluster\n", "n_points = 500\n", "\n", "# Generate random samples\n", "x0_samples = np.random.normal(x0, xs0, n_points)\n", "y0_samples = np.random.normal(y0, ys0, n_points)\n", "x1_samples = np.random.normal(x1, xs1, n_points)\n", "y1_samples = np.random.normal(y1, ys1, n_points)\n", "\n", "# interleave the random samples such that we get\n", "# x = [x0_samples[0], x1_samples[0], x0_samples[1],...]\n", "# y = [y0_samples[0], y1_samples[0], y0_samples[1],...]\n", "\n", "x = np.vstack((x0_samples, x1_samples)).reshape(-1, order=\"F\")\n", "y = np.vstack((y0_samples, y1_samples)).reshape(-1, order=\"F\")\n", "states = np.array([0, 1] * 500)\n", "\n", "# prepare cluster with dummy data that will be returned \n", "# after retrieving acquisitions.\n", "cluster.delete_dummy_binned_acquisition_data(1)\n", "cluster.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=\"0\",\n", " data=[\n", " get_dummy_binned_acquisition_data(float(re), float(im), 0, 0)\n", " for re, im in zip(x, y)\n", " ],\n", ")\n", "\n", "cluster.start_sequencer = lambda: start_dummy_cluster_armed_sequencers(ic_cluster)" ] }, { "cell_type": "code", "execution_count": 6, "id": "68d40b86", "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.01126 ... -0.002185 -0.01607\n",
       "    y1       (dim_0) float64 8kB 0.003523 0.001669 ... 0.002645 0.001739\n",
       "Attributes:\n",
       "    tuid:                             20250320-203442-178-4599cb\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.01126 ... -0.002185 -0.01607\n", " y1 (dim_0) float64 8kB 0.003523 0.001669 ... 0.002645 0.001739\n", "Attributes:\n", " tuid: 20250320-203442-178-4599cb\n", " name: Readout Calibration\n", " grid_2d: False\n", " grid_2d_uniformly_spaced: False\n", " 1d_2_settables_uniformly_spaced: False" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "from qcodes import ManualParameter\n", "\n", "from quantify_scheduler import Schedule, ScheduleGettable\n", "from quantify_scheduler.operations import Measure\n", "from quantify_scheduler.schedules import readout_calibration_sched\n", "\n", "\n", "single_qubit_device.cfg_sched_repetitions(1)\n", "\n", "states = ManualParameter(name=\"States\", unit=\"\", label=\"\")\n", "states.batched = True\n", "\n", "prepared_states = np.asarray([0, 1] * 500)\n", "readout_calibration_kwargs = {\"qubit\": \"q0\", \"prepared_states\": prepared_states}\n", "gettable = ScheduleGettable(\n", " single_qubit_device,\n", " schedule_function=readout_calibration_sched,\n", " schedule_kwargs=readout_calibration_kwargs,\n", " real_imag=True,\n", " batched=True,\n", " max_batch_size=200,\n", ")\n", "\n", "measurement_control.settables(states)\n", "measurement_control.setpoints(prepared_states)\n", "measurement_control.gettables(gettable)\n", "measurement_control.verbose(False)\n", "\n", "dataset = measurement_control.run(\"Readout Calibration\")\n", "dataset" ] }, { "cell_type": "markdown", "id": "a8f80114", "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": "edbd4bd8", "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": "06218e8c", "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": "5c11b6a3", "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": "009f1a04", "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": "c4df340c", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "cluster.delete_dummy_binned_acquisition_data(1)\n", "cluster.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=\"0\",\n", " data=[\n", " get_dummy_binned_acquisition_data(\n", " float(re), float(im), acq_rotation, acq_threshold\n", " )\n", " for re, im in zip(x, y)\n", " ],\n", ")\n", "\n", "cluster.start_sequencer = lambda: start_dummy_cluster_armed_sequencers(ic_cluster)" ] }, { "cell_type": "code", "execution_count": 10, "id": "61c2d28a", "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\": prepared_states,\n", " \"acq_protocol\": \"ThresholdedAcquisition\",\n", "}\n", "\n", "gettable = ScheduleGettable(\n", " single_qubit_device,\n", " schedule_function=readout_calibration_sched,\n", " schedule_kwargs=readout_calibration_kwargs,\n", " real_imag=True,\n", " batched=True,\n", " max_batch_size=200,\n", ")\n", "\n", "measurement_control.settables(states)\n", "measurement_control.setpoints(prepared_states)\n", "measurement_control.gettables(gettable)\n", "dataset = measurement_control.run(\"Readout Calibration Verification\")\n", "\n", "prepared_states = dataset.x0.values\n", "measured_states = dataset.y0.values\n", "\n", "ConfusionMatrixDisplay.from_predictions(\n", " prepared_states, measured_states, cmap=\"Blues\", normalize=None\n", ")\n", "plt.title(\"Confusion Matrix\")\n", "plt.xlabel(\"Measured State\")\n", "plt.ylabel(\"Prepared State\")\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "bfdb3509", "metadata": {}, "source": [ "As expected, the threshold that we set did a good job of discriminating the qubit states (the discrimination is not perfect because the data points belonging to the two states slightly overlap).\n", "\n", "## Conditional Reset\n", "\n", "The conditional reset is implemented in Quantify as a gate. When we have a single {{ Reset }} at the beginning of a schedule, we simply replace the {{ Reset }} gate with the {{ ConditionalReset }} gate, for example\n", "\n", "```{code-block} python\n", "schedule = Schedule()\n", "#schedule.add(Reset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q0\"))\n", "...\n", "```\n", "\n", "In other cases, however, we need to pass extra arguments to {{ ConditionalReset }} that we illustrate below.\n", "\n", "### Example: Modifying the T1 schedule\n", "\n", "In this example, we use the schedule function {{ t1_sched }} using the {{ ConditionalReset }} instead of the standard {{ Reset }}. When using multiple consecutive {{ ConditionalReset }} on the same qubit, we need to increment the `acq_index` for each one, similar to when adding multiple {{ Measure }} to the schedule. We also need to ensure that all acquisition protocols in the schedule are equal to `\"ThresholdedAcquisition\"`." ] }, { "cell_type": "code", "execution_count": 11, "id": "d7b3a90a", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.qblox.operations import ConditionalReset\n", "from quantify_scheduler.operations import X, Reset\n", "\n", "\n", "# original T1 schedule\n", "def t1_sched(\n", " times: np.ndarray,\n", " qubit: str,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", "\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(Reset(qubit), label=f\"Reset {i}\")\n", " schedule.add(X(qubit), label=f\"pi {i}\")\n", " schedule.add(\n", " Measure(qubit, acq_index=i),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule\n", "\n", "\n", "# updated T1 schedule\n", "def t1_sched(\n", " times: np.ndarray,\n", " qubit: str,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", "\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(\n", " ConditionalReset(qubit, acq_index=i, acq_channel=0),\n", " label=f\"Reset {i}\",\n", " )\n", " schedule.add(X(qubit), label=f\"pi {i}\")\n", " schedule.add(\n", " Measure(\n", " qubit,\n", " acq_index=i,\n", " acq_protocol=\"ThresholdedAcquisition\",\n", " acq_channel=1,\n", " ),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule" ] }, { "cell_type": "markdown", "id": "0d761eb5", "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": "ac093bd0", "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": "8d133c55", "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": "70f2c21c", "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": "9b46fb7d", "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": "2c216c1b", "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": "b6fe8c46", "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.21" }, "myst": { "substitutions": { "BasicTransmonElement": "{class}`~quantify_scheduler.device_under_test.transmon_element.BasicTransmonElement`", "Cluster": "{class}`~qblox_instruments.Cluster`", "ConditionalReset": "{class}`~quantify_scheduler.backends.qblox.operations.gate_library.ConditionalReset`", "Measure": "{class}`~quantify_scheduler.operations.gate_library.Measure`", "MeasurementControl": "{class}`~quantify_core.measurement.control.MeasurementControl`", "QuantumDevice": "{class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice`", "ReadoutCalibrationAnalysis": "{class}`~quantify_core.analysis.readout_calibration_analysis.ReadoutCalibrationAnalysis`", "Reset": "{class}`~quantify_scheduler.operations.gate_library.Reset`", "RuntimeError": "{class}`~RuntimeError`", "Schedule": "{class}`~quantify_scheduler.schedules.schedule.Schedule`", "ScheduleGettable": "{class}`~quantify_scheduler.gettables.ScheduleGettable`", "T1Analysis": "{class}`~quantify_core.analysis.single_qubit_timedomain.T1Analysis`", "ThresholdedAcquisition": "{class}`~quantify_scheduler.operations.acquisition_library.ThresholdedAcquisition`", "readout_calibration_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.readout_calibration_sched`", "t1_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.t1_sched`" } }, "source_map": [ 23, 69, 82, 123, 130, 147, 151, 184, 194, 255, 287, 297, 305, 309, 318, 325, 345, 386, 407, 458, 471, 527, 553, 562, 568, 574 ] }, "nbformat": 4, "nbformat_minor": 5 }