{ "cells": [ { "cell_type": "markdown", "id": "e5a260ac", "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": "9711e031", "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": "495e6351", "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": "c04f7e3b", "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": "ecaf598c", "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": "fb22f13c", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "998b2f17", "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": "443bde32", "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": "3bb42825", "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": "903fb0f9", "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.0007881 -0.01229 ... -0.005863 -0.01218\n",
       "    y1       (dim_0) float64 8kB 0.003489 -0.0001137 ... 0.003838 0.0008266\n",
       "Attributes:\n",
       "    tuid:                             20241121-223917-960-975ef1\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.0007881 -0.01229 ... -0.005863 -0.01218\n", " y1 (dim_0) float64 8kB 0.003489 -0.0001137 ... 0.003838 0.0008266\n", "Attributes:\n", " tuid: 20241121-223917-960-975ef1\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": "06996951", "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": "e10d5f0d", "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": "2a064351", "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": "bac35c61", "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": "6aec9911", "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": "f8e38742", "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": "046cd78b", "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": "4560d777", "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": "ea38c37f", "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": "76f7c6f3", "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": "042173af", "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": "4f9e1a5e", "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": "79da4eb3", "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": "6ec65eb9", "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": "05da8049", "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": "162af1ae", "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 }