{ "cells": [ { "cell_type": "markdown", "id": "8c32bd4c", "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": "451efe5c", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1412/40710294.py:4: DeprecationWarning: This package has reached its end of life. It is no longer maintained and will not receive any further updates or support. For further developments, please refer to the new Quantify repository: https://gitlab.com/quantify-os/quantify.All existing functionalities can be accessed via the new Quantify repository.\n", " from quantify_core.analysis import base_analysis as ba\n" ] } ], "source": [ "\"\"\"Disable transparent backgrounds for analysis figures to make them look nicer\n", "in both dark and bright mode on the website.\"\"\"\n", "\n", "from quantify_core.analysis import base_analysis as ba\n", "\n", "ba.settings[\"mpl_transparent_background\"] = False" ] }, { "cell_type": "code", "execution_count": 2, "id": "875b6c2c", "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": "13b7c8b1", "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": "621bf7b9", "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": "9b84b9db", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "24d0ee68", "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": "25a959d7", "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": "de556810", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "### Generate dummy data\n", "\n", "import numpy as np\n", "from qblox_instruments.ieee488_2.dummy_transport import DummyBinnedAcquisitionData\n", "from quantify_scheduler.qblox import start_dummy_cluster_armed_sequencers\n", "\n", "def get_dummy_binned_acquisition_data(\n", " real: float, imag: float, theta: float, threshold: float\n", "):\n", " angle = 2 * np.pi * theta / (360)\n", " threshold *= 1000 # different normalization (integration length) on qblox instruments\n", " if real * np.cos(angle) - imag * np.sin(angle) > threshold:\n", " thres = 1\n", " else:\n", " thres = 0\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=thres, avg_cnt=0)\n", "\n", "\n", "def setup_dummy_data(theta: float, threshold: float):\n", " # Means and standard deviations\n", " x0, xs0 = -2.7, 2.5\n", " y0, ys0 = 2.9, 2.5\n", " x1, xs1 = -14, 2.5\n", " y1, ys1 = 1.9, 2.5\n", "\n", " # Number of points per data cluster\n", " max_batch_size = 60\n", "\n", " # Generate random samples\n", " x0_samples = np.random.normal(x0, xs0, max_batch_size)\n", " y0_samples = np.random.normal(y0, ys0, max_batch_size)\n", " x1_samples = np.random.normal(x1, xs1, max_batch_size)\n", " y1_samples = np.random.normal(y1, ys1, max_batch_size)\n", "\n", " # interleave the random samples such that we get\n", " # x = [x0_samples[0], x1_samples[0], x0_samples[1],...]\n", " # y = [y0_samples[0], y1_samples[0], y0_samples[1],...]\n", "\n", " x = np.vstack((x0_samples, x1_samples)).reshape(-1, order=\"F\")\n", " y = np.vstack((y0_samples, y1_samples)).reshape(-1, order=\"F\")\n", " states = np.array([0, 1] * max_batch_size)\n", "\n", " # prepare cluster with dummy data that will be returned \n", " # after retrieving acquisitions.\n", " cluster.delete_dummy_binned_acquisition_data(1)\n", " cluster.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=\"0\",\n", " data=[\n", " get_dummy_binned_acquisition_data(float(re), float(im), theta, threshold)\n", " for re, im in zip(x, y)\n", " ],\n", " )\n", "\n", "def setup_dummy_and_start_sequencer(theta: float, threshold: float):\n", " setup_dummy_data(theta, threshold)\n", " start_dummy_cluster_armed_sequencers(ic_cluster)\n", "\n", "cluster.start_sequencer = lambda: setup_dummy_and_start_sequencer(0, 0)" ] }, { "cell_type": "code", "execution_count": 6, "id": "0ea9f63b", "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.0001411 -0.0146 ... 0.0008478 -0.01441\n",
       "    y1       (dim_0) float64 8kB -0.001942 0.001882 ... 0.001886 2.374e-06\n",
       "Attributes:\n",
       "    tuid:                             20260113-141356-594-7c99b0\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.0001411 -0.0146 ... 0.0008478 -0.01441\n", " y1 (dim_0) float64 8kB -0.001942 0.001882 ... 0.001886 2.374e-06\n", "Attributes:\n", " tuid: 20260113-141356-594-7c99b0\n", " name: Readout Calibration\n", " grid_2d: False\n", " grid_2d_uniformly_spaced: False\n", " 1d_2_settables_uniformly_spaced: False" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "from qcodes import ManualParameter\n", "\n", "from quantify_scheduler import Schedule, ScheduleGettable\n", "from quantify_scheduler.operations import Measure\n", "from quantify_scheduler.schedules import readout_calibration_sched\n", "\n", "\n", "single_qubit_device.cfg_sched_repetitions(1)\n", "\n", "states = ManualParameter(name=\"States\", unit=\"\", label=\"\")\n", "states.batched = True\n", "\n", "prepared_states = np.asarray([0, 1] * 500)\n", "readout_calibration_kwargs = {\"qubit\": \"q0\", \"prepared_states\": states}\n", "gettable = ScheduleGettable(\n", " single_qubit_device,\n", " schedule_function=readout_calibration_sched,\n", " schedule_kwargs=readout_calibration_kwargs,\n", " real_imag=True,\n", " batched=True,\n", " max_batch_size=60,\n", ")\n", "\n", "measurement_control.settables(states)\n", "measurement_control.setpoints(prepared_states)\n", "measurement_control.gettables(gettable)\n", "measurement_control.verbose(False)\n", "\n", "dataset = measurement_control.run(\"Readout Calibration\")\n", "dataset" ] }, { "cell_type": "markdown", "id": "af031419", "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": "af58f4cc", "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": "b8fbc105", "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": "612e424e", "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": "ce0b4d9a", "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": "f4778188", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "cluster.delete_dummy_binned_acquisition_data(1)\n", "\n", "cluster.start_sequencer = lambda: setup_dummy_and_start_sequencer(acq_rotation, acq_threshold)" ] }, { "cell_type": "code", "execution_count": 10, "id": "f73a5fea", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from sklearn.metrics import ConfusionMatrixDisplay\n", "import matplotlib.pyplot as plt\n", "\n", "single_qubit_device.cfg_sched_repetitions(1)\n", "\n", "states = ManualParameter(name=\"States\", unit=\"\", label=\"\")\n", "states.batched = True\n", "\n", "prepared_states = np.asarray([0, 1] * 500)\n", "readout_calibration_kwargs = {\n", " \"qubit\": \"q0\",\n", " \"prepared_states\": states,\n", " \"acq_protocol\": \"ThresholdedAcquisition\",\n", "}\n", "\n", "gettable = ScheduleGettable(\n", " single_qubit_device,\n", " schedule_function=readout_calibration_sched,\n", " schedule_kwargs=readout_calibration_kwargs,\n", " real_imag=True,\n", " batched=True,\n", " max_batch_size=60,\n", ")\n", "\n", "measurement_control.settables(states)\n", "measurement_control.setpoints(prepared_states)\n", "measurement_control.gettables(gettable)\n", "dataset = measurement_control.run(\"Readout Calibration Verification\")\n", "\n", "prepared_states = dataset.x0.values\n", "measured_states = dataset.y0.values\n", "\n", "ConfusionMatrixDisplay.from_predictions(\n", " prepared_states, measured_states, cmap=\"Blues\", normalize=None\n", ")\n", "plt.title(\"Confusion Matrix\")\n", "plt.xlabel(\"Measured State\")\n", "plt.ylabel(\"Prepared State\")\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "6a34fc6d", "metadata": {}, "source": [ "As expected, the threshold that we set did a good job of discriminating the qubit states (the discrimination is not perfect because the data points belonging to the two states slightly overlap).\n", "\n", "## Conditional Reset\n", "\n", "The conditional reset is implemented in Quantify as a gate. When we have a single {{ Reset }} at the beginning of a schedule, we simply replace the {{ Reset }} gate with the {{ ConditionalReset }} gate, for example\n", "\n", "```{code-block} python\n", "schedule = Schedule()\n", "#schedule.add(Reset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q0\"))\n", "...\n", "```\n", "\n", "In other cases, however, we need to pass extra arguments to {{ ConditionalReset }} that we illustrate below.\n", "\n", "### Example: Modifying the T1 schedule\n", "\n", "In this example, we use the schedule function {{ t1_sched }} using the {{ ConditionalReset }} instead of the standard {{ Reset }}. We need to ensure that all acquisition protocols in the schedule are equal to `\"ThresholdedAcquisition\"`." ] }, { "cell_type": "code", "execution_count": 11, "id": "829d3cd1", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.qblox.operations import ConditionalReset\n", "from quantify_scheduler.operations import X, Reset\n", "\n", "\n", "# original T1 schedule\n", "def t1_sched(\n", " times: np.ndarray,\n", " qubit: str,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", "\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(Reset(qubit), label=f\"Reset {i}\")\n", " schedule.add(X(qubit), label=f\"pi {i}\")\n", " schedule.add(\n", " Measure(qubit),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule\n", "\n", "\n", "# updated T1 schedule\n", "def t1_sched(\n", " times: np.ndarray,\n", " qubit: str,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", "\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(\n", " ConditionalReset(qubit, acq_channel=0),\n", " label=f\"Reset {i}\",\n", " )\n", " schedule.add(X(qubit), label=f\"pi {i}\")\n", " schedule.add(\n", " Measure(\n", " qubit,\n", " acq_protocol=\"ThresholdedAcquisition\",\n", " acq_channel=1,\n", " ),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule" ] }, { "cell_type": "markdown", "id": "b171e52e", "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": "50685c26", "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": "c0880e13", "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": "d1d065fa", "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": "b3903c82", "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": "99a1ebca", "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": "de0a004f", "metadata": {}, "source": [ "```{note}\n", "Often, we can use an `Analysis` class on datasets to visualize the data and extract relevant parameters such as {{ T1Analysis }}\n", "```\n", "\n", "### Note on Execution Order\n", "\n", "Parallel {{ ConditionalReset }} operations are not supported. For example, compiling the following schedule will raise a {{ RuntimeError }}:\n", "\n", "```{code-block} python\n", "schedule = Schedule(\"\")\n", "schedule.add(ConditionalReset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q1\"), ref_pt=\"start\")\n", "```\n", "\n", "and will have to be scheduled sequentially,\n", "\n", "```{code-block} python\n", "schedule = Schedule(\"\")\n", "schedule.add(ConditionalReset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q1\"))\n", "```\n", "\n", "\n", "## Closing Remarks\n", "\n", "You can find more technical information and explanations of the different limitations in our [reference guide](sec-qblox-conditional-playback)." ] } ], "metadata": { "file_format": "mystnb", "kernelspec": { "display_name": "python3", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.25" }, "myst": { "substitutions": { "BasicTransmonElement": "{class}`~quantify_scheduler.device_under_test.transmon_element.BasicTransmonElement`", "Cluster": "{class}`~qblox_instruments.Cluster`", "ConditionalReset": "{class}`~quantify_scheduler.backends.qblox.operations.gate_library.ConditionalReset`", "Measure": "{class}`~quantify_scheduler.operations.gate_library.Measure`", "MeasurementControl": "{class}`~quantify_core.measurement.control.MeasurementControl`", "QuantumDevice": "{class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice`", "ReadoutCalibrationAnalysis": "{class}`~quantify_core.analysis.readout_calibration_analysis.ReadoutCalibrationAnalysis`", "Reset": "{class}`~quantify_scheduler.operations.gate_library.Reset`", "RuntimeError": "{class}`~RuntimeError`", "Schedule": "{class}`~quantify_scheduler.schedules.schedule.Schedule`", "ScheduleGettable": "{class}`~quantify_scheduler.gettables.ScheduleGettable`", "T1Analysis": "{class}`~quantify_core.analysis.single_qubit_timedomain.T1Analysis`", "ThresholdedAcquisition": "{class}`~quantify_scheduler.operations.acquisition_library.ThresholdedAcquisition`", "readout_calibration_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.readout_calibration_sched`", "t1_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.t1_sched`" } }, "source_map": [ 23, 69, 82, 123, 130, 147, 151, 184, 194, 260, 292, 302, 310, 314, 323, 330, 339, 380, 401, 451, 464, 520, 546, 555, 561, 567 ] }, "nbformat": 4, "nbformat_minor": 5 }