{ "cells": [ { "cell_type": "markdown", "id": "1efb8d39", "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": "a5b213b8", "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": "5449921b", "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": "559e94bf", "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": "de2662eb", "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": "f7501446", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "4d8bc4e9", "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": "ddbe4d28", "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": "50607b93", "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": "81c56154", "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.00202 -0.0144 ... -0.005183 -0.01683\n",
       "    y1       (dim_0) float64 8kB 0.002453 0.003552 ... 0.009429 0.006577\n",
       "Attributes:\n",
       "    tuid:                             20250117-153804-226-282b20\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.00202 -0.0144 ... -0.005183 -0.01683\n", " y1 (dim_0) float64 8kB 0.002453 0.003552 ... 0.009429 0.006577\n", "Attributes:\n", " tuid: 20250117-153804-226-282b20\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": "3f4a563a", "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": "033c919e", "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": "db7cd08a", "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": "cb5b1f31", "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": "b5e48cbc", "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": "e2638992", "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": "ea4446f1", "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": "0e2ffea4", "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": "d174b1bf", "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": "9702ca5c", "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": "bd5ae37f", "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": "ed7b4a25", "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": "2a3f511a", "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": "17dd7c0c", "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": "4f19e1fc", "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": "c995f2c1", "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 }