{ "cells": [ { "cell_type": "markdown", "id": "fdee5f2e", "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": "5cad973a", "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.device_under_test.quantum_device import QuantumDevice\n", "from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement\n", "from quantify_scheduler.instrument_coordinator import InstrumentCoordinator\n", "from quantify_scheduler.instrument_coordinator.components.qblox import ClusterComponent\n", "from quantify_scheduler.helpers.qblox_dummy_instrument import start_dummy_cluster_armed_sequencers\n", "\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", " \"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}.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": "7f8ae787", "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": "02f8ca5b", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations.gate_library 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": "411b8fc9", "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": "77f073e1", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "from qcodes.instrument.parameter import ManualParameter\n", "\n", "from quantify_scheduler.gettables 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": "759c9355", "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": "6f0ba0d2", "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": "c7791686", "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": "29a2dc6d", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAGwCAYAAABFFQqPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABUP0lEQVR4nO3deVhU9eIG8HcGEWUbZAdFEXdzww0x1yTXuGlqaiZqtvy6apFLYddcyjIrS23Rsky9N9My5XqtKFPLNFNESS33NIxFRGKQRSA4vz/GGWeGMzNnYPZ5P88zj86Zs3znUJ6X7yoTBEEAERERkRuS27sARERERPbCIERERERui0GIiIiI3BaDEBEREbktBiEiIiJyWwxCRERE5LYYhIiIiMhtNbB3ARxdTU0NcnJy4OfnB5lMZu/iEBERkQSCIODmzZuIjIyEXG643odByIScnBxERUXZuxhERERUB1evXkWzZs0Mfs4gZIKfnx8A1Y309/e3c2mIiIhIiuLiYkRFRWme44YwCJmgbg7z9/dnECIiInIyprq1sLM0ERERuS0GISIiInJbDEJERETkthiEiIiIyG0xCBEREZHbYhAiIiIit8UgRERERG6LQYiIiIjcFoMQERERuS0GISIiInJbDEJERETkthiEiIiIyD6U2cDlA6o/7YSLrhIREZHtHd8M/O9pQKgBZHIgcTXQPcnmxWCNkL04QAomIiKyC2X2nRAEqP78X7JdnomsEbIHB0nBREREdlF46U4IUhOqgcLfAUVTmxaFNUK25kApmIiIyC4CW6kqArTJPIDAGJsXhUHI1oylYCIiInegaKpqDZF5qN7LPIDEVTavDQLYNGZ76hSsHYbslIKJiIjspnsS0GqIqiIgMMYuIQhgjZDtOVAKJiIisitFU6Blf7s+A1kjZA8OkoKJiIjcHYOQvSiaMgARERHZGZvGiIiIyG0xCBEREZHbYhByFJxpmoiIyObYR8gRcKZpIiIiu2CNkL1xpmkiIiK7cbog9O677yI6OhqNGjVCXFwcjh49anDf9evXo3///mjSpAmaNGmChIQEo/vbhaGZpq8eZVMZERGRlTlVENq2bRvmzJmDxYsX4/jx4+jatSuGDRuG/Px80f2///57TJo0Cfv378fhw4cRFRWFoUOHIjvbgcKF2HorkAFfPAJsSgRWdVI1nREREZHFyQRBEOxdCKni4uLQq1cvvPPOOwCAmpoaREVFYfbs2UhJSTF5fHV1NZo0aYJ33nkHSUnS+uAUFxdDoVBAqVTC39+/XuU36PhmVXOYUA1VNhVuv26TeQDJpzjvEBERkURSn99OUyNUWVmJjIwMJCQkaLbJ5XIkJCTg8OHDks5RVlaGqqoqBAYGGtynoqICxcXFOi+r656kCjpTdwPjPoJOCAJUAenXVDaTERERWZjTBKGCggJUV1cjLCxMZ3tYWBjy8vIkneO5555DZGSkTpjSt3z5cigUCs0rKiqqXuWWTL3eSlScSFMZgG+fZzMZERGRhTlNEKqvV199FVu3bsXOnTvRqFEjg/stWLAASqVS87p69aoNS4nai7Jq44gyIiIii3KaeYSCg4Ph4eGBa9eu6Wy/du0awsPDjR77xhtv4NVXX8V3332HLl26GN3Xy8sLXl5e9S5vvagXZf01VVUTpE2oVi3Wyv5CRERE9eY0NUINGzZEjx49sHfvXs22mpoa7N27F/Hx8QaPe+211/DSSy8hLS0NPXv2tEVRLUPRFLhrdO1mMpmHasV6IiIiqjenCUIAMGfOHKxfvx6bNm3CmTNn8OSTT6K0tBTTp08HACQlJWHBggWa/VesWIEXXngBGzZsQHR0NPLy8pCXl4eSkhJ7fQXz6DeTyTyAxFWsDSIiIrIQp2kaA4AJEybg+vXrWLRoEfLy8tCtWzekpaVpOlBnZWVBLr+T7dauXYvKykqMGzdO5zyLFy/GkiVLbFn0ulM3kxX+rqoJYggiIiKyGKeaR8gebDKPEBEREVmUy80jRERERGRpDELOSJnNdciIiIgswKn6CBFuL8dxe7V6mVzVmbq7tOVCiIiISBdrhJyJMvtOCAI4wSIREVE9sUbImRReuhOC1IRq4OpRoDBItZI9R5URERFJxiDkTAJbqZrDdMKQDPjiETaVERER1QGbxpxJrXXIbv/42FRGRERUJ6wRcjbaEyyWXge2T9f9nGuRERERScYg5IwUTVUvZXbtpjKuRUZERCQZm8acGdciIyIiqhfWCDk7rkVGRERUZwxCrkDdVEZERERmYdOYq+HyG0RERJKxRsiVcPkNIiIiszAIuQpDy2+E3gVUlXLWaSIiIhEMQq7C0PIbHw0BBIE1RERERCLYR8hVqJff0CcIt//krNNERET6GIRchaHlN7SpZ50mIiIiAGwacy3acwp5egMfJdSeddrTWzWqjH2GiIiIGIRcjvacQomrVc1hQrUqBHWZcCccsc8QERERg5BLM1ZDJNQAu54GGvoCUXGsHSIiIrfEPkKuTtEUaNlfNYRef1QZalSr16/qpJqDiIiIyM0wCLkLQ6PKAI4oIyIit8Ug5C5qjSrTwxFlRETkhhiE3En3JCD5FDBuY+3aIZmHavV6IiIiN8Ig5G4UTYFOY3Rrh2QeQOIq1d+5YCsREbkRjhpzV9ojygJjgEt7VZ2mObSeiIjcCGuE3Jl6RBkgvmAra4aIiMjFMQiR4QVb2XmaiIhcHIMQGRhaLwdKr7NWiIiIXBqDEIkMrZcBEHQnW1RmsyM1ERG5HJkgCIK9C+HIiouLoVAooFQq4e/vb+/iWJcyG7h6FPjiEb2mMhkgk7EjNREROQ2pz2/WCNEdiqaAT5DIUhwCO1ITEZFLYhAiXcaW4lBjR2oiInIRDEKkq1Z/ITlUfYa0cBZqIiJyEZxQkWoTm2zxf8mqmiD1LNSKpvYuJRERUb05XY3Qu+++i+joaDRq1AhxcXE4evSo0f0///xztG/fHo0aNULnzp3x1Vdf2aikTk492aKi6Z01yqbuVv3JjtJEROQinCoIbdu2DXPmzMHixYtx/PhxdO3aFcOGDUN+fr7o/j/99BMmTZqEGTNm4MSJExg9ejRGjx6N06dP27jkLkA7GBEREbkIpxo+HxcXh169euGdd94BANTU1CAqKgqzZ89GSkpKrf0nTJiA0tJS7N69W7OtT58+6NatG9atWyfpmm41fJ6IiMhFuNzw+crKSmRkZCAhIUGzTS6XIyEhAYcPHxY95vDhwzr7A8CwYcMM7g8AFRUVKC4u1nmRCE6wSERELsBpglBBQQGqq6sRFhamsz0sLAx5eXmix+Tl5Zm1PwAsX74cCoVC84qKiqp/4V3N8c2qGac3Jd6ZeZqIiMgJOU0QspUFCxZAqVRqXlevXrV3kRyLMtv0SvWsLSIiIifhNMPng4OD4eHhgWvXrulsv3btGsLDw0WPCQ8PN2t/APDy8oKXl1f9C+yqjK1Ur2iqqh1SByUux0FERA7OaWqEGjZsiB49emDv3r2abTU1Ndi7dy/i4+NFj4mPj9fZHwD27NljcH+SwNhK9X9mmK4tIiIiciBOUyMEAHPmzMHUqVPRs2dP9O7dG6tWrUJpaSmmT58OAEhKSkLTpk2xfPlyAMDTTz+NgQMHYuXKlRg1ahS2bt2KY8eO4YMPPrDn13Bu6pmn1RMsaq9Ur/67Nu3aIiIiIgfjVEFowoQJuH79OhYtWoS8vDx069YNaWlpmg7RWVlZkMvv1Fb07dsXW7ZswcKFC/H888+jTZs2SE1NRadOnez1FVyDeubpWivVi8zEwOU4iIjIgTnVPEL2wHmEjLh8QDVyTJ9MfruP0O3lOFoNUfUtCmzFmiEiIrIJqc9vp6oRIgej7i+k3Xla5gHM2ANUld1Zp2xVJ3aeJiIih+Q0naXJAemvVK+uAWrWQ7UcB8DO00RE5NBYI0T1o79SvXbTl6Gh9r+mAneNZjMZERHZHWuEqP4MLcgqOtQewLfPc0ZqIiJyCAxCZD36TWfa2ExGREQOgEGIrKt7EpB8Chj6Su3PhGrVEHxDy3FwqQ4iIrIy9hEi61M0VfUJ2rNQr8+Q7M48RPojyrhUBxER2QBrhMg2ajWT3f5PT2xEmZSFXYmIiCyANUJkO9ojzEqv316WQ4t6OQ4I4qPNrh4FCoNUnbABTtJIRET1xiBEtqVoqnops8UnY/T0Bor+qP2ZdjMaZLe3CXeazTh7NRER1QGDENmH/uKtMg+gywTgo4Q7YUcmAwQBqmY0QXxNM6EG2PXU7X3Zn4iIiMzDIET2o91U5umtFYIAVfCRA+M+xp3V7Q0Rbgcm3OlP1GoIa4aIiMgkBiGyL3VT2eUDtfsFoQbwCVbNWF2rqcwI/f5EDERERGQAR42RYxCbhVrmcWfZDp0RZ7ebzQCo/hOWQe9AVX+iTYmcwZqIiIxijRA5BrE+Q4mr7tTm6K9pBtz5+6W9d47T70/EpjIiIjJCJgiCYHo391VcXAyFQgGlUgl/f397F8f1KbPFF3CVepzYsHwAmLpbtR4aERG5BanPb9YIkWNR9xmq63GGhuWra5GIiIi0sI8QuRb9/kT6TWxERERaWCNErke/P5GpEKTM5mSMRERuikGIXJN2E5uxoMPFXYmI3BqDELk2saCjXo7D00d8cVftEWasLSIicmkMQuS6xFax116OAzLoLNcBqIbg/5oK3DX69rB8AyGKwYiIyCVw+LwJHD7vxC4fUE2qWCdaC7tqb+OaZkREToHD54nUs1WbWppDdB+x3w/01jTb9TTQ0BeIirszdF9dWwSw5oiIyAkwCJHr0p+tWj3rtHbIkXkAM/YAWT8D3z5v5gVqVJM3yuRAl4nAya1aTW5QXcdQkxr7HhEROQQ2jZnApjEXoD1btfZyHOo5hronqfZZ1UmvZkirKUwsREmm16SmHZrYxEZEZBVSn98MQiYwCLkgQ8t4HN9cOyRpz0eks6aZBck8gORTrBkiIrIgBiELYRByM6bWOlNmA1ePqla3N9X3yBxcC42IyKKkPr+5xAaRNkVTVSAxVDujaAp0GlN7GY+uD915r24KA6D6X0wmciItXAuNiMhu2FmaqC7ElvG4Z+Gd94DhfkldJgAnt+k2wWkHL3akJiKyGTaNmcCmMbII/SY37ffAneAjNomjsY7UDE1ERKI4jxCRI9Fe+0z7vfYSIPqTOKqX/Ai9C6gqrR12uE4aEVG9sUbIBNYIkdWIDtkXIZOpJnLUDjtix+qPPmNtERG5MdYIETm6wkvSRp6JzWatfq+zX7WquU2/pqkuTWwMUUTkJhiEiOxFdAkQ/Ukc9YPS7dmsIUOtRWPVo8/EFps1p4mNEz4SkRthECKyF/0lQPQncfT0Bj5KMFBrJEAVmm4HKfWxAPDrTvHaoo+G3GliS1gCRMYCnj61Q9MvW7SOux2iWg0xXDPE2iMicmJOE4QKCwsxe/Zs/O9//4NcLsfYsWOxevVq+Pr6Gtx/8eLF+Pbbb5GVlYWQkBCMHj0aL730EhQKhY1LT2SA2DB84M6fOmul6ROAsR8DPsF3hukb63Ok3cS2Z9HtjXq1SqLHaTW56WOHbSJyck4zoeLkyZPx66+/Ys+ePdi9ezcOHDiAxx9/3OD+OTk5yMnJwRtvvIHTp09j48aNSEtLw4wZM2xYaiIJjE3i2D1J1QF63EZV0NAm8wCiet+ZkVq7ZkeHsf/NpYyVkAOl11U1P4Dqz8sHgD8zxJvg1PsRETkBpxg1dubMGXTs2BHp6eno2bMnACAtLQ0jR47En3/+icjISEnn+fzzz/Hwww+jtLQUDRqIV4ZVVFSgoqJC8764uBhRUVEcNUb2J7YWmrr25fIBYFNi7WOGvQJE9THSxHabdhOb9oSP2kP69fsPGapNssZyIfVpfmPTHZFbcqlRY4cPH0ZAQIAmBAFAQkIC5HI5jhw5gjFjxkg6j/pmGApBALB8+XIsXbq03mUmsjhDzWiAeMdrmQfQcXTtvkj6ZB7AjD1AVZnuLNn6a6rp9x8SrU3Sqj0ytFabOpQA0gJKfZrf2HRHRCY4RRDKy8tDaGiozrYGDRogMDAQeXl5ks5RUFCAl156yWhzGgAsWLAAc+bM0bxX1wgROQT9iRm1t4t1vFbvqx2ick4A3y3R3a9Zj9rnKwySNrxfE8Bu1xBtn34ndLQaIj5rtn5Nk6GAYmgEnLHO25Y4lojchl2DUEpKClasWGF0nzNnztT7OsXFxRg1ahQ6duyIJUuWGN3Xy8sLXl5e9b4mkc0ZqzEC7oSolv2BTmMN76cmOrxfj7o2qSirdu3Rrqe0pgLQmzVbuzbJ2PB+sbmWjHXe1lafY8WwiY3IJdk1CM2dOxfTpk0zuk9MTAzCw8ORn5+vs/3vv/9GYWEhwsPDjR5/8+ZNDB8+HH5+fti5cyc8PT3rW2wix2Woxqgu+4nVMoktGNushyrA1ApMwp2RalJGphka3i/W5Kdeo80YQ82Fxo411HTHNeCIXJZdg1BISAhCQkJM7hcfH4+ioiJkZGSgRw9VFf6+fftQU1ODuLg4g8cVFxdj2LBh8PLywq5du9CoUSOLlZ3ILYjVMt2zsHZtkpTaI1PEhvdrOmjrhS9A1UFcrK+Rdggx1lyoz+C6byJrwKln+I6Kq30+V+6XZCrg1aUPmC3LR8a56QzzTjFqDABGjBiBa9euYd26daiqqsL06dPRs2dPbNmi6ryZnZ2NIUOGYPPmzejduzeKi4sxdOhQlJWVYefOnfDx8dGcKyQkBB4eHpKuy7XGiCTSHtUGOVTBQfufF5luU5kMt8OP2Aza2ofpdeY21tdIbFZs7SAHiP9D7+ljemSdaNn0go7o+nFyYNxH4qFJnyM8eAyVwVTAMxQkxfY153tKfThbM4Da4+di61AiZYZ57T5/ThCMpD6/nSYIFRYWYtasWToTKq5Zs0YzoeKVK1fQsmVL7N+/H4MGDcL333+PwYMHi57r8uXLiI6OlnRdBiEiMyiz74SOS3sNz5qtCSWmZtC+TT0kX+pCtWraC9Ea+4deysSSxq4xY4+qebC04PYSKGL7GXg4qx9wOZnAd4uNP3iMPQwt8ZmhJkBDi/yqv7epIGns52DsASt1+RcpixDrf1fA8L3V/sxUs6g1Akp9l70xt0yS/r/S+kXGSWo6XS4I2QuDEFE9aAcjk0Pkkw0P71c/0AzNl2TM1N2q65sToGoXQqs2S+xj2e3aLf1O4fr7aYWHWiPpjFzT1MNQ/8Gp7mNl6kFusDlQq7zJp1QPVbH7rvO9TTxKDP4cRB6wrYYAV48AX8yQ1lk/6zDw7b/Er6me08pYjVWtUKy+D0buidTFjc0NqFJCiVjIU6vLgsu/7hS/f8bol8ERajP1uNQ8QkTkpKR23jY1vL+ufZHUnaPFRpCJ7q81FYC66U67Nkt/biU1nU7hMsNl1O4Ubio0aXc2N7YGHFB7mgCdJVS0rqE9Qq/oD70QJlIOoVr1ndWBwej3NsLoz0Hve+qMNjRB534auCZQeyoF/VGLBufHMnJPrgqmFzeWGkK1A6DYWoFiZfg1FbhrdO0aL/0y6fdnM1QDaC7tEZh1CV8OFJpYI2QCa4SI7MBYTZJO7ZFeYBEb1Wao6USffl8kQLwMtfpCiZxz3EbVn2KhyZKGvgL4RxhujjNEU5Njckfz+nWZDJISanksQacp9pLxJkvzT16P2sHb/cUCWog0JZo4r+i19JoWTTXNGqz50t9X7/8lsT5/6hohQFqzpJoNBxOwacxCGISIHJB2UAJ0A4uhEKW/RImh0GTO9cX6N9VqOkk2HppEiXU2N8RUzZI5tB/GYmWQA+M2AAHNxb+3oSCp38FdJ1BJ/J6iD2eR+znsFdWM6oY61ZvN1D2pCzP6pNX63sbKZ4H/FtT3T///JbE+f92TDDdXD33lTo2VsUEJxkJTPTEIWQiDEJEL0Q9JUvswGWNsDTjta4p2CtfuH+MBJCwGIruLP3gkPwyNfWYkjOl3aC+9Ll67oO53Y+p7a39/0ZF0G1SLBmt/T2PhK6q37s/MWAgFjPdFMlaTaKg2y9g9UZdTctCVSD+U/JoKfPu8iYPqULOkOdREKKn1C4iJEZf2XJ8QDEIWwyBERCbVpVO42Eg60c60esHN0MNw3EbAJ1i8j5X6GqJhTC9oaF/bVJOHlO9tqMZA++EnpeZB6v00VkuhvkemahL1PzN2T4zVkplsRpPDYE2ToVFvUjr9S26a1QviUmtFRUe1GQrpJrBGyPExCBGRRdW3Fqq+AUVqTY65+9anvGLHSL1HYvvW5ZpSGbsnhoKuWCd70fmxDJzX0PVNBSgpzcHGgrgYY1MpZP0socYKdwJgXf+bkohByEIYhIjI4dQ3oNQ3aNi6vI52TWP3RGofNbHySL3X5tSgWbo52FgNn5RpKvQDoBVHjTEIWQiDEBE5JEsEFFuyR3kd7R5Zqzy2/J6matssOSihnhiELIRBiIiISIvUAQKWHJRQBwxCFsIgREREpMfRattEcGZpIiIisg6ps8Y7Abm9C0BERERkLwxCRERE5LYYhIiIiMhtMQgRERGR2zKrs3RRURF27tyJH3/8EX/88QfKysoQEhKC2NhYDBs2DH379rVWOYmIiIgsTlKNUE5ODh599FFERERg2bJlKC8vR7du3TBkyBA0a9YM+/fvx7333ouOHTti27Zt1i4zERERkUVIqhGKjY3F1KlTkZGRgY4dO4ruU15ejtTUVKxatQpXr17FvHnzLFpQIiIiIkuTNKHijRs3EBQUJPmk5u7vyDihIhERkfOR+vyW1DQWFBSE3bt3o6bGyEJqevsTEREROTrJo8ZGjx6NqKgo/Otf/8LFixetWSYiIiIim5AchC5fvownnngCW7duRbt27TBw4ED8+9//Rnl5uTXLR0RERGQ1koNQVFQUFi1ahEuXLuG7775DdHQ0nnzySUREROD//u//kJ6ebs1yEhEREVlcnSZUHDx4MDZt2oTc3Fy8/vrrOHXqFPr06YOuXbtaunxEREREVlOv1ef9/PwwZMgQ/PHHHzh79ix+++03S5WLiIiIyOrqVCNUXl6OzZs3Y9CgQWjTpg22bt2KOXPm4MqVKxYuHhEREZH1mFUj9PPPP2PDhg347LPPUFlZiQceeADfffcdBg8ebK3yEREREVmN5CDUsWNHnDt3DrGxsVi+fDkeeughKBQKa5aNiIjIYqqrq1FVVWXvYpCFeHp6wsPDo97nkRyEEhIS8Omnn7JDNBERORVBEJCXl4eioiJ7F4UsLCAgAOHh4ZDJZHU+h+QgtGbNmjpfhIiIyF7UISg0NBTe3t71emiSYxAEAWVlZcjPzwcARERE1PlckoLQ8OHDsWTJEvTp08fofjdv3sR7770HX19fzJw5s86FIiIisoTq6mpNCOLyT66lcePGAID8/HyEhobWuZlMUhAaP348xo4dC4VCgcTERPTs2RORkZFo1KgR/vrrL/z22284ePAgvvrqK4waNQqvv/56nQpDRERkSeo+Qd7e3nYuCVmD+udaVVVl3SA0Y8YMPPzww/j888+xbds2fPDBB1AqlQAAmUyGjh07YtiwYUhPT0eHDh3qVBAiIiJrYXOYa7LEz1VyHyEvLy88/PDDePjhhwEASqUS5eXlCAoKgqenZ70LQkRERGRrdZpQEQAUCgXCw8MZgoiIiJzElStXIJPJkJmZae+iOIw6ByEiIiIiZ+c0QaiwsBCTJ0+Gv78/AgICMGPGDJSUlEg6VhAEjBgxAjKZDKmpqdYtKBERkRVUVlbauwguyWmC0OTJk/Hrr79iz5492L17Nw4cOIDHH39c0rGrVq1iRzkiIqqXXGU5frpUgFxluU2uN2jQIMyaNQvJyckIDg7GsGHDcPr0aYwYMQK+vr4ICwvDlClTUFBQoDkmLS0N/fr1Q0BAAIKCgnDffffh0qVLNimvs3KKIHTmzBmkpaXhww8/RFxcHPr164e3334bW7duRU5OjtFjMzMzsXLlSmzYsEHStSoqKlBcXKzzIiIi97YtPQt3v7oPD60/grtf3Ydt6Vk2ue6mTZvQsGFDHDp0CK+++iruuecexMbG4tixY0hLS8O1a9fw4IMPavYvLS3FnDlzcOzYMezduxdyuRxjxoxBTU2NTcrrjMxadFWtqKgI27dvx6VLlzB//nwEBgbi+PHjCAsLQ9OmTS1dRhw+fBgBAQHo2bOnZltCQgLkcjmOHDmCMWPGiB5XVlaGhx56CO+++y7Cw8MlXWv58uVYunSpRcpNRETOL1dZjgU7TqFGUL2vEYDnd5zGgLYhiFA0tuq127Rpg9deew0AsGzZMsTGxuKVV17RfL5hwwZERUXh/PnzaNu2LcaOHatz/IYNGxASEoLffvsNnTp1smpZnZXZNUInT55E27ZtsWLFCrzxxhuatVt27NiBBQsWWLp8AFTTo4eGhupsa9CgAQIDA5GXl2fwuGeeeQZ9+/bF/fffL/laCxYsgFKp1LyuXr1a53ITEZHzu1xQqglBatWCgCsFZVa/do8ePTR//+WXX7B//374+vpqXu3btwcATfPXhQsXMGnSJMTExMDf3x/R0dEAgKws29RgOSOza4TmzJmDadOm4bXXXoOfn59m+8iRI/HQQw+Zda6UlBSsWLHC6D5nzpwxt4gAgF27dmHfvn04ceKEWcd5eXnBy8urTtckIiLX0zLYB3IZdMKQh0yG6GDrz1bt4+Oj+XtJSQkSExNFn5vqtbYSExPRokULrF+/HpGRkaipqUGnTp3Y0doIs4NQeno63n///VrbmzZtarR2RszcuXMxbdo0o/vExMQgPDxcs7Ca2t9//43CwkKDTV779u3DpUuXEBAQoLN97Nix6N+/P77//nuzykpERO4pQtEYyx/ojOd3nEa1IMBDJsMrD3SyerOYvu7du+OLL75AdHQ0GjSo/fi+ceMGzp07h/Xr16N///4AgIMHD9q0jM7I7CDk5eUl2oH4/PnzCAkJMetcISEhko6Jj49HUVERMjIyNNWE+/btQ01NDeLi4kSPSUlJwaOPPqqzrXPnznjrrbeQmJhoVjmJiMi9TejVHAPahuBKQRmig71tHoIAYObMmVi/fj0mTZqEZ599FoGBgbh48SK2bt2KDz/8EE2aNEFQUBA++OADREREICsrCykpKTYvp7Mxu4/QP/7xD7z44ouahexkMhmysrLw3HPP1eqkZSkdOnTA8OHD8dhjj+Ho0aM4dOgQZs2ahYkTJyIyMhIAkJ2djfbt2+Po0aMAgPDwcHTq1EnnBQDNmzdHy5YtrVJOIiJyXRGKxohvFWSXEAQAkZGROHToEKqrqzF06FB07twZycnJCAgIgFwuh1wux9atW5GRkYFOnTrhmWee4SLoEphdI7Ry5UqMGzcOoaGhKC8vx8CBA5GXl4f4+Hi8/PLL1igjAOCTTz7BrFmzMGTIEMjlcowdOxZr1qzRfF5VVYVz586hrMz6ndeIiIisTawLR5s2bbBjxw6DxyQkJOC3337T2SYIdzo3RUdH67ynOgQhhUKBPXv24ODBgzh58iRKSkrQvXt3JCQkWKN8GoGBgdiyZYvBz6X8cPnDJyIiIm11mkcIAPr164d+/fpZsixERERENmV2ENJujtImk8nQqFEjtG7dGgMGDICHh0e9C0dERERkTWYHobfeegvXr19HWVkZmjRpAgD466+/4O3tDV9fX+Tn5yMmJgb79+9HVFSUxQtMREREZClmjxp75ZVX0KtXL1y4cAE3btzAjRs3cP78ecTFxWH16tXIyspCeHg4nnnmGWuUl4iIiMhizK4RWrhwIb744gu0atVKs61169Z44403MHbsWPz+++947bXXrDaUnoiIiMhSzK4Rys3Nxd9//11r+99//62ZWToyMhI3b96sf+mIiIiIrMjsIDR48GA88cQTOmt4nThxAk8++STuueceAMCpU6c4aSERERE5PLOD0EcffYTAwED06NFDs0Bpz549ERgYiI8++ggA4Ovri5UrV1q8sERERESWZHYfofDwcOzZswdnz57F+fPnAQDt2rVDu3btNPsMHjzYciUkIiJyQ4MGDUK3bt2watUqu5YjOjoaycnJSE5Otms5rKXOEyq2b98e7du3t2RZiIiI6LYdO3bA09PT3sVAeno6fHx87F0Mq6lTEPrzzz+xa9cuZGVlobKyUuezN9980yIFIyIicmeBgYH2LgIAICQkxOrXqKysRMOGDa1+HTFm9xHau3cv2rVrh7Vr12LlypXYv38/Pv74Y2zYsAGZmZlWKCIREZEDUGYDlw+o/rSBQYMGaZqjoqOjsWzZMiQlJcHX1xctWrTArl27cP36ddx///3w9fVFly5dcOzYMc3xN27cwKRJk9C0aVN4e3ujc+fO+PTTT3WucfPmTUyePBk+Pj6IiIjAW2+9pXNd9bW1m+dkMhk+/PBDjBkzBt7e3mjTpg127dql+by6uhozZsxAy5Yt0bhxY7Rr1w6rV6/Wue60adMwevRovPzyy4iMjES7du3w4osvolOnTrXuQ7du3fDCCy/U404aZ3YQWrBgAebNm4dTp06hUaNG+OKLL3D16lUMHDgQ48ePt0YZiYiI7Ov4ZmBVJ2BTourP45ttXoS33noLd999N06cOIFRo0ZhypQpSEpKwsMPP4zjx4+jVatWSEpK0iwwfuvWLfTo0QNffvklTp8+jccffxxTpkzB0aNHNeecM2cODh06hF27dmHPnj348ccfcfz4cZNlWbp0KR588EGcPHkSI0eOxOTJk1FYWAgAqKmpQbNmzfD555/jt99+w6JFi/D888/js88+0znH3r17ce7cOezZswe7d+/GI488gjNnziA9PV2zz4kTJ3Dy5ElMnz7dErdQnGAmX19f4eLFi4IgCEJAQIBw+vRpQRAEITMzU2jRooW5p3N4SqVSACAolUp7F4WIiMxUXl4u/Pbbb0J5eXndT1L0pyAsCRCExf53XkuaqLZb0cCBA4Wnn35aEARBaNGihfDwww9rPsvNzRUACC+88IJm2+HDhwUAQm5ursFzjho1Spg7d64gCIJQXFwseHp6Cp9//rnm86KiIsHb21tzXfW133rrLc17AMLChQs170tKSgQAwtdff23wujNnzhTGjh2reT916lQhLCxMqKio0NlvxIgRwpNPPql5P3v2bGHQoEEGz2vs5yv1+W12jZCPj4+mX1BERAQuXbqk+aygoMAS2YyIiMhxFF4ChBrdbUI1UPi7TYvRpUsXzd/DwsIAAJ07d661LT8/H4Cqieqll15C586dERgYCF9fX3zzzTfIysoCAPz++++oqqpC7969NedQKBQ6o8CllMXHxwf+/v6a6wLAu+++ix49eiAkJAS+vr744IMPNNdV69y5c61+QY899hg+/fRT3Lp1C5WVldiyZQseeeQRk+WpD7M7S/fp0wcHDx5Ehw4dMHLkSMydOxenTp3Cjh070KdPH2uUkYiIyH4CWwEyuW4YknkAgTE2LYb2CDKZTGZwW02Nqpyvv/46Vq9ejVWrVqFz587w8fFBcnJyrUFO9S2L+trq627duhXz5s3DypUrER8fDz8/P7z++us4cuSIzjFiI9ESExPh5eWFnTt3omHDhqiqqsK4cePqXV5jzA5Cb775JkpKSgCo2ghLSkqwbds2tGnThiPGiIjI9SiaAomrgf8lq2qCZB5A4irVdgd26NAh3H///Xj44YcBqALS+fPn0bFjRwBATEwMPD09kZ6ejubNmwMAlEolzp8/jwEDBtTrun379sU///lPzTbt1iNjGjRogKlTp+Ljjz9Gw4YNMXHiRDRu3LjOZZF0TXMPiIm5k4B9fHywbt06ixaIiIjI4XRPAloNUTWHBcY4fAgCgDZt2mD79u346aef0KRJE7z55pu4du2aJgj5+flh6tSpmD9/PgIDAxEaGorFixdDLpdrapfqet3Nmzfjm2++QcuWLfHvf/8b6enpkpfeevTRR9GhQwcAqlBlbWb3EYqJicGNGzdqbS8qKtIJSURERC5F0RRo2d8pQhAALFy4EN27d8ewYcMwaNAghIeHY/To0Tr7vPnmm4iPj8d9992HhIQE3H333ejQoQMaNWpU5+s+8cQTeOCBBzBhwgTExcXhxo0bOrVDprRp0wZ9+/ZF+/btERcXV+dySCW73QNcMrlcjry8PISGhupsv3btGpo3b46KigqLFtDeiouLoVAooFQq4e/vb+/iEBGRGW7duoXLly+jZcuW9Xq4u4vS0lI0bdoUK1euxIwZM+xSBkEQ0KZNG/zzn//EnDlzjO5r7Ocr9fktuWlMe7Kkb775BgqFQvO+uroae/fuRXR0tNTTERERkZ2dOHECZ8+eRe/evaFUKvHiiy8CAO6//367lOf69evYunUr8vLyrDt3kBbJQUhdnSaTyTB16lSdzzw9PREdHc0V54mIiJzMG2+8gXPnzqFhw4bo0aMHfvzxRwQHB9ulLKGhoQgODsYHH3yAJk2a2OSakoOQelhcy5YtkZ6ebrebRERERJYRGxuLjIwMexdDw8zeOhZh9qixy5cvW6McRERERDYnKQitWbNG8gmfeuqpOheGiIjIGuxR00DWZ4mfq6Qg9NZbb0k6mUwmYxAiIiKHoZ4BuayszOoT85HtlZWVAag907U5JAUhNocREZEz8vDwQEBAgGYdLG9v73pNFkiOQRAElJWVIT8/HwEBAfDw8KjzuczuI6RfEAD8j4qIiBxWeHg4AOgsCkquISAgQPPzras6BaHNmzfj9ddfx4ULFwAAbdu2xfz58zFlypR6FYaIiMjSZDIZIiIiEBoaiqqqKnsXhyzE09OzXjVBanVadPWFF17ArFmzcPfddwMADh48iP/7v/9DQUEBnnnmmXoXioiIyNI8PDws8uAk12L2EhstW7bE0qVLkZSUpLN906ZNWLJkicv1J+ISG0RERM5H6vPb7EVXc3Nz0bdv31rb+/bti9zcXHNPR0RERGQ3Zgeh1q1b47PPPqu1fdu2bWjTpo1FCkVERERkC2b3EVq6dCkmTJiAAwcOaPoIHTp0CHv37hUNSERERESOSnKN0OnTpwEAY8eOxZEjRxAcHIzU1FSkpqYiODgYR48exZgxY6xWUCIiIiJLk9xZWi6Xo1evXnj00UcxceJE+Pn5WbtsDoGdpYmIiJyPxTtL//DDD7jrrrswd+5cREREYNq0afjxxx8tUlgpCgsLMXnyZPj7+yMgIAAzZsxASUmJyeMOHz6Me+65Bz4+PvD398eAAQNQXl5ugxITERGRo5MchPr3748NGzYgNzcXb7/9Ni5fvoyBAweibdu2WLFiBfLy8qxZTkyePBm//vor9uzZg927d+PAgQN4/PHHjR5z+PBhDB8+HEOHDsXRo0eRnp6OWbNmQS43u484ERERuSCz5xHSdvHiRXz88cf497//jby8PAwfPhy7du2yZPkAAGfOnEHHjh2Rnp6Onj17AgDS0tIwcuRI/Pnnn4iMjBQ9rk+fPrj33nvx0ksvSb5WRUUFKioqNO+Li4sRFRXFpjEiIiInYrV5hLS1bt0azz//PBYuXAg/Pz98+eWX9TmdQYcPH0ZAQIAmBAFAQkIC5HI5jhw5InpMfn4+jhw5gtDQUPTt2xdhYWEYOHAgDh48aPRay5cvh0Kh0LyioqIs+l2IiIjIcdQ5CB04cADTpk1DeHg45s+fjwceeACHDh2yZNk08vLyEBoaqrOtQYMGCAwMNNgk9/vvvwMAlixZgsceewxpaWno3r07hgwZolkjTcyCBQugVCo1r6tXr1ruixAREZFDMSsI5eTk4JVXXkHbtm0xaNAgXLx4EWvWrEFOTg7Wr1+PPn36mHXxlJQUyGQyo6+zZ8+adU61mpoaAMATTzyB6dOnIzY2Fm+99RbatWuHDRs2GDzOy8sL/v7+Oi8iIiJyTZInVBwxYgS+++47BAcHIykpCY888gjatWtXr4vPnTsX06ZNM7pPTEwMwsPDkZ+fr7P977//RmFhIcLDw0WPi4iIAAB07NhRZ3uHDh2QlZVV90ITERGRy5AchDw9PbF9+3bcd999Flu9NyQkBCEhISb3i4+PR1FRETIyMtCjRw8AwL59+1BTU4O4uDjRY6KjoxEZGYlz587pbD9//jxGjBhR/8ITERGR05MchKwxGkyqDh06YPjw4Xjsscewbt06VFVVYdasWZg4caJmxFh2djaGDBmCzZs3o3fv3pDJZJg/fz4WL16Mrl27olu3bti0aRPOnj2L7du32+27EBERkeMwe60xe/nkk08wa9YsDBkyBHK5HGPHjsWaNWs0n1dVVeHcuXMoKyvTbEtOTsatW7fwzDPPoLCwEF27dsWePXvQqlUre3wFIiIicjD1mkfIHXCJDSIiIudjk3mEiIiIiJwZgxARERG5LQYhIiIiclsMQkREROS2GISIiIjIbTEIERERkdtiECIiIiK3xSBEREREbotBiIiIiNwWgxARERG5LQYhIiIiclsMQkREROS2GISIiIjIbTEIERERkdtiECIiIiK3xSBEREREbotBiIiIiNwWgxARERG5LQYhIiIiB5CrLMdPlwqQqyy3d1HcSgN7F4CIiNxbrrIclwtK0TLYBxGKxrXeu4Nt6VlYsOMUagRALgOWP9AZE3o1t3ex6sTZfn4MQkREZJC1H2r6AWBMbFPsPJHt0IHAnHuivS8A0eNyleWaewAANQLw/I7TGNA2RLOfsWvW9TNrnFdKoHO0oMQgRERUT5b6h90eNSPGrmHqoVbXQKD9cNcPAF8cz9YcIxYI6vpd9D8HUKd7bc49OXD+umZf2e3PBdQ+7nJBqeYeqFULAq4UlCFC0bjWNZ8b3h6dmylqXUP/vGJlHdA2RLR8Uo41dd5jVwpFA137cD+UVlabvKa9yARBEEzv5r6Ki4uhUCigVCrh7+9v7+IQkQm2/m3T3LAg9TdpUzUjxs4LiNc86B97KluJFV+fFb1GrrIcd7+6T+cBLQew5qFY9GjRxKwHmqF79NOlAjy0/ojJe/zpY30Q3yrI7J+DoYe+fijRv9faQUP73vo09MCY936SdE+0ryHGQybDjn/Go7SyWvS8HjIZDqYMBoBaPwc1sWuoz5tVWIant2bqHCcDIJPBYPmMXdPYZ9rnFSOTAYKJa1rj/1Wpz28GIRMYhIich637WYiFBe0HnH7QEAs36t+k9R9a+qSeV6zmwVAgMHaNwtJKzNpyQrQsUh5oxsKDlIe8mnbQEAuSucpy0ftn6qEvhdi9NXSOulxDHRDU10k9kYNqQYCHTIZnh7dD52YKoz8HU+eti4WjOiBc0Uj0mu9MikVucTle/vJs3U5ugJSgWxcMQhbCIERkOVJra+rS5GLsgSuln0Vdym6oRkPqg8jUb9J1Pa+ha0h5WBv77d0U9QNNO5AaCg8LR3XAqC4ROHD+Op7fcVoTAEbHRmoCgamaG+33zk4dQssqa3Ayu0gTdOsa4upD7Jrm/rcKqEJsjYl9HKFGiH2EiMgmpNbWmFOrY+qBa6yfhX5NiTnNVuqmE5+GHpCLPBykhhXBjH3NOa+ha0g5XHtfGSD6/cR4yGSIDvau1e/H0KHLvjyDV746g+UPdMbBlMG4UlCG6GBvRCgaY96wdsi48hee2nrCaP8h7fe2JPWe1Aqh6hog1A4I1YKAssoaRAd7Y/KHP+vcP2M/B+1rGAse8tvnkhJu9K+pPlbs+mLnlQN4+6FYNGvSuNYvJ9rX9JDJ8MoDnezeYZpBiIisTsqoGHP30++YKfZcMvRwrhGAlC9O3XmAGOkn4tPQo9axy79WNQ3oN2lI+Q1YCv2aEUud1xixawgA3p4YCwA6oQQQf6ABwO6TOeIPTJEHrvrnezBlsE7TSISiMQJ9a3cgNue7GHvoa4cS/Xttirrm5mphuaR7MqBtiCbkAcCVgjJ4N5SL1l5GB3uLdpxW/xyCfL1wMrsIr319TlODpn0NsfOqQ0n3232YtGvf1Md+eTIXy748Y/CaN0orRJvKXhjVASNFavVeeaATRnWJBKD6hUPsmtrB194YhIjIYgzVqBgaFfPlyVyM6hKh2dfU6BlAt3ZGjFzkt82fLhWIPlwErXCjX9ugDjvG+oXUCEDqiRxNk4bYg0hNLNwY+k26++3+MPOGtTP4gDN0Xv2aB2OBQN0XpUuzAIMP5x7RqrKUVv5t9IF24Px1g/191OEh/cpftR64+j9ftZbBPpJrXsTun6GHvn4o0a6FulJQVitoaN9b9Xm6RjVB16gmJu+J+jtpfzf138UCgvoz/e+t/XOIbxWEf3SNNHgNsfOqQ8mEXs1FyzeqSwRe+eqMwWvmKstFyzTy9v+7hs5r7JqOEIDU2EfIBPYRIpLGWJOWWKdiNVOdhk2NrtGm3c9C/Y+uoc60lqTd2XNbepbOg0gdNLTLox0e9B9axpoBpZ4XgNFrGHpo6V9Dvzza19CvoTMWgtTnMdS53FAfEf3y6IcSsZAipbym6B9n7Dx1vYaxY039HOp6XmNMXbO+ZbIHdpa2EAYhckfmzLdiKGjoP+C0/yHVZ6rZQsqoHUP/eOsMZzZSU2KKodoJsQe5OQ8ia+1ry2sY6jSubjqpz0PeVCipTxBxZPb4Xqau6Wz3mkHIQhiEyN3UCg+o+6iddybFItC3oU5oEuuPoM9YZ0tD+6qbk9QMzYNjqOnEWD8R/RE9+n00HP03Y2szt6bH2R6o5Jw4aoyIdEiZLl+/Y7B2JDB31I4MdzrYajeVifVH0FcDINDHC6WV1UY73ur3gdAm1t9IfV5D/RoM9RNR9wsBYLCPhjuLUDQ22udFbH/eN3IUDEJEbkDqFP3Gmp7MoT/cVn/0l/ZDU6yZSj2CBhDvOKrfD0iMWGdb7fMCtR/I6vemwg4f5LUZ6zBL5MgYhIiciKnlGqSu56Q9Igq4E0LqG4LUTU8CUGu4rfboIP2HpliHXmOjYNS1M8aYW0shdjwf5ubhPSNnxCBEZGd1XezRWH8d7aYosSYiNUPBR26k47KpUTujukQaHG5rqDamLsNvpWAtBRGZws7SJrCzNFmTlFmU6zr8W71GU5SEDsfa9JueANRp1I4zDrclItfhcqPGCgsLMXv2bPzvf/+DXC7H2LFjsXr1avj6+ho8Ji8vD/Pnz8eePXtw8+ZNtGvXDv/6178wduxYyddlECJLMNRkZWqkjanJA6XQn/1Yn9hsuJYKLBwdRET24nKjxiZPnozc3Fzs2bMHVVVVmD59Oh5//HFs2bLF4DFJSUkoKirCrl27EBwcjC1btuDBBx/EsWPHEBsba8PSkzszVOtjaBbljCt/IdC39giuutKf/djYFP2WDizsM0JEjs4paoTOnDmDjh07Ij09HT179gQApKWlYeTIkfjzzz8RGVl76CwA+Pr6Yu3atZgyZYpmW1BQEFasWIFHH31U9JiKigpUVFRo3hcXFyMqKoo1QlQnhmp9dvwzHlmFZbWau/QnFjQ2eaCx/jpitGc/Zk0NEbk6l6oROnz4MAICAjQhCAASEhIgl8tx5MgRjBkzRvS4vn37Ytu2bRg1ahQCAgLw2Wef4datWxg0aJDBay1fvhxLly619FcgNyDW/GWo1mf0ez9BEO4EH+3Zjo0tImpoLSpjq3YDpoeNExG5K6cIQnl5eQgNDdXZ1qBBAwQGBiIvL8/gcZ999hkmTJiAoKAgNGjQAN7e3ti5cydat25t8JgFCxZgzpw5mvfqGiEiYww1fxlaOFLQCjtyAXjHwJBzwPjkgWLz4NzXVXyBTAYfIqLa7BqEUlJSsGLFCqP7nDljfCp+Y1544QUUFRXhu+++Q3BwMFJTU/Hggw/ixx9/ROfOnUWP8fLygpeXV52vSe7D0GzMNQKw4ItT8PFqgB4tmtSaPLBG7zzq2Y6jg73rPHmgPg4bJyKSxq59hK5fv44bN24Y3ScmJgb/+c9/MHfuXPz111+a7X///TcaNWqEzz//XLRp7NKlS2jdujVOnz6Nu+66S7M9ISEBrVu3xrp16ySVkaPG3Etd5vQx1pdHe2X1KwVl8G4orzWUXXukGIecExFZhlP0EQoJCUFISIjJ/eLj41FUVISMjAz06NEDALBv3z7U1NQgLi5O9JiysjIAgFwu19nu4eGBmhr938nJnanDz6lsJVZ8fVbSnD6G1uPSp15a4mDKYE1HZWOzHbMmh4jItpxi1BgAjBgxAteuXcO6des0w+d79uypGT6fnZ2NIUOGYPPmzejduzeqqqrQsWNHRERE4I033kBQUBBSU1Mxf/587N69GyNHjpR0XdYIuTZj8/SYO6ePWF8gNe0RWwBHbRERWZtT1AiZ45NPPsGsWbMwZMgQzYSKa9as0XxeVVWFc+fOaWqCPD098dVXXyElJQWJiYkoKSlB69atsWnTJskhiFyTob49+syZ00fdl+dqYbnJEVsAR20RETkKp6kRshfWCDk/7X4/5qy0bs6cPtp9edjPh4jI/lyuRoioLvQ7NQPSVlqvy5w+auznQ0TkPBiEyCWZ06lZe56eZ4e3Q5dmAbhRWmH2nD7a2PRFROQcGITI5ZizUKmheXpyleUWm9OHiIgcF4MQuZRcZbnRECS20nrXqCa19otQNBYd5i62LxEROS8GIXJK+hMfqt8XllYaHdllzkrr7OtDROT6GITI6eiv6zUmtil2nsjWdIjWH+El1qlZaqhhXx8iItfGIEQOxdgSF2IdoGsE4Ivj2Zp9BKiCkNROzURE5N4YhMhhGFrBXf8zUwQAb0+MRZCvF5u0iIjIKAYhcgj6nZzVa3QNaKtai05qCAJUtUA9opswABERkUly07sQWd/lgtJaQadaEHCloEz0MzUPmQxjuzeFh0ymea+9iCkREZExrBEih9Ay2KfWvD1yADdKKxDVpLHoZ9odoOcNa8fRXUREZDauNWYC1xqzLv11wNTz9mgvh6EeGZZ6IofrdxERkSRca4wckqEFUNWdow+mDEbGlb90VnCvEYDUEzmc1ZmIiCyOQYhsxtgCqOrO0QdTBiPQt6Fof6GyyhrEtwqyZZGJiMjFsbM02YT+qDABtRdBVXeOVvcX0uYhkyE62NsWRSUiIjfCIERWl6ssx+6TOSaHv6vDjnqdL44EIyIia2PTGFmVsYkQxRZAVYcdrvNFRES2wCBEVmNsJXgpC6BynS8iIrI2BiGqN3NXgn9hVAeM7BJh9gKoRERElsYgRPVi7krwHjKZTggiIiKyJ3aWpjoTWx/si+PZOiPDAGhGgLHTMxERORrWCFGdSB0JxpXgiYjIkTEIkdmMjQTTx5XgiYjIkbFpjMxiaiQYV4InIiJnwhohMsvlglKTI8G4EjwRETkLBiEyi3r5C+0wpD8SjPP/EBGRs2DTGJmFy18QEZErYY0QidKfJFEbl78gIiJXwSBEtehPkrj8gc6Y0Ku5zj5s/iIiIlfAIEQ6xCZJfH7HabQP90NpZbVoDREREZGzYhAiHWKjwqoFAaPf+wmCkRoiIiIiZ8TO0qRDPSpMn6BXQ5SrLLdtwYiIiKyAQYh06I8KE/sPpFoQcKWgzLYFIyIisgI2jZGGeqTYgLYhOJgyGFcKyuDdUI4x7/1Ua96g6GBv+xWUiIjIQhiECIDxkWLLH+iM53ecRrUgcN4gIiJyKU7TNPbyyy+jb9++8Pb2RkBAgKRjBEHAokWLEBERgcaNGyMhIQEXLlywbkGdkKGRYup+QBN6NcfBlMH49LE+OJgymB2liYjIZThNEKqsrMT48ePx5JNPSj7mtddew5o1a7Bu3TocOXIEPj4+GDZsGG7dumXFkjofQyPFtPsBRSgaI75VEGuCiIjIpThN09jSpUsBABs3bpS0vyAIWLVqFRYuXIj7778fALB582aEhYUhNTUVEydOtFZRnYa6T5BPQw/R9cPYD4iIiFyd0wQhc12+fBl5eXlISEjQbFMoFIiLi8Phw4cNBqGKigpUVFRo3hcXF1u9rLakDj+nspVY8fVZTZ+gMbFNkXoih/2AiIjIrbhsEMrLywMAhIWF6WwPCwvTfCZm+fLlmtonV6PdIVpbjQCknsjBjn/Go6yyhuuHERGR27BrH6GUlBTIZDKjr7Nnz9q0TAsWLIBSqdS8rl69atPrW4t+h2h91YKAssoa9gMiIiK3Ytcaoblz52LatGlG94mJianTucPDwwEA165dQ0REhGb7tWvX0K1bN4PHeXl5wcvLq07XdETqprDC0kqDIQhgnyAiInJPdg1CISEhCAkJscq5W7ZsifDwcOzdu1cTfIqLi3HkyBGzRp45M+2mMBlUL7EsxD5BRETkrpymj1BWVhYKCwuRlZWF6upqZGZmAgBat24NX19fAED79u2xfPlyjBkzBjKZDMnJyVi2bBnatGmDli1b4oUXXkBkZCRGjx5tvy9iI/pNYQJUQUg9OsxDJsOzw9uhS7MA9gkiIiK35TRBaNGiRdi0aZPmfWxsLABg//79GDRoEADg3LlzUCqVmn2effZZlJaW4vHHH0dRURH69euHtLQ0NGrUyKZltwexuYEEAG9PjEWQrxfDDxEREQCZIAhGeo5QcXExFAoFlEol/P397V0ck7TnBhJbI+xgymAGICIicnlSn99OUyNEpumvF8a5gYiIiIxjEHIRYuuFcW4gIiIi4xiEXISh9cLUcwMRERFRbU6z6CoZ1zLYB3KZ7jbODURERGQcg5ATylWW46dLBchVlmveXy4oxXMj2sNDpkpD7BNERERkGpvGnIxYh+idJ7I1758b3p5zAxEREUnEGiEnItYh+ovj2TrvX0s7xxBEREQkEYOQExHrEK2vWhBwpaDMNgUiIiJycgxCTkSsQ7Q+dpAmIiKSjkHIiUQoGmP5A511OkSP7d6UHaSJiIjqiEtsmOCIS2zkKstxpaBM0xdI/z0REZG74xIbLixC0Vgn8Oi/JyIiImnYNEZERERui0GIiIiI3BaDkBPQn0maiIiILIN9hByc/kzSyx/ojAm9mtu7WERERC6BNUIOKldZjv/9kl1rJunnd5xmzRAREZGFsEbIAWnXAulTzxzNUWJERET1xxohB6O/npg+zhxNRERkOQxCDsbYemKcOZqIiMiy2DTmYNTriWmHITmAtx+KRfcWTRiCiIiILIg1Qg5GbD2x5WM7Y1SXSIYgIiIiC2ONkAOa0Ks5BrQN4fphREREVsYg5CByleW4XFCKlsE+mrXDGICIiIisi0HIAXDSRCIiIvtgHyE70x8uz0kTiYiIbIdByM7EhsurJ00kIiIi62IQsjP1cHltnDSRiIjINhiE7ExsuDwnTSQiIrINdpa2E+1RYhwuT0RE7kh/xLQ9MAjZgaFRYgxARETkLhxlxDSbxmyMo8SIiMjdOdKzkEHIxjhKjIiI3J0jPQsZhGyMo8SIiMjdOdKzkEHIxjhKjIiI3J0jPQtlgiAIpndzX8XFxVAoFFAqlfD397fYeXOV5RwlRkREbs2az0Kpz2+nqRF6+eWX0bdvX3h7eyMgIMDk/lVVVXjuuefQuXNn+Pj4IDIyEklJScjJybF+YSWIUDRGfKsghiAiInJbjvAsdJogVFlZifHjx+PJJ5+UtH9ZWRmOHz+OF154AcePH8eOHTtw7tw5/OMf/7BySYmIiMhZOF3T2MaNG5GcnIyioiKzj01PT0fv3r3xxx9/oHlzaXMVWKtpjIiIiKxH6vPbrSZUVCqVkMlkRpvWKioqUFFRoXlfXFxsg5IRERGRPThN01h93bp1C8899xwmTZpkNBkuX74cCoVC84qKirJhKYmIiMiW7BqEUlJSIJPJjL7Onj1b7+tUVVXhwQcfhCAIWLt2rdF9FyxYAKVSqXldvXq13tcnIiIix2TXprG5c+di2rRpRveJiYmp1zXUIeiPP/7Avn37TPbz8fLygpeXV72uSURERM7BrkEoJCQEISEhVju/OgRduHAB+/fvR1BQkNWuRURERM7HafoIZWVlITMzE1lZWaiurkZmZiYyMzNRUlKi2ad9+/bYuXMnAFUIGjduHI4dO4ZPPvkE1dXVyMvLQ15eHiorK+31NYiIiMiBOM2osUWLFmHTpk2a97GxsQCA/fv3Y9CgQQCAc+fOQalUAgCys7Oxa9cuAEC3bt10zqV9DBEREbkvp5tHyNY4jxAREZHzcbklNoiIiIgszWmaxuxFXWHGiRWJiIich/q5barhi0HIhJs3bwIAJ1YkIiJyQjdv3oRCoTD4OfsImVBTU4OcnBz4+flBJpNZ5JzFxcWIiorC1atX2e/IynivbYf32nZ4r22H99p2LH2vBUHAzZs3ERkZCbnccE8g1giZIJfL0axZM6uc29/fn/9j2Qjvte3wXtsO77Xt8F7bjiXvtbGaIDV2liYiIiK3xSBEREREbotByA68vLywePFirmlmA7zXtsN7bTu817bDe2079rrX7CxNREREbos1QkREROS2GISIiIjIbTEIERERkdtiECIiIiK3xSBkY++++y6io6PRqFEjxMXF4ejRo/Yukks6cOAAEhMTERkZCZlMhtTUVHsXySUtX74cvXr1gp+fH0JDQzF69GicO3fO3sVySWvXrkWXLl00k83Fx8fj66+/tnex3MKrr74KmUyG5ORkexfF5SxZsgQymUzn1b59e5uWgUHIhrZt24Y5c+Zg8eLFOH78OLp27Yphw4YhPz/f3kVzOaWlpejatSveffddexfFpf3www+YOXMmfv75Z+zZswdVVVUYOnQoSktL7V00l9OsWTO8+uqryMjIwLFjx3DPPffg/vvvx6+//mrvorm09PR0vP/+++jSpYu9i+Ky7rrrLuTm5mpeBw8etOn1OXzehuLi4tCrVy+88847AFTrmEVFRWH27NlISUmxc+lcl0wmw86dOzF69Gh7F8XlXb9+HaGhofjhhx8wYMAAexfH5QUGBuL111/HjBkz7F0Ul1RSUoLu3bvjvffew7Jly9CtWzesWrXK3sVyKUuWLEFqaioyMzPtVgbWCNlIZWUlMjIykJCQoNkml8uRkJCAw4cP27FkRJajVCoBqB7QZD3V1dXYunUrSktLER8fb+/iuKyZM2di1KhROv9uk+VduHABkZGRiImJweTJk5GVlWXT63PRVRspKChAdXU1wsLCdLaHhYXh7NmzdioVkeXU1NQgOTkZd999Nzp16mTv4rikU6dOIT4+Hrdu3YKvry927tyJjh072rtYLmnr1q04fvw40tPT7V0UlxYXF4eNGzeiXbt2yM3NxdKlS9G/f3+cPn0afn5+NikDgxARWcTMmTNx+vRpm7fvu5N27dohMzMTSqUS27dvx9SpU/HDDz8wDFnY1atX8fTTT2PPnj1o1KiRvYvj0kaMGKH5e5cuXRAXF4cWLVrgs88+s1mTL4OQjQQHB8PDwwPXrl3T2X7t2jWEh4fbqVREljFr1izs3r0bBw4cQLNmzexdHJfVsGFDtG7dGgDQo0cPpKenY/Xq1Xj//fftXDLXkpGRgfz8fHTv3l2zrbq6GgcOHMA777yDiooKeHh42LGErisgIABt27bFxYsXbXZN9hGykYYNG6JHjx7Yu3evZltNTQ327t3LNn5yWoIgYNasWdi5cyf27duHli1b2rtIbqWmpgYVFRX2LobLGTJkCE6dOoXMzEzNq2fPnpg8eTIyMzMZgqyopKQEly5dQkREhM2uyRohG5ozZw6mTp2Knj17onfv3li1ahVKS0sxffp0exfN5ZSUlOj8RnH58mVkZmYiMDAQzZs3t2PJXMvMmTOxZcsW/Pe//4Wfnx/y8vIAAAqFAo0bN7Zz6VzLggULMGLECDRv3hw3b97Eli1b8P333+Obb76xd9Fcjp+fX61+bj4+PggKCmL/NwubN28eEhMT0aJFC+Tk5GDx4sXw8PDApEmTbFYGBiEbmjBhAq5fv45FixYhLy8P3bp1Q1paWq0O1FR/x44dw+DBgzXv58yZAwCYOnUqNm7caKdSuZ61a9cCAAYNGqSz/eOPP8a0adNsXyAXlp+fj6SkJOTm5kKhUKBLly745ptvcO+999q7aER19ueff2LSpEm4ceMGQkJC0K9fP/z8888ICQmxWRk4jxARERG5LfYRIiIiIrfFIERERERui0GIiIiI3BaDEBEREbktBiEiIiJyWwxCRERE5LYYhIiIiMhtMQgRERGRRRw4cACJiYmIjIyETCZDamqqVa+3ZMkSyGQynVf79u3NOgeDEBHZ1aBBg5CcnKx5Hx0djVWrVln8OtOmTcPo0aMtfl6ppkyZgldeeUXSvhMnTsTKlSutXCIiyystLUXXrl3x7rvv2uyad911F3JzczWvgwcPmnU8gxARWY09wseVK1cgk8mQmZmps3316tV2W17ll19+wVdffYWnnnpK0v4LFy7Eyy+/DKVSaeWSEVnWiBEjsGzZMowZM0b084qKCsybNw9NmzaFj48P4uLi8P3339frmg0aNEB4eLjmFRwcbNbxDEJE5BYUCgUCAgLscu23334b48ePh6+vr6T9O3XqhFatWuE///mPlUtGZFuzZs3C4cOHsXXrVpw8eRLjx4/H8OHDceHChTqf88KFC4iMjERMTAwmT56MrKwss45nECIimyktLUVSUhJ8fX0REREhqfmnqKgIjz76KEJCQuDv74977rkHv/zyi8H9W7ZsCQCIjY2FTCbTLAirXzs1aNAgzJ49G8nJyWjSpAnCwsKwfv16lJaWYvr06fDz80Pr1q3x9ddf65z/9OnTGDFiBHx9fREWFoYpU6agoKDAYHmqq6uxfft2JCYm6mx/77330KZNGzRq1AhhYWEYN26czueJiYnYunWryftD5CyysrLw8ccf4/PPP0f//v3RqlUrzJs3D/369cPHH39cp3PGxcVh48aNSEtLw9q1a3H58mX0798fN2/elHwOBiEispn58+fjhx9+wH//+198++23+P7773H8+HGjx4wfPx75+fn4+uuvkZGRge7du2PIkCEoLCwU3f/o0aMAgO+++w65ubnYsWOHwXNv2rQJwcHBOHr0KGbPno0nn3wS48ePR9++fXH8+HEMHToUU6ZMQVlZGQBVKLvnnnsQGxuLY8eOIS0tDdeuXcODDz5o8BonT56EUqlEz549NduOHTuGp556Ci+++CLOnTuHtLQ0DBgwQOe43r174+jRo6ioqDB6f4icxalTp1BdXY22bdvC19dX8/rhhx9w6dIlAMDZs2drdX7Wf6WkpGjOOWLECIwfPx5dunTBsGHD8NVXX6GoqAifffaZ5HI1sPg3JSISUVJSgo8++gj/+c9/MGTIEACqINKsWTODxxw8eBBHjx5Ffn4+vLy8AABvvPEGUlNTsX37djz++OO1jgkJCQEABAUFITw83GiZunbtioULFwIAFixYgFdffRXBwcF47LHHAACLFi3C2rVrcfLkSfTp0wfvvPMOYmNjdTo9b9iwAVFRUTh//jzatm1b6xp//PEHPDw8EBoaqtmWlZUFHx8f3HffffDz80OLFi0QGxurc1xkZCQqKyuRl5eHFi1aGP0eRM6gpKQEHh4eyMjIgIeHh85n6mbjmJgYnDlzxuh5goKCDH4WEBCAtm3b4uLFi5LLxSBERDZx6dIlVFZWIi4uTrMtMDAQ7dq1M3jML7/8gpKSklr/8JWXl2t+g6yPLl26aP7u4eGBoKAgdO7cWbMtLCwMAJCfn68pz/79+0X7+ly6dEk0CJWXl8PLywsymUyz7d5770WLFi0QExOD4cOHY/jw4RgzZgy8vb01+zRu3BgANLVRRM4uNjYW1dXVyM/PR//+/UX3adiwodnD37WVlJTg0qVLmDJliuRjGISIyGGVlJQgIiJCdFSJJTo+e3p66ryXyWQ629ThpaamRlOexMRErFixota5IiIiRK8RHByMsrIyVFZWomHDhgAAPz8/HD9+HN9//z2+/fZbLFq0CEuWLEF6errme6mb/tQ1XETOoKSkRKc25vLly8jMzERgYCDatm2LyZMnIykpCStXrkRsbCyuX7+OvXv3okuXLhg1apTZ15s3bx4SExPRokUL5OTkYPHixfDw8MCkSZMkn4NBiIhsolWrVvD09MSRI0fQvHlzAMBff/2F8+fPY+DAgaLHdO/eHXl5eWjQoAGio6MlXUcdNqqrqy1Sbv3yfPHFF4iOjkaDBtL++ezWrRsA4LffftP8HVAN+U1ISEBCQgIWL16MgIAA7Nu3Dw888AAAVafsZs2amT0UmMiejh07hsGDB2vez5kzBwAwdepUbNy4ER9//DGWLVuGuXPnIjs7G8HBwejTpw/uu+++Ol3vzz//xKRJk3Djxg2EhISgX79++Pnnn836BYJBiIhswtfXFzNmzMD8+fMRFBSE0NBQ/Otf/4JcbnjMRkJCAuLj4zF69Gi89tpraNu2LXJycvDll19izJgxOh2Q1UJDQ9G4cWOkpaWhWbNmaNSoERQKhUW+w8yZM7F+/XpMmjQJzz77LAIDA3Hx4kVs3boVH374Ya1+D4CqRqd79+44ePCgJgjt3r0bv//+OwYMGIAmTZrgq6++Qk1NjU4z4Y8//oihQ4dapNxEtjJo0CAIgmDwc09PTyxduhRLly61yPUsMbKSo8aIyGZef/119O/fH4mJiUhISEC/fv3Qo0cPg/vLZDJ89dVXGDBgAKZPn462bdti4sSJ+OOPPzT9d/Q1aNAAa9aswfvvv4/IyEjcf//9Fit/ZGQkDh06hOrqagwdOhSdO3dGcnIyAgICjAa6Rx99FJ988onmfUBAAHbs2IF77rkHHTp0wLp16/Dpp5/irrvuAgDcunULqampmk7bRGQ9MsFYdCMionorLy9Hu3btsG3bNsTHx5vcf+3atdi5cye+/fZbG5SOyL2xRoiIyMoaN26MzZs3G514UZunpyfefvttK5eKiADWCBEREZEbY40QERERuS0GISIiInJbDEJERETkthiEiIiIyG0xCBEREZHbYhAiIiIit8UgRERERG6LQYiIiIjcFoMQERERua3/B3pqCi8/4RlXAAAAAElFTkSuQmCC", "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": "f424d1f6", "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": "0c42cec6", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.operations.pulse_library 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": "3472e83b", "metadata": {}, "source": [ "Again, we define the gettable and run the experiment." ] }, { "cell_type": "code", "execution_count": 7, "id": "20085799", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/compiler_abc.py:634: 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": "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", "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": "772c11fc", "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": "62c5fb0e", "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": "db0e710f", "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": "08cdcd2b", "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": "889476564b3b4e18bbd5c8e7bcfead46", "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": "7a578532", "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": "6c035a55", "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:                             20241014-165519-251-953db5\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: 20241014-165519-251-953db5\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": "2f201c27", "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": "affeea95", "metadata": {}, "outputs": [], "source": [ "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", "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "quantum_device = QuantumDevice(name=\"quantum_sample\")\n", "quantum_device.cfg_sched_repetitions(2)\n", "\n", "from quantify_scheduler.gettables import ScheduleGettable\n", "schedule_gettable = ScheduleGettable(\n", " quantum_device=quantum_device,\n", " schedule_function=schedule_function,\n", " schedule_kwargs={\"q0\": \"q0\"},\n", ")" ] }, { "cell_type": "markdown", "id": "b9899312", "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": "f6c53cf4", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "quantum_device.close()" ] }, { "cell_type": "code", "execution_count": 13, "id": "3a9e6e17", "metadata": {}, "outputs": [], "source": [ "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", "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "quantum_device = QuantumDevice(name=\"quantum_sample\")\n", "\n", "from quantify_scheduler.gettables import ScheduleGettable\n", "schedule_gettable = ScheduleGettable(\n", " quantum_device=quantum_device,\n", " schedule_function=schedule_function,\n", " schedule_kwargs={\"q0\": \"q0\"},\n", ")" ] }, { "cell_type": "markdown", "id": "9f7dea2d", "metadata": {}, "source": [ "(sec-schedulegettable-2dsweep-usage)=\n", "\n", "## 2D (and ND) measurement loops" ] }, { "cell_type": "code", "execution_count": 14, "id": "7ab51fe8", "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.device_under_test.quantum_device import QuantumDevice\n", "from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement\n", "from quantify_scheduler.instrument_coordinator import InstrumentCoordinator\n", "from quantify_scheduler.instrument_coordinator.components.qblox import ClusterComponent\n", "\n", "\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", " \"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}.module2.complex_output_0\", \"q0:mw\"],\n", " [f\"{cluster.name}.module3.complex_output_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": "f725e8c7", "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": "b98b7732", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations.gate_library import Measure, Reset, X, X90\n", "from quantify_scheduler.operations.pulse_library import SquarePulse\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": "77151546", "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": "55b4456c", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting iterative measurement...\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "12305b965c8344cca940b5cb810e2a8e", "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": "fac10061", "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:                             20241014-165520-417-056f67\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: 20241014-165520-417-056f67\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": "18e28aca", "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": "95311c10", "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": "dc38f3d5", "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": "49b60c7d", "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": "d7046176", "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": "e3fafd764e824e4d81b0512f43b4ce03", "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": "a70fd671", "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:                             20241014-165528-185-eb75fe\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: 20241014-165528-185-eb75fe\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": "47c44158", "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.20" }, "source_map": [ 6, 34, 143, 151, 168, 172, 197, 201, 249, 253, 265, 275, 301, 305, 324, 334, 358, 366, 371, 375, 377, 403, 419, 425, 432, 447, 453, 589, 595, 619, 625, 662, 664, 674, 694, 716, 720, 756, 758 ], "widgets": { "application/vnd.jupyter.widget-state+json": { "state": { "0457d611f5284b4bbc241d8e54d4f72d": { "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_83426e1ad8ce4744aa4e4e508cd2a697", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_29365f04ed1f4ef9be74b5a1de45811a", "tabbable": null, "tooltip": null, "value": 100.0 } }, "0af8bd372e044085ae9e3ea0052bf699": { "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 } }, "12305b965c8344cca940b5cb810e2a8e": { "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_eae84ea0547e43d6b1d034867171231b", "IPY_MODEL_0457d611f5284b4bbc241d8e54d4f72d", "IPY_MODEL_3a0aeab408654892a15a4961ac2c403f" ], "layout": "IPY_MODEL_286c75a44282423caca3e5ab25a45974", "tabbable": null, "tooltip": null } }, "172998ccaa534188aea8fd7d8bf14d8c": { "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 } }, "286c75a44282423caca3e5ab25a45974": { "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 } }, "29365f04ed1f4ef9be74b5a1de45811a": { "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": "" } }, "2e69aae17e734cb3b1d500c4cede1e5a": { "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_84290cabbd8743b8b11ab15294e676fd", "placeholder": "​", "style": "IPY_MODEL_4a1bf9fa8b444f10952cd7d350efbac9", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 125" } }, "3640986a80d74877a4304fb231cf0eca": { "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_c1c00fb07caa4ef48c12c75f3db7ef46", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_a740a2cda58e4330b627321e44c2242e", "tabbable": null, "tooltip": null, "value": 100.0 } }, "3a0aeab408654892a15a4961ac2c403f": { "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_5cb1904fa69941678717162c10375319", "placeholder": "​", "style": "IPY_MODEL_f2e3adbef9524a3eb0b96e245b8ff0d5", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:07 | time left: 00:00 ] " } }, "440ae9cad7ab484c98fc3469ff81b245": { "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 } }, "4a1bf9fa8b444f10952cd7d350efbac9": { "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 } }, "4ff1f7a19539403584b3aed08cea6a45": { "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_440ae9cad7ab484c98fc3469ff81b245", "placeholder": "​", "style": "IPY_MODEL_0af8bd372e044085ae9e3ea0052bf699", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "54da8b64c7e04c63a2aafcdfdb81721d": { "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": "" } }, "5cb1904fa69941678717162c10375319": { "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 } }, "5fc2d7fc2f0b46d58dc507b734d7ed5b": { "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 } }, "72bf7e80658d4136b44b0d0aa53d71f5": { "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 } }, "781d5c2f9aa946139976870ef4d823d6": { "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 } }, "83426e1ad8ce4744aa4e4e508cd2a697": { "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 } }, "84290cabbd8743b8b11ab15294e676fd": { "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 } }, "889476564b3b4e18bbd5c8e7bcfead46": { "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_4ff1f7a19539403584b3aed08cea6a45", "IPY_MODEL_3640986a80d74877a4304fb231cf0eca", "IPY_MODEL_2e69aae17e734cb3b1d500c4cede1e5a" ], "layout": "IPY_MODEL_5fc2d7fc2f0b46d58dc507b734d7ed5b", "tabbable": null, "tooltip": null } }, "90442cb338a94a28abfebab3aa4f3e61": { "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_172998ccaa534188aea8fd7d8bf14d8c", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_54da8b64c7e04c63a2aafcdfdb81721d", "tabbable": null, "tooltip": null, "value": 100.0 } }, "9c7348105ea249da84f9c46556652a1d": { "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_c6608c74c4b14035961414afd3813af2", "placeholder": "​", "style": "IPY_MODEL_781d5c2f9aa946139976870ef4d823d6", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 10" } }, "a0972a4f8e3c4d41aba0215c3309a8da": { "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 } }, "a740a2cda58e4330b627321e44c2242e": { "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": "" } }, "c1c00fb07caa4ef48c12c75f3db7ef46": { "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 } }, "c6608c74c4b14035961414afd3813af2": { "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 } }, "ce3d4507b29848d08a6c1f84457d695e": { "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_eb25a65f72c246578bb7e3b7b963a25c", "placeholder": "​", "style": "IPY_MODEL_e320163410a2495fa0f82f4d6b9bcf13", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "e320163410a2495fa0f82f4d6b9bcf13": { "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 } }, "e3fafd764e824e4d81b0512f43b4ce03": { "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_ce3d4507b29848d08a6c1f84457d695e", "IPY_MODEL_90442cb338a94a28abfebab3aa4f3e61", "IPY_MODEL_9c7348105ea249da84f9c46556652a1d" ], "layout": "IPY_MODEL_a0972a4f8e3c4d41aba0215c3309a8da", "tabbable": null, "tooltip": null } }, "ea1258bd44a34ec092d97a55cf23995d": { "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 } }, "eae84ea0547e43d6b1d034867171231b": { "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_72bf7e80658d4136b44b0d0aa53d71f5", "placeholder": "​", "style": "IPY_MODEL_ea1258bd44a34ec092d97a55cf23995d", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "eb25a65f72c246578bb7e3b7b963a25c": { "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 } }, "f2e3adbef9524a3eb0b96e245b8ff0d5": { "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 }