{ "cells": [ { "cell_type": "markdown", "id": "5ec5e031", "metadata": {}, "source": [ "(sec-tutorial-conditional-reset)=\n", "\n", "\n", "```{seealso}\n", "The complete source code of this tutorial can be found in\n", "\n", "{nb-download}`Conditional Reset.ipynb`\n", "\n", "```\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": "991390dd", "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": "5241fa54", "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": "e28aa08e", "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": "39bf689b", "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": "b25a15ce", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "a2ee22b4", "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": "e5211fc9", "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": "df3b5de7", "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": "7886038a", "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.003791 -0.0109 ... -0.001932 -0.01187\n",
       "    y1       (dim_0) float64 8kB 0.002038 0.00205 ... 0.001152 -0.001182\n",
       "Attributes:\n",
       "    tuid:                             20241120-183349-373-42e7cc\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.003791 -0.0109 ... -0.001932 -0.01187\n", " y1 (dim_0) float64 8kB 0.002038 0.00205 ... 0.001152 -0.001182\n", "Attributes:\n", " tuid: 20241120-183349-373-42e7cc\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": "1011d39e", "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": "15b75302", "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": "59b67d8c", "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": "529a34e7", "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": "3f26894b", "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": "315dee31", "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": "13dfcaaf", "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": "c010462f", "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": "d7f876d2", "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": "8be80b2b", "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": "8c944018", "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": "363f8bbf", "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": "dead169a", "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": "5f3305f0", "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": "8384f565", "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": "62dbd735", "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.20" }, "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 }