{ "cells": [ { "cell_type": "markdown", "id": "c3ace432", "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": "3a553120", "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": "63032227", "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": "2c85bc22", "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": "eae2558f", "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": "463e069a", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "5d778ae3", "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": "2926833f", "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": "8d5bdfa1", "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": "e18cfb90", "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.0002088 -0.01961 ... -0.003877 -0.01401\n",
       "    y1       (dim_0) float64 8kB 0.00297 -0.003143 ... 0.003922 -0.0003731\n",
       "Attributes:\n",
       "    tuid:                             20260306-170043-224-14f23a\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.0002088 -0.01961 ... -0.003877 -0.01401\n", " y1 (dim_0) float64 8kB 0.00297 -0.003143 ... 0.003922 -0.0003731\n", "Attributes:\n", " tuid: 20260306-170043-224-14f23a\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": "fe4e6d99", "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": "380c3c11", "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": "2eef56e8", "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": "baf16125", "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": "aad0a963", "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": "e49faaf0", "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": "3ed661bd", "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": "eb1997df", "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": "e3504617", "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": "50032624", "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": "5424062d", "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": "c3ddd7a2", "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": "e1e97889", "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": "08d9816b", "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": "55d76dd5", "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": "92c4f184", "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 }