{ "cells": [ { "cell_type": "markdown", "id": "baaf7e12", "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": "017e7248", "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": "d379fc7a", "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.device_under_test.quantum_device import QuantumDevice\n", "from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement\n", "from quantify_scheduler.instrument_coordinator import InstrumentCoordinator\n", "from quantify_scheduler.instrument_coordinator.components.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": "55c6c0cc", "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": "0d769a54", "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": "004b9247", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "4c65259c", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "hardware_cfg = {\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}.module2.complex_output_0\", \"q0:mw\"),\n", " ]\n", " },\n", "}\n", "\n", "single_qubit_device.hardware_config(hardware_cfg)" ] }, { "cell_type": "markdown", "id": "0813d270", "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": "7ef0008d", "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.helpers.qblox_dummy_instrument import (\n", " start_dummy_cluster_armed_sequencers,\n", ")\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": "1ce2e1df", "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.007409 -0.01521 ... -0.003537 -0.01211\n",
       "    y1       (dim_0) float64 8kB 0.008123 0.002685 ... -0.0005204 0.001487\n",
       "Attributes:\n",
       "    tuid:                             20240916-171154-098-1c83e3\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.007409 -0.01521 ... -0.003537 -0.01211\n", " y1 (dim_0) float64 8kB 0.008123 0.002685 ... -0.0005204 0.001487\n", "Attributes:\n", " tuid: 20240916-171154-098-1c83e3\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.gettables import ScheduleGettable\n", "from quantify_scheduler.operations.gate_library import Measure\n", "from quantify_scheduler.schedules.schedule import Schedule\n", "from quantify_scheduler.schedules.timedomain_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": "36ba6813", "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": "81dfa2e3", "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": "976b6d4d", "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": "7abd5f22", "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": "8d336092", "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": "63deedb8", "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": "1b3336c4", "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": "fdc557fd", "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": "eec2abc5", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.backends.qblox.operations.gate_library import ConditionalReset\n", "from quantify_scheduler.operations.gate_library 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": "3719909b", "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": "a3f83162", "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": "d91c99a7", "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": "726504dd", "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": "d008e2a0", "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": "aa992a7b", "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": "50b0270b", "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, 125, 132, 149, 153, 184, 194, 257, 290, 300, 308, 312, 321, 328, 348, 389, 410, 461, 474, 530, 556, 565, 571, 577 ] }, "nbformat": 4, "nbformat_minor": 5 }