{ "cells": [ { "cell_type": "markdown", "id": "4733decf", "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": "9835c2de", "metadata": { "tags": [] }, "source": [ "Setup\n", "-----\n", "\n", "First, we are going to import the required packages." ] }, { "cell_type": "code", "execution_count": 1, "id": "1aeb03fd", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:30.960938Z", "iopub.status.busy": "2025-05-16T13:33:30.960733Z", "iopub.status.idle": "2025-05-16T13:33:31.583938Z", "shell.execute_reply": "2025-05-16T13:33:31.583240Z" }, "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": "c72cbff2", "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": "9b824877", "metadata": {}, "source": [ "`!qblox-pnp list`" ] }, { "cell_type": "code", "execution_count": 2, "id": "c12bfe93", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:31.587138Z", "iopub.status.busy": "2025-05-16T13:33:31.586909Z", "iopub.status.idle": "2025-05-16T13:33:31.589622Z", "shell.execute_reply": "2025-05-16T13:33:31.589162Z" } }, "outputs": [], "source": [ "cluster_ip = \"10.10.200.42\"\n", "cluster_name = \"cluster0\"" ] }, { "cell_type": "markdown", "id": "3d173c9c", "metadata": {}, "source": [ "### Connect to Cluster\n", "\n", "We now make a connection with the Cluster." ] }, { "cell_type": "code", "execution_count": 3, "id": "c2a24705", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:31.591648Z", "iopub.status.busy": "2025-05-16T13:33:31.591449Z", "iopub.status.idle": "2025-05-16T13:33:32.466723Z", "shell.execute_reply": "2025-05-16T13:33:32.466011Z" }, "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", " 10: ClusterType.CLUSTER_QTM,\n", " }\n", " if cluster_ip is None\n", " else None\n", " ),\n", ")" ] }, { "cell_type": "markdown", "id": "a250c3de", "metadata": { "lines_to_next_cell": 2 }, "source": [ "#### Get connected modules" ] }, { "cell_type": "code", "execution_count": 4, "id": "a79468be", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:32.469472Z", "iopub.status.busy": "2025-05-16T13:33:32.469113Z", "iopub.status.idle": "2025-05-16T13:33:32.472725Z", "shell.execute_reply": "2025-05-16T13:33:32.472228Z" } }, "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": "606028f3", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:32.474591Z", "iopub.status.busy": "2025-05-16T13:33:32.474448Z", "iopub.status.idle": "2025-05-16T13:33:32.491834Z", "shell.execute_reply": "2025-05-16T13:33:32.491387Z" }, "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": "5c6695dd", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:32.493317Z", "iopub.status.busy": "2025-05-16T13:33:32.493172Z", "iopub.status.idle": "2025-05-16T13:33:32.495485Z", "shell.execute_reply": "2025-05-16T13:33:32.495079Z" } }, "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": "56123e7b", "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": "573f0c01", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:32.496985Z", "iopub.status.busy": "2025-05-16T13:33:32.496841Z", "iopub.status.idle": "2025-05-16T13:33:35.038210Z", "shell.execute_reply": "2025-05-16T13:33:35.037530Z" } }, "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": "ee8cda59", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.040438Z", "iopub.status.busy": "2025-05-16T13:33:35.039977Z", "iopub.status.idle": "2025-05-16T13:33:35.042716Z", "shell.execute_reply": "2025-05-16T13:33:35.042255Z" }, "lines_to_next_cell": 0 }, "outputs": [], "source": [ "readout_module = module" ] }, { "cell_type": "markdown", "id": "5bbb9337", "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": "04ce15f2", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.044409Z", "iopub.status.busy": "2025-05-16T13:33:35.044229Z", "iopub.status.idle": "2025-05-16T13:33:35.047101Z", "shell.execute_reply": "2025-05-16T13:33:35.046702Z" } }, "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": "bd2c5e73", "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": "1cb42df9", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.048530Z", "iopub.status.busy": "2025-05-16T13:33:35.048264Z", "iopub.status.idle": "2025-05-16T13:33:35.050599Z", "shell.execute_reply": "2025-05-16T13:33:35.050132Z" } }, "outputs": [], "source": [ "# Acquisitions\n", "acquisitions = {\n", " \"ttl\": {\"num_bins\": 100, \"index\": 0},\n", "}" ] }, { "cell_type": "markdown", "id": "f1aaff44", "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": "29931588", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.051930Z", "iopub.status.busy": "2025-05-16T13:33:35.051789Z", "iopub.status.idle": "2025-05-16T13:33:35.054513Z", "shell.execute_reply": "2025-05-16T13:33:35.054110Z" } }, "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": "547acec9", "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": "79d695de", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.055846Z", "iopub.status.busy": "2025-05-16T13:33:35.055699Z", "iopub.status.idle": "2025-05-16T13:33:35.058435Z", "shell.execute_reply": "2025-05-16T13:33:35.058038Z" } }, "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": "e107bfc2", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.059731Z", "iopub.status.busy": "2025-05-16T13:33:35.059573Z", "iopub.status.idle": "2025-05-16T13:33:35.099427Z", "shell.execute_reply": "2025-05-16T13:33:35.098978Z" } }, "outputs": [], "source": [ "# Upload sequence.\n", "readout_module.sequencer0.sequence(sequence_awg)\n", "readout_module.sequencer1.sequence(sequence_acq)" ] }, { "cell_type": "markdown", "id": "f7dc976f", "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": "0007ee39", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.101658Z", "iopub.status.busy": "2025-05-16T13:33:35.101244Z", "iopub.status.idle": "2025-05-16T13:33:35.198328Z", "shell.execute_reply": "2025-05-16T13:33:35.197742Z" } }, "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": "755a00fc", "metadata": {}, "source": [ "We start the sequence, and print the status flags of our sequencers." ] }, { "cell_type": "code", "execution_count": 15, "id": "3dfe86d2", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.200216Z", "iopub.status.busy": "2025-05-16T13:33:35.199997Z", "iopub.status.idle": "2025-05-16T13:33:35.216645Z", "shell.execute_reply": "2025-05-16T13:33:35.215977Z" } }, "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": "4cf987e1", "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": "a0c06004", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.221030Z", "iopub.status.busy": "2025-05-16T13:33:35.219919Z", "iopub.status.idle": "2025-05-16T13:33:35.408253Z", "shell.execute_reply": "2025-05-16T13:33:35.407646Z" } }, "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": "72d731c8", "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": "4741ac9b", "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": "8563ee82", "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 <8 with a minimum spacing of 8 ns 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": "fad43dce", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.410288Z", "iopub.status.busy": "2025-05-16T13:33:35.410095Z", "iopub.status.idle": "2025-05-16T13:33:35.414108Z", "shell.execute_reply": "2025-05-16T13:33:35.413637Z" } }, "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": "3bc7a2a1", "metadata": {}, "source": [ "We now generate the program, upload it and set the threshold and input gain." ] }, { "cell_type": "code", "execution_count": 18, "id": "27147843", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.415643Z", "iopub.status.busy": "2025-05-16T13:33:35.415481Z", "iopub.status.idle": "2025-05-16T13:33:35.452852Z", "shell.execute_reply": "2025-05-16T13:33:35.451848Z" } }, "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": "d46b2826", "metadata": {}, "source": [ "We then arm the sequencers and play the sequence." ] }, { "cell_type": "code", "execution_count": 19, "id": "d6c41260", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.455106Z", "iopub.status.busy": "2025-05-16T13:33:35.454651Z", "iopub.status.idle": "2025-05-16T13:33:35.473760Z", "shell.execute_reply": "2025-05-16T13:33:35.472942Z" } }, "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": "3cadd8bc", "metadata": {}, "source": [ "We retrieve the acquisition and plot it as in the previous section." ] }, { "cell_type": "code", "execution_count": 20, "id": "71e6a385", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.475918Z", "iopub.status.busy": "2025-05-16T13:33:35.475527Z", "iopub.status.idle": "2025-05-16T13:33:35.626326Z", "shell.execute_reply": "2025-05-16T13:33:35.625633Z" } }, "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": "18bd5f1d", "metadata": {}, "source": [ "We encourage you to play around with the `num_pulses`, `wait_time`, `input_gain` and `threshold` yourself." ] }, { "cell_type": "markdown", "id": "19d92feb", "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": "9bcd5b52", "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": "e5752779", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.628343Z", "iopub.status.busy": "2025-05-16T13:33:35.628153Z", "iopub.status.idle": "2025-05-16T13:33:35.631343Z", "shell.execute_reply": "2025-05-16T13:33:35.630819Z" } }, "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": "5d8aa5d2", "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": "4c644a4b", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.633288Z", "iopub.status.busy": "2025-05-16T13:33:35.633130Z", "iopub.status.idle": "2025-05-16T13:33:35.746461Z", "shell.execute_reply": "2025-05-16T13:33:35.745656Z" } }, "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": "5b828c53", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:33:35.748562Z", "iopub.status.busy": "2025-05-16T13:33:35.748294Z", "iopub.status.idle": "2025-05-16T13:34:05.783306Z", "shell.execute_reply": "2025-05-16T13:34:05.781709Z" } }, "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": "669d0631", "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": "b34d10f8", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:34:05.787447Z", "iopub.status.busy": "2025-05-16T13:34:05.787019Z", "iopub.status.idle": "2025-05-16T13:34:05.831301Z", "shell.execute_reply": "2025-05-16T13:34:05.830107Z" }, "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, 999, 999, 999, 998, 996, 994, 985, 981, 977, 970, 962, 946, 930, 910, 890, 858, 818, 773, 711, 656, 606, 567, 513, 467, 412, 357, 314, 261, 221, 185, 160, 124, 105, 77, 65, 58, 43, 34, 24, 20, 16, 7, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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": "050967c7", "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": "aec5c4c2", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:34:05.834673Z", "iopub.status.busy": "2025-05-16T13:34:05.834267Z", "iopub.status.idle": "2025-05-16T13:34:06.011205Z", "shell.execute_reply": "2025-05-16T13:34:06.010704Z" } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1wAAAJHCAYAAACEg1coAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAABuwElEQVR4nO3dd3gUZf/+/XNDCql0EhICSeggSJHepKiUEARBFFBEb4oiIoKIiiACgreCiujXLtyCDayABUFAQVREKSJIgAApJPSEFEKSnecPf9nHmN1kE3bSeL+OY48Ddq5r5jO7k9k9d2ausRiGYQgAAAAA4HJupV0AAAAAAFRUBC4AAAAAMAmBCwAAAABMQuACAAAAAJMQuAAAAADAJAQuAAAAADAJgQsAAAAATELgAgAAAACTELgAAAAAwCQELgBOe+utt9S9e/fSLgMokxo0aKCvv/66tMtwqdmzZ2v06NGlXUaFZ7ValZqaWtpllFsXL14s7RK0fft29e/fX+Hh4apWrVq5eT/5XC8ZBK5yJDU1VUOGDNHIkSMdttm0aZMiIyPVtGlTeXl5yWKxyMfHRy1bttTw4cP1+++/F7iM3377TcOGDdM111wjHx8fWSwWeXl5qVmzZoqKitLmzZsL7H/48GHdcccdat26tfz9/WWxWOTu7q6GDRvqpptu0po1a2QYRrHWH1du7Nix8vLy0pdfflms/rGxsYqJiXFxVeY6cOCAKleuLIvFku/h5uamiIgI3XzzzdqzZ4/Ll32lr3dF8/XXX8vb21t33HFHaZdiiqNHjyouLi7Pc3v37lWVKlXK9Beagt6XEydO6NixYyVfVBH16tVL/v7+2r17d2mXUiS//PKLunTpooCAANWpU0c5OTmlXVKxffvtt3J3d7e7r/33w9PTU7/88ku+eRiGoY8++kg33nijGjRoYJtfQECA2rZtqzFjxujIkSN5+mzYsMH2+o0ZM0bJyckltco2q1evVrdu3ZSYmKgRI0ZoyZIl8vX1LfE6iqM8fq6XR+6lXQCck56erkGDBmnLli3q2rWr3TYPP/ywnnvuOXXs2FH9+/dX3bp15eXlpfT0dJ04cUKbNm3SddddpxdeeEGTJ0/O13/p0qWaOnWqmjZtqj59+mjMmDHy9vZWZmamYmNjtX37dvXu3VsPP/yw/vvf/+br//HHH2vUqFEKCgrSgAEDNGLECPn7+ysrK0vx8fHatWuXhg8frltvvVUffPCBLBaLy18nFGzr1q26fPmyfv31Vw0YMCDPtF9//VXnz5/XDTfcUErVmSMpKUmZmZmaPXu2atWqlWdaTk6O4uLitG7dOrVr105ff/21+vbt67JlF/R6X41++eUXXbp0Sdu3by/tUkrM7t27lZKS4vJ1Tk1N1YoVK3TvvffKze3Kfjst6++LM/umrVu3yjAM7d27V61bty654q7Apk2b1L9/f3Xq1Enz5s1Thw4dVKlSpdIuq9ji4+OVk5OjF154odD18PT0VLNmzfI8ZxiGbr31Vq1Zs0Z9+vTR0KFDFRwcLA8PD128eFHHjx/X+vXr9eGHH+q9997T0KFDJUk9evTQ6tWrtX//fi1btkw7duzQ3r17VblyZdPW9Z+sVqumT5+uqKgoffrpp1f894gKykCZl5GRYdx4442Gn5+f0bp1a6Nr16752vz++++GxWIx/vvf/xpWq9XufC5fvmzcd999hq+vr5GQkJBnWnx8vOHj42NMnjzZyMrKsts/JyfHePrppw2LxWLs3r07z7S0tDQjJCTEGDp0qJGenu5wXVatWmVIMtauXVvYasMEc+fONVq1amXs2LEj37S77rrL6NatW4H958yZY4SEhJhVnik2b95sSDKio6Mdtrl8+bLRq1cvo1mzZg7/foqjoNf7avTzzz8brVu3Np544onSLsUUkow33ngjz3NHjx41OnToYNx9990uXdaWLVsMScbhw4eveF4FvS9jxoyx+5lTkpzZN40fP95o166dS16PktKzZ0/jlltuMbKzs0u7FJd45513DEkOv0MU5vPPPzckGR999JHDNqmpqcbNN99s1K1b10hLS8s3PTY21vD39zfefvvtYtVQHHFxcYYk45tvvimxZbpSefxcL48IXGWc1Wo1br75ZsPPz8/Yvn27ww+/iRMnGo0aNSp0x33hwgWjSpUqxsKFC/M8v2jRIqNKlSpGcnJygf2zsrKMBg0aGBMmTMjz/AcffGBYLBYjJiam0HW6/vrrjZtuuqnQdihZznyxKo87ZmcCl2EYxhdffGFIMpKSkkqoMlQ09gKXWZzdrq9UWQhcZaEGV4uNjTUkGT///HNpl+IyVxq4+vXrZ/Tu3bvQdkeOHDEsFovx/vvv251+7733Gn369ClWDcWxbds2Q5Lx559/ltgyXak8fq6XRxz3LOMMw5Cvr6+++eYbdenSxWG7mJgYtW/fvtDD+FWqVFGLFi3yna8bExOjFi1aKCAgoMD+7u7u6tixo93+derUUVhYWMErJKlLly6cL4wyp0GDBpL+vg4RAMwUGxsrSWrbtm0pV1J2xMTEqFOnToW2i4iIUJ06dRx+j2jXrl2+aynNlJGRIUny9vYusWWi/CFwlXFubm5auXJlgWFLko4fP646deo4Nc+QkJB8O6qS7n/s2DGnB8+4cOGCgoKCtGvXLhmGoQ8//FA33HCD6tSpo+DgYFmtVknSn3/+qcDAQJ07d67Q+QUGBuqPP/7IN23MmDGaNWuW0tPT9fTTT6tdu3aqWrWqLBaLatSooQ4dOmjhwoW6fPmy3XknJyfrvvvuU/369fNdJOzh4aFGjRpp8eLFTq/7bbfdphUrVtidlpOTo9atW2v+/PkO+0dGRmrNmjW2/2/cuFENGjSwvWaS1KdPH1ksFq1YsULbt2/PU7OjaybS09O1ZMkSDR48WE2aNJG7u7ttcJaJEyfq1KlTTq3fv+3bt0/jxo1Tw4YNbYOuuLm5qX79+rrhhhv03XffFWu+zvD09JQkZWZm5nk+MzNTCxcuVPv27VWjRg3ba5O7vhMmTFBSUpLdedp7vXNt2LBBHTt2lJ+fX75tpUaNGoqMjNTBgwftznfVqlW69tpr5e3tna9vYGCgRo4cqYSEBLt9c3Jy9Prrr6tLly4KDAy09fPy8lLTpk01cuTIfBel5/rn39iPP/6o2267TXXr1pWHh4dt+7755psLHLigUaNGDkfyu5L3v1evXnrjjTd09uxZzZw5U9dcc41tHoGBgerSpYveeOMNu++FM77//nv169dPYWFhqlSpkt2BABzp3bu33njjjXzPF2d/sWLFClksFvXq1UvS369nbh9vb29FR0fb2jq778ydT0EjLKalpWnBggW67rrrVK1atTwDKo0aNUpHjx612+/tt99Wjx49HL+w/8+3336riIiIYu+b3nnnHYfLMQxDH3/8sXr27KmQkJA8r3HDhg01ePBghwNK/fPzYv/+/Ro7dqzCwsJUuXJlVapUSWFhYbrpppu0ZcuWQtfxnxISElS9enW5u9u/lN7e62GPs597pSEnJ0enTp1SXFyc4uPjlZWVVWD7K/0ekqtWrVoO93+OpKSkaMaMGWrTpo0CAgJs20hAQIDatGmjGTNmKCUlJU+f1NRUValSxbYthoeH2/pVqVLFqVEK/7l97dixQ7fddptCQ0Ntg57l7rtee+01hwOqNGzY0KnRUXP3kUV16NAhDRo0SLVr1863n/Lx8VH79u311VdfOey/d+9eDRkyRI0aNZKHh4etb2hoqPr06VPgoFI7d+5Ur169bN/D/vkICAjQ9ddfr59//rnI61QaGDSjgsjIyHD6AlEfH598O6OMjAzVqFHD6f7p6elXtPzLly8rJyfH4YfNP124cEFJSUmKi4vT4sWLtWbNGg0YMECjR4/WddddZ7tA9dSpUzp16pTOnTun6tWrFzi/U6dOKTExUddcc02eacePH9eZM2fUoUMHnT17VpGRkRo8eLCqVaum5ORkHTx4ULNnz9bXX3+tLVu25PuSNXXqVK1Zs0YTJkxQaGhonotnMzIytGPHDk2fPl3Vq1fX2LFjC1337OxsvfrqqxozZky+aTt27NCePXt08eJFPf744/lq2bdvn9avX6///Oc/tufi4uJ09OhRWa1WW22PPfaYhgwZonfffVenT5/WQw89ZGvfokWLfMtNS0tT586ddejQIUVGRmr48OGqVauWLl++rOPHj+v999/X6tWrdeDAAdWuXbvQdcy1e/du9ejRQ9WqVdPgwYMVEhIiHx8fWa1WJSYmauPGjerTp49ef/11jRs3zun5Oiv3b+KfR2kNw9CNN96o7du3a/jw4YqKirLt+NPT0/Otb2BgYJ552nu9pb+Pog0cOFDdu3fX7Nmz5ePjk2eZx44d0yeffKLIyEgdOHBAHh4etulbt27V6NGjNWTIEN1xxx15/u4Mw9DBgwe1Zs0a3X777dq6dWu+9Rw7dqzeffddDRo0SDfccINq1qwpi8ViGxxnzZo1atGihXbu3KmWLVvm6Zv7N7Zo0SItWbJE119/vUaOHKnAwEC5ubkpISFB69evV7t27fTVV1/pxhtvzLf8w4cP2/31+Urf/5iYGG3dulVz5sxR5cqV1b9/fwUHBysgIEBnz57Vnj17NH78eP3www/63//+l69/QZYvX66xY8eqffv2uu2221SnTh27ZxPYG4xI+nv0wuPHj+d7vjj7iz59+mjZsmU6dOiQli5dmmcwGG9vb9WrV882D2f3nZLj90X6e8jtrl27KiEhQZGRkYqMjFT16tWVlZWluLg4ffzxx7Zt5t/71BMnTjgMY/8UHx+vmJiYYu+bjh8/7nA5c+bM0bx589SrVy+NHTtWtWvXlpubm21Ap3Xr1um6667T+vXr1a9fvzx9cz8v3n77bS1btkzt2rXTLbfcoqCgIHl6eioxMVHfffedevXqpTfffFP33HNPoeua+5r6+fkV6fWwx9nPvX87ffp0vh+X7KlZs2aRB5949NFHtWbNGh0/fjzPjwWVKlVSRESEpk+frv/85z/51uvSpUtF+h7x7+8hufz9/Ys0TPylS5d03XXXKTY2ViNHjtStt94qf39/SX+/T4cPH9ayZcv0ySefaN++fbYjWb6+vlq2bJl+/vlnvfzyy3ryySdt36OqVKni1CiFudvXf//7X61cuVIdO3bUrbfeqqCgIFWuXNm275o4caK+//57rVq1Kt88jhw54tQRvZiYGLv7oYJkZWUpMjJSVqtVkydPtn3+5Tp79qy++uor20i/TZs2zdN/06ZNuummmxQREWHbr3t4eMhqtSopKUk//vijBg4cqGeeeUYzZszI0/f8+fO66aabFB4erhkzZuQ7A+vkyZP6/PPPNWDAAP3111+qWbNmkdatxJXSqYwoJkfnstevX994/PHHiz2Pnj17GqNGjXKqv73zfYtyjn1Rz/OOiYkxJBl9+vQxevbsaRw9etRuO2evacid37fffptvWs+ePQ1JxkMPPeSwvtyL1VevXp3n+ZycHMPT09NYsmRJgcuPjIw0brjhhgLb5Prggw8MScbx48fzTXvooYcMT09Ph+eOz5w506hevbqRmZlpe66g197Za7gkGe3atTNOnTplt83p06eNGjVqGJMmTSps9fIYN26cERoaaly4cMHu9JycHGPUqFFGrVq17F4s7Yiz28XUqVONgICAPNdBrlmzxpBkbNiwwWG/pKQko3r16sZ9992Xb5qj13v+/PlGzZo187w3//brr78akozt27fnef4///mP0apVqwIH98itOy4uLs/zO3fuNCQZr7/+usO+qampRtOmTY0BAwbkm5b7WgYHBxv79u2z2z8rK8vo27ev0aJFC7s1ysF1Tlf6/tevX9+QZCxZssTha7NixQpDkvHLL7/YnW5PWlqaERgYaNx5551GTk5OgW0drZu9/fOV7i+c2a6d3XcWVPuYMWMMScZ9991nXL582W7f9PR0o3nz5sbAgQPzTXP2+hBX7JvsLScuLs7w8vIyHnvssQIHlOrdu7fRvHnzfG1yX8OAgABjy5YtdvtbrVZj7NixRq1atYzU1NQC68z1zjvvGPXr1y9wujOfk8W5lm///v2GJKcew4cPd3q+K1euNCQZXl5exvjx442lS5caq1evNtauXWt8/vnnxhtvvGHcddddhsViMaZPn56vv6Nt0J6CvrPkvibOeu655wx3d3dj//79DtscOHDA8PDwMP773//mm/btt98akpy6hv3fcrcvf39/h9uXYRjG8uXLHV7z5+zr5uh7YkF/o7nXp/32228O55uZmWlUr17dWLBgQb5prVq1Mrp06WJcunTJbl+r1Wo88sgjhp+fX77rp1euXGm4ubk5/K5hGH9//losFmPVqlUO25QVnFJYga1atUqenp569913i9V/69at8vLy0oIFC4rV//Dhw/Lz89P48eOL1f/f9u7dqw8//FDh4eEumZ8j9evX13PPPefw6FvPnj3Vrl27fKeQnDp1SpcvX1bjxo0LnP/jjz+u4cOHO1XLwIEDVbly5TynBUp/H8n49NNPNXnyZPn4+Gjt2rV5plutVr3//vsaMWKE7VQ5V3rrrbfyDbGeq2bNmhozZkyRT7Hx9fXVY489pipVqtid7ubmpqlTp+r06dP666+/ilqyTp48qbi4uDyPEydO6KefftLMmTNtRwv+eeRi69atatWqVYHDUdeuXVtjxoyxezTJkdjYWIWFhRX43rRt21azZ8/Oc8Qit2/jxo0LPIVt4MCBdn8R/P7771W1alXdfffdDvv6+vrq3nvvtQ2zbc+CBQvyHcnI5e7urilTpmj//v06e/asw+XYW+6Vvv89e/bU1KlTHb42o0ePVs2aNYv0Xv31119KSkrSQw895NLhns3YXzhypfvOqlWraunSpXmOtP6Tt7e3Jk6cqC1btpS5+yz+/PPPyszM1PTp0x1uFx4eHpoyZYr+/PNPh9vs1KlT1bNnT7vTLBaLHnroIZ0+fVoHDhxwWe1mady4sTZs2KC1a9cW+li4cKHT8x08eLCWLVumI0eO6LXXXtPkyZM1bNgwRUZGKioqSv/5z3/0zjvv6Nlnn9XSpUtt17EVZOHChfLy8iry50lRbN26VQMGDFDz5s0dtmnatKkiIyOLtO8oioK2L0m64447VLNmTX3//femLN+R3PeooP2Up6enlixZom7duuV5/vz589q7d6+mTJkiLy8vu30tFoumT5+u1NRU7dixI9+yq1ev7vC7hvT35+/ixYvVqlUrZ1ep1HBKYQWWkpKirKysYt+BPT09XZcvXy72TQQzMzOVnp6uCxcuFKv/vw0ZMiTfKVtm6Ny5c6H3CKtfv36+88erVq0qSYWub6dOnZy6MFiS/Pz8NGDAAH300Ud5TqfZu3evYmJiNHr0aB0+fFhr167Nczh+x44dOn78uCk3mK1du7auvfbaAtuEhYUpJiZGhmE4fb+1559/3vbv5ORku9ttbgg+duyY2rRpU4SqVeB1JJUrV9a8efM0ZcqUPM8fP37cqYFgwsPDi7S+1atXL3Q7sVgsmjt3rt2+p0+fLrBv5cqV9cwzz+R7/vjx46pXr16hg+uEh4crLS1NZ86csfth17lz5wL7169fX9Lfp7A4e5qHK97/wupyc3NTvXr1ijRoT+5Nf3PXyVXM2F84cqX7zubNmxe6zYSFhRW4zZSW48ePKyAgQNWqVSuwXW4YdbTNFmWbv+6664pZbclwd3fXNddc49QphUXZbvz8/DRp0qRC240bN07Tp0/Xrl27FBoaWmDbCxcu6PLly0pLS3O6jqI6fvy4rr/++kLbhYeHO3WtVHEUdp1+cfZdrpB7muqFCxcKPEXS3mUPufvOiIiIApdRs2ZN+fv757vBevXq1ZWamqrs7OwCLz+ZOnVqgfMvKwhcFdjEiRM1dOjQIl1H80/9+/fXqVOnnL62699atGihM2fO2M6FvlL2ricygzM3nvT39883UELlypXVoUMHLV68WA0aNFBwcHCeX8QrVaqk2rVrF/nGlsOHD9ftt9+u48eP2z7UP/30UzVs2FDXXnutBg0apPHjx+vs2bO29+q9995TgwYNrviLmj2OfuX+J39/f6Wnpzt9nZ7093n0CxYs0KuvvqozZ84U2LY4PwK89tprCg4OzvNc7odYw4YN7V47kJycrLp16xY676Kub/fu3bVw4UK98MILGjhwYL7RrQICAhyOGNq9e3dNnjxZq1atUqdOnfL9cli9evU814T9e32c+XvMbZOcnGz3y3Nh2/A/+zvLFe+/s3+7Rakrt21B19sUh1n7C3uudN/pzI8IhW0zpaU427w9ZmzzpWX//v0Oj1D/27Bhw7R69WqXLj93/+ZMeFi4cKGmTZtW7O8xzijKNmLW+2vGvssV2rRpIx8fH82cOVOPPPKIqlSpkmd/ULlyZdtgUv+WW2tGRkah15gFBATk+yGxS5cuyszM1GOPPaa777473z7Y19e30B9SyhICVwWWO8LNlbjSD86iXMRbmMKGrC8L/u///k+33HKLw19DPT091b9/f7388ssKCQlxap6RkZGqXLmyVq9erenTp0v6O3ANGzZMFotFAwYMkNVq1Zdffqk77rhDWVlZ+uijjzRp0iSnjy6VBfPmzdPixYv1wAMPqG3btna/4Obk5Ojmm28u1vx79+6thg0bXmGVrtGvXz9NnjxZU6dOdfjrXN26dfXUU0/lG1zlP//5j7777juNHj3a4fwbN26sxYsXKzIy0qV1m8ns978sMmN/YU952Hei5DRp0kQbNmxw6ghXs2bNTKnB2fDg5uZmathCwWrVqqVXX31V9957r1auXGm3jb+/vyZMmKAFCxbYPU3emVFKJeX70fOaa67RokWLNGvWLD377LN2+9SoUUMPP/ywZsyYUea/7xC4KggfHx/bvSAKk56enu8X8JLu7+np6ZJfbsuatm3b6uDBgzpw4IDi4+PzXM+Qk5Oj48ePa9GiRZowYYLWrVvn1Dz9/PzUv39/ffTRR5o+fbqOHDmivXv36p133pEk1alTR9ddd53Wrl2rO+64Q99++63OnDmjUaNGmbKOZnnllVc0bdq0Aq8ZzM7OLsGKzGOxWLR06VI98sgjOnToUL7TZVJTU7V+/XrdfffdatGihTp06GCb5uHhodWrVysmJkZHjhzRpUuXbNMMw1BycrJWrVql4cOH66+//sp3DVhZdTW9/7nM2F8AhXF3dy/wutTiKsop5Pau9fP29r6i7yEwxx133KFBgwbpwIED+a5xzMzM1J49e7Ro0SIFBgbafhT+J3tnl/ybxWJR165d8z0/Y8YMjR07VgcPHswX0DMyMrR9+3bNnDlTDRo00LBhw4qxdiWHwFVB1KtXT4mJiU61jY+Pz3c6Qb169bRv3z6n+//74ut69erp888/d7p/WFiYy3+NyP0Vt7B7X5j9pc3Ly0utW7dW69at7U738fHRhAkTdPnyZacHtBg+fLhGjhypmJgYffrppwoPD89zDUtkZKSWLFmiy5cv67333lOnTp3UqFGjItXt6+vrcJhds50/f14XLlxQ+/btC2xX0l+4/f39nbqXysWLF+Xj41PkHxFCQkIcHrm49dZbtXXrVq1duzZP4MoVHh7ucBCEIUOGqHr16vr222/zDFNdlPWR5HAAC1crq++/9P+/Bqmpqbbrruwp7mARxd1f5F5PURJ/s86sm6NtJiAgwKltrqD39kr2TWV1m3dWYdtdce8rZ4ZbbrlFbdq00RNPPFFgu9wfhv59uUJRv8cMGTKk2LX+U1G2kdLcPhwt39n6r2T/WbVqVYdH4m+55RYdPXpUn3/+eZ7AlXuaZpcuXZw+hdWeWrVqOTzbavjw4fr111/1+eefl/nAxSiFFUR4eLh++eWXQv+gUlJStH///nxf1MLDw7V///5CD/FnZ2frl19+sdv/5MmTTp2TvWPHDlNGGswd3ODEiRMFttu2bZvLly1JiYmJWrJkSaFfTkJDQ2W1Wgsd+OCfIiMj5eXlpdWrV+vTTz/V8OHD8wTWQYMGKSUlRV9//bU+++yzYg2WERYWpri4uFIZZSz32pXCvjxs2rSpJMqxCQsLy3chrz0xMTG2m1464/333y/w5sDS369JSEhIvi8g//d//1fo35mvr6+qV6+er29YWJhOnDhR6OscExMjX1/fEruvSVl9/6X/f79S2Hawd+/eIs33SvcXuXU5M9LblTpw4IDDm67mOn78uN1tJiwsTMnJyfluGvtvBe2Xr2TflLv8wgYnyf2bMnsU3KJydrsrC8HL399f33zzTaHtzpw5o7S0tHwDEoWHh+vHH38stH9MTIxOnjzpsveqqPv50mC1WnXixAm7y8/drxckJiZG8fHxdqdVrlzZ4emlv/zyiz7++ONC6wsNDc33eZNba2H7KMMw1KNHD7333nt5nv/666+1efPmYi27LCJwVRATJkzQkSNHtHjxYocfSllZWXrssceUlZWVb0SZO++8U1lZWXr88ccdhjbDMLR48WIdOXJEEydOzDNt0KBBCg4O1rRp0wr8JfKDDz7Q5s2bnRrJqKiqVauma665Ri+99JLDdfjzzz8L/fWtuKKjozVt2jTt2bOn0HaVKlUq0vV1/v7+6t+/v9544w3t2LEj3y85bdq0UZ06dfTggw8qMzNTt956a5Hr79Kli06fPq2PPvqoyH2vVJUqVVSrVq0Ch9w9duxYiY9G1L17d+3Zs6fAL/qnT5/WihUrnD5PXZLefPNNPfnkkwW2ycrK0rFjx/IN2vHcc8/pxRdfLLDv+fPndebMmXx9u3XrpvPnz2v58uUO+6anp+v//u//1KNHjxI7J76svv/S39e71K5dW88//7zDfevZs2eLvE+70v1FzZo11ahRI73yyiuFhqErdf78eU2dOtXhfjUjI0P/93//p549e+bbZjp27CgvL688o1D+25o1a/T+++87nH4l+6YOHTrYhq12JCsrSy+++KKaN29e7EGizLJ48WKHYWrPnj220UgPHz5ckmXZ1b17d/3000/69ddfHbYxDEPPPvusfH191bFjxzzT7rvvPm3ZskUffPCBw/7p6emaNm2agoODFRUV5bK6v/zySx08eNBhm7/++kvr1q0r0n7elVauXKkzZ86oe/fu+ab17NlT//vf/xwONpScnFzgDbnDw8N19uxZnTx5Mt+0b775RhMnTlRWVlaB9UVHR+f7vKlWrZpatGihV155pcAfBLZu3aoffvgh32mHq1ev1tSpUwv8ocUwDLvLLos4pbCCaN26taZNm6aZM2fqk08+UdeuXRUSEiIvLy/bCDHffvut/vrrLz3//POqU6dOnv516tTRwoUL9eCDD2rz5s3q27ev6tatK29vb2VmZio+Pl7btm3Tzp07NX369Hynv/j4+OjFF1/UqFGj1KxZM0VGRio0NFR+fn7Kzs5WQkKCdu3ape+++852Xw5Xs1gsWrJkifr166drr71WkZGRCgoKkmEYOnXqlH777Td99913mj59ut0hs69Uhw4dVK9ePQ0ZMkSDBw9WgwYN8nz5yMnJUVxcnF5//XXdeuutTo/el2v48OH67LPPVL9+/XzDDlssFkVGRuqNN95QVFRUsY5MdO3a1TYi4scff6yWLVuqW7du6tWrV5HnVRzTp0/XzJkzlZSUpDZt2sjX11dZWVk6ffq0/vjjD3311VeaPn26Fi1aVCL1SH+/5i+99JJuuukm3XbbbWratKltlKaMjAydOHFC7733ngzD0OzZs52e76233qqJEydqyJAh6tChQ74RstLS0rRhwwadPn06X7i+9dZb9dxzz+n06dNq3bp1nhEODcPQxYsX9fHHH8vX11f9+/fP07djx44aNWqU7rnnHq1du1atW7dW9erVZbFYdPnyZcXFxWn16tWlErzL4vsv/b1vW7Roke6++24dPHhQffv2Ve3atWUYhk6fPq2DBw/qyy+/zPdaF+ZK9xe5+7uoqCi1bdtW/fv3V0REhO688067I25eiWuuuUbfffedgoODNWjQINWrV0/VqlVTdna24uPjtWbNGiUlJenDDz/M1zckJESPPPKInnzySW3fvl2dOnVSzZo1lZGRocTERG3evFlHjhzRuHHj9PLLL9td/pXsm0JDQ/Xwww9r3rx5+vHHH9W5c2fVqlVLbm5uts+mdevW2d7HkvqRwd3dvdAvsdLfPxJ26tRJffv2VWBgoO1v4pdfftHWrVs1depU7dy5U7NmzdKJEyf0n//8p8ifLa4yZswYvfbaa+rRo4duv/12NWrUyDb4Te5R2m3btmnLli1auHBhvsEwIiMjNWzYMN1+++1688031bZtWwUHB8vd3V2pqamKjY3V2rVrderUKa1atcrhNVxZWVlFOr178uTJev3119W2bVuNGjVKDRo0sNWdmpqqI0eOaNWqVQoNDdXkyZOL+eoU7LPPPssX+AzD0Llz57R371598sknGjlyZL6QKklPPPGE3n//fTVt2lQjR45UaGioPD09dfbsWUVHR2vt2rWKiopyOAR///79Vbt2bfXt21e33Xabunbtqt69e0uSbr75Zj311FPq3r27brjhhnw//Fy+fNlW36uvvppnmsVi0fPPP69+/fqpTZs2GjBggAIDA+Xu7i7DMJSamqqDBw9qzZo16tGjR75ruIYPH663335bN9xwg3r06JFvELaMjAzt2LFDu3bt0tNPP+3cC12aSuLuynCd2bNnG6NHj3Y4fcOGDcaAAQOMxo0bG56enoYko3Llykbz5s2NoUOHGrt27Spw/jt37jSGDBliNG/e3KhcubIhyfD09DQaN25sDBgwwNi4cWOB/Q8dOmSMGjXKaNWqleHn52dIMipVqmSEh4cbffv2NT788EPDarUWaZ0vXLhg1K5d2/j222+dav/7778bgwcPNho0aGC4u7sb7u7uRp06dYzhw4cb27ZtM86fP2/Url3b2LdvX76+d955p907sf/bE088Yfcu93/++acxcOBAo0aNGoakPA83NzcjNDTUmDhxonHu3Dmn1uWfUlJSjLp16xqLFi2yO33r1q1GQECA8fXXXzucx4YNG4zw8HAjJyfH7vSsrCxj6dKlRvv27Y2aNWsaffv2zTP9zTffNLp3715ord98802By7EnOzvbWLZsmdGyZUvD19fX9poFBgYagwYNMr788ksjJyfHCAsLMzZs2OD0fP/8808jMDDQOHv2rNN9/ikjI8OYP3++0a5dO6NatWq299Pb29to3ry5MW7cOOPkyZN2+zp6va1Wq/Hss88ajRo1Mjw8PPJtK/7+/kb79u2N9evX55tnZmamMXPmTKN+/fpGpUqV8vWtVq2a0bNnT2PHjh12a8rOzjZeeeUVo2PHjkatWrVs/XL/zkeMGGFER0fb7bt//36jdu3ahb6WBf2NNWjQwPjqq6/s1nUl73/Pnj2N119/vcC6DMP5v/F/27Jli3HDDTcY9erVMywWi2GxWIzq1asb3bp1M15++WUjKyvLiIiIsLtu119/vd3aXLG/+Pnnn40BAwYYYWFhhr+/v3Ho0CHbtKLsOx29L7n7uosXLxpz58412rRpYwQEBOTZZm6//XbjyJEjDudttVqNNWvWGD169DCCg4Ntn0sNGjQw7rvvPuP48eOF7jMK2ze99dZbDvdNVqvV+Oijj4zu3bsbderUsb3GlSpVMiIiIoxBgwY5/GwsaFv+N0fvvz3ffvut4enp6fDz8J133jEkGQkJCca9995rtGrVyqhUqZLh4eFhhISEGMOGDbP9HRw6dMi47rrrjKpVqzrcF5WU5ORkY9asWUbLli0Nf3//PNt0cHCw0bNnT+OLL75w2N9qtRrvv/++0bdvXyM8PNy2j/Pz8zNatWpljB492uH+KdfKlSuNunXrFqnuCxcuGNOmTTOuvfbaPHX7+/sb1157rTFt2jTjwoULdvvu3bvXqF27tnH+/PkiLdMwDCMmJibf3/4/H7Vq1TI6duxovPLKK0Z2drbD+SQlJRkTJkwwWrRoYXh7exsWi8WoUaOG0bt3b+N///ufYbVaC9xH7tmzx+jXr59Rq1atfH9b69atM9q3b2/7TvfPR+4+YPHixQ7r+/33342oqCgjIiIiz2dWtWrVjFatWhnz5883kpOT7fZdvny5cc0119i+j/7z4e3tbbRs2dJYsWKFk6926bIYRhm7LTwAAEAFduDAATVv3lwnTpywe+Rh+fLlGjt2rLKyskrtiFV59dRTT+nLL7/UTz/9VNqlFOrYsWMKDw/Xt99+q759+5Z2OTAR13ABAACUoIYNG6pevXr5TsPKZbFYbA84LysrS++8847tlDigrOBnEwAAgBLk4eGhRx55RPfff7/S09M1ePBgtWjRwjb8db9+/bRixYoKeb9KVzP+38AJBw8e1NNPP63ExEQ98MADpV0WkAeBCwAAoITde++9MgxDDz/8sF544QX5+voqOTnZNiplcW7vcTXasGGD+vXrJ0lq2rSptm/frqCgoFKuCsiLa7gAAABKSVZWlo4cOaLU1NR8I9CicJcuXdLOnTvVoEED1alTp1ydhnnhwgU1btxYGzduVKtWrUq7HJiIwAUAAAAAJmHQDAAAAAAwCddwOclqtSohIUH+/v7l6nA1AAAAANcyDEMXL15UcHCw3NwKPoZF4HJSQkKCw7t0AwAAALj6xMbGqm7dugW2IXA5yd/fX9LfL2pAQEApVwMAAACgtKSkpCg0NNSWEQpC4HJS7mmEAQEBBC4AAAAATl1qxKAZAAAAAGASAhcAAAAAmITABQAAAAAmIXABAAAAgEkIXAAAAABgEgIXAAAAAJiEwAUAAAAAJiFwAQAAAIBJCFwAAAAAYBICFwAAAACYhMAFAAAAACYhcAEAAACASQhcAAAAAGASAhcAAAAAmITABQAAAAAmIXABAAAAgEkIXAAAAABgEgIXAAAAAJiEwAUAAAAAJnEv7QIAAKXLMn95sfsas+5yWR0AAFREHOECAAAAAJMQuAAAAADAJAQuAAAAADAJgQsAAAAATELgAgAAAACTELgAAAAAwCQELgAAAAAwCYELAAAAAExSbgLXpk2b1K1bN4WEhCgoKMj2CA0NVVRUlP7888887aOjozVy5Eg1atTI1jY4OFht27bVM888o8zMzFJaEwAAAABXi3IRuKKjo3XPPfdo8eLFiouLU2Jiou1x7NgxjR49WjfffLMtRMXFxalPnz6KjIzUnj17bG3j4+P1+eef68iRIxo1alQprxUAAACAiq5cBK7Vq1dr/Pjx6tixoywWS55plSpV0q233qrQ0FDt379fkrRo0SI9/PDDGjlypHx8fGxtLRaLQkND9eqrr+rw4cP6/fffS3Q9AAAAAFxdykXgOnbsmBo0aFBgm5tvvllubn+vzr59+9SrVy+Hbd3c3NS7d2/t27fPpXUCAAAAwD+5l3YBzrh8+bK8vLwKbDN58mTbv+Pi4lSnTp0C2wcHB+vEiRMuqQ8AAAAA7CkXgUuSLly4oMmTJ2vbtm06efKk7fkaNWqoa9euevLJJxUcHCxJysnJUaVKlQqcn7u7u7Kzsx1Oz8zMzDOwRkpKyhWuAQAAAICrTbk4pVD6+7qsG2+8Udu3b7cNgnHy5Elt375dLVq0UL9+/QoMUEW1cOFCValSxfYIDQ112bwBAAAAXB3KTeAaMWKEBg0alG8QjKpVq2rKlCmqW7euvv/+e7t9V65cqTZt2hRpeY8++qiSk5Ntj9jY2CuqHwAAAMDVp9wErqZNmxY4/ZprrtGRI0fsThs9enSRRyT08vJSQEBAngcAAAAAFEW5CVze3t4FTvfx8VFaWpqkwq/PkqTs7Gy5u5ebS9gAAAAAlEPlInD5+vrq0qVLBbbJyMiwnW5Yt25dJSYmFtg+ISFB9erVc1mNAAAAAPBv5SJwRUREKDo6usA2Bw4cUEREhCSpZcuW2rRpk8O2VqtVmzdvVsuWLV1aJwAAAAD8U7k4p27kyJHq2rWrunfvrh49ethucCxJWVlZWrlypaKjo9W9e3dJ0syZM9W5c2fVrFlTQ4YMsR35MgxDCQkJmjt3riIiIoo8kAYAAAAAFEW5OMJVp04drV69WgsXLlT9+vUVFBRkezRs2FDffPON1q9fb7s5ckhIiL777jutW7dO1157ra1tcHCwBg4cqIiICK1ataqU1woAAABARVcujnBJUrt27fTNN9843b5hw4Z6//33TawIAAAAAApWLo5wAQAAAEB5ROACAAAAAJMQuAAAAADAJAQuAAAAADAJgQsAAAAATELgAgAAAACTELgAAAAAwCQELgAAAAAwCYELAAAAAExC4AIAAAAAkxC4AAAAAMAkBC4AAAAAMAmBCwAAAABMQuACAAAAAJMQuAAAAADAJAQuAAAAADAJgQsAAAAATELgAgAAAACTELgAAAAAwCQELgAAAAAwCYELAAAAAExC4AIAAAAAkxC4AAAAAMAkBC4AAAAAMAmBCwAAAABMQuACAAAAAJMQuAAAAADAJAQuAAAAADCJe2kXAAAovyzzl19Rf2PWXS6pozy50tfsSlyNrzcAlDaOcAEAAACASQhcAAAAAGASAhcAAAAAmITABQAAAAAmIXABAAAAgEkIXAAAAABgEoaFBwBcdRjOHgBQUjjCBQAAAAAmIXABAAAAgEkIXAAAAABgEgIXAAAAAJiEwAUAAAAAJiFwAQAAAIBJGBYeAAAU6kqG0mcYfQBXM45wAQAAAIBJCFwAAAAAYBICFwAAAACYhMAFAAAAACYhcAEAAACASQhcAAAAAGASAhcAAAAAmITABQAAAAAmIXABAAAAgEkIXAAAAABgEgIXAAAAAJiEwAUAAAAAJiFwAQAAAIBJCFwAAAAAYBICFwAAAACYhMAFAAAAACYpF4Hru+++k4+Pj4KCghw+QkNDlZCQYOuza9cuRUVFKSIiwtYmJCREHTp00JtvvqmcnJxSXCMAAAAAVwP30i7AGSkpKbr11lu1fPlyp9rv2rVLw4cP17Jly9SnTx95eXlJkqxWq6Kjo/XII4/o4MGDeu6550ysGgAAAMDVrlwc4SqqOXPm6MUXX9SAAQNsYUuS3Nzc1KRJE61atUqrV69WUlJSKVYJAAAAoKKrkIFr37596tWrl8Ppvr6+ateunf76668SrAoAAADA1aZcnFJYVMnJyfLz8yuwTXBwsE6cOOFwemZmpjIzM23/T0lJcVl9AAAAAK4O5SZwHT16VOPGjdOPP/6oc+fOyTAMSVLt2rV1ww036PHHH1f16tWdnp+7u7uys7MdTl+4cKHmzp17xXUDAByzzF9e7L7GrLtcVgcAAGYpF6cUhoWFKTk5WZ07d9amTZsUHx+vxMREnTx5Ut999528vb11++2320KYKzz66KNKTk62PWJjY102bwAAAABXh3JxhKt169bas2dPvuctFotq1qypefPmqVWrVjp69KgaNGiQr92iRYv0448/6osvvnB6mV5eXnkG3AAAAACAoioXgaswFotFzZo105EjR+wGrpkzZ5ZCVQAAAACuduXilEJn+Pj4KD093en22dnZcnevEHkTAAAAQBlVLgLXW2+9pX379hXYJiMjQ97e3pKkqlWrKjU1tcD2CQkJqlevnstqBAAAAIB/KxeB69ixY9qyZYvD6YZh6NChQ4qIiJAktWzZUps2bXLYPi0tTbt27VKTJk1cXSoAAAAA2JSLwBUVFaWlS5dq9+7d+UYizMjI0DPPPKOqVauqYcOGkqSnnnpKDz74oNavX5/nXlpWq1WHDx/W6NGjNWzYMAUGBpboegAAAAC4upSLi5jat2+v5557ThMnTtSJEydktVpt03x8fHTjjTfqww8/lMVikSS1adNGn3zyiebMmaPJkyfbru1yc3NTSEiIxo0bp3vuuadU1gUAAADA1aNcBC5JGjx4sAYPHux0+zZt2hRpGHgAAAAAcLVycUohAAAAAJRHBC4AAAAAMAmBCwAAAABMQuACAAAAAJMQuAAAAADAJAQuAAAAADAJgQsAAAAATELgAgAAAACTELgAAAAAwCQELgAAAAAwCYELAAAAAExC4AIAAAAAkxC4AAAAAMAkBC4AAAAAMAmBCwAAAABMQuACAAAAAJMQuAAAAADAJAQuAAAAADAJgQsAAAAATELgAgAAAACTuJd2AQAAlDeW+ctLuwQAQDnBES4AAAAAMAmBCwAAAABMQuACAAAAAJMQuAAAAADAJAQuAAAAADAJgQsAAAAATMKw8ABQATBMOQAAZRNHuAAAAADAJAQuAAAAADAJgQsAAAAATELgAgAAAACTELgAAAAAwCQELgAAAAAwCYELAAAAAExC4AIAAAAAkxC4AAAAAMAkBC4AAAAAMAmBCwAAAABMQuACAAAAAJMQuAAAAADAJAQuAAAAADCJe2kXAAAASoZl/vLSLgEArjoc4QIAAAAAkxC4AAAAAMAkBC4AAAAAMAmBCwAAAABMQuACAAAAAJMQuAAAAADAJAQuAAAAADAJgQsAAAAATOLSGx9/88032rBhg44dO6bTp0/L29tbr7/+uurXr6/7779fgYGBGjt2rOrWrevKxQIAAABAmeSSI1w5OTmKjIzUgAEDtGHDBmVnZysoKEgbN27U/v37JUkBAQF66aWX1KlTJ8XExLhisQAAAABQprkkcL300kv6+uuv9eWXX2rfvn36/PPPtWTJEhmGYWvz9NNPa//+/bJYLFqyZIkrFgsAAAAAZZpLAtdHH32k2267TTfddJPtOYvFkq9drVq1dMstt2jDhg2uWCwAAAAAlGkuCVzR0dFq1qyZU23r1q2rkydPumKxAAAAAFCmuSRwnT17VlWrVnWqrbe3t9LS0lyxWAAAAAAo01w2LLy9UwgBAAAA4GrmksDl7e2t9PR0p9peunRJ3t7erlispL9HSBw6dKhWr16d5/lNmzapb9++CgsLU1BQkIKCghQaGqru3bvrk08+yTOgBwAAAACYwSX34WrYsKGOHTvmVNu4uDhFRES4YrGSpNmzZ2v9+vWKioqyPffZZ59p9uzZeuWVV9SxY0d5eHhIkrKzs7V3715NmTJFCQkJuv/++11WBwAAAAD8m0uOcHXp0kXvvfeekpKSCmyXkpKi999/X926dXPFYvX555/ryy+/1F133ZXn+VmzZmnlypXq1q2bLWxJkru7u9q2basPPvhACxcuVE5OjkvqAAAAAAB7XHKEa968eVqzZo2aNm2qUaNGKSIiQlarVRaLRd98842OHTum2NhYvfvuu7JarZo7d+4VLzM6OlpTpkzRpk2b9NJLL9mez8rK0pkzZ9SqVSuHfUNCQhQYGKj4+HjVq1fvimsBAAAAAHtcErhq1qypgwcP6qmnntLWrVu1cuVKpaSkSPr7psh+fn4KDw/XkCFDNHv2bNWqVeuKlpeWlqZbbrlFS5cuVYMGDfJMS0xMdGr+wcHBOnHiBIELAAAAgGlcErgkqUaNGnrxxRddNTuHDMPQ+PHjNXDgwDzXbeXKyclRpUqVCp2Pu7u7srOzHU7PzMxUZmam7f+5ARIAAAAAnOWywFVSli1bppMnT2rFihWmLmfhwoUuOfURAJxhmb+8tEsATHOl27cx6y6X1AEApcFl9+EqCdu3b9fixYv1/vvvy93d+aw4adIkTZo0qUjLevTRR5WcnGx7xMbGFrVcAAAAAFc5lx7h+v333xUcHKzAwMB8006dOqX4+Hi1adOmWPNOTEzUyJEj9d5779mdf0FefvnlIi/Py8tLXl5eRe4HAAAAALlccoTr7Nmz6tSpk6677jq9++67dtusWrVK7dq1U6dOnXTu3LkizT87O1sjRozQ1KlT1bVr1wLbFnZt1j/nWZSjZAAAAABQVC5JHAsWLFB0dLS2bNmi7t27220zdepUtWvXTkOGDNH8+fO1ZMkSp+e/fft27dq1SwcPHtSiRYvyTU9OTpanp6fWrFmjzz77TGfOnCl0ngkJCYxQCAAAAMBULjnCtXbtWvXv399h2MrVo0cP9e/fX1988UWR5t+zZ0+lpqYqKSlJiYmJ+R4jRozQihUrtG7dOrm7u6tWrVravXu3w/klJCQoKSlJISEhRaoDAAAAAIrCJYErISFBzZo1c6pt06ZNdfLkSVcs1qEFCxbojjvu0LZt25SVlWV7PicnR7t379aIESM0c+ZMp4aPBwAAAIDicskphRkZGapWrZpTbatVq6ZLly65YrE2VapUkZ+fn+3/UVFR8vPz05NPPqno6Gjb/bQ8PDxUv359TZ06VUOHDnVpDQCAksVQ+gCA8qBCjBph74bLvXv3Vu/evUuhGgAAAAD4m0tOKQwICNDFixedapuamip/f39XLBYAAAAAyjSXBK4GDRro6NGjTrU9evSoGjRo4IrFAgAAAECZ5pLAdcMNN+i9997TkSNHCmwXHR2tVatW6aabbnLFYgEAAACgTHPJNVyzZs3Sp59+qhYtWigyMlL16tXLM4hFamqqjh8/rvXr1ys8PFyzZs1yxWIBAAAAoExzSeDy8/PTvn37tGzZMn3//ffatGmTUlJSbNMDAgIUHh6uRYsW6b777pOnp6crFgsAAAAAZZrLRin09PTUQw89pIceeshVswQAAACAcs0l13ABAAAAAPIjcAEAAACASQhcAAAAAGASl13DJUmffPKJtmzZopiYGCUnJztsFxYWpv/973+uXDQAAAAAlDkuCVxZWVm68cYbtXXrVrVr107169cv8ObG9erVc8ViAQAAAKBMc0ngWrx4sX788Udt2bJFPXr0cMUsAQAAAKDcc8k1XJ9++qlGjBhB2AIAAACAf3BJ4Dpy5IiaNm3qilkBAAAAQIXhksB17tw5ValSxRWzAgAAAIAKwyWBq0qVKjp//rwrZgUAAAAAFYZLAleDBg0UGxvrilkBAAAAQIXhksA1dOhQrVu3Tlar1RWzAwAAAIAKwSWBa+rUqapevbpmzpzpitkBAAAAQIXgkvtwLVy4UPXr19fixYu1Zs0ade7cWZUqVXLYPiwsTE899ZQrFg0AAAAAZZZLAteJEyeUlpZmuw9XQkJCge0LCmMAAAD/ZJm/vNh9jVl3lbvlAqhYXBK4li9f7orZAAAAAECF4pJruAAAAAAA+RG4AAAAAMAkBC4AAAAAMIlLruHK9eeff2rTpk06duyYTp8+rcqVK2v+/PmqXbu2nn32WQUFBenmm2+Wv7+/KxcLAAAAAGWSy45w3X///br22ms1e/Zsbdy4UdHR0Xrrrbf066+/SpJ2796tu+++W126dNGpU6dctVgAAAAAKLNcErhWrlypV155RcuWLdPp06e1Z88erV69WoZh2NqsWrVKBw4c0MmTJ/XCCy+4YrEAAAAAUKa5JHC9/vrrioqK0oQJE+Tu/vdZihaLJV+7hg0bavjw4fr8889dsVgAAAAAKNNcEriio6PVpk0bp9qGh4cXemNkAAAAAKgIXBK4kpKSVLNmTafa+vj4KCUlxRWLBQAAAIAyzWWDZtg7hfBK2gEAAABAeeeSwOXp6alLly451fby5cvy9PR0xWIBAAAAoExzSeCKiIhQbGysU21Pnjyp8PBwVywWAAAAAMo0lwSutm3bavXq1UpLSyuwXVZWlj7++GO1a9fOFYsFAAAAgDLN3RUzWbBggZo3b65rr71W9957r8LDw5WVlSWLxaI9e/ZIkmJjY/X6668rMTFR8+bNc8ViAQAAAKBMc0ngql+/vn799VfNnDlT8+bNyzMK4eOPPy5J8vf3V48ePfTuu+8qLCzMFYsFAAAAgDLNJYFLkpo1a2a7ofGFCxeUnJxsm+bv76/q1au7alEAAAAAUC64LHD9U9WqVVW1alUzZg0AAAAA5YZLBs3Ys2ePMjIyXDErAAAAAKgwXBK4unfvruXLl7tiVgAAAABQYbgkcNWoUUMHDx50xawAAAAAoMJwSeDq0qWLbfh3AAAAAMDfXBK4Jk+erG3btmn79u2umB0AAAAAVAguCVydOnXSCy+8oNGjR2vr1q2umCUAAAAAlHsuGRb+lVde0YkTJxQWFqbevXurcePGatGihQICAuy2Dw8P1xNPPOGKRQMAAABAmeWSwPXxxx/r6NGjkqR69erp0qVL2rVrl8P2sbGxrlgsAAAAAJRpLglcmzZtcsVsAAAAAKBCcck1XAAAAACA/FwSuM6cOSPDMFwxKwAAAACoMFxySmGjRo20ZMkSjR071hWzA4ByyTJ/eWmXAAAAyhiXHOHy8/PTH3/84YpZAQAAAECF4ZLA1a5dOx04cMAVswIAAACACsMlgevee+/VN998o/3797tidgAAAABQIbgkcN10002aPn26Ro4cqUOHDrlilgAAAABQ7rlk0Iy1a9eqfv36ql27ttq0aaOePXuqefPmCggIsNu+fv36GjNmjCsWDQAAAABllksC17Rp03T48GHb/7/++mt9/fXXDts3bNiQwAUAAACgwnNJ4OI0QgAAAADIzyXXcAEAAAAA8is3gWvjxo3q1q2bgoODFRgYqKCgINWpU0dNmzbVokWLlJWVlaf9rl27FBUVpYiICAUFBSkoKEghISHq0KGD3nzzTeXk5JTSmgAAAAC4WpSLwHXs2DGNHTtWixcvVnx8vJKSkpSYmKiTJ0/qhx9+0M6dO7VkyRJb+127dmn48OGaOHGiDhw4oMTERCUmJio2Nlbvvvuu1q1bp0ceeaQU1wgAAADA1cBlgctqtTr9KKoffvhBgwcPVseOHWWxWPJMq1Wrlv773//qo48+sj03Z84cvfjiixowYIC8vLxsz7u5ualJkyZatWqVVq9eraSkpOKvMAAAAAAUwiWDZjRo0EDHjh1zun14eHieUQ0L07FjR7Vp08bh9JCQkDzhad++ferVq5fD9r6+vmrXrp3++usvBQYGOl0HAAAAABSFSwLXa6+9pvj4eIfTs7Oz9cMPP+iDDz7Q+PHjNWjQoCLNv3HjxgVOj4uLU9u2bW3/T05Olp+fX4F9goODdeLECYfTMzMzlZmZaft/SkqKk9UCAAAAwN9cErj69u1baJt77rlHkZGRuueeezRjxgxXLFaGYSgxMVEzZszQnXfeWaS+7u7uys7Odjh94cKFmjt37pWWCAAAAOAqVqKDZgwbNkwRERH673//W+x5xMbGKjQ0VEFBQapWrZqCg4NVrVo1DR061IWVSo8++qiSk5Ntj9jYWJfOHwAAAEDFV+KjFPbq1Utff/11sfuHhoYqNjZWiYmJOn/+vE6ePCk/Pz9NnTrVYZ9FixYpKiqqSMvx8vJSQEBAngcAAAAAFIVLTiksiqCgoAKv9yoKi8WioKAgLVmyRM2bN1diYqKCgoLytZs5c6ZLlgcAAAAARVHiR7i8vb116dIll86zUqVKatasmf7880+n+2RnZ8vdvcTzJgAAAICrSIkHrjNnzig4OLhIfa6//npdvHixwDZubm5yc/t7dapWrarU1NQC2yckJKhevXpFqgMAAAAAiqLEA9dPP/2khg0bFqlPpUqVdPDgQYfTDcPQgQMHFBERIUlq2bKlNm3a5LB9Wlqadu3apSZNmhSpDgAAAAAoihILXKmpqZo3b542btyoBx54oEh9R44cqRkzZti9b1ZaWppmz56tJk2a2I5YPfXUU3rwwQe1fv36PPfSslqtOnz4sEaPHq1hw4Zx02MAAAAApnLJRUw9e/ZUTEyMw+mpqalKTk6Wp6ennnjiCQ0ZMqRI87/77rt16dIlDRw4UGfOnJFhGLZp/v7+GjBggJYvX257rk2bNvrkk080Z84cTZ48Wenp6ZL+Pu0wJCRE48aN0z333FO0lQQAAACAInJJ4LrrrrvsHn3KFRAQoLCwMHXs2LHI129Jf49GOGnSJE2aNMnpPm3atNEXX3xR5GUBAAAAgKu4JHCNHTvWFbMBAAAAgAqlxAfNAAAAAICrBYELAAAAAEzissC1e/duTZkyRV999ZXd6d98842mTJmi33//3VWLBAAAAIAyzSWBa9u2bercubM2bNggLy8vu208PT31zTffqEuXLtq+fbsrFgsAAAAAZZpLBs1YtGiRmjRpol9//VXu7vZn2atXL+3bt0/t27fXwoULtW7dOlcsGgAAoMKxzF9e7L7GrLtcVgeAK+eSI1y//fabunbt6jBs5fLw8FDXrl3122+/uWKxAAAAAFCmuSRwnTp1So0aNXKqbcOGDXX69GlXLBYAAAAAyjSXBC6r1SpPT0+n2np6espqtbpisQAAAABQprlslEJnQxRhCwAAAMDVwiWBKyQkxOnTBM+cOaPg4GBXLBYAAAAAyjSXBK6GDRvq559/dqrtjh07nL7eCwAAAADKM5cErgceeEAbNmzQ/PnzlZqaardNSkqK5s6dq02bNmnKlCmuWCwAAAAAlGkuuQ/XkCFDNHv2bC1YsEBz5sxRlSpV5OfnZ5uempqq5ORkeXl56cknn9TgwYNdsVgAAAAAKNNcErgk6cknn9T48eP1yy+/KCYmRikpKbZpAQEBCg8PV4cOHbh+CwAAAMBVw2WBS5KCg4N18803u3KWAAAAAFBuuWxYeAAAAABAXgQuAAAAADCJywLXl19+qcGDB+u9996zO/2DDz7Q4MGDtX79elctEgAAAADKNJcErrVr12rQoEFKS0tT8+bN7bZp2rSpUlNTFRUVpXXr1rlisQAAAABQprkkcD3//PPq1KmTNm7cqNatW9tt07p1a23atEmdOnXSkiVLXLFYAAAAACjTXBK49u/fr/bt2zvVtn379tq/f78rFgsAAAAAZZpLAtfp06cVERHhVNvw8HCdOXPGFYsFAAAAgDLNZYNmuLs7d0svZ9sBAAAAQHnnksDl5uamnJwcp9rm5OTIYrG4YrEAAAAAUKa5JHCFhoYqMTHRqbanTp1SaGioKxYLAAAAAGWaSwJXkyZNtHnzZqfabty4UU2bNnXFYgEAAACgTHPJBVWPPvqoevXqpXHjxmnKlCmqV6+e/Pz8bNNTU1N1/PhxPf/889q5c6e2bt3qisUCAAAUyDJ/eWmXAOAq55LA1bNnT7311lt69NFH9fbbb9ttYxiGAgMD9c4776hbt26uWCwAAAAAlGkuGzJw7Nixuu222/TXX38pJiZGKSkptmkBAQEKDw9XkyZN5O3t7apFAgAAAECZ5tIx2r29vdW6dWu1bt3albMFAAAAgHLJZffhAgAAAADkdUVHuJKSkhQTE6Njx44pPT3dbhsfHx+FhYUpPDxcgYGBV7I4AAAAAChXihW4jh49qpkzZ+rjjz+WYRhO9bFYLBo6dKgWLlyohg0bFmexAAAAAFCuFPmUwtTUVPXo0UO7du3S22+/rUOHDiktLU1Wq9XuIy0tTYcOHdLbb7+t3377Tddff70uXrxoxroAAAAAQJlS5CNcTz/9tC5cuKCDBw+qbt26hbb39vZWw4YN1bBhQ/Xu3VvNmjXTggULtGjRomIVDAAAAADlRZGPcH3//fcaNmyYU2Hr30JDQzV8+HB9//33Re4LAAAAAOVNkQPX4cOHFR4eXuwFhoeH68iRI8XuDwAAAADlRZED16lTp1SzZs1iL7B69eo6c+ZMsfsDAAAAQHlRrPtwWSyWYi/wSvoCAAAAQHnCjY8BAAAAwCRFDlyenp7KzMws9gIzMzPl6elZ7P4AAAAAUF4UOXCFh4crNja22AuMj49XWFhYsfsDAAAAQHlR5MDVsGFDbd++vdgL/OGHH9SwYcNi9wcAAACA8qLIgWvq1KnauXOnnnnmGVmtVqf7Wa1WLVy4ULt27dKDDz5Y1MUCAAAAQLnjXtQOvXv31sMPP6zHHntMb775pjp27Kg6derI29vbbvuMjAwlJCTol19+0dGjR/XQQw+pT58+V1w4AAAAAJR1RQ5ckvTMM89o1KhRev3113X06FH9/vvvSk9Pt9vWx8dH9erVU9++fTVhwgS1bt36SuoFAAAAgHKjWIFLklq1aqVly5a5shYAAAAAqFC4DxcAAAAAmITABQAAAAAmIXABAAAAgEkIXAAAAABgEgIXAAAAAJiEwAUAAAAAJiFwAQAAAIBJCFwAAAAAYBICFwAAAACYhMAFAAAAACYpN4Fr5cqVat26terUqaOgoCAFBQWpTp06at68uZYsWaLs7Ow87Tdt2qS+ffsqLCzM1j40NFTdu3fXJ598IsMwSmlNAAAAAFwt3Eu7AGds2bJFixYt0ieffKLGjRvnmZaUlKRx48bJw8NDkydPliR99tlnmj17tl555RV17NhRHh4ekqTs7Gzt3btXU6ZMUUJCgu6///4SXxcAAAAAV49ycYTrq6++0uTJk/OFLUkKDAzUs88+q5UrV9qemzVrllauXKlu3brZwpYkubu7q23btvrggw+0cOFC5eTklEj9AAAAAK5O5SJwde7cWTfccIPD6aGhoYqNjZUkZWVl6cyZM2rVqpXD9iEhIQoMDFR8fLzLawUAAACAXOXilMKbb765wOl//PGHGjZsKElKTExUrVq1Cp1ncHCwTpw4oXr16rmiRAAAAADIp1wEroLEx8drwoQJevzxxyVJOTk5qlSpUqH93N3d8w208U+ZmZnKzMy0/T8lJeXKiwUAAABwVSm3gcswDK1YsUIPP/ywZs2apWHDhrl0/gsXLtTcuXNdOk8A5rPMX17aJQAAANiUy8B16NAhTZo0Sampqfrmm2/Utm3bAttPmjRJkvTyyy87vYxHH31UDz30kO3/KSkpCg0NLV7BAAAAAK5K5Spw5eTkaMGCBXrzzTf11FNP6c4775SbW+HjfhQlaOXy8vKSl5dXccoEAAAAAEnlKHClpqZq5MiRcnd31969e1W1alW77Qq7NitXdna23N3LzeoDAAAAKIfKxbDwkjR9+nTVrVtXH3/8scOwJUlBQUE6c+ZMofNLSEhghEIAAAAApioXh3iio6P19ddf68CBA7JYLAW2dXd3V61atbR79261bt3abpuEhAQlJSUpJCTEhGoBAAAA4G/l4gjX77//rl69esnb29up9gsWLNAdd9yhbdu2KSsry/Z8Tk6Odu/erREjRmjmzJlODR8PAAAAAMVVLo5wnT17VqtXr9ZXX33lsI2Hh4d+/vlnBQcHKyoqSn5+fnryyScVHR1tu5+Wh4eH6tevr6lTp2ro0KElVT4AALjKcIsKALkshmEYpV1EeZCSkqIqVaooOTlZAQEBpV0OAAf4kgPgamfMuqu0SwAqvKJkg3JxSiEAAAAAlEcELgAAAAAwCYELAAAAAExC4AIAAAAAkxC4AAAAAMAkBC4AAAAAMAmBCwAAAABMQuACAAAAAJMQuAAAAADAJAQuAAAAADAJgQsAAAAATELgAgAAAACTELgAAAAAwCQELgAAAAAwCYELAAAAAExC4AIAAAAAkxC4AAAAAMAkBC4AAAAAMAmBCwAAAABMQuACAAAAAJO4l3YBAComy/zlpV0CAABAqeMIFwAAAACYhMAFAAAAACYhcAEAAACASQhcAAAAAGASAhcAAAAAmITABQAAAAAmIXABAAAAgEm4DxcAAABc4kruwWjMustldQBlCUe4AAAAAMAkBC4AAAAAMAmBCwAAAABMQuACAAAAAJMQuAAAAADAJAQuAAAAADAJgQsAAAAATELgAgAAAACTELgAAAAAwCQELgAAAAAwCYELAAAAAExC4AIAAAAAkxC4AAAAAMAkBC4AAAAAMAmBCwAAAABMQuACAAAAAJMQuAAAAADAJAQuAAAAADAJgQsAAAAATELgAgAAAACTELgAAAAAwCTupV0AAAAAXMcyf3mx+xqz7nJZHQD+xhEuAAAAADAJgQsAAAAATELgAgAAAACTELgAAAAAwCQELgAAAAAwCYELAAAAAExC4AIAAAAAkxC4AAAAAMAk5T5wpaamauDAgXrjjTfyPL9r1y5FRUUpIiJCQUFBCgoKUkhIiDp06KA333xTOTk5pVQxAAAAgKtFuQ5cKSkp6t+/v/bv36+0tDTb87t27dLw4cM1ceJEHThwQImJiUpMTFRsbKzeffddrVu3To888kgpVg4AAADgauBe2gUUV0ZGhm688UYNGDBAVqs1z7Q5c+boxRdf1IABA/I87+bmpiZNmmjVqlVq3ry5Hn74YQUGBpZk2QAAAACuIuX2CJdhGHrooYc0e/bsfNP27dunXr16Oezr6+urdu3a6a+//jKzRAAAAABXuXJ7hMvHx0e33nqr3WnJycny8/MrsH9wcLBOnDjhcHpmZqYyMzNt/09JSSleoQAAAACuWuU2cF0pd3d3ZWdnO5y+cOFCzZ07twQrAgAAQHFY5i+/ov7GrLtcUgdgT7k9pdBsjz76qJKTk22P2NjY0i4JAAAAQDlzVQSuRYsWKSoqqkh9vLy8FBAQkOcBAAAAAEVxVZxSOHPmzNIuAQAAAMBV6Ko4wmVPdna23N2virwJAAAAoJRUyMBVtWpVpaamFtgmISFB9erVK6GKAAAAAFyNKmTgatmypTZt2uRwelpamnbt2qUmTZqUYFUAAAAArjYV8py6p556SkOHDpW7u7v69u0rLy8vSZLVatXRo0f18MMPa9iwYQoMDCzlSgEAAABUZBUicAUEBMjf39/2/zZt2uiTTz7RnDlzNHnyZKWnp0uS3NzcFBISonHjxumee+4prXJRDnF/DwAAzHWln7XlEd8vrg4VInA99NBD+Z5r06aNvvjii1KoBgAAAAD+ViGv4QIAAACAsoDABQAAAAAmIXABAAAAgEkIXAAAAABgEgIXAAAAAJikQoxSCMAcV+MQvQAAAK7EES4AAAAAMAmBCwAAAABMQuACAAAAAJMQuAAAAADAJAQuAAAAADAJgQsAAAAATMKw8EAFxrDuAICi4HMDcD2OcAEAAACASQhcAAAAAGASAhcAAAAAmITABQAAAAAmIXABAAAAgEkIXAAAAABgEgIXAAAAAJiEwAUAAAAAJiFwAQAAAIBJCFwAAAAAYBICFwAAAACYhMAFAAAAACYhcAEAAACASQhcAAAAAGASAhcAAAAAmITABQAAAAAmIXABAAAAgEkIXAAAAABgEgIXAAAAAJiEwAUAAAAAJiFwAQAAAIBJLIZhGKVdRHmQkpKiKlWqKDk5WQEBAaVdDkqYZf7y0i4BAADAZYxZd5V2CeVaUbIBR7gAAAAAwCQELgAAAAAwCYELAAAAAExC4AIAAAAAkxC4AAAAAMAkBC4AAAAAMAmBCwAAAABMQuACAAAAAJMQuAAAAADAJAQuAAAAADAJgQsAAAAATELgAgAAAACTELgAAAAAwCQELgAAAAAwiXtpFwAUhWX+8tIuAQAAAHAaR7gAAAAAwCQELgAAAAAwCYELAAAAAExC4AIAAAAAkxC4AAAAAMAkBC4AAAAAMAnDwpdTVzo8ujHrLpfUUVQM6w4AAFD6yut3stL6DnslOMIFAAAAACap0IHrwoULmjFjhlq2bKk6deooKChIQUFBat68ue69914lJSWVdokAAAAAKrAKG7hycnLUp08f+fr6asuWLUpISFBiYqISExO1Y8cONW3aVF27dlV6enpplwoAAACggqqwgevTTz9VWFiY5syZoxo1ashisdimValSRVOmTNGAAQP02muvlWKVAAAAACqyChu49u3bp169ehXYpm/fvtq3b18JVQQAAADgalNhA1dcXJzq1KlTYJvg4GCdOHGihCoCAAAAcLWpsMPC5+TkqFKlSgW2cXd3V3Z2tt1pmZmZyszMtP0/OTlZkpSSkuK6Iq/EpYwr6l5q63GFdQMAAODqVVa+i+fWYRhGoW0rbOC6UgsXLtTcuXPzPR8aGloK1bhelQX3lXYJAAAAQJGUte+wFy9eVJUqVQpsc9UErr/++kv9+/fX119/rcaNGxfa/tFHH9VDDz1k+7/VatW5c+fyDcAB10lJSVFoaKhiY2MVEBBQ2uWgAmIbg9nYxmA2tjGUBLazwhmGoYsXLyo4OLjQtldN4GrSpImOHj3qdHsvLy95eXnlea5q1aourgr2BAQE8McNU7GNwWxsYzAb2xhKAttZwQo7spWrwg6aUdD1Wbmys7Pl7n7VZE4AAAAAJazCBq66desqMTGxwDYJCQmqV69eCVUEAAAA4GpTYQNXy5YttWnTpgLbbNq0SS1btiyhilAYLy8vzZkzJ9+pnICrsI3BbGxjMBvbGEoC25lrWQxnxjIsh3JyctSpUycNGDBADzzwgKpXr24b7CIlJUUrVqzQiy++qD179sjX17eUqwUAAABQEVXYI1yVKlXSxo0blZGRoZ49eyo4OFhBQUEKCgpShw4d9Mcff2jbtm2ELQAAAACmqbBHuAAAAACgtFXYI1wAAAAAUNoIXAAAAABgEgIXTLdx40Z169ZNwcHBCgwMVFBQkOrUqaOmTZtq0aJFysrKytN+165dioqKUkREhO26u5CQEHXo0EFvvvmmcnJySmlNUN7k5ORo6NChWr16dZ7nN23apL59+yosLMy2jYWGhqp79+765JNPxJnW+LfvvvtOPj4+tu3F3iM0NFQJCQm2PuzLUFSbNm1St27dFBISkm/bioqK0p9//pmnfXR0tEaOHKlGjRrZ2gYHB6tt27Z65plnlJmZWUprgrJqy5YtBe7HfH19tWLFCklSRkaGFi5cqDZt2uQZC6Fx48YaNWqUjhw5UsprU44YgIliYmKMunXrGj/99JNhtVrzTDt16pQxdOhQY9GiRbbnfv31VyM8PNxYv369cenSJdvzOTk5xsGDB43Bgwcb06ZNK7H6Ub499thjhqenp/HOO+/Ynvv000+Nli1bGj/88INx+fJl2/NZWVnGrl27jG7duhkvvfRSKVSLsuzTTz81xowZ43R79mUoqkOHDhn169e3+3mZnZ1tfPjhh0ajRo1s21NsbKwRGhpqrFq1ykhLS7O1tVqtxokTJ4xx48YZt9xyS4muA8q/hx56yHj33XcNwzCMwYMHGxMnTjTi4uLybJOpqanGihUrjNDQUCM+Pr60Si1XCFww1f/+9z9j0qRJDqcfPnzYaNu2re3/AwcONL744guH7VNTU4169eoZiYmJLq0TFc9nn31mtG7d2hg/fnyewNWiRQtjz549DvvFxcUZwcHBRnZ2dglUifKiqIGLfRmKasGCBcaCBQsKbNO7d29j165dhmEYxqRJk4ylS5c6bJuTk2Nce+21xm+//ebSOlGxDRs2zNi8ebOxc+dOo127dkZOTo7DtosXLzYeeOCBEqyu/OKUQpiqY8eOmjhxosPpISEhSkpKsv1/37596tWrl8P2vr6+ateunf766y+X1omKJTo6WlOmTNGaNWvk7e1tez4rK0tnzpxRq1atHPYNCQlRYGCg4uPjS6JUVFDsy1BUx44dU4MGDQpsc/PNN8vN7e+vboVtY25uburdu7f27dvn0jpRcaWlpennn39Wly5dtG/fPl1//fW27c2evn37sn05yb20C0DF1rhx4wKnx8XFqW3btrb/Jycny8/Pr8A+wcHBOnHihEvqQ8WTlpamW265RUuXLs335SUxMVG1atUqdB6521i9evXMKhMVHPsyFNXly5fl5eVVYJvJkyfb/h0XF6c6deoU2J5tDM6yWq26//77NXHiRHl6erJ9uRhHuFAqDMPQyZMnNWPGDN15551F6uvu7q7s7GyTKkN5ZhiGxo8fr4EDByoqKirf9JycHFWqVKnQ+bCNwZ6jR49q3LhxatGiherUqWO7gLxVq1aaNm2azp07V6T5sZ3h3y5cuKDJkyerTZs2eQYyaNGihcaPH59nUBZn9mdsY3BGenq6hg8frsuXL2vGjBmS2L5cjcCFEhMbG6vQ0FAFBQWpWrVqCg4OVrVq1TR06NDSLg0VxLJly3Ty5EnNmzevtEtBBRMWFqbk5GR17txZmzZtUnx8vBITE3Xy5El999138vb21u23384Il7giixYt0o033qjt27crMTHRto1t375dLVq0UL9+/fiCC5c6ffq0+vTpo1atWmnlypVyd+fkNzMQuFBiQkNDFRsbq8TERJ0/f14nT56Un5+fpk6d6rDPokWL7B6pAP5t+/btWrx4sd5///0ifWBMmjRJkyZNMrEyVAStW7fWnj17dPfddysoKMh2XYPFYlHNmjU1b948JSQk6OjRo3b7sy+DM0aMGKFBgwbJx8fH9pzFYlHVqlU1ZcoU1a1bV99//73dvitXrlSbNm1KqlRUAIZh6I477tBdd92lOXPmyGKxOGybnJyshg0basuWLSVXYAVCjEWpsFgsCgoK0pIlS9S8eXMlJiYqKCgoX7uZM2eWQnUobxITEzVy5Ei99957CgwMLFLfl19+2aSqcDWxWCxq1qyZjhw5YnfgA/ZlcEbTpk0LnH7NNdfoyJEj6t27d75po0eP1ujRo80qDRXQhg0blJOTo/HjxxfatkqVKjp8+HAJVFUxcYQLpapSpUpq1qxZvps5FiQ7O5tD3rDJzs7WiBEjNHXqVHXt2rXAts6eb842huLw8fFRenq60+3ZzvBv/xxV1R4fHx+lpaVJcm5/xjaGgnz22WcaO3as3SNbbF+uReCCqa6//npdvHixwDZubm6203OqVq2q1NTUAtsnJCQwehxstm/frl27dmnhwoV5LjLPfbz22muaMmWKIiMjFRQUpDNnzhQ6T7Yx/Ntbb71V6PDHGRkZti/M7MtQVL6+vrp06VKBbTIyMmynG9atW1eJiYkFtmcbQ0F++uknde7c2e40ti/XInDBVJUqVdLBgwcdTjcMQwcOHFBERIQkqWXLltq0aZPD9mlpadq1a5eaNGni8lpRPvXs2VOpqalKSkqyXWT+z8eIESO0YsUKrVu3Tu7u7qpVq5Z2797tcH4JCQlKSkpSSEhIya0Eyrxjx44VeO2CYRg6dOgQ+zIUW0REhKKjowtsU5TPS6vVqs2bN6tly5YurRMVR3x8vMPPupYtW2rz5s2yWq0O+2/atInty0kELphq5MiRmjFjht37NKSlpWn27Nlq0qSJ7ReSp556Sg8++KDWr1+vzMxMW1ur1arDhw9r9OjRGjZsWJGv0wFyLViwQHfccYe2bdumrKws2/M5OTnavXu3RowYoZkzZzo1fDyuHlFRUVq6dKl2796dbyTCjIwMPfPMM6pataoaNmwoiX0Zim7kyJF65513tGXLlnxfcrOysvTOO+8oOjpa3bt3l/T3dYGLFy/WqlWr8pzKahiG4uPjNXHiREVERDCQBhy6fPmyPD097U5r166d6tevr3vvvVfx8fF59nvp6elauXKlnn/+eT3yyCMlVW65ZjEYwxYmMgxDr7zyil599VWdOXMmzx+sv7+/BgwYoLlz56pq1aq253///XfNmTNHf/zxh+1DxM3NTSEhIRo3bpzuuecevgzDaVOmTNGgQYPUt29f23Pfffednn76aUVHR9u+DHt4eKh+/fqaOnWqhg4dWuBoTbg6ff7551q4cKFOnDiR5wuxj4+PbrzxRj311FOqXbu27Xn2ZSiqXbt26bHHHtOff/6Z5wchLy8vde7cWU8//bTtCJckHT58WE888YR+/fVX2+n7FotFgYGBuu222/Tggw+qcuXKJb4eKB9atmxZ4KnSly5d0vPPP68PP/xQSUlJtu9w/v7+at++vebNm2d3kCDkR+ACAAAAAJNwSiEAAAAAmITABQAAAAAmIXABAAAAgEkIXAAAAABgEgIXAAAAAJiEwAUAAAAAJiFwAQAAAIBJCFwAAAAAYBICFwAAAACYhMAFAAAAACYhcAFABbVq1SpZLJYiP55++ukiL+vJJ5+Uu7u7Xn/9dRPWpGLIzMzUokWL1LNnT9WtWzfPa16pUiXVr19fffr00fr162UYRmmXCwBwEffSLgAAYI7evXtr2bJl+b68nz59Wk899ZQeeOABNWrUKF+/G2+8scjL+v7775WTk6OffvpJ48ePL3bNFdX58+fVuXNnHTlyREOHDlX37t1Vu3Ztubn9/btndna2Tp06pa1btyoyMlLPPPOMZsyYUcpVu15qaqpWrFihe++917buAFDRWQx+RgOAq8rhw4fVqFEjbd68Wddff71L5vnGG2/oxRdf1IIFCzR48GCXzLMiefjhh/XGG29ox44datasmcN2hmHokUce0bJlyxQXF6fq1auXYJXm27p1q66//nodPnxYDRo0KO1yAKBE8PMSAOCKjRs3Tn/88Qdhyw7DMPTKK69o6tSpBYYtSbJYLHrkkUeUkZGhAwcOlFCFJSf3N15+6wVwNSFwAQBgoqSkJKWnp6tz585Ota9Ro4bCw8OVlJRkcmUAgJJA4AIAOLRx40bVq1dPWVlZSktL0+LFi9W+fXtVr15dt956q63dgQMHFBgYqHPnztmdz969ezVkyBA1atRIHh4etsEiGjRooJtvvlk///yzevXq5XDQjWPHjmn06NFq1qyZvLy8bP1DQ0PVr18/ffXVVxozZoxmzZplt//p06d17733qlWrVvLx8bH1r1mzpjp37qznn39e2dnZdvvOnTtXw4cPlySdOHFC06dPV9OmTeXr66uXX3650NfwxIkTkqQ6deoU2jbXli1bFBkZme95wzD08ccfq2fPngoJCbGth4eHhxo2bKjBgwfr999/tzvPb7/9VhEREbJarQUu+88//3T4Xvbq1UtvvPGGzp49q5kzZ+qaa66Rv7+/LBaLAgMD1aVLF73xxhv5lrFixQpZLBb16tVLktSoUSNb7d7e3oqOjnb2pQGAcodBMwAADsXFxSk2NlbHjx/XLbfcooSEBN14443q37+/+vXrZ2uXlJSkU6dO6dy5c/muO9q0aZNuuukmNWnSREOGDFGdOnXk4eEhq9Wqs2fPaufOnerTp48kqWvXrvlqOHDggNq1a6eaNWtq2LBhCgkJkZeXlwzD0Pnz57Vv3z4NGTJEfn5+eWrKdebMGTVv3lxZWVkaOXKkRo8eLR8fHxmGoQsXLujAgQOaPn26vv32W61fv14WiyVP/5iYGMXExGjbtm0aPHiwateurW7duqlBgwYaOHBgoa9henq6JMnb27vwF/z/qVevnt3n58yZo3nz5qlXr14aO3asbeCNrKwsxcfHa926dbruuuu0fv36fK9FfHy8YmJiZLVaCxyw4tSpUw7fy5iYGG3dulVz5sxR5cqV1b9/fwUHBysgIEBnz57Vnj17NH78eP3www/63//+Z+vXp08fLVu2TIcOHdLSpUs1e/Zs1apVy/a6OFpfAKgQDADAVSU6OtqQZGzevLnQtu+8844hyejTp48xadIkIzk52W67zZs3G5KM6OjofNNatWpl9OnTx8jKynK4nFdffdWQZDz++OP5pkVFRRlNmzY10tPTHfb/6quvDEnGqFGj8k174IEHjICAACM+Pr7Q/l9++WW+aWPGjDEaN25shIWFGW+++aaRnZ3tcD72FPTaFEVcXJzh5eVlPPbYY4bVarXb5vLly0bv3r2N5s2b52uT+14W9D4UVm/9+vUNScaSJUsc1rBixQpDkvHLL78Uad4AUFFxSiEAoFBWq1VLly5VQEBAkfqdP39ee/fu1eTJk+Xu7vikirvvvtvudMMwtGXLFk2cOLHAI0T9+vVTWFiY3WlbtmzRqFGjFBwc7LD/TTfdpBYtWmjDhg12px86dEhjxozRPffco0qVKjmcj5l+/vlnZWZmavr06fmOwuXy8PDQlClT9Oeff+rs2bOm1NGzZ09NnTrVYQ2jR49WzZo1tXXrVlOWDwDlDYELAFCocePGFeu+SceOHZPk+BS5XB4eHnavcbpw4YJSUlKcOuUsNDTUYQ0REREF9rVYLIqIiLDVa8+ECRMKrcFMx48fV0BAgKpVq1Zgu/DwcEl/n/5nhsIG/3Bzc1O9evVMWz4AlDdcwwUAKFSLFi2K1S85OVmS5O/vX2hbe4HuSvtLUkpKiqxWq+Li4grs7+XlpZMnT9qdVq1aNQUFBRVag5mSk5Odeh1y2+S+dq7mzBE+f39/05YPAOUNgQsAUKiinkpY1jzyyCN65JFHCm2XO3jHvwUEBDg8hQ4AgIIQuAAAFd7999+vm266qdB2xT2SVxAfHx9JUkZGhtN9jh07puDgYHl6erq8HgBAySJwAQBMk3t6W1paWqFtDcNweX9J8vPzU5MmTeze16ok1K9fX5J08uRJtWzZ0qk+vXv31nPPPaehQ4fanvP391dqamqhfS9evChJqlKlSp7nc49SpqamqmrVqg77O7ofmSv4+vpK+v+HygeAqwGDZgAATJM7gEPuzX8dOXfunN1rrKpXry5/f/9C++fk5Gj//v0Oa4iNjS201scee0z33Xdfoe2Kqnbt2vL19dWOHTucan/u3DnFxMSodu3aeZ4PCwtTcnKyLly4UGD/3MEqcl/7f/aXCn8vtm3b5lSdxZFbgzPvBwBUFAQuAIBpqlWrpubNm+ull15yeOQkIyNDEyZMkNVqzTfNYrGoe/fuevXVVx2ekpedna1p06Y5HAa9R48eevfddwscxOH06dN644038oUcV7BYLLr//vv1/PPP68CBA4W2f/bZZ+Xl5aVmzZrleb5Dhw7y9PTUkiVLHPbNysrSiy++qObNm6tGjRp5pjVt2lS1a9fWCy+84PBo4A8//KAXXnih8JUqppo1a6pRo0Z65ZVXlJOTY9pyAKAs4ZRCAIBpLBaLnn/+efXv31+tW7fWwIEDFRQUJDc3N507d05Hjx7V2rVr1aFDB4f3yXrmmWd03XXXqWnTpho2bJiCg4Pl4eGhCxcu6MSJE1q7dq2CgoLUpk0bu/1nz56tDz74QI0bN9btt9+uunXrqnLlypL+DntxcXH6+OOP5e7urrvvvtuU1+HRRx/VunXr1KpVKw0dOlSNGjVS7dq1bSMr5uTk6PTp09q6dau2bdump59+Ol9gCg0N1cMPP6x58+bpxx9/VOfOnVWrVi25ubkpOztbCQkJWrdunQ4ePKgvv/wy3yAfPj4+WrRoke6++24dOHBAvXv3Vu3atZWVlaWkpCT9+OOP2rlzpx544AEtXrzYlNfBYrFoyZIlioqKUtu2bdW/f39FRETozjvvtL0nAFDRELgA4CpTo0YNBQcH273v1b/VrVtXtWrVKvCaH0kKDAxU7dq1Vb169XzTbrzxRv3666968skntWbNGh0/flxWq1XVqlVTs2bNNH/+fE2YMEGNGjWyO+9rrrlG+/fv1xNPPKF169bp2LFjunz5sqpUqaKGDRvqgQce0IMPPqiBAwfa7V+7dm3t379fc+bM0caNG3X06FHb0TJfX1/VqVNHUVFRmjZtmt37fYWHhxd6Gl5hqlSpot9++00vvvii1q1bp+3btys+Pt423WKxKDg4WI0aNdKnn36qwYMH253PvHnzdO211+qll17SW2+9ZRvGvlKlSqpfv75atGihlStXqm3btnb7jx07VuHh4Xr66ae1cuVKxcbGysPDQ0FBQerVq5def/11WSwWvfvuu3bfy7CwMNs1aQWpX7++w/uiRUZG6qefftLcuXP14Ycf6uzZs+rVq5fD9x8AyjuL4ei8AgAASlBYWJhGjx6t+fPnF6v/9ddfr7p162rlypUurgwAgOLjGi4AgGlycnK0d+9ep9parVa7N9Xdu3evU9f7OOoPAEBpInABAEwTHR2ta6+9Vjt37iywXXp6uk6dOpXvlL6MjAxde+21+uSTTwrsb7VadeLECbunBAIAUJo4pRAAYJqcnBw1aNBAHh4eGjJkiEJDQ/MN5pCenq4vv/xSv/zyi/7666981/706NFD0dHRGjFihCIiImwDTeS6dOmStm3bps8//1y//PKL2rdvb/p6AQDgLAIXAMBU+/fv17Rp0/Tzzz/bvYeUv7+/mjdvrgULFqhPnz75psfFxWnq1KnasmWLzpw5k2+6t7e3GjVqpMcee0wjRowwYxUAACg2AhcAAAAAmIRruAAAAADAJAQuAAAAADAJgQsAAAAATELgAgAAAACTELgAAAAAwCQELgAAAAAwCYELAAAAAExC4AIAAAAAk/x/UD9uiWCrxg4AAAAASUVORK5CYII=", "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(list(res.keys()), list(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": "213d4905", "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": "07a3b5c9", "metadata": { "execution": { "iopub.execute_input": "2025-05-16T13:34:06.014567Z", "iopub.status.busy": "2025-05-16T13:34:06.014408Z", "iopub.status.idle": "2025-05-16T13:34:12.022341Z", "shell.execute_reply": "2025-05-16T13:34:12.021556Z" } }, "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", "connected :\tTrue \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: BOOTING, 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": { "cell_metadata_filter": "all", "notebook_metadata_filter": "files_to_bundle_in_zip_file,is_demo,execute" }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "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.22" } }, "nbformat": 4, "nbformat_minor": 5 }