{ "cells": [ { "cell_type": "markdown", "id": "52c775f0", "metadata": {}, "source": [ "(sec-tutorial-schedulegettable)=\n", "\n", "# Tutorial: ScheduleGettable\n", "\n", "```{seealso}\n", "The complete source code of this tutorial can be found in\n", "\n", "{nb-download}`ScheduleGettable.ipynb`\n", "```\n", "\n", "This tutorial covers the {class}`~quantify_scheduler.gettables.ScheduleGettable` in-depth. If you're looking for more information on how to set up an experiment in general, please see {ref}`sec-tutorial-experiment`.\n", "\n", "The {class}`~quantify_scheduler.gettables.ScheduleGettable` forms the top-level interface to {mod}`quantify_scheduler`. Under the hood, it uses `quantify-scheduler` modules to compile {ref}`Schedules `, run them on your hardware and retrieve measurement data from the hardware. As the {class}`~quantify_scheduler.gettables.ScheduleGettable` uses functions that return {class}`~quantify_scheduler.schedules.schedule.Schedule`s, you can dynamically set function parameters during experiments.\n", "\n", "For those familiar with [quantify-core](https://quantify-os.org/docs/quantify-core), the interface of the {class}`~quantify_scheduler.gettables.ScheduleGettable` is also designed to be used as a [gettable](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#settables-and-gettables) for [MeasurementControl](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#measurement-control). This is convenient for large, possibly multi-dimensional measurement loops, as is demonstrated in {ref}`2D (and ND) measurement loops`.\n", "\n", "Two things are always required when using a {class}`~quantify_scheduler.gettables.ScheduleGettable`: a {ref}`QuantumDevice ` and a function that returns a {class}`~quantify_scheduler.schedules.schedule.Schedule`. We will set these up in a few example scenarios below and show how to use the {class}`~quantify_scheduler.gettables.ScheduleGettable`. More commonly used schedule functions are also included in `quantify-scheduler` out of the box. You can find them in {mod}`~.quantify_scheduler.schedules.spectroscopy_schedules`, {mod}`~.quantify_scheduler.schedules.timedomain_schedules` and {mod}`~.quantify_scheduler.schedules.trace_schedules`.\n", "\n", "(sec-schedulegettable-1dsweep-usage)=\n", "\n", "## 1D iterative measurement loop\n", "\n", "\n", "```{admonition} Setup and hardware configuration\n", "The device setup and hardware configuration for this tutorial can be viewed in the collapsed code cells. In places where you would communicate with actual hardware, dummy objects have been used. If you want to learn more about how to set up the {class}`~quantify_scheduler.device_under_test.quantum_device.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": "09233972", "metadata": { "mystnb": { "code_prompt_show": "Set up the quantum device, dummy hardware and hardware configuration" }, "tags": [ "hide-cell" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Data will be saved in:\n", "/root/quantify-data\n" ] } ], "source": [ "from qblox_instruments import Cluster, ClusterType\n", "from quantify_core.data import handling as dh\n", "\n", "from quantify_scheduler import BasicTransmonElement, InstrumentCoordinator, QuantumDevice\n", "from quantify_scheduler.qblox import ClusterComponent, start_dummy_cluster_armed_sequencers\n", "\n", "# First, don't forget to set the data directory!\n", "dh.set_datadir() # change me!\n", "\n", "# We define a single transmon qubit as an element (BasicTransmonElement) of the\n", "# QuantumDevice, and populate the parameters with some reasonable values.\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)\n", "\n", "# For this example, we will set up a Qblox cluster hardware setup with two modules: a\n", "# QRM-RF and a QCM-RF.\n", "\n", "# Note: 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.\n", "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", "# Temporarily fixing dummy cluster's deficiency.\n", "cluster.start_sequencer = lambda : start_dummy_cluster_armed_sequencers(ic_cluster)\n", "\n", "# We create an InstrumentCoordinator to control the cluster and add it to the\n", "# QuantumDevice.\n", "\n", "instrument_coordinator = InstrumentCoordinator(\"instrument_coordinator\")\n", "instrument_coordinator.add_component(ic_cluster)\n", "\n", "single_qubit_device.instr_instrument_coordinator(instrument_coordinator.name)\n", "\n", "# A basic hardware configuration will be used for the two cluster modules.\n", "\n", "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\": {\n", " \"instrument_type\": \"QRM_RF\"\n", " },\n", " \"2\": {\n", " \"instrument_type\": \"QCM_RF\"\n", " }\n", " },\n", " \"ref\": \"internal\"\n", " }\n", " },\n", " \"hardware_options\": {\n", " \"modulation_frequencies\": {\n", " \"q0:res-q0.ro\": {\n", " \"lo_freq\": LO_FREQ_READOUT\n", " },\n", " \"q0:mw-q0.01\": {\n", " \"lo_freq\": LO_FREQ_QUBIT\n", " }\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", "\n", "# This hardware configuration should also be added to the quantum device.\n", "single_qubit_device.hardware_config(hardware_cfg)" ] }, { "cell_type": "markdown", "id": "de709b43", "metadata": {}, "source": [ "For this experiment, we have set up a basic {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice` called `single_qubit_device`, representing a single transmon qubit.\n", "\n", "We'll now define the schedule function. A valid schedule function must contain a `repetitions` (integer) parameter (see {ref}`Repetitions`), and can contain any number of additional parameters. It must return a {class}`~quantify_scheduler.schedules.schedule.Schedule` object.\n", "\n", "The schedule function can be parameterized to loop over different values. The parameters can be scalars or arrays. For example, the schedule function defined below takes an array of values for the parameter `times`. This is called a _batched_ measurement, as will be explained further in this tutorial." ] }, { "cell_type": "code", "execution_count": 2, "id": "53f8c91a", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations import Measure, Reset, X\n", "\n", "def t1_sched(times, repetitions=1):\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(Reset(\"q0\"), label=f\"Reset {i}\")\n", " schedule.add(X(\"q0\"), label=f\"pi {i}\")\n", " # Measure tau seconds after the start of the X gate\n", " schedule.add(\n", " Measure(\"q0\", acq_index=i),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule" ] }, { "cell_type": "markdown", "id": "12da35a6", "metadata": {}, "source": [ "Now, let's create the {class}`~quantify_scheduler.gettables.ScheduleGettable`. The {class}`~quantify_scheduler.gettables.ScheduleGettable` provides a convenient way to compile and execute schedules in just a few lines of code. The parameters can be set directly, with arrays and scalars, or through QCoDeS parameters, as shown below." ] }, { "cell_type": "code", "execution_count": 3, "id": "2e4f6a3b", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "from qcodes.instrument.parameter import ManualParameter\n", "\n", "from quantify_scheduler import ScheduleGettable\n", "\n", "# The points we want to measure.\n", "times = np.linspace(start=1.6e-7, stop=4.976e-5, num=125)\n", "\n", "# As QCoDeS parameter:\n", "time = ManualParameter(\"sample\", label=\"Sample time\", unit=\"s\")\n", "# Set the parameter. This can be done even after defining the gettable!\n", "time(times)\n", "\n", "# Or as array:\n", "time = times\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=single_qubit_device,\n", " schedule_function=t1_sched,\n", " schedule_kwargs={\"times\": time},\n", " batched=True\n", ")" ] }, { "cell_type": "markdown", "id": "cffac368", "metadata": {}, "source": [ "Note that `batched=True` here. This means we are doing a _batched_ measurement, which simply means that we tell the {class}`~quantify_scheduler.gettables.ScheduleGettable` to expect an array of values in the acquisition result. In this case, our schedule function creates one schedule for an array of times, and it includes an acquisition (the {class}`~quantify_scheduler.operations.gate_library.Measure` operation) for each point." ] }, { "cell_type": "code", "execution_count": 4, "id": "61879a2e", "metadata": { "mystnb": { "code_prompt_show": "Provide the dummy hardware with acquisition data" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "import xarray\n", "\n", "from quantify_scheduler.waveforms import soft_square\n", "\n", "from qblox_instruments import DummyScopeAcquisitionData, DummyBinnedAcquisitionData\n", "\n", "\n", "soft_sq_samples = round(q0.measure.integration_time() * 1e9)\n", "soft_sq_times = np.arange(soft_sq_samples)\n", "soft_sq = soft_square(t=soft_sq_times, amp=0.5)\n", "scope_data_real = np.zeros(16384) # Scope trace acquires 16384 points\n", "scope_data_real[:soft_sq_samples] = soft_sq\n", "scope_data_real += np.random.randn(16384) / 500 # add some \"noise\"\n", "\n", "# Create dummy scope data with the soft square pulse on the I path and noise on\n", "# the Q path\n", "scope_data = list(zip(scope_data_real, np.random.randn(16384) / 500))\n", "\n", "dummy_scope_acquisition_data = DummyScopeAcquisitionData(\n", " data=scope_data, out_of_range=(False, False), avg_cnt=(0, 0)\n", " )\n", "\n", "ic_cluster.instrument.set_dummy_scope_acquisition_data(\n", " slot_idx=1, sequencer=None, data=dummy_scope_acquisition_data\n", ")\n", "\n", "\n", "# Dataset with T1 experiment data\n", "example_dataset = xarray.open_dataset(\"../examples/dataset.hdf5\")\n", "\n", "def get_dummy_binned_acquisition_data(real: float, imag: float):\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=0, avg_cnt=0)\n", "\n", "ic_cluster.instrument.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) * 1024, float(im) * 1024)\n", " for re, im in zip(example_dataset[\"y0\"], example_dataset[\"y1\"])\n", " ],\n", ")" ] }, { "cell_type": "markdown", "id": "2df3fc19", "metadata": {}, "source": [ "Let's now run the experiment and retrieve the acquisitions using the {meth}`~quantify_scheduler.gettables.ScheduleGettable.get` method." ] }, { "cell_type": "code", "execution_count": 5, "id": "c476f843", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "\n", "data = gettable.get()\n", "\n", "plt.plot(times, data[0], '.', label=\"real\")\n", "plt.plot(times, data[1], '.', label=\"imaginary\")\n", "plt.legend()\n", "plt.xlabel(\"Idle time (s)\")\n", "plt.ylabel(\"Voltage (V)\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "5d76246d", "metadata": {}, "source": [ "Note that the data used here is the same as in {ref}`sec-tutorial-experiment`. The example dataset can be downloaded {download}`here <../examples/dataset.hdf5>`.\n", "\n", "As we defined 125 points in our `times` array which were measured in 125 different `acq_index`es, the acquisition result also contains 125 _I_ values (in `data[0][:]`) and 125 _Q_ values (in `data[1][:]`). The general format of the data returned by the {class}`~quantify_scheduler.gettables.ScheduleGettable` is also explained in the {ref}`user guide `.\n", "\n", "## Trace measurement\n", "\n", "The previous experiment's acquisition results had one data point for each acquisition in the schedule. For a trace measurement, the data format is slightly different. To illustrate this, let us set up an experiment with a trace measurement." ] }, { "cell_type": "code", "execution_count": 6, "id": "08c4c26c", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.operations import IdlePulse, SoftSquarePulse\n", "\n", "\n", "def trace_schedule(pulse_amp, acq_delay, port=\"q0:res\", clock=\"q0.ro\", repetitions=1):\n", " schedule = Schedule(\"Trace a pulse\", repetitions=repetitions)\n", "\n", " schedule.add(\n", " SoftSquarePulse(\n", " duration=q0.measure.integration_time(),\n", " amp=pulse_amp,\n", " port=port,\n", " clock=clock,\n", " ),\n", " label=\"trace_pulse\",\n", " )\n", "\n", " # Add acq_delay to compensate for time-of-flight of the pulse\n", " schedule.add(\n", " Measure(q0.name, acq_protocol=\"Trace\"),\n", " ref_pt=\"start\",\n", " rel_time=acq_delay,\n", " label=\"acquisition\"\n", " )\n", "\n", " return schedule" ] }, { "cell_type": "markdown", "id": "f7966581", "metadata": {}, "source": [ "Again, we define the gettable and run the experiment." ] }, { "cell_type": "code", "execution_count": 7, "id": "3b9b82d3", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/compiler_abc.py:670: RuntimeWarning: Operation is interrupting previous Pulse because it starts before the previous ends, offending operation: Pulse \"SquarePulse\" (t0=1.0000000000000001e-07, duration=3e-07)\n", " warnings.warn(\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAABW1klEQVR4nO3deVwU9f8H8NeCghy6oMil3B5oIiAK4n1Q5m2ZmpUo3zK/pZbSJR3a9RVNLUot0/Ko7zchS81feWSkeUSKKImpqAhCCiQeiwKJwfz+wF1YmF12gb2G1/PxoGRmdua9s8PMa2c+8xmZIAgCiIiIiCTCytQFEBERETUlhhsiIiKSFIYbIiIikhSGGyIiIpIUhhsiIiKSFIYbIiIikhSGGyIiIpKUFqYuwNgqKytx5coVtG7dGjKZzNTlEBERkQ4EQcCtW7fg6ekJKyvt52aaXbi5cuUKvLy8TF0GERERNUBeXh46duyodZpmF25at24NoGrltGnTxsTVEBERkS6Ki4vh5eWlOo5r0+zCjfJSVJs2bRhuiIiILIwuTUrYoJiIiIgkheGGiIiIJIXhhoiIiCSF4YaIiIgkheGGiIiIJIXhhoiIiCSF4YaIiIgkheGGiIiIJIXhhoiIiCSF4YaIiIgkheGGiIiIJIXhhpq9fEUZfs0qQr6izNSl6M2Sa6cqTf0ZNmR+3I5IaprdgzOJakpKzUXc1gxUCoCVDIh/OAhT+niLTpuvKEN2UQn8XBzgIbfTOKwpaZu/ptrrq6kpaq49D33naYjpa04DANlFJXCwsUZJeYXq//q+Z0OvS322P0PNryGvaertvjHzM/TfIFkmmSAIgqmLMKbi4mLI5XIoFAo+FbyZy1eUof+Sn1FZ4y/AWibD1mcjVQdCoOog+euFIqzelwUBVQeAVx4MRNHtO/jsYDaUL48bGYhZgwPU5n8s5zpkMhnCfJwBQO33mjtisbCw/lA2PjuUDUEAZAAWjAzEuBBPHMu5jptld7Houz/UarcCMC7EE9+lX4GAqtc8OyQA/Tu7qOb76YEsLNl1FkKNA9mgLu31Cg4Hzl1VHQxlAAZ2dsGhC0Wq35V11gwXddbl/iytNeQryrD3dAGKbpejuOwuNqVcgnJP9Vi4F6b08ULu9VLVuqxZkzbKdRLo0Vrtc1C+v5r17vj9impdKd9Xzc/30wNZWLLzrOrzfyzcC3OHd9YagmqGrdzrpXg+MV2tZhmAt8ffh6jubhrnU3sbUg67dL0UK/acQ81VoMv8xP4GDi0YWmd65XJSLl5H4tFc1ec9c6AfRvf0UPs86gu8mran2iFd+b7K/6nE8EBXBHs5q81j/aFsfH4ou8nCIZk3fY7fZhFuVq9ejWXLlqGgoADBwcFYuXIlwsPDRafduHEjYmJi1IbZ2tri77//1mlZDDfSVPPgodzJejnbqX1br3lg8HK2w9Gc6/jPD2frzEsGqA4QNf+ti+mRPghwdcCePwpx+MI1rdOOD/bEglGB+N9vl7BqX5ZqeISfM45m39Brubro7OqI83/dVhsmu/cf5V5g9r0wpDwIl5X/g/8dycW+s1cbvE70IQMwsoc7dp4qMNASxJe3648C6LInjPB1RkRAO+TfLMOWtMui0wwPbI8hXV0R1d0NANQOwPqYEOKBMN+2cLa3QZiPM3b8fgXxO6u3VxmAh3t1wNbjl3X6PGqGwptld+FsbwMAmPPViTrTPhTqiRn9fBHs5Yzf827gvd1ncTjrus61D+3aHvvPXa0TDGsHEuX7qF3/hBohvaYAF3s81Ksjrij+xuYjuaLv+/PpYejuKdd45g4Az/RYKIsKN0lJSYiOjsaaNWsQERGBhIQEbNmyBZmZmXB1da0z/caNG/H8888jMzNTNUwmk8HNzU2n5THcSE/NsxFiZAAi/dvi14u675yJCJDbtYCi7J8mmVeYtxPScm82ybyaAs/0WB6LCjcRERHo06cPVq1aBQCorKyEl5cX5s6diwULFtSZfuPGjZg3bx5u3rzZoOUx3Jg/Te05ap6VUZ76XrbnLFbXOOtBRKQrTZfgyDzpc/w2aYPi8vJypKWlIS4uTjXMysoKUVFRSElJ0fi627dvw8fHB5WVlejVqxcWL16M++67T3TaO3fu4M6dO6rfi4uLm+4NUJOr3bjxodAO2Hbisugp/e4erXE6/5bxiyQiSagQBKz95SLCfJ3rtIMjy2bSW8GLiopQUVFR55KSm5sbCgrEr7l37doV69evx3fffYf//ve/qKysRL9+/fDnn3+KTh8fHw+5XK768fLyavL3QU0jX1Gm1ii0UgC+PS4ebAAw2BBRo234NQdzvjqByPif8ekvPAssFRbXz01kZCSio6MREhKCwYMHY+vWrWjfvj0+/fRT0enj4uKgUChUP3l5eUaumOqj7GNj5c/n9W50SUTUVOJ3ncWyPXVvMiDLY9LLUi4uLrC2tkZhYaHa8MLCQri7u+s0j5YtWyI0NBQXLlwQHW9rawtbW9tG10qGUfMyFBGRqa3el4U/b5RhwchAALyzylKZNNzY2NggLCwMycnJmDBhAoCqBsXJycmYM2eOTvOoqKhARkYGRo0aZcBKyRBqX4Yypd4+TvCQt4K9TQs4O7RE+T8CbFrIcOpyMQ5fuKbWb0w3jzb45Jcs/HGluv1WVzdHZBbe1jj/xnBxtEHR7XK1ZV34qwQV9+4FGNzJBSE+TujZUY5tx6/g+4x8g9ShqwkhHgBk2J5+pdHzmh7pg7sVAjYfVb/td3hgezwW4Y2y8krcLCuHouwurt0ux/rDOY1eZm0yAI9FeOMrDbceN0d9/Z0R3NEJnx7INviyeni2wZn8W6rt3Ri+S7+C72psv7yzyvKYvIfi2NhYTJ8+Hb1790Z4eDgSEhJQUlKi6ssmOjoaHTp0QHx8PADg7bffRt++fdGpUyfcvHkTy5Ytw6VLl/DUU0+Z8m1QA2QXlRg12FgBeGVkIHp2dIKviz0AIKeoFL4u9lq/leUryupMNybYE7/n3cCxnBvo7euMYC9nfHogC0t3nVV1bqbsP8YKwDNDAnCj9C4SU3M1vufZQwPg3dYer249hQpBUIWplx4MrLMssZoAoLunHDtP5dfpGK5mXzY19fZxQs+OThgf4gnXNq2QU1SKk5dvqr2PZ4cEYEDn9igtv4ucolL09nWGa5tWSMu5gZSL17D5XoduyvWr7Ogupr8vJnz8q9pyrQBMjfBWvaY2ZZ8ntTvNmzu8E9JybkAmA3ppafjZ1b014r7NQOW9ecwc5IfRQR4oLa+Er4s9/ir+G+sOZKvWkQzA1Hud7/1V/DeO5dxA3o1SfJFyCZVC1d00ix/ugSl9vDFnWCdsOJSDzw5dVL3fPn7OSM25ofr9qUF+sLG2wsf7s0Tfn7VMhmAvOY438JZo2b3P0Vomw6AuLtiXeVW1Xl8ZGYgOTnaQyYCOznYoLa+EvY0VfjhZoFbzK/c6Waz5XmT35l9z3UMGVSeFtf92lHcxrjso3n+PDMD4EA/09m2Lb9L+RHqeQjUupKMcMwf5q2r0dbHHjt+vqLa5qs4oPeDTzgHD7nXcp9zeD1+4qtYnlHJZSyYG4WbpXcTvqntJ6bVRgdifeRWHs7T3O6VNpQC8uvUUBnVpzzM4FsLkt4IDwKpVq1Sd+IWEhOCjjz5CREQEAGDIkCHw9fXFxo0bAQDz58/H1q1bUVBQAGdnZ4SFheHdd99FaGioTsvireCmp7y1+8dTBdiYcqnJ5vv0ID/E9Pers6N85t7Bub4Q0xRqhg6gbnhSjj95+SaW7jyrOgjXPJBrCi66SkrNVQUk5cEZgGqY8iAc099Pa4/EutagbVqxWpS9z+YUlcLexgp518tUoUVsnelLl9rrm0bb+NrjxKat+f6UIUN5IPeQ26nCqq+LPextWqq2l5oB7sC5q3XW3aAu7etdtj7vV9ftVdP8a3++Lz/YVS0AKdUO5w393JTT/XS6ENlFJfBv74Dh3ap7X675BaPm9lZ7XEO9M/4+TIv0bfgMqFEsqp8bY2O4Ma2maGMT4eeMozk31Lrjr93tfWMDgjEYskZtB1xjrxNL+CzMlSWsO3OrUZdg+ueNErz0TUaD5j+xVwesmBzSBJWSvhhutGC4MZ3f825gwupfG9xuQQZg++x+Wi/LEBHpIik1Fwu+zWjQ/mjZI0GY1Jvtb4yN4UYLhhvjUz5PZt3Bhjc+rH2KmYiosfIVZdhwKAdrD17U+7UhHeWY2Luj6tlf/JJleAw3WjDcGFdjvh1ZAVg3PUzVJoE7DyIyhHxFGeZtPoEjOTcaPI+nB/ohZoDmdmzUeAw3WjDcGE++ogz9l/ysV/saKxlEGwMSERna8j1n69yNpQ/eMm5YFvNsKZK2tEs39Ao2E3t1wIsjurItDRGZxIsjAvF4Xx/VXWs/ZORjZ4b4o4DE8JZx88FwQwaRlJqLV77V/W6Ez6eHYXi3ql6puVMgIlPxkNthTHDVPmh0z6r+rN7Y/gdOXlbU88oqFYKAnKJS7sdMzOKeLUXmL19RpnOwsQKwdGKQKtgQEZmTYC9n7Jg7AJ9PD9P5NaXldw1YEemCZ26oyS3ddabeaVZNDUU7R1tefiIii2Bno/vh8slNaYgbGYigjnI+l8pEGG6oyeQryvBR8nlsT6//2UZebe009lRKRGRu/FwcVDc86EL5KAg2MjYNXpaiJpGUmot+8T9j89E8naYvLa80cEVERE3HQ26H+IeD9D5oKhsZ5yvKDFIXiWO4oUbLV5RhwVbd+7KxlslUz7IhIrIUU/p443DcMDw90F/1sFFdKBsZk/HwshQ12svfnBR94rQYZf81vAZNRJbIQ26HV0d3Q8wAX6Tl3MD//X4Fe04X1vs6exueSzAmduJHjbLlWK5OD6CbbcQncxMRGdOnB7IQv/Os1mlkAJZMZNubxmAnfmQUL3ydjm+PX9Y6zYjubnhz/H0MNEQkWbMGBaCvX1uMX/2rxmkEAK98mwEH2xZ8FpUR8DwZ6S1fUYYvUrLrDTYRvs74NLo3/4iJSPKCvZzx9EC/eqeb89UJ9F/yM5JSc41QVfPFcEN6SUrNRf8lP2Phd6frnTZhaqgRKiIiMg8xA/x0amjMO6gMj+GGdJavKEPc1gyd+nmIGxXIMzZE1Kx4yO2wYGSgTtPyDirDYrghnWUXlegUbGYPDcCsQQGGL4iIyMzMGhyA2UPr3//JwDuoDIlrlnSW8Wf9D46LGxmIl0bo9s2FiEiKXhoRWG/AEQA89PGvbHtjIAw3pJN8RRmW7tZ+q+N3s/th1mCesSEi0iXgsO2N4TDckE42HMrWeknq8QhvPiuKiKgGXQJOhSAgLeeGkSpqPhhuqF75ijKsPZitdZpI/3ZGqoaIyHL07+RS7zTPJZ7g5akmxnBD9dpwSHuwkQEI8+VZGyKi2vxcHOq9PZyXp5oeww1plXymoN6zNgt42zcRkSgPuR2WTAyqN+Dw1vCmxXBDGr3wdTqe3JSmdZq4kYG87ZuISIspfbzxa9wwvDP+Pq3Tnbx80zgFNQMMNyTq97wb9T5egXdHERHpxkNuh2mRvpg9RPM+M37nWV6aaiIMNyRq3YGLWsc/PdCfd0cREenppQcDEeGned+5MvmCEauRLoYbqiNfUYbvMwq0ThMzwNc4xRARScyro7ppHLf5aC7P3jQBhhuqY8ku7Z318blRREQNV1JeoXGcAJ69aQoMN6Tm01+y8F36FY3j2YCYiKhx/FwcYKXl9qmvjuZi2R7tXzJJO4YbUslXlCFey1kbNiAmImo8D7kd4h8O0noAXr0vC58eyDJaTVLDcEMq2UUlGsfx8QpERE1nSh9vfPRYqNZplu7i3VMNxXBDKofPF2kcN2dYJyNWQkQkfWE+zlo796sUwOdONRDDDQGouiT18X7xU6BPD/RnA2Iioiam7L1Ym7l87lSDMNxQ1a3fJ69A7KHfMvC2byIiQ5nSxxvfze6ncbwgAHHfZvDylJ4Ybpq5pNRc9F/yM/7zg3hD4un9fHjWhojIgIK9nLX2XFwJYMOhHKPVIwUMN81YvqIMcVszUCl2yuYeL2d74xVERNRMvfRgIALdHTWOX3fwIs/e6IHhphnLLirRGmwAoLcv75AiIjKGpRN7ahwngGdv9MFw04w52FhrHR/h15a3fxMRGUmwlzNG9nDXOP6zQzx7oyuGm2Ys6Vie1vEJj4YYpxAiIgIATIv00TiuUgByikqNWI3lYrhppj79JQtfHdEcbvj8KCIi4/NzcdDa983JyzeNVYpFY7hphup7zAKfH0VEZBr19X2zZCd7LdYFw00zpO2p3zH9fPn8KCIiE5rSxxurNDyagQ2LdcNw08zU99TvCaGeRqyGiIjEeDlrbhawlreF14vhphnJV5RpPWszKsidd0cREZmBkvIKreNX/XzBSJVYJoabZiS7qET0EQsAMD3SBx8/HmbUeoiISFx9DYu/OpLLszdaMNw0I9r+WP6tpetvIiIyrvoaFgvgE8O1YbhpRg6cu6rxzA37TiAiMi9T+ngjJW4Y+ge0Ex1/s6zcyBVZDoabZiJfUYZXvs0QHWclA3xd+AwpIiJz4yG3w/LJwaJn3d/Y/geSUnONXpMlYLhpJrQ1JH5qgD877CMiMlOaLlEJABZ8m8G2NyIYbpoBbbd/ywDEDPA1aj1ERKSfQV3aiw5n2xtxDDcSV19vxAv4mAUiIrN3LOe6xnFse1MXw43EZReVaBw3orsbH7NARGQBZDLNN4Z/k3bZiJVYBoYbidtzqkDjuLHB7I2YiMgShPlo7mA1Pe8mlu/RfIa+OWK4kbBPf8nCppRLouNkAMJ82RsxEZEl8JDbYamWfm9W7ctiw+IazCLcrF69Gr6+vmjVqhUiIiJw9OhRnV6XmJgImUyGCRMmGLZAC8S2NkRE0jKljzc+n665J3k+ULOaycNNUlISYmNjsWjRIhw/fhzBwcEYMWIE/vrrL62vy8nJwYsvvoiBAwcaqVLLoq2tzYQQT7a1ISKyQMO7uWNkD3fRcWsPXsTvebxzCjCDcPP+++9j5syZiImJQffu3bFmzRrY29tj/fr1Gl9TUVGBxx9/HG+99Rb8/f21zv/OnTsoLi5W+2kO/FwcNI57ZWSgESshIqKmtHBsd43jxq/+lR37wcThpry8HGlpaYiKilINs7KyQlRUFFJSUjS+7u2334arqyuefPLJepcRHx8PuVyu+vHy8mqS2s3dDg392sTxchQRkUXTdmYeYMd+gInDTVFRESoqKuDm5qY23M3NDQUF4nf5HDp0CJ9//jnWrVun0zLi4uKgUChUP3l5eY2u29xpa2/Ts4OTcYshIqImVd8Tw9mxnxlcltLHrVu3MG3aNKxbtw4uLi46vcbW1hZt2rRR+5G6lcnnRYfzGVJERJavvieGA0DKxWtGqsY8tTDlwl1cXGBtbY3CwkK14YWFhXB3r9tgKisrCzk5ORg7dqxqWGVlJQCgRYsWyMzMREBA824om68ow1dHxc9OPdrHm5ekiIgkYEofbwS6t8b41b+Kjt98NBdzhnVqtvt8k565sbGxQVhYGJKTk1XDKisrkZycjMjIyDrTBwYGIiMjA+np6aqfcePGYejQoUhPT2827Wm0+el0ocZxc4d3MmIlRERkSMFezojTcINIpQDkFJUauSLzYdIzNwAQGxuL6dOno3fv3ggPD0dCQgJKSkoQExMDAIiOjkaHDh0QHx+PVq1aoUePHmqvd3JyAoA6w5ujpNRcvPHdH6LjJoR4NtsET0QkVUEd5RrHnbx8E5EB7YxYjfkwebiZMmUKrl69ioULF6KgoAAhISHYvXu3qpFxbm4urKwsqmmQSeQryvDKtxkax0d1c9M4joiILJOfiwOsZFVnamp7b1cmxgU3zy+2MkEQRFaJdBUXF0Mul0OhUEiqcfGvWUV4bN0RjeNT4oY1yw2ciEjqklJzEfdtBipFxm2e2VcyZ2/0OX7zlIhEaOu0b87QAAYbIiKJmtLHG88MFb+ZprneIctwIxH/+038AZkje7jjxRHskZiISKryFWX4eF+W6Lgdv4t36Cp1DDcSELPxKFaJbNjTI33wyROaH7JGRESWL7uoBJral8TvPNsseytmuLFwy3afxb6zV0XHffnbpWa5URMRNSf19Vi8MvmC0WoxFww3FixfUYbV+8VPRQLs54CIqDmor8fir47mNrsvugw3Fqy+h6fxcQtERM3DlD7e+G52P43jl2p43qBUMdxYMG13SAHAUwP8eZcUEVEzEezljOGB7UXHbU+/0qzO3jDcSJQMQMwAX1OXQURERvTc8M4ax81LTDdeISbGcGPBNhzK1jhuwahAnrUhImpmgr2cEe7rLDruSPZ1/J53w8gVmQbDjYXKV5Rh3UHxcDN7aABmDWreT0cnImquPpwaqnHcsRyGGzJjGw5li/Zr8Fi4N15ip31ERM2Wh9wOs4eIf8G9UVpu5GpMg+HGAmk7azN3eCcjV0NERObmpQcDMVSkcfHq/VnNomExw40F0tQbpbZOnIiIqHmZ2KtjnWGCABy/JP1LUww3Fqis/B/R4QLYaR8REVURBPGHMnyRIv4sQilhuLEwSam5eHJTmug4dtpHRERKvX3big4/kn0dyWcKjFyNcTHcWJB8RRkWfJuhcfwrI3n7NxERVfGQ22FMkLvouCc3pSEpNdfIFRkPw40F0fbk14dCPHn7NxERqZk5yF/juLitGZJtXMxwY0G0PW5heDc3I1ZCRESWINjLGQM7u4iOk/LDlRluJEAGIExDj5RERNS8vfhAF9HhUm6nyXBjQZ75r3hD4scivNnWhoiIROVeFz8707Ojk2SPHQw3FmLZ7rNIz1OIjov0b2fkaoiIyFLIZOK9oKXn3cSyPWeNXI1xMNxYgHxFGVbvz9I4npekiIhIkzAfzceI1fuy8OkBzccXS8VwYwGyi0o0jpszNECypxWJiKjxPOR2iBup+ZmDS3edldxdUww3FiDjT/HLUUMD2+NFPiSTiIjqMWtwAMaHeIqOqxSANIk9LZzhxszlK8oQv0v8mujih4KMXA0REVmqBVrO3szdfEJSnfox3Ji55zef0DhOqv0TEBFR0/OQ2+HpgX6i4wRIq1M/hhsz9nveDRzVcKpQyv0TEBGRYcQM8IP4vVPS6tSP4caMHc25rnEcnyNFRET68pDb4dkh4o/qkdKXZoYbM3az5K7o8BmRPnyOFBERNUh/DY9jGNDJRTJfmhluzJSmvm2GBrbHm+N7mKAiIiKSAj8XB9FLU4cuFLHNDRnW0l1nRIcPD3Q1ciVERCQlHnI7zBRpWMw2N2RQ+YoybE/PFx33V/EdI1dDRERSM7qnh+hwextpxAJpvAuJ0dYj8fBuPHNDRESNU1JeITq8tLzSyJUYBsONGXKwsRYdPqxrewR78TlSRETUOH4uDrASaXiz9qA0njPFcGOGfjgpfklqJu+QIiKiJuAht8Mzg+seU/advYo3vztlgoqaFsONmclXlGHtwew6w6XU/wAREZmek0NL0eEbUy5Z/JPCGW7MTNol8R6Jp4Z7S6b/ASIiMr1w37Yax1n6k8IZbszMJ/suiA6P9G9n5EqIiEjKgr2cEe4r3o7T0m8LZ7gxIzM2HMUf+bfqDJcBCNOwARIRETXUh1NDNY7bc0q8/aclYLgxE7/n3cD+zKui40YHefCSFBERNTltTwq35LY3DDdmQttDMmcOEt/wiIiIGkvbk8Itte0Nw42Z0NSwi33bEBGRIXnI7bBgZKDoOEtte8NwYya+SLlUZ1hXN0esjwk3QTVERNSczBocgKGB7UXHnbx807jFNAGGGzPwe94NfHv8cp3h5/+6bZGnA4mIyLLkK8rwi4Z2n+/tyrS4YxHDjRlYd+Ci6HBLPR1IRESWJbuoBJWC+LgKQbC4YxHDjYnlK8rwfUaB6Dj2SkxERMag6ZmGQFV3JJZ2LGK4MbFjWu6Sin84iLeAExGRwWl6SrilYrgxMZlM/Aa8dyfchyl9vI1cDRERNUeanhIOAAKAtBzxRwOZK4YbE7t8o24jLZkMGN7NzQTVEBFRc+Qht0P8w0EaQ8GczSeQlJpr1Joag+HGhPIVZVi6+2yd4QtGBvJyFBERGdWUPt44HDcME0I8RcfHbc2wmLumGG5MSFPr9J4dnIxeCxERkYfcDvd1aCM6zpLu4GW4MaE9p8TvkrK34cdCRESmoanHfEu6a4pHURP59JcsbBLplRgASssrjVwNERFRlWAvZ0zs1aHOcAHAgXPiHf2ZG4YbE8hXlGHJrrptbQD2bUNERKb34oiuosMtpd2NWYSb1atXw9fXF61atUJERASOHj2qcdqtW7eid+/ecHJygoODA0JCQvDll18asdrG23AoGxo6gsQrbExMREQmll1UIjrcUtrdtNBn4ps3b2Lbtm04ePAgLl26hNLSUrRv3x6hoaEYMWIE+vXrp3cBSUlJiI2NxZo1axAREYGEhASMGDECmZmZcHV1rTN927Zt8dprryEwMBA2Njb4/vvvERMTA1dXV4wYMULv5RtbvqIMaw9maxw/Lli8lToREZGx+Lk4aBxnCe1CdarwypUreOqpp+Dh4YF3330XZWVlCAkJwfDhw9GxY0fs27cP999/P7p3746kpCS9Cnj//fcxc+ZMxMTEoHv37lizZg3s7e2xfv160emHDBmChx56CN26dUNAQACef/559OzZE4cOHdJruaaiKQ0rWUIiJiIiafOQ2+HpgX6i45JS/zRyNfrT6cxNaGgopk+fjrS0NHTv3l10mrKyMmzfvh0JCQnIy8vDiy++WO98y8vLkZaWhri4ONUwKysrREVFISUlpd7XC4KAn3/+GZmZmVi6dKnoNHfu3MGdO3dUvxcXF9c7X0PSlobZ3oaIiMzF6J4eolcavjqaCx8Xe8waFGCCqnSjU7g5ffo02rVrp3UaOzs7TJ06FVOnTsW1a9d0WnhRUREqKirg5qbeG6+bmxvOnhVvcAsACoUCHTp0wJ07d2BtbY2PP/4Y999/v+i08fHxeOutt3Sqxxi0tTR/aoA/29sQEZFZ0Pa8qaW7zmJcsKfZHrN0uizVrl07fP/996is1O0W5fqCUGO1bt0a6enpSE1NxX/+8x/ExsZi//79otPGxcVBoVCofvLy8gxamzb5ijIs+DZDdJwVgJgBvkath4iISBM/FwdoeNyU2Tcs1rlB8YQJE+Dm5oYZM2YgJiYGnTp1avTCXVxcYG1tjcLCQrXhhYWFcHd31/g6Kysr1fJDQkJw5swZxMfHY8iQIXWmtbW1ha2tbaNrbQpLd53RfJfUKN4lRURE5sNDbocFIwMRr6HrEnNuWKxzZdnZ2Zg1axYSExPRtWtXDB48GF9++SXKyhp+v7uNjQ3CwsKQnJysGlZZWYnk5GRERkbqPJ/Kykq1djXm6NNfsrA9PV/jeD5ygYiIzE1QR7nGcebc4azO4cbLywsLFy5EVlYWfvrpJ/j6+uKZZ56Bh4cH/v3vfyM1NbVBBcTGxmLdunXYtGkTzpw5g2eeeQYlJSWIiYkBAERHR6s1OI6Pj8fevXtx8eJFnDlzBitWrMCXX36JJ554okHLNwZtnfYBbEhMRETmSdulqZOXbxqzFL3o1c+N0tChQzF06FCsWrUKiYmJ2LhxI/r27YsePXrg999/12teU6ZMwdWrV7Fw4UIUFBQgJCQEu3fvVjUyzs3NhZVVdQYrKSnBs88+iz///BN2dnYIDAzEf//7X0yZMqUhb8UosotKNF6OkgGIfziIl6SIiMjseMjtsGRiEF4RaS8av9N8GxXLBEHQdNzVycWLF7F+/Xp88sknKC4uxt27d5uqNoMoLi6GXC6HQqFAmzbiTz5tavmKMvSL/1k04Hw3ux+CvZyNUgcREVFDfPlbDt7Y/ked4RNCPJHwaKhRatDn+N2g1kBlZWX44osvMGTIEHTu3BmJiYmIjY1FTk5OQ2YneR5yO0yN8BIdZ87XLImIiADA2d5GdPj29Cv49ECWkaupn16XpX777TesX78eX3/9NcrLy/Hwww/jp59+wtChQw1VnyQkpebiqyN1b0G3lsnY1oaIiMxemI/mKwzm2OeNzuGme/fuyMzMRGhoKOLj4/HYY49BLtfcipqq5CvKRK9VAsDLI7ua1cZA0lZRUWH2l41JPzY2NmptEokMxUNuh8fCvfDV0bpf1JV93pjT8UzncBMVFYXNmzcjODjYkPVIzsrk8xrH8fZvMgZBEFBQUICbN2+auhRqYlZWVvDz84ONjfglA6KmNHd4Z9FwA5jfHb86h5uPPvrIkHVIUr6iTOOGwNu/yViUwcbV1RX29vaQyTTd2EmWpLKyEleuXEF+fj68vb35uZLBecjtEKehU78dv18xq2dN6RRuHnzwQbz55pvo27ev1ulu3bqFjz/+GI6Ojpg9e3aTFGjJtD0B/NkhAWZ1Co+kqaKiQhVsDP1YFDK+9u3b48qVK/jnn3/QsmVLU5dDzYCmTv3Mrd2NTuFm0qRJmDhxIuRyOcaOHYvevXvD09MTrVq1wo0bN3D69GkcOnQIO3fuxOjRo7Fs2TJD120RlJ0fid0C3r9Te2OXQ82Qso2NvT3PEkqR8nJURUUFww0Zhabjmrm1u9Ep3Dz55JN44oknsGXLFiQlJWHt2rVQKBQAAJlMhu7du2PEiBFITU1Ft27dDFqwJTlw7qposOFdUmRsvGQhTfxcydg85HZ4sIc7dp0qUBsug3k1tdC5zY2trS2eeOIJ1WMOFAoFysrK0K5dO35jEKHtCeC8S4qIiCxRvqIMe/4oqDNcALB8TyZWTA4xek1iGnwPoVwuh7u7O4ONBtoeucC7pIhMIycnBzKZDOnp6aYuhcgiZReVoFLDwe3b45fxe94N4xakATtIMBBNDxvjXVJERGSptD1IEwCO5TDcSJpYexs+JJOo4crLy01dAlGz5yG3w4KRgRrHm8uXd4YbA9DWK/GgLrxLiixXvqIMv2YVIV9RZvBlDRkyBHPmzMG8efPg4uKCESNG4NSpUxg5ciQcHR3h5uaGadOmoaioSPWa3bt3Y8CAAXByckK7du0wZswYZGWZ33NviCzZrMEBiBslHnCe3JSGpNRcI1dUF8ONARzLuS46XEDVrXJEligpNRf9l/yMx9YdQf8lPxtlB7Zp0ybY2Njg8OHDWLJkCYYNG4bQ0FAcO3YMu3fvRmFhISZPnqyavqSkBLGxsTh27BiSk5NhZWWFhx56CJWVfEAtUVOaNSgAn08PEx0XtzXDKF+AtNHrwZlKN2/exDfffIOsrCy89NJLaNu2LY4fPw43Nzd06NChqWu0OClZ10SHs70NWap8RRnitmaoGhJWCsCrW09hUJf2Br3M2rlzZ7z33nsAgHfffRehoaFYvHixavz69evh5eWFc+fOoUuXLpg4caLa69evX4/27dvj9OnT6NGjh8HqJGqOLmroqNYc+rzR+8zNyZMn0aVLFyxduhTLly9XPa9m69atiIuLa+r6LI62Ry68MjKQ7W3IIondIVEhCAY/ExkWVv3N8Pfff8e+ffvg6Oio+gkMrDo1rrz0dP78eUydOhX+/v5o06YNfH19AQC5uaY/TU4kNeG+bTWOO3zhqhErqUvvcBMbG4sZM2bg/PnzaNWqlWr4qFGjcODAgSYtzhKlXRJvKf5QiKdZPXeDSB9+Lg6wqnWLhDE6o3RwcFD9+/bt2xg7dizS09PVfs6fP49BgwYBAMaOHYvr169j3bp1OHLkCI4cOQKAjZGJDCHYyxkDO7uIjvt4f5ZJL03pHW5SU1Mxa9asOsM7dOiAgoK6Hfs0Nz+dFl8HYb7ORq6EqOl4yO0Q/3AQrO/1iGstk2Hxwz2MeiayV69e+OOPP+Dr64tOnTqp/Tg4OODatWvIzMzE66+/juHDh6Nbt264ccM8bkslkqoXH+giOlx5acpU9G5zY2tri+Li4jrDz507h/btm/edQPmKMmxPzxcd52RnY+RqiJrWlD7eGNSlPXKKSuHrYm/0S6yzZ8/GunXrMHXqVLz88sto27YtLly4gMTERHz22WdwdnZGu3btsHbtWnh4eCA3NxcLFiwwao1EzU1JeYXGcfY2prtnSe8ljxs3Dm+//bbqgXwymQy5ubl45ZVX6jTma240PQVcBp65IWnwkNshMqCdSdqOeXp64vDhw6ioqMADDzyAoKAgzJs3D05OTrCysoKVlRUSExORlpaGHj16YP78+XyIL5GBaevUr7TcdHcpygRB0PSUAFEKhQKPPPIIjh07hlu3bsHT0xMFBQWIjIzEzp071a6Rm6Pi4mLI5XIoFAq0adOmSeedryhDv/if63TeFzcqkO1tyCT+/vtvZGdnw8/PT62NHEkDP18yB5/+koX4XWfrDJ89NAAvjdDc4Z++9Dl+631ZSi6XY+/evTh06BBOnjyJ27dvo1evXoiKimpwwVLx398uiT5Palywp9FrISIiMoZZgwNQ/PddrN6n3mHm6n1ZaGPX0iRf7hvUzw0ADBgwAAMGDGjKWizap79k1flglUx9vz8REZEhBbq3Fh2+dNdZjAv2NPoxUO9w89FHH4kOl8lkaNWqFTp16oRBgwbB2tq60cVZinxFmegpOYAd9xERkfTJZOItb0zVoZ/e4eaDDz7A1atXUVpaCmfnqkayN27cgL29PRwdHfHXX3/B398f+/btg5eXV5MXbI40NSQGgEf7ePOsDRERSVqYj/hNM6b6gq/33VKLFy9Gnz59cP78eVy7dg3Xrl3DuXPnEBERgQ8//BC5ublwd3fH/PnzDVGvWXKw0XyWau7wTkashIiIyPg85HZYOjFI7c4pmQyIfzjIJF/w9T5z8/rrr+Pbb79FQEB1A6FOnTph+fLlmDhxIi5evIj33nuvWd0Wruk+/6cH+vOsDRERNQvKvrDScm5AJgN6+Tib7Biod7jJz8/HP//8U2f4P//8o+qh2NPTE7du3Wp8dRZC2TV9zWfvWAGIGeBrqpKIiIiMzkNuhzHBpv9Sr/dlqaFDh2LWrFk4ceKEatiJEyfwzDPPYNiwYQCAjIwM+Pn5NV2VZk6sa/r4iaY5FUdERNTc6X3m5vPPP8e0adMQFhaGli1bAqg6azN8+HB8/vnnAABHR0esWLGiaSs1c6bump6IiIiq6B1u3N3dsXfvXpw9exbnzp0DAHTt2hVdu3ZVTTN06NCmq9CCeMjtGGqImsiQIUMQEhKChIQEk9bh6+uLefPmYd68eSatg4h01+BO/AIDAxEY2HTdKhMR1bR161bV2WFTSk1NNfvHyhCRugaFmz///BM7duxAbm4uysvL1ca9//77TVIYETVvbdu2NXUJAID27dsbfBnl5eWwsbEx+HKImgu9GxQnJyeja9eu+OSTT7BixQrs27cPGzZswPr165Genm6AEonIbCguA9kHqv5vYEOGDFFdCvL19cW7776L6OhoODo6wsfHBzt27MDVq1cxfvx4ODo6omfPnjh27Jjq9deuXcPUqVPRoUMH2NvbIygoCJs3b1Zbxq1bt/D444/DwcEBHh4e+OCDD9SWq1x2zUtjMpkMn332GR566CHY29ujc+fO2LFjh2p8RUUFnnzySfj5+cHOzg5du3bFhx9+qLbcGTNmYMKECfjPf/4DT09PdO3aFW+//TZ69OhRZz2EhITgjTfeaMSaJGp+9A43cXFxePHFF5GRkYFWrVrh22+/RV5eHgYPHoxJkyYZokYiMgfHvwASegCbxlb9//gXRl38Bx98gP79++PEiRMYPXo0pk2bhujoaDzxxBM4fvw4AgICEB0dDUGo6pPh77//RlhYGH744QecOnUKTz/9NKZNm4ajR4+q5hkbG4vDhw9jx44d2Lt3Lw4ePIjjx4/XW8tbb72FyZMn4+TJkxg1ahQef/xxXL9+HQBQWVmJjh07YsuWLTh9+jQWLlyIV199FV9//bXaPJKTk5GZmYm9e/fi+++/x7/+9S+cOXMGqampqmlOnDiBkydPIiYmpilWIVHzIejJ0dFRuHDhgiAIguDk5CScOnVKEARBSE9PF3x8fPSdndEpFAoBgKBQKExdCpHBlZWVCadPnxbKysoaN6ObfwrCm06CsKhN9c+bzlXDDWTw4MHC888/LwiCIPj4+AhPPPGEalx+fr4AQHjjjTdUw1JSUgQAQn5+vsZ5jh49WnjhhRcEQRCE4uJioWXLlsKWLVtU42/evCnY29urlqtc9gcffKD6HYDw+uuvq36/ffu2AEDYtWuXxuXOnj1bmDhxour36dOnC25ubsKdO3fUphs5cqTwzDPPqH6fO3euMGTIEI3zbbLPl8gC6HP81vvMjYODg6qdjYeHB7Kyqp+EXVRU1BR5i4jMzfUsQKhUHyZUANcvGq2Enj17qv7t5uYGAAgKCqoz7K+//gJQdXnonXfeQVBQENq2bQtHR0fs2bMHubm5AICLFy/i7t27CA8PV81DLper3fmpSy0ODg5o06aNarkAsHr1aoSFhaF9+/ZwdHTE2rVrVctVCgoKqtPOZubMmdi8eTP+/vtvlJeX46uvvsK//vWveushInV6Nyju27cvDh06hG7dumHUqFF44YUXkJGRga1bt6Jv376GqJGITK1tACCzUg84Mmugrb/RSqh555TyCcRiwyorq2pctmwZPvzwQyQkJCAoKAgODg6YN29enZsgGluLctnK5SYmJuLFF1/EihUrEBkZidatW2PZsmU4cuSI2mvE7sAaO3YsbG1tsW3bNtjY2ODu3bt45JFHGl0vUXOjd7h5//33cfv2bQBV151v376NpKQkdO7cmXdKEUmVvAMw9kPg/+ZVnbGRWQNjE6qGm6nDhw9j/PjxeOKJJwBUhZ5z586he/fuAAB/f3+0bNkSqamp8Pb2BgAoFAqcO3cOgwYNatRy+/Xrh2effVY1rOYZbm1atGiB6dOnY8OGDbCxscGjjz4KOzv2nUWkL73Djb9/9Tc1BwcHrFmzpkkLIiIz1SsaCBhedSmqrb9ZBxsA6Ny5M7755hv8+uuvcHZ2xvvvv4/CwkJVuGndujWmT5+Ol156CW3btoWrqysWLVoEKysr1Vmghi73iy++wJ49e+Dn54cvv/wSqampOj+S5qmnnkK3bt0AVAUlItKf3m1u/P39ce3atTrDb968qRZ8iEiC5B0Av4FmH2wA4PXXX0evXr0wYsQIDBkyBO7u7pgwYYLaNO+//z4iIyMxZswYREVFoX///ujWrRtatWrV4OXOmjULDz/8MKZMmYKIiAhcu3ZN7SxOfTp37ox+/fohMDAQERERDa6DqDmTCYIg1D9ZNSsrKxQUFMDV1VVteGFhIby9vXHnzp0mLbCpFRcXQy6XQ6FQoE2bNqYuh8ig/v77b2RnZ8PPz69RB+zmoqSkBB06dMCKFSvw5JNPmqQGQRDQuXNnPPvss4iNjdU6LT9fak70OX7rfFmqZidVe/bsgVwuV/1eUVGB5ORk+Pr66l8tEZGJnDhxAmfPnkV4eDgUCgXefvttAMD48eNNUs/Vq1eRmJiIgoIC9m1D1Ag6hxvl6VyZTIbp06erjWvZsiV8fX2b3ZPAicjyLV++HJmZmbCxsUFYWBgOHjwIFxcXk9Ti6uoKFxcXrF27Fs7OziapgUgKdA43ytsc/fz8kJqaarI/fiKiphIaGoq0tDRTl6GiZysBItJA77ulsrOzDVEHERERUZPQKdx89NFHOs/wueeea3AxRGQYPCMgTfxcicTpFG4++OADnWYmk8kYbojMiLIn3dLSUnYGJ0HK3patra1NXAmRedEp3PBSFJFlsra2hpOTk+q5R/b29o3qoI7MR2VlJa5evQp7e3u0aKF3CwMiSWvUX4TylCh3lkTmy93dHQDUHuxI0mBlZQVvb2/ug4lqaVC4+eKLL7Bs2TKcP38eANClSxe89NJLmDZtWpMWR0SNJ5PJ4OHhAVdXV9y9e9fU5VATsrGxgZWV3h3NE0legx6c+cYbb2DOnDno378/AODQoUP497//jaKiIsyfP7/JiySixrO2tmbbDCJqFvR+/IKfnx/eeustREdHqw3ftGkT3nzzTbNvn8PHLxAREVkefY7fep/PzM/PR79+/eoM79evH/Lz8/WdHREREVGT0jvcdOrUCV9//XWd4UlJSejcuXOTFEVERETUUHq3uXnrrbcwZcoUHDhwQNXm5vDhw0hOThYNPbpYvXo1li1bhoKCAgQHB2PlypUIDw8XnXbdunX44osvcOrUKQBAWFgYFi9erHF6IiIial50PnOjDBMTJ07EkSNH4OLigu3bt2P79u1wcXHB0aNH8dBDD+ldQFJSEmJjY7Fo0SIcP34cwcHBGDFihMbbVvfv34+pU6di3759SElJgZeXFx544AFcvnxZ72UTERGR9OjcoNjKygp9+vTBU089hUcffRStW7dukgIiIiLQp08frFq1CkBVx1ReXl6YO3cuFixYUO/rKyoq4OzsjFWrVtVp5CyGDYqJiIgsj0EaFP/yyy+477778MILL8DDwwMzZszAwYMHG1VoeXk50tLSEBUVVV2QlRWioqKQkpKi0zxKS0tx9+5dtG3bVnT8nTt3UFxcrPZDRERE0qVzuBk4cCDWr1+P/Px8rFy5EtnZ2Rg8eDC6dOmCpUuXoqCgQO+FFxUVoaKiAm5ubmrD3dzcdJ7fK6+8Ak9PT7WAVFN8fDzkcrnqx8vLS+86iYiIyHLofbeUg4MDYmJi8Msvv+DcuXOYNGkSVq9eDW9vb4wbN84QNWq0ZMkSJCYmYtu2bWjVqpXoNHFxcVAoFKqfvLw8o9ZIRERExtWoZ0t16tQJr776Knx8fBAXF4cffvhBr9e7uLjA2toahYWFasMLCwtVz8PRZPny5ViyZAl++ukn9OzZU+N0tra2sLW11asuIiIislwNfijJgQMHMGPGDLi7u+Oll17Cww8/jMOHD+s1DxsbG4SFhSE5OVk1rLKyEsnJyYiMjNT4uvfeew/vvPMOdu/ejd69ezf0LRAREZEE6XXm5sqVK9i4cSM2btyICxcuoF+/fvjoo48wefJkODg4NKiA2NhYTJ8+Hb1790Z4eDgSEhJQUlKCmJgYAEB0dDQ6dOiA+Ph4AMDSpUuxcOFCfPXVV/D19VW1zXF0dISjo2ODaiAiIiLp0DncjBw5Ej/99BNcXFwQHR2Nf/3rX+jatWujC5gyZQquXr2KhQsXoqCgACEhIdi9e7eqkXFubq7aU28/+eQTlJeX45FHHlGbz6JFi/Dmm282uh4iIiKybDr3czNu3Dg8+eSTGDNmjEU/WZj93BAREVkefY7fOp+52bFjR6MLIyIiIjK0BjcoJiIiIjJHDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkMN0RERCQpDDdEREQkKQw3REREJCkmDzerV6+Gr68vWrVqhYiICBw9elTjtH/88QcmTpwIX19fyGQyJCQkGK9QIiIisggmDTdJSUmIjY3FokWLcPz4cQQHB2PEiBH466+/RKcvLS2Fv78/lixZAnd3dyNXS0RERJZAJgiCYKqFR0REoE+fPli1ahUAoLKyEl5eXpg7dy4WLFig9bW+vr6YN28e5s2bp3W6O3fu4M6dO6rfi4uL4eXlBYVCgTZt2jT6PRAREZHhFRcXQy6X63T8NtmZm/LycqSlpSEqKqq6GCsrREVFISUlpcmWEx8fD7lcrvrx8vJqsnkTERGR+TFZuCkqKkJFRQXc3NzUhru5uaGgoKDJlhMXFweFQqH6ycvLa7J5ExERkflpYeoCDM3W1ha2tramLoOIiIiMxGRnblxcXGBtbY3CwkK14YWFhWwsTERERA1msnBjY2ODsLAwJCcnq4ZVVlYiOTkZkZGRpiqLiIiILJxJL0vFxsZi+vTp6N27N8LDw5GQkICSkhLExMQAAKKjo9GhQwfEx8cDqGqEfPr0adW/L1++jPT0dDg6OqJTp04mex9ERERkPkwabqZMmYKrV69i4cKFKCgoQEhICHbv3q1qZJybmwsrq+qTS1euXEFoaKjq9+XLl2P58uUYPHgw9u/fb+zyiYiIyAyZtJ8bU9DnPnkiIiIyDxbRzw0RERGRITDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwQERGRpDDcEBERkaQw3BAREZGkMNwYi+IykH2g6v/NRXN8z0REZHItTF2AZCkuA9ezgLYBQFYy8H/PA0IlILMCxn4I9Iqu/3XyDnV/N1e16zz+Rd33HDBc83tRXAbyjlT92ytC83ttivVhbuvU0PXoum6NXZclasg6aex65OfQ/BjiM9c0T32WVXNaoOrfLR2AuyXV/zeT7ZThxhBqHtghuzdQuPe/SuD/5gGu9wE3L1UNUx5wageCno8CJxPvzQfAwBeA4QurD1al1wH7tnUPWMoNsKVD9TKcfNSXB1RNU14KXLsAeEcCrd3rHgTFwlbNaQDgyCfAr6uq3+PAF4BDH1TXLVQCO54DZLLq9xb1JuAZWlXjiS+BtA01VqAMGPdRdQBU1nAlHfhpUfV67TcHiHim7h/Sn2lAbkr1e6pZ/+GPgJ8WAoKgXkd9f/A116nyD1i5Dmv/Wyy4aZqu9rZy/1uAz4Dq+juGaa5JF8e/qFr3ys8GAMatrNr+zu0GrG2Bdv51tyGxuvo/r/l9iW0rys+hXSfAxl69bk2BS9cdsLbplPN18tG8s609Xe2/RU3rsuY60bT9aVz/97brgOFA5q6qv7t2nYCuI3VfZtgMwK1H9d89UHe71LQuFZerlnu7EOjyoPq2pa/a27Ryf6Qktl8Se72mA6LY/IHq96x8Hx3Cqrat+vZ1un5x0rZN1q61Zo23CsT/ZvUhup9D3f1+Q+rT9AVbbfsCEDQJ6DpKfP6164IMavsVpfq+wBuJTBAEkeqMa/Xq1Vi2bBkKCgoQHByMlStXIjw8XOP0W7ZswRtvvIGcnBx07twZS5cuxahRo3RaVnFxMeRyORQKBdq0adNUb6GKcuex8wX9X3v/28BPb9bYcDRw9gduXBR/vc8A4NeVwJnv6p+Ppg2zps4PAOf3Vk/n0w+4lFL/65rKqBVA0Tng6Foty6x1kNn2DPD7V+LT+UQCl37VMJsaQefM9+rL9OkH5P4msk5rrsMa/w6aVFXP3RItO4R7B6rjm7R/VsGPAQ99AiS/AxxcUf3afnOqPu/LadUBpaV99e8AUFoEHFmjZd3VEjYDCI2uOjB8+2Tduu5/B+j/XNW/D38E7H2jelzNdSSzAtx7AvnptVbXvXV8PbtWmAUQOBqoqAAu/Ki+U+/9JHBgGZC2sep91An9NQ74eUeAjK9F3liNUJF3pOpvVHQ6VC/Xf4j6N9IrJ4CdL0J0XYbNAAa9XPXvml86nHyAz4aLv6a2+98G5F7qX1gAIKFHPX/Ltf+OZcDA2Kr5KNcZAHToDVw+pv7SbhOA+8ZX/bv2l5maX3o6hqkfWBV/AnsX6va+lOuyZrC/+AtwaEXVF4yagiYBXn2BwlPqtTe1sBj1gKj8klH7S8D9bwOQVX8ZUpHd2xf+Kl5jtwmA38Cq9WfvAtg5VQ1XbhO1vxypvuBtFJ8foB7YlDXc/xZQchVIWV1rG1HWd1h9WO3tZNRyYNdLGrYvbfPXhQx4KrlxAVqEPsdvk4ebpKQkREdHY82aNYiIiEBCQgK2bNmCzMxMuLq61pn+119/xaBBgxAfH48xY8bgq6++wtKlS3H8+HH06NGj3uUZLNyI/XGQcYU8BqSLBRsL5xFSNyiYSveHqwLnX6dMXYn0+Q0Gsn8x3vI6PwBc2Fs3dDi6VZ0lkaqgydrDrsHo8AXT0o1b2aRncCwq3ERERKBPnz5YtWoVAKCyshJeXl6YO3cuFixYUGf6KVOmoKSkBN9//71qWN++fRESEoI1a9bUuzyDhBvFZeCD7k0zLyIiIqmYf7rJ2uDoc/w26d1S5eXlSEtLQ1RUlGqYlZUVoqKikJKSIvqalJQUtekBYMSIERqnv3PnDoqLi9V+mpzydC0RERFVO7DMJIs1abgpKipCRUUF3Nzc1Ia7ubmhoKBA9DUFBQV6TR8fHw+5XK768fLyapriiYiISLvjm0zSHYjk+7mJi4uDQqFQ/eTl5TX9QpSN/4iIiKiaUAlcF7kJxsBMGm5cXFxgbW2NwkL1xmqFhYVwd3cXfY27u7te09va2qJNmzZqP01O3uFey3oiIiJSkVkDbf2NvliThhsbGxuEhYUhOTlZNayyshLJycmIjIwUfU1kZKTa9ACwd+9ejdMbTf/nq26VVfVrg6p+XbqPN1lJBuHS1dQVWK6WDqauwEBk9U+iDzuXpp0fGY9nbyBwjO7TdwxHk28/lsqrr6kraAQNn6HMGhibYJJO/UzeiV9sbCymT5+O3r17Izw8HAkJCSgpKUFMTAwAIDo6Gh06dEB8fDwA4Pnnn8fgwYOxYsUKjB49GomJiTh27BjWrl1ryrdRpf9zQI+JQN7Rqt+9wqv7jjiyBkhZVd03R+Bo4OwPqHMrYPgsoNvY6qRbc15A3fkA1fMImgy4B93rL6eiesNyvQ/4fHjdvhqmJgI2DlX9o9zMVe+Eq+wmUHEH6DLiXkd4F6tqUnXkd68uJ++qvlzO/6jeR4kaWY2O/Sqqfg+fCbRoVeO9WAED5wNuQTX6+gi/1/nUvOr3E7VIpD+gJr6lctArQIdeVeum5udQeh3I+w3I2KL/8sKfBvrP09BvSe36rYDuY4HTO9SHB00GTn1T972PWlH1ee17R6Qu5bytgPvfBPYu0r/22vN7Kll9mwCq/t3SvmpbuF1Ytd389YdI9wgi7/WR9VXb0d3S6vl9cF/dOh/4D/Dj63XnF/Fvzf353P820OMR9b5ygKovHlFvAZ69qrf/zJ31fLay6r5YAKAwQ3PfJEMXVvdvomk6n/6a+0oRW7Y+n9ugV6o+g7uldT+XzJ3AweW6z0tpahKweYr4uPseBiLnVPdrcvijWv07iZBZA5M2Vv07c/e9/sFqbRujlt/rH8Yb+DxKt/5WlPsJubf6vuRWAXBqC/CbHn0/1d7HKoU8Dljb1Ppca/Vh1da/el+s7fOTyYCx9/phEtvuldyCq/aRyveSsgo4vb16/xk2var7ACfvqu05+5ca/Wgp9yn/B+DeOgx5rKpvJStlR57hwKlvdezD6N5+xzNE/e+25nFBOdxEvRWb/FZwAFi1apWqE7+QkBB89NFHiIioascyZMgQ+Pr6YuPGjarpt2zZgtdff13Vid97771nHp341UdxWT0kHP+i+sCtPPjU7gW2vvkA6vMUWw6gvixl6GnqHiSVy724Hzj0/r0O3WosS6wusWHa3m/t9aacf8Dw6gBi3xZQ5KmHvKhF6gcyoPqPWbkT1nW91AmrVlWd6jm0r7EzuxfW/IfW/zkEDK8OBzV3CDVDpDIoa/scNT7yota62/E8qnZw97Y5uXfV6528q3aWNd9X5yjgwk/6rZ/a66rme6gdVjXNr3ad42r2qCry+tp/S/3mVIWeOr0X11qfYvUqPwvldqJtR117W9D0npTLrnmwFf3ic+8z6fFI3S821y9WdSZYexur2Rs4UFXDvAztBxVlPdm/1N9hnsYebWVAv7l113PtdancT9W3nurbR9X+jGt/GdL1gKo2H7H3W2N/0dZffZutvZ/WZ18MqB/8a+6Hau4fam73A+cD9u2qArVYh3j17T9rj9dnf1tzPw7ZvXwmGO74oQOL6ufG2EwabsTosrFxWQ2bv641NLTWpgpr+tL2+qZYfkN2iE1Vvy7T6TvcGAz5mdY3bWO/uNQMXkrawkJj3qu+256+4xtSByD+5cIQy9W3NlM/o6m+8GZkDDdamF24ISJqLHM6IBIZiD7Hb5O3uSEiokaSd2CoIapB8v3cEBERUfPCcENERESSwnBDREREksJwQ0RERJLCcENERESSwnBDREREksJwQ0RERJLCcENERESSwnBDREREksJwQ0RERJLCcENERESS0uyeLaV8TmhxcbGJKyEiIiJdKY/bujzvu9mFm1u3bgEAvLy8TFwJERER6evWrVuQy+Vap5EJukQgCamsrMSVK1fQunVryGSyJp13cXExvLy8kJeXV+/j2KnhuJ6Ng+vZeLiujYPr2TgMtZ4FQcCtW7fg6ekJKyvtrWqa3ZkbKysrdOzY0aDLaNOmDf9wjIDr2Ti4no2H69o4uJ6NwxDrub4zNkpsUExERESSwnBDREREksJw04RsbW2xaNEi2NramroUSeN6Ng6uZ+PhujYOrmfjMIf13OwaFBMREZG08cwNERERSQrDDREREUkKww0RERFJCsMNERERSQrDjZ5Wr14NX19ftGrVChERETh69KjW6bds2YLAwEC0atUKQUFB2Llzp5EqtWz6rOd169Zh4MCBcHZ2hrOzM6Kiour9XKiKvtuzUmJiImQyGSZMmGDYAiVE33V98+ZNzJ49Gx4eHrC1tUWXLl24/9CBvus5ISEBXbt2hZ2dHby8vDB//nz8/fffRqrWMh04cABjx46Fp6cnZDIZtm/fXu9r9u/fj169esHW1hadOnXCxo0bDVukQDpLTEwUbGxshPXr1wt//PGHMHPmTMHJyUkoLCwUnf7w4cOCtbW18N577wmnT58WXn/9daFly5ZCRkaGkSu3LPqu58cee0xYvXq1cOLECeHMmTPCjBkzBLlcLvz5559Grtyy6LuelbKzs4UOHToIAwcOFMaPH2+cYi2cvuv6zp07Qu/evYVRo0YJhw4dErKzs4X9+/cL6enpRq7csui7nv/3v/8Jtra2wv/+9z8hOztb2LNnj+Dh4SHMnz/fyJVblp07dwqvvfaasHXrVgGAsG3bNq3TX7x4UbC3txdiY2OF06dPCytXrhSsra2F3bt3G6xGhhs9hIeHC7Nnz1b9XlFRIXh6egrx8fGi00+ePFkYPXq02rCIiAhh1qxZBq3T0um7nmv7559/hNatWwubNm0yVImS0JD1/M8//wj9+vUTPvvsM2H69OkMNzrSd11/8skngr+/v1BeXm6sEiVB3/U8e/ZsYdiwYWrDYmNjhf79+xu0TinRJdy8/PLLwn333ac2bMqUKcKIESMMVhcvS+movLwcaWlpiIqKUg2zsrJCVFQUUlJSRF+TkpKiNj0AjBgxQuP01LD1XFtpaSnu3r2Ltm3bGqpMi9fQ9fz222/D1dUVTz75pDHKlISGrOsdO3YgMjISs2fPhpubG3r06IHFixejoqLCWGVbnIas5379+iEtLU116erixYvYuXMnRo0aZZSamwtTHAub3YMzG6qoqAgVFRVwc3NTG+7m5oazZ8+KvqagoEB0+oKCAoPVaekasp5re+WVV+Dp6Vnnj4mqNWQ9Hzp0CJ9//jnS09ONUKF0NGRdX7x4ET///DMef/xx7Ny5ExcuXMCzzz6Lu3fvYtGiRcYo2+I0ZD0/9thjKCoqwoABAyAIAv755x/8+9//xquvvmqMkpsNTcfC4uJilJWVwc7OrsmXyTM3JClLlixBYmIitm3bhlatWpm6HMm4desWpk2bhnXr1sHFxcXU5UheZWUlXF1dsXbtWoSFhWHKlCl47bXXsGbNGlOXJin79+/H4sWL8fHHH+P48ePYunUrfvjhB7zzzjumLo0aiWdudOTi4gJra2sUFhaqDS8sLIS7u7voa9zd3fWanhq2npWWL1+OJUuW4KeffkLPnj0NWabF03c9Z2VlIScnB2PHjlUNq6ysBAC0aNECmZmZCAgIMGzRFqoh27SHhwdatmwJa2tr1bBu3bqhoKAA5eXlsLGxMWjNlqgh6/mNN97AtGnT8NRTTwEAgoKCUFJSgqeffhqvvfYarKz4/b8paDoWtmnTxiBnbQCeudGZjY0NwsLCkJycrBpWWVmJ5ORkREZGir4mMjJSbXoA2Lt3r8bpqWHrGQDee+89vPPOO9i9ezd69+5tjFItmr7rOTAwEBkZGUhPT1f9jBs3DkOHDkV6ejq8vLyMWb5Facg23b9/f1y4cEEVIAHg3Llz8PDwYLDRoCHrubS0tE6AUQZKgY9dbDImORYarKmyBCUmJgq2trbCxo0bhdOnTwtPP/204OTkJBQUFAiCIAjTpk0TFixYoJr+8OHDQosWLYTly5cLZ86cERYtWsRbwXWg73pesmSJYGNjI3zzzTdCfn6+6ufWrVumegsWQd/1XBvvltKdvus6NzdXaN26tTBnzhwhMzNT+P777wVXV1fh3XffNdVbsAj6rudFixYJrVu3FjZv3ixcvHhR+PHHH4WAgABh8uTJpnoLFuHWrVvCiRMnhBMnTggAhPfff184ceKEcOnSJUEQBGHBggXCtGnTVNMrbwV/6aWXhDNnzgirV6/mreDmZuXKlYK3t7dgY2MjhIeHC7/99ptq3ODBg4Xp06erTf/1118LXbp0EWxsbIT77rtP+OGHH4xcsWXSZz37+PgIAOr8LFq0yPiFWxh9t+eaGG70o++6/vXXX4WIiAjB1tZW8Pf3F/7zn/8I//zzj5Grtjz6rOe7d+8Kb775phAQECC0atVK8PLyEp599lnhxo0bxi/cguzbt090n6tct9OnTxcGDx5c5zUhISGCjY2N4O/vL2zYsMGgNcoEgefeiIiISDrY5oaIiIgkheGGiIiIJIXhhoiIiCSF4YaIiIgkheGGiIiIJIXhhoiIiCSF4YaIiIgkheGGiIiIRB04cABjx46Fp6cnZDIZtm/fbvBlXr58GU888QTatWsHOzs7BAUF4dixY3rNg+GGiExuxowZmDBhgsmWP23aNCxevFinaR999FGsWLHCwBURmYeSkhIEBwdj9erVRlnejRs30L9/f7Rs2RK7du3C6dOnsWLFCjg7O+s1H/ZQTEQGJZPJtI5ftGgR5s+fD0EQ4OTkZJyiavj9998xbNgwXLp0CY6OjvVOf+rUKQwaNAjZ2dmQy+VGqJDIPMhkMmzbtk3ti8idO3fw2muvYfPmzbh58yZ69OiBpUuXYsiQIQ1axoIFC3D48GEcPHiwUbXyzA0RGVR+fr7qJyEhAW3atFEb9uKLL0Iul5sk2ADAypUrMWnSJJ2CDQD06NEDAQEB+O9//2vgyojM35w5c5CSkoLExEScPHkSkyZNwoMPPojz5883aH47duxA7969MWnSJLi6uiI0NBTr1q3Tez4MN0RkUO7u7qofuVwOmUymNszR0bHOZakhQ4Zg7ty5mDdvHpydneHm5oZ169ahpKQEMTExaN26NTp16oRdu3apLevUqVMYOXIkHB0d4ebmhmnTpqGoqEhjbRUVFfjmm28wduxYteEff/wxOnfujFatWsHNzQ2PPPKI2vixY8ciMTGx8SuHyILl5uZiw4YN2LJlCwYOHIiAgAC8+OKLGDBgADZs2NCgeV68eBGffPIJOnfujD179uCZZ57Bc889h02bNuk1H4YbIjJLmzZtgouLC44ePYq5c+fimWeewaRJk9CvXz8cP34cDzzwAKZNm4bS0lIAwM2bNzFs2DCEhobi2LFj2L17NwoLCzF58mSNyzh58iQUCgV69+6tGnbs2DE899xzePvtt5GZmYndu3dj0KBBaq8LDw/H0aNHcefOHcO8eSILkJGRgYqKCnTp0gWOjo6qn19++QVZWVkAgLNnz0Imk2n9WbBggWqelZWV6NWrFxYvXozQ0FA8/fTTmDlzJtasWaNXbS2a9J0SETWR4OBgvP766wCAuLg4LFmyBC4uLpg5cyYAYOHChfjkk09w8uRJ9O3bF6tWrUJoaKhaw+D169fDy8sL586dQ5cuXeos49KlS7C2toarq6tqWG5uLhwcHDBmzBi0bt0aPj4+CA0NVXudp6cnysvLUVBQAB8fH0O8fSKzd/v2bVhbWyMtLQ3W1tZq45SXef39/XHmzBmt82nXrp3q3x4eHujevbva+G7duuHbb7/VqzaGGyIySz179lT929raGu3atUNQUJBqmJubGwDgr7/+AlDVMHjfvn2ibWeysrJEw01ZWRlsbW3VGj3ff//98PHxgb+/Px588EE8+OCDeOihh2Bvb6+axs7ODgBUZ42ImqPQ0FBUVFTgr7/+wsCBA0WnsbGxQWBgoM7z7N+/PzIzM9WGnTt3Tu8vEQw3RGSWWrZsqfa7TCZTG6YMJJWVlQCqvkWOHTsWS5curTMvDw8P0WW4uLigtLQU5eXlsLGxAQC0bt0ax48fx/79+/Hjjz9i4cKFePPNN5Gamqpq9Hz9+nUAQPv27Rv3JonM3O3bt3HhwgXV79nZ2UhPT0fbtm3RpUsXPP7444iOjsaKFSsQGhqKq1evIjk5GT179sTo0aP1Xt78+fPRr18/LF68GJMnT8bRo0exdu1arF27Vq/5sM0NEUlCr1698Mcff8DX1xedOnVS+3FwcBB9TUhICADg9OnTasNbtGiBqKgovPfeezh58iRycnLw888/q8afOnUKHTt2hIuLi8HeD5E5OHbsGEJDQ1WXZmNjYxEaGoqFCxcCADZs2IDo6Gi88MIL6Nq1KyZMmIDU1FR4e3s3aHl9+vTBtm3bsHnzZvTo0QPvvPMOEhIS8Pjjj+s1H565ISJJmD17NtatW4epU6fi5ZdfRtu2bXHhwgUkJibis88+q9MmAKg689KrVy8cOnRIFXS+//57XLx4EYMGDYKzszN27tyJyspKdO3aVfW6gwcP4oEHHjDWWyMymSFDhkBbd3gtW7bEW2+9hbfeeqvJljlmzBiMGTOmUfPgmRsikgRPT08cPnwYFRUVeOCBBxAUFIR58+bByckJVlaad3VPPfUU/ve//6l+d3JywtatWzFs2DB069YNa9aswebNm3HfffcBAP7++29s375d1bCZiMwPeygmomatrKwMXbt2RVJSEiIjI+ud/pNPPsG2bdvw448/GqE6ImoInrkhombNzs4OX3zxhdbO/mpq2bIlVq5caeCqiKgxeOaGiIiIJIVnboiIiEhSGG6IiIhIUhhuiIiISFIYboiIiEhSGG6IiIhIUhhuiIiISFIYboiIiEhSGG6IiIhIUhhuiIiISFL+H9jfQBeIyVzNAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "gettable = ScheduleGettable(\n", " quantum_device=single_qubit_device,\n", " schedule_function=trace_schedule,\n", " schedule_kwargs={\n", " \"pulse_amp\": 0.5,\n", " \"acq_delay\": 100e-9,\n", " },\n", " batched=True,\n", ")\n", "\n", "data = gettable.get()\n", "\n", "plt.plot(np.arange(1000)/1e9, data[0], '.', label=\"real\")\n", "plt.plot(np.arange(1000)/1e9, data[1], '.', label=\"imaginary\")\n", "plt.legend()\n", "plt.xlabel(\"Time (s)\")\n", "plt.ylabel(\"Voltage (V)\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "70483201", "metadata": {}, "source": [ "This time, there is only one acquisition operation in the schedule. The measurement result contains two arrays: one for the _I_ values (`data[0][:]`), and one for the _Q_ values (`data[1][:]`) of the acquired trace.\n", "\n", "## MeasurementControl\n", "\n", "Iterating through different parameters can be done with some help from `quantify-core` as well, through the {class}`~quantify_core.measurement.control.MeasurementControl` class. The {class}`~quantify_core.measurement.control.MeasurementControl` uses settables (parameters to vary in an experiment) and gettables (in this case, our {class}`~quantify_scheduler.gettables.ScheduleGettable`). The settable must be a class that implements `set()`, such as a QCoDeS {class}`~qcodes.parameters.ManualParameter`.\n", "\n", "In this example, the settable is the `time` object, and the setpoints are a numpy array of values (`times`). These are added to the {class}`~quantify_core.measurement.control.MeasurementControl` as shown, together with the {class}`~quantify_scheduler.gettables.ScheduleGettable`. The {class}`~quantify_core.measurement.control.MeasurementControl` object will be in charge of setting the setpoints, and retrieving the measurement results through the gettable." ] }, { "cell_type": "code", "execution_count": 8, "id": "382bfa91", "metadata": {}, "outputs": [], "source": [ "from quantify_core.measurement.control import MeasurementControl\n", "\n", "\n", "measurement_control = MeasurementControl(\"measurement_control\")\n", "\n", "# Configure the settable\n", "time = ManualParameter(\"sample\", label=\"Sample time\", unit=\"s\")\n", "time.batched = True\n", "\n", "times = 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={\"times\": time},\n", " batched=True\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables(time)\n", "measurement_control.setpoints(times)\n", "measurement_control.gettables(gettable)" ] }, { "cell_type": "markdown", "id": "1039acbf", "metadata": {}, "source": [ "The experiment is set to run fully in _batched_ mode. When using {class}`~quantify_core.measurement.control.MeasurementControl`, settables and gettables can be either batched (an array of points is set for each measurement iteration) or iterative (only one point is set per iteration). Combinations of batched and iterative settables are possible, as explained in detail in the [quantify-core documentation](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#mixing-iterative-and-batched-settables).\n", "\n", "Settables and gettables are batched if they have the attribute `batched=True`. In {class}`~quantify_scheduler.gettables.ScheduleGettable`, this can be controlled through the `batched` argument when creating the class. For other classes, the attribute can be added dynamically if needed, as shown above for the `time` parameter.\n", "\n", "With both the gettable and the settable having `batched=True`, the {class}`~quantify_core.measurement.control.MeasurementControl` knows that it should set the entire `times` array as the settable's value (instead of repeating the experiment for each value in the array). All data points are measured without interruption and all measurement results are returned in one go. Now, let's run the experiment and retrieve the data." ] }, { "cell_type": "code", "execution_count": 9, "id": "ac70ab51", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting batched measurement...\n", "Iterative settable(s) [outer loop(s)]:\n", "\t --- (None) --- \n", "Batched settable(s):\n", "\t sample \n", "Batch size limit: 125\n", "\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6ce1eb827185482eb162bf817f9b870a", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "dataset = measurement_control.run()" ] }, { "cell_type": "markdown", "id": "b9e83bc8", "metadata": {}, "source": [ "The {class}`~quantify_core.measurement.control.MeasurementControl` class processes the data returned by the {class}`~quantify_scheduler.gettables.ScheduleGettable`, and turns it into a {class}`~xarray.Dataset`. More information on the format of this dataset can be found in the [quantify-core documentation](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#dataset)." ] }, { "cell_type": "code", "execution_count": 10, "id": "ccc9f232", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 3kB\n",
       "Dimensions:  (dim_0: 125)\n",
       "Coordinates:\n",
       "    x0       (dim_0) float64 1kB 1.6e-07 5.6e-07 9.6e-07 ... 4.936e-05 4.976e-05\n",
       "Dimensions without coordinates: dim_0\n",
       "Data variables:\n",
       "    y0       (dim_0) float64 1kB -1.166 -1.141 -1.109 ... -0.737 -0.7305 -1.164\n",
       "    y1       (dim_0) float64 1kB 0.2569 0.2138 0.2035 ... -0.2533 -0.247 0.2671\n",
       "Attributes:\n",
       "    tuid:                             20250320-203512-329-9bc56e\n",
       "    name:                             \n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         False\n",
       "    1d_2_settables_uniformly_spaced:  False
" ], "text/plain": [ " Size: 3kB\n", "Dimensions: (dim_0: 125)\n", "Coordinates:\n", " x0 (dim_0) float64 1kB 1.6e-07 5.6e-07 9.6e-07 ... 4.936e-05 4.976e-05\n", "Dimensions without coordinates: dim_0\n", "Data variables:\n", " y0 (dim_0) float64 1kB -1.166 -1.141 -1.109 ... -0.737 -0.7305 -1.164\n", " y1 (dim_0) float64 1kB 0.2569 0.2138 0.2035 ... -0.2533 -0.247 0.2671\n", "Attributes:\n", " tuid: 20250320-203512-329-9bc56e\n", " name: \n", " grid_2d: False\n", " grid_2d_uniformly_spaced: False\n", " 1d_2_settables_uniformly_spaced: False" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dataset" ] }, { "cell_type": "markdown", "id": "11f1a9f6", "metadata": {}, "source": [ "The dataset coordinates and data variables are named as generic `x` and `y` parameters. You can click on the 'Show/Hide attributes' button next to the coordinates and variables to see what they refer to.\n", "\n", "(sec-tutorial-schedulegettable-repetitions)=\n", "## Repetitions\n", "\n", "Repetition defines how many times the defined schedule will run on the hardware. Running the schedule multiple times can be useful for example if the user would like to reduce errors of acquisitions by averaging the result of multiple measurements.\n", "\n", "There are multiple ways the repetitions can be set. They are not completely independent of each other, and which setting will be taken into account depends on how you create and use the schedule.\n", "\n", "1. {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice`: via `cfg_sched_repetitions` (by default it is `1024`),\n", "2. schedule function: via the `repetitions` function argument,\n", "3. {class}`~quantify_scheduler.schedules.schedule.Schedule` object: via the `repetitions` function argument of its constructor, or via its `repetitions` attribute directly,\n", "4. ({class}`~quantify_scheduler.gettables.ScheduleGettable`: currently, it is not possible to supply `repetitions` via `schedule_kwargs`).\n", "\n", "Ultimately, the {class}`~quantify_scheduler.schedules.schedule.Schedule` object is what governs the repetitions, via its `repetitions` attribute.\n", "\n", "When using a schedule function, the `repetitions` function argument sets the repetitions, provided that the schedule function passes it to the `Schedule` object. This is true for the pre-defined schedules, see {mod}`!quantify_scheduler.schedules`.\n", "\n", "However, if the experiment is run using `ScheduleGettable`, this `repetitions` function argument is set to `QuantumDevice.cfg_sched_repetitions`. Hence, typically, the schedule will run `QuantumDevice.cfg_sched_repetitions` times.\n", "\n", "### Possible mistake: ignoring `repetitions` argument\n", "\n", "Keep in mind that the schedule function should pass the `repetitions` argument to the `Schedule` initializer, otherwise both `QuantumDevice.cfg_sched_repetitions` and the `repetitions` argument of the schedule function will be ignored. For example, in the following setup, the `repetitions` will always be `1` (default for the `Schedule` object), even if `cfg_sched_repetitions` is set to `2`." ] }, { "cell_type": "code", "execution_count": 11, "id": "fac2b5e2", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import QuantumDevice, ScheduleGettable\n", "\n", "def schedule_function(q0: str, repetitions: int):\n", " schedule = Schedule(\"Example schedule\")\n", " schedule.add(Measure(q0, acq_index=0))\n", " return schedule\n", "\n", "quantum_device = QuantumDevice(name=\"quantum_sample\")\n", "quantum_device.cfg_sched_repetitions(2)\n", "\n", "schedule_gettable = ScheduleGettable(\n", " quantum_device=quantum_device,\n", " schedule_function=schedule_function,\n", " schedule_kwargs={\"q0\": \"q0\"},\n", ")" ] }, { "cell_type": "markdown", "id": "e6a5d677", "metadata": {}, "source": [ "### Possible mistake: ignoring `cfg_sched_repetitions` default value\n", "\n", "Also note, that the default value of the `repetitions` argument of the schedule function will be ignored if `ScheduleGettable` is used, and it will be set to `QuantumDevice.cfg_sched_repetitions`. For example, in the following setup, `repetitions` will be `1024` (default for `QuantumDevice`), even if the default argument for `repetitions` is `2`." ] }, { "cell_type": "code", "execution_count": 12, "id": "e88cf3a2", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "quantum_device.close()" ] }, { "cell_type": "code", "execution_count": 13, "id": "f9e90cd3", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import QuantumDevice, ScheduleGettable\n", "\n", "def schedule_function(q0: str, repetitions: int = 2):\n", " schedule = Schedule(\"Example schedule\", repetitions=repetitions)\n", " schedule.add(Measure(q0, acq_index=0))\n", " return schedule\n", "\n", "quantum_device = QuantumDevice(name=\"quantum_sample\")\n", "\n", "schedule_gettable = ScheduleGettable(\n", " quantum_device=quantum_device,\n", " schedule_function=schedule_function,\n", " schedule_kwargs={\"q0\": \"q0\"},\n", ")" ] }, { "cell_type": "markdown", "id": "df2af178", "metadata": {}, "source": [ "(sec-schedulegettable-2dsweep-usage)=\n", "\n", "## 2D (and ND) measurement loops" ] }, { "cell_type": "code", "execution_count": 14, "id": "ed30c3f5", "metadata": { "mystnb": { "code_prompt_show": "Set up the quantum device, dummy hardware and hardware configuration" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from qblox_instruments import Cluster, ClusterType, DummyBinnedAcquisitionData\n", "\n", "from quantify_scheduler import BasicTransmonElement, InstrumentCoordinator, QuantumDevice\n", "from quantify_scheduler.qblox import ClusterComponent\n", "\n", "\n", "single_qubit_device.close_all()\n", "\n", "# Device parameters\n", "Q0_ACQ_DELAY = 100e-9\n", "Q0_FREQ_01 = 4e9\n", "Q0_READOUT_AMP = 0.1\n", "Q0_READOUT_FREQ = 4.3e9\n", "Q0_PI_PULSE_AMP = 0.15\n", "Q0_LO_FREQ_QUBIT = 3.9e9\n", "Q0_LO_FREQ_READOUT = 4.5e9\n", "\n", "Q1_ACQ_DELAY = 120e-9\n", "Q1_FREQ_01 = 4.1e9\n", "Q1_READOUT_AMP = 0.1\n", "Q1_READOUT_FREQ = 3.8e9\n", "Q1_PI_PULSE_AMP = 0.15\n", "Q1_LO_FREQ_QUBIT = 4.1e9\n", "Q1_LO_FREQ_READOUT = 3.8e9\n", "\n", "two_qubit_device = QuantumDevice(\"two_qubit_device\")\n", "\n", "q0 = BasicTransmonElement(\"q0\")\n", "q0.measure.acq_channel(0)\n", "q0.measure.pulse_amp(Q0_READOUT_AMP)\n", "q0.clock_freqs.readout(Q0_READOUT_FREQ)\n", "q0.clock_freqs.f01(Q0_FREQ_01)\n", "q0.measure.acq_delay(Q0_ACQ_DELAY)\n", "q0.rxy.amp180(Q0_PI_PULSE_AMP)\n", "\n", "q1 = BasicTransmonElement(\"q1\")\n", "q1.measure.acq_channel(1) # Note that we're specifying that measurements on q1 should use a different measurement channel\n", "q1.measure.pulse_amp(Q1_READOUT_AMP)\n", "q1.clock_freqs.readout(Q1_READOUT_FREQ)\n", "q1.clock_freqs.f01(Q1_FREQ_01)\n", "q1.measure.acq_delay(Q1_ACQ_DELAY)\n", "q1.rxy.amp180(Q1_PI_PULSE_AMP)\n", "\n", "two_qubit_device.add_element(q0)\n", "two_qubit_device.add_element(q1)\n", "\n", "# We will need to adjust the hardware configuration.\n", "\n", "# Note: 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.\n", "cluster = Cluster(\n", " \"cluster\",\n", " dummy_cfg={\n", " 1: ClusterType.CLUSTER_QRM_RF,\n", " 2: ClusterType.CLUSTER_QCM_RF,\n", " 3: ClusterType.CLUSTER_QRM_RF,\n", " 4: ClusterType.CLUSTER_QCM_RF,\n", " },\n", ")\n", "\n", "ic_cluster = ClusterComponent(cluster)\n", "\n", "# Temporarily fixing dummy cluster's deficiency.\n", "cluster.start_sequencer = lambda : start_dummy_cluster_armed_sequencers(ic_cluster)\n", "\n", "instrument_coordinator = InstrumentCoordinator(\"instrument_coordinator\")\n", "instrument_coordinator.add_component(ic_cluster)\n", "\n", "two_qubit_device.instr_instrument_coordinator(instrument_coordinator.name)\n", "\n", "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\": {\n", " \"instrument_type\": \"QRM_RF\"\n", " },\n", " \"2\": {\n", " \"instrument_type\": \"QCM_RF\"\n", " },\n", " \"3\": {\n", " \"instrument_type\": \"QRM_RF\"\n", " },\n", " \"4\": {\n", " \"instrument_type\": \"QCM_RF\"\n", " }\n", " },\n", " \"ref\": \"internal\"\n", " }\n", " },\n", " \"hardware_options\": {\n", " \"modulation_frequencies\": {\n", " \"q0:res-q0.ro\": {\n", " \"lo_freq\": Q0_LO_FREQ_READOUT\n", " },\n", " \"q0:mw-q0.01\": {\n", " \"lo_freq\": Q0_LO_FREQ_QUBIT\n", " },\n", " \"q1:res-q1.ro\": {\n", " \"lo_freq\": Q1_LO_FREQ_READOUT\n", " },\n", " \"q1:mw-q1.01\": {\n", " \"lo_freq\": Q1_LO_FREQ_QUBIT\n", " }\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", " [f\"{cluster.name}.module3.complex_output_0\", \"q1:res\"],\n", " [f\"{cluster.name}.module3.complex_input_0\", \"q1:res\"],\n", " [f\"{cluster.name}.module4.complex_output_0\", \"q1:mw\"]\n", " ]\n", " }\n", "}\n", "\n", "\n", "two_qubit_device.hardware_config(hardware_cfg)\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1, sequencer=0, acq_index_name=\"0\", data=[DummyBinnedAcquisitionData(data=(0.0, 0.0), thres=0, avg_cnt=0)]\n", ")\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=3, sequencer=0, acq_index_name=\"0\", data=[DummyBinnedAcquisitionData(data=(0.0, 0.0), thres=0, avg_cnt=0)]\n", ")" ] }, { "cell_type": "markdown", "id": "31ab3205", "metadata": {}, "source": [ "2D and higher-dimensional measurement loops are easy to realize. Below we show an example Chevron experiment, which is a type of two-qubit experiment often performed on transmon qubits. The experiment includes a square pulse, and we want to vary both its amplitude and duration in a 2D grid. We have already set up a two-qubit {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice` under the variable name `two_qubit_device`.\n", "\n", "We define simple schedule below with a parameterized amplitude and duration of the square pulse. `duration` and `amp` are scalars, so for each measurement point the schedule will be recompiled." ] }, { "cell_type": "code", "execution_count": 15, "id": "00efe337", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations import Measure, Reset, SquarePulse, X, X90\n", "\n", "def chevron_schedule_not_batched(duration, amp, repetitions=1):\n", " sched = Schedule(\"Chevron Experiment\", repetitions=repetitions)\n", "\n", " acq_idx = 0\n", "\n", " reset = sched.add(Reset(\"q0\", \"q1\"))\n", " sched.add(X(\"q0\"), ref_op=reset, ref_pt=\"end\") # Start at the end of the reset\n", " # We specify a clock for tutorial purposes, Chevron experiments do not necessarily use modulated square pulses\n", " square = sched.add(SquarePulse(amp=amp, duration=duration, port=\"q0:mw\", clock=\"q0.01\"))\n", " sched.add(X90(\"q0\"), ref_op=square) # Start at the end of the square pulse\n", " sched.add(X90(\"q1\"), ref_op=square)\n", " sched.add(Measure(\"q0\", acq_index=acq_idx), label=f\"M q0 {acq_idx}\")\n", " sched.add(\n", " Measure(\"q1\", acq_index=acq_idx),\n", " label=f\"M q1 {acq_idx}\",\n", " ref_pt=\"start\", # Start at the same time as the other measure\n", " )\n", "\n", " return sched" ] }, { "cell_type": "markdown", "id": "2ff0ac38", "metadata": {}, "source": [ "We set up a non-batched measurement with {class}`~quantify_core.measurement.control.MeasurementControl` and a {class}`~quantify_scheduler.gettables.ScheduleGettable`. For this {class}`~quantify_scheduler.gettables.ScheduleGettable`, notice the keyword argument `num_channels=2`, which is needed since we specified in the quantum device elements that the measurements on `\"q0\"` and `\"q1\"` should end up in two different channels.\n", "\n", "In addition, we used another new argument in the {class}`~quantify_scheduler.gettables.ScheduleGettable`: `real_imag=False`. `real_imag` can be used to transform the acquisition data. If it is `True` (the default), the I and Q values will be returned, and if it is `False`, the data will be transformed to the absolute value and the phase (in degrees, in the interval `(-180, 180]`)." ] }, { "cell_type": "code", "execution_count": 16, "id": "cca047a2", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting iterative measurement...\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9ff64205e6694c44a13245837404a4b2", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "measurement_control = MeasurementControl(\"measurement_control\")\n", "\n", "# Configure the settables\n", "duration = ManualParameter(\"duration\", label=\"Duration\", unit=\"s\")\n", "duration.batched = False\n", "\n", "durations = np.linspace(start=20e-9, stop=60e-9, num=6)\n", "\n", "amplitude = ManualParameter(\"amplitude\", label=\"Amplitude\", unit=\"V\")\n", "amplitude.batched = False\n", "\n", "amplitudes = np.linspace(start=0.1, stop=1.0, num=10)\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=two_qubit_device,\n", " schedule_function=chevron_schedule_not_batched,\n", " schedule_kwargs={\"duration\": duration, \"amp\": amplitude},\n", " batched=False,\n", " real_imag=False,\n", " num_channels=2,\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables([duration, amplitude])\n", "measurement_control.setpoints_grid([durations, amplitudes]) # note: setpoints_grid instead of setpoints\n", "measurement_control.gettables(gettable)\n", "\n", "# Run!\n", "dataset = measurement_control.run()\n", "dset_grid = dh.to_gridded_dataset(dataset)" ] }, { "cell_type": "code", "execution_count": 17, "id": "21192f6f", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 2kB\n",
       "Dimensions:  (x0: 6, x1: 10)\n",
       "Coordinates:\n",
       "  * x0       (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n",
       "  * x1       (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n",
       "Data variables:\n",
       "    y0       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "    y1       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "    y2       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "    y3       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "Attributes:\n",
       "    tuid:                             20250320-203513-555-8c8c87\n",
       "    name:                             \n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         True\n",
       "    1d_2_settables_uniformly_spaced:  False\n",
       "    xlen:                             6\n",
       "    ylen:                             10
" ], "text/plain": [ " Size: 2kB\n", "Dimensions: (x0: 6, x1: 10)\n", "Coordinates:\n", " * x0 (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n", " * x1 (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n", "Data variables:\n", " y0 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", " y1 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", " y2 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", " y3 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", "Attributes:\n", " tuid: 20250320-203513-555-8c8c87\n", " name: \n", " grid_2d: False\n", " grid_2d_uniformly_spaced: True\n", " 1d_2_settables_uniformly_spaced: False\n", " xlen: 6\n", " ylen: 10" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dset_grid" ] }, { "cell_type": "markdown", "id": "142b80e4", "metadata": {}, "source": [ "As expected, this dataset contains double the amount of coordinates and data variables (note that the actual data has been mocked and set to 0.0). The two coordinates refer to the settables, `duration` and `amplitude`. With `real_imag` now set to `False`, the data variables contain the magnitude and phase (as opposed to the I and Q voltages) for measurements on `\"q0\"` and `\"q1\"`.\n", "\n", "### Batched 2D experiment\n", "\n", "Since this measurement is not batched, it's rather slow. Let's make this faster with (partial) batching.\n", "\n", "We will batch the amplitudes together, so we change the amplitudes parameter in the schedule function to an array." ] }, { "cell_type": "code", "execution_count": 18, "id": "f733d39b", "metadata": { "mystnb": { "code_prompt_show": "Provide the dummy hardware with acquisition data" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from qblox_instruments import DummyBinnedAcquisitionData\n", "\n", "\n", "def get_dummy_binned_acquisition_data(real: float, imag: float):\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=0, avg_cnt=0)\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1, sequencer=0, acq_index_name=\"0\", data=[get_dummy_binned_acquisition_data(re * 10, im * 10) for re, im in zip(range(-5, 5), range(5, -5, -1))]\n", ")\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=3, sequencer=0, acq_index_name=\"0\", data=[get_dummy_binned_acquisition_data(re * 10, im * 10) for re, im in zip(range(-5, 5), range(5, -5, -1))]\n", ")" ] }, { "cell_type": "code", "execution_count": 19, "id": "49e3e948", "metadata": {}, "outputs": [], "source": [ "def chevron_schedule_batched(duration, amps, repetitions=1):\n", " sched = Schedule(\"Chevron Experiment\", repetitions=repetitions)\n", "\n", " acq_idx = 0\n", "\n", " for amp in amps:\n", " reset = sched.add(Reset(\"q0\", \"q1\"))\n", " sched.add(X(\"q0\"), ref_op=reset, ref_pt=\"end\")\n", " square = sched.add(SquarePulse(amp=amp, duration=duration, port=\"q0:mw\", clock=\"q0.01\"))\n", " sched.add(X90(\"q0\"), ref_op=square)\n", " sched.add(X90(\"q1\"), ref_op=square)\n", " sched.add(Measure(\"q0\", acq_index=acq_idx), label=f\"M q0 {acq_idx}\")\n", " sched.add(\n", " Measure(\"q1\", acq_index=acq_idx),\n", " label=f\"M q1 {acq_idx}\",\n", " ref_pt=\"start\",\n", " )\n", "\n", " acq_idx += 1\n", "\n", " return sched" ] }, { "cell_type": "markdown", "id": "8d24ebe9", "metadata": {}, "source": [ "We specify that we want to batch the amplitudes by setting ``amplitude.batched = True`` and ``batched=True``as keyword argument for the gettable. Finally, we run this experiment just as before." ] }, { "cell_type": "code", "execution_count": 20, "id": "735d877d", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting batched measurement...\n", "Iterative settable(s) [outer loop(s)]:\n", "\t duration \n", "Batched settable(s):\n", "\t amplitude \n", "Batch size limit: 60\n", "\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9fbfffad8bdf440da4b9bded8958550e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Configure the settables\n", "duration = ManualParameter(\"duration\", label=\"Duration\", unit=\"s\")\n", "duration.batched = False\n", "\n", "durations = np.linspace(start=20e-9, stop=60e-9, num=6)\n", "\n", "amplitude = ManualParameter(\"amplitude\", label=\"Amplitude\", unit=\"V\")\n", "amplitude.batched = True\n", "\n", "amplitudes = np.linspace(start=0.1, stop=1.0, num=10)\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=two_qubit_device,\n", " schedule_function=chevron_schedule_batched,\n", " schedule_kwargs={\"duration\": duration, \"amps\": amplitude},\n", " batched=True,\n", " real_imag=False,\n", " data_labels=[\"Magnitude Q0\", \"Phase Q0\", \"Magnitude Q1\", \"Phase Q1\"],\n", " num_channels=2,\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables([duration, amplitude])\n", "measurement_control.setpoints_grid([durations, amplitudes])\n", "measurement_control.gettables(gettable)\n", "\n", "# Run!\n", "dataset = measurement_control.run()\n", "dset_grid = dh.to_gridded_dataset(dataset)" ] }, { "cell_type": "code", "execution_count": 21, "id": "3f027c35", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 2kB\n",
       "Dimensions:  (x0: 6, x1: 10)\n",
       "Coordinates:\n",
       "  * x0       (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n",
       "  * x1       (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n",
       "Data variables:\n",
       "    y0       (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n",
       "    y1       (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n",
       "    y2       (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n",
       "    y3       (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n",
       "Attributes:\n",
       "    tuid:                             20250320-203519-051-5e7309\n",
       "    name:                             \n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         True\n",
       "    1d_2_settables_uniformly_spaced:  False\n",
       "    xlen:                             6\n",
       "    ylen:                             10
" ], "text/plain": [ " Size: 2kB\n", "Dimensions: (x0: 6, x1: 10)\n", "Coordinates:\n", " * x0 (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n", " * x1 (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n", "Data variables:\n", " y0 (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n", " y1 (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n", " y2 (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n", " y3 (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n", "Attributes:\n", " tuid: 20250320-203519-051-5e7309\n", " name: \n", " grid_2d: False\n", " grid_2d_uniformly_spaced: True\n", " 1d_2_settables_uniformly_spaced: False\n", " xlen: 6\n", " ylen: 10" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dset_grid" ] }, { "cell_type": "markdown", "id": "d0dee6a4", "metadata": {}, "source": [ "The shape of the dataset is no different from the previous (non-batched) experiment, but the metadata is a little different. Some coordinates and data variables now have the `batched=True` attribute. We also introduced another keyword argument: the `data_labels`. These `data_labels` are picked up by the {class}`~quantify_core.measurement.control.MeasurementControl`and end up in the {class}`xarray.Dataset` as the \"long_name\" of attributes. For example, `\"y0\"`s label can be accessed through `dataset[\"y0\"].attrs[\"long_name\"]`. The various plotting features of `quantify-core` will use this name to get labels for the figure axes." ] } ], "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" }, "source_map": [ 6, 34, 141, 149, 166, 170, 195, 199, 247, 251, 263, 273, 299, 303, 322, 332, 356, 364, 369, 373, 375, 401, 417, 423, 430, 445, 451, 588, 594, 617, 623, 660, 662, 672, 692, 714, 718, 754, 756 ], "widgets": { "application/vnd.jupyter.widget-state+json": { "state": { "1175ecb9a2e84df4a205560b3b09d866": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "1555d35cffa24981a29758e6e7f80886": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "19841b9c9e67407584e1ff21dc4ef684": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_ed95cf1e7e084bda8a05a30ad73a293e", "placeholder": "​", "style": "IPY_MODEL_7432930652bb472f86eafc77a843ae82", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "1b5cedbb00ec468381ca5b8cc2d7267b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_1555d35cffa24981a29758e6e7f80886", "placeholder": "​", "style": "IPY_MODEL_4ca392c608d8456d9adab63aba7db27f", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:04 | time left: 00:00 ] " } }, "2539d8c7736c4a7288d147f4901a552f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "2603a5b0fb8e461abc0db031a6c3eea6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_8f3bdd2dcafc47adb939c19dc612b79b", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_504ac9dd3f4645fd8378d649ffb5e450", "tabbable": null, "tooltip": null, "value": 100.0 } }, "2996b39cbc9f46d7a08a057b71bc6ae9": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "3fb4ea2dce6947faa84905f11b802d70": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "4728684bb5814d688ef127c5722ec1cf": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "4ca392c608d8456d9adab63aba7db27f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "504ac9dd3f4645fd8378d649ffb5e450": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "56ca6c2ddaa2437b8054f17f4ac46de8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "60d557c3953e4a8f9a6c688b2b6b3368": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "62ae45f5e4c94f3480eb9d9a5753bcc2": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "698e7dd51dea470a9ad9521c9bbaa46b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_ccc525754b9941a9968c10dcc771ae50", "placeholder": "​", "style": "IPY_MODEL_718bfee328dd446fba337dcd5fc97cd7", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "6ce1eb827185482eb162bf817f9b870a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_19841b9c9e67407584e1ff21dc4ef684", "IPY_MODEL_2603a5b0fb8e461abc0db031a6c3eea6", "IPY_MODEL_76935e1a8d6f4ceaa07dbfb97f69cea8" ], "layout": "IPY_MODEL_3fb4ea2dce6947faa84905f11b802d70", "tabbable": null, "tooltip": null } }, "718bfee328dd446fba337dcd5fc97cd7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "7432930652bb472f86eafc77a843ae82": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "76935e1a8d6f4ceaa07dbfb97f69cea8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_c4c54475bfe34df2a63b7171f01886b0", "placeholder": "​", "style": "IPY_MODEL_62ae45f5e4c94f3480eb9d9a5753bcc2", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 125" } }, "7f88aa36415c445d98c94b63ecc0010f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_8e08ff8642664c94822157ebc3648bce", "placeholder": "​", "style": "IPY_MODEL_8e3d4065ea90476ebb8a76e932beb292", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "843b18e8cd554216a711002b4b9629c0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_4728684bb5814d688ef127c5722ec1cf", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_2996b39cbc9f46d7a08a057b71bc6ae9", "tabbable": null, "tooltip": null, "value": 100.0 } }, "8e08ff8642664c94822157ebc3648bce": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "8e3d4065ea90476ebb8a76e932beb292": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "8f3bdd2dcafc47adb939c19dc612b79b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "9fbfffad8bdf440da4b9bded8958550e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_7f88aa36415c445d98c94b63ecc0010f", "IPY_MODEL_f3df78d25fa14abb9c6a71726267f45a", "IPY_MODEL_a7cfd7ba06b942b086661fb7f96f44c2" ], "layout": "IPY_MODEL_1175ecb9a2e84df4a205560b3b09d866", "tabbable": null, "tooltip": null } }, "9ff64205e6694c44a13245837404a4b2": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_698e7dd51dea470a9ad9521c9bbaa46b", "IPY_MODEL_843b18e8cd554216a711002b4b9629c0", "IPY_MODEL_1b5cedbb00ec468381ca5b8cc2d7267b" ], "layout": "IPY_MODEL_de149665170e4d4995861448d2ef85ed", "tabbable": null, "tooltip": null } }, "a7cfd7ba06b942b086661fb7f96f44c2": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_2539d8c7736c4a7288d147f4901a552f", "placeholder": "​", "style": "IPY_MODEL_ff0a65197546427b9e5921dbc0f08809", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 10" } }, "c4c54475bfe34df2a63b7171f01886b0": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "ccc525754b9941a9968c10dcc771ae50": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "de149665170e4d4995861448d2ef85ed": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "ed95cf1e7e084bda8a05a30ad73a293e": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "f3df78d25fa14abb9c6a71726267f45a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_60d557c3953e4a8f9a6c688b2b6b3368", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_56ca6c2ddaa2437b8054f17f4ac46de8", "tabbable": null, "tooltip": null, "value": 100.0 } }, "ff0a65197546427b9e5921dbc0f08809": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } } }, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }