{ "cells": [ { "cell_type": "markdown", "id": "f883f39a", "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": "7ba0cd50", "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": "103c2db6", "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": "474f34df", "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": "5dc1272d", "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": "a1fdbc7d", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "b3371ee5", "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": "0fbbef47", "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": "fc0fcb96", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "### Generate dummy data\n", "\n", "import numpy as np\n", "from qblox_instruments.ieee488_2.dummy_transport import DummyBinnedAcquisitionData\n", "from quantify_scheduler.qblox import start_dummy_cluster_armed_sequencers\n", "\n", "def get_dummy_binned_acquisition_data(\n", " real: float, imag: float, theta: float, threshold: float\n", "):\n", " angle = 2 * np.pi * theta / (360)\n", " threshold *= 1000 # different normalization (integration length) on qblox instruments\n", " if real * np.cos(angle) + imag * np.sin(angle) > -threshold:\n", " thres = 0\n", " else:\n", " thres = 1\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=thres, avg_cnt=0)\n", "\n", "\n", "# Means and standard deviations\n", "x0, xs0 = -2.7, 2.5\n", "y0, ys0 = 2.9, 2.5\n", "x1, xs1 = -14, 2.5\n", "y1, ys1 = 1.9, 2.5\n", "\n", "# Number of points per data cluster\n", "n_points = 500\n", "\n", "# Generate random samples\n", "x0_samples = np.random.normal(x0, xs0, n_points)\n", "y0_samples = np.random.normal(y0, ys0, n_points)\n", "x1_samples = np.random.normal(x1, xs1, n_points)\n", "y1_samples = np.random.normal(y1, ys1, n_points)\n", "\n", "# interleave the random samples such that we get\n", "# x = [x0_samples[0], x1_samples[0], x0_samples[1],...]\n", "# y = [y0_samples[0], y1_samples[0], y0_samples[1],...]\n", "\n", "x = np.vstack((x0_samples, x1_samples)).reshape(-1, order=\"F\")\n", "y = np.vstack((y0_samples, y1_samples)).reshape(-1, order=\"F\")\n", "states = np.array([0, 1] * 500)\n", "\n", "# prepare cluster with dummy data that will be returned \n", "# after retrieving acquisitions.\n", "cluster.delete_dummy_binned_acquisition_data(1)\n", "cluster.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=\"0\",\n", " data=[\n", " get_dummy_binned_acquisition_data(float(re), float(im), 0, 0)\n", " for re, im in zip(x, y)\n", " ],\n", ")\n", "\n", "cluster.start_sequencer = lambda: start_dummy_cluster_armed_sequencers(ic_cluster)" ] }, { "cell_type": "code", "execution_count": 6, "id": "02944263", "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.0004954 -0.01482 ... -0.005738 -0.01077\n",
       "    y1       (dim_0) float64 8kB 0.002955 0.002654 ... 0.003249 0.005616\n",
       "Attributes:\n",
       "    tuid:                             20250408-154526-772-5cab8e\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.0004954 -0.01482 ... -0.005738 -0.01077\n", " y1 (dim_0) float64 8kB 0.002955 0.002654 ... 0.003249 0.005616\n", "Attributes:\n", " tuid: 20250408-154526-772-5cab8e\n", " name: Readout Calibration\n", " grid_2d: False\n", " grid_2d_uniformly_spaced: False\n", " 1d_2_settables_uniformly_spaced: False" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "from qcodes import ManualParameter\n", "\n", "from quantify_scheduler import Schedule, ScheduleGettable\n", "from quantify_scheduler.operations import Measure\n", "from quantify_scheduler.schedules import readout_calibration_sched\n", "\n", "\n", "single_qubit_device.cfg_sched_repetitions(1)\n", "\n", "states = ManualParameter(name=\"States\", unit=\"\", label=\"\")\n", "states.batched = True\n", "\n", "prepared_states = np.asarray([0, 1] * 500)\n", "readout_calibration_kwargs = {\"qubit\": \"q0\", \"prepared_states\": prepared_states}\n", "gettable = ScheduleGettable(\n", " single_qubit_device,\n", " schedule_function=readout_calibration_sched,\n", " schedule_kwargs=readout_calibration_kwargs,\n", " real_imag=True,\n", " batched=True,\n", " max_batch_size=200,\n", ")\n", "\n", "measurement_control.settables(states)\n", "measurement_control.setpoints(prepared_states)\n", "measurement_control.gettables(gettable)\n", "measurement_control.verbose(False)\n", "\n", "dataset = measurement_control.run(\"Readout Calibration\")\n", "dataset" ] }, { "cell_type": "markdown", "id": "b1ac42e9", "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": "5cd85e37", "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": "f3bf340e", "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": "6157e5fd", "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": "bdd11697", "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": "fd483dac", "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": "ae4621eb", "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": "c0ef65e1", "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": "3f2cd9d6", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.qblox.operations import ConditionalReset\n", "from quantify_scheduler.operations import X, Reset\n", "\n", "\n", "# original T1 schedule\n", "def t1_sched(\n", " times: np.ndarray,\n", " qubit: str,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", "\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(Reset(qubit), label=f\"Reset {i}\")\n", " schedule.add(X(qubit), label=f\"pi {i}\")\n", " schedule.add(\n", " Measure(qubit, acq_index=i),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule\n", "\n", "\n", "# updated T1 schedule\n", "def t1_sched(\n", " times: np.ndarray,\n", " qubit: str,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", "\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(\n", " ConditionalReset(qubit, acq_index=i, acq_channel=0),\n", " label=f\"Reset {i}\",\n", " )\n", " schedule.add(X(qubit), label=f\"pi {i}\")\n", " schedule.add(\n", " Measure(\n", " qubit,\n", " acq_index=i,\n", " acq_protocol=\"ThresholdedAcquisition\",\n", " acq_channel=1,\n", " ),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule" ] }, { "cell_type": "markdown", "id": "823821d9", "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": "d9d6f103", "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": "9d87016d", "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": "0a1b2eec", "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": "9e9ccbb4", "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": "354b4a66", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAABZk0lEQVR4nO3dB3RUxdsG8Ce9QBIIaSSB0GuooXcERcCCBRFQEMSOqNjAAoIFFfEDFUFR1L8NFBUVERSkifReQg2QkB4gnfR8552waxKSuBt2c7c8v3PW7N4tmWwk99mZd2YciouLi0FERERkIxy1bgARERGRKTHcEBERkU1huCEiIiKbwnBDRERENoXhhoiIiGwKww0RERHZFIYbIiIisikMN0RERGRTGG6IiIjIpjDcENmBs2fPwsHBAZ9//jksWaNGjXDfffdp3Qyr88orr6jfLxGVYLghMoCcOAy5bNy4UT1+0aJFGDlyJBo2bKiOG3PCltco/ZpOTk4ICAjAnXfeicjISFi7f/75R52MU1NTYSkk9FX1e92+fbvWTbQJb7zxBlauXKl1M8gOOGvdACJr8OWXX5a5/b///Q9//vnnVcdbt26tvr711lvIyMhAt27dEB8fX63vOWXKFHTt2hX5+fk4ePAgFi9erILP4cOHERQUBGsON7NmzVKBr06dOmXuO378OBwdtfvMNXv2bDRu3Piq482aNYMle+mllzBt2jRYQ7iRkD5ixAitm0I2juGGyAD33HNPmdvySV7CTfnjOps2bdL32tSuXbta37Nv377qRKDTsmVLPPLIIypYPffcc7BFbm5umn7/oUOHokuXLrAWWVlZqFWrFpydndWFiEpwWIrIDMLCwkxeAyFhR5w+fbrM8djYWEycOBGBgYEqHLRt2xZLly79z9eT3iDpPWnSpAnc3d1Vb5C8zoULF/SPuXz5Mlq1aqUucl3n4sWLqF+/Pnr16oXCwkKDX0+Go5599ll1XXpIdMM+UhNUWc1NVFSUGuLz9fWFp6cnevTogd9++63CobzvvvsOr7/+OkJDQ1UbBg0ahFOnTsFUZs6cqXqW1q9fX+b4gw8+CFdXVxw4cKBMe5YvX44XXnhBvRcSQm655RbExMRc9bo7duzAjTfeCB8fH/Uz9u/fH1u3bq2wrubo0aMYM2YM6tatiz59+pS5rzS5PXnyZHz//fdo06YNPDw80LNnTxw6dEjd/9FHH6keKXmfBgwYoP8dVLdd8j7reuPk8RMmTEB2dnaZ9kgY++KLL/S/d9ZXkbkw6hNZCd3JR05qOomJiepkrzuR+fv74/fff8f999+P9PR0PPnkk5W+nvQ8SXCQk5CcfI8cOYKPP/5YfZWeKXlNOSHKyah379548cUX8e6776rnPvbYY0hLS1O1KlITZOjr3X777Thx4gS+/fZb/N///R/8/PzUc6XdFZGfTwKUnCRlmK5evXqqPRISVqxYgdtuu63M4998800VPp555hnVvrfffhtjx45VJ2lDyHNSUlLKHJN2y/fVDf/8+uuv6v2VkODl5YW1a9diyZIlePXVV9GhQ4cyz5WgJc9//vnnkZSUhPnz52Pw4MHYv3+/em/FX3/9pXqMIiIi9OHps88+w3XXXYctW7aooc3SJOg1b95cDfEUFxdX+fPI83/55Rf1+xJz5szBTTfdpHr+PvzwQzz66KO4dOmSep8kiEpbdIxt11133aUCq3yPvXv34pNPPlG1YjJEK2QId9KkSep5EgZF06ZNDfq9EBmtmIiM9thjj8lZxaDH1qpVq3j8+PEGv/aGDRvUay9durQ4OTm5OC4urnjNmjXFzZo1K3ZwcCjeuXOn/rH3339/cf369YtTUlLKvMbdd99d7OPjU5ydna1unzlzRr3mZ599pn+M7r7Svv32W/W4zZs3lzk+ffr0YkdHR3X8+++/V4+ZP39+mccY+npz585Vx6RN5YWFhZV5r5588kn12C1btuiPZWRkFDdu3Li4UaNGxYWFhWXes9atWxfn5ubqH7tgwQJ1/NChQ8VVkfdFHlfRxc3Nrcxj5bVcXV2LJ02aVHzp0qXikJCQ4i5duhTn5+frH6Nrj9yXnp6uP/7dd9+p49IuUVRUVNy8efPiIUOGqOul30v5Ga+//nr9sZkzZ6rnjh49+qr26+4rTdf20u/zRx99pI4HBQWVaZf8fkv/TqrTrokTJ5b5/rfddltxvXr1runfAlF1cViKyELJJ2np0QgODlZDA9KrIJ9+pchYyPnrhx9+wM0336yuS4+D7jJkyBD1ePkEXRldz4HIyclRz5NeIFH+eTL0IMNd48ePV5/2ZXhCelKq+3qGWr16tfqkrxt+EVLDJJ/8pSdLhmhKk14jGR4qP5QnPUqGWLhwoeqBKn2RnrDSwsPDVUG09EzI+yw/p/QmVVTzMm7cONW7oyM1VDKcJz+XkB6ckydPqmEmGb7T/f5k+EaG1DZv3oyioqIyr/nwww/DUPIaMtSn0717d/X1jjvuKNMu3XHd+2SKdsl7L8+VHkSimsZhKSILNWPGDHWCyMzMxE8//YRly5aVmUmUnJysplPL0I9cKiJDIZWRuhk5Scvrln+cBKPSJDBIHY8EK6nRkOGJ8jUexryeoc6dO6c/8VY0K03ul7ChI0XcpemG8GToxRASpAwpKJa6Ifk5d+7cqYaHpKalIjJ8VJq8Z1LnohtilAAhJDRWRt670kORFc3mqkz590NqYUSDBg0qPK57n6rTrqree29vb4PbTGQKDDdEFqpdu3aqPkPI1FmpO3nggQdUL4acnHSfnGXGVmUnofbt21f6+lIjIdOy5UTdsWNH1SMirym9ROU/lQupLdH1ysjJr/xJ1tjXMwdd/U95/1WbYizp4dAFAF2BbnXo3pe5c+eq96wi5Wfble4hq+778V/vU3XaVVPvPZEhGG6IrIQUy0oPjhSpypo3MmQlQwsyW0kXggwln6Zlxo/0tEgPkY7uhF2ezISSNWBk2EeGLKQwVE7qpT/xG/p6xswik1lnsvZNeceOHdPfX9PkxC+zfKQ3Qgq2dWu3SLF0eeV/fjnRy6wiXejUFdTKaxn7OzQnc7WLqyhTTWHNDZGVkBOO1ErIDKWEhAT1SVluS92NLOxXngxbVUb3Kbv8p2qZzVOeLCIoJ3Op/VmwYIH6/jKL6amnnqrW68mUaGHICsXDhg1TQz/btm3TH5O6DxmGk1qSyoaDzElmjEkPlbRBZkjJbC5Zf6j8LCshaxLJYo46MsNLFnWUWUhCZiLJ7/Wdd95Rw4/G/A7NyVztkt+9Ja1MTbaLPTdEZiDThXVrnuhWGH7ttdfUbZnGXNVwUVVkyEfWcpHQID05ctmwYYOqS5EhKznZS+2LFPCuW7dOXa+IfCLv16+fmgIs7QsJCcEff/yBM2fOXPVYabf01kjPjPQUSduld0amRUuPhQQQY15PTpxCppbffffdcHFxUUXRutBTmqy6K9PGJQxIAbOsdSPFu/K6EupMvZqxFA/reoVKkwAj6/fI9hcvv/yyCnvSZiFhT4ZupNBafjelSXtlGFF6vCQQyu9Nam7kdyWk/VKYLD+fFGzL4+S9k7WL5Pcq76v8v1TTzNUu+d3L/5cSECUsy9BmRTVVRNes2vOsiOzYf00Fl+mulU0tLj0duyK6acQy5boiAwYMKPb29i5OTU1VtxMTE1V7GjRoUOzi4qKm+Q4aNKj4448/1j+noqng58+fV9N169Spo6aNjxw5Uk07l8fJ9F6xZ8+eYmdn5+LHH3+8TBsKCgqKu3btWhwcHKymQxv6ejqvvvqqmiYt08tLT0EuPxVcnD59uvjOO+9Ur+vu7l7crVu34lWrVhn0nlX0cxs7FVz3fN3PHBoaqn/vy085X758eZn2yFR4mWYdEBBQ7OHhUTx8+PDic+fOXfX99+3bV3z77berqdMyfVveh7vuuqt4/fr1V025luUBDJ0KLv9fVPR+yHR8Q96/a2mX7j0tPRX92LFjxf369VPvhdzHaeFkLg7yn2uPSEREpCMrFA8cOFCtDlx6Cw0iqhmsuSEiIiKbwnBDRERENoXhhoiIiGwKa26IiIjIprDnhoiIiGwKww0RERHZFLtcxE+WT4+Li1MLknE5cCIiIusglTSy6rcsAlnVIp52GW4k2JTfFZeIiIisQ0xMDEJDQyu93y7DjfTY6N4cWUaciIiILF96errqnNCdxytjl+FGNxQlwYbhhoiIyLr8V0kJC4qJiIjIpjDcEBERkU1huCEiIiKbwnBDRERENoXhhoiIiGwKww0RERHZFIYbIiIisikMN0RERGRTNA83mzdvxs0336z2iZBFeVauXPmfz9m4cSM6d+4MNzc3NGvWDJ9//nmNtJWIiIgsn+bhJisrCx06dMDChQsNevyZM2cwfPhwDBw4EPv378eTTz6JSZMmYe3atWZvKxEREVk+zbdfGDp0qLoYavHixWjcuDHmzZunbrdu3Rp///03/u///g9DhgwxY0uJiIjIGmjec2Osbdu2YfDgwWWOSaiR45XJzc1Vm22VvhAREZFtsrpwk5CQgMDAwDLH5LYElsuXL1f4nDlz5sDHx0d/kR1FzaGgsAjHEtKRmVtgltcnIiIiGww31TF9+nSkpaXpLzExMWb5Prd9+A9unL8F209fMMvrExERkQ2Gm6CgICQmJpY5Jre9vb3h4eFR4XNkVpXcX/piDs0Da6uvh+PSzPL6REREZIPhpmfPnli/fn2ZY3/++ac6rrXwYB/19XAsa3qIiIjsNtxkZmaqKd1y0U31luvR0dH6IaVx48bpH//www8jKioKzz33HI4dO4YPP/wQ3333HZ566iloLTykJNwcYc8NERGR/Yab3bt3o1OnTuoipk6dqq7PmDFD3Y6Pj9cHHSHTwH/77TfVWyPr48iU8E8++cQipoG3CfaGgwMQn5aDlMxcrZtDRERklxyKi4uLYWdkZpXMmpLiYlPX31w3byOikrPwxcRu6N/C36SvTUREZM/SDTx/a95zY2v+rbvh0BQREZEWGG5MLDykJEmy7oaIiEgbDDcmxhlTRERE2mK4MbG2V8JN9MVspGXna90cIiIiu8NwY2I+ni5o4FuymOCReA5NERER1TSGGzMOTR3h0BQREVGNY7gx42J+3IaBiIio5jHcmEHb4JIZU5wOTkREVPMYbsxYVByVkoWs3AKtm0NERGRXGG7MwN/LDUHe7pC1nyPjWXdDRERUkxhuzLyYH4emiIiIahbDjZmHpg7HseeGiIioJjHcmHvGFHtuiIiIahTDjZm0uxJuTiRm4GRihtbNISIishsMN2YS5OOO69sEoqgYePW3SBRLdTERERGZHcONGb04rDVcnByw+UQyNhxP0ro5REREdoHhxowa+dXCxD6N1fVXV0Uir6BI6yYRERHZPIYbM5s8sBn8arvhTEoW/rftrNbNISIisnkMN2bm5e6C54a0VNcXrDuJlMxcrZtERERk0xhuasCdEaFqUb+M3AIs3nha6+YQERHZNIabGuDo6KCGp8RfLCwmIiIyK4abGtKzqR8cHYCo5CwkpOVo3RwiIiKbxXBTQ3w8XPSrFv9zOkXr5hAREdkshpsa1Kupn/q69dQFrZtCRERksxhualDvZvX0PTdcsZiIiMg8GG5qUJcwX7g6OSI+LQdnL2Rr3RwiIiKbxHBTgzxcndCpYR11fesp1t0QERGZA8ONRnU3LComIiIyD4Ybjeputp2+gCLZMpyIiIhMiuGmhnVoUAeerk64lJ2PyIR0rZtDRERkcxhuapiLkyO6NfZV1//hlHAiIiKTY7jRQG/dejesuyEiIjI5hhsN9LpSd7PzzEXkFxZp3RwiIiKbwnCjgdZB3qjr6YLsvEIcPJ+qdXOIiIhsCsONRruEd21UUnez6+wlrZtDRERkUxhuNNKlUV31dc85hhsiIiJTYrjRSERYSbjZe+4S95kiIiIyIYYbjbQN9lH7TF3IyuM+U0RERCbEcKMRdxcntAv1Udc5NEVERGQ6DDcWMDTFcENERGQ6DDcWEW4uat0UIiIim8Fwo6HODUvCzYnETKRdzte6OURERDaB4UZD/l5uCKvnqa7vi+bQFBERkSkw3FjQlHAiIiK6dgw3FhJudjPcEBERmQTDjca6hJVsw7A/JhUF3ESTiIjomjHcaKx5QG14uTmrTTSPJWRo3RwiIiKrx3BjAZtoduJ6N0RERCbDcGMBujDcEBERmQzDjQUVFe86e5GbaBIREV0jhhsLWczP1dkR8Wk5OJ2cpXVziIiIrBrDjQXwcHVC98Yls6Y2nUjWujlERERWjeHGQvRv4a++MtwQERFdG4YbCws3O6IuICe/UOvmEBERWS2GGwvRLKA2gn3ckVtQhB1nuEs4ERFRdTHcWAgHBwf0b3llaOo4h6aIiIiqi+HGgvRrrqu7SdK6KURERFbLIsLNwoUL0ahRI7i7u6N79+7YuXNnlY+fP38+WrZsCQ8PDzRo0ABPPfUUcnJyYO16NfODk6ODmg5+/lK21s0hIiKySpqHm+XLl2Pq1KmYOXMm9u7diw4dOmDIkCFISqq49+Kbb77BtGnT1OMjIyPx6aefqtd44YUXYO18PFzQuWEddX3ziRStm0NERGSVNA837777Lh544AFMmDABbdq0weLFi+Hp6YmlS5dW+Ph//vkHvXv3xpgxY1Rvzw033IDRo0f/Z2+P9U0J59AUERGR1YWbvLw87NmzB4MHD/63QY6O6va2bdsqfE6vXr3Uc3RhJioqCqtXr8awYcMq/T65ublIT08vc7FU/VsEqK9bT11AfmGR1s0hIiKyOpqGm5SUFBQWFiIwMLDMcbmdkJBQ4XOkx2b27Nno06cPXFxc0LRpUwwYMKDKYak5c+bAx8dHf5E6HUvVNtgb9Wq5IjO3AHu5kSYREZH1DUsZa+PGjXjjjTfw4YcfqhqdH3/8Eb/99hteffXVSp8zffp0pKWl6S8xMTGwVI6ODuh3ZWjqjdWRSEq3/kJpIiKimuQMDfn5+cHJyQmJiYlljsvtoKCgCp/z8ssv495778WkSZPU7Xbt2iErKwsPPvggXnzxRTWsVZ6bm5u6WIsH+jbBX8eScOB8Gm75YCs+HheB9qElhcZERERkwT03rq6uiIiIwPr16/XHioqK1O2ePXtW+Jzs7OyrAowEJFFcXAxb0CbYG79M7q1WLU5Iz8HIxdvw8/5YrZtFRERkFTQflpJp4EuWLMEXX3yhpnY/8sgjqidGZk+JcePGqWElnZtvvhmLFi3CsmXLcObMGfz555+qN0eO60KOLQirVws/PdoL17UKUFsyPLV8P6KSM7VuFhERkcXTdFhKjBo1CsnJyZgxY4YqIu7YsSPWrFmjLzKOjo4u01Pz0ksvqa0K5GtsbCz8/f1VsHn99ddha7zcXbBkXBeM/WQ7tkddxNojiXhkQG2tm0VERGTRHIptZSzHCDIVXGZNSXGxt7c3LN1X28/hpZWHERFWFz880kvr5hAREVn0+VvzYSn6b4Nal6x9szf6ElIyc7VuDhERkUVjuLEC9X080C7EB9LHJrOoiIiIqHIMN1ZicOuSGqR1R8tOmyciIqKyGG6sbGhqy8kU5OQXat0cIiIii8VwYyVkW4b6Pu64nF+IbacvaN0cIiIii8VwYyVk+rtuaOrPSA5NERERVYbhxooMblMSbtZHJqKoyO5m8BMRERmE4caK9Gjii1quTkhMz8XhuDStm0NERGSRGG6siJuzk37HcM6aIiIiqhjDjbVOCY/kejdEREQVYbixMgNa+sPBATgan46k9Bytm0NERGRxGG6sTL3abggP9lHXN59M0bo5REREFofhxgr1v1J3s+lEstZNISIisjgMN1aof8uScPP3yWQUcko4ERFRGQw3VqhTgzrwcnfGpex8HIrllHAiIqLSGG6skLOTI/o081PXNx3n0BQREVFpDDdWSrfezaYTnBJORERUGsONlYeb/TGpSM3O07o5REREFoPhxkqF1PFA84DakHriv09xSjgREdE1hZsvv/wSvXv3RnBwMM6dO6eOzZ8/Hz///HN1Xo6udUo4626IiIiqH24WLVqEqVOnYtiwYUhNTUVhYaE6XqdOHRVwqOaHpjafTEZxMaeEExERVSvcvP/++1iyZAlefPFFODk56Y936dIFhw4d4rtag7o19oW7i6PaJfx4YobWzSEiIrLOcHPmzBl06tTpquNubm7IysoyVbvIAO4uTujRpJ66vuUE626IiIiqFW4aN26M/fv3X3V8zZo1aN26Nd/VGqYLN7vPXdS6KURERBbB2dgnSL3NY489hpycHFXnsXPnTnz77beYM2cOPvnkE/O0kioVEVZXfd1zLlX9Phxky3AiIiI7ZnS4mTRpEjw8PPDSSy8hOzsbY8aMUbOmFixYgLvvvts8raRKtQvxgYuTA1IycxF9MRth9Wpp3SQiIiLrCjdi7Nix6iLhJjMzEwEBAaZvGRlcdxMe4oN90anYc+4Sww0REdk9o2turrvuOjUFXHh6euqDTXp6urqPal5EQ93Q1CWtm0JERGR94Wbjxo3Iy7t6uX+pwdmyZYup2kVG6NKI4YaIiMjoYamDBw/qrx89ehQJCQn627KQn8yWCgkJMfTlyIQ6X+m5kbVu0nPy4e3uonWTiIiILD/cdOzYUc3EkUtFw09SZCwL/FHNC/B2RwNfD8RcvIz90an6lYuJiIjskbMxi/fJVOMmTZqo6d/+/v+eQF1dXVXtTekVi6lmdQnzRczFWOw+d4nhhoiI7JrB4SYsLEx9LSoqMmd7qJo6h9XFT/tisZd1N0REZOeqNRVcV3cTHR19VXHxLbfcYop2kZG6XFnMb1/0JRQWFcPJkYv5ERGRfTI63ERFReG2225Tm2RK/Y1uN2rdyri6XcKpZrUI9EJtN2dk5hbgWEI62gb7aN0kIiIi65gK/sQTT6j9pZKSktQ6N0eOHMHmzZvVruAyTZy0IT01nRrWUdc5NEVERPbM6HCzbds2zJ49G35+fnB0dFSXPn36qL2lpkyZYp5WkpH7TFUcbuJSL2PlvlgUFZX0thEREdkio4elZNjJy8tLXZeAExcXh5YtW6qC4+PHj5ujjWRkuJEZU+U30TyVlInRS7YjOSNX1eTcERGqYUuJiIgsqOcmPDwcBw4cUNe7d++Ot99+G1u3blW9OTJNnLTTqWFdODs64Pyly3hq+X5k5OSr46eT/w02Ys2RfxdgJCIigr2HG9kNXDcdXAKNrH/Tt29frF69Wu0MTtqRguKXb2qj6m9W7o/DTe//jVUH4zD645JgE1LHQz1uy8lk5OSz8JuIiGyTQ7FuutM1uHjxIurWrVtmGMSSySafPj4+SEtLg7e3N2zNnnMXMeXb/YhNvaw/1irIC19P6o6b3/8bcWk5WHpfF1zXKlDTdhIREZnj/G10z83EiRORkZFR5pivry+ys7PVfaS9iDBfrJ7SF0PDg9TtloElwaZebTcMal0SaP48mqRxK4mIiCyk50a2WIiPj1fbLZSWkpKCoKAgFBQUwNLZes+Njvxqj8Slo1lAbbi7lGyNselEMsYv3YkALzdsnz4Ijlzsj4iIrISh529nY15QTpZykZ4bd3f3MjOopOamfOAhbckwYXhI2cX8ejTxRS1XJyRl5OJQbBo6NChZG4eIiMhWGBxu6tSpo98VvEWLFlfdL8dnzZpl6vaRibk5O6F/S3+sPpSAdZGJDDdERGS/4WbDhg2q1+a6667DDz/8oOpsSu8KLuvcBAcHm6udZEKDWwdeCTdJePqGllo3h4iISJtw079/f/VVpn43bNjQamZG0dUGtgyAlNpExqfj/KVshNb11LpJREREJmP0bKnIyEi1aJ/OwoUL0bFjR4wZMwaXLnFPI2tQt5YruoSV9Lytj+SsKSIisvNw8+yzz6riYiE7g0+dOhXDhg1TPTpynazD4DYlxd9Sd0NERGTX4UZCTJs2bdR1qb25+eab8cYbb6genN9//90cbSQz1d2I7VEXcDmPqxUTEZEdhxspHpYF+8S6detwww03qOtSYKzr0SHL19ivllrrJr+wWE0JJyIisttw06dPHzX89Oqrr2Lnzp0YPny4On7ixAmEhnKnaWshBeGdG5bsIr43mrVSRERkx+Hmgw8+gLOzM1asWIFFixYhJCREHZchqRtvvNEcbSQz6RxWssbN3nMMN0REZIdTwXVkGviqVauuOv5///d/pmoT1ZB/e25S1RpGnN5PRER22XNDtkO2ZnBxckBKZi5iLv67gzgREZE1Y7ixY7KZZpvgkr2nWHdDRES2guHGznVueKXuhuGGiIhshEWEG1kjp1GjRmqn8e7du6tZWFVJTU3FY489hvr168PNzU1t5Cm7kpPxIsI4Y4qIiOy8oNjUli9frqaWL168WAWb+fPnY8iQITh+/DgCAkpW0S0tLy8P119/vbpPZmzJbK1z586pXcup+kXFkfEZyM4rgKer5v9LEBERXZNqncni4+Px66+/qt4S6XG55ZZb1MaaTk5ORr/Wu+++iwceeAATJkxQtyXk/Pbbb1i6dCmmTZt21ePl+MWLF/HPP//AxcVFHZM2UPUE1/FAkLc7EtJzcPB8Gno0qad1k4iIiGpmWEr2kXr99dfRtWtXNG7cWPW4yIJ++fn5uO++++Dv74+xY8eq44auVCy9MHv27MHgwYP/bZCjo7q9bdu2Cp/zyy+/oGfPnmpYKjAwEOHh4Wr7h8LCyrcQyM3NVW0qfaGr17vZw/VuiIjIXsKNrGEjQUYCzpNPPql6btavX49nnnlG1ctER0errRiaN2+Ot956q8LhpIqkpKSoUCIhpTS5nZCQUOFzoqKi1HCUPE96jl5++WXMmzcPr732WqXfZ86cOfDx8dFfGjRoYFD77G1oat+VuhtZ8+b99Sdxzyc7kJ6Tr3HriIiIjONQLGey/5CUlIS6devqh4H+y/nz5w3aiiEuLk7VzMgQk/TG6Dz33HPYtGkTduzYcdVzpHg4JydHbeCpGwaToa25c+eq0FVZz41cdKTnRgJOWloavL29Ye+kx+aORf/At5Yr9rw0GK/9FolP/z6j7ltwd0fc2rFkFWoiIiItyflbOin+6/xtUM2NoT0xOobuMeXn56cCSmJiYpnjcjsoKKjC58gMKQlZpet7WrdurXp6ZJhLNvYsT2ZUyYUqFh7iDVcnR1zMysOUZfvx64E4/X1H4tIZboiIyD6ngl+6dAn/+9//jHqOBJGIiAg1xKVTVFSkbpfuySmtd+/eOHXqlHqcjmzaKaGnomBD/83N2QltQ0oSsC7Y9Gnmp74eieOO4UREZKfhRupudDOejCHTwJcsWYIvvvgCkZGReOSRR5CVlaV/rXHjxmH69On6x8v9MlvqiSeeUKFGZlZJQbEUGNO1192IV0eEY9rQVur64dh0VYNDRERkc1PB/2uGUUZGRrUaMGrUKCQnJ2PGjBlqaKljx45Ys2aNvshYQpPMoNKRWpm1a9fiqaeeQvv27VXNjgSd559/vlrfn0qM6toAu89exJjuDTGqa0PkFhTC2dEBaZfzEZt6GaF1PbVuIhERkekKioUEjKp2jdbtKl3VlGxrK0iyd0MXbEFkfDo+ujcCQ9pWXANFRERklQXFwsvLCy+++KJaRbgiJ0+exEMPPVS91pJFahvsrcKNFBUz3BARkbUwONx07txZfZWViCsi2x+wNsP2ws2KPcBRFhUTEZEtFhSPGTNGbWxZGZm6PXPmTFO1iyxAeIiP+io9N0RERDZXc2NLWHNjmMzcArR7ZS3k/xBZ3K9eba4VREREln/+NtlUcLI9td2c0aheLXWdvTdERGQtGG6oSm2CS5Ixww0REdlUuJFp4LLdgbGX2bNnm/8nILMXFQuuVExERDY1W0o2qawOmUFF1q1tcElR8VH23BARkS2Fm7CwMPO3hCy65+bMhSxk5RaglpvBqwcQERFpgjU3VCW/2m4I9HZTM6ZkQT8iIiJLx3BDBg9NHY5l3Q0REVk+hhsyoqiYPTdERGT5WEBBBoebtUcSUFhUjNb1vdE2xBs9GteDo2Plm6kSERFZbM+Nr68vUlJS1PWJEyciIyPD3O0iC9KlkS88XZ2QnlOAH/fF4vXVkRizZAcWbz6tddOIiIiqF27y8vLUksfiiy++QE5OjiFPIxsqKt783EAsGdcFU69vgV5N66njP++L07ppRERE1RuW6tmzJ0aMGIGIiAi18/eUKVPg4eFR4WOXLl1qyEuSFQac69sEqsv4no0Q8dqfOJ6YgajkTDTxr61184iIiIzrufnqq68wbNgwZGZmwsHBQW1YdenSpQovZPt8PF3Q80rvzZojCVo3h4iI6Np2BW/cuDF2796NevVKTm7WiLuCX7uvd5zDiz8dRodQH/w8uY/WzSEiIjuQbq5dwWUrBmsONmQaN7QJgoMDcOB8GmJTL2vdHCIiomtb52bTpk24+eab0axZM3W55ZZbsGXLluq8FFkpfy83dA3zVdfXHubQFBERWXG4kfqbwYMHw9PTUxUW64qLBw0ahG+++cY8rSSLdGN4kPq6huGGiIisueamdevWePDBB/HUU0+VOf7uu+9iyZIliIyMhKVjzY1pyHBU7zf/UsNTO18YrHpziIiIrK7mJioqSg1JlSdDU1KPQ/YjpI6HKiiWePzHUfbeEBGRZTA63DRo0ADr16+/6vi6devUfWRfhnBoioiIrH1vqaefflrV2ezfvx+9evVSx7Zu3YrPP/8cCxYsMEcbyYLd2DYIb685jm2nLyA1Ow91PF21bhIREdk5o8PNI488gqCgIMybNw/fffedvg5n+fLluPXWW83RRrJgsjqxbKQZGZ+OXw7EYVzPRlo3iYiI7JzRBcW2gAXFpvXZ1jOY9etRFXJWT+mjVrEmIiKymoJiovJu6xQCV2dH1XtzOLZkg1UiIiKtMNzQNZM6G6m9Ect2RWvdHCIisnMMN2QSd3ctmSn3y/44ZOcVaN0cIiKyYww3ZBI9mtRDQ19PZOQWYPUhTgsnIiIrCjcbNmwwT0vIqjk6OmDUld6b5RyaIiIiawo3N954I5o2bYrXXnsNMTEx5mkVWaU7I0Lh5OiAXWcv4VRSptbNISIiO2V0uImNjcXkyZOxYsUKNGnSBEOGDFHr3eTl5ZmnhWQ1Ar3dMbBlgLrO3hsiIrKacOPn56c2zZQVinfs2IEWLVrg0UcfRXBwsFq5+MCBA+ZpKVlVYfGynTG4mMXAS0REVlZQ3LlzZ0yfPl315GRmZmLp0qWIiIhA3759ceTIEdO1kqzGda0C0DbYWxUWv//XSa2bQ0REdqha4SY/P18NSw0bNgxhYWFYu3YtPvjgAyQmJuLUqVPq2MiRI03fWrKKwuIXhrVW17/afg7nLmRp3SQiIrIzRoebxx9/HPXr18dDDz2khqT27duHbdu2YdKkSahVqxYaNWqEd955B8eOHTNPi8ni9W7mh/4t/JFfWIy5a49r3RwiIrIzRoebo0eP4v3330dcXBzmz5+P8PDwCutyOGXcvk0b2gqyxdSqg/HYH5OqdXOIiMiOGB1uZs6cqYac3NzcyhwvKCjA5s2b1XVnZ2f079/fdK0kqyObaN7ROVRdn7M6Ena4PysREVlLuBk4cCAuXrx41XHZoVPuI9KZen0LuDk7YseZi/hw42kUFTHgEBGRBYYb+QTuIOMN5Vy4cEHV3BDpBNfxwKMDmqnrUnsz4fNdSMnM1bpZRERk45wNfeDtt9+uvkqwue+++8oMSxUWFuLgwYPo1auXeVpJVmvKoGbw93LDrF+PYNOJZAxdsAXzR3VURcdERESahhsfHx99z42Xlxc8PDz097m6uqJHjx544IEHzNJIsl4Shsd0b4iIsLp4/Nu9OJGYiYmf78KW5wYiwNtd6+YREZE9h5vPPvtMfZWp3s888wyHoMgoLYO88PNjfTDyo39wODYdvxyIw6S+TbRuFhER2aBqzZZisKHq8HB1wt1dG6rrP+yN1bo5RERkzz03ss3C+vXrUbduXXTq1KnCgmKdvXv3mrJ9ZGNual8fs389isj4dHWRKeNEREQ1Hm5uvfVWfQHxiBEjTNoAsi91PF0xsJU/1h5JxE/7YhluiIjI5ByK7XB1tfT0dFUgLWvzeHvz5FrT1h5JwENf7kGgtxv+mTYITo6V9wQSEREZe/6+pl3BiapjYMsA1PF0QWJ6Lv45naJ1c4iIyB6HpaTWpqo6m9IqWr2YqDRXZ0dVe/PV9mj8uDcWfZv7a90kIiKyt3AjG2QSmdLtnUNVuFlzOAGvjShALTeDVyUgIiKqkkFnlPHjxxvyMCKDdWpQB439auFMSha+3H5OLfTn7e6idbOIiMheCoqlgEdXuCPXq2INBbosKLYM760/iXf/PKG/HVrXA50a1sX0oa3UvlRERETVOX8bXHMTHx+PgIAA1KlTp8L6G92GmrLPFJEh7u0RhuMJGdgXfQlxaTk4f+myuuw+exFf3t8NzQK8tG4iERFZIYPCzV9//QVfX191fcOGDeZuE9mJurVcsXBsZ3U9NTsPR+LS8fLPhxGVnIU7F2/DZ/d1VT05RERExuA6NxyWsigXs/Iw4fNdOBCTCg8XJyy+NwL9W3A2FRERwbzr3Fy6dAnvvPMO7r//fnWZN2/eNU0BX7hwodqQ093dHd27d8fOnTsNet6yZcvUUBhXTbYdvrVc8c2k7ujb3A+X8wsx5dt9yC8s0rpZRERkRYwON5s3b1ZB5L333lMhRy5yvXHjxuo+Yy1fvhxTp05VG3LKvlQdOnTAkCFDkJSUVOXzzp49q3Yn79u3r9HfkyybTAv/dHxXeLo6Ie1yPs5dyNK6SUREZMvh5rHHHsOoUaNw5swZ/Pjjj+oSFRWFu+++W91nrHfffRcPPPAAJkyYgDZt2mDx4sXw9PTE0qVLK32OFC2PHTsWs2bNQpMmTYz+nmQdC/01DywpKD6ekKl1c4iIyJbDzalTp/D000/DyclJf0yuS++L3GeMvLw87NmzB4MHD/63QY6O6va2bdsqfd7s2bPVzC0ZEjNEbm6uGqcrfSHL1yKgtvp6IjFD66YQEZEth5vOnTsjMjLyquNyTIaUjJGSkqJ6YQIDA8scl9sJCQkVPufvv//Gp59+iiVLlhj8febMmaMKkHSXBg0aGNVO0kbLoJKeG4YbIiIy+VTwgwcP6q9PmTIFTzzxhOql6dGjhzq2fft2VRT85ptvwpwyMjJw7733qmDj5+dn8POmT5+uepZ0pOeGAcfytdANSzHcEBGRqcNNx44d1ayk0rPGn3vuuaseN2bMGFWPYygJKDKklZiYWOa43A4KCrrq8adPn1aFxDfffLP+WFFRyUwaZ2dnHD9+HE2bNr3qeW5ubupC1tlzc+5CNnLyC+Hu8u9QKBER0TWFGykeNgdXV1dERERg/fr1+uncElbk9uTJk696fKtWrXDo0KEyx1566SXVo7NgwQL2xtiYAC83+Hi4qBlTsrBfm2CuSURERCYKN2FhYTAXGS6SjTm7dOmCbt26qR3Is7Ky1OwpMW7cOISEhKi6GVkHJzw8vMzzZTsIUf44WT/pLWwRWBu7zl5SdTcMN0REZLJwU5GjR48iOjpazXgq7ZZbbjHqdWQYKzk5GTNmzFBFxDIEtmbNGn2RsXwPmUFF9lt3I+GGdTdERGS27RdkTZvbbrtNDQ+VrsPRbaZpDRtncvsF6/G/bWcx4+cjGNw6AJ+M76o//sJPh/D7oXj8MrkPGvh6atpGIiKy8u0XZKaUrEYsKwjLYntHjhxRKxPLsNLGjRuvtd1E/zljSjbZ/G5XDC5l5+P73TEato6IiCyR0eFGFteTRfRkppMMF8mlT58+qiZGpokTmSPcxFy8jKzcAnX9j6OJKCgq6TH87VB8mVl8RERERocbGXby8io54UjAiYuL0xcdy1RsIlNvpOlXu2Qa/6mkkm0YVh+K199/OjkLJxK5PQMREV1DuJFZSQcOHFDXZQfvt99+G1u3blW9OdznicyhZVBt/dBUWnY+tp5KUbdlJpWu94aIiKja4UbWldEtnCeBRtbAkZ25V69erXYHJzLX0NSJhAz8cTQB+YXFaBnohYf6lSzYKIXFRERE1Z4KPmTIEP31Zs2a4dixY7h48SLq1q2rnzFFZEoSZMSJpExEpWSp68Pa1cfgNoFwcXLAyaRMnEzM0O8iTkRE9u2aFpCJiYlRF19fXwYbMpsWV7ZhOHQ+FVtOJqvrw9oFqdWL+zb3V7c5NEVERNUONwUFBXj55ZfVPPNGjRqpi1yX4ar8/HxjX47oPzUPKKmtkanfMiQlt3W9NNKDU77ImIiI7JvRw1KPP/44fvzxR1VI3LNnT/308FdeeQUXLlzAokWLzNFOsmNe7i4IqeOB2NTLZQKNuL51ydCUzJg6lZSBZgEcmiIisndGh5tvvvkGy5Ytw9ChQ/XH2rdvrzatHD16NMMNmYXMjNKFm+Ht/w03Pp4u6N3MDxuPJ+O3gwl4YjDDDRGRvTN6WMrNzU0NRZUnqxbLLt9E5qy7aRZQWz97SkfXk/Pl9nP4+2TJNHEiIrJfRoebyZMn49VXX0Vubq7+mFx//fXX1X1E5nBrhxA08PXAlEHNr7pvaHgQGtXzREpmLu75dAee+f6A2qJByOrFaZfzkZNv+XueERFRDW6cefvtt5e5vW7dOtWD06FDB3VbFvWT3cEHDRqk6nEsHTfOtD2ZuQWYu+YY/rf9HOT/aJlJVdvNGcmZucgrKEJdTxf8ObW/frVjIiKyPoaevw2quZEXKu2OO+4oc1vqbYi0JEFm1q3huKVjCKb9cFCtfSM9Njoy0+qvyCTc1ZX/rxIR2TqDem5sDXtubJv01OyNvgQ3Z0f4e7nh6x3RWLTxNIa3q4+FYztr3TwiIrKEnpuKJCcn6zfKbNmyJfz9SxZTI9Kaq7MjejSpp789uHWgCjd/n0pBQWERnJ2uae1KIiKycEb/lc/KysLEiRNRv3599OvXT12Cg4Nx//33Izs72zytJLoGHUJ9VA2ODFMdOJ+mdXOIiMjSws3UqVOxadMm/Prrr0hNTVWXn3/+WR17+umnzdNKomsgPTV9mvup65tOlGzfQEREtsvocPPDDz/g008/VYv4yXiXXIYNG4YlS5ZgxYoV5mkl0TXqf2UPKoYbIiLbZ3S4kaGnwMDAq44HBARwWIosVr8WJeHm4PlUXMwqWQOHiIhsk9HhRvaTmjlzJnJycvTHLl++jFmzZun3miKyNEE+7mgV5KXWwNHtLE5ERLbJ6NlS8+fPx4033ojQ0NAyi/i5u7tj7dq15mgjkUn0b+GPYwkZ2HwiBbd2DNG6OUREZCnhpl27djh58iS+/vprHDt2TB2TDTPHjh0LDw8Pc7SRyGTh5qPNUarupqioGI6ODlo3iYiItA43+fn5aNWqFVatWoUHHnjAHO0hMpuIRnXh6eqk9qCKTEhH2+CyK28TEZEd1ty4uLiUqbUhsiZuzk7oeWVxP86aIiKyXUYXFD/22GN46623UFBQYJ4WEZlR/5Yls6Z+P5SgdgwnIiLbY3TNza5du7B+/Xr88ccfqv6mVq1aZe63hl3ByX4NaRuEOauP4VBsGn7cG4s7IkK1bhIREWkdburUqXPVruBE1iLQ2x1TBjXHW2uO4Y3VkWrfKR9PF62bRUREJsRdwbkruF3uGj7svS04lZSJe3uE4dUR4Vo3iYiITHj+NrjmpqioSNXa9O7dG127dsW0adPU4n1E1rhr+Oxb26rrX+04p1YtrkxWbgHyC4tqsHVERHStDA43r7/+Ol544QXUrl0bISEhWLBggSouJrJGvZr6YUTHYLVi8csrD6OwqGwHZlp2Pqb9cBBtZ65Ft9fXYebPh3EgJpVFyEREtjQs1bx5czzzzDN46KGH1O1169Zh+PDhqvfG0dHoSVea4rAUiaSMHAx6ZxMycgvQ1L8Wbu8cihGdQlSImfHzEbUeTnktA72wdEJXhNThgpVERJZ6/jY43Li5ueHUqVNo0KCB/phsuSDHZCsGa8JwQzq/HIjDcysOICf/6qGnJv618PqIdsgtKMRP+2Kx9kiCetz0oa3wUP+mmrSXiMiepRt4/jZ4tpSsayNhpvyifrJqMZG1uqVDMAa29MfvhxPw095YbIu6AGdHBzw6oCkeHdgM7i5O6nEDWgbg482n8cbqY9h97hJK+i+JiMgSGRxupIPnvvvuUz04OrJa8cMPP1xmrRuuc0PWxsvdBXd1aaAuSek5cHFyRN1arlc9LiLMV33de+6S+vfg4MC9qYiIrDrcjB8//qpj99xzj6nbQ6SpAO+yvZOlhYd4w9XJERey8nD2QjYa+5VdwJKIiKws3Hz22WfmbQmRFexN1S7UB3vOXVIXhhsiIstkXdOciDTWJayu+irhhoiILBPDDZEROuvDzUWtm0JERJVguCEyQueGJeHmRGIm0i5zpiARkSViuCEygr+XGxrV81TX90VzaIqIyBIx3BBVe2iK4YaIyBIx3BAZqcuV9W4YboiILBPDDZGRIq703OyPSUUBdwwnIrI4DDdERmoeUBte7s7IzivEsYQMrZtDRETlMNwQGcnR0UE/a0o3NHUqKUPtPZWQlqNx64iIyOAViomo7NDUphPJWHUwDptPJGP9sSR1fHvURSy9r6vWzSMismsMN0TXsFLxrrMlPTeyh2ZxMVTgSc7IVVPGiYhIGxyWIqqGjg3roL6PO1ydHTG6W0Osn9ofHRrUQWFRMX49EKd184iI7Bp7boiqwdPVGX9O7Y/i4mJ4ubuoY3d0DsGBmFT8uO88JvZprHUTiYjsFntuiKqptpuzPtiIm9oHw9nRAYdj03EikbOoiIi0wnBDZCK+tVwxoGWAuv7j3litm0NEZLcYbohMSIamxM/7Y1FUVKx1c4iI7BLDDZEJXdc6AN7uzohPy8H2qAtaN4eIyC4x3BCZkJuzE27qEKyu/2Dg0NTsX4/iro+2ITGdCwASEZkCww2Rid3eqWRoas3heGTk5Ff5WNmfaunWM9h55iLGL92JtMtVP56IiP4bww2RGVYvblTPE1l5hbj74+2IS71c6WPfW39Sf132qZr0xS7k5BfWUEuJiGyTRYSbhQsXolGjRnB3d0f37t2xc+fOSh+7ZMkS9O3bF3Xr1lWXwYMHV/l4oprm4OCAd0d1RL1arjgSl45bPtiq34OqNFkT569jSXB0ABbf01ltxikrHk/+Zi93GycisuZws3z5ckydOhUzZ87E3r170aFDBwwZMgRJSSV79ZS3ceNGjB49Ghs2bMC2bdvQoEED3HDDDYiN5dRbshyysebPk3ujVZAXUjJzMfrj7fh+d0yFvTYjOobgxvD6+HR8V7g5O2JdZBJeXx2pUcuJiKyfQ7Essaoh6anp2rUrPvjgA3W7qKhIBZbHH38c06ZN+8/nFxYWqh4cef64ceMM+p7p6enw8fFBWloavL29r/lnIKpMVm4Bpn63H2uPJKrb9/dpjOlDWyEyPgM3f/C36rVZN7U/mvjX1tfpPPzVXrWtw64XBsPH899FAomI7F26gedvTXtu8vLysGfPHjW0pG+Qo6O6Lb0yhsjOzkZ+fj58fX0rfUxubq56Q0pfiGpCLTdnLBobgScGNVe3P/37DCZ+sRtvrz2mbt/aMUQfbMSQtkGqtyevoAi/HOQeVURE1aFpuElJSVE9L4GBgWWOy+2EhASDXuP5559HcHBwmYBU3pw5c1TS012kZ4iopjg6OuCp61tg4ZjOcHdxxOYTydhyMkX12ky+rtlV9Tp3RoSq6yvKDWPJooCPfbMXY5ZsR2p2Xo3+DERE1kTzmptr8eabb2LZsmX46aefVDFyZaZPn666sHSXmJiyJw2imjC8fX2seLgXgn3c9b02TUv12uiM6BSi9qg6cD6tzB5Vvx6Mw28H4/HP6QuY+PkuXM7jrCoiIosLN35+fnByckJiYkk9go7cDgoKqvK577zzjgo3f/zxB9q3b1/lY93c3NTYXOkLkRbCQ3zw6+N98M7IDnj9tvAKH+NX2w0DW5XsUbViz3n1NbegEHPXHlfXHRyAvdGpePTrPcjnrCoiIssKN66uroiIiMD69ev1x6SgWG737Nmz0ue9/fbbePXVV7FmzRp06dKlhlpLZBr1arupoSdPV+dKHzPyytCUbMAp08K/3HYO5y9dRqC3G76c2F0Nb204noznVxzkHlZERJY2LCXTwGXtmi+++AKRkZF45JFHkJWVhQkTJqj7ZQaUDCvpvPXWW3j55ZexdOlStTaO1ObIJTMzU8Ofgsi0pOdG1smRaeQyHPX+X6fU8anXt0Cf5n74cGxnODk64Md9sZjzO6eNExFZVLgZNWqUGmKaMWMGOnbsiP3796seGV2RcXR0NOLj4/WPX7RokZpldeedd6J+/fr6i7wGka1wcXJUtTfi+R8OqW0ZWgTWxp0RJcXw17UKxNt3lAzHLtlyBh9tOq1pe4mILInm69xogevckDWIjE/H0AVb9Lc/u6+rvhZH5+PNp/HG6pJp5XPvbI+RXTgTkIhsl1Wsc0NElWtd3xvhISX/eHs2qYcBLf2vesyD/ZrioX5N1PVpPx7CuqNli/OJiOwRww2RBXtpeBsMbOmP124LV2vgVGTa0Fa4o3MoCq+sg3M84d/p40RE9ojhhsiC9WhSD59N6Fbhejg6EnrevKMd+jb3Q25BET7YUFJ8TERkrxhuiGykAHn60Nbq+upD8Yi5mK11k4iINMNwQ2Qj2gR7q94bGZ5auvWM1s0hItIMww2RDXmgb0lx8fJdMUjLzte6OUREmmC4IbIh0nMjs6yy8wrx1Y5zWjeHiEgTDDdENkSKix/s11hd/2zrWeTkc3NNIrI/DDdENuam9sGo7+Outm74eX+s1s0hIqpxDDdENjhzamLvkt6bxZuiTNp7I68174/j2Hwi2WSvSURkagw3RDbo7m4N1MabZ1Ky8NLKwzDVLitz1x5Xm3g++vVeXMjMNclrEhGZGsMNkQ3ycnfBe6M7wdEBWLHnPL7dGXPNr7k96oJ+inlmboF+p3IiIkvDcENko3o388OzQ1qp66/8cgT7Y1Kr/VoZOfl45vsDkA6gzg3rqGNfbT+HsylZJmsvEZGpMNwQ2bCH+zfBkLaByCsswqNf7UH0hewK62j2nLuEpIycSl/ntVWROH/pMkLreuB/93dH/xb+KCgqxtw/jpv5JyAiMp5zNZ5DRFY0NXzuyA44mbgVUSlZ6Dd3A5r610Lf5v5qRtU/py9gx5kLyMkvgoeLE2bd2hYjI0LLbNIpO40v3x0DOTRvZAfUdnNWm3VuPpmM3w7GY1KfS+jUsK6mPycRUWkOxaaqNLQi6enp8PHxQVpaGry9vbVuDpHZnU7OxPQfDmH3uYsoquBfvKerk1r4T9zSIRiv3xaOE4mZ+HjzafxxNFENR03q0xgv3dRG/xwZppJ6nm6NfbH8wR6V7lpORFTT52+GG4YbsiOyJcO2qBRsOpGC5IxcdG/si74t/NA8wAuLN53Gu3+eUHtTSe+MFA3rDG9XH/Pu6gB3Fyf9sbjUyxj4zka1E7kMfY2MaID+Lf3VVHQiInNguKkCww1RxaT2Zsq3+xCbehmuTo4Y0SlY7VfVPNCrwscv2ngab605pr/tW8sV9/dpjEcHNGVPDhGZHMNNFRhuiCqXdjkfG44loVfTegjwdv/Pxx+JS8NPe2Oxcn+cWhVZfD2pu5qtRURkSgw3VWC4ITK9gsIitWDgsl0xKhh980APrZtERHZ6/ubgOBGZhLOTIx4f1BzOjg5qFta+6EtaN4mI7BTDDRGZTEgdD9zWKURd/3Djaa2bQ0R2iuGGiEzqYVVMDPx5NBHHEzIMek5RUTG2nExGdt6/M7SIiKqL4YaITKqpf20MDQ9S12V6uTiWkI4Jn+1E19fXVThctWD9Sdz76U51MeUu5kRknxhuiMjkHh3QTH395UCcmlo+dMEWbDierNbWkcX/SgcY2blcppTrpqJP//GQyXYxJyL7xHBDRCYXHuKDfi381YKAEnAkqwxrFwS/2m44nZyFhRtKdhSXEDPj58Nq76tWQV5wcnTAT/tiWa9DRNeE4YaIzOKZG1rA291Zbc/w06O98OHYCMy+ta26T3pqZKhq9aEEbDmZAldnRyy+JwKzbim5f+7a41h9KF7jn4CIrBU3ziQis2gfWgcHZt5QZqViqcW5oU2g2q/quRUHkZheshP5w/2bopFfLXWRfbA+23oWU7/br3Yhl9chIjIGe26IyGzKb8Egt18dEQ4vd2ccPJ+GxPRcNPT1VNs16Lw0vA0GtPRXO5VP+mI34tMua9ByIrJmDDdEVKMCvd3xwrDW+tsyFFV6Q06pu3l/dCe0CKyNpIxcFXB0U8SlRmfd0UQ8uWwf5qyOxMp9sWp4K7+wSJOfhYgsE4eliKjGjerSAPGpl1HLzRkDWwVcdb+Xuws+Hd8VIxZuxZG4dDy5bD8eGdAUb/5+DDvOXLzq8XU9XTD5uua4p0dDuDn/G5RK75e17XQK/j6VgkAvd0y+rhk39iSyYdxbintLEVmsPecuYvTHO9RsKh0pPh7TraGaiRUZn45jCRnIzC3p2Wng64Fnh7RCE79aOBqfru4/EJOK/TGpKCr1l+6bB7qjV1Nu7ElkbbhxZhUYboishww9Pbl8v1r1+PZOoZh6Qwu1zUPpDTtX7DmPd/88oYaxKtPUvxY8XJ1wODYdg1sH4pPxXWroJyAiU2G4qQLDDZF12Rt9SU0rbxbgVeljpC7nky1n8MmWKDg6OqB1kDda15eLF3o2rYfQup5qJtageZtUUNrw9AA1O4uIrAfDTRUYbohsl+5PWmU1NRM/34W/jiXhvl6N8MqVdXWIyDoYev7mbCkisikSaqoqFp7Yu7H6+v3uGKTn5Ndgy4iopjDcEJFd6d2snppmnpVXiO92xZS572JWnppa/vfJFPy8P9bgXc2JyLJwKjgR2RXp1ZHem2k/HlIrId/bMwzrjibh482nceB8WpnHypo7Lw1vrYawOHWcyHqw5oY1N0R2R3Yl7zlnPS5l56NeLVdcyMors2aOv5ebmnIuM6t06/LIyspyjIgs//zNnhsisjuyIvLY7mH4YMMpFWwk0NzbsxHG9QxTO5cL+dz36d9n8MbqSCzfHYOolEwsuidCf39VioqK1YwtItIGe27Yc0NklzJy8jHvjxNo4l8Ld0aEwtO14s96G44nYco3+5CRW6DW1/l4XATaBvtU+NhLWXl4fXUkfj0Qh5dvaoN7eoSZ+acgsi/pnApeOYYbIjLGqaRMPPC/3TiTkgUPFye8e1cHDG1XX3+//Bn99WA8Zv96BCmZJUNcLk4O+PGR3mgXWnEQIiLjMdxUgeGGiIyVlp2Pyd/uxZaTKer2vT3C1N5YKZm5iErOxN7oVHW8eUBttTmo7GPVqJ4nVk3pi9puJb1CMRezMe+P4wjwdsdtnULUIoNEZDiGmyow3BBRdchWD2+sPoalW89cdZ/01Ewe2BwPD2iCnLwiDHtvC2JTL+P2TiF4d1RHrD4Uj+d/OIiMnJJ9sESrIC/c0TkUo7s31AcgIqocw00VGG6I6FqsOhiH9ZFJqOPpogqM/Wu7oXsTX4TV+3c7h91nL+Kuj7apDTt7Na2Hf05fUMc7NqiDIG93tUqybkNQmbH15ODmuLtbQ7g4VTwj62hcugpLfZv7qYJoQ4KYcyWvRWStGG6qwHBDRDXhvfUn1YaeQpbJeaR/Uzx1fQsVYFKz87DqYLyakSW1PEJ2M5/QpzFC63io0CQbff51LBE/7o1Vu5+LYB93PH1DSzWsVdGMrPzCIjz29V5sj7qAd0Z2wA1tg8rcL8f/t+0s7u7aEP1a+NfI+0BkKgw3VWC4IaKaUFhUjCnf7kNkfDpm3xqOPs39Kgwjy3ZGY/66k2XW2ynP1ckR3h5S41PyGKnXefmm1ujV9N/XlD/nL608jK93RKvbkn3evL097uraQN3+cvs5zPrlCAqkOwnAQ/2aqKDE9XvIWjDcVIHhhogscWq6rJi859wlVaQsF1lksF2ID27vHIKb2gXDzcURn/9zFgs3nNLX7jzYrwmeuRJQPtt6BrN+Pap6iXo39VNFzeLZIS0Rn3YZX20vCT1t6nvjaHzJAoUdQn3w/ujOaFjP86o2yelBpsDXcnVWqzUTaY3hpgoMN0RkzWQPrHf+OI5vrvTQSEAZ1bUhXlp5SNX4TB/aSoWet9Ycx+JNp/XPk9Dz3JBWeLh/E6w9kqgKnNMu56tgdH3rQBWiZKjqQmYeVu6PxY97z+NEYqbqAfKt5Qa/2q5qXaA+zfxV7U8D36sDEZE5MdxUgeGGiGzB2iMJeG5FSUDRGRkRirfvbK/fC2vJ5ii1sGAtVycsuLsTBrcJ1D9WCpSnLt+PHWcu6o95uzur3hpDzgyN/WqpKfHjezUyqmdHTju5BUUGFUYTlcZwUwWGGyKyFXGpl/Hksv3YefYiujX2xVf3d7+qhkZqfnxruar1d8qTU8CRuHT8tC9W7YSuq+np1sgXt3UOwZC2QWrmVXJmLpIzcnHofJpa62dv9CV97Y70HL15R/v/XLdH9vT6fs95fLolCgnpOXjjtna4vXOoyd6LfdGXcCk7D/1bBHAYzUYx3FSB4YaIbImEjwPnUxEe4gM3Z6drfp0AL/f/HHKSGqGV++Pw9ppjqv7H2dEBo7s1hLuLowpBEpKk80imyctGpHKiWbHnvBpSK02Kmp+7sVWFYSQztwA7oi6o1+/RpB6CfK4OZzq/HYzHlGX7VBF3Q19PTOrbGCMjGqgZZ2Q7GG6qwHBDRGQaiek5mPnzEaw5kmDQ40PremBSn8aqJ2jhhpJ6oIEt/fHMkJZIzc5XwSj6Yja2nirpHcov/PcU1SKwNvo298fNHYLVekE6skDi49+WBBvptcorKFk/SDZElan3MnSmG6aryP6YVHy44RQGtw7EyC6hVz1Wepxk+n75ACanz0+2nMGZC1l4aXjrSvcnI9NhuKkCww0RkWn9cSRBLWzooxY2dFXr9MjZRUJMSkYu0nPyVTAZGh6kX1xQNhh95vsDqv6mMtILI4slHopNK1MHJMNmUjQtCyHqgo2sBj17RLgqhJbQISFJSGiZe2d71K3letXr/7TvPJ7/4ZA+EPVo4os5t7dX9URnU7Lwyd9R+H73eYTV88TH93ZBI7+ShRrl1Pnqqkj9atWy7pDsOVZViKJrx3BTBYYbIiLLIDU8z644oHqAJBDJJdDbDRGNfNGvuZ9+1WdZ9HDrqQv482gCfjsUX6ZHR0iwmTuyg753RcLOF/+cxZu/H1MBSFaFnndXB3Rv7KvCldz/9tpj+GhTlHp854Z11PT4nPwi1fsjj5Op9KXPkD4eLvhwbGe14vRrv0WqBRiFfE95vVm3tFXF1eYmw4dS72SPBdnpDDeVY7ghIrJeCWk5ak0fmQovM7tGdAzGvLs6Vli3czg2TS2kGHVlFWjpWKnr6Qp3Z0fEpeWoY48NbIqnr2+J85cu48WVh/Sbo+qGzMZ0D1NrC8nwlXyP3s38sPlEsrpfiqKz8wpU2JG6o+UP9UBEmG+F7ZYApBs6M4acpqUXSsKWfF/ZyuNyXqEannugbxO0CS45j8lrSw/XqaRM9Gvhp2qnbA3DTRUYboiIrJ8MdZ1IyEDnhnUr3IpCJyu3ALN/PYof9p7Xz/ASbs6Oatr8rR1D9MfklPjLgTgcPJ+GUV0boEWgl77u5oWfDqmtMHRevy0cY7uHqedM/nafKmoO8HLDqil9ygQLqSOSLS9khWgJJbIlhqwp1LeZn36ITtpYUohdMitNhvOikrNUb9Kx+HSkl9pwtTxZc8jb3UWFH92yAJ6uTir4yNCd7F5fEWm3FH7LytfGFKLLz7DxeJJqu4So8s+VVbcPxKT+5+/F5sPNwoULMXfuXCQkJKBDhw54//330a1bt0of//333+Pll1/G2bNn0bx5c7z11lsYNmyYwd+P4YaIyP5Iz4ZMFVcrQGfkoVlA7SpnYJUnp0sZipKVpCdf10zNDtORcHLrwq2q10R6cOS1ZWq89PRIWNLV9JQmG6Z6ujmptlzOL6zye8trSliQINO3hT8kMizZEqWKqUvlNXi5O6sp/9IOIcN8E3o3UjVDMnOtjqcrjsanYcuJFGw5laKClG59Iz+vkk1gdV9llpvUT5V8dVOz1mTJgN8PxSMrr1A/VHdT+/oYGl5fFVZvOZGMbacvqB61VY/3UTP47DLcLF++HOPGjcPixYvRvXt3zJ8/X4WX48ePIyAg4KrH//PPP+jXrx/mzJmDm266Cd98840KN3v37kV4eLhB35PhhoiITO10ciYmfr4L5y6UFDKXJrO7ZNp7cB0PFRAk8JSfFu/h4qSChC5UhNb1VAGpdX0vFZYq6l2JuZiN73fHqB4SKdiWNYecHB3w++EEvLXmWIVtMQWZ9VZQWKzWK6qIFIG/dUd7tU6SXYYbCTRdu3bFBx98oG4XFRWhQYMGePzxxzFt2rSrHj9q1ChkZWVh1apV+mM9evRAx44dVUAyBMMNERGZg5xS49Ny1MKJcpFhn2Ht6qNro7plZlLJ0M2+aKnhKeldkUtlw0fVlVdQhOW7Y/DPqZQr+5WV9FrJDDTZZkN6gaQ3SIbc5HjSlfWJZHabbtFG3T5ncl16vq5vI9t0hKJLWF3VYyS9NDI7TXqBZFd73eu2DS4JWaZm6Plb00n5eXl52LNnD6ZPn64/5ujoiMGDB2Pbtm0VPkeOT506tcyxIUOGYOXKlZV+n9zcXHUp/eYQERGZmgQY6Z2Ry6DW/251UZ6smyMrSpuTq7OjWuNHLlWRWVcyXNUsoKS+yFBODlA73Ve0273WNN3nPiUlBYWFhQgMLPs/gNyW+puKyHFjHi9kCEuSnu4iPUNERERkmzQNNzVFeoakC0t3iYmJ0bpJREREZCaaDkv5+fnByckJiYmJZY7L7aCgiouQ5Lgxjxdubm7qQkRERLZP054bV1dXREREYP369fpjUlAst3v27Fnhc+R46ceLP//8s9LHExERkX3RfJcvKQ4eP348unTpota2kangMhtqwoQJ6n6ZJh4SEqLqZsQTTzyB/v37Y968eRg+fDiWLVuG3bt34+OPP9b4JyEiIiJLoHm4kandycnJmDFjhioKlinda9as0RcNR0dHqxlUOr169VJr27z00kt44YUX1CJ+MlPK0DVuiIiIyLZpvs6NFrjODRERke2ev+1ithQRERHZD4YbIiIisikMN0RERGRTGG6IiIjIpjDcEBERkU1huCEiIiKbwnBDRERENkXzRfy0oFvaR+bLExERkXXQnbf/a4k+uww3GRkZ6muDBg20bgoRERFV4zwui/lVxi5XKJbNOePi4uDl5QUHBweTpUkJSzExMVz12Mz4Xtccvtc1h+91zeF7bb3vs0QWCTbBwcFltmYqzy57buQNCQ0NNctryy+Q/1hqBt/rmsP3uubwva45fK+t832uqsdGhwXFREREZFMYboiIiMimMNyYiJubG2bOnKm+knnxva45fK9rDt/rmsP32vbfZ7ssKCYiIiLbxZ4bIiIisikMN0RERGRTGG6IiIjIpjDcEBERkU1huDGBhQsXolGjRnB3d0f37t2xc+dOrZtkkzZv3oybb75ZrUwpK0uvXLlS6ybZpDlz5qBr165qBe+AgACMGDECx48f17pZNmnRokVo3769fpGznj174vfff9e6WXbhzTffVH9HnnzySa2bYnNeeeUV9d6WvrRq1apG28Bwc42WL1+OqVOnqulue/fuRYcOHTBkyBAkJSVp3TSbk5WVpd5fCZNkPps2bcJjjz2G7du3488//0R+fj5uuOEG9f6TaclK6XKS3bNnD3bv3o3rrrsOt956K44cOaJ102zarl278NFHH6lgSebRtm1bxMfH6y9///03ahKngl8j6amRT7kffPCBft8q2Uvj8ccfx7Rp07Runs2STwI//fST6lUg80pOTlY9OBJ6+vXrp3VzbJ6vry/mzp2L+++/X+um2KTMzEx07twZH374IV577TV07NgR8+fP17pZNtdzs3LlSuzfv1+zNrDn5hrk5eWpT1yDBw8us2+V3N62bZumbSMylbS0NP1Jl8ynsLAQy5YtUz1kMjxF5iG9ksOHDy/zd5tM7+TJk6qEoEmTJhg7diyio6NRk+xy40xTSUlJUX+QAgMDyxyX28eOHdOsXUSmIj2RUpPQu3dvhIeHa90cm3To0CEVZnJyclC7dm3VI9mmTRutm2WTJDxK+YAMS5F5RzQ+//xztGzZUg1JzZo1C3379sXhw4dVLV9NYLghoio/5cofpJoeL7cncgKQ7nvpIVuxYgXGjx+vhgAZcEwrJiYGTzzxhKojk8kfZD5Dhw7VX5e6Jgk7YWFh+O6772psuJXh5hr4+fnByckJiYmJZY7L7aCgIM3aRWQKkydPxqpVq9QsNSl8JfNwdXVFs2bN1PWIiAjVq7BgwQJV8EqmIyUEMtFD6m10pOdd/v+Wmsnc3Fz195xMr06dOmjRogVOnTqFmsKam2v8oyR/jNavX1+mG19uc8ycrJXMMZBgI8Mjf/31Fxo3bqx1k+yK/A2REy2Z1qBBg9QQoPSS6S5dunRR9SByncHGvEXcp0+fRv369VFT2HNzjWQauHQjyz+Sbt26qap7KQicMGGC1k2zyX8gpZP/mTNn1B8lKXRt2LChpm2ztaGob775Bj///LMaH09ISFDHfXx84OHhoXXzbMr06dNVF778/5uRkaHe940bN2Lt2rVaN83myP/L5evGatWqhXr16rGezMSeeeYZtSaZDEXFxcWppVIkPI4ePRo1heHmGo0aNUpNlZ0xY4Y6Cci0wjVr1lxVZEzXTtYBGThwYJlgKSRcSvEamW5hOTFgwIAyxz/77DPcd999GrXKNskwybhx41TRpYRHqU+QYHP99ddr3TSiajt//rwKMhcuXIC/vz/69Omj1s2S6zWF69wQERGRTWHNDREREdkUhhsiIiKyKQw3REREZFMYboiIiMimMNwQERGRTWG4ISIiIpvCcENEREQ2heGGiDQlK/I6ODggNTW1xr+3fF+5yN43xrRVLiNGjDB7+4gswebNm9WKw8HBwer//ZUrV5r1+73yyiv6f2e6S6tWrYx6DYYbIqoxsurxk08+WeZYr1699Cv0akFWXj5x4oRBj9W19a677jJ7u4gsRVZWFjp06ICFCxfW2Pds27at+remu/z9999GPZ/bLxCR5hvQBgUFafb9pdcmICDAqLbKHlvc3JLsxdChQ9WlMvJv4cUXX8S3336remBlr6633nrrqi1cjOHs7HxNfxfYc0NENUL2pdq0aRMWLFig72o+e/bsVcNSsk+YBI5Vq1ahZcuW8PT0xJ133ons7Gx88cUXaNSoEerWrYspU6agsLCwzB9Y2bAvJCREbYjYvXt39drGOnDggNrDTDZa9Pb2RkREhNrXjIgqNnnyZGzbtg3Lli3DwYMHMXLkSNx44404efIkqkueK8NgTZo0UTu3R0dHG/V89twQUY2QUCPDP/Kpbvbs2eqYbKQnAac8CTLvvfee+mMpu2XffvvtuO2221ToWb16NaKionDHHXegd+/eavNa3R/Yo0ePqufIH8WffvpJ/YE9dOgQmjdvbnA75Q9pp06d1AaispOx7Dzv4uJiwneCyHZER0eroV35Kv/uhHzIkA2k5fgbb7xh9GvKBxP5kCMfbmRIatasWejbty8OHz6sPnQYguGGiGqE1NTIsI70xPxXd3N+fr4KF02bNlW3pefmyy+/RGJiImrXro02bdqo3pUNGzaocGPKP7DyGs8++6y+gNGYYERkbw4dOqR6UFu0aFHmuPSk1qtXT10/duwYWrduXeXrPP/883jzzTfV9dJDYO3bt1dhJywsDN999x3uv/9+g9rFcENEFkcCkC7YiMDAQDUcJcGm9LGkpCSD/8AaaurUqZg0aZIKU4MHD1Zd7KXbQkT/yszMVD2ce/bsUV9L0/17laGlyMhIVKWqf6fSYyv/tk+dOgVDMdwQkcUpPwwkNTkVHSsqKjL4D6wx01DHjBmD3377Db///jtmzpyphrpkWIyIypIhXPlgIR80ZOioItJja+xU7tLk3/fp06dx7733GvwchhsiqjHyR650EXBN/oE1hnxKlMtTTz2F0aNHq6EthhuyV5mZmWV6Tc6cOaNq0Xx9fdW/E6lTGzduHObNm6f+LSYnJ2P9+vVqSGn48OFGfz8ZUpZ1dWQoKi4uTn3AkA8t8m/RUJwtRUQ1RoaWduzYoYqIU1JS9D0v16r0H9gff/xR/fHduXMn5syZo3pgDHX58mVVmCyzrM6dO4etW7di165d/1kvQGTLdu/erUKLXHRDt3J9xowZ6raEf/m39/TTT6siYFngUv7dNGzYsFrf7/z58yrIyGvJmlIyZLV9+3Y1AcFQ7Lkhohojn8jGjx+vCoIlSEgIMRX5A/vaa6+pP7CxsbHw8/NDjx49cNNNNxn8GvLp8MKFC+oPtRQvy2vITC2ZrUFkrwYMGIDi4uJK75chY/k3Yqp/JzIMfK0ciqtqMRGRDZO6HZkybuxWCrJmj6zLY+5l6ImoejgsRUR2Tbq/Q0NDDXrsli1bVIHy119/bfZ2EVH1seeGiOyWrkhShqMaN278n4+XoTQZ8hIScrTcNoKIKsdwQ0RERDaFw1JERERkUxhuiIiIyKYw3BAREZFNYbghIiIim8JwQ0RERDaF4YaIiIhsCsMNERER2RSGGyIiIrIpDDdEREQEW/L/Wj8oviJpDA4AAAAASUVORK5CYII=", "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": "214f8043", "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.21" }, "myst": { "substitutions": { "BasicTransmonElement": "{class}`~quantify_scheduler.device_under_test.transmon_element.BasicTransmonElement`", "Cluster": "{class}`~qblox_instruments.Cluster`", "ConditionalReset": "{class}`~quantify_scheduler.backends.qblox.operations.gate_library.ConditionalReset`", "Measure": "{class}`~quantify_scheduler.operations.gate_library.Measure`", "MeasurementControl": "{class}`~quantify_core.measurement.control.MeasurementControl`", "QuantumDevice": "{class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice`", "ReadoutCalibrationAnalysis": "{class}`~quantify_core.analysis.readout_calibration_analysis.ReadoutCalibrationAnalysis`", "Reset": "{class}`~quantify_scheduler.operations.gate_library.Reset`", "RuntimeError": "{class}`~RuntimeError`", "Schedule": "{class}`~quantify_scheduler.schedules.schedule.Schedule`", "ScheduleGettable": "{class}`~quantify_scheduler.gettables.ScheduleGettable`", "T1Analysis": "{class}`~quantify_core.analysis.single_qubit_timedomain.T1Analysis`", "ThresholdedAcquisition": "{class}`~quantify_scheduler.operations.acquisition_library.ThresholdedAcquisition`", "readout_calibration_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.readout_calibration_sched`", "t1_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.t1_sched`" } }, "source_map": [ 23, 69, 82, 123, 130, 147, 151, 184, 194, 255, 287, 297, 305, 309, 318, 325, 345, 386, 407, 458, 471, 527, 553, 562, 568, 574 ] }, "nbformat": 4, "nbformat_minor": 5 }