{ "cells": [ { "cell_type": "markdown", "id": "ed9ec615", "metadata": {}, "source": [ "TTL acquisition\n", "==================\n", "\n", "In this tutorial we will demonstrate the sequencer based TTL (Transistor-Transistor-Logic) acquisition procedure. The TTL acquisition enables us to count trigger pulses, based on a settable threshold.\n", "\n", "The acquisition protocol allows us to save the number of triggers in separate bins, or average the triggers on the fly (see section [TTL Acquisitions](https://docs.qblox.com/en/main/cluster/q1_sequence_processor.html#acquisitions)).\n", "\n", "We will showcase this functionality by using a QRM of which output $\\text{O}^{[1]}$ is directly connected to input $\\text{I}^{[1]}$, to both send pulses and acquire the resulting data." ] }, { "cell_type": "markdown", "id": "feeb1d9c", "metadata": {}, "source": [ "Setup\n", "-----\n", "\n", "First, we are going to import the required packages." ] }, { "cell_type": "code", "execution_count": 1, "id": "95d0fd84", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:09.065314Z", "iopub.status.busy": "2024-11-13T02:40:09.065132Z", "iopub.status.idle": "2024-11-13T02:40:09.678129Z", "shell.execute_reply": "2024-11-13T02:40:09.677344Z" }, "tags": [ "imports" ] }, "outputs": [], "source": [ "from __future__ import annotations\n", "\n", "from typing import TYPE_CHECKING, Callable\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from numpy import random\n", "from qcodes.instrument import find_or_create_instrument\n", "\n", "from qblox_instruments import Cluster, ClusterType\n", "\n", "if TYPE_CHECKING:\n", " from qblox_instruments.qcodes_drivers.module import Module" ] }, { "cell_type": "markdown", "id": "7b0ec09f", "metadata": {}, "source": [ "### Scan For Clusters\n", "\n", "We scan for the available devices connected via ethernet using the Plug & Play functionality of the Qblox Instruments package (see [Plug & Play](https://docs.qblox.com/en/main/api_reference/tools.html#api-pnp) for more info)." ] }, { "cell_type": "markdown", "id": "06bdd03d", "metadata": {}, "source": [ "`!qblox-pnp list`" ] }, { "cell_type": "code", "execution_count": 2, "id": "9cb56462", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:09.680654Z", "iopub.status.busy": "2024-11-13T02:40:09.680456Z", "iopub.status.idle": "2024-11-13T02:40:09.683557Z", "shell.execute_reply": "2024-11-13T02:40:09.682929Z" } }, "outputs": [], "source": [ "cluster_ip = \"10.10.200.42\"\n", "cluster_name = \"cluster0\"" ] }, { "cell_type": "markdown", "id": "f9d01ac3", "metadata": {}, "source": [ "### Connect to Cluster\n", "\n", "We now make a connection with the Cluster." ] }, { "cell_type": "code", "execution_count": 3, "id": "a49b006f", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:09.685603Z", "iopub.status.busy": "2024-11-13T02:40:09.685228Z", "iopub.status.idle": "2024-11-13T02:40:10.456574Z", "shell.execute_reply": "2024-11-13T02:40:10.455776Z" }, "lines_to_next_cell": 2 }, "outputs": [], "source": [ "cluster = find_or_create_instrument(\n", " Cluster,\n", " recreate=True,\n", " name=cluster_name,\n", " identifier=cluster_ip,\n", " dummy_cfg=(\n", " {\n", " 2: ClusterType.CLUSTER_QCM,\n", " 4: ClusterType.CLUSTER_QRM,\n", " 6: ClusterType.CLUSTER_QCM_RF,\n", " 8: ClusterType.CLUSTER_QRM_RF,\n", " }\n", " if cluster_ip is None\n", " else None\n", " ),\n", ")" ] }, { "cell_type": "markdown", "id": "0599585c", "metadata": { "lines_to_next_cell": 2 }, "source": [ "#### Get connected modules" ] }, { "cell_type": "code", "execution_count": 4, "id": "035af02a", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:10.458815Z", "iopub.status.busy": "2024-11-13T02:40:10.458609Z", "iopub.status.idle": "2024-11-13T02:40:10.462673Z", "shell.execute_reply": "2024-11-13T02:40:10.461956Z" } }, "outputs": [], "source": [ "def get_connected_modules(cluster: Cluster, filter_fn: Callable | None = None) -> dict[int, Module]:\n", " def checked_filter_fn(mod: ClusterType) -> bool:\n", " if filter_fn is not None:\n", " return filter_fn(mod)\n", " return True\n", "\n", " return {\n", " mod.slot_idx: mod for mod in cluster.modules if mod.present() and checked_filter_fn(mod)\n", " }" ] }, { "cell_type": "code", "execution_count": 5, "id": "36a417b8", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:10.464742Z", "iopub.status.busy": "2024-11-13T02:40:10.464289Z", "iopub.status.idle": "2024-11-13T02:40:10.487326Z", "shell.execute_reply": "2024-11-13T02:40:10.486781Z" }, "tags": [ "module_select" ] }, "outputs": [], "source": [ "# QRM modules\n", "modules = get_connected_modules(cluster, lambda mod: mod.is_qrm_type and not mod.is_rf_type)" ] }, { "cell_type": "code", "execution_count": 6, "id": "f0bde893", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:10.489662Z", "iopub.status.busy": "2024-11-13T02:40:10.489294Z", "iopub.status.idle": "2024-11-13T02:40:10.492273Z", "shell.execute_reply": "2024-11-13T02:40:10.491617Z" } }, "outputs": [], "source": [ "# This uses the module of the correct type with the lowest slot index\n", "module = list(modules.values())[0]" ] }, { "cell_type": "markdown", "id": "280e1356", "metadata": {}, "source": [ "### Reset the Cluster\n", "\n", "We reset the Cluster to enter a well-defined state. Note that resetting will clear all stored parameters, so resetting between experiments is usually not desirable." ] }, { "cell_type": "code", "execution_count": 7, "id": "7ac5a587", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:10.494015Z", "iopub.status.busy": "2024-11-13T02:40:10.493857Z", "iopub.status.idle": "2024-11-13T02:40:12.972848Z", "shell.execute_reply": "2024-11-13T02:40:12.972060Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Status: OKAY, Flags: NONE, Slot flags: NONE\n" ] } ], "source": [ "cluster.reset()\n", "print(cluster.get_system_status())" ] }, { "cell_type": "code", "execution_count": 8, "id": "49cc4f11", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:12.974762Z", "iopub.status.busy": "2024-11-13T02:40:12.974586Z", "iopub.status.idle": "2024-11-13T02:40:12.977809Z", "shell.execute_reply": "2024-11-13T02:40:12.977099Z" }, "lines_to_next_cell": 0 }, "outputs": [], "source": [ "readout_module = module" ] }, { "cell_type": "markdown", "id": "21ed29b9", "metadata": { "title": "BODY" }, "source": [ "Generate waveforms\n", "------------------------------\n", "\n", "Next, we need to create the waveforms used by the sequence for playback on the outputs. Here, we define a single waveform consisting of a 16 ns block pulse with an amplitude of 0.5." ] }, { "cell_type": "code", "execution_count": 9, "id": "212f920d", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:12.979780Z", "iopub.status.busy": "2024-11-13T02:40:12.979589Z", "iopub.status.idle": "2024-11-13T02:40:12.983098Z", "shell.execute_reply": "2024-11-13T02:40:12.982428Z" } }, "outputs": [], "source": [ "# Waveform length parameter\n", "waveform_length = 16 # nanoseconds\n", "\n", "waveforms = {\n", " \"block\": {\"data\": [0.5 for i in range(0, waveform_length)], \"index\": 0},\n", "}" ] }, { "cell_type": "markdown", "id": "bc66aba8", "metadata": {}, "source": [ "Specify acquisitions\n", "--------------------\n", "\n", "We need to specify the acquisitions so that the instrument can allocate the required memory for its acquisition list. Here, we create one acquisition that consists of 100 bins, at acquisition index 0." ] }, { "cell_type": "code", "execution_count": 10, "id": "85a0b646", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:12.985989Z", "iopub.status.busy": "2024-11-13T02:40:12.985807Z", "iopub.status.idle": "2024-11-13T02:40:12.989247Z", "shell.execute_reply": "2024-11-13T02:40:12.988573Z" } }, "outputs": [], "source": [ "# Acquisitions\n", "acquisitions = {\n", " \"ttl\": {\"num_bins\": 100, \"index\": 0},\n", "}" ] }, { "cell_type": "markdown", "id": "69151bb1", "metadata": {}, "source": [ "Create Q1ASM programs\n", "--------------------\n", "\n", "Now that we have the waveform and acquisition specified, we define a simple Q1ASM program that sequences the waveforms and one that triggers the acquisitions.\n", "We will send 5 block pulses of 16 ns at 1 MHz (with 984 ns in between them). At the same time we will perform a 6000 ns TTL acquisition.\n", "Note that 1 MHz is the maximum continuous rate for a TTL acquisition.\n", "\n", "The TTL acquisition is carried out with the `acquire_ttl` command that takes four arguments. The first argument is the index of what acquisition should be done, the second specifies in what bin index it is stored, the third toggles the acquisition on or off and finally the fourth argument is the amount of ns to wait. See the section on [Q1ASM instructions](https://docs.qblox.com/en/main/cluster/q1_sequence_processor.html#instructions) for a more detailed overview of the sequencer instructions." ] }, { "cell_type": "code", "execution_count": 11, "id": "275b26ee", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:12.992178Z", "iopub.status.busy": "2024-11-13T02:40:12.991996Z", "iopub.status.idle": "2024-11-13T02:40:12.995868Z", "shell.execute_reply": "2024-11-13T02:40:12.995209Z" } }, "outputs": [], "source": [ "# Sequence program for AWG.\n", "seq_prog_awg = \"\"\"\n", " wait_sync 4 #Wait for sequencers to synchronize and then wait another 4ns.\n", " move 5,R0 #Loop iterator.\n", "loop:\n", " play 0,0,16 #Play a block on output path 0 and wait 16ns.\n", " wait 984 #Wait 984ns\n", " loop R0, @loop #Repeat loop until R0 is 0\n", "\n", " stop #Stop the sequence after the last iteration.\n", "\"\"\"\n", "\n", "# Sequence program for acquiring\n", "seq_prog_acq = \"\"\"\n", " wait_sync 4 #Wait for sequencers to synchronize and then wait another 4ns.\n", " wait 140 #Approximate time of flight\n", " acquire_ttl 0,0,1,4 #Turn on TTL acquire on input path 0 and wait 4ns.\n", " wait 6000 #Wait 6000ns.\n", " acquire_ttl 0,0,0,4 #Turn off TTL acquire on input path 0 and wait 4ns.\n", "\n", " stop #Stop sequencer.\n", "\"\"\"" ] }, { "cell_type": "markdown", "id": "f806b08f", "metadata": {}, "source": [ "Upload sequence\n", "---------------\n", "\n", "The sequences are uploaded to the sequencers. We will use sequencer 0 to send the pulses and sequencer 1 to acquire them." ] }, { "cell_type": "code", "execution_count": 12, "id": "97e7c447", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:12.998706Z", "iopub.status.busy": "2024-11-13T02:40:12.998526Z", "iopub.status.idle": "2024-11-13T02:40:13.002253Z", "shell.execute_reply": "2024-11-13T02:40:13.001589Z" } }, "outputs": [], "source": [ "# Add sequence program, waveform and acquisitions to single dictionary.\n", "sequence_awg = {\n", " \"waveforms\": waveforms,\n", " \"weights\": {},\n", " \"acquisitions\": {},\n", " \"program\": seq_prog_awg,\n", "}\n", "sequence_acq = {\n", " \"waveforms\": {},\n", " \"weights\": {},\n", " \"acquisitions\": acquisitions,\n", " \"program\": seq_prog_acq,\n", "}" ] }, { "cell_type": "code", "execution_count": 13, "id": "c8a54013", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:13.004326Z", "iopub.status.busy": "2024-11-13T02:40:13.004144Z", "iopub.status.idle": "2024-11-13T02:40:13.056331Z", "shell.execute_reply": "2024-11-13T02:40:13.053158Z" } }, "outputs": [], "source": [ "# Upload sequence.\n", "readout_module.sequencer0.sequence(sequence_awg)\n", "readout_module.sequencer1.sequence(sequence_acq)" ] }, { "cell_type": "markdown", "id": "73717467", "metadata": {}, "source": [ "Play sequence\n", "-------------\n", "\n", "Now we configure the sequencers, and play the sequence.\n", "\n", "We will use sequencer 0 which will drive output $\\text{O}^{1}$, and sequencer 1 which will acquire on input $\\text{I}^{1}$, enabling syncing, and prepare the (scope) acquisition.\n", "\n", "Then the TTL acquisition is configured by using `ttl_acq_input_select` to select $\\text{I}^{1}$ as input. We set `ttl_acq_auto_bin_incr_en` to False such that our TTL count will be put in one bin. We set our TTL threshold to a value of 0.5 of our input range (corresponding to 0.5 V) using `ttl_acq_threshold `, and our input gain to 0 dB using `in0_gain`." ] }, { "cell_type": "code", "execution_count": 14, "id": "40b7d687", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:13.065049Z", "iopub.status.busy": "2024-11-13T02:40:13.064267Z", "iopub.status.idle": "2024-11-13T02:40:13.219388Z", "shell.execute_reply": "2024-11-13T02:40:13.216161Z" } }, "outputs": [], "source": [ "# Map sequencer to specific outputs (but first disable all sequencer connections).\n", "readout_module.disconnect_outputs()\n", "readout_module.disconnect_inputs()\n", "\n", "# Drive through first output\n", "readout_module.sequencer0.connect_out0(\"I\")\n", "\n", "# Acquire through first input\n", "readout_module.sequencer1.connect_acq_I(\"in0\")\n", "\n", "# Enable sync\n", "readout_module.sequencer0.sync_en(True)\n", "readout_module.sequencer1.sync_en(True)\n", "\n", "# Delete previous acquisition.\n", "readout_module.delete_acquisition_data(1, \"ttl\")\n", "\n", "# Configure scope mode\n", "readout_module.scope_acq_sequencer_select(1)\n", "\n", "# Choose threshold and input gain\n", "threshold = 0.5\n", "input_gain = 0\n", "\n", "# Configure the TTL acquisition\n", "readout_module.sequencer1.ttl_acq_input_select(0)\n", "readout_module.sequencer1.ttl_acq_auto_bin_incr_en(False)\n", "\n", "# Set input gain and threshold\n", "readout_module.in0_gain(input_gain)\n", "readout_module.sequencer1.ttl_acq_threshold(threshold)" ] }, { "cell_type": "markdown", "id": "21b984d7", "metadata": {}, "source": [ "We start the sequence, and print the status flags of our sequencers." ] }, { "cell_type": "code", "execution_count": 15, "id": "28cd20ce", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:13.229145Z", "iopub.status.busy": "2024-11-13T02:40:13.228296Z", "iopub.status.idle": "2024-11-13T02:40:13.261965Z", "shell.execute_reply": "2024-11-13T02:40:13.258911Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Status: OKAY, State: STOPPED, Info Flags: NONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n", "Status: OKAY, State: STOPPED, Info Flags: ACQ_SCOPE_DONE_PATH_0, ACQ_SCOPE_DONE_PATH_1, ACQ_BINNING_DONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n" ] } ], "source": [ "# Arm and start sequencer.\n", "readout_module.arm_sequencer(0)\n", "readout_module.arm_sequencer(1)\n", "readout_module.start_sequencer()\n", "\n", "# Print status of sequencer.\n", "print(readout_module.get_sequencer_status(0))\n", "print(readout_module.get_sequencer_status(1))" ] }, { "cell_type": "markdown", "id": "3f3468af", "metadata": {}, "source": [ "Retrieve acquisition\n", "--------------------\n", "\n", "We retrieve the acquisition data from sequencer 1. Then, both plot the scope data for the first 6000 ns and print the number of counted pulses, that is stored in `data['acquisition'][\"bins\"][\"avg_cnt\"][0]`." ] }, { "cell_type": "code", "execution_count": 16, "id": "acc5861c", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:13.270500Z", "iopub.status.busy": "2024-11-13T02:40:13.269723Z", "iopub.status.idle": "2024-11-13T02:40:13.507312Z", "shell.execute_reply": "2024-11-13T02:40:13.506632Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "pulses detected: 5\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Wait for the sequencer to stop with a timeout period of one minute.\n", "readout_module.get_acquisition_status(1)\n", "\n", "# Move acquisition data from temporary memory to acquisition list.\n", "readout_module.store_scope_acquisition(1, \"ttl\")\n", "\n", "# Get acquisition list from instrument.\n", "data = readout_module.get_acquisitions(1)[\"ttl\"]\n", "\n", "# Plot acquired signal on both inputs.\n", "print(\"pulses detected: \" + str(data[\"acquisition\"][\"bins\"][\"avg_cnt\"][0]))\n", "\n", "fig, ax = plt.subplots(1, 1)\n", "ax.plot(data[\"acquisition\"][\"scope\"][\"path0\"][\"data\"][0:6000], label=\"Trace\")\n", "ax.axhline(y=threshold, color=\"r\", label=\"Threshold\")\n", "ax.set_xlabel(\"Time (ns)\")\n", "ax.set_ylabel(\"Amplitude (Volt)\")\n", "plt.legend(loc=\"upper right\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "60d6047d", "metadata": {}, "source": [ "We observe that we indeed do see five 16 ns pulses in the scope acquisition. Furthermore we observe that the amount of pulses counted matches the amount we of the scope trace. You are encouraged to change the threshold value and input gain yourself, and learn about th importance of calibrating these values." ] }, { "cell_type": "markdown", "id": "50476b35", "metadata": {}, "source": [ "
\n", "

Note

\n", "It is important to correctly calibrate your input gain and threshold. For example in a setup with noise and/or interferences, setting the input gain too high might result in these kind of pulses:\n", "\n", "![misconfigured_gain_scope](figures/misconfigured_gain_scope.png)\n", "\n", "\n", "Such a single pulse results in multiple counts, as the threshold is passed multiple times. We therefore strongly recommend calibrating the TTL acquisition using the scope acquisition as is shown above.\n", "
" ] }, { "cell_type": "markdown", "id": "61c634d2", "metadata": { "lines_to_next_cell": 2 }, "source": [ "Short pulse bursts\n", "--------------------\n", "\n", "As the acquisition module in the sequencer has an internal buffer of 8 data entries, any pulse bursts of <8 will be handled correctly when exceeding the maximum continuous rate of 1 MHz. When exceeding the buffer limit, a `ACQ_BINNING_FIFO_ERROR` will be thrown.\n", "To illustrate this we will define a function `generate_pulse_program` that takes as input `num_pulses` (the number of pulses to generate) and `wait_time` (the time to wait between pulses in ns).\n", "We also define a function to upload the sequence to the AWG." ] }, { "cell_type": "code", "execution_count": 17, "id": "f3561dab", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:13.509673Z", "iopub.status.busy": "2024-11-13T02:40:13.509470Z", "iopub.status.idle": "2024-11-13T02:40:13.513308Z", "shell.execute_reply": "2024-11-13T02:40:13.512717Z" } }, "outputs": [], "source": [ "# Sequence program for AWG.\n", "def generate_pulse_program(num_pulses: int, wait_time: int) -> str:\n", " seq_prog_awg = f\"\"\"\n", " wait_sync 4 #Wait for sequencers to synchronize and then wait another 4ns.\n", " move {num_pulses},R0 #Loop iterator.\n", "loop:\n", " play 0,0,16 #Play a block on output path 0 and wait 16ns.\n", " wait {wait_time} #Wait wait_time ns\n", " loop R0, @loop #Repeat loop until R0 is 0\n", "\n", " stop #Stop the sequence after the last iteration.\n", " \"\"\"\n", " return seq_prog_awg\n", "\n", "\n", "# Upload sequence to AWG\n", "def upload_sequence(seq_prog_awg: str) -> None:\n", " sequence_awg = {\n", " \"waveforms\": waveforms,\n", " \"weights\": {},\n", " \"acquisitions\": {},\n", " \"program\": seq_prog_awg,\n", " }\n", "\n", " readout_module.sequencer0.sequence(sequence_awg)" ] }, { "cell_type": "markdown", "id": "29a4a39a", "metadata": {}, "source": [ "We now generate the program, upload it and set the threshold and input gain." ] }, { "cell_type": "code", "execution_count": 18, "id": "ff690188", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:13.515082Z", "iopub.status.busy": "2024-11-13T02:40:13.514922Z", "iopub.status.idle": "2024-11-13T02:40:13.557128Z", "shell.execute_reply": "2024-11-13T02:40:13.556323Z" } }, "outputs": [], "source": [ "seq_prog_awg = generate_pulse_program(num_pulses=5, wait_time=20)\n", "upload_sequence(seq_prog_awg)\n", "\n", "# Choose threshold and input gain\n", "threshold = 0.5\n", "input_gain = 0\n", "\n", "# Delete previous acquisition.\n", "readout_module.delete_acquisition_data(1, \"ttl\")\n", "\n", "# Set input gain and threshold\n", "readout_module.in0_gain(input_gain)\n", "readout_module.sequencer1.ttl_acq_threshold(threshold)" ] }, { "cell_type": "markdown", "id": "f1c42632", "metadata": {}, "source": [ "We then arm the sequencers and play the sequence." ] }, { "cell_type": "code", "execution_count": 19, "id": "7f610d5c", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:13.559239Z", "iopub.status.busy": "2024-11-13T02:40:13.559073Z", "iopub.status.idle": "2024-11-13T02:40:13.583402Z", "shell.execute_reply": "2024-11-13T02:40:13.580477Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Status: OKAY, State: STOPPED, Info Flags: NONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n", "Status: OKAY, State: STOPPED, Info Flags: ACQ_SCOPE_DONE_PATH_0, ACQ_SCOPE_DONE_PATH_1, ACQ_BINNING_DONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n" ] } ], "source": [ "# Arm and start sequencer.\n", "readout_module.arm_sequencer(0)\n", "readout_module.arm_sequencer(1)\n", "readout_module.start_sequencer()\n", "\n", "# Print status of sequencer.\n", "print(readout_module.get_sequencer_status(0))\n", "print(readout_module.get_sequencer_status(1))" ] }, { "cell_type": "markdown", "id": "05eebc7f", "metadata": {}, "source": [ "We retrieve the acquisition and plot it as in the previous section." ] }, { "cell_type": "code", "execution_count": 20, "id": "817d2189", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:13.593540Z", "iopub.status.busy": "2024-11-13T02:40:13.591239Z", "iopub.status.idle": "2024-11-13T02:40:13.772100Z", "shell.execute_reply": "2024-11-13T02:40:13.771428Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "pulses detected: 5\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Wait for the sequencer to stop with a timeout period of one minute.\n", "readout_module.get_acquisition_status(1)\n", "\n", "# Move acquisition data from temporary memory to acquisition list.\n", "readout_module.store_scope_acquisition(1, \"ttl\")\n", "\n", "# Get acquisition list from instrument.\n", "data = readout_module.get_acquisitions(1)[\"ttl\"]\n", "\n", "# Plot acquired signal on both inputs (first 200 ns).\n", "print(\"pulses detected: \" + str(data[\"acquisition\"][\"bins\"][\"avg_cnt\"][0]))\n", "\n", "fig, ax = plt.subplots(1, 1)\n", "ax.plot(data[\"acquisition\"][\"scope\"][\"path0\"][\"data\"][0:200], label=\"Trace\")\n", "ax.axhline(y=threshold, color=\"r\", label=\"Threshold\")\n", "ax.set_xlabel(\"Time (ns)\")\n", "ax.set_ylabel(\"Amplitude (Volt)\")\n", "plt.legend(loc=\"upper right\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "922776e5", "metadata": {}, "source": [ "We encourage you to play around with the `num_pulses`, `wait_time`, `input_gain` and `threshold` yourself." ] }, { "cell_type": "markdown", "id": "df8f55af", "metadata": {}, "source": [ "Auto bin increment\n", "--------------\n", "\n", "\n", "In the play sequence section we set the `ttl_acq_auto_bin_incr_en` to False, meaning all of our pulses get counted within one bin.\n", "When it is set to True our data will be stored in separate bins, where the bin index is incremented by one for every detected pulse. The pulse count is therefore equal to the number of valid bins. When doing multiple measurements, this allows us to acquire a cumulative probability distribution of counted triggers.\n", "\n", "To illustrate the usage we will define a function which returns a Q1ASM program that plays a `N` amount of pulses (at a 1 MHz rate), where `N` is a random number between 1 and 100 taken from a Poissonian distribution. This is meant to mock a stochastic physical process, e.g the amount of photons emitted by a laser.\n", "We will call the function a 1000 times and run it, without deleting the acquisition data between the runs.\n", "After this we will plot a histogram from our acquired data to inspect the result." ] }, { "cell_type": "markdown", "id": "611687d4", "metadata": {}, "source": [ "We will now define new Q1ASM programs. We define a function which returns a program that generates `num_pulses` number of pulses. These pulses are 16 ns long, and are send at a rate of 1 MHz again.\n", "\n", "For the acquiring sequencer we will execute the same program as in the previous section, albeit with an acquisition window of 100.000 ns." ] }, { "cell_type": "code", "execution_count": 21, "id": "93cc6e88", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:13.774220Z", "iopub.status.busy": "2024-11-13T02:40:13.774040Z", "iopub.status.idle": "2024-11-13T02:40:13.777295Z", "shell.execute_reply": "2024-11-13T02:40:13.776706Z" } }, "outputs": [], "source": [ "# Sequence program for acquiring\n", "seq_prog_acq = \"\"\"\n", " move 10,R0 #Loop iterator.\n", " wait_sync 4 #Wait for sequencers to synchronize and then wait another 4ns.\n", " wait 140 #Approximate time of flight\n", " acquire_ttl 0,0,1,4 #Turn on TTL acquire on input path 0 and wait 4ns.\n", "loop:\n", " wait 10000 #Wait 10000 ns\n", " loop R0, @loop #Repeat loop until R0 is 0\n", " acquire_ttl 0,0,0,4 #Turn off TTL acquire on input path 0 and wait 4ns.\n", "\n", " stop #Stop sequencer.\n", "\"\"\"" ] }, { "cell_type": "markdown", "id": "4edd84e3", "metadata": {}, "source": [ "We will first configure our sequencers. Then use `random` to generate an amount of pulses, and repeat this 10000 times." ] }, { "cell_type": "code", "execution_count": 22, "id": "130a375b", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:13.779155Z", "iopub.status.busy": "2024-11-13T02:40:13.778996Z", "iopub.status.idle": "2024-11-13T02:40:13.920474Z", "shell.execute_reply": "2024-11-13T02:40:13.917081Z" } }, "outputs": [], "source": [ "# Choose threshold and input gain\n", "threshold = 0.5\n", "input_gain = 0\n", "\n", "# Delete previous acquisition.\n", "readout_module.delete_acquisition_data(1, \"ttl\")\n", "\n", "# Configure the TTL acquisition\n", "readout_module.sequencer1.ttl_acq_input_select(0)\n", "readout_module.sequencer1.ttl_acq_auto_bin_incr_en(True)\n", "\n", "# Enable sync\n", "readout_module.sequencer0.sync_en(True)\n", "readout_module.sequencer1.sync_en(True)\n", "\n", "# Set input gain and threshold\n", "readout_module.in0_gain(input_gain)\n", "readout_module.sequencer1.ttl_acq_threshold(threshold)\n", "\n", "sequence_acq = {\n", " \"waveforms\": {},\n", " \"weights\": {},\n", " \"acquisitions\": acquisitions,\n", " \"program\": seq_prog_acq,\n", "}\n", "\n", "# Upload acquire sequence.\n", "readout_module.sequencer1.sequence(sequence_acq)\n", "\n", "# Map sequencer to specific outputs (but first disable all sequencer connections)\n", "readout_module.disconnect_outputs()\n", "readout_module.disconnect_inputs()\n", "\n", "# Drive through first output\n", "readout_module.sequencer0.connect_out0(\"I\")\n", "\n", "# Acquire through first input\n", "readout_module.sequencer1.connect_acq_I(\"in0\")" ] }, { "cell_type": "code", "execution_count": 23, "id": "66bf0b32", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:13.927993Z", "iopub.status.busy": "2024-11-13T02:40:13.927827Z", "iopub.status.idle": "2024-11-13T02:40:54.974417Z", "shell.execute_reply": "2024-11-13T02:40:54.971027Z" } }, "outputs": [], "source": [ "num_pulses_list = random.poisson(lam=50, size=1000)\n", "wait_time = 1000\n", "\n", "for num_pulses in num_pulses_list:\n", " seq_prog_awg = generate_pulse_program(num_pulses, wait_time)\n", " upload_sequence(seq_prog_awg)\n", " # Arm and start sequencer.\n", " readout_module.arm_sequencer(0)\n", " readout_module.arm_sequencer(1)\n", " readout_module.start_sequencer()\n", " readout_module.get_acquisition_status(1)" ] }, { "cell_type": "markdown", "id": "9b9643d6", "metadata": {}, "source": [ "### Create histogram\n", "\n", "We retrieve the acquired data from the sequence to take a look at it." ] }, { "cell_type": "code", "execution_count": 24, "id": "8e1e5f37", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:54.982014Z", "iopub.status.busy": "2024-11-13T02:40:54.981843Z", "iopub.status.idle": "2024-11-13T02:40:55.016510Z", "shell.execute_reply": "2024-11-13T02:40:55.015758Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "counts per bin: [1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 999, 997, 995, 992, 991, 985, 981, 973, 959, 940, 909, 875, 841, 798, 763, 729, 687, 625, 567, 516, 457, 407, 363, 318, 276, 231, 194, 156, 128, 104, 75, 60, 42, 32, 27, 19, 19, 16, 11, 9, 8, 6, 5, 5, 3, 3, 3, 3, 3, 3, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n" ] } ], "source": [ "# Wait for the sequencer to stop with a timeout period of one minute.\n", "readout_module.get_acquisition_status(1)\n", "\n", "# Move acquisition data from temporary memory to acquisition list.\n", "readout_module.store_scope_acquisition(1, \"ttl\")\n", "\n", "# Get acquisition list from instrument.\n", "data = readout_module.get_acquisitions(1)[\"ttl\"][\"acquisition\"][\"bins\"][\"avg_cnt\"]\n", "\n", "# Plot acquired signal on both inputs.\n", "print(f\"counts per bin: {data}\")" ] }, { "cell_type": "markdown", "id": "aab2207b", "metadata": { "lines_to_next_cell": 2 }, "source": [ "Every time the acquisition_ttl is ran the sequencer starts over with incrementing the bins (from bin 0). In every bin, the counts are summed up for all 1000 runs. Therefore, the data is a cumulative probability distribution of triggers counted. We now reorganize the acquired data into a probability distribution function (a histogram), and plot the result." ] }, { "cell_type": "code", "execution_count": 25, "id": "43aec0a6", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:55.018629Z", "iopub.status.busy": "2024-11-13T02:40:55.018436Z", "iopub.status.idle": "2024-11-13T02:40:55.155016Z", "shell.execute_reply": "2024-11-13T02:40:55.154282Z" } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1wAAAJHCAYAAACEg1coAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABxaElEQVR4nO3dd3gU1eL/8c+GkJCEhE5CQiAJHQQpAtKlWOiCIAooohfEglwUFRVBBASvgorotQtXsIEVsKAIKIiKqIAUCRAghYSemEJIsuf3h7/s15jdZBN20ni/nmefB2bOmXNmdjK7n52ZMzZjjBEAAAAAwOO8SrsDAAAAAFBREbgAAAAAwCIELgAAAACwCIELAAAAACxC4AIAAAAAixC4AAAAAMAiBC4AAAAAsAiBCwAAAAAsQuACAAAAAIsQuAC47fXXX1ePHj1KuxtAmdSoUSN98cUXpd0Nj5o5c6bGjh1b2t2o8Ox2u1JTU0u7G+XWn3/+Wdpd0JYtW9S/f39FRkaqRo0a5eb95HO9ZBC4ypHU1FQNGzZMo0ePdllm/fr1GjRokJo3by5fX1/ZbDb5+/urdevWGjlypH799dcC2/jll180YsQIXXLJJfL395fNZpOvr69atGihIUOGaMOGDQXWP3DggG666Sa1bdtWgYGBstls8vb2VuPGjXX11Vdr1apVMsYUa/1x4caPHy9fX1999tlnxaofGxurmJgYD/fKWnv37lWVKlVks9nyvby8vBQVFaVrr71WO3bs8HjbF7q9K5ovvvhCfn5+uummm0q7K5Y4dOiQ4uLi8kzbuXOnqlWrVqa/0BT0vhw9elSHDx8u+U4VUe/evRUYGKjffvuttLtSJD/99JO6du2qoKAg1atXTzk5OaXdpWL76quv5O3t7fRY+8+Xj4+Pfvrpp3zLMMbo/fff11VXXaVGjRo5lhcUFKT27dtr3LhxOnjwYJ4669atc2y/cePGKTk5uaRW2WHlypXq3r27EhMTNWrUKC1atEgBAQEl3o/iKI+f6+WRd2l3AO5JT0/X4MGDtXHjRnXr1s1pmfvvv19PP/20OnfurP79+6t+/fry9fVVenq6jh49qvXr1+uyyy7Ts88+q8mTJ+erv3jxYk2dOlXNmzdX3759NW7cOPn5+SkzM1OxsbHasmWL+vTpo/vvv1//+c9/8tX/4IMPNGbMGIWEhGjAgAEaNWqUAgMDlZWVpfj4eG3fvl0jR47U9ddfr3fffVc2m83j2wkF27Rpk86fP6+ff/5ZAwYMyDPv559/1pkzZ3TllVeWUu+skZSUpMzMTM2cOVN16tTJMy8nJ0dxcXFas2aNOnTooC+++EL9+vXzWNsFbe+L0U8//aRz585py5Ytpd2VEvPbb78pJSXF4+ucmpqqZcuW6Y477pCX14X9dlrW3xd3jk2bNm2SMUY7d+5U27ZtS65zF2D9+vXq37+/Lr/8cs2ZM0edOnVSpUqVSrtbxRYfH6+cnBw9++yzha6Hj4+PWrRokWeaMUbXX3+9Vq1apb59+2r48OEKDQ1V5cqV9eeff+rIkSNau3at3nvvPb399tsaPny4JKlnz55auXKldu/erSVLlmjr1q3auXOnqlSpYtm6/p3dbte0adM0ZMgQffTRRxf894gKyqDMy8jIMFdddZWpWrWqadu2renWrVu+Mr/++qux2WzmP//5j7Hb7U6Xc/78eXPnnXeagIAAk5CQkGdefHy88ff3N5MnTzZZWVlO6+fk5JgnnnjC2Gw289tvv+WZl5aWZsLCwszw4cNNenq6y3VZsWKFkWRWr15d2GrDArNnzzZt2rQxW7duzTfvlltuMd27dy+w/qxZs0xYWJhV3bPEhg0bjCQTHR3tssz58+dN7969TYsWLVz+/RRHQdv7YvTjjz+atm3bmkcffbS0u2IJSebVV1/NM+3QoUOmU6dO5tZbb/VoWxs3bjSSzIEDBy54WQW9L+PGjXP6mVOS3Dk2TZw40XTo0MEj26Ok9OrVy1x33XUmOzu7tLviEW+++aaR5PI7RGE++eQTI8m8//77Lsukpqaaa6+91tSvX9+kpaXlmx8bG2sCAwPNG2+8Uaw+FEdcXJyRZL788ssSa9OTyuPnenlE4Crj7Ha7ufbaa03VqlXNli1bXH74TZo0yTRp0qTQA/fZs2dNtWrVzPz58/NMX7BggalWrZpJTk4usH5WVpZp1KiRuf322/NMf/fdd43NZjMxMTGFrtMVV1xhrr766kLLoWS588WqPB6Y3Qlcxhjz6aefGkkmKSmphHqGisZZ4LKKu/v1hSoLgass9MHTYmNjjSTz448/lnZXPOZCA9c111xj+vTpU2i5gwcPGpvNZt555x2n8++44w7Tt2/fYvWhODZv3mwkmT179pRYm55UHj/XyyPOe5ZxxhgFBAToyy+/VNeuXV2Wi4mJUceOHQs9jV+tWjW1atUq3/W6MTExatWqlYKCggqs7+3trc6dOzutX69ePUVERBS8QpK6du3K9cIocxo1aiTpr/sQAcBKsbGxkqT27duXck/KjpiYGF1++eWFlouKilK9evVcfo/o0KFDvnsprZSRkSFJ8vPzK7E2Uf4QuMo4Ly8vLV++vMCwJUlHjhxRvXr13FpmWFhYvgNVSdc/fPiw24NnnD17ViEhIdq+fbuMMXrvvfd05ZVXql69egoNDZXdbpck7dmzR8HBwTp9+nShywsODtbvv/+eb964ceM0Y8YMpaen64knnlCHDh1UvXp12Ww21apVS506ddL8+fN1/vx5p8tOTk7WnXfeqYYNG+a7Sbhy5cpq0qSJFi5c6Pa633DDDVq2bJnTeTk5OWrbtq3mzp3rsv6gQYO0atUqx/+//vprNWrUyLHNJKlv376y2WxatmyZtmzZkqfPru6ZSE9P16JFizR06FA1a9ZM3t7ejsFZJk2apOPHj7u1fv+0a9cuTZgwQY0bN3YMuuLl5aWGDRvqyiuv1DfffFOs5brDx8dHkpSZmZlnemZmpubPn6+OHTuqVq1ajm2Tu7633367kpKSnC7T2fbOtW7dOnXu3FlVq1bNt6/UqlVLgwYN0r59+5wud8WKFbr00kvl5+eXr25wcLBGjx6thIQEp3VzcnL0yiuvqGvXrgoODnbU8/X1VfPmzTV69Oh8N6Xn+vvf2Pfff68bbrhB9evXV+XKlR3797XXXlvgwAVNmjRxOZLfhbz/vXv31quvvqpTp05p+vTpuuSSSxzLCA4OVteuXfXqq686fS/c8e233+qaa65RRESEKlWq5HQgAFf69OmjV199Nd/04hwvli1bJpvNpt69e0v6a3vm1vHz81N0dLSjrLvHztzlFDTCYlpamubNm6fLLrtMNWrUyDOg0pgxY3To0CGn9d544w317NnT9Yb9/7766itFRUUV+9j05ptvumzHGKMPPvhAvXr1UlhYWJ5t3LhxYw0dOtTlgFJ//7zYvXu3xo8fr4iICFWpUkWVKlVSRESErr76am3cuLHQdfy7hIQE1axZU97ezm+ld7Y9nHH3c6805OTk6Pjx44qLi1N8fLyysrIKLH+h30Ny1alTx+Xxz5WUlBQ98MADateunYKCghz7SFBQkNq1a6cHHnhAKSkpeeqkpqaqWrVqjn0xMjLSUa9atWpujVL49/1r69atuuGGGxQeHu4Y9Cz32PXyyy+7HFClcePGbo2OmnuMLKr9+/dr8ODBqlu3br7jlL+/vzp27KjPP//cZf2dO3dq2LBhatKkiSpXruyoGx4err59+xY4qNS2bdvUu3dvx/ewv7+CgoJ0xRVX6McffyzyOpUGBs2oIDIyMty+QdTf3z/fwSgjI0O1atVyu356evoFtX/+/Hnl5OS4/LD5u7NnzyopKUlxcXFauHChVq1apQEDBmjs2LG67LLLHDeoHj9+XMePH9fp06dVs2bNApd3/PhxJSYm6pJLLskz78iRIzp58qQ6deqkU6dOadCgQRo6dKhq1Kih5ORk7du3TzNnztQXX3yhjRs35vuSNXXqVK1atUq33367wsPD89w8m5GRoa1bt2ratGmqWbOmxo8fX+i6Z2dn66WXXtK4cePyzdu6dat27NihP//8U4888ki+vuzatUtr167Vv/71L8e0uLg4HTp0SHa73dG3hx9+WMOGDdNbb72lEydO6N5773WUb9WqVb5209LS1KVLF+3fv1+DBg3SyJEjVadOHZ0/f15HjhzRO++8o5UrV2rv3r2qW7duoeuY67ffflPPnj1Vo0YNDR06VGFhYfL395fdbldiYqK+/vpr9e3bV6+88oomTJjg9nLdlfs38feztMYYXXXVVdqyZYtGjhypIUOGOA786enp+dY3ODg4zzKdbW/pr7NoAwcOVI8ePTRz5kz5+/vnafPw4cP68MMPNWjQIO3du1eVK1d2zN+0aZPGjh2rYcOG6aabbsrzd2eM0b59+7Rq1SrdeOON2rRpU771HD9+vN566y0NHjxYV155pWrXri2bzeYYHGfVqlVq1aqVtm3bptatW+epm/s3tmDBAi1atEhXXHGFRo8ereDgYHl5eSkhIUFr165Vhw4d9Pnnn+uqq67K1/6BAwec/vp8oe9/TEyMNm3apFmzZqlKlSrq37+/QkNDFRQUpFOnTmnHjh2aOHGivvvuO/3vf//LV78gS5cu1fjx49WxY0fdcMMNqlevntOrCZwNRiT9NXrhkSNH8k0vzvGib9++WrJkifbv36/FixfnGQzGz89PDRo0cCzD3WOn5Pp9kf4acrtbt25KSEjQoEGDNGjQINWsWVNZWVmKi4vTBx984Nhn/nlMPXr0qMsw9nfx8fGKiYkp9rHpyJEjLtuZNWuW5syZo969e2v8+PGqW7euvLy8HAM6rVmzRpdddpnWrl2ra665Jk/d3M+LN954Q0uWLFGHDh103XXXKSQkRD4+PkpMTNQ333yj3r1767XXXtNtt91W6LrmbtOqVasWaXs44+7n3j+dOHEi349LztSuXbvIg0889NBDWrVqlY4cOZLnx4JKlSopKipK06ZN07/+9a9863Xu3LkifY/45/eQXIGBgUUaJv7cuXO67LLLFBsbq9GjR+v6669XYGCgpL/epwMHDmjJkiX68MMPtWvXLseZrICAAC1ZskQ//vijXnjhBT322GOO71HVqlVza5TC3P3rP//5j5YvX67OnTvr+uuvV0hIiKpUqeI4dk2aNEnffvutVqxYkW8ZBw8edOuMXkxMjNPjUEGysrI0aNAg2e12TZ482fH5l+vUqVP6/PPPHSP9Nm/ePE/99evX6+qrr1ZUVJTjuF65cmXZ7XYlJSXp+++/18CBA/Xkk0/qgQceyFP3zJkzuvrqqxUZGakHHngg3xVYx44d0yeffKIBAwbojz/+UO3atYu0biWulC5lRDG5upa9YcOG5pFHHin2Mnr16mXGjBnjVn1n1/sW5Rr7ol7nHRMTYySZvn37ml69eplDhw45LefuPQ25y/vqq6/yzevVq5eRZO69916X/cu9WX3lypV5pufk5BgfHx+zaNGiAtsfNGiQufLKKwssk+vdd981ksyRI0fyzbv33nuNj4+Py2vHp0+fbmrWrGkyMzMd0wra9u7ewyXJdOjQwRw/ftxpmRMnTphatWqZu+66q7DVy2PChAkmPDzcnD171un8nJwcM2bMGFOnTh2nN0u74u5+MXXqVBMUFJTnPshVq1YZSWbdunUu6yUlJZmaNWuaO++8M988V9t77ty5pnbt2nnem3/6+eefjSSzZcuWPNP/9a9/mTZt2hQ4uEduv+Pi4vJM37Ztm5FkXnnlFZd1U1NTTfPmzc2AAQPyzcvdlqGhoWbXrl1O62dlZZl+/fqZVq1aOe2jXNzndKHvf8OGDY0ks2jRIpfbZtmyZUaS+emnn5zOdyYtLc0EBwebm2++2eTk5BRY1tW6OTs+X+jxwp392t1jZ0F9HzdunJFk7rzzTnP+/HmnddPT003Lli3NwIED881z9/4QTxybnLUTFxdnfH19zcMPP1zggFJ9+vQxLVu2zFcmdxsGBQWZjRs3Oq1vt9vN+PHjTZ06dUxqamqB/cz15ptvmoYNGxY4353PyeLcy7d7924jya3XyJEj3V7u8uXLjSTj6+trJk6caBYvXmxWrlxpVq9ebT755BPz6quvmltuucXYbDYzbdq0fPVd7YPOFPSdJXebuOvpp5823t7eZvfu3S7L7N2711SuXNn85z//yTfvq6++MpLcuof9n3L3r8DAQJf7lzHGLF261OU9f+5uN1ffEwv6G829P+2XX35xudzMzExTs2ZNM2/evHzz2rRpY7p27WrOnTvntK7dbjcPPvigqVq1ar77p5cvX268vLxcftcw5q/PX5vNZlasWOGyTFnBJYUV2IoVK+Tj46O33nqrWPU3bdokX19fzZs3r1j1Dxw4oKpVq2rixInFqv9PO3fu1HvvvafIyEiPLM+Vhg0b6umnn3Z59q1Xr17q0KFDvktIjh8/rvPnz6tp06YFLv+RRx7RyJEj3erLwIEDVaVKlTyXBUp/ncn46KOPNHnyZPn7+2v16tV55tvtdr3zzjsaNWqU41I5T3r99dfzDbGeq3bt2ho3blyRL7EJCAjQww8/rGrVqjmd7+XlpalTp+rEiRP6448/itplHTt2THFxcXleR48e1Q8//KDp06c7zhb8/czFpk2b1KZNmwKHo65bt67GjRvn9GySK7GxsYqIiCjwvWnfvr1mzpyZ54xFbt2mTZsWeAnbwIEDnf4i+O2336p69eq69dZbXdYNCAjQHXfc4Rhm25l58+blO5ORy9vbW1OmTNHu3bt16tQpl+04a/dC3/9evXpp6tSpLrfN2LFjVbt27SK9V3/88YeSkpJ07733enS4ZyuOF65c6LGzevXqWrx4cZ4zrX/n5+enSZMmaePGjWXuOYs//vijMjMzNW3aNJf7ReXKlTVlyhTt2bPH5T47depU9erVy+k8m82me++9VydOnNDevXs91nerNG3aVOvWrdPq1asLfc2fP9/t5Q4dOlRLlizRwYMH9fLLL2vy5MkaMWKEBg0apCFDhuhf//qX3nzzTT311FNavHix4z62gsyfP1++vr5F/jwpik2bNmnAgAFq2bKlyzLNmzfXoEGDinTsKIqC9i9Juummm1S7dm19++23lrTvSu57VNBxysfHR4sWLVL37t3zTD9z5ox27typKVOmyNfX12ldm82madOmKTU1VVu3bs3Xds2aNV1+15D++vxduHCh2rRp4+4qlRouKazAUlJSlJWVVewnsKenp+v8+fPFfohgZmam0tPTdfbs2WLV/6dhw4blu2TLCl26dCn0GWENGzbMd/149erVJanQ9b388svdujFYkqpWraoBAwbo/fffz3M5zc6dOxUTE6OxY8fqwIEDWr16dZ7T8Vu3btWRI0csecBs3bp1demllxZYJiIiQjExMTLGuP28tWeeecbx7+TkZKf7bW4IPnz4sNq1a1eEXqvA+0iqVKmiOXPmaMqUKXmmHzlyxK2BYCIjI4u0vjVr1ix0P7HZbJo9e7bTuidOnCiwbpUqVfTkk0/mm37kyBE1aNCg0MF1IiMjlZaWppMnTzr9sOvSpUuB9Rs2bCjpr0tY3L3MwxPvf2H98vLyUoMGDYo0aE/uQ39z18lTrDheuHKhx86WLVsWus9EREQUuM+UliNHjigoKEg1atQosFxuGHW1zxZln7/sssuK2duS4e3trUsuucStSwqLst9UrVpVd911V6HlJkyYoGnTpmn79u0KDw8vsOzZs2d1/vx5paWlud2Pojpy5IiuuOKKQstFRka6da9UcRR2n35xjl2ekHuZ6tmzZwu8RNLZbQ+5x86oqKgC26hdu7YCAwPzPWC9Zs2aSk1NVXZ2doG3n0ydOrXA5ZcVBK4KbNKkSRo+fHiR7qP5u/79++v48eNu39v1T61atdLJkycd10JfKGf3E1nBnQdPBgYG5hsooUqVKurUqZMWLlyoRo0aKTQ0NM8v4pUqVVLdunWL/GDLkSNH6sYbb9SRI0ccH+offfSRGjdurEsvvVSDBw/WxIkTderUKcd79fbbb6tRo0YX/EXNGVe/cv9dYGCg0tPT3b5PT/rrOvp58+bppZde0smTJwssW5wfAV5++WWFhobmmZb7Ida4cWOn9w4kJyerfv36hS67qOvbo0cPzZ8/X88++6wGDhyYb3SroKAglyOG9ujRQ5MnT9aKFSt0+eWX5/vlsGbNmnnuCfvn+rjz95hbJjk52emX58L24b/Xd5cn3n93/3aL0q/csgXdb1McVh0vnLnQY6c7PyIUts+UluLs885Ysc+Xlt27d7s8Q/1PI0aM0MqVKz3afu7xzZ3wMH/+fN13333F/h7jjqLsI1a9v1YcuzyhXbt28vf31/Tp0/Xggw+qWrVqeY4HVapUcQwm9U+5fc3IyCj0HrOgoKB8PyR27dpVmZmZevjhh3XrrbfmOwYHBAQU+kNKWULgqsByR7i5EBf6wVmUm3gLU9iQ9WXBf//7X1133XUufw318fFR//799cILLygsLMytZQ4aNEhVqlTRypUrNW3aNEl/Ba4RI0bIZrNpwIABstvt+uyzz3TTTTcpKytL77//vu666y63zy6VBXPmzNHChQt1zz33qH379k6/4Obk5Ojaa68t1vL79Omjxo0bX2AvPeOaa67R5MmTNXXqVJe/ztWvX1+PP/54vsFV/vWvf+mbb77R2LFjXS6/adOmWrhwoQYNGuTRflvJ6ve/LLLieOFMeTh2ouQ0a9ZM69atc+sMV4sWLSzpg7vhwcvLy9KwhYLVqVNHL730ku644w4tX77caZnAwEDdfvvtmjdvntPL5N0ZpVRSvh89L7nkEi1YsEAzZszQU0895bROrVq1dP/99+uBBx4o8993CFwVhL+/v+NZEIVJT0/P9wt4Sdf38fHxyC+3ZU379u21b98+7d27V/Hx8XnuZ8jJydGRI0e0YMEC3X777VqzZo1by6xatar69++v999/X9OmTdPBgwe1c+dOvfnmm5KkevXq6bLLLtPq1at100036auvvtLJkyc1ZswYS9bRKi+++KLuu+++Au8ZzM7OLsEeWcdms2nx4sV68MEHtX///nyXy6Smpmrt2rW69dZb1apVK3Xq1Mkxr3Llylq5cqViYmJ08OBBnTt3zjHPGKPk5GStWLFCI0eO1B9//JHvHrCy6mJ6/3NZcbwACuPt7V3gfanFVZRLyJ3d6+fn53dB30NgjZtuukmDBw/W3r17893jmJmZqR07dmjBggUKDg52/Cj8d86uLvknm82mbt265Zv+wAMPaPz48dq3b1++gJ6RkaEtW7Zo+vTpatSokUaMGFGMtSs5BK4KokGDBkpMTHSrbHx8fL7LCRo0aKBdu3a5Xf+fN183aNBAn3zyidv1IyIiPP5rRO6vuIU9+8LqL22+vr5q27at2rZt63S+v7+/br/9dp0/f97tAS1Gjhyp0aNHKyYmRh999JEiIyPz3MMyaNAgLVq0SOfPn9fbb7+tyy+/XE2aNClSvwMCAlwOs2u1M2fO6OzZs+rYsWOB5Ur6C3dgYKBbz1L5888/5e/vX+QfEcLCwlyeubj++uu1adMmrV69Ok/gyhUZGelyEIRhw4apZs2a+uqrr/IMU12U9ZHkcgALTyur77/0f9sgNTXVcd+VM8UdLKK4x4vc+ylK4m/WnXVztc8EBQW5tc8V9N5eyLGprO7z7ipsvyvuc+WscN1116ldu3Z69NFHCyyX+8PQP29XKOr3mGHDhhW7r39XlH2kNPcPV+272/8LOX5Wr17d5Zn46667TocOHdInn3ySJ3DlXqbZtWtXty9hdaZOnTour7YaOXKkfv75Z33yySdlPnAxSmEFERkZqZ9++qnQP6iUlBTt3r073xe1yMhI7d69u9BT/NnZ2frpp5+c1j927Jhb12Rv3brVkpEGcwc3OHr0aIHlNm/e7PG2JSkxMVGLFi0q9MtJeHi47HZ7oQMf/N2gQYPk6+urlStX6qOPPtLIkSPzBNbBgwcrJSVFX3zxhT7++ONiDZYRERGhuLi4UhllLPfelcK+PKxfv74kuuMQERGR70ZeZ2JiYhwPvXTHO++8U+DDgaW/tklYWFi+LyD//e9/C/07CwgIUM2aNfPVjYiI0NGjRwvdzjExMQoICCix55qU1fdf+r/jSmH7wc6dO4u03As9XuT2y52R3i7U3r17XT50NdeRI0ec7jMRERFKTk7O99DYfyrouHwhx6bc9gsbnCT3b8rqUXCLyt39riwEr8DAQH355ZeFljt58qTS0tLyDUgUGRmp77//vtD6MTExOnbsmMfeq6Ie50uD3W7X0aNHnbafe1wvSExMjOLj453Oq1KlisvLS3/66Sd98MEHhfYvPDw83+dNbl8LO0YZY9SzZ0+9/fbbeaZ/8cUX2rBhQ7HaLosIXBXE7bffroMHD2rhwoUuP5SysrL08MMPKysrK9+IMjfffLOysrL0yCOPuAxtxhgtXLhQBw8e1KRJk/LMGzx4sEJDQ3XfffcV+Evku+++qw0bNrg1klFR1ahRQ5dccomef/55l+uwZ8+eQn99K67o6Gjdd9992rFjR6HlKlWqVKT76wIDA9W/f3+9+uqr2rp1a75fctq1a6d69erp3//+tzIzM3X99dcXuf9du3bViRMn9P777xe57oWqVq2a6tSpU+CQu4cPHy7x0Yh69OihHTt2FPhF/8SJE1q2bJnb16lL0muvvabHHnuswDJZWVk6fPhwvkE7nn76aT333HMF1j1z5oxOnjyZr2737t115swZLV261GXd9PR0/fe//1XPnj1L7Jr4svr+S3/d71K3bl0988wzLo+tp06dKvIx7UKPF7Vr11aTJk304osvFhqGLtSZM2c0depUl8fVjIwM/fe//1WvXr3y7TOdO3eWr69vnlEo/2nVqlV65513XM6/kGNTp06dHMNWu5KVlaXnnntOLVu2LPYgUVZZuHChyzC1Y8cOx2ikBw4cKMluOdWjRw/98MMP+vnnn12WMcboqaeeUkBAgDp37pxn3p133qmNGzfq3XffdVk/PT1d9913n0JDQzVkyBCP9fuzzz7Tvn37XJb5448/tGbNmiId5z1p+fLlOnnypHr06JFvXq9evfS///3P5WBDycnJBT6QOzIyUqdOndKxY8fyzfvyyy81adIkZWVlFdi/6OjofJ83NWrUUKtWrfTiiy8W+IPApk2b9N133+W77HDlypWaOnVqgT+0GGOctl0WcUlhBdG2bVvdd999mj59uj788EN169ZNYWFh8vX1dYwQ89VXX+mPP/7QM888o3r16uWpX69ePc2fP1///ve/tWHDBvXr10/169eXn5+fMjMzFR8fr82bN2vbtm2aNm1avstf/P399dxzz2nMmDFq0aKFBg0apPDwcFWtWlXZ2dlKSEjQ9u3b9c033ziey+FpNptNixYt0jXXXKNLL71UgwYNUkhIiIwxOn78uH755Rd98803mjZtmtMhsy9Up06d1KBBAw0bNkxDhw5Vo0aN8nz5yMnJUVxcnF555RVdf/31bo/el2vkyJH6+OOP1bBhw3zDDttsNg0aNEivvvqqhgwZUqwzE926dXOMiPjBBx+odevW6t69u3r37l3kZRXHtGnTNH36dCUlJaldu3YKCAhQVlaWTpw4od9//12ff/65pk2bpgULFpRIf6S/tvnzzz+vq6++WjfccIOaN2/uGKUpIyNDR48e1dtvvy1jjGbOnOn2cq+//npNmjRJw4YNU6dOnfKNkJWWlqZ169bpxIkT+cL19ddfr6efflonTpxQ27Zt84xwaIzRn3/+qQ8++EABAQHq379/nrqdO3fWmDFjdNttt2n16tVq27atatasKZvNpvPnzysuLk4rV64sleBdFt9/6a9j24IFC3Trrbdq37596tevn+rWrStjjE6cOKF9+/bps88+y7etC3Ohx4vc492QIUPUvn179e/fX1FRUbr55pudjrh5IS655BJ98803Cg0N1eDBg9WgQQPVqFFD2dnZio+P16pVq5SUlKT33nsvX92wsDA9+OCDeuyxx7RlyxZdfvnlql27tjIyMpSYmKgNGzbo4MGDmjBhgl544QWn7V/IsSk8PFz333+/5syZo++//15dunRRnTp15OXl5fhsWrNmjeN9LKkfGby9vQv9Eiv99SPh5Zdfrn79+ik4ONjxN/HTTz9p06ZNmjp1qrZt26YZM2bo6NGj+te//lXkzxZPGTdunF5++WX17NlTN954o5o0aeIY/Cb3LO3mzZu1ceNGzZ8/P99gGIMGDdKIESN044036rXXXlP79u0VGhoqb29vpaamKjY2VqtXr9bx48e1YsUKl/dwZWVlFeny7smTJ+uVV15R+/btNWbMGDVq1MjR79TUVB08eFArVqxQeHi4Jk+eXMytU7CPP/44X+Azxuj06dPauXOnPvzwQ40ePTpfSJWkRx99VO+8846aN2+u0aNHKzw8XD4+Pjp16pSio6O1evVqDRkyxOUQ/P3791fdunXVr18/3XDDDerWrZv69OkjSbr22mv1+OOPq0ePHrryyivz/fBz/vx5R/9eeumlPPNsNpueeeYZXXPNNWrXrp0GDBig4OBgeXt7yxij1NRU7du3T6tWrVLPnj3z3cM1cuRIvfHGG7ryyivVs2fPfIOwZWRkaOvWrdq+fbueeOIJ9zZ0aSqJpyvDc2bOnGnGjh3rcv66devMgAEDTNOmTY2Pj4+RZKpUqWJatmxphg8fbrZv317g8rdt22aGDRtmWrZsaapUqWIkGR8fH9O0aVMzYMAA8/XXXxdYf//+/WbMmDGmTZs2pmrVqkaSqVSpkomMjDT9+vUz7733nrHb7UVa57Nnz5q6deuar776yq3yv/76qxk6dKhp1KiR8fb2Nt7e3qZevXpm5MiRZvPmzebMmTOmbt26ZteuXfnq3nzzzU6fxP5Pjz76qNOn3O/Zs8cMHDjQ1KpVy0jK8/Ly8jLh4eFm0qRJ5vTp026ty9+lpKSY+vXrmwULFjidv2nTJhMUFGS++OILl8tYt26diYyMNDk5OU7nZ2VlmcWLF5uOHTua2rVrm379+uWZ/9prr5kePXoU2tcvv/yywHacyc7ONkuWLDGtW7c2AQEBjm0WHBxsBg8ebD777DOTk5NjIiIizLp169xe7p49e0xwcLA5deqU23X+LiMjw8ydO9d06NDB1KhRw/F++vn5mZYtW5oJEyaYY8eOOa3ranvb7Xbz1FNPmSZNmpjKlSvn21cCAwNNx44dzdq1a/MtMzMz00yfPt00bNjQVKpUKV/dGjVqmF69epmtW7c67VN2drZ58cUXTefOnU2dOnUc9XL/zkeNGmWio6Od1t29e7epW7duoduyoL+xRo0amc8//9xpvy7k/e/Vq5d55ZVXCuyXMe7/jf/Txo0bzZVXXmkaNGhgbDabsdlspmbNmqZ79+7mhRdeMFlZWSYqKsrpul1xxRVO++aJ48WPP/5oBgwYYCIiIkxgYKDZv3+/Y15Rjp2u3pfcY92ff/5pZs+ebdq1a2eCgoLy7DM33nijOXjwoMtl2+12s2rVKtOzZ08TGhrq+Fxq1KiRufPOO82RI0cKPWYUdmx6/fXXXR6b7Ha7ef/9902PHj1MvXr1HNu4UqVKJioqygwePNjlZ2NB+/I/uXr/nfnqq6+Mj4+Py8/DN99800gyCQkJ5o477jBt2rQxlSpVMpUrVzZhYWFmxIgRjr+D/fv3m8suu8xUr17d5bGopCQnJ5sZM2aY1q1bm8DAwDz7dGhoqOnVq5f59NNPXda32+3mnXfeMf369TORkZGOY1zVqlVNmzZtzNixY10en3ItX77c1K9fv0j9Pnv2rLnvvvvMpZdemqffgYGB5tJLLzX33XefOXv2rNO6O3fuNHXr1jVnzpwpUpvGGBMTE5Pvb//vrzp16pjOnTubF1980WRnZ7tcTlJSkrn99ttNq1atjJ+fn7HZbKZWrVqmT58+5n//+5+x2+0FHiN37NhhrrnmGlOnTp18f1tr1qwxHTt2dHyn+/sr9xiwcOFCl/379ddfzZAhQ0xUVFSez6waNWqYNm3amLlz55rk5GSndZcuXWouueQSx/fRv7/8/PxM69atzbJly9zc2qXLZkwZeyw8AABABbZ37161bNlSR48edXrmYenSpRo/fryysrJK7YxVefX444/rs88+0w8//FDaXSnU4cOHFRkZqa+++kr9+vUr7e7AQtzDBQAAUIIaN26sBg0a5LsMK5fNZnO84L6srCy9+eabjkvigLKCn00AAABKUOXKlfXggw/q7rvvVnp6uoYOHapWrVo5hr++5pprtGzZsgr5vEpPM/9/4IR9+/bpiSeeUGJiou65557S7haQB4ELAACghN1xxx0yxuj+++/Xs88+q4CAACUnJztGpSzO4z0uRuvWrdM111wjSWrevLm2bNmikJCQUu4VkBf3cAEAAJSSrKwsHTx4UKmpqflGoEXhzp07p23btqlRo0aqV69euboM8+zZs2ratKm+/vprtWnTprS7AwsRuAAAAADAIgyaAQAAAAAW4R4uN9ntdiUkJCgwMLBcna4GAAAA4FnGGP35558KDQ2Vl1fB57AIXG5KSEhw+ZRuAAAAABef2NhY1a9fv8AyBC43BQYGSvprowYFBZVybwAAAACUlpSUFIWHhzsyQkEIXG7KvYwwKCiIwAUAAADArVuNGDQDAAAAACxC4AIAAAAAixC4AAAAAMAiBC4AAAAAsAiBCwAAAAAsQuACAAAAAIsQuAAAAADAIgQuAAAAALAIgQsAAAAALELgAgAAAACLELgAAAAAwCIELgAAAACwCIELAAAAACxC4AIAAAAAixC4AAAAAMAiBC4AAAAAsAiBCwAAAAAsQuACAAAAAIsQuAAAAADAIt6l3QEAKC9sc5cWuY6ZcYvH+wEAAMoPznABAAAAgEUIXAAAAABgEQIXAAAAAFiEwAUAAAAAFiFwAQAAAIBFCFwAAAAAYBECFwAAAABYhMAFAAAAABYpN4Fr/fr16t69u8LCwhQSEuJ4hYeHa8iQIdqzZ0+e8tHR0Ro9erSaNGniKBsaGqr27dvrySefVGZmZimtCQAAAICLRbkIXNHR0brtttu0cOFCxcXFKTEx0fE6fPiwxo4dq2uvvdYRouLi4tS3b18NGjRIO3bscJSNj4/XJ598ooMHD2rMmDGlvFYAAAAAKrpyEbhWrlypiRMnqnPnzrLZbHnmVapUSddff73Cw8O1e/duSdKCBQt0//33a/To0fL393eUtdlsCg8P10svvaQDBw7o119/LdH1AAAAAHBxKReB6/Dhw2rUqFGBZa699lp5ef21Ort27VLv3r1dlvXy8lKfPn20a9cuj/YTAAAAAP7Ou7Q74I7z58/L19e3wDKTJ092/DsuLk716tUrsHxoaKiOHj3qkf4BAAAAgDPlInBJ0tmzZzV58mRt3rxZx44dc0yvVauWunXrpscee0yhoaGSpJycHFWqVKnA5Xl7eys7O9vl/MzMzDwDa6SkpFzgGgAAAAC42JSLSwqlv+7Luuqqq7RlyxbHIBjHjh3Tli1b1KpVK11zzTUFBqiimj9/vqpVq+Z4hYeHe2zZAAAAAC4O5SZwjRo1SoMHD843CEb16tU1ZcoU1a9fX99++63TusuXL1e7du2K1N5DDz2k5ORkxys2NvaC+g8AAADg4lNuAlfz5s0LnH/JJZfo4MGDTueNHTu2yCMS+vr6KigoKM8LAAAAAIqi3AQuPz+/Auf7+/srLS1NUuH3Z0lSdna2vL3LzS1sAAAAAMqhchG4AgICdO7cuQLLZGRkOC43rF+/vhITEwssn5CQoAYNGnisjwAAAADwT+UicEVFRSk6OrrAMnv37lVUVJQkqXXr1lq/fr3Lsna7XRs2bFDr1q092k8AAAAA+LtycU3d6NGj1a1bN/Xo0UM9e/Z0POBYkrKysrR8+XJFR0erR48ekqTp06erS5cuql27toYNG+Y482WMUUJCgmbPnq2oqKgiD6QBAAAAAEVRLgJXvXr1tHLlSj388MO66aablJWV5Zjn6+urLl26aO3atY6HI4eFhembb77Ro48+qscee0x//vmnpL9GNQwODtYNN9ygxYsXl8q6AIAVbHOXFrmOmXGLx/sBAADyKheBS5I6dOigL7/80u3yjRs31jvvvGNhjwAAAACgYOXiHi4AAAAAKI8IXAAAAABgEQIXAAAAAFiEwAUAAAAAFiFwAQAAAIBFCFwAAAAAYJFyMyw8AJRHPB8LAICLG2e4AAAAAMAiBC4AAAAAsAiBCwAAAAAsQuACAAAAAIsQuAAAAADAIgQuAAAAALAIgQsAAAAALELgAgAAAACLELgAAAAAwCIELgAAAACwCIELAAAAACxC4AIAAAAAixC4AAAAAMAiBC4AAAAAsAiBCwAAAAAsQuACAAAAAIsQuAAAAADAIgQuAAAAALAIgQsAAAAALELgAgAAAACLELgAAAAAwCIELgAAAACwCIELAAAAACxC4AIAAAAAixC4AAAAAMAiBC4AAAAAsAiBCwAAAAAsQuACAAAAAIsQuAAAAADAIgQuAAAAALAIgQsAAAAALELgAgAAAACLELgAAAAAwCIELgAAAACwCIELAAAAACxC4AIAAAAAixC4AAAAAMAiBC4AAAAAsAiBCwAAAAAsQuACAAAAAIsQuAAAAADAIgQuAAAAALAIgQsAAAAALELgAgAAAACLELgAAAAAwCIELgAAAACwCIELAAAAACxC4AIAAAAAixC4AAAAAMAiBC4AAAAAsIh3aXcAAJCXbe7S0u4CAADwEM5wAQAAAIBFykXg+uabb+Tv76+QkBCXr/DwcCUkJDjqbN++XUOGDFFUVJSjTFhYmDp16qTXXntNOTk5pbhGAAAAAC4G5eKSwpSUFF1//fVaunSpW+W3b9+ukSNHasmSJerbt698fX0lSXa7XdHR0XrwwQe1b98+Pf300xb2GgAAAMDFrlyc4SqqWbNm6bnnntOAAQMcYUuSvLy81KxZM61YsUIrV65UUlJSKfYSAAAAQEVXIQPXrl271Lt3b5fzAwIC1KFDB/3xxx8l2CsAAAAAF5tycUlhUSUnJ6tq1aoFlgkNDdXRo0ddzs/MzFRmZqbj/ykpKR7rHwAAAICLQ7kJXIcOHdKECRP0/fff6/Tp0zLGSJLq1q2rK6+8Uo888ohq1qzp9vK8vb2VnZ3tcv78+fM1e/bsC+43AJRVxRl+3sy4xeP9AACgIisXlxRGREQoOTlZXbp00fr16xUfH6/ExEQdO3ZM33zzjfz8/HTjjTc6QpgnPPTQQ0pOTna8YmNjPbZsAAAAABeHcnGGq23bttqxY0e+6TabTbVr19acOXPUpk0bHTp0SI0aNcpXbsGCBfr+++/16aefut2mr69vngE3AAAAAKCoykXgKozNZlOLFi108OBBp4Fr+vTppdArAAAAABe7cnFJoTv8/f2Vnp7udvns7Gx5e1eIvAkAAACgjCoXgev111/Xrl27CiyTkZEhPz8/SVL16tWVmppaYPmEhAQ1aNDAY30EAAAAgH8qF4Hr8OHD2rhxo8v5xhjt379fUVFRkqTWrVtr/fr1LsunpaVp+/btatasmae7CgAAAAAO5SJwDRkyRIsXL9Zvv/2WbyTCjIwMPfnkk6pevboaN24sSXr88cf173//W2vXrs3zLC273a4DBw5o7NixGjFihIKDg0t0PQAAAABcXMrFTUwdO3bU008/rUmTJuno0aOy2+2Oef7+/rrqqqv03nvvyWazSZLatWunDz/8ULNmzdLkyZMd93Z5eXkpLCxMEyZM0G233VYq6wIAAADg4mEznnx4VQWWkpKiatWqKTk5WUFBQaXdHQCloDgPCq5oePAxAABFywbl4pJCAAAAACiPCFwAAAAAYBECFwAAAABYhMAFAAAAABYhcAEAAACARQhcAAAAAGARAhcAAAAAWITABQAAAAAWIXABAAAAgEUIXAAAAABgEQIXAAAAAFiEwAUAAAAAFiFwAQAAAIBFCFwAAAAAYBECFwAAAABYhMAFAAAAABYhcAEAAACARQhcAAAAAGARAhcAAAAAWITABQAAAAAWIXABAAAAgEUIXAAAAABgEQIXAAAAAFiEwAUAAAAAFiFwAQAAAIBFCFwAAAAAYBECFwAAAABYxLu0OwAAqNhsc5cWq56ZcUuJtFWcdgAAcBdnuAAAAADAIgQuAAAAALAIgQsAAAAALELgAgAAAACLELgAAAAAwCIELgAAAACwCIELAAAAACzCc7gAAG4r7jO1AAC4WHGGCwAAAAAsQuACAAAAAIsQuAAAAADAIgQuAAAAALAIgQsAAAAALELgAgAAAACLMCw8AMsUZwhxM+MWj/cDAACgtHCGCwAAAAAsQuACAAAAAIsQuAAAAADAIgQuAAAAALAIgQsAAAAALELgAgAAAACLMCw8gItScYasR8niPQIAVASc4QIAAAAAi3j0DNeXX36pdevW6fDhwzpx4oT8/Pz0yiuvqGHDhrr77rsVHBys8ePHq379+p5sFgAAAADKJI+c4crJydGgQYM0YMAArVu3TtnZ2QoJCdHXX3+t3bt3S5KCgoL0/PPP6/LLL1dMTIwnmgUAAACAMs0jgev555/XF198oc8++0y7du3SJ598okWLFskY4yjzxBNPaPfu3bLZbFq0aJEnmgUAAACAMs0jgev999/XDTfcoKuvvtoxzWaz5StXp04dXXfddVq3bp0nmgUAAACAMs0jgSs6OlotWrRwq2z9+vV17NgxTzQLAAAAAGWaRwLXqVOnVL16dbfK+vn5KS0tzRPNAgAAAECZ5rFh4Z1dQggAAAAAFzOPBC4/Pz+lp6e7VfbcuXPy8/PzRLOS/hohcfjw4Vq5cmWe6evXr1e/fv0UERGhkJAQhYSEKDw8XD169NCHH36YZ0APAAAAALCCR57D1bhxYx0+fNitsnFxcYqKivJEs5KkmTNnau3atRoyZIhj2scff6yZM2fqxRdfVOfOnVW5cmVJUnZ2tnbu3KkpU6YoISFBd999t8f6AQAAAAD/5JEzXF27dtXbb7+tpKSkAsulpKTonXfeUffu3T3RrD755BN99tlnuuWWW/JMnzFjhpYvX67u3bs7wpYkeXt7q3379nr33Xc1f/585eTkeKQfAAAAAOCMR85wzZkzR6tWrVLz5s01ZswYRUVFyW63y2az6csvv9Thw4cVGxurt956S3a7XbNnz77gNqOjozVlyhStX79ezz//vGN6VlaWTp48qTZt2risGxYWpuDgYMXHx6tBgwYX3BcAAAAAcMYjgat27drat2+fHn/8cW3atEnLly9XSkqKpL8eily1alVFRkZq2LBhmjlzpurUqXNB7aWlpem6667T4sWL1ahRozzzEhMT3Vp+aGiojh49SuACAAAAYBmPBC5JqlWrlp577jlPLc4lY4wmTpyogQMH5rlvK1dOTo4qVapU6HK8vb2VnZ3tcn5mZqYyMzMd/88NkAAAAADgLo8NC19SlixZomPHjmnOnDmWtjN//nxVq1bN8QoPD7e0PQAAAAAVT7kKXFu2bNHChQv1zjvvyNvb/ZNzd911l+66664itfXQQw8pOTnZ8YqNjS1qdwEAAABc5Dx2SaEk/frrrwoNDVVwcHC+ecePH1d8fLzatWtXrGUnJiZq9OjRevvtt50uvyAvvPBCkdvz9fWVr69vkesBAAAAQC6PnOE6deqULr/8cl122WV66623nJZZsWKFOnTooMsvv1ynT58u0vKzs7M1atQoTZ06Vd26dSuwbGH3Zv19mUU5SwYAAAAAReWRxDFv3jxFR0dr48aN6tGjh9MyU6dOVYcOHTRs2DDNnTtXixYtcnv5W7Zs0fbt27Vv3z4tWLAg3/zk5GT5+Pho1apV+vjjj3Xy5MlCl5mQkMAIhQAAAAAs5ZEzXKtXr1b//v1dhq1cPXv2VP/+/fXpp58Wafm9evVSamqqkpKSlJiYmO81atQoLVu2TGvWrJG3t7fq1Kmj3377zeXyEhISlJSUpLCwsCL1AwAAAACKwiOBKyEhQS1atHCrbPPmzXXs2DFPNOvSvHnzdNNNN2nz5s3KyspyTM/JydFvv/2mUaNGafr06W4NHw8AAAAAxeWRSwozMjJUo0YNt8rWqFFD586d80SzDtWqVVPVqlUd/x8yZIiqVq2qxx57TNHR0Y7naVWuXFkNGzbU1KlTNXz4cI/2AQAAAAD+qUKMGuHsgct9+vRRnz59SqE3AAAAAPAXj1xSGBQUpD///NOtsqmpqQoMDPREswAAAABQpnkkcDVq1EiHDh1yq+yhQ4fUqFEjTzQLAAAAAGWaRwLXlVdeqbffflsHDx4ssFx0dLRWrFihq6++2hPNAgAAAECZ5pF7uGbMmKGPPvpIrVq10qBBg9SgQYM8g1ikpqbqyJEjWrt2rSIjIzVjxgxPNAsAAAAAZZpHAlfVqlW1a9cuLVmyRN9++63Wr1+vlJQUx/ygoCBFRkZqwYIFuvPOO+Xj4+OJZgEAAACgTPPYKIU+Pj669957de+993pqkQAAAABQrlWIYeEBAChJtrlLi1zHzLjF4/0AAJR9Hhk0AwAAAACQH4ELAAAAACzi0UsKP/zwQ23cuFExMTFKTk52WS4iIkL/+9//PNk0AAAAAJQ5HglcWVlZuuqqq7Rp0yZ16NBBDRs2LPDhxg0aNPBEswAAAABQpnkkcC1cuFDff/+9Nm7cqJ49e3pikQAAAABQ7nnkHq6PPvpIo0aNImwBAAAAwN945AzXwYMHNXToUE8sCgCAElWcId4BAHCXR85wnT59WtWqVfPEogAAAACgwvBI4KpWrZrOnDnjiUUBAAAAQIXhkcDVqFEjxcbGemJRAAAAAFBheCRwDR8+XGvWrJHdbvfE4gAAAACgQvBI4Jo6dapq1qyp6dOne2JxAAAAAFAheGSUwvnz56thw4ZauHChVq1apS5duqhSpUouy0dEROjxxx/3RNMAAAAAUGZ5JHAdPXpUaWlpjudwJSQkFFi+oDAGAAAAABWFRwLX0qVLPbEYAAAAAKhQPHIPFwAAAAAgPwIXAAAAAFiEwAUAAAAAFvHIPVy59uzZo/Xr1+vw4cM6ceKEqlSporlz56pu3bp66qmnFBISomuvvVaBgYGebBYAAAAAyiSPneG6++67demll2rmzJn6+uuvFR0drddff10///yzJOm3337Trbfeqq5du+r48eOeahYAAAAAyiyPBK7ly5frxRdf1JIlS3TixAnt2LFDK1eulDHGUWbFihXau3evjh07pmeffdYTzQIAAABAmeaRSwpfeeUVDRkyRLfffrtjms1my1eucePGGjlypD755BM98cQTnmgaQAVjm7u0yHXMjFs83g8AAABP8MgZrujoaLVr186tspGRkYU+GBkAAAAAKgKPBK6kpCTVrl3brbL+/v5KSUnxRLMAAAAAUKZ5bNAMZ5cQXkg5AAAAACjvPBK4fHx8dO7cObfKnj9/Xj4+Pp5oFgAAAADKNI8ErqioKMXGxrpV9tixY4qMjPREswAAAABQpnkkcLVv314rV65UWlpageWysrL0wQcfqEOHDp5oFgAAAADKNI8MCz9v3jy1bNlSl156qe644w5FRkYqKytLNptNO3bskCTFxsbqlVdeUWJioubMmeOJZgEUU3GGXi/LKtr6AACAisMjgathw4b6+eefNX36dM2ZMyfPKISPPPKIJCkwMFA9e/bUW2+9pYiICE80CwAAAABlmkcClyS1aNFCn3zyiSTp7NmzSk5OdswLDAxUzZo1PdUUAAAAAJQLHgtcf1e9enVVr17dikUDAAAAQLnhkUEzduzYoYyMDE8sCgAAAAAqDI8Erh49emjp0qWeWBQAAAAAVBgeCVy1atXSvn37PLEoAAAAAKgwPBK4unbt6hj+HQAAAADwF48ErsmTJ2vz5s3asmWLJxYHAAAAABWCRwLX5ZdfrmeffVZjx47Vpk2bPLFIAAAAACj3PDIs/IsvvqijR48qIiJCffr0UdOmTdWqVSsFBQU5LR8ZGalHH33UE00DAAAAQJnlkcD1wQcf6NChQ5KkBg0a6Ny5c9q+fbvL8rGxsZ5oFgAAAADKNI8ErvXr13tiMQAAAABQoXjkHi4AAAAAQH4eCVwnT56UMcYTiwIAAACACsMjgatJkyZaunSpJxYFAAAAABWGRwJX1apV9fvvv3tiUQAAAABQYXgkcHXo0EF79+71xKIAAAAAoMLwSOC644479OWXX2r37t2eWBwAAAAAVAgeCVxXX321pk2bptGjR2v//v2eWCQAAAAAlHseeQ7X6tWr1bBhQ9WtW1ft2rVTr1691LJlSwUFBTkt37BhQ40bN84TTQMAAABAmWUzHhjPvWnTpjpw4IDb5Rs3blzuzoSlpKSoWrVqSk5OdhkkgfLCNndpaXcBuOiYGbeUdhcAAB5SlGzgkTNc5S08ARUJ4QkAAKDs8sg9XAAAAACA/MpN4Pr666/VvXt3hYaGKjg4WCEhIapXr56aN2+uBQsWKCsrK0/57du3a8iQIYqKilJISIhCQkIUFhamTp066bXXXlNOTk4prQkAAACAi0W5CFyHDx/W+PHjtXDhQsXHxyspKUmJiYk6duyYvvvuO23btk2LFi1ylN++fbtGjhypSZMmae/evUpMTFRiYqJiY2P11ltvac2aNXrwwQdLcY0AAAAAXAw8Frjsdrvbr6L67rvvNHToUHXu3Fk2my3PvDp16ug///mP3n//fce0WbNm6bnnntOAAQPk6+vrmO7l5aVmzZppxYoVWrlypZKSkoq/wgAAAABQCI8MmtGoUSMdPnzY7fKRkZFFGtWwc+fOateuncv5YWFhecLTrl271Lt3b5flAwIC1KFDB/3xxx8KDg52ux8AAAAAUBQeCVwvv/yy4uPjXc7Pzs7Wd999p3fffVcTJ07U4MGDi7T8pk2bFjg/Li5O7du3d/w/OTlZVatWLbBOaGiojh496nJ+ZmamMjMzHf9PSUlxs7cAAAAA8BePBK5+/foVWua2227ToEGDdNttt+mBBx7wRLMyxigxMVEPPPCAbr755iLV9fb2VnZ2tsv58+fP1+zZsy+0iwAAAAAuYiU6aMaIESMUFRWl//znP8VeRmxsrMLDwxUSEqIaNWooNDRUNWrU0PDhwz3YU+mhhx5ScnKy4xUbG+vR5QMAAACo+Ep8lMLevXvriy++KHb98PBwxcbGKjExUWfOnNGxY8dUtWpVTZ061WWdBQsWaMiQIUVqx9fXV0FBQXleAAAAAFAUHrmksChCQkIKvN+rKGw2m0JCQrRo0SK1bNlSiYmJCgkJyVdu+vTpHmkPAAAAAIqixM9w+fn56dy5cx5dZqVKldSiRQvt2bPH7TrZ2dny9i7xvAkAAADgIlLigevkyZMKDQ0tUp0rrrhCf/75Z4FlvLy85OX11+pUr15dqampBZZPSEhQgwYNitQPAAAAACiKEg9cP/zwgxo3blykOpUqVdK+fftczjfGaO/evYqKipIktW7dWuvXr3dZPi0tTdu3b1ezZs2K1A8AAAAAKIoSC1ypqamaM2eOvv76a91zzz1Fqjt69Gg98MADTp+blZaWppkzZ6pZs2aOM1aPP/64/v3vf2vt2rV5nqVlt9t14MABjR07ViNGjOChxwAAAAAs5ZGbmHr16qWYmBiX81NTU5WcnCwfHx89+uijGjZsWJGWf+utt+rcuXMaOHCgTp48KWOMY15gYKAGDBigpUuXOqa1a9dOH374oWbNmqXJkycrPT1d0l+XHYaFhWnChAm67bbbiraSAACUA7a5S4tcx8y4xeP9AAD8xSOB65ZbbnF69ilXUFCQIiIi1Llz5yLfvyX9NRrhXXfdpbvuusvtOu3atdOnn35a5LYAAAAAwFM8ErjGjx/vicUAAAAAQIVS4oNmAAAAAMDFgsAFAAAAABbxWOD67bffNGXKFH3++edO53/55ZeaMmWKfv31V081CQAAAABlmkcC1+bNm9WlSxetW7dOvr6+Tsv4+Pjoyy+/VNeuXbVlyxZPNAsAAAAAZZpHBs1YsGCBmjVrpp9//lne3s4X2bt3b+3atUsdO3bU/PnztWbNGk80DQBAucBw7QBwcfLIGa5ffvlF3bp1cxm2clWuXFndunXTL7/84olmAQAAAKBM80jgOn78uJo0aeJW2caNG+vEiROeaBYAAAAAyjSPBC673S4fHx+3yvr4+Mhut3uiWQAAAAAo0zw2SqG7IYqwBQAAAOBi4ZHAFRYW5vZlgidPnlRoaKgnmgUAAACAMs0jgatx48b68ccf3Sq7detWt+/3AgAAAIDyzCOB65577tG6des0d+5cpaamOi2TkpKi2bNna/369ZoyZYonmgUAAACAMs0jz+EaNmyYZs6cqXnz5mnWrFmqVq2aqlat6pifmpqq5ORk+fr66rHHHtPQoUM90SwAAAAAlGkeCVyS9Nhjj2nixIn66aefFBMTo5SUFMe8oKAgRUZGqlOnTty/BQAAAOCi4bHAJUmhoaG69tprPblIAAAAACi3PDYsPAAAAAAgLwIXAAAAAFjEY4Hrs88+09ChQ/X22287nf/uu+9q6NChWrt2raeaBAAAAIAyzSOBa/Xq1Ro8eLDS0tLUsmVLp2WaN2+u1NRUDRkyRGvWrPFEswAAAABQpnkkcD3zzDO6/PLL9fXXX6tt27ZOy7Rt21br16/X5ZdfrkWLFnmiWQAAAAAo0zwSuHbv3q2OHTu6VbZjx47avXu3J5oFAAAAgDLNI4HrxIkTioqKcqtsZGSkTp486YlmAQAAAKBM89igGd7e7j3Sy91yAAAAAFDeeSRweXl5KScnx62yOTk5stlsnmgWAAAAAMo0jwSu8PBwJSYmulX2+PHjCg8P90SzAAAAAFCmeSRwNWvWTBs2bHCr7Ndff63mzZt7olkAAAAAKNM8Ergeeugh/fDDD5owYYJ+//13paSkyG63O14pKSnatWuXbr31Vm3btk2PPPKIJ5oFAAAAgDLNIyNY9OrVS6+//roeeughvfHGG07LGGMUHBysN998U927d/dEswAAAABQpnlsyMDx48frhhtu0B9//KGYmBilpKQ45gUFBSkyMlLNmjWTn5+fp5oEAAAAgDLNo2O0+/n5qW3btmrbtq0nFwsAAAAA5ZLHnsMFAAAAAMjrgs5wJSUlKSYmRocPH1Z6errTMv7+/oqIiFBkZKSCg4MvpDkAAAAAKFeKFbgOHTqk6dOn64MPPpAxxq06NptNw4cP1/z589W4cePiNAsAAAAA5UqRA1dqaqp69uwpX19fvfHGG+rWrZvCwsJcDoaRkZGh+Ph4bdmyRY8//riuuOIK7d27V4GBgRfceQAAKjLb3KWl3QUAwAUqcuB64okndPbsWe3bt0/169cvtLyfn58aN26sxo0bq0+fPmrRooXmzZunBQsWFKvDAAAAAFBeFHnQjG+//VYjRoxwK2z9U3h4uEaOHKlvv/22yHUBAAAAoLwpcuA6cOCAIiMji91gZGSkDh48WOz6AAAAAFBeFDlwHT9+XLVr1y52gzVr1tTJkyeLXR8AAAAAyotiPYfLZrMVu8ELqQsAAAAA5QkPPgYAAAAAixQ5cPn4+CgzM7PYDWZmZsrHx6fY9QEAAACgvChy4IqMjFRsbGyxG4yPj1dERESx6wMAAABAeVHkwNW4cWNt2bKl2A1+9913aty4cbHrAwAAAEB5UeTANXXqVG3btk1PPvmk7Ha72/Xsdrvmz5+v7du369///ndRmwUAAACAcse7qBX69Omj+++/Xw8//LBee+01de7cWfXq1ZOfn5/T8hkZGUpISNBPP/2kQ4cO6d5771Xfvn0vuOMAAAAAUNYVOXBJ0pNPPqkxY8bolVde0aFDh/Trr78qPT3daVl/f381aNBA/fr10+233662bdteSH8BAAAAoNwoVuCSpDZt2mjJkiWe7AsAAAAAVCg8hwsAAAAALELgAgAAAACLELgAAAAAwCIELgAAAACwCIELAAAAACxC4AIAAAAAixC4AAAAAMAiBC4AAAAAsAiBCwAAAAAsQuACAAAAAIuUm8C1fPlytW3bVvXq1VNISIhCQkJUr149tWzZUosWLVJ2dnae8uvXr1e/fv0UERHhKB8eHq4ePXroww8/lDGmlNYEAAAAwMXCu7Q74I6NGzdqwYIF+vDDD9W0adM885KSkjRhwgRVrlxZkydPliR9/PHHmjlzpl588UV17txZlStXliRlZ2dr586dmjJlihISEnT33XeX+LoAAAAAuHiUizNcn3/+uSZPnpwvbElScHCwnnrqKS1fvtwxbcaMGVq+fLm6d+/uCFuS5O3trfbt2+vdd9/V/PnzlZOTUyL9BwAAAHBxKheBq0uXLrryyitdzg8PD1dsbKwkKSsrSydPnlSbNm1clg8LC1NwcLDi4+M93lcAAAAAyFUuLim89tprC5z/+++/q3HjxpKkxMRE1alTp9BlhoaG6ujRo2rQoIEnuggAAAAA+ZSLwFWQ+Ph43X777XrkkUckSTk5OapUqVKh9by9vfMNtPF3mZmZyszMdPw/JSXlwjsLAAAA4KJSLi4pdMYYo6VLl6pt27a65ZZbNGLECI8uf/78+apWrZrjFR4e7tHlAwAAAKj4yuUZrv379+uuu+5SamqqvvzyS7Vv377A8nfddZck6YUXXnC7jYceekj33nuv4/8pKSmELgAAAABFUq4CV05OjubNm6fXXntNjz/+uG6++WZ5eRV+kq4oQSuXr6+vfH19i9NNAAAAAJBUjgJXamqqRo8eLW9vb+3cuVPVq1d3Wq6we7NyZWdny9u73Kw+AAAAgHKo3NzDNW3aNNWvX18ffPCBy7AlSSEhITp58mShy0tISGCEQgAAAACWKheneKKjo/XFF19o7969stlsBZb19vZWnTp19Ntvv6lt27ZOyyQkJCgpKUlhYWEW9BYAAAAA/lIuznD9+uuv6t27t/z8/NwqP2/ePN10003avHmzsrKyHNNzcnL022+/adSoUZo+fbpbw8cDAAAAQHGVizNcp06d0sqVK/X555+7LFO5cmX9+OOPCg0N1ZAhQ1S1alU99thjio6OdjxPq3LlymrYsKGmTp2q4cOHl1T3AbfZ5i4t7S4AAADAg2zGGFPanSgPUlJSVK1aNSUnJysoKKi0u4MKisAFoDSYGbeUdhcAoFwpSjYoF5cUAgAAAEB5ROACAAAAAIsQuAAAAADAIgQuAAAAALAIgQsAAAAALELgAgAAAACLlIvncAEAgLKlOI+xYPh5ABcjznABAAAAgEUIXAAAAABgEQIXAAAAAFiEwAUAAAAAFiFwAQAAAIBFCFwAAAAAYBECFwAAAABYhMAFAAAAABYhcAEAAACARQhcAAAAAGARAhcAAAAAWITABQAAAAAWIXABAAAAgEUIXAAAAABgEQIXAAAAAFiEwAUAAAAAFiFwAQAAAIBFCFwAAAAAYBECFwAAAABYhMAFAAAAABYhcAEAAACARbxLuwMAAKB02eYuLe0uAECFxRkuAAAAALAIgQsAAAAALELgAgAAAACLELgAAAAAwCIELgAAAACwCIELAAAAACzCsPCARRhmGQAAAJzhAgAAAACLELgAAAAAwCIELgAAAACwCIELAAAAACxC4AIAAAAAixC4AAAAAMAiBC4AAAAAsAiBCwAAAAAsQuACAAAAAIsQuAAAAADAIgQuAAAAALAIgQsAAAAALELgAgAAAACLELgAAAAAwCIELgAAAACwCIELAAAAACxC4AIAAAAAixC4AAAAAMAiBC4AAAAAsAiBCwAAAAAsQuACAAAAAIsQuAAAAADAIgQuAAAAALBIuQ9cqampGjhwoF599dU807dv364hQ4YoKipKISEhCgkJUVhYmDp16qTXXntNOTk5pdRjAAAAABeLch24UlJS1L9/f+3evVtpaWmO6du3b9fIkSM1adIk7d27V4mJiUpMTFRsbKzeeustrVmzRg8++GAp9hwAAADAxcC7tDtQXBkZGbrqqqs0YMAA2e32PPNmzZql5557TgMGDMgz3cvLS82aNdOKFSvUsmVL3X///QoODi7JbgMAAAC4iJTbM1zGGN17772aOXNmvnm7du1S7969XdYNCAhQhw4d9Mcff1jZRQAAAAAXuXJ7hsvf31/XX3+903nJycmqWrVqgfVDQ0N19OhRl/MzMzOVmZnp+H9KSkrxOgoAAADgolVuA9eF8vb2VnZ2tsv58+fP1+zZs0uwRwAAVGy2uUuLXMfMuMXj/QCAklRuLym02kMPPaTk5GTHKzY2trS7BAAAAKCcuSgC14IFCzRkyJAi1fH19VVQUFCeFwAAAAAUxUVxSeH06dNLuwsAAAAALkIXxRkuZ7Kzs+XtfVHkTQAAAAClpEIGrurVqys1NbXAMgkJCWrQoEEJ9QgAAADAxahCBq7WrVtr/fr1LuenpaVp+/btatasWQn2CgAAAMDFpkJeU/f4449r+PDh8vb2Vr9+/eTr6ytJstvtOnTokO6//36NGDFCwcHBpdxTAAAAABVZhQhcQUFBCgwMdPy/Xbt2+vDDDzVr1ixNnjxZ6enpkiQvLy+FhYVpwoQJuu2220qruwAAAAAuEhUicN177735prVr106ffvppKfQGAAAAAP5SIe/hAgAAAICygMAFAAAAABYhcAEAAACARQhcAAAAAGARAhcAAAAAWKRCjFIIWM02d2lpdwEA4KbiHLPNjFs83g8AkDjDBQAAAACWIXABAAAAgEUIXAAAAABgEQIXAAAAAFiEwAUAAAAAFiFwAQAAAIBFCFwAAAAAYBECFwAAAABYhMAFAAAAABYhcAEAAACARQhcAAAAAGARAhcAAAAAWITABQAAAAAWIXABAAAAgEW8S7sDwIWwzV1a5Dpmxi0e7wcAAADgDGe4AAAAAMAiBC4AAAAAsAiBCwAAAAAsQuACAAAAAIsQuAAAAADAIgQuAAAAALAIw8IDAIAyqziP/yjLeJwJcPHhDBcAAAAAWITABQAAAAAWIXABAAAAgEUIXAAAAABgEQIXAAAAAFiEwAUAAAAAFmFYeFx0KtoQwwAAACi7OMMFAAAAABYhcAEAAACARQhcAAAAAGARAhcAAAAAWITABQAAAAAWIXABAAAAgEUIXAAAAABgEZ7DBUsU51lXZsYtHu8HAABW4bmOANzBGS4AAAAAsAiBCwAAAAAsQuACAAAAAIsQuAAAAADAIgQuAAAAALAIgQsAAAAALMKw8BcRhq8FAKD8KalHrZTlR7oU9zsMj5wp2+/rxYIzXAAAAABgEQIXAAAAAFiEwAUAAAAAFiFwAQAAAIBFCFwAAAAAYBECFwAAAABYhGHhy6mKOMR7RVwnAABKQ0l9pjLkOC7ExbL/cIYLAAAAACxSoQPX2bNn9cADD6h169aqV6+eQkJCFBISopYtW+qOO+5QUlJSaXcRAAAAQAVWYQNXTk6O+vbtq4CAAG3cuFEJCQlKTExUYmKitm7dqubNm6tbt25KT08v7a4CAAAAqKAqbOD66KOPFBERoVmzZqlWrVqy2WyOedWqVdOUKVM0YMAAvfzyy6XYSwAAAAAVWYUNXLt27VLv3r0LLNOvXz/t2rWrhHoEAAAA4GJTYQNXXFyc6tWrV2CZ0NBQHT16tIR6BAAAAOBiU2GHhc/JyVGlSpUKLOPt7a3s7Gyn8zIzM5WZmen4f3JysiQpJSXFc528EOcySrsHAABUGMX6fOezuFhKcluXme9tpakY267EtltZ7lshcvthjCm0bIUNXBdq/vz5mj17dr7p4eHhpdAbAABgpWrz7iztLlw0SnJb874WT1nebmWtb3/++aeqVatWYJmLJnD98ccf6t+/v7744gs1bdq00PIPPfSQ7r33Xsf/7Xa7Tp8+nW8AjrImJSVF4eHhio2NVVBQUGl3B6WE/QC52BcgsR/g/7AvQGI/8ARjjP7880+FhoYWWvaiCVzNmjXToUOH3C7v6+srX1/fPNOqV6/u4V5ZJygoiD8gsB/AgX0BEvsB/g/7AiT2gwtV2JmtXBV20IyC7s/KlZ2dLW/viyZzAgAAAChhFTZw1a9fX4mJiQWWSUhIUIMGDUqoRwAAAAAuNhU2cLVu3Vrr168vsMz69evVunXrEupRyfD19dWsWbPyXQ6Jiwv7AXKxL0BiP8D/YV+AxH5Q0mzGnbEMy6GcnBxdfvnlGjBggO655x7VrFnTMdhFSkqKli1bpueee047duxQQEBAKfcWAAAAQEVUYc9wVapUSV9//bUyMjLUq1cvhYaGKiQkRCEhIerUqZN+//13bd68mbAFAAAAwDIV9gwXAAAAAJS2CnuGCwAAAABKG4ELAAAAACxC4Convv76a3Xv3l2hoaEKDg5WSEiI6tWrp+bNm2vBggXKysrKU3779u0aMmSIoqKiHPeuhYWFqVOnTnrttdeUk5NTSmsCq+Tk5Gj48OFauXJlnunr169Xv379FBER4dgXwsPD1aNHD3344YfiquLy55tvvpG/v7/j/XT2Cg8PV0JCgqMOx4SKa/369erevbvCwsLy7QNDhgzRnj178pSPjo7W6NGj1aRJE0fZ0NBQtW/fXk8++aQyMzNLaU1wITZu3FjgMSEgIEDLli2TJGVkZGj+/Plq165dnnvcmzZtqjFjxujgwYOlvDa4EElJSZowYYIiIyPz7AORkZEaM2aMYmNj85Q/e/asHnjgAbVu3Vr16tVzlG/ZsqXuuOMOJSUlldKaVCAGZV5MTIypX7+++eGHH4zdbs8z7/jx42b48OFmwYIFjmk///yziYyMNGvXrjXnzp1zTM/JyTH79u0zQ4cONffdd1+J9R8l4+GHHzY+Pj7mzTffdEz76KOPTOvWrc13331nzp8/75ielZVltm/fbrp3726ef/75UugtLsRHH31kxo0b53Z5jgkV1/79+03Dhg2dfj5kZ2eb9957zzRp0sTxvsfGxprw8HCzYsUKk5aW5ihrt9vN0aNHzYQJE8x1111XouuAknHvvfeat956yxhjzNChQ82kSZNMXFxcnv0mNTXVLFu2zISHh5v4+PjS6iou0FVXXWXmzJljMjIy8kzPysoyr7/+uunYsaPJyckxxvx1nGjfvr157LHHzMmTJ/PsD2fPnjXPPvusadSoUZ7jBYqOwFUO/O9//zN33XWXy/kHDhww7du3d/x/4MCB5tNPP3VZPjU11TRo0MAkJiZ6tJ8oPR9//LFp27atmThxYp7A1apVK7Njxw6X9eLi4kxoaKjJzs4ugV7CU4oauDgmVFzz5s0z8+bNK7BMnz59zPbt240xxtx1111m8eLFLsvm5OSYSy+91Pzyyy8e7SdK34gRI8yGDRvMtm3bTIcOHRxfuJ1ZuHChueeee0qwd/CUs2fPmgYNGuT7AebvunXrZvbs2WOMMWblypVm+PDhBS5z8uTJZtGiRR7t58WGSwrLgc6dO2vSpEku54eFheU53btr1y717t3bZfmAgAB16NBBf/zxh0f7idIRHR2tKVOmaNWqVfLz83NMz8rK0smTJ9WmTRuXdcPCwhQcHKz4+PiS6CpKCceEiuvw4cNq1KhRgWWuvfZaeXn99XFf2L7g5eWlPn36aNeuXR7tJ0pXWlqafvzxR3Xt2lW7du3SFVdc4dgnnOnXrx/7QDl1/Phx1atXz/HsWWfq16/vuKywsGOCxP7gCd6l3QEUrmnTpgXOj4uLU/v27R3/T05OVtWqVQusExoaqqNHj3qkfyg9aWlpuu6667R48eJ8X7oSExNVp06dQpeRuy80aNDAqm6ilHFMqLjOnz8vX1/fAstMnjzZ8e+4uDjVq1evwPLsCxWL3W7X3XffrUmTJsnHx4d9oIKLjIzU6dOnZbfbXYbq2NhYRUVFSfrrmFDQD7MS+4MncIarHDPG6NixY3rggQd08803F6mut7e3srOzLeoZSoIxRhMnTtTAgQM1ZMiQfPNzcnJUqVKlQpfDvlA+HTp0SBMmTFCrVq3y3OTcpk0b3XfffTp9+nSRlsd+UH6dPXtWkydPVrt27fLcIN+qVStNnDgxz+Ap7hwX2BcqjvT0dI0cOVLnz5/XAw88IIl9oKLz9vZWp06d9Mgjj+jMmTN5BsbKzMzUW2+9pcOHDzsCF/tDySBwlTOxsbEKDw9XSEiIatSoodDQUNWoUUPDhw8v7a6hhC1ZskTHjh3TnDlzSrsrKGERERFKTk5Wly5dtH79esXHxysxMVHHjh3TN998Iz8/P914442MQHmRWLBgga666ipt2bJFiYmJjn1hy5YtatWqla655hq+LF2ETpw4ob59+6pNmzZavny5vL25qOliMWPGDP33v/9VzZo1Vbt2bYWEhCg4OFj+/v6aMGGCVq5cWeAlpfA8tnY5Ex4ertjYWCUmJurMmTM6duyYqlatqqlTp7qss2DBAqdnQFB+bdmyRQsXLtQ777xTpA/Ru+66S3fddZeFPUNJaNu2rXbs2KFbb71VISEhjg9Om82m2rVra86cOUpISNChQ4ec1ueYULGMGjVKgwcPlr+/v2OazWZT9erVNWXKFNWvX1/ffvut07rLly9Xu3btSqqrKCHGGN1000265ZZbNGvWrALv50lOTlbjxo21cePGkusgLHPixAkNGTJEr776qlJTU3Xq1CklJiYqKSlJKSkpeuutt7RgwQKdP3/eaf0//vhDUVFR2r9/fwn3vGLj545yzGazKSQkRIsWLVLLli2VmJiokJCQfOWmT59eCr2DVRITEzV69Gi9/fbbCg4OLlLdF154waJeoSyx2Wxq0aKFDh486HRABY4JFUvz5s0LnH/JJZfo4MGD6tOnT755Y8eO1dixY63qGkrJunXrlJOTo4kTJxZatlq1ajpw4EAJ9Aol4d1339XQoUM1cuTIfPMCAgI0cuRI/fjjj1q5cqXGjBmTr0yzZs1c/liH4uMMVwVQqVIltWjRIt/DLQuSnZ3N5QXlUHZ2tkaNGqWpU6eqW7duBZZ195pr9oWKyd/fX+np6W6XZz8ov/4+Oqkz/v7+SktLk+TecYF9ofz7+OOPNX78eKdnttgHKrZ9+/YVOghG69attW3bNknsDyWFwFUOXHHFFfrzzz8LLOPl5eW4rKh69epKTU0tsHxCQgKj0pVDW7Zs0fbt2zV//vw8N8fnvl5++WVNmTJFgwYNUkhIiE6ePFnoMtkXyp/XX3+90CF6MzIyHF/EOSZUXAEBATp37lyBZTIyMhyXG9avX1+JiYkFlmdfKP9++OEHdenSxek89oGKzZ1gZLPZHCGL/aFkELjKgUqVKmnfvn0u5xtjtHfvXseIM61bt9b69etdlk9LS9P27dvVrFkzj/cV1urVq5dSU1OVlJTkuDn+769Ro0Zp2bJlWrNmjby9vVWnTh399ttvLpeXkJCgpKQkhYWFldxK4IIdPny4wPstjDHav38/x4SLQFRUlKKjowssU5TPB7vdrg0bNqh169Ye7SdKVnx8vMvjeuvWrbVhwwbZ7XaX9devX88+UE5FRUUVesXTnj17FBkZKanwY4LE/uARpfjQZbjptddeM1dccYU5cuRIvnmpqalmxowZZujQoY5pv/zyi4mIiDBr1qwx586dc0zPyckx0dHR5tprrzX33ntvSXQdJWzcuHHmo48+cvz/k08+MZdccon57rvvzPnz5x3Ts7Ozza+//mq6d+9uFi9eXAo9xYX46aefTOPGjc2vv/5q7HZ7nnnp6elm/vz55oorrnDM45hQcSUkJJjIyEizYcMGk5OTk2fe+fPnzRtvvGGaN2/ueN/j4uJMeHi4Wb58uUlLS3OUtdvtJi4uzkyYMMEMHz68RNcBnletWrUC5w8bNsxMnDjRxMXF5TmGpKWlmbfeesuEh4eb+Ph4i3sJK5w4ccI0bNjQfPHFFyY7OzvPvOzsbPP555+bsLAwk5CQ4Jh22WWXmZkzZ5qTJ0/m2R+Sk5PN4sWLTaNGjUxqamqJrkdFYzOGcYPLOmOMXnzxRb300ks6efJknqGeAwMDNWDAAM2ePVvVq1d3TP/11181a9Ys/f777477OLy8vBQWFqYJEybotttuc+sZTShfpkyZosGDB6tfv36Oad98842eeOIJRUdHKzMzU5JUuXJlNWzYUFOnTtXw4cMLHMEKZdMnn3yi+fPn6+jRo3l+qfb399dVV12lxx9/XHXr1nVM55hQcW3fvl0PP/yw9uzZo6ysLMd0X19fdenSRU888YTjDJckHThwQI8++qh+/vlnx+XqNptNwcHBuuGGG/Tvf/9bVapUKfH1gOe0bt26wMuOz507p2eeeUbvvfeekpKSHN8rAgMD1bFjR82ZM8fpgDsoH3bs2KHp06fr999/z3NM8Pb2VqtWrTR37lx17NjRMT05OVnz5s3TZ599plOnTjn2h+rVq6tXr16aPXu200HZ4D4CFwAAAABYhHu4AAAAAMAiBC4AAAAAsAiBCwAAAAAsQuACAAAAAIsQuAAAAADAIgQuAAAAALAIgQsAAAAALELgAgAAAACLELgAAAAAwCIELgAAAACwCIELACqoFStWyGazFfn1xBNPFLmtxx57TN7e3nrllVcsWJOKITMzUwsWLFCvXr1Uv379PNu8UqVKatiwofr27au1a9fKGFPa3QUAeIh3aXcAAGCNPn36aMmSJfm+vJ84cUKPP/647rnnHjVp0iRfvauuuqrIbX377bfKycnRDz/8oIkTJxa7zxXVmTNn1KVLFx08eFDDhw9Xjx49VLduXXl5/fW7Z3Z2to4fP65NmzZp0KBBevLJJ/XAAw+Ucq89LzU1VcuWLdMdd9zhWHcAqOhshp/RAOCicuDAATVp0kQbNmzQFVdc4ZFlvvrqq3ruuec0b948DR061CPLrEjuv/9+vfrqq9q6datatGjhspwxRg8++KCWLFmiuLg41axZswR7ab1Nmzbpiiuu0IEDB9SoUaPS7g4AlAh+XgIAXLAJEybo999/J2w5YYzRiy++qKlTpxYYtiTJZrPpwQcfVEZGhvbu3VtCPSw5ub/x8lsvgIsJgQsAAAslJSUpPT1dXbp0cat8rVq1FBkZqaSkJIt7BgAoCQQuAIBLX3/9tRo0aKCsrCylpaVp4cKF6tixo2rWrKnrr7/eUW7v3r0KDg7W6dOnnS5n586dGjZsmJo0aaLKlSs7Boto1KiRrr32Wv3444/q3bu3y0E3Dh8+rLFjx6pFixby9fV11A8PD9c111yjzz//XOPGjdOMGTOc1j9x4oTuuOMOtWnTRv7+/o76tWvXVpcuXfTMM88oOzvbad3Zs2dr5MiRkqSjR49q2rRpat68uQICAvTCCy8Uug2PHj0qSapXr16hZXNt3LhRgwYNyjfdGKMPPvhAvXr1UlhYmGM9KleurMaNG2vo0KH69ddfnS7zq6++UlRUlOx2e4Ft79mzx+V72bt3b7366qs6deqUpk+frksuuUSBgYGy2WwKDg5W165d9eqrr+ZrY9myZbLZbOrdu7ckqUmTJo6++/n5KTo62t1NAwDlDoNmAABciouLU2xsrI4cOaLrrrtOCQkJuuqqq9S/f39dc801jnJJSUk6fvy4Tp8+ne++o/Xr1+vqq69Ws2bNNGzYMNWrV0+VK1eW3W7XqVOntG3bNvXt21eS1K1bt3x92Lt3rzp06KDatWtrxIgRCgsLk6+vr4wxOnPmjHbt2qVhw4apatWqefqU6+TJk2rZsqWysrI0evRojR07Vv7+/jLG6OzZs9q7d6+mTZumr776SmvXrpXNZstTPyYmRjExMdq8ebOGDh2qunXrqnv37mrUqJEGDhxY6DZMT0+XJPn5+RW+wf+/Bg0aOJ0+a9YszZkzR71799b48eMdA29kZWUpPj5ea9as0WWXXaa1a9fm2xbx8fGKiYmR3W4vcMCK48ePu3wvY2JitGnTJs2aNUtVqlRR//79FRoaqqCgIJ06dUo7duzQxIkT9d133+l///ufo17fvn21ZMkS7d+/X4sXL9bMmTNVp04dx3Zxtb4AUCEYAMBFJTo62kgyGzZsKLTsm2++aSSZvn37mrvuusskJyc7LbdhwwYjyURHR+eb16ZNG9O3b1+TlZXlsp2XXnrJSDKPPPJIvnlDhgwxzZs3N+np6S7rf/7550aSGTNmTL5599xzjwkKCjLx8fGF1v/ss8/yzRs3bpxp2rSpiYiIMK+99prJzs52uRxnCto2RREXF2d8fX3Nww8/bOx2u9My58+fN3369DEtW7bMVyb3vSzofSisvw0bNjSSzKJFi1z2YdmyZUaS+emnn4q0bACoqLikEABQKLvdrsWLFysoKKhI9c6cOaOdO3dq8uTJ8vZ2fVHFrbfe6nS+MUYbN27UpEmTCjxDdM011ygiIsLpvI0bN2rMmDEKDQ11Wf/qq69Wq1attG7dOqfz9+/fr3Hjxum2225TpUqVXC7HSj/++KMyMzM1bdq0fGfhclWuXFlTpkzRnj17dOrUKUv60atXL02dOtVlH8aOHavatWtr06ZNlrQPAOUNgQsAUKgJEyYU67lJhw8fluT6ErlclStXdnqP09mzZ5WSkuLWJWfh4eEu+xAVFVVgXZvNpqioKEd/nbn99tsL7YOVjhw5oqCgINWoUaPAcpGRkZL+uvzPCoUN/uHl5aUGDRpY1j4AlDfcwwUAKFSrVq2KVS85OVmSFBgYWGhZZ4HuQutLUkpKiux2u+Li4gqs7+vrq2PHjjmdV6NGDYWEhBTaByslJye7tR1yy+RuO09z5wxfYGCgZe0DQHlD4AIAFKqolxKWNQ8++KAefPDBQsvlDt7xT0FBQS4voQMAoCAELgBAhXf33Xfr6quvLrRccc/kFcTf31+SlJGR4Xadw4cPKzQ0VD4+Ph7vDwCgZBG4AACWyb28LS0trdCyxhiP15ekqlWrqlmzZk6fa1USGjZsKEk6duyYWrdu7VadPn366Omnn9bw4cMd0wIDA5Wamlpo3T///FOSVK1atTzTc89Spqamqnr16i7ru3oemScEBARI+r+h8gHgYsCgGQAAy+QO4JD78F9XTp8+7fQeq5o1ayowMLDQ+jk5Odq9e7fLPsTGxhba14cfflh33nlnoeWKqm7dugoICNDWrVvdKn/69GnFxMSobt26eaZHREQoOTlZZ8+eLbB+7mAVudv+7/Wlwt+LzZs3u9XP4sjtgzvvBwBUFAQuAIBlatSooZYtW+r55593eeYkIyNDt99+u+x2e755NptNPXr00EsvveTykrzs7Gzdd999LodB79mzp956660CB3E4ceKEXn311XwhxxNsNpvuvvtuPfPMM9q7d2+h5Z966in5+vqqRYsWeaZ36tRJPj4+WrRokcu6WVlZeu6559SyZUvVqlUrz7zmzZurbt26evbZZ12eDfzuu+/07LPPFr5SxVS7dm01adJEL774onJycixrBwDKEi4pBABYxmaz6ZlnnlH//v3Vtm1bDRw4UCEhIfLy8tLp06d16NAhrV69Wp06dXL5nKwnn3xSl112mZo3b64RI0YoNDRUlStX1tmzZ3X06FGtXr1aISEhateundP6M2fO1LvvvqumTZvqxhtvVP369VWlShVJf4W9uLg4ffDBB/L29tatt95qyXZ46KGHtGbNGrVp00bDhw9XkyZNVLduXcfIijk5OTpx4oQ2bdqkzZs364knnsgXmMLDw3X//fdrzpw5+v7779WlSxfVqVNHXl5eys7OVkJCgtasWaN9+/bps88+yzfIh7+/vxYsWKBbb71Ve/fuVZ8+fVS3bl1lZWUpKSlJ33//vbZt26Z77rlHCxcutGQ72Gw2LVq0SEOGDFH79u3Vv39/RUVF6eabb3a8JwBQ0RC4AOAiU6tWLYWGhjp97tU/1a9fX3Xq1Cnwnh9JCg4OVt26dVWzZs1886666ir9/PPPeuyxx7Rq1SodOXJEdrtdNWrUUIsWLTR37lzdfvvtatKkidNlX3LJJdq9e7ceffRRrVmzRocPH9b58+dVrVo1NW7cWPfcc4/+/e9/a+DAgU7r161bV7t379asWbP09ddf69ChQ46zZQEBAapXr56GDBmi++67z+nzviIjIwu9DK8w1apV0y+//KLnnntOa9as0ZYtWxQfH++Yb7PZFBoaqiZNmuijjz7S0KFDnS5nzpw5uvTSS/X888/r9ddfdwxjX6lSJTVs2FCtWrXS8uXL1b59e6f1x48fr8jISD3xxBNavny5YmNjVblyZYWEhKh379565ZVXZLPZ9NZbbzl9LyMiIhz3pBWkYcOGLp+LNmjQIP3www+aPXu23nvvPZ06dUq9e/d2+f4DQHlnM66uKwAAoARFRERo7Nixmjt3brHqX3HFFapfv76WL1/u4Z4BAFB83MMFALBMTk6Odu7c6VZZu93u9KG6O3fudOt+H1f1AQAoTQQuAIBloqOjdemll2rbtm0FlktPT9fx48fzXdKXkZGhSy+9VB9++GGB9e12u44ePer0kkAAAEoTlxQCACyTk5OjRo0aqXLlyho2bJjCw8PzDeaQnp6uzz77TD/99JP++OOPfPf+9OzZU9HR0Ro1apSioqIcA03kOnfunDZv3qxPPvlEP/30kzp27Gj5egEA4C4CFwDAUrt379Z9992nH3/80ekzpAIDA9WyZUvNmzdPffv2zTc/Li5OU6dO1caNG3Xy5Ml88/38/NSkSRM9/PDDGjVqlBWrAABAsRG4AAAAAMAi3MMFAAAAABYhcAEAAACARQhcAAAAAGARAhcAAAAAWITABQAAAAAWIXABAAAAgEUIXAAAAABgEQIXAAAAAFjk/wGuIMu+ncOGoQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def create_histogram(data: list) -> dict[int, float]:\n", " data_diff = np.diff(data)\n", " res = {\n", " count + 1: -v\n", " for (count, v) in enumerate(data_diff)\n", " if not (np.isnan(v) or np.isclose(v, 0))\n", " }\n", " return res\n", "\n", "\n", "res = create_histogram(data)\n", "plt.bar(res.keys(), res.values(), 1)\n", "plt.title(\"1000 runs with a Poissonian distribution (ยต = 50) of pulses\")\n", "plt.xlabel(\"Trigger Count\")\n", "plt.ylabel(\"Occurrence\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "32dd20fa", "metadata": {}, "source": [ "Stop\n", "----\n", "\n", "Finally, let's stop the sequencers if they haven't already and close the instrument connection. One can also display a detailed snapshot containing the instrument parameters before\n", "closing the connection by uncommenting the corresponding lines." ] }, { "cell_type": "code", "execution_count": 26, "id": "c4ea2ee0", "metadata": { "execution": { "iopub.execute_input": "2024-11-13T02:40:55.157050Z", "iopub.status.busy": "2024-11-13T02:40:55.156875Z", "iopub.status.idle": "2024-11-13T02:41:02.554943Z", "shell.execute_reply": "2024-11-13T02:41:02.554217Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Status: OKAY, State: STOPPED, Info Flags: FORCED_STOP, Warning Flags: NONE, Error Flags: NONE, Log: []\n", "Status: OKAY, State: STOPPED, Info Flags: FORCED_STOP, ACQ_SCOPE_DONE_PATH_0, ACQ_SCOPE_DONE_PATH_1, ACQ_BINNING_DONE, Warning Flags: NONE, Error Flags: NONE, Log: []\n", "\n", "Snapshot:\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "cluster0_module4:\n", "\tparameter value\n", "--------------------------------------------------------------------------------\n", "in0_gain :\t0 (dB)\n", "in0_offset :\t0 (V)\n", "in1_gain :\t-6 (dB)\n", "in1_offset :\t0 (V)\n", "marker0_exp0_config :\tbypassed \n", "marker0_exp1_config :\tbypassed \n", "marker0_exp2_config :\tbypassed \n", "marker0_exp3_config :\tbypassed \n", "marker0_fir_config :\tbypassed \n", "marker0_inv_en :\tFalse \n", "marker1_exp0_config :\tbypassed \n", "marker1_exp1_config :\tbypassed \n", "marker1_exp2_config :\tbypassed \n", "marker1_exp3_config :\tbypassed \n", "marker1_fir_config :\tbypassed \n", "marker1_inv_en :\tFalse \n", "marker2_exp0_config :\tbypassed \n", "marker2_exp1_config :\tbypassed \n", "marker2_exp2_config :\tbypassed \n", "marker2_exp3_config :\tbypassed \n", "marker2_fir_config :\tbypassed \n", "marker2_inv_en :\tFalse \n", "marker3_exp0_config :\tbypassed \n", "marker3_exp1_config :\tbypassed \n", "marker3_exp2_config :\tbypassed \n", "marker3_exp3_config :\tbypassed \n", "marker3_fir_config :\tbypassed \n", "marker3_inv_en :\tFalse \n", "out0_exp0_config :\tbypassed \n", "out0_exp1_config :\tbypassed \n", "out0_exp2_config :\tbypassed \n", "out0_exp3_config :\tbypassed \n", "out0_fir_config :\tbypassed \n", "out0_latency :\t0 (s)\n", "out0_offset :\t0 (V)\n", "out1_exp0_config :\tbypassed \n", "out1_exp1_config :\tbypassed \n", "out1_exp2_config :\tbypassed \n", "out1_exp3_config :\tbypassed \n", "out1_fir_config :\tbypassed \n", "out1_latency :\t0 (s)\n", "out1_offset :\t0 (V)\n", "present :\tTrue \n", "scope_acq_avg_mode_en_path0 :\tFalse \n", "scope_acq_avg_mode_en_path1 :\tFalse \n", "scope_acq_sequencer_select :\t1 \n", "scope_acq_trigger_level_path0 :\t0 \n", "scope_acq_trigger_level_path1 :\t0 \n", "scope_acq_trigger_mode_path0 :\tsequencer \n", "scope_acq_trigger_mode_path1 :\tsequencer \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "cluster0_module4_sequencer0:\n", "\tparameter value\n", "--------------------------------------------------------------------------------\n", "connect_acq_I :\toff \n", "connect_acq_Q :\toff \n", "connect_out0 :\tI \n", "connect_out1 :\toff \n", "cont_mode_en_awg_path0 :\tFalse \n", "cont_mode_en_awg_path1 :\tFalse \n", "cont_mode_waveform_idx_awg_path0 :\t0 \n", "cont_mode_waveform_idx_awg_path1 :\t0 \n", "demod_en_acq :\tFalse \n", "gain_awg_path0 :\t1 \n", "gain_awg_path1 :\t1 \n", "integration_length_acq :\t1024 \n", "marker_ovr_en :\tFalse \n", "marker_ovr_value :\t0 \n", "mixer_corr_gain_ratio :\t1 \n", "mixer_corr_phase_offset_degree :\t-0 \n", "mod_en_awg :\tFalse \n", "nco_freq :\t0 (Hz)\n", "nco_freq_cal_type_default :\toff (Hz)\n", "nco_phase_offs :\t0 (Degrees)\n", "nco_prop_delay_comp :\t0 (ns)\n", "nco_prop_delay_comp_en :\tFalse (ns)\n", "offset_awg_path0 :\t0 \n", "offset_awg_path1 :\t0 \n", "sync_en :\tTrue \n", "thresholded_acq_marker_address :\t1 \n", "thresholded_acq_marker_en :\tFalse \n", "thresholded_acq_marker_invert :\tFalse \n", "thresholded_acq_rotation :\t0 (Degrees)\n", "thresholded_acq_threshold :\t0 \n", "thresholded_acq_trigger_address :\t1 \n", "thresholded_acq_trigger_en :\tFalse \n", "thresholded_acq_trigger_invert :\tFalse \n", "trigger10_count_threshold :\t1 \n", "trigger10_threshold_invert :\tFalse \n", "trigger11_count_threshold :\t1 \n", "trigger11_threshold_invert :\tFalse \n", "trigger12_count_threshold :\t1 \n", "trigger12_threshold_invert :\tFalse \n", "trigger13_count_threshold :\t1 \n", "trigger13_threshold_invert :\tFalse \n", "trigger14_count_threshold :\t1 \n", "trigger14_threshold_invert :\tFalse \n", "trigger15_count_threshold :\t1 \n", "trigger15_threshold_invert :\tFalse \n", "trigger1_count_threshold :\t1 \n", "trigger1_threshold_invert :\tFalse \n", "trigger2_count_threshold :\t1 \n", "trigger2_threshold_invert :\tFalse \n", "trigger3_count_threshold :\t1 \n", "trigger3_threshold_invert :\tFalse \n", "trigger4_count_threshold :\t1 \n", "trigger4_threshold_invert :\tFalse \n", "trigger5_count_threshold :\t1 \n", "trigger5_threshold_invert :\tFalse \n", "trigger6_count_threshold :\t1 \n", "trigger6_threshold_invert :\tFalse \n", "trigger7_count_threshold :\t1 \n", "trigger7_threshold_invert :\tFalse \n", "trigger8_count_threshold :\t1 \n", "trigger8_threshold_invert :\tFalse \n", "trigger9_count_threshold :\t1 \n", "trigger9_threshold_invert :\tFalse \n", "ttl_acq_auto_bin_incr_en :\tFalse \n", "ttl_acq_input_select :\t0 \n", "ttl_acq_threshold :\t0 \n", "upsample_rate_awg_path0 :\t0 \n", "upsample_rate_awg_path1 :\t0 \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "cluster0_module4_sequencer1:\n", "\tparameter value\n", "--------------------------------------------------------------------------------\n", "connect_acq_I :\tin0 \n", "connect_acq_Q :\toff \n", "connect_out0 :\toff \n", "connect_out1 :\toff \n", "cont_mode_en_awg_path0 :\tFalse \n", "cont_mode_en_awg_path1 :\tFalse \n", "cont_mode_waveform_idx_awg_path0 :\t0 \n", "cont_mode_waveform_idx_awg_path1 :\t0 \n", "demod_en_acq :\tFalse \n", "gain_awg_path0 :\t1 \n", "gain_awg_path1 :\t1 \n", "integration_length_acq :\t1024 \n", "marker_ovr_en :\tFalse \n", "marker_ovr_value :\t0 \n", "mixer_corr_gain_ratio :\t1 \n", "mixer_corr_phase_offset_degree :\t-0 \n", "mod_en_awg :\tFalse \n", "nco_freq :\t0 (Hz)\n", "nco_freq_cal_type_default :\toff (Hz)\n", "nco_phase_offs :\t0 (Degrees)\n", "nco_prop_delay_comp :\t0 (ns)\n", "nco_prop_delay_comp_en :\tFalse (ns)\n", "offset_awg_path0 :\t0 \n", "offset_awg_path1 :\t0 \n", "sync_en :\tTrue \n", "thresholded_acq_marker_address :\t1 \n", "thresholded_acq_marker_en :\tFalse \n", "thresholded_acq_marker_invert :\tFalse \n", "thresholded_acq_rotation :\t0 (Degrees)\n", "thresholded_acq_threshold :\t0 \n", "thresholded_acq_trigger_address :\t1 \n", "thresholded_acq_trigger_en :\tFalse \n", "thresholded_acq_trigger_invert :\tFalse \n", "trigger10_count_threshold :\t1 \n", "trigger10_threshold_invert :\tFalse \n", "trigger11_count_threshold :\t1 \n", "trigger11_threshold_invert :\tFalse \n", "trigger12_count_threshold :\t1 \n", "trigger12_threshold_invert :\tFalse \n", "trigger13_count_threshold :\t1 \n", "trigger13_threshold_invert :\tFalse \n", "trigger14_count_threshold :\t1 \n", "trigger14_threshold_invert :\tFalse \n", "trigger15_count_threshold :\t1 \n", "trigger15_threshold_invert :\tFalse \n", "trigger1_count_threshold :\t1 \n", "trigger1_threshold_invert :\tFalse \n", "trigger2_count_threshold :\t1 \n", "trigger2_threshold_invert :\tFalse \n", "trigger3_count_threshold :\t1 \n", "trigger3_threshold_invert :\tFalse \n", "trigger4_count_threshold :\t1 \n", "trigger4_threshold_invert :\tFalse \n", "trigger5_count_threshold :\t1 \n", "trigger5_threshold_invert :\tFalse \n", "trigger6_count_threshold :\t1 \n", "trigger6_threshold_invert :\tFalse \n", "trigger7_count_threshold :\t1 \n", "trigger7_threshold_invert :\tFalse \n", "trigger8_count_threshold :\t1 \n", "trigger8_threshold_invert :\tFalse \n", "trigger9_count_threshold :\t1 \n", "trigger9_threshold_invert :\tFalse \n", "ttl_acq_auto_bin_incr_en :\tTrue \n", "ttl_acq_input_select :\t0 \n", "ttl_acq_threshold :\t0.49976 \n", "upsample_rate_awg_path0 :\t0 \n", "upsample_rate_awg_path1 :\t0 \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "cluster0_module4_sequencer2:\n", "\tparameter value\n", "--------------------------------------------------------------------------------\n", "connect_acq_I :\toff \n", "connect_acq_Q :\toff \n", "connect_out0 :\toff \n", "connect_out1 :\toff \n", "cont_mode_en_awg_path0 :\tFalse \n", "cont_mode_en_awg_path1 :\tFalse \n", "cont_mode_waveform_idx_awg_path0 :\t0 \n", "cont_mode_waveform_idx_awg_path1 :\t0 \n", "demod_en_acq :\tFalse \n", "gain_awg_path0 :\t1 \n", "gain_awg_path1 :\t1 \n", "integration_length_acq :\t1024 \n", "marker_ovr_en :\tFalse \n", "marker_ovr_value :\t0 \n", "mixer_corr_gain_ratio :\t1 \n", "mixer_corr_phase_offset_degree :\t-0 \n", "mod_en_awg :\tFalse \n", "nco_freq :\t0 (Hz)\n", "nco_freq_cal_type_default :\toff (Hz)\n", "nco_phase_offs :\t0 (Degrees)\n", "nco_prop_delay_comp :\t0 (ns)\n", "nco_prop_delay_comp_en :\tFalse (ns)\n", "offset_awg_path0 :\t0 \n", "offset_awg_path1 :\t0 \n", "sync_en :\tFalse \n", "thresholded_acq_marker_address :\t1 \n", "thresholded_acq_marker_en :\tFalse \n", "thresholded_acq_marker_invert :\tFalse \n", "thresholded_acq_rotation :\t0 (Degrees)\n", "thresholded_acq_threshold :\t0 \n", "thresholded_acq_trigger_address :\t1 \n", "thresholded_acq_trigger_en :\tFalse \n", "thresholded_acq_trigger_invert :\tFalse \n", "trigger10_count_threshold :\t1 \n", "trigger10_threshold_invert :\tFalse \n", "trigger11_count_threshold :\t1 \n", "trigger11_threshold_invert :\tFalse \n", "trigger12_count_threshold :\t1 \n", "trigger12_threshold_invert :\tFalse \n", "trigger13_count_threshold :\t1 \n", "trigger13_threshold_invert :\tFalse \n", "trigger14_count_threshold :\t1 \n", "trigger14_threshold_invert :\tFalse \n", "trigger15_count_threshold :\t1 \n", "trigger15_threshold_invert :\tFalse \n", "trigger1_count_threshold :\t1 \n", "trigger1_threshold_invert :\tFalse \n", "trigger2_count_threshold :\t1 \n", "trigger2_threshold_invert :\tFalse \n", "trigger3_count_threshold :\t1 \n", "trigger3_threshold_invert :\tFalse \n", "trigger4_count_threshold :\t1 \n", "trigger4_threshold_invert :\tFalse \n", "trigger5_count_threshold :\t1 \n", "trigger5_threshold_invert :\tFalse \n", "trigger6_count_threshold :\t1 \n", "trigger6_threshold_invert :\tFalse \n", "trigger7_count_threshold :\t1 \n", "trigger7_threshold_invert :\tFalse \n", "trigger8_count_threshold :\t1 \n", "trigger8_threshold_invert :\tFalse \n", "trigger9_count_threshold :\t1 \n", "trigger9_threshold_invert :\tFalse \n", "ttl_acq_auto_bin_incr_en :\tFalse \n", "ttl_acq_input_select :\t0 \n", "ttl_acq_threshold :\t0 \n", "upsample_rate_awg_path0 :\t0 \n", "upsample_rate_awg_path1 :\t0 \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "cluster0_module4_sequencer3:\n", "\tparameter value\n", "--------------------------------------------------------------------------------\n", "connect_acq_I :\toff \n", "connect_acq_Q :\toff \n", "connect_out0 :\toff \n", "connect_out1 :\toff \n", "cont_mode_en_awg_path0 :\tFalse \n", "cont_mode_en_awg_path1 :\tFalse \n", "cont_mode_waveform_idx_awg_path0 :\t0 \n", "cont_mode_waveform_idx_awg_path1 :\t0 \n", "demod_en_acq :\tFalse \n", "gain_awg_path0 :\t1 \n", "gain_awg_path1 :\t1 \n", "integration_length_acq :\t1024 \n", "marker_ovr_en :\tFalse \n", "marker_ovr_value :\t0 \n", "mixer_corr_gain_ratio :\t1 \n", "mixer_corr_phase_offset_degree :\t-0 \n", "mod_en_awg :\tFalse \n", "nco_freq :\t0 (Hz)\n", "nco_freq_cal_type_default :\toff (Hz)\n", "nco_phase_offs :\t0 (Degrees)\n", "nco_prop_delay_comp :\t0 (ns)\n", "nco_prop_delay_comp_en :\tFalse (ns)\n", "offset_awg_path0 :\t0 \n", "offset_awg_path1 :\t0 \n", "sync_en :\tFalse \n", "thresholded_acq_marker_address :\t1 \n", "thresholded_acq_marker_en :\tFalse \n", "thresholded_acq_marker_invert :\tFalse \n", "thresholded_acq_rotation :\t0 (Degrees)\n", "thresholded_acq_threshold :\t0 \n", "thresholded_acq_trigger_address :\t1 \n", "thresholded_acq_trigger_en :\tFalse \n", "thresholded_acq_trigger_invert :\tFalse \n", "trigger10_count_threshold :\t1 \n", "trigger10_threshold_invert :\tFalse \n", "trigger11_count_threshold :\t1 \n", "trigger11_threshold_invert :\tFalse \n", "trigger12_count_threshold :\t1 \n", "trigger12_threshold_invert :\tFalse \n", "trigger13_count_threshold :\t1 \n", "trigger13_threshold_invert :\tFalse \n", "trigger14_count_threshold :\t1 \n", "trigger14_threshold_invert :\tFalse \n", "trigger15_count_threshold :\t1 \n", "trigger15_threshold_invert :\tFalse \n", "trigger1_count_threshold :\t1 \n", "trigger1_threshold_invert :\tFalse \n", "trigger2_count_threshold :\t1 \n", "trigger2_threshold_invert :\tFalse \n", "trigger3_count_threshold :\t1 \n", "trigger3_threshold_invert :\tFalse \n", "trigger4_count_threshold :\t1 \n", "trigger4_threshold_invert :\tFalse \n", "trigger5_count_threshold :\t1 \n", "trigger5_threshold_invert :\tFalse \n", "trigger6_count_threshold :\t1 \n", "trigger6_threshold_invert :\tFalse \n", "trigger7_count_threshold :\t1 \n", "trigger7_threshold_invert :\tFalse \n", "trigger8_count_threshold :\t1 \n", "trigger8_threshold_invert :\tFalse \n", "trigger9_count_threshold :\t1 \n", "trigger9_threshold_invert :\tFalse \n", "ttl_acq_auto_bin_incr_en :\tFalse \n", "ttl_acq_input_select :\t0 \n", "ttl_acq_threshold :\t0 \n", "upsample_rate_awg_path0 :\t0 \n", "upsample_rate_awg_path1 :\t0 \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "cluster0_module4_sequencer4:\n", "\tparameter value\n", "--------------------------------------------------------------------------------\n", "connect_acq_I :\toff \n", "connect_acq_Q :\toff \n", "connect_out0 :\toff \n", "connect_out1 :\toff \n", "cont_mode_en_awg_path0 :\tFalse \n", "cont_mode_en_awg_path1 :\tFalse \n", "cont_mode_waveform_idx_awg_path0 :\t0 \n", "cont_mode_waveform_idx_awg_path1 :\t0 \n", "demod_en_acq :\tFalse \n", "gain_awg_path0 :\t1 \n", "gain_awg_path1 :\t1 \n", "integration_length_acq :\t1024 \n", "marker_ovr_en :\tFalse \n", "marker_ovr_value :\t0 \n", "mixer_corr_gain_ratio :\t1 \n", "mixer_corr_phase_offset_degree :\t-0 \n", "mod_en_awg :\tFalse \n", "nco_freq :\t0 (Hz)\n", "nco_freq_cal_type_default :\toff (Hz)\n", "nco_phase_offs :\t0 (Degrees)\n", "nco_prop_delay_comp :\t0 (ns)\n", "nco_prop_delay_comp_en :\tFalse (ns)\n", "offset_awg_path0 :\t0 \n", "offset_awg_path1 :\t0 \n", "sync_en :\tFalse \n", "thresholded_acq_marker_address :\t1 \n", "thresholded_acq_marker_en :\tFalse \n", "thresholded_acq_marker_invert :\tFalse \n", "thresholded_acq_rotation :\t0 (Degrees)\n", "thresholded_acq_threshold :\t0 \n", "thresholded_acq_trigger_address :\t1 \n", "thresholded_acq_trigger_en :\tFalse \n", "thresholded_acq_trigger_invert :\tFalse \n", "trigger10_count_threshold :\t1 \n", "trigger10_threshold_invert :\tFalse \n", "trigger11_count_threshold :\t1 \n", "trigger11_threshold_invert :\tFalse \n", "trigger12_count_threshold :\t1 \n", "trigger12_threshold_invert :\tFalse \n", "trigger13_count_threshold :\t1 \n", "trigger13_threshold_invert :\tFalse \n", "trigger14_count_threshold :\t1 \n", "trigger14_threshold_invert :\tFalse \n", "trigger15_count_threshold :\t1 \n", "trigger15_threshold_invert :\tFalse \n", "trigger1_count_threshold :\t1 \n", "trigger1_threshold_invert :\tFalse \n", "trigger2_count_threshold :\t1 \n", "trigger2_threshold_invert :\tFalse \n", "trigger3_count_threshold :\t1 \n", "trigger3_threshold_invert :\tFalse \n", "trigger4_count_threshold :\t1 \n", "trigger4_threshold_invert :\tFalse \n", "trigger5_count_threshold :\t1 \n", "trigger5_threshold_invert :\tFalse \n", "trigger6_count_threshold :\t1 \n", "trigger6_threshold_invert :\tFalse \n", "trigger7_count_threshold :\t1 \n", "trigger7_threshold_invert :\tFalse \n", "trigger8_count_threshold :\t1 \n", "trigger8_threshold_invert :\tFalse \n", "trigger9_count_threshold :\t1 \n", "trigger9_threshold_invert :\tFalse \n", "ttl_acq_auto_bin_incr_en :\tFalse \n", "ttl_acq_input_select :\t0 \n", "ttl_acq_threshold :\t0 \n", "upsample_rate_awg_path0 :\t0 \n", "upsample_rate_awg_path1 :\t0 \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "cluster0_module4_sequencer5:\n", "\tparameter value\n", "--------------------------------------------------------------------------------\n", "connect_acq_I :\toff \n", "connect_acq_Q :\toff \n", "connect_out0 :\toff \n", "connect_out1 :\toff \n", "cont_mode_en_awg_path0 :\tFalse \n", "cont_mode_en_awg_path1 :\tFalse \n", "cont_mode_waveform_idx_awg_path0 :\t0 \n", "cont_mode_waveform_idx_awg_path1 :\t0 \n", "demod_en_acq :\tFalse \n", "gain_awg_path0 :\t1 \n", "gain_awg_path1 :\t1 \n", "integration_length_acq :\t1024 \n", "marker_ovr_en :\tFalse \n", "marker_ovr_value :\t0 \n", "mixer_corr_gain_ratio :\t1 \n", "mixer_corr_phase_offset_degree :\t-0 \n", "mod_en_awg :\tFalse \n", "nco_freq :\t0 (Hz)\n", "nco_freq_cal_type_default :\toff (Hz)\n", "nco_phase_offs :\t0 (Degrees)\n", "nco_prop_delay_comp :\t0 (ns)\n", "nco_prop_delay_comp_en :\tFalse (ns)\n", "offset_awg_path0 :\t0 \n", "offset_awg_path1 :\t0 \n", "sync_en :\tFalse \n", "thresholded_acq_marker_address :\t1 \n", "thresholded_acq_marker_en :\tFalse \n", "thresholded_acq_marker_invert :\tFalse \n", "thresholded_acq_rotation :\t0 (Degrees)\n", "thresholded_acq_threshold :\t0 \n", "thresholded_acq_trigger_address :\t1 \n", "thresholded_acq_trigger_en :\tFalse \n", "thresholded_acq_trigger_invert :\tFalse \n", "trigger10_count_threshold :\t1 \n", "trigger10_threshold_invert :\tFalse \n", "trigger11_count_threshold :\t1 \n", "trigger11_threshold_invert :\tFalse \n", "trigger12_count_threshold :\t1 \n", "trigger12_threshold_invert :\tFalse \n", "trigger13_count_threshold :\t1 \n", "trigger13_threshold_invert :\tFalse \n", "trigger14_count_threshold :\t1 \n", "trigger14_threshold_invert :\tFalse \n", "trigger15_count_threshold :\t1 \n", "trigger15_threshold_invert :\tFalse \n", "trigger1_count_threshold :\t1 \n", "trigger1_threshold_invert :\tFalse \n", "trigger2_count_threshold :\t1 \n", "trigger2_threshold_invert :\tFalse \n", "trigger3_count_threshold :\t1 \n", "trigger3_threshold_invert :\tFalse \n", "trigger4_count_threshold :\t1 \n", "trigger4_threshold_invert :\tFalse \n", "trigger5_count_threshold :\t1 \n", "trigger5_threshold_invert :\tFalse \n", "trigger6_count_threshold :\t1 \n", "trigger6_threshold_invert :\tFalse \n", "trigger7_count_threshold :\t1 \n", "trigger7_threshold_invert :\tFalse \n", "trigger8_count_threshold :\t1 \n", "trigger8_threshold_invert :\tFalse \n", "trigger9_count_threshold :\t1 \n", "trigger9_threshold_invert :\tFalse \n", "ttl_acq_auto_bin_incr_en :\tFalse \n", "ttl_acq_input_select :\t0 \n", "ttl_acq_threshold :\t0 \n", "upsample_rate_awg_path0 :\t0 \n", "upsample_rate_awg_path1 :\t0 \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Status: OKAY, Flags: NONE, Slot flags: NONE\n" ] } ], "source": [ "# Stop both sequencers.\n", "module.stop_sequencer()\n", "\n", "# Print status of both sequencers (should now say it is stopped).\n", "print(module.get_sequencer_status(0))\n", "print(module.get_sequencer_status(1))\n", "print()\n", "\n", "# Print an overview of the instrument parameters.\n", "print(\"Snapshot:\")\n", "module.print_readable_snapshot(update=True)\n", "\n", "# Reset the cluster\n", "cluster.reset()\n", "print(cluster.get_system_status())" ] } ], "metadata": { "files_to_bundle_in_zip_file": [ "figures/misconfigured_gain_scope.png" ], "jupytext": { "main_language": "python", "notebook_metadata_filter": "files_to_bundle_in_zip_file" }, "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" } }, "nbformat": 4, "nbformat_minor": 5 }