{ "cells": [ { "cell_type": "markdown", "id": "bd6d306e", "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": "edf59654", "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": "7b42401b", "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": "c9d655f0", "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": "c0820029", "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": "cffeb8fc", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "23c621e3", "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": "8fd6052e", "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": "6f0dd37b", "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": "966c4126", "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.00125 -0.01144 ... -0.004606 -0.01157\n",
       "    y1       (dim_0) float64 8kB 0.00463 0.002001 0.004715 ... 0.00631 0.003302\n",
       "Attributes:\n",
       "    tuid:                             20251105-000311-297-bf6880\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.00125 -0.01144 ... -0.004606 -0.01157\n", " y1 (dim_0) float64 8kB 0.00463 0.002001 0.004715 ... 0.00631 0.003302\n", "Attributes:\n", " tuid: 20251105-000311-297-bf6880\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": "53c330d6", "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": "5372239c", "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": "2271d431", "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": "4298cdf3", "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": "2ea5a2b2", "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": "5cc3546a", "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": "54bc9039", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfsAAAHHCAYAAAC4M/EEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAABAjUlEQVR4nO3deXgUVdbH8V93QhLISoAkLCEJLkCGfY+ooAIRkQHBUQQ1MCguQYEIOjrsiFFQVkF0RgER3LcBHRaBgGIERNkRWYJBIUFACAlkIan3D9702AYkTXdouuv74aln0rduVZ3qQU7OrVtVFsMwDAEAAK9ldXcAAACgYpHsAQDwciR7AAC8HMkeAAAvR7IHAMDLkewBAPByJHsAALwcyR4AAC9HsgcAwMuR7IE/2LNnj7p06aLQ0FBZLBZ98sknLt3/gQMHZLFYNG/ePJfu15N17NhRHTt2dHcYgNci2eOKtG/fPj300EOqV6+eAgICFBISovbt22v69Ok6c+ZMhR47KSlJ27Zt08SJE7VgwQK1atWqQo93OfXv318Wi0UhISHn/R737Nkji8Uii8WiF1980eH9Hzp0SGPHjtXmzZtdEC0AV/F1dwDAH3322Wf629/+Jn9/f91///1q1KiRCgsL9dVXX2nEiBHasWOHXnvttQo59pkzZ5Senq5//vOfGjx4cIUcIyYmRmfOnFGlSpUqZP8X4+vrq9OnT2vx4sW666677NYtXLhQAQEBys/Pv6R9Hzp0SOPGjVNsbKyaNWtW7u2WL19+SccDUD4ke1xRMjIy1KdPH8XExGjVqlWqWbOmbV1ycrL27t2rzz77rMKO/+uvv0qSwsLCKuwYFotFAQEBFbb/i/H391f79u319ttvl0n2ixYtUrdu3fThhx9ellhOnz6tKlWqyM/P77IcDzArhvFxRZk0aZJyc3P1+uuv2yX6UldffbWGDBli+3z27FlNmDBBV111lfz9/RUbG6tnnnlGBQUFdtvFxsbq9ttv11dffaU2bdooICBA9erV05tvvmnrM3bsWMXExEiSRowYIYvFotjYWEnnhr9Lf/69sWPHymKx2LWtWLFC119/vcLCwhQUFKT69evrmWeesa2/0DX7VatW6YYbblBgYKDCwsLUo0cP7dq167zH27t3r/r376+wsDCFhoZqwIABOn369IW/2D/o27ev/vvf/+rEiRO2to0bN2rPnj3q27dvmf7Hjx/X8OHD1bhxYwUFBSkkJERdu3bVli1bbH3S0tLUunVrSdKAAQNslwNKz7Njx45q1KiRNm3apBtvvFFVqlSxfS9/vGaflJSkgICAMuefmJioqlWr6tChQ+U+VwAke1xhFi9erHr16um6664rV/8HHnhAo0ePVosWLTR16lR16NBBqamp6tOnT5m+e/fu1Z133qnOnTvrpZdeUtWqVdW/f3/t2LFDktSrVy9NnTpVknTPPfdowYIFmjZtmkPx79ixQ7fffrsKCgo0fvx4vfTSS/rrX/+qdevW/el2X3zxhRITE3XkyBGNHTtWKSkp+vrrr9W+fXsdOHCgTP+77rpLp06dUmpqqu666y7NmzdP48aNK3ecvXr1ksVi0UcffWRrW7RokRo0aKAWLVqU6b9//3598sknuv322zVlyhSNGDFC27ZtU4cOHWyJt2HDhho/frwkadCgQVqwYIEWLFigG2+80bafY8eOqWvXrmrWrJmmTZumm2666bzxTZ8+XTVq1FBSUpKKi4slSa+++qqWL1+umTNnqlatWuU+VwCSDOAKcfLkSUOS0aNHj3L137x5syHJeOCBB+zahw8fbkgyVq1aZWuLiYkxJBlr1661tR05csTw9/c3nnjiCVtbRkaGIcmYPHmy3T6TkpKMmJiYMjGMGTPG+P1/RlOnTjUkGb/++usF4y49xty5c21tzZo1MyIiIoxjx47Z2rZs2WJYrVbj/vvvL3O8v//973b7vOOOO4xq1apd8Ji/P4/AwEDDMAzjzjvvNG655RbDMAyjuLjYiIqKMsaNG3fe7yA/P98oLi4ucx7+/v7G+PHjbW0bN24sc26lOnToYEgy5syZc951HTp0sGtbtmyZIcl49tlnjf379xtBQUFGz549L3qOAMqisscVIycnR5IUHBxcrv6ff/65JCklJcWu/YknnpCkMtf24+PjdcMNN9g+16hRQ/Xr19f+/fsvOeY/Kr3W/+mnn6qkpKRc2xw+fFibN29W//79FR4ebmtv0qSJOnfubDvP33v44YftPt9www06duyY7Tssj759+yotLU1ZWVlatWqVsrKyzjuEL527zm+1nvvnori4WMeOHbNdovjuu+/KfUx/f38NGDCgXH27dOmihx56SOPHj1evXr0UEBCgV199tdzHAvA/JHtcMUJCQiRJp06dKlf/n376SVarVVdffbVde1RUlMLCwvTTTz/ZtdetW7fMPqpWrarffvvtEiMu6+6771b79u31wAMPKDIyUn369NF77733p4m/NM769euXWdewYUMdPXpUeXl5du1/PJeqVatKkkPncttttyk4OFjvvvuuFi5cqNatW5f5LkuVlJRo6tSpuuaaa+Tv76/q1aurRo0a2rp1q06ePFnuY9auXduhyXgvvviiwsPDtXnzZs2YMUMRERHl3hbA/5DsccUICQlRrVq1tH37doe2++MEuQvx8fE5b7thGJd8jNLryaUqV66stWvX6osvvtB9992nrVu36u6771bnzp3L9HWGM+dSyt/fX7169dL8+fP18ccfX7Cql6TnnntOKSkpuvHGG/XWW29p2bJlWrFihf7yl7+UewRDOvf9OOL777/XkSNHJEnbtm1zaFsA/0OyxxXl9ttv1759+5Senn7RvjExMSopKdGePXvs2rOzs3XixAnbzHpXqFq1qt3M9VJ/HD2QJKvVqltuuUVTpkzRzp07NXHiRK1atUqrV68+775L49y9e3eZdT/88IOqV6+uwMBA507gAvr27avvv/9ep06dOu+kxlIffPCBbrrpJr3++uvq06ePunTpok6dOpX5Tsr7i1d55OXlacCAAYqPj9egQYM0adIkbdy40WX7B8yEZI8rypNPPqnAwEA98MADys7OLrN+3759mj59uqRzw9CSysyYnzJliiSpW7duLovrqquu0smTJ7V161Zb2+HDh/Xxxx/b9Tt+/HiZbUsfLvPH2wFL1axZU82aNdP8+fPtkuf27du1fPly23lWhJtuukkTJkzQyy+/rKioqAv28/HxKTNq8P777+uXX36xayv9peR8vxg56qmnnlJmZqbmz5+vKVOmKDY2VklJSRf8HgFcGA/VwRXlqquu0qJFi3T33XerYcOGdk/Q+/rrr/X++++rf//+kqSmTZsqKSlJr732mk6cOKEOHTpow4YNmj9/vnr27HnB27ouRZ8+ffTUU0/pjjvu0OOPP67Tp0/rlVde0bXXXms3QW38+PFau3atunXrppiYGB05ckSzZ89WnTp1dP31119w/5MnT1bXrl2VkJCggQMH6syZM5o5c6ZCQ0M1duxYl53HH1mtVo0cOfKi/W6//XaNHz9eAwYM0HXXXadt27Zp4cKFqlevnl2/q666SmFhYZozZ46Cg4MVGBiotm3bKi4uzqG4Vq1apdmzZ2vMmDG2WwHnzp2rjh07atSoUZo0aZJD+wNMz813AwDn9eOPPxoPPvigERsba/j5+RnBwcFG+/btjZkzZxr5+fm2fkVFRca4ceOMuLg4o1KlSkZ0dLTx9NNP2/UxjHO33nXr1q3Mcf54y9eFbr0zDMNYvny50ahRI8PPz8+oX7++8dZbb5W59W7lypVGjx49jFq1ahl+fn5GrVq1jHvuucf48ccfyxzjj7enffHFF0b79u2NypUrGyEhIUb37t2NnTt32vUpPd4fb+2bO3euIcnIyMi44HdqGPa33l3IhW69e+KJJ4yaNWsalStXNtq3b2+kp6ef95a5Tz/91IiPjzd8fX3tzrNDhw7GX/7yl/Me8/f7ycnJMWJiYowWLVoYRUVFdv2GDRtmWK1WIz09/U/PAYA9i2E4MKMHAAB4HK7ZAwDg5Uj2AAB4OZI9AABejmQPAICXI9kDAODlSPYAAHg5j36oTklJiQ4dOqTg4GCXPqYTAHB5GIahU6dOqVatWrY3K1aE/Px8FRYWOr0fPz8/BQQEuCCiy8ujk/2hQ4cUHR3t7jAAAE46ePCg6tSpUyH7zs/PV+XgatLZ007vKyoqShkZGR6X8D062Ze+99wvPkkWn/K/NhPwJJlpL7o7BKDCnMrJ0dVx0bZ/zytCYWGhdPa0/OOTJGdyRXGhsnbOV2FhIcn+ciodurf4+JHs4bVCQkLcHQJQ4S7LpVjfAKdyhWHx3GluHp3sAQAoN4skZ36p8OCpYSR7AIA5WKznFme291CeGzkAACgXKnsAgDlYLE4O43vuOD7JHgBgDgzjAwAAb0VlDwAwB4bxAQDwdk4O43vwYLjnRg4AAMqFyh4AYA4M4wMA4OWYjQ8AALwVlT0AwBwYxgcAwMuZeBifZA8AMAcTV/ae+2sKAAAoFyp7AIA5MIwPAICXs1icTPYM4wMAgCsUlT0AwByslnOLM9t7KJI9AMAcTHzN3nMjBwAA5UJlDwAwBxPfZ0+yBwCYA8P4AADAW1HZAwDMgWF8AAC8nImH8Un2AABzMHFl77m/pgAAgHKhsgcAmAPD+AAAeDmG8QEAgLeisgcAmISTw/geXB+T7AEA5sAwPgAA8FZU9gAAc7BYnJyN77mVPckeAGAOJr71znMjBwAA5UJlDwAwBxNP0CPZAwDMwcTD+CR7AIA5mLiy99xfUwAAQLlQ2QMAzIFhfAAAvBzD+AAAwFtR2QMATMFischi0sqeZA8AMAUzJ3uG8QEA8HJU9gAAc7D8/+LM9h6KZA8AMAWG8QEAgNeisgcAmIKZK3uSPQDAFEj2AAB4OTMne67ZAwDg5ajsAQDmwK13AAB4N4bxAQCA16KyBwCYwrk33DpT2bsulsuNZA8AMAWLnBzG9+BszzA+AABejsoeAGAKZp6gR7IHAJiDiW+9YxgfAAAvR2UPADAHJ4fxDYbxAQC4sjl7zd65mfzuxTA+AMAUSpO9M8ulev7552WxWDR06FBbW35+vpKTk1WtWjUFBQWpd+/eys7OttsuMzNT3bp1U5UqVRQREaERI0bo7NmzDh+fZA8AQAXauHGjXn31VTVp0sSufdiwYVq8eLHef/99rVmzRocOHVKvXr1s64uLi9WtWzcVFhbq66+/1vz58zVv3jyNHj3a4RhI9gAAc7C4YHFQbm6u+vXrp3/961+qWrWqrf3kyZN6/fXXNWXKFN18881q2bKl5s6dq6+//lrffPONJGn58uXauXOn3nrrLTVr1kxdu3bVhAkTNGvWLBUWFjoUB8keAGAKrhrGz8nJsVsKCgoueMzk5GR169ZNnTp1smvftGmTioqK7NobNGigunXrKj09XZKUnp6uxo0bKzIy0tYnMTFROTk52rFjh0PnTrIHAMAB0dHRCg0NtS2pqann7ffOO+/ou+++O+/6rKws+fn5KSwszK49MjJSWVlZtj6/T/Sl60vXOYLZ+AAAU3DVbPyDBw8qJCTE1u7v71+m78GDBzVkyBCtWLFCAQEBl3xMV6GyBwCYgquG8UNCQuyW8yX7TZs26ciRI2rRooV8fX3l6+urNWvWaMaMGfL19VVkZKQKCwt14sQJu+2ys7MVFRUlSYqKiiozO7/0c2mf8iLZAwDgYrfccou2bdumzZs325ZWrVqpX79+tp8rVaqklStX2rbZvXu3MjMzlZCQIElKSEjQtm3bdOTIEVufFStWKCQkRPHx8Q7FwzA+AMAULudDdYKDg9WoUSO7tsDAQFWrVs3WPnDgQKWkpCg8PFwhISF67LHHlJCQoHbt2kmSunTpovj4eN13332aNGmSsrKyNHLkSCUnJ593NOHPkOwBAOZwhb0IZ+rUqbJarerdu7cKCgqUmJio2bNn29b7+PhoyZIleuSRR5SQkKDAwEAlJSVp/PjxDh+LZA8AwGWQlpZm9zkgIECzZs3SrFmzLrhNTEyMPv/8c6ePTbIHAJiCmZ+NT7IHAJgCyR4AAC9n5mTPrXcAAHg5KnsAgDlcYbPxLyeSPQDAFBjGBwAAXovKHnaGJnXWmME99Mrbq/XMlA8lSbG1q2vCkDvUrlk9+VXy1cr0XXrqxff16/FTtu2uqhuh8Y/3VNum9VTJ10c79x7SxDlL9NWmPe46FaDcpsxdpiWrt2jPT9kK8K+kNk3qaezgHromNvLiG8NjUNm72axZsxQbG6uAgAC1bdtWGzZscHdIptQ8vq7639Fe23/82dZWJcBPH72cLEOGejwyU10fmCq/Sj56e8pDdn/x35nysHx9rOrxyAzddP8kbd/zi96Z+rAiqgW741QAh3z93V498LcbtfyN4fro5cEqOlusXo+9rLwzF35POTyPRU6+CMeDL9q7Pdm/++67SklJ0ZgxY/Tdd9+padOmSkxMtHvwPypeYGU/vTa+v4Y897ZOnDpja2/btJ7q1qym5HFvaee+Q9q575AeHbtAzRvW1Y2tr5UkhYcG6uqYCE2bv0I79h7S/oO/atzLnyqwsr8aXlXLXacElNsHM5PVt3s7NbyqphpfW0ezx9yrn7N+0+ZdB90dGuASbk/2U6ZM0YMPPqgBAwYoPj5ec+bMUZUqVfTGG2+4OzRTmfzk3Vq+brvWbNht1+7v5yvDMFRQeNbWll94ViUlhto1vUqSdPxknn48kKW7u7VRlQA/+fhY1b/X9TpyLEebd2Ve1vMAXCEnN1+SVDWkipsjgSu56hW3nsityb6wsFCbNm1Sp06dbG1Wq1WdOnVSenq6GyMzl16dW6ppg2iNn/WfMus2bjug0/mFGvtYD1X2r6QqAX6aMOQO+fr6KKp6iK3fHckvq8m10Tq45kVlfTVVj/a9WXc+PlsnfzdKAHiCkpISPT3lA7VtWk/xVzMy5VUsLlg8lFuT/dGjR1VcXKzISPtJMJGRkcrKyirTv6CgQDk5OXYLnFM7MkypT/TWoFHz7Kr3UsdO5Kr/P17XrTc00s9rX9JPqycrNLiyNu/KVEmJYes3+cm7dPS3U7rtwWm6pf9kfb5mi96e8pAiq4WU2SdwJRs+6T3t2ndYr08c4O5QAJfxqNn4qampGjdunLvD8CpNG9RVRLUQpS14ytbm6+uj65pfpQf/dqMi2w/V6vU/qMUd4xQeGqizxSXKyT2jH5Y+pwPLN0mSbmx9rRKvb6S4W57Uqbxzw5/DX3hPHds00D23t9W0+Svccm6Ao0ZMek/Lvtyuz18bqtqRVd0dDlzMzLPx3Zrsq1evLh8fH2VnZ9u1Z2dnKyoqqkz/p59+WikpKbbPOTk5io6OrvA4vdnajbt1XZ+Jdm0vj75Xew5ka/qbK+yq9+Mn8yRJN7S6VjWqBum/X26TdG7GvnRu+PP3SgxDVg/+jwPmYRiGnpz8vj5L26LFc4YopnZ1d4eECkCydxM/Pz+1bNlSK1euVM+ePSWdSxgrV67U4MGDy/T39/eXv7//ZY7Su+WeLtCufYft2k6fKdTxk3m29r7d2+nHjCwd/S1XbZrEKTXlTs1+e7X2/nTujokNWzN04tRpzR57vyb/+786U1CkpJ7XKaZWNS1ft+OynxPgqOEvvKcPln2rRS8OUlCVAGUfPXeJMCQoQJX//5dZeD6L5dzizPaeyu3D+CkpKUpKSlKrVq3Upk0bTZs2TXl5eRowgOtlV4prYiI0OvmvqhpSRZmHjuulucs0e9Eq2/rjJ/N05+OzNfKR7vp09uPy9bXqh/1Z6jf8NW3f84sbIwfK540Pv5Qk3f7wdLv2WaPvVd/u7dwREuBSFsMwjIt3q1gvv/yyJk+erKysLDVr1kwzZsxQ27ZtL7pdTk6OQkND5d/4QVl8+O0b3um3jS+7OwSgwuTk5CiyWqhOnjypkJCKmdBbmivqPfaBrP6Bl7yfkoI87Z95Z4XGWlHcXtlL0uDBg887bA8AgMs4OYzPrXcAAOCKdUVU9gAAVDRm4wMA4OXMPBufYXwAALwclT0AwBSsVous1ksvzw0ntnU3kj0AwBQYxgcAAF6Lyh4AYArMxgcAwMuZeRifZA8AMAUzV/ZcswcAwMtR2QMATMHMlT3JHgBgCma+Zs8wPgAAXo7KHgBgChY5OYzvwe+4JdkDAEyBYXwAAOC1qOwBAKbAbHwAALwcw/gAAMBrUdkDAEyBYXwAALycmYfxSfYAAFMwc2XPNXsAALwclT0AwBycHMb34AfokewBAObAMD4AAPBaVPYAAFNgNj4AAF6OYXwAAOC1qOwBAKbAMD4AAF6OYXwAAOC1qOwBAKZg5sqeZA8AMAWu2V+i/Px8BQQEuCoWAAAqjJkre4ev2ZeUlGjChAmqXbu2goKCtH//fknSqFGj9Prrr7s8QAAA4ByHk/2zzz6refPmadKkSfLz87O1N2rUSP/+979dGhwAAK5SOozvzOKpHE72b775pl577TX169dPPj4+tvamTZvqhx9+cGlwAAC4SukwvjOLp3I42f/yyy+6+uqry7SXlJSoqKjIJUEBAADXcTjZx8fH68svvyzT/sEHH6h58+YuCQoAAFezyMlhfHefgBMcno0/evRoJSUl6ZdfflFJSYk++ugj7d69W2+++aaWLFlSETECAOA0q8UiqxND8c5s624OV/Y9evTQ4sWL9cUXXygwMFCjR4/Wrl27tHjxYnXu3LkiYgQAAE64pPvsb7jhBq1YscLVsQAAUGHM/FAdhyv7evXq6dixY2XaT5w4oXr16rkkKAAAXO1yz8Z/5ZVX1KRJE4WEhCgkJEQJCQn673//a1ufn5+v5ORkVatWTUFBQerdu7eys7Pt9pGZmalu3bqpSpUqioiI0IgRI3T27FmHz93hZH/gwAEVFxeXaS8oKNAvv/zicAAAAFwOVovziyPq1Kmj559/Xps2bdK3336rm2++WT169NCOHTskScOGDdPixYv1/vvva82aNTp06JB69epl2764uFjdunVTYWGhvv76a82fP1/z5s3T6NGjHT73cg/j/+c//7H9vGzZMoWGhtoFtHLlSsXGxjocAAAA3qh79+52nydOnKhXXnlF33zzjerUqaPXX39dixYt0s033yxJmjt3rho2bKhvvvlG7dq10/Lly7Vz50598cUXioyMVLNmzTRhwgQ99dRTGjt2rN2D7S6m3Mm+Z8+eks4NgyQlJdmtq1SpkmJjY/XSSy+V+8AAAFxWFiefb+/EpsXFxXr//feVl5enhIQEbdq0SUVFRerUqZOtT4MGDVS3bl2lp6erXbt2Sk9PV+PGjRUZGWnrk5iYqEceeUQ7duxw6Hb3cif7kpISSVJcXJw2btyo6tWrl/sgAAC4m6sm6OXk5Ni1+/v7y9/f/7zbbNu2TQkJCcrPz1dQUJA+/vhjxcfHa/PmzfLz81NYWJhd/8jISGVlZUmSsrKy7BJ96frSdY5w+Jp9RkYGiR4AYFrR0dEKDQ21LampqRfsW79+fW3evFnr16/XI488oqSkJO3cufMyRnvOJd16l5eXpzVr1igzM1OFhYV26x5//HGXBAYAgCtZ/v+PM9tL0sGDBxUSEmJrv1BVL0l+fn62R8y3bNlSGzdu1PTp03X33XersLBQJ06csKvus7OzFRUVJUmKiorShg0b7PZXOlu/tE95OZzsv//+e9122206ffq08vLyFB4erqNHj9puCyDZAwCuRJcyo/6P20uy3Up3KUpKSlRQUKCWLVuqUqVKWrlypXr37i1J2r17tzIzM5WQkCBJSkhI0MSJE3XkyBFFRERIklasWKGQkBDFx8c7dFyHk/2wYcPUvXt3zZkzR6Ghofrmm29UqVIl3XvvvRoyZIijuwMAwCs9/fTT6tq1q+rWratTp05p0aJFSktLs93RNnDgQKWkpCg8PFwhISF67LHHlJCQoHbt2kmSunTpovj4eN13332aNGmSsrKyNHLkSCUnJ//paML5OJzsN2/erFdffVVWq1U+Pj4qKChQvXr1NGnSJCUlJdndIwgAwJXC2dfUOrrtkSNHdP/99+vw4cMKDQ1VkyZNtGzZMtuj5adOnSqr1arevXuroKBAiYmJmj17tm17Hx8fLVmyRI888ogSEhIUGBiopKQkjR8/3uHYHU72lSpVktV6bl5fRESEMjMz1bBhQ4WGhurgwYMOBwAAwOVwuR+X+/rrr//p+oCAAM2aNUuzZs26YJ+YmBh9/vnnjh34PBxO9s2bN9fGjRt1zTXXqEOHDho9erSOHj2qBQsWqFGjRk4HBAAAXMvhW++ee+451axZU9K5pwFVrVpVjzzyiH799Ve9+uqrLg8QAABXKH3FrTOLp3K4sm/VqpXt54iICC1dutSlAQEAUBF4650Dbr75Zp04caJMe05Oju35vgAAXGku91vvriQOJ/u0tLQyD9KRzr2q78svv3RJUAAAwHXKPYy/detW2887d+60ey5vcXGxli5dqtq1a7s2OgAAXMTMw/jlTvbNmjWzDWOcb7i+cuXKmjlzpkuDAwDAVZydZGeKCXoZGRkyDEP16tXThg0bVKNGDds6Pz8/RUREyMfHp0KCBAAAl67cyT4mJkbS/151CwCAJ7HIqVfSO7Wtu5V7gt6PP/5Y5u07K1eu1E033aQ2bdroueeec3lwAAC4CrPxy+Gpp57SkiVLbJ8zMjLUvXt3+fn5KSEhQampqZo2bVpFxAgAAJxQ7mH8b7/9Vk8++aTt88KFC3Xttddq2bJlkqQmTZpo5syZGjp0qMuDBADAWa56xa0nKndlf/ToUdWpU8f2efXq1erevbvtc8eOHXXgwAGXBgcAgKswjF8O4eHhOnz4sKRzk/S+/fZb2zt3JamwsFCGYbg+QgAA4JRyJ/uOHTtqwoQJOnjwoKZNm6aSkhJ17NjRtn7nzp2KjY2tgBABAHCN0gfrXMriycp9zX7ixInq3LmzYmJi5OPjoxkzZigwMNC2fsGCBTwbHwBwxXJ2KN6Th/HLnexjY2O1a9cu7dixQzVq1FCtWrXs1o8bN87umj4AAFcSM0/Qc+gVt76+vmratOl5112oHQAAuJfD77MHAMATMYwPAICX43G5AADAa1HZAwBMgVfcXsTWrVvLvcMmTZpccjAAAFQUZ++X9+BcX75k36xZM1ksFhmGcdEJCsXFxS4JDAAAuEa5rtlnZGRo//79ysjI0Icffqi4uDjNnj1b33//vb7//nvNnj1bV111lT788MOKjhcAgEti5mfjl6uyj4mJsf38t7/9TTNmzNBtt91ma2vSpImio6M1atQo9ezZ0+VBAgDgLDMP4zs8G3/btm2Ki4sr0x4XF6edO3e6JCgAAOA6Dif7hg0bKjU1VYWFhba2wsJCpaamqmHDhi4NDgAAVymdje/M4qkcvvVuzpw56t69u+rUqWObeb9161ZZLBYtXrzY5QECAOAKZh7GdzjZt2nTRvv379fChQv1ww8/SJLuvvtu9e3b1+4teAAAXEl4XK6DAgMDNWjQIFfHAgAAKsAlJfsFCxbo1Vdf1f79+5Wenq6YmBhNnTpV9erVU48ePVwd40VlrJqskJCQy35c4HKo2m6ou0MAKoxRXHDZjmWVc8+I9+Tnyzsc+yuvvKKUlBR17dpVv/32m+0hOlWrVtW0adNcHR8AAC5h5vvsHU72M2fO1L/+9S/985//lK/v/wYGWrVqpW3btrk0OAAA4DyHh/EzMjLUvHnzMu3+/v7Ky8tzSVAAALiaxSJZTTob3+HKPi4uTps3by7TvnTpUu6zBwBcsawW5xdP5XBln5KSouTkZOXn58swDG3YsEFvv/22UlNT9e9//7siYgQAAE5wONk/8MADqly5skaOHKnTp0+rb9++qlWrlqZPn64+ffpURIwAADiN++zL6ezZs1q0aJESExPVr18/nT59Wrm5uYqIiKio+AAAcAlnh+I9eRjfoWv2vr6+evjhh5Wfny9JqlKlCokeAIArnMMT9Nq0aaPvv/++ImIBAKDClD4b35nFUzl8zf7RRx/VE088oZ9//lktW7Ys8zz80pfjAABwJXH2zXWmeutd6SS8xx9/3NZmsVhkGIYsFovtiXoAAFxJzPy43Et6qA4AAPAcDif7mJiYiogDAIAKxfvsL8HOnTuVmZmpwsJCu/a//vWvTgcFAICrWeXkNXt5brZ3ONnv379fd9xxh7Zt22a7Vi/972EDXLMHAODK4vB8gyFDhiguLk5HjhxRlSpVtGPHDq1du1atWrVSWlpaBYQIAIDzuPXOAenp6Vq1apWqV68uq9Uqq9Wq66+/XqmpqXr88ce5Bx8AcEXiCXoOKC4uVnBwsCSpevXqOnTokKRzE/d2797t2ugAAIDTHK7sGzVqpC1btiguLk5t27bVpEmT5Ofnp9dee0316tWriBgBAHDauffZO/MiHBcGc5k5nOxHjhypvLw8SdL48eN1++2364YbblC1atX07rvvujxAAABcgVvvHJCYmGj7+eqrr9YPP/yg48ePq2rVqh79+j8AALzVJd9nL0kHDx6UJEVHR7skGAAAKgoT9Bxw9uxZjRo1SqGhoYqNjVVsbKxCQ0M1cuRIFRUVVUSMAAA4zeKCP57K4cr+scce00cffaRJkyYpISFB0rnb8caOHatjx47plVdecXmQAAA4y8yVvcPJftGiRXrnnXfUtWtXW1uTJk0UHR2te+65h2QPAMAVxuFk7+/vr9jY2DLtcXFx8vPzc0VMAAC4nJkre4ev2Q8ePFgTJkxQQUGBra2goEATJ07U4MGDXRocAACuYrFYnF48lcOV/ffff6+VK1eqTp06atq0qSRpy5YtKiws1C233KJevXrZ+n700UeuixQAAFwSh5N9WFiYevfubdfGrXcAgCudmYfxHU72c+fOrYg4AACoUGZ+gp7D1+ylc/faf/HFF3r11Vd16tQpSdKhQ4eUm5vr0uAAAIDzHK7sf/rpJ916663KzMxUQUGBOnfurODgYL3wwgsqKCjQnDlzKiJOAACcYrVYnHoRjjPbupvDlf2QIUPUqlUr/fbbb6pcubKt/Y477tDKlStdGhwAAK5Ses3emcURqampat26tYKDgxUREaGePXuWeRV8fn6+kpOTVa1aNQUFBal3797Kzs6265OZmalu3bqpSpUqioiI0IgRI3T27FnHzt2x0KUvv/xSI0eOLHNPfWxsrH755RdHdwcAgFdas2aNkpOT9c0332jFihUqKipSly5dbG+OlaRhw4Zp8eLFev/997VmzRodOnTI7q624uJidevWTYWFhfr66681f/58zZs3T6NHj3YoFoeH8UtKSlRcXFym/eeff1ZwcLCjuwMA4PJwcoKeo4/GX7p0qd3nefPmKSIiQps2bdKNN96okydP6vXXX9eiRYt08803Szo3Cb5hw4b65ptv1K5dOy1fvlw7d+7UF198ocjISDVr1kwTJkzQU089pbFjx5b7YXYOV/ZdunTRtGnTbJ8tFotyc3M1ZswY3XbbbY7uDgCAy8Iqi9OLJOXk5Ngtv3/I3J85efKkJCk8PFyStGnTJhUVFalTp062Pg0aNFDdunWVnp4u6dy7Zxo3bqzIyEhbn8TEROXk5GjHjh0OnLuDXnzxRa1bt07x8fHKz89X3759bUP4L7zwgqO7AwDgsii99c6ZRTr3bJnQ0FDbkpqaetFjl5SUaOjQoWrfvr0aNWokScrKypKfn5/CwsLs+kZGRiorK8vW5/eJvnR96brycngYPzo6Wlu2bNG7776rLVu2KDc3VwMHDlS/fv3sJuwBAOCNDh48qJCQENtnf3//i26TnJys7du366uvvqrI0C7IoWRfVFSkBg0aaMmSJerXr5/69etXUXEBAOBSrnqCXkhIiF2yv5jBgwdryZIlWrt2rerUqWNrj4qKUmFhoU6cOGFX3WdnZysqKsrWZ8OGDXb7K52tX9qnXLGXu6ekSpUqKT8/35FNAAC4IpTeZ+/M4gjDMDR48GB9/PHHWrVqleLi4uzWt2zZUpUqVbK7bX337t3KzMxUQkKCJCkhIUHbtm3TkSNHbH1WrFihkJAQxcfHl//cHYpc54YiXnjhBYfv8QMAwEySk5P11ltvadGiRQoODlZWVpaysrJ05swZSVJoaKgGDhyolJQUrV69Wps2bdKAAQOUkJCgdu3aSTo3KT4+Pl733XeftmzZomXLlmnkyJFKTk4u1+WDUg5fs9+4caNWrlyp5cuXq3HjxgoMDLRbz5vuAABXosv9bPxXXnlFktSxY0e79rlz56p///6SpKlTp8pqtap3794qKChQYmKiZs+ebevr4+OjJUuW6JFHHlFCQoICAwOVlJSk8ePHOxSLS956BwDAlc4qJx+X6+CN9oZhXLRPQECAZs2apVmzZl2wT0xMjD7//HOHjv1HvPUOAAAvV+5r9iUlJXrhhRfUvn17tW7dWv/4xz9s1x0AALjSueo+e09U7mQ/ceJEPfPMMwoKClLt2rU1ffp0JScnV2RsAAC4jNUFi6cqd+xvvvmmZs+erWXLlumTTz7R4sWLtXDhQpWUlFRkfAAAwEnlTvaZmZl2z77v1KmTLBaLDh06VCGBAQDgShaLxenFU5V7gt7Zs2cVEBBg11apUiUVFRW5PCgAAFzNIodfXFdme09V7mRvGIb69+9vdxN/fn6+Hn74Ybt77bnPHgBwJbqUp+D9cXtPVe5kn5SUVKbt3nvvdWkwAADA9cqd7Lm/HgDg6Ty3NneOww/VAQDAE13ux+VeSTz5tkEAAFAOVPYAAFNw9vY5U9x6BwCAJ3P2KXiePBTuybEDAIByoLIHAJgCw/gAAHg5Mz9Bj2F8AAC8HJU9AMAUGMYHAMDLmXk2PskeAGAKZq7sPfkXFQAAUA5U9gAAUzDzbHySPQDAFHgRDgAA8FpU9gAAU7DKIqsTg/HObOtuJHsAgCkwjA8AALwWlT0AwBQs///Hme09FckeAGAKDOMDAACvRWUPADAFi5Oz8RnGBwDgCmfmYXySPQDAFMyc7LlmDwCAl6OyBwCYArfeAQDg5ayWc4sz23sqhvEBAPByVPYAAFNgGB8AAC/HbHwAAOC1qOwBAKZgkXND8R5c2JPsAQDmwGx8AADgtajsUS6n8vL1/Kuf6bM1W3T0t1w1vraOJqb0Vov4GHeHBjhk6H23aExyd73yzho9M+1jSVJs7Wqa8FgPtWtaT35+vlqZvktPTflQvx7PtW33RP/O6nJdvBpdW1tFRcWK7fy0u04Bl8jMs/HdWtmvXbtW3bt3V61atWSxWPTJJ5+4Mxz8iaHPLVLahh80e+z9WrvwaXVs20C9B7+sw0dOuDs0oNyaN4xW/zuu0/Y9v9jaqgT46aPpj8iQoR6DZ6nroOnyq+Srtyc/KMvvpl9X8vXRJ6s2642P1rkjdLhA6Wx8ZxZP5dZkn5eXp6ZNm2rWrFnuDAMXcSa/UEtWb9GYwT10XfOrVS+6hp568DbF1amhuR995e7wgHIJrOyn18bdpyGp7+rEqTO29rZN4lS3ZriSxy/Szn2HtXPfYT06fqGaN4zWja2usfV7/t9L9co7a7Rz32F3hA8XsLhg8VRuTfZdu3bVs88+qzvuuMOdYeAizhaXqLi4RAH+lezaK/tX0jdb9rkpKsAxk4ffqeXrdmrNxh/t2v39fGUYhgqKztra8guLVFJiqF3Tepc7TKBCeNQEvYKCAuXk5NgtqHjBgQFq3ThOL76xVId/Pani4hK999+N2rg9Q9lH+f8AV75enZqraf06Gv/KkjLrNm4/oNP5hRqb/FdV9q+kKgF+mvB4D/n6+iiqWogbokVFscoiq8WJxYNre49K9qmpqQoNDbUt0dHR7g7JNGaPvU+GITW+faRq3TBM/3ovTb26tJTVk+9FgSnUjghTakovDRq7QAWFZ8usP3YiT/2fmadbr/+Lfl79gn76IlWhQZW1+YeDKjEMN0SMimLmYXyPmo3/9NNPKyUlxfY5JyeHhH+ZxNWpocVzhijvTIFO5eUrqnqoBv7zDcXUqubu0IA/1bRBtCLCg5U2b7itzdfXR9c1q6cH77xekTcO1+oNu9XizmcVHhqos8Ulysk9ox8+G68Dvxx1Y+SA63hUsvf395e/v7+7wzC1wMr+CqzsrxM5p7X6mx80ZnAPd4cE/Km13/6o6/o+b9f28si+2vNTtqYvWKmSkv9V78dP5kmSbmh5jWpUDdJ/v9xxWWNFBXO2PPfg0t6jkj3cZ9U3u2QYhq6OiVDGwaMaO/MTXRMTqb7d27k7NOBP5Z4u0K79WXZtp/MLdfzkaVt7325t9OOBbB09kas2jWOVOqyXZr+zRnszj9i2qRMZprCQQNWJrCqr1aJG19SWJGX8/KvyzhRevhPCJTPzffZuTfa5ubnau3ev7XNGRoY2b96s8PBw1a1b142R4Y9ycs/o2dmLdejICYWFVFH3m5rqn490VyVfH3eHBjjtmpgIjX70dlUNqaLMw8f10rwVmv12ml2fpwfdpr7d2tg+f7lghCTp9kdf1rrv9gq4klkMw30zUNLS0nTTTTeVaU9KStK8efMuun1OTo5CQ0N16NcTCglh1iy8U/Xrhrk7BKDCGMUFKtg8RydPnqywf8dLc8XKzZkKCr70Y+SeytEtzepWaKwVxa2VfceOHeXG3zUAACZi4kv2nnXrHQAAcBwT9AAA5mDi0p5kDwAwBWbjAwDg5Zx9cx1vvQMAAFcsKnsAgCmY+JI9yR4AYBImzvYM4wMA4OVI9gAAU7C44I8j1q5dq+7du6tWrVqyWCz65JNP7NYbhqHRo0erZs2aqly5sjp16qQ9e/bY9Tl+/Lj69eunkJAQhYWFaeDAgcrNzXX43En2AABTKJ2N78ziiLy8PDVt2lSzZs067/pJkyZpxowZmjNnjtavX6/AwEAlJiYqPz/f1qdfv37asWOHVqxYoSVLlmjt2rUaNGiQw+fONXsAACpA165d1bVr1/OuMwxD06ZN08iRI9Wjx7lXhb/55puKjIzUJ598oj59+mjXrl1aunSpNm7cqFatWkmSZs6cqdtuu00vvviiatWqVe5YqOwBAKZgccHiKhkZGcrKylKnTp1sbaGhoWrbtq3S09MlSenp6QoLC7Mleknq1KmTrFar1q9f79DxqOwBAObgotn4OTk5ds3+/v7y9/d3aFdZWVmSpMjISLv2yMhI27qsrCxFRETYrff19VV4eLitT3lR2QMA4IDo6GiFhobaltTUVHeHdFFU9gAAU3DVs/EPHjxo9z57R6t6SYqKipIkZWdnq2bNmrb27OxsNWvWzNbnyJEjdtudPXtWx48ft21fXlT2AABTcNVs/JCQELvlUpJ9XFycoqKitHLlSltbTk6O1q9fr4SEBElSQkKCTpw4oU2bNtn6rFq1SiUlJWrbtq1Dx6OyBwCYwuV+gF5ubq727t1r+5yRkaHNmzcrPDxcdevW1dChQ/Xss8/qmmuuUVxcnEaNGqVatWqpZ8+ekqSGDRvq1ltv1YMPPqg5c+aoqKhIgwcPVp8+fRyaiS+R7AEAqBDffvutbrrpJtvnlJQUSVJSUpLmzZunJ598Unl5eRo0aJBOnDih66+/XkuXLlVAQIBtm4ULF2rw4MG65ZZbZLVa1bt3b82YMcPhWCyGYRjOn5J75OTkKDQ0VId+PWF3/QTwJtWvG+buEIAKYxQXqGDzHJ08ebLC/h0vzRXpu35RUPClHyP3VI4SGtau0FgrCpU9AMAUXDVBzxMxQQ8AAC9HZQ8AMIVLeb79H7f3VCR7AIApmPh19gzjAwDg7ajsAQDmYOLSnmQPADAFZuMDAACvRWUPADAFZuMDAODlTHzJnmQPADAJE2d7rtkDAODlqOwBAKZg5tn4JHsAgDk4OUHPg3M9w/gAAHg7KnsAgCmYeH4eyR4AYBImzvYM4wMA4OWo7AEApsBsfAAAvJyZH5fLMD4AAF6Oyh4AYAomnp9HsgcAmISJsz3JHgBgCmaeoMc1ewAAvByVPQDAFCxycja+yyK5/Ej2AABTMPEle4bxAQDwdlT2AABTMPNDdUj2AACTMO9APsP4AAB4OSp7AIApMIwPAICXM+8gPsP4AAB4PSp7AIApMIwPAICXM/Oz8Un2AABzMPFFe67ZAwDg5ajsAQCmYOLCnmQPADAHM0/QYxgfAAAvR2UPADAFZuMDAODtTHzRnmF8AAC8HJU9AMAUTFzYk+wBAObAbHwAAOC1qOwBACbh3Gx8Tx7IJ9kDAEyBYXwAAOC1SPYAAHg5hvEBAKZg5mF8kj0AwBTM/LhchvEBAPByVPYAAFNgGB8AAC9n5sflMowPAICXo7IHAJiDiUt7kj0AwBSYjQ8AALwWlT0AwBSYjQ8AgJcz8SV7kj0AwCRMnO25Zg8AgJejsgcAmIKZZ+OT7AEApsAEPQ9lGIYk6dSpHDdHAlQco7jA3SEAFcYoLjz3v///73lFyslxLlc4u707eXSyP3XqlCSpfr26bo4EAOCMU6dOKTQ0tEL27efnp6ioKF0TF+30vqKiouTn5+eCqC4vi3E5fp2qICUlJTp06JCCg4Nl8eTxFQ+Sk5Oj6OhoHTx4UCEhIe4OB3Ap/n5ffoZh6NSpU6pVq5as1oqbM56fn6/CwkKn9+Pn56eAgAAXRHR5eXRlb7VaVadOHXeHYUohISH8Ywivxd/vy6uiKvrfCwgI8Mgk7SrcegcAgJcj2QMA4OVI9nCIv7+/xowZI39/f3eHArgcf7/hrTx6gh4AALg4KnsAALwcyR4AAC9HsgcAwMuR7AEA8HIke5TbrFmzFBsbq4CAALVt21YbNmxwd0iAS6xdu1bdu3dXrVq1ZLFY9Mknn7g7JMClSPYol3fffVcpKSkaM2aMvvvuOzVt2lSJiYk6cuSIu0MDnJaXl6emTZtq1qxZ7g4FqBDceodyadu2rVq3bq2XX35Z0rn3EkRHR+uxxx7TP/7xDzdHB7iOxWLRxx9/rJ49e7o7FMBlqOxxUYWFhdq0aZM6depka7NarerUqZPS09PdGBkAoDxI9rioo0ePqri4WJGRkXbtkZGRysrKclNUAIDyItkDAODlSPa4qOrVq8vHx0fZ2dl27dnZ2YqKinJTVACA8iLZ46L8/PzUsmVLrVy50tZWUlKilStXKiEhwY2RAQDKw9fdAcAzpKSkKCkpSa1atVKbNm00bdo05eXlacCAAe4ODXBabm6u9u7da/uckZGhzZs3Kzw8XHXr1nVjZIBrcOsdyu3ll1/W5MmTlZWVpWbNmmnGjBlq27atu8MCnJaWlqabbrqpTHtSUpLmzZt3+QMCXIxkDwCAl+OaPQAAXo5kDwCAlyPZAwDg5Uj2AAB4OZI9AABejmQPAICXI9kDAODlSPaAl+jYsaOGDh3q7jAAXIFI9vAa/fv3l8Vi0cMPP1xmXXJysiwWi/r373/5A7tCFBcX6/nnn1eDBg1UuXJlhYeHq23btvr3v/9t63OpvzD0799fPXv2dF2wAFyKZA+vEh0drXfeeUdnzpyxteXn52vRokUe8YzzwsLCCtv3uHHjNHXqVE2YMEE7d+7U6tWrNWjQIJ04caLCjgngykCyh1dp0aKFoqOj9dFHH9naPvroI9WtW1fNmze361tSUqLU1FTFxcWpcuXKatq0qT744APb+uLiYg0cONC2vn79+po+fbrdPtLS0tSmTRsFBgYqLCxM7du3108//STp/NXu0KFD1bFjR9vnjh07avDgwRo6dKiqV6+uxMRESdL27dvVtWtXBQUFKTIyUvfdd5+OHj1q2y4vL0/333+/goKCVLNmTb300ksX/W7+85//6NFHH9Xf/vY3xcXFqWnTpho4cKCGDx9ui3fNmjWaPn26LBaLLBaLDhw4cNHvYezYsZo/f74+/fRT23ZpaWmSpIMHD+quu+5SWFiYwsPD1aNHDx04cOCisQJwLZI9vM7f//53zZ071/b5jTfeOO/b+VJTU/Xmm29qzpw52rFjh4YNG6Z7771Xa9askXTul4E6dero/fff186dOzV69Gg988wzeu+99yRJZ8+eVc+ePdWhQwdt3bpV6enpGjRokCwWi0Pxzp8/X35+flq3bp3mzJmjEydO6Oabb1bz5s317bffaunSpcrOztZdd91l22bEiBFas2aNPv30Uy1fvlxpaWn67rvv/vQ4UVFRWrVqlX799dfzrp8+fboSEhL04IMP6vDhwzp8+LCio6Mv+j0MHz5cd911l2699Vbbdtddd52KioqUmJio4OBgffnll1q3bp2CgoJ06623VugIBoDzMAAvkZSUZPTo0cM4cuSI4e/vbxw4cMA4cOCAERAQYPz6669Gjx49jKSkJMMwDCM/P9+oUqWK8fXXX9vtY+DAgcY999xzwWMkJycbvXv3NgzDMI4dO2ZIMtLS0v40nt8bMmSI0aFDB9vnDh06GM2bN7frM2HCBKNLly52bQcPHjQkGbt37zZOnTpl+Pn5Ge+9955t/bFjx4zKlSsbQ4YMuWDsO3bsMBo2bGhYrVajcePGxkMPPWR8/vnndn06dOjwp/so9fvv4ULnumDBAqN+/fpGSUmJra2goMCoXLmysWzZsoseA4Dr8D57eJ0aNWqoW7dumjdvngzDULdu3VS9enW7Pnv37tXp06fVuXNnu/bCwkK74f5Zs2bpjTfeUGZmps6cOaPCwkI1a9ZMkhQeHq7+/fsrMTFRnTt3VqdOnXTXXXepZs2aDsXbsmVLu89btmzR6tWrFRQUVKbvvn37bHH8/vXC4eHhql+//p8eJz4+Xtu3b9emTZu0bt06rV27Vt27d1f//v3tJumdz599DxeyZcsW7d27V8HBwXbt+fn52rdv359uC8C1SPbwSn//+981ePBgSecS1R/l5uZKkj777DPVrl3bbp2/v78k6Z133tHw4cP10ksvKSEhQcHBwZo8ebLWr19v6zt37lw9/vjjWrp0qd59912NHDlSK1asULt27WS1WmX84Q3SRUVFZWIJDAwsE1v37t31wgsvlOlbs2ZN7d27tzxfwXlZrVa1bt1arVu31tChQ/XWW2/pvvvu0z//+U/FxcWdd5vyfA/nk5ubq5YtW2rhwoVl1tWoUeOSzwGA40j28Eql14UtFott0tvvxcfHy9/fX5mZmerQocN597Fu3Tpdd911evTRR21t56tImzdvrubNm+vpp59WQkKCFi1apHbt2qlGjRravn27Xd/NmzerUqVKfxp7ixYt9OGHHyo2Nla+vmX/E73qqqtUqVIlrV+/3naHwW+//aYff/zxgudyIfHx8ZLOTfiTJD8/PxUXF9v1Kc/3cL7tWrRooXfffVcREREKCQlxKC4ArsUEPXglHx8f7dq1Szt37pSPj0+Z9cHBwRo+fLiGDRum+fPna9++ffruu+80c+ZMzZ8/X5J0zTXX6Ntvv9WyZcv0448/atSoUdq4caNtHxkZGXr66aeVnp6un376ScuXL9eePXvUsGFDSdLNN9+sb7/9Vm+++ab27NmjMWPGlEn+55OcnKzjx4/rnnvu0caNG7Vv3z4tW7ZMAwYMUHFxsYKCgjRw4ECNGDFCq1at0vbt29W/f39ZrX/+n/Odd96pqVOnav369frpp5+Ulpam5ORkXXvttWrQoIEkKTY2VuvXr9eBAwd09OhRlZSUXPR7KN1u69at2r17t44ePaqioiL169dP1atXV48ePfTll18qIyNDaWlpevzxx/Xzzz9f9HsA4Doke3itkJCQP60oJ0yYoFGjRik1NVUNGzbUrbfeqs8++8w2nP3QQw+pV69euvvuu9W2bVsdO3bMrrqtUqWKfvjhB/Xu3VvXXnutBg0apOTkZD300EOSpMTERI0aNUpPPvmkWrdurVOnTun++++/aNy1atXSunXrVFxcrC5duqhx48YaOnSowsLCbAl98uTJuuGGG9S9e3d16tRJ119/fZlr/3+UmJioxYsXq3v37rr22muVlJSkBg0aaPny5bYRhOHDh8vHx0fx8fGqUaOGMjMzL/o9SNKDDz6o+vXrq1WrVqpRo4bWrVunKlWqaO3atapbt6569eqlhg0bauDAgcrPz6fSBy4zi/HHi4oAAMCrUNkDAODlSPYAAHg5kj0AAF6OZA8AgJcj2QMA4OVI9gAAeDmSPQAAXo5kDwCAlyPZAwDg5Uj2AAB4OZI9AABejmQPAICX+z/xInd4r5VbKwAAAABJRU5ErkJggg==", "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": "f6fba6b0", "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": "7387f47e", "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": "c2d13f65", "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": "f682db36", "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": "73fa47ef", "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": "6d0e95be", "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": "d020a758", "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": "fb9d3b8f", "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": "a1205975", "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 }