diff --git a/README.md b/README.md index b860efa8..de8ff03d 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ various spin-control experiments on quantum systems, such as NV centers in diamo * Spin Core PulseBlaster * Excelitas SPCM for photon detection * NI-DAQ card (PCIx 6363) for data acquisition and control - * Jena System's Piezo Actuator Stage Control Amplifier + * Jena System's Piezo Actuator Control Amplifier * [Future] spectrometer The code in this package facilitates usages of these devices to perform diff --git a/examples/confocal-scan-random-and-hyperdaq.ipynb b/examples/confocal-scan-random-and-hyperdaq.ipynb new file mode 100644 index 00000000..f2de8e57 --- /dev/null +++ b/examples/confocal-scan-random-and-hyperdaq.ipynb @@ -0,0 +1,577 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "84edc1c2", + "metadata": {}, + "source": [ + "# Confocal Scan - Random Testing and Hyper DAQ\n", + "\n", + "This notebook demonstrates how to use the CounterAndScanner class (also called NiDaqPiezoScanner)\n", + "to generate a 2D image of a sample. This uses an actuator to move the location of \n", + "laser light impinging on a sample and an NiDAQ to count the photons emitted (via \n", + "digital TTL pulses generated from a photon detector) from the sample. When used with \n", + "an appropriate pinhole that restricts the in-focus depth of field, \n", + "the image is known as a confocal scan. \n", + "\n", + "In this example, dummy objects are used to demonstrate how to run without hardware, \n", + "which is useful for testing purposes. \n", + "\n", + "More importantly, usage of a 'hyper data acquisition' function is also demonstrated. \n", + "The hyper data acquisition function allows an experimenter to take extra data at \n", + "each position of 2D image, such as with a spectrometer to generate a \"hyperspectral image\". " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4410fcd5", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "815ca094", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7e06f7a3", + "metadata": {}, + "outputs": [], + "source": [ + "import nipiezojenapy\n", + "import qt3utils.datagenerators as datasources\n", + "import qt3utils.datagenerators.piezoscanner" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a7a370ec", + "metadata": {}, + "outputs": [], + "source": [ + "#logging.basicConfig(level = logging.INFO) #set to logging.WARNING to suppress logged information to cells\n", + "#qt3utils.datagenerators.piezoscanner.logger.setLevel(logging.INFO)" + ] + }, + { + "cell_type": "markdown", + "id": "3e3f2ccc", + "metadata": {}, + "source": [ + "## Object Instantiation\n", + "\n", + "To generate a 2D image, three objects are used:\n", + "\n", + " * an object to control the position of the light\n", + " * an object to count the number of photons that reach our photon detector\n", + " * an object that uses both the position controller and photon counter to generate the image. \n", + " \n", + " \n", + "In the QT3 lab, we use the nipiezojenapy software package to control the \n", + "piezo actuator that positions the objective over a sample and the NIDAQ \n", + "card to count the number of TTL pulses from an SPCM. \n", + "\n", + "In this instance, for our demonstration purposes, we will use dummy \n", + "position control and DAQ objects, which mimic usage of real hardware objects.\n", + "\n", + " * nipiezojenapy.BaseControl - dummy actuator controller\n", + " * datasources.RandomRateCounter - random data generator\n", + " * CounterAndScanner - perform the scans and generates the image\n", + "\n", + "See the [confocal_scan](confocal-scan.ipynb) notebook for example usage of real hardware." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "29a0511f", + "metadata": {}, + "outputs": [], + "source": [ + "position_controller = nipiezojenapy.BaseControl()\n", + "data_acq = datasources.RandomRateCounter(simulate_single_light_source=True, num_data_samples_per_batch=50)\n", + "scanner = datasources.CounterAndScanner(data_acq, position_controller)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5b2cf4e1", + "metadata": {}, + "outputs": [], + "source": [ + "scanner.set_scan_range(0, 20, 0, 20)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d8b848c3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'x': 0, 'y': 0, 'z': 0}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scanner.get_current_position()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "15ff65d8-e99f-4493-879b-5e9b97561da8", + "metadata": {}, + "outputs": [], + "source": [ + "# assume we wish to generate an image at some particular depth, z\n", + "\n", + "some_optimal_z = 15 \n", + "position_controller.go_to_position(z = some_optimal_z)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c78a079c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 0, 15]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "position_controller.get_current_position()" + ] + }, + { + "cell_type": "markdown", + "id": "6921fd3b", + "metadata": {}, + "source": [ + "### Run Scan\n", + "\n", + "The docstring for the `run_scan` function describes the actions it performs. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b1b0e47f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on method run_scan in module qt3utils.datagenerators.piezoscanner:\n", + "\n", + "run_scan(reset_starting_position=True, line_scan_callback=None) method of qt3utils.datagenerators.piezoscanner.CounterAndScanner instance\n", + " Runs a scan across the range of set parameters: xmin, xmax, ymin, ymax, with increments of step_size.\n", + " \n", + " To get the data after the scan, call get_raw_counts() or get_count_rate(). You may also\n", + " provide a callback function that will be called after each line scan is completed.\n", + " \n", + " :param reset_starting_position: if True, the actuator will be reset to the starting position before the scan begins\n", + " :param line_scan_callback: a function that will be called after each line scan is completed. The function\n", + " should take a single argument, which will be an instance of this class.\n", + " i.e. line_scan_callback(obj: CounterAndScanner)\n", + " :return: None\n", + "\n" + ] + } + ], + "source": [ + "help(scanner.run_scan)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3702c8ee", + "metadata": {}, + "outputs": [], + "source": [ + "scanner.run_scan() # user logger to display text during scan" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b2d67812", + "metadata": {}, + "outputs": [], + "source": [ + "count_rate = scanner.get_count_rate()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "82e5580f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg4AAAGiCAYAAACPjU4xAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA8vklEQVR4nO3df1RUdf7H8degAmYy5A8YKFQqEy1/pYbY75WvaG6JWf5Yv0lltRn0TclSdxPtxy6lW5lpsu2m2CnXH+ekblq0hIlroibGN3WTVb8oujpoFkyQAsH9/rGH2SYBBy6D6H0+zrnnNPe+753P3IB5+f7cuWMzDMMQAACAF/wu9AAAAMDFg+AAAAC8RnAAAABeIzgAAACvERwAAIDXCA4AAMBrBAcAAOA1ggMAAPAawQEAAHiN4AAAALzWoOCQmpqqQYMGqX379goJCVF8fLzy8/M9as6ePavExER17NhRl19+ucaMGaOioqJ6j2sYhlJSUhQWFqa2bdsqNjZWBw4caPirAQAAPtWg4JCdna3ExERt375dmZmZqqys1LBhw1RWVuaumTZtmj788EOtWbNG2dnZOn78uO699956jztv3jwtXLhQaWlp2rFjh9q1a6e4uDidPXu2ca8KAAD4hM3Ml1ydOnVKISEhys7O1m233aaSkhJ17txZK1as0H333SdJ2r9/v3r27KmcnBwNHjz4nGMYhqHw8HA9/fTTmj59uiSppKREoaGhSk9P1/jx4xs7PAAA0MRam9m5pKREktShQwdJUm5uriorKxUbG+uuiYqKUpcuXeoMDgUFBXI6nR772O12RUdHKycnp9bgUF5ervLycvfj6upqffvtt+rYsaNsNpuZlwQAuAAMw9D333+v8PBw+fn57vK7s2fPqqKiwvRx/P39FRgY2AQjuvg0OjhUV1dr6tSpuvnmm3XDDTdIkpxOp/z9/RUcHOxRGxoaKqfTWetxataHhoZ6vU9qaqqef/75xg4dANBCHT16VFdddZVPjn327FlFRkbW+d7SEA6HQwUFBZYMD40ODomJidq7d6+2bt3alOPxyqxZs5ScnOx+XFJSoi5dujT7OAAATat9+/Y+O3ZFRYWcTqcKCwsVFBTU6OO4XC516dJFFRUVBAdvJSUlacOGDdqyZYtHMnQ4HKqoqFBxcbFH16GoqEgOh6PWY9WsLyoqUlhYmMc+/fr1q3WfgIAABQQENGboAIAWrDmmm4OCgkwFB6tr0ESSYRhKSkrS2rVrtWnTJkVGRnpsHzBggNq0aaOsrCz3uvz8fBUWFiomJqbWY0ZGRsrhcHjs43K5tGPHjjr3AQCgsQzDML1YmtEAU6ZMMex2u7F582bjxIkT7uWHH35w1zz++ONGly5djE2bNhm7du0yYmJijJiYGI/j9OjRw/jggw/cj19++WUjODjYWL9+vfHVV18Zo0aNMiIjI40zZ854Na6SkhJDEgsLCwvLRb6UlJQ05G2pQWreK7799lvjxx9/bPTy7bff+nysLVmDgkNd/6OXLVvmrjlz5ozxxBNPGFdccYVx2WWXGaNHjzZOnDhxznF+uk91dbUxe/ZsIzQ01AgICDCGDh1q5Ofnez0uggMLCwvLpbE0R3A4ffq0UVlZ2ejl9OnTPh9rS2bqPg4thcvlkt1uv9DDAACYVFJS4rPrD2reK06fPm364siOHTv6dKwtman7OAAAcLExTF6ncAn8e9sUggMAwFIIDubw7ZgAAMBrdBwAAJZCx8EcggMAwFIIDuYwVQEAALxGxwEAYCl0HMwhOAAALIXgYA5TFQAAwGt0HAAAlkLHwRyCAwDAUggO5hAcAACWQnAwh2scAACA1+g4AAAshY6DOQQHAIClEBzMYaoCAAB4jY4DAMBS6DiYQ3AAAFgKwcEcpioAAIDX6DgAACyFjoM5BAcAgOVY/c3fDKYqAACA1+g4AAAshakKcwgOAABLITiYQ3AAAFgKwcEcrnEAAABeo+MAALAUOg7mEBwAAJZCcDCHqQoAAOA1Og64KHiT8G02WzOMBMDFjo6DOQQHAIClEBzMYaoCAAB4jY4DAMBS6DiYQ3AAAFgKwcEcpioAAIDXGhwctmzZorvvvlvh4eGy2Wxat26dx3abzVbrMn/+/DqPOXfu3HPqo6KiGvxiAAA4n5qOg5nFyho8VVFWVqa+ffvq4Ycf1r333nvO9hMnTng8/vjjjzV58mSNGTOm3uNef/31+vTTT/8zsNbMogAAmh5TFeY0+N15xIgRGjFiRJ3bHQ6Hx+P169frzjvv1NVXX13/QFq3PmdfAACaGsHBHJ/+s76oqEgbN27U8uXLz1t74MABhYeHKzAwUDExMUpNTVWXLl1qrS0vL1d5ebn7scvlarIxo2Xi5k7AxS0tLa3e7WfOnNG0adOaaTQww6cXRy5fvlzt27evdUrjp6Kjo5Wenq6MjAwtWbJEBQUFuvXWW/X999/XWp+amiq73e5eIiIifDF8AMAliGsczPFpcFi6dKkmTpyowMDAeutGjBih+++/X3369FFcXJw++ugjFRcXa/Xq1bXWz5o1SyUlJe7l6NGjvhg+AOASRHAwx2dTFX//+9+Vn5+vVatWNXjf4OBgXXfddTp48GCt2wMCAhQQEGB2iAAAoIF81nF45513NGDAAPXt27fB+5aWlurQoUMKCwvzwcgAAFZGx8GcBgeH0tJS5eXlKS8vT5JUUFCgvLw8FRYWumtcLpfWrFmjRx55pNZjDB06VIsWLXI/nj59urKzs3X48GFt27ZNo0ePVqtWrTRhwoSGDg8AgHoRHMxp8FTFrl27dOedd7ofJycnS5ISEhKUnp4uSVq5cqUMw6jzjf/QoUP65ptv3I+PHTumCRMm6PTp0+rcubNuueUWbd++XZ07d27o8AAAgA81ODjccccd501bjz32mB577LE6tx8+fNjj8cqVKxs6DAAAGoX7OJjD7RkBAJZj9Td/MwgOAACfe/zxxy/0ENBECA4AAEthqsIcggMAwFIIDuYQHAAAlkJwMMent5wGAACXFjoOAABLoeNgDsEBAGApBAdzmKoAAMCHqqqqNHv2bEVGRqpt27a65ppr9OKLL3oEEMMwlJKSorCwMLVt21axsbE6cOCAx3G+/fZbTZw4UUFBQQoODtbkyZNVWlrqUfPVV1/p1ltvVWBgoCIiIjRv3rxzxrNmzRpFRUUpMDBQvXv31kcffdSg10NwAABYSnN/V8Urr7yiJUuWaNGiRfr666/1yiuvaN68eXrzzTfdNfPmzdPChQuVlpamHTt2qF27doqLi9PZs2fdNRMnTtS+ffuUmZmpDRs2aMuWLR53aXa5XBo2bJi6du2q3NxczZ8/X3PnztXbb7/trtm2bZsmTJigyZMn68svv1R8fLzi4+O1d+9er1+PzbgEei4ul0t2u/1CDwMAYFJJSYmCgoJ8cuya94qcnBxdfvnljT5OaWmpYmJivB7rL3/5S4WGhuqdd95xrxszZozatm2r9957T4ZhKDw8XE8//bSmT58u6d/nITQ0VOnp6Ro/fry+/vpr9erVS1988YUGDhwoScrIyNBdd92lY8eOKTw8XEuWLNFvf/tbOZ1O+fv7S5JmzpypdevWaf/+/ZKkcePGqaysTBs2bHCPZfDgwerXr5/S0tK8ev10HAAAaASXy+WxlJeX11o3ZMgQZWVl6Z///Kck6X//93+1detWjRgxQtK/v2Xa6XQqNjbWvY/dbld0dLRycnIkSTk5OQoODnaHBkmKjY2Vn5+fduzY4a657bbb3KFBkuLi4pSfn6/vvvvOXfPT56mpqXkeb3BxJADAUprq4siIiAiP9XPmzNHcuXPPqZ85c6ZcLpeioqLUqlUrVVVV6Xe/+50mTpwoSXI6nZKk0NBQj/1CQ0Pd25xOp0JCQjy2t27dWh06dPCoiYyMPOcYNduuuOIKOZ3Oep/HGwQHAIClNFVwOHr0qMdURUBAQK31q1ev1vvvv68VK1bo+uuvV15enqZOnarw8HAlJCQ0ehwXCsEBAIBGCAoK8uoah2eeeUYzZ87U+PHjJUm9e/fWkSNHlJqaqoSEBDkcDklSUVGRwsLC3PsVFRWpX79+kiSHw6GTJ096HPfHH3/Ut99+697f4XCoqKjIo6bm8flqarZ7g2scAACW0tyfqvjhhx/k5+f5dtuqVStVV1dLkiIjI+VwOJSVleXe7nK5tGPHDsXExEiSYmJiVFxcrNzcXHfNpk2bVF1drejoaHfNli1bVFlZ6a7JzMxUjx49dMUVV7hrfvo8NTU1z+MNggMAwFKaOzjcfffd+t3vfqeNGzfq8OHDWrt2rV577TWNHj1akmSz2TR16lS99NJL+utf/6o9e/Zo0qRJCg8PV3x8vCSpZ8+eGj58uB599FHt3LlTn3/+uZKSkjR+/HiFh4dLkn71q1/J399fkydP1r59+7Rq1Sq98cYbSk5Odo/lqaeeUkZGhl599VXt379fc+fO1a5du5SUlOT162GqAgBgKc1958g333xTs2fP1hNPPKGTJ08qPDxcv/71r5WSkuKuefbZZ1VWVqbHHntMxcXFuuWWW5SRkaHAwEB3zfvvv6+kpCQNHTpUfn5+GjNmjBYuXOjebrfb9be//U2JiYkaMGCAOnXqpJSUFI97PQwZMkQrVqzQc889p9/85jfq3r271q1bpxtuuMHr18N9HAAALUZz3Mdhy5Ytpu/jcNttt/l0rC0ZHQcAgKXwXRXmEBwAAJZCcDCHiyMBAIDX6DgAACyFjoM5BAcAgKUQHMxhqgIAAHiNjgMAwFLoOJhDcAAAWI7V3/zNYKoCAAB4jY4DAMBSmKowh+AAALAUgoM5BAcAgKUQHMzhGgcAAOA1Og4AAEuh42AOwQEAYCkEB3OYqgAAAF5rcHDYsmWL7r77boWHh8tms2ndunUe2x988EHZbDaPZfjw4ec97uLFi9WtWzcFBgYqOjpaO3fubOjQAAA4r5qOg5nFyhocHMrKytS3b18tXry4zprhw4frxIkT7uUvf/lLvcdctWqVkpOTNWfOHO3evVt9+/ZVXFycTp482dDhAQBQL4KDOQ2+xmHEiBEaMWJEvTUBAQFyOBxeH/O1117To48+qoceekiSlJaWpo0bN2rp0qWaOXNmQ4cIAAB8xCfXOGzevFkhISHq0aOHpkyZotOnT9dZW1FRodzcXMXGxv5nUH5+io2NVU5OTq37lJeXy+VyeSwAAHiDjoM5TR4chg8frnfffVdZWVl65ZVXlJ2drREjRqiqqqrW+m+++UZVVVUKDQ31WB8aGiqn01nrPqmpqbLb7e4lIiKiqV8GAOASRXAwp8k/jjl+/Hj3f/fu3Vt9+vTRNddco82bN2vo0KFN8hyzZs1ScnKy+7HL5SI8AADQDHz+ccyrr75anTp10sGDB2vd3qlTJ7Vq1UpFRUUe64uKiuq8TiIgIEBBQUEeCwAA3qDjYI7Pg8OxY8d0+vRphYWF1brd399fAwYMUFZWlntddXW1srKyFBMT4+vhAQAshuBgToODQ2lpqfLy8pSXlydJKigoUF5engoLC1VaWqpnnnlG27dv1+HDh5WVlaVRo0bp2muvVVxcnPsYQ4cO1aJFi9yPk5OT9ac//UnLly/X119/rSlTpqisrMz9KQsAAJoKwcGcBl/jsGvXLt15553uxzXXGiQkJGjJkiX66quvtHz5chUXFys8PFzDhg3Tiy++qICAAPc+hw4d0jfffON+PG7cOJ06dUopKSlyOp3q16+fMjIyzrlgEgAAXFg24xKITi6XS3a7/UIPAwBgUklJic+uW6t5r1i3bp3atWvX6OOUlZUpPj7ep2NtyfiSKwCApfAlV+bwJVcAAMBrdByARlq6dOl5ax5++OFmGAmAhqDjYA7BAQBgKQQHc5iqAAAAXqPjAACwFDoO5hAcAACWY/U3fzOYqgAAAF6j4wAAsBSmKswhOAAALIXgYA7BAQBgKQQHcwgOQCNxcycAVkRwAABYCh0HcwgOAABLITiYw8cxAQCA1+g4AAAshY6DOQQHAIClEBzMYaoCAAB4jY4DAMBS6DiYQ3AAAFgKwcEcpioAAIDX6DgAACyFjoM5BAcAgKUQHMwhOAAALIXgYA7XOAAAAK/RcQAAWAodB3MIDgAASyE4mMNUBQAA8BodBwCApdBxMIfgAACwFIKDOUxVAAAAr9FxAABYCh0HcwgOAABLITiYw1QFAADwGh0HAIDlWL1rYAbBAQBgKUxVmNPgqYotW7bo7rvvVnh4uGw2m9atW+feVllZqRkzZqh3795q166dwsPDNWnSJB0/frzeY86dO1c2m81jiYqKavCLAQDgfGqCg5nFyhocHMrKytS3b18tXrz4nG0//PCDdu/erdmzZ2v37t364IMPlJ+fr3vuuee8x73++ut14sQJ97J169aGDg0AAPhYg4PDiBEj9NJLL2n06NHnbLPb7crMzNTYsWPVo0cPDR48WIsWLVJubq4KCwvrPW7r1q3lcDjcS6dOneqsLS8vl8vl8lgAAPDGheg4/Otf/9J///d/q2PHjmrbtq169+6tXbt2eYwpJSVFYWFhatu2rWJjY3XgwAGPY3z77beaOHGigoKCFBwcrMmTJ6u0tNSj5quvvtKtt96qwMBARUREaN68eeeMZc2aNYqKilJgYKB69+6tjz76qEGvxeefqigpKZHNZlNwcHC9dQcOHFB4eLiuvvpqTZw4sd6gkZqaKrvd7l4iIiKaeNQAgEtVcweH7777TjfffLPatGmjjz/+WP/4xz/06quv6oorrnDXzJs3TwsXLlRaWpp27Nihdu3aKS4uTmfPnnXXTJw4Ufv27VNmZqY2bNigLVu26LHHHnNvd7lcGjZsmLp27arc3FzNnz9fc+fO1dtvv+2u2bZtmyZMmKDJkyfryy+/VHx8vOLj47V3716vX4/NMDFZY7PZtHbtWsXHx9e6/ezZs7r55psVFRWl999/v87jfPzxxyotLVWPHj104sQJPf/88/rXv/6lvXv3qn379ufUl5eXq7y83P3Y5XIRHgDgElBSUqKgoCCfHNvlcslut+utt95S27ZtG32cM2fO6IknnvB6rDNnztTnn3+uv//977VuNwxD4eHhevrppzV9+nRJ/z4PoaGhSk9P1/jx4/X111+rV69e+uKLLzRw4EBJUkZGhu666y4dO3ZM4eHhWrJkiX7729/K6XTK39/f/dzr1q3T/v37JUnjxo1TWVmZNmzY4H7+wYMHq1+/fkpLS/Pq9fus41BZWamxY8fKMAwtWbKk3toRI0bo/vvvV58+fRQXF6ePPvpIxcXFWr16da31AQEBCgoK8lgAAPBGU3Ucfj5l/tN/0P7UX//6Vw0cOFD333+/QkJC1L9/f/3pT39yby8oKJDT6VRsbKx7nd1uV3R0tHJyciRJOTk5Cg4OdocGSYqNjZWfn5927NjhrrntttvcoUGS4uLilJ+fr++++85d89PnqampeR5v+CQ41ISGI0eOKDMzs8Fv7MHBwbruuut08OBBXwwPAGBhTRUcIiIiPKbNU1NTa32+//u//9OSJUvUvXt3ffLJJ5oyZYr+53/+R8uXL5ckOZ1OSVJoaKjHfqGhoe5tTqdTISEhHttbt26tDh06eNTUdoyfPkddNTXbvdHk93GoCQ0HDhzQZ599po4dOzb4GKWlpTp06JAeeOCBph4eAABN4ujRox7/MA4ICKi1rrq6WgMHDtTvf/97SVL//v21d+9epaWlKSEhoVnG2pQa3HEoLS1VXl6e8vLyJP27xZKXl6fCwkJVVlbqvvvu065du/T++++rqqpKTqdTTqdTFRUV7mMMHTpUixYtcj+ePn26srOzdfjwYW3btk2jR49Wq1atNGHCBPOvEACAn2iqjsPPp8zrCg5hYWHq1auXx7qePXu6PwTgcDgkSUVFRR41RUVF7m0Oh0MnT5702P7jjz/q22+/9aip7Rg/fY66amq2e6PBwWHXrl3q37+/+vfvL0lKTk5W//79lZKSon/961/661//qmPHjqlfv34KCwtzL9u2bXMf49ChQ/rmm2/cj48dO6YJEyaoR48eGjt2rDp27Kjt27erc+fODR0eAAD1au5PVdx8883Kz8/3WPfPf/5TXbt2lSRFRkbK4XAoKyvLvd3lcmnHjh2KiYmRJMXExKi4uFi5ubnumk2bNqm6ulrR0dHumi1btqiystJdk5mZqR49erg/wRETE+PxPDU1Nc/jjQZPVdxxxx31njRvTujhw4c9Hq9cubKhwwAAoFHM3v2xoftOmzZNQ4YM0e9//3uNHTtWO3fu1Ntvv+3+mKTNZtPUqVP10ksvqXv37oqMjNTs2bMVHh7u/tRiz549NXz4cD366KNKS0tTZWWlkpKSNH78eIWHh0uSfvWrX+n555/X5MmTNWPGDO3du1dvvPGGXn/9dfdYnnrqKd1+++169dVXNXLkSK1cuVK7du3y+Mjm+fBdFQAA+NCgQYO0du1azZo1Sy+88IIiIyO1YMECTZw40V3z7LPPqqysTI899piKi4t1yy23KCMjQ4GBge6a999/X0lJSRo6dKj8/Pw0ZswYLVy40L3dbrfrb3/7mxITEzVgwAB16tRJKSkpHvd6GDJkiFasWKHnnntOv/nNb9S9e3etW7dON9xwg9evx9R9HFqKms/mAgAubs1xH4cFCxaYvo/D1KlTfTrWloyOAwDAUpp7quJS4/NbTgMAgEsHHQcAgKXQcTCH4AAAsBSCgzlMVQAAAK/RcQAAWAodB3MIDgAASyE4mMNUBQAA8BodBwCApdBxMIfgAACwFIKDOQQHAIDlWP3N3wyucQAAAF6j4wAAsBSmKswhOAAALIXgYA5TFQAAwGt0HAAAlkLHwRyCAwDAUggO5jBVAQAAvEbHAQBgKXQczCE4AAAsheBgDlMVAADAa3QcAACWQsfBHIIDAMBSCA7mEBwAAJZCcDCHaxwAAIDX6DgAACyFjoM5BAcAgKUQHMxhqgIAAHiNjgMAwFLoOJhDcAAAWArBwRymKgAAgNfoOAAALIWOgzkEBwCApRAczGnwVMWWLVt09913Kzw8XDabTevWrfPYbhiGUlJSFBYWprZt2yo2NlYHDhw473EXL16sbt26KTAwUNHR0dq5c2dDhwYAAHyswcGhrKxMffv21eLFi2vdPm/ePC1cuFBpaWnasWOH2rVrp7i4OJ09e7bOY65atUrJycmaM2eOdu/erb59+youLk4nT55s6PAAAKhXTcfBzGJlDQ4OI0aM0EsvvaTRo0efs80wDC1YsEDPPfecRo0apT59+ujdd9/V8ePHz+lM/NRrr72mRx99VA899JB69eqltLQ0XXbZZVq6dGmt9eXl5XK5XB4LAADeIDiY06SfqigoKJDT6VRsbKx7nd1uV3R0tHJycmrdp6KiQrm5uR77+Pn5KTY2ts59UlNTZbfb3UtERERTvgwAwCWO0NB4TRocnE6nJCk0NNRjfWhoqHvbz33zzTeqqqpq0D6zZs1SSUmJezl69GgTjB4AAJzPRfmpioCAAAUEBFzoYQAALkJ8qsKcJu04OBwOSVJRUZHH+qKiIve2n+vUqZNatWrVoH0AAGgsrnEwp0mDQ2RkpBwOh7KystzrXC6XduzYoZiYmFr38ff314ABAzz2qa6uVlZWVp37AACAC6PBUxWlpaU6ePCg+3FBQYHy8vLUoUMHdenSRVOnTtVLL72k7t27KzIyUrNnz1Z4eLji4+Pd+wwdOlSjR49WUlKSJCk5OVkJCQkaOHCgbrrpJi1YsEBlZWV66KGHzL9CAAB+gqkKcxocHHbt2qU777zT/Tg5OVmSlJCQoPT0dD377LMqKyvTY489puLiYt1yyy3KyMhQYGCge59Dhw7pm2++cT8eN26cTp06pZSUFDmdTvXr108ZGRnnXDAJAIBZBAdzbMYlcAZcLpfsdvuFHgYAwKSSkhIFBQX55Ng17xXTp083dYF9eXm5/vCHP/h0rC3ZRfmpCgAAGouOgzkEBwCApRAczGnST1UAAIBLGx0HAICl0HEwh+AAALAUgoM5BAcAgKUQHMzhGgcAAOA1Og4AAEuh42AOwQEAYCkEB3OYqgAAAF6j4wAAsBQ6DuYQHAAAlkJwMIepCgAA4DU6DgAAS6HjYA7BAQBgKQQHc5iqAAAAXqPjAACwFDoO5hAcAACWQnAwh+AAALAcq7/5m8E1DgAAwGt0HAAAlsJUhTkEBwCApRAczGGqAgCAZvTyyy/LZrNp6tSp7nVnz55VYmKiOnbsqMsvv1xjxoxRUVGRx36FhYUaOXKkLrvsMoWEhOiZZ57Rjz/+6FGzefNm3XjjjQoICNC1116r9PT0c55/8eLF6tatmwIDAxUdHa2dO3c2aPwEBwCApdR0HMwsjfXFF1/oj3/8o/r06eOxftq0afrwww+1Zs0aZWdn6/jx47r33nvd26uqqjRy5EhVVFRo27ZtWr58udLT05WSkuKuKSgo0MiRI3XnnXcqLy9PU6dO1SOPPKJPPvnEXbNq1SolJydrzpw52r17t/r27au4uDidPHnS69dgMy6BnovL5ZLdbr/QwwAAmFRSUqKgoCCfHLvmvWLy5Mny9/dv9HEqKir0zjvv6OjRox5jDQgIUEBAQJ37lZaW6sYbb9Rbb72ll156Sf369dOCBQtUUlKizp07a8WKFbrvvvskSfv371fPnj2Vk5OjwYMH6+OPP9Yvf/lLHT9+XKGhoZKktLQ0zZgxQ6dOnZK/v79mzJihjRs3au/eve7nHD9+vIqLi5WRkSFJio6O1qBBg7Ro0SJJUnV1tSIiIvTkk09q5syZXr1+Og4AADRCRESE7Ha7e0lNTa23PjExUSNHjlRsbKzH+tzcXFVWVnqsj4qKUpcuXZSTkyNJysnJUe/evd2hQZLi4uLkcrm0b98+d83Pjx0XF+c+RkVFhXJzcz1q/Pz8FBsb667xBhdHAgAspakujqyt41CXlStXavfu3friiy/O2eZ0OuXv76/g4GCP9aGhoXI6ne6an4aGmu012+qrcblcOnPmjL777jtVVVXVWrN///76XrIHggMAwFKaKjgEBQV5Na1y9OhRPfXUU8rMzFRgYGCjn7elYKoCAAAfys3N1cmTJ3XjjTeqdevWat26tbKzs7Vw4UK1bt1aoaGhqqioUHFxscd+RUVFcjgckiSHw3HOpyxqHp+vJigoSG3btlWnTp3UqlWrWmtqjuENggMAwFKa+1MVQ4cO1Z49e5SXl+deBg4cqIkTJ7r/u02bNsrKynLvk5+fr8LCQsXExEiSYmJitGfPHo9PP2RmZiooKEi9evVy1/z0GDU1Ncfw9/fXgAEDPGqqq6uVlZXlrvEGUxUAAEtp7htAtW/fXjfccIPHunbt2qljx47u9ZMnT1ZycrI6dOigoKAgPfnkk4qJidHgwYMlScOGDVOvXr30wAMPaN68eXI6nXruueeUmJjovrbi8ccf16JFi/Tss8/q4Ycf1qZNm7R69Wpt3LjR/bzJyclKSEjQwIEDddNNN2nBggUqKyvTQw895PXrITgAACylJd458vXXX5efn5/GjBmj8vJyxcXF6a233nJvb9WqlTZs2KApU6YoJiZG7dq1U0JCgl544QV3TWRkpDZu3Khp06bpjTfe0FVXXaU///nPiouLc9eMGzdOp06dUkpKipxOp/r166eMjIxzLpisD/dxAAC0GM1xH4dJkyaZvo/Du+++69OxtmR0HAAAltISOw4XE4IDAMBSCA7mNPmnKrp16yabzXbOkpiYWGt9enr6ObWXwudcAQC4FDV5x+GLL75QVVWV+/HevXv1X//1X7r//vvr3CcoKEj5+fnuxzabramHBQCAJDoOZjV5cOjcubPH45dfflnXXHONbr/99jr3sdlsDbr5BAAAjUVwMMenN4CqqKjQe++9p4cffrjeLkJpaam6du2qiIgIjRo1yv2FHXUpLy+Xy+XyWAAAgO/5NDisW7dOxcXFevDBB+us6dGjh5YuXar169frvffeU3V1tYYMGaJjx47VuU9qaqrHN5JFRET4YPQAgEtRc9858lLj0/s4xMXFyd/fXx9++KHX+1RWVqpnz56aMGGCXnzxxVprysvLVV5e7n7scrkIDwBwCWiO+ziMHz/e9H0cVq5cyX0cmtqRI0f06aef6oMPPmjQfm3atFH//v118ODBOmsCAgLq/fpSAADgGz6bqli2bJlCQkI0cuTIBu1XVVWlPXv2KCwszEcjAwBYGVMV5vik41BdXa1ly5YpISFBrVt7PsWkSZN05ZVXKjU1VZL0wgsvaPDgwbr22mtVXFys+fPn68iRI3rkkUd8MTQAgMXxqQpzfBIcPv30UxUWFurhhx8+Z1thYaH8/P7T6Pjuu+/06KOPyul06oorrtCAAQO0bds299eEAgDQ1Kz+5m8GX3IFAGgxmuPiyLFjx6pNmzaNPk5lZaVWr17NxZEAAFgBUxXmEBwAAJZCcDDHpzeAAgAAlxY6DgAAS6HjYA7BAQBgKQQHc5iqAAAAXqPjAACwFDoO5hAcAACWQnAwh6kKAADgNToOAABLoeNgDsEBAGApBAdzCA4AAEshOJjDNQ4AAMBrdBwAAJZCx8EcggMAwFIIDuYwVQEAALxGxwEAYCl0HMwhOAAALIXgYA5TFQAAwGt0HAAAlkLHwRyCAwDAUggO5jBVAQAAvEbHAQBgKXQczCE4AAAsheBgDsEBAGApBAdzuMYBAAB4jY4DAMByrN41MIPgAACwFKYqzGGqAgAAeI2OAwDAUug4mENwAABYCsHBHKYqAACA1+g4AAAshY6DOQQHAIClEBzMYaoCAAB4rcmDw9y5c2Wz2TyWqKioevdZs2aNoqKiFBgYqN69e+ujjz5q6mEBACDpPx0HM4uV+aTjcP311+vEiRPuZevWrXXWbtu2TRMmTNDkyZP15ZdfKj4+XvHx8dq7d68vhgYAsDiCgzk+CQ6tW7eWw+FwL506daqz9o033tDw4cP1zDPPqGfPnnrxxRd14403atGiRb4YGgDA4ggO5vgkOBw4cEDh4eG6+uqrNXHiRBUWFtZZm5OTo9jYWI91cXFxysnJqXOf8vJyuVwujwUAAPhekweH6OhopaenKyMjQ0uWLFFBQYFuvfVWff/997XWO51OhYaGeqwLDQ2V0+ms8zlSU1Nlt9vdS0RERJO+BgDApYuOgzlNHhxGjBih+++/X3369FFcXJw++ugjFRcXa/Xq1U32HLNmzVJJSYl7OXr0aJMdGwBwaSM4mOPz+zgEBwfruuuu08GDB2vd7nA4VFRU5LGuqKhIDoejzmMGBAQoICCgSccJAADOz+f3cSgtLdWhQ4cUFhZW6/aYmBhlZWV5rMvMzFRMTIyvhwYAsCA6DuY0eXCYPn26srOzdfjwYW3btk2jR49Wq1atNGHCBEnSpEmTNGvWLHf9U089pYyMDL366qvav3+/5s6dq127dikpKamphwYAAMHBpCafqjh27JgmTJig06dPq3Pnzrrlllu0fft2de7cWZJUWFgoP7//5JUhQ4ZoxYoVeu655/Sb3/xG3bt317p163TDDTc09dAAAIBJNuMSiE4ul0t2u/1CDwMAYFJJSYmCgoJ8cuya94ro6Gi1bt34fzf/+OOP2rFjh0/H2pLxJVcAAEvhS67M4UuuAACA1+g4AAAshY6DOQQHAIClEBzMITgAACyF4GAO1zgAAACvERwAAJbTnDd/Sk1N1aBBg9S+fXuFhIQoPj5e+fn5HjVnz55VYmKiOnbsqMsvv1xjxow55+sYCgsLNXLkSF122WUKCQnRM888ox9//NGjZvPmzbrxxhsVEBCga6+9Vunp6eeMZ/HixerWrZsCAwMVHR2tnTt3Nuj1EBwAAJbS3HeOzM7OVmJiorZv367MzExVVlZq2LBhKisrc9dMmzZNH374odasWaPs7GwdP35c9957r3t7VVWVRo4cqYqKCm3btk3Lly9Xenq6UlJS3DUFBQUaOXKk7rzzTuXl5Wnq1Kl65JFH9Mknn7hrVq1apeTkZM2ZM0e7d+9W3759FRcXp5MnT3r9ergBFACgxWiOG0DdeOONatWqVaOPU1VVpd27d+vo0aMeY/X2CxhPnTqlkJAQZWdn67bbblNJSYk6d+6sFStW6L777pMk7d+/Xz179lROTo4GDx6sjz/+WL/85S91/PhxhYaGSpLS0tI0Y8YMnTp1Sv7+/poxY4Y2btyovXv3up9r/PjxKi4uVkZGhiQpOjpagwYN0qJFiyRJ1dXVioiI0JNPPqmZM2d69frpOAAALKWpOg4RERGy2+3uJTU11avnLykpkSR16NBBkpSbm6vKykrFxsa6a6KiotSlSxfl5ORIknJyctS7d293aJCkuLg4uVwu7du3z13z02PU1NQco6KiQrm5uR41fn5+io2Nddd4g09VAAAspak+VVFbx+F8qqurNXXqVN18883u72RyOp3y9/dXcHCwR21oaKicTqe75qehoWZ7zbb6alwul86cOaPvvvtOVVVVtdbs37//vGOvQXAAgEvMO++8c96ayZMnN8NILm1BQUENnlZJTEzU3r17tXXrVh+NyveYqgAAWMqF+lrtpKQkbdiwQZ999pmuuuoq93qHw6GKigoVFxd71BcVFcnhcLhrfv4pi5rH56sJCgpS27Zt1alTJ7Vq1arWmppjeIPgAACwlOYODoZhKCkpSWvXrtWmTZsUGRnpsX3AgAFq06aNsrKy3Ovy8/NVWFiomJgYSVJMTIz27Nnj8emHzMxMBQUFqVevXu6anx6jpqbmGP7+/howYIBHTXV1tbKystw13mCqAgAAH0pMTNSKFSu0fv16tW/f3n1Ngt1uV9u2bWW32zV58mQlJyerQ4cOCgoK0pNPPqmYmBgNHjxYkjRs2DD16tVLDzzwgObNmyen06nnnntOiYmJ7msrHn/8cS1atEjPPvusHn74YW3atEmrV6/Wxo0b3WNJTk5WQkKCBg4cqJtuukkLFixQWVmZHnroIa9fD8EBAGApzX3L6SVLlkiS7rjjDo/1y5Yt04MPPihJev311+Xn56cxY8aovLxccXFxeuutt9y1rVq10oYNGzRlyhTFxMSoXbt2SkhI0AsvvOCuiYyM1MaNGzVt2jS98cYbuuqqq/TnP/9ZcXFx7ppx48bp1KlTSklJkdPpVL9+/ZSRkXHOBZP14T4OAHCJuZgvjmyO+zjccMMNpu/jsHfvXp+OtSWj4wAAsBS+5MocLo4EAABeo+MAALAUOg7mEBwA4BLTUq9faCkIDuYwVQEAALxGxwEAYCl0HMwhOAAALIXgYA5TFQAAwGt0HAAAlkLHwRyCAwDAUggO5jBVAQAAvEbHAQBgKXQczCE4ALhoTJw48bw177//fjOMBBczgoM5BAcAgKUQHMzhGgcAAOA1Og4AAMuxetfADIIDAMBSmKowh6kKAADgtSYPDqmpqRo0aJDat2+vkJAQxcfHKz8/v9590tPTZbPZPJbAwMCmHhoAAO6Og5nFypo8OGRnZysxMVHbt29XZmamKisrNWzYMJWVldW7X1BQkE6cOOFejhw50tRDAwCA4GBSk1/jkJGR4fE4PT1dISEhys3N1W233VbnfjabTQ6Ho6mHAwAAmpDPr3EoKSmRJHXo0KHeutLSUnXt2lUREREaNWqU9u3bV2dteXm5XC6XxwIAgDfoOJhjM3x4Bqqrq3XPPfeouLhYW7durbMuJydHBw4cUJ8+fVRSUqI//OEP2rJli/bt26errrrqnPq5c+fq+eef99WwAQAXSElJiYKCgnxybJfLJbvdroiICPn5Nf7fzdXV1Tp69KhPx9qS+TQ4TJkyRR9//LG2bt1aawCoS2VlpXr27KkJEyboxRdfPGd7eXm5ysvL3Y9dLpciIiKaZMwAgAuH4NDy+ew+DklJSdqwYYO2bNnSoNAgSW3atFH//v118ODBWrcHBAQoICCgKYYJALAY7uNgTpNf42AYhpKSkrR27Vpt2rRJkZGRDT5GVVWV9uzZo7CwsKYeHgDA4rjGwZwm7zgkJiZqxYoVWr9+vdq3by+n0ylJstvtatu2rSRp0qRJuvLKK5WamipJeuGFFzR48GBde+21Ki4u1vz583XkyBE98sgjTT08AIDF0XEwp8mDw5IlSyRJd9xxh8f6ZcuW6cEHH5QkFRYWeswvfffdd3r00UfldDp1xRVXaMCAAdq2bZt69erV1MMDAAAm+PTiyOZSc8ELAODi1hwXR4aFhZm+OPLEiRNcHAkAgBUwVWEOX3IFAAC8RscBAGApdBzMITgAACyF4GAOUxUAAMBrdBwAAJZCx8EcggMAwFIIDuYwVQEAALxGxwEAYCl0HMwhOAAALIXgYA7BAQBgKQQHc7jGAQAAeI2OAwDAcqzeNTCD4AAAsBSzocHqoYOpCgAA4DU6DgAAS6HjYA7BAQBgKQQHc5iqAAAAXqPjAACwFDoO5hAcAACWQnAwh6kKAADgNToOAABLoeNgDsEBAGApBAdzCA4AAEshOJjDNQ4AAMBrdBwAAJZCx8EcggMAwFIIDuYwVQEAALxGxwEAYCl0HMwhOAAALIXgYA7B4SLw6aefelUXGxvr45EAl4aoqKjz1uzfv78ZRgJcfAgOAABLoeNgDsEBAGApBAdz+FQFAADwGh0HAICl0HEwh+AAALAUgoM5PpuqWLx4sbp166bAwEBFR0dr586d9davWbNGUVFRCgwMVO/evfXRRx/5amgAAAszDMP0YmU+CQ6rVq1ScnKy5syZo927d6tv376Ki4vTyZMna63ftm2bJkyYoMmTJ+vLL79UfHy84uPjtXfvXl8MDwAANJLN8EF0io6O1qBBg7Ro0SJJUnV1tSIiIvTkk09q5syZ59SPGzdOZWVl2rBhg3vd4MGD1a9fP6WlpZ1TX15ervLycvfjkpISdenSpalfRouxfv16r+pGjRrl45EAl4bu3buft+bAgQPNMBL8XHFxsex2u0+O7XK5mvTYJSUlCgoKarLjXTSMJlZeXm60atXKWLt2rcf6SZMmGffcc0+t+0RERBivv/66x7qUlBSjT58+tdbPmTPHkMTCwsLCcokthw4daoq3olqdOXPGcDgcTTJOh8NhnDlzxmdjbcma/OLIb775RlVVVQoNDfVYHxoaWued2JxOZ631Tqez1vpZs2YpOTnZ/bi4uFhdu3ZVYWGhz5Kqr7hcLkVEROjo0aMXVXJl3M2LcTe/i3XsF+u4azrHHTp08NlzBAYGqqCgQBUVFaaP5e/vr8DAwCYY1cXnovxURUBAgAICAs5Zb7fbL6pflJ8KCgq6KMfOuJsX425+F+vYL9Zx+/n59vZCgYGBln3DbypN/n+oU6dOatWqlYqKijzWFxUVyeFw1LqPw+FoUD0AALgwmjw4+Pv7a8CAAcrKynKvq66uVlZWlmJiYmrdJyYmxqNekjIzM+usBwAAF4ZPpiqSk5OVkJCggQMH6qabbtKCBQtUVlamhx56SJI0adIkXXnllUpNTZUkPfXUU7r99tv16quvauTIkVq5cqV27dqlt99+26vnCwgI0Jw5c2qdvmjpLtaxM+7mxbib38U6dsYNX/PJxzEladGiRZo/f76cTqf69eunhQsXKjo6WpJ0xx13qFu3bkpPT3fXr1mzRs8995wOHz6s7t27a968ebrrrrt8MTQAANBIPgsOAADg0sO3YwIAAK8RHAAAgNcIDgAAwGsEBwAA4LWLJjhcjF/TnZqaqkGDBql9+/YKCQlRfHy88vPz690nPT1dNpvNY2nuu5zNnTv3nDFERUXVu09LON/dunU7Z9w2m02JiYm11l+oc71lyxbdfffdCg8Pl81m07p16zy2G4ahlJQUhYWFqW3btoqNjfXqC5ca+jvS1GOvrKzUjBkz1Lt3b7Vr107h4eGaNGmSjh8/Xu8xG/Pz1pTjlqQHH3zwnDEMHz78vMf19Tk/37hr+3m32WyaP39+ncdsjvPtzd++s2fPKjExUR07dtTll1+uMWPGnHMjwJ9r7O8GmtZFERwu1q/pzs7OVmJiorZv367MzExVVlZq2LBhKisrq3e/oKAgnThxwr0cOXKkmUb8H9dff73HGLZu3VpnbUs531988YXHmDMzMyVJ999/f537XIhzXVZWpr59+2rx4sW1bp83b54WLlyotLQ07dixQ+3atVNcXJzOnj1b5zEb+jvii7H/8MMP2r17t2bPnq3du3frgw8+UH5+vu65557zHrchP29NPe4aw4cP9xjDX/7yl3qP2Rzn/Hzj/ul4T5w4oaVLl8pms2nMmDH1HtfX59ubv33Tpk3Thx9+qDVr1ig7O1vHjx/XvffeW+9xG/O7AR+4kN+w5a2bbrrJSExMdD+uqqoywsPDjdTU1Frrx44da4wcOdJjXXR0tPHrX//ap+M8n5MnTxqSjOzs7Dprli1bZtjt9uYbVC3mzJlj9O3b1+v6lnq+n3rqKeOaa64xqqura93eEs61JI9vkq2urjYcDocxf/5897ri4mIjICDA+Mtf/lLncRr6O9IUfj722uzcudOQZBw5cqTOmob+vJlV27gTEhKMUaNGNeg4zX3OvTnfo0aNMn7xi1/UW9Pc59swzv3bV1xcbLRp08ZYs2aNu+brr782JBk5OTm1HqOxvxtoei2+41BRUaHc3FzFxsa61/n5+Sk2NlY5OTm17pOTk+NRL0lxcXF11jeXkpISSTrvt7+Vlpaqa9euioiI0KhRo7Rv377mGJ6HAwcOKDw8XFdffbUmTpyowsLCOmtb4vmuqKjQe++9p4cfflg2m63OupZwrn+qoKBATqfT43za7XZFR0fXeT4b8zvSXEpKSmSz2RQcHFxvXUN+3nxl8+bNCgkJUY8ePTRlyhSdPn26ztqWeM6Lioq0ceNGTZ48+by1zX2+f/63Lzc3V5WVlR7nLyoqSl26dKnz/DXmdwO+0eKDQ31f013X12439Gu6m0N1dbWmTp2qm2++WTfccEOddT169NDSpUu1fv16vffee6qurtaQIUN07NixZhtrdHS00tPTlZGRoSVLlqigoEC33nqrvv/++1rrW+L5XrdunYqLi/Xggw/WWdMSzvXP1ZyzhpzPxvyONIezZ89qxowZmjBhQr3f0tjQnzdfGD58uN59911lZWXplVdeUXZ2tkaMGKGqqqpa61viOV++fLnat29/3nZ/c5/v2v72OZ1O+fv7nxMoz/d3vabG233gGxfl12pfjBITE7V3797zziXGxMR4fLnXkCFD1LNnT/3xj3/Uiy++6OthSpJGjBjh/u8+ffooOjpaXbt21erVq73610xL8M4772jEiBEKDw+vs6YlnOtLVWVlpcaOHSvDMLRkyZJ6a1vCz9v48ePd/927d2/16dNH11xzjTZv3qyhQ4c2yxjMWrp0qSZOnHjeC3yb+3x7+7cPF48W33G4FL6mOykpSRs2bNBnn32mq666qkH7tmnTRv3799fBgwd9NLrzCw4O1nXXXVfnGFra+T5y5Ig+/fRTPfLIIw3aryWc65pz1pDz2ZjfEV+qCQ1HjhxRZmZmvd2G2pzv5605XH311erUqVOdY2hp5/zvf/+78vPzG/wzL/n2fNf1t8/hcKiiokLFxcUe9ef7u15T4+0+8I0WHxwu5q/pNgxDSUlJWrt2rTZt2qTIyMgGH6Oqqkp79uxRWFiYD0bondLSUh06dKjOMbSU811j2bJlCgkJ0ciRIxu0X0s415GRkXI4HB7n0+VyaceOHXWez8b8jvhKTWg4cOCAPv30U3Xs2LHBxzjfz1tzOHbsmE6fPl3nGFrSOZf+3WEbMGCA+vbt2+B9fXG+z/e3b8CAAWrTpo3H+cvPz1dhYWGd568xvxvwkQt8caZXVq5caQQEBBjp6enGP/7xD+Oxxx4zgoODDafTaRiGYTzwwAPGzJkz3fWff/650bp1a+MPf/iD8fXXXxtz5swx2rRpY+zZs6dZxz1lyhTDbrcbmzdvNk6cOOFefvjhB3fNz8f+/PPPG5988olx6NAhIzc31xg/frwRGBho7Nu3r9nG/fTTTxubN282CgoKjM8//9yIjY01OnXqZJw8ebLWMbeU820Y/76yvUuXLsaMGTPO2dZSzvX3339vfPnll8aXX35pSDJee+0148svv3R/8uDll182goODjfXr1xtfffWVMWrUKCMyMtI4c+aM+xi/+MUvjDfffNP9+Hy/I80x9oqKCuOee+4xrrrqKiMvL8/jZ768vLzOsZ/v583X4/7++++N6dOnGzk5OUZBQYHx6aefGjfeeKPRvXt34+zZs3WOuznO+fl+VgzDMEpKSozLLrvMWLJkSa3HuBDn25u/fY8//rjRpUsXY9OmTcauXbuMmJgYIyYmxuM4PXr0MD744AP3Y29+N+B7F0VwMAzDePPNN40uXboY/v7+xk033WRs377dve322283EhISPOpXr15tXHfddYa/v79x/fXXGxs3bmzmEf/741O1LcuWLXPX/HzsU6dOdb/O0NBQ46677jJ2797drOMeN26cERYWZvj7+xtXXnmlMW7cOOPgwYN1jtkwWsb5NgzD+OSTTwxJRn5+/jnbWsq5/uyzz2r9uagZW3V1tTF79mwjNDTUCAgIMIYOHXrO6+natasxZ84cj3X1/Y40x9gLCgrq/Jn/7LPP6hz7+X7efD3uH374wRg2bJjRuXNno02bNkbXrl2NRx999JwAcCHO+fl+VgzDMP74xz8abdu2NYqLi2s9xoU439787Ttz5ozxxBNPGFdccYVx2WWXGaNHjzZOnDhxznF+uo83vxvwPb5WGwAAeK3FX+MAAABaDoIDAADwGsEBAAB4jeAAAAC8RnAAAABeIzgAAACvERwAAIDXCA4AAMBrBAcAAOA1ggMAAPAawQEAAHjt/wGy3aAwoXTXjAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "artist = ax.imshow(count_rate, cmap='gray', extent = scanner.get_completed_scan_range())\n", + "fig.colorbar(artist, ax=ax)" + ] + }, + { + "cell_type": "markdown", + "id": "2833b2ae", + "metadata": {}, + "source": [ + "# Now, we add a Hyper DAQ function\n", + "\n", + "A \"Hyper DAQ\" function allows a researcher to take data at each position \n", + "during a scan. For example, one may wish to measure the energy spectrum\n", + "of photons at each postion, creating a hyperspectral image of a sample. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "e2a64fc4", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "my_functions_data = []\n", + "\n", + "def my_function(scanner_object):\n", + " rand_data = np.random.random(100)\n", + " my_functions_data.append([scanner_object.get_current_position(), rand_data])\n", + " \n", + "\n", + "# Since this function does not touch any hardware\n", + "# used by the scanner, we can provide the attribute 'in_parallel' = True. \n", + "# With this setting, the scanner will run this function in a separate processing thread\n", + "# while it simultaneously acquires data from the RandomRateCounter\n", + "\n", + "# In real life, one can set the hyper DAQ function to 'in_parallel' if\n", + "# the function doesn't need to touch hardware used by the confocal scan\n", + "# For example, if a beamsplitter diverts light from a sample so that both\n", + "# a spectrometer and a photon counter receive signal, a spectrum and total\n", + "# count rate can be simultaneously generated.\n", + "\n", + "my_function.in_parallel = True" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5fd0a110", + "metadata": {}, + "outputs": [], + "source": [ + "scanner.set_hyper_data_acquisition_function(my_function)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "387f330c", + "metadata": {}, + "outputs": [], + "source": [ + "scanner.run_scan()\n", + "count_rate = scanner.get_count_rate()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "97721bf7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "artist = ax.imshow(count_rate, cmap='gray', extent = scanner.get_completed_scan_range())\n", + "fig.colorbar(artist, ax=ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "633002c8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1600\n" + ] + }, + { + "data": { + "text/plain": [ + "[[{'x': 0.0, 'y': 0, 'z': 15},\n", + " array([0.31452213, 0.35451581, 0.98887843, 0.72970574, 0.09544869,\n", + " 0.27399608, 0.50155377, 0.62806833, 0.47108881, 0.95060407,\n", + " 0.6806713 , 0.23337498, 0.4045021 , 0.3622902 , 0.41479225,\n", + " 0.5255417 , 0.87803697, 0.6299015 , 0.6965338 , 0.74122237,\n", + " 0.71905561, 0.21392037, 0.05950756, 0.36841156, 0.49753285,\n", + " 0.47952426, 0.6349023 , 0.82112918, 0.2256583 , 0.71479503,\n", + " 0.66250976, 0.72881137, 0.60264403, 0.56977916, 0.22136641,\n", + " 0.64898267, 0.469511 , 0.7731227 , 0.60596433, 0.03316667,\n", + " 0.03802478, 0.24201959, 0.07425821, 0.8163585 , 0.39698327,\n", + " 0.89983163, 0.36804661, 0.30183733, 0.03262771, 0.22796159,\n", + " 0.65103523, 0.01511088, 0.11394079, 0.6507492 , 0.33257084,\n", + " 0.76230229, 0.28549521, 0.04028606, 0.36139356, 0.889166 ,\n", + " 0.67783701, 0.17723507, 0.66518609, 0.86413806, 0.69168639,\n", + " 0.79187832, 0.91038901, 0.37228708, 0.48048336, 0.06371737,\n", + " 0.32302115, 0.90020679, 0.63158089, 0.52514972, 0.09317859,\n", + " 0.07671227, 0.63465768, 0.34138153, 0.0352425 , 0.79120745,\n", + " 0.24153934, 0.124083 , 0.23167348, 0.47569986, 0.56785272,\n", + " 0.03152147, 0.36377083, 0.93417836, 0.00308938, 0.41620902,\n", + " 0.96017147, 0.16941695, 0.49669156, 0.82004671, 0.80186092,\n", + " 0.34201109, 0.57538375, 0.04380919, 0.02887302, 0.83008538])],\n", + " [{'x': 0.5, 'y': 0, 'z': 15},\n", + " array([0.10085373, 0.89020433, 0.5020103 , 0.53321429, 0.23884737,\n", + " 0.29960896, 0.31844161, 0.28619061, 0.96430294, 0.65094684,\n", + " 0.26603207, 0.16313636, 0.88537496, 0.11665349, 0.97364149,\n", + " 0.61723051, 0.9398117 , 0.35017829, 0.81622657, 0.8920931 ,\n", + " 0.55439331, 0.52459943, 0.39685363, 0.05270687, 0.03925469,\n", + " 0.43077531, 0.8768004 , 0.02316975, 0.9256348 , 0.59286166,\n", + " 0.47081801, 0.16402066, 0.62219207, 0.82273861, 0.32413582,\n", + " 0.58188467, 0.83825695, 0.42092253, 0.259126 , 0.28883077,\n", + " 0.81819112, 0.7315914 , 0.80605162, 0.8917003 , 0.36769154,\n", + " 0.17781673, 0.14508092, 0.17201237, 0.15932898, 0.1188686 ,\n", + " 0.08635844, 0.02356635, 0.73712502, 0.44723345, 0.18381022,\n", + " 0.34972678, 0.74042979, 0.1642673 , 0.83526595, 0.59526604,\n", + " 0.48132073, 0.3847834 , 0.44966642, 0.49666464, 0.4391638 ,\n", + " 0.82255819, 0.54240792, 0.60437853, 0.60956808, 0.01505983,\n", + " 0.37089889, 0.83891886, 0.63227209, 0.81763654, 0.74363278,\n", + " 0.36110181, 0.10065781, 0.43005997, 0.13131226, 0.33426462,\n", + " 0.0632574 , 0.90965429, 0.72017657, 0.72449606, 0.10897441,\n", + " 0.26284905, 0.02511043, 0.97425685, 0.59179729, 0.67818428,\n", + " 0.23210561, 0.00960374, 0.50120222, 0.63960781, 0.14938292,\n", + " 0.30390049, 0.33734481, 0.06716696, 0.11262085, 0.23542495])]]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# During the scan, data was generated and stored into our array\n", + "print(len(my_functions_data))\n", + "my_functions_data[:2] #display the first two sets of data" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "9b211e7f", + "metadata": {}, + "outputs": [], + "source": [ + "# One could imagine extending the callback to an unlimited number of functions\n", + "# (Although, care should be taken to manage memory usage)\n", + "\n", + "other_data = []\n", + "shape, scale = 2., 2. # mean=4, std=2*sqrt(2)\n", + "\n", + "def my_other_function(scanner):\n", + " s = np.random.gamma(shape, scale, 1000)\n", + " other_data.append([scanner.get_current_position(), s])\n", + " \n", + "\n", + "def both_hyper_functions(scanner):\n", + " my_function(scanner)\n", + " my_other_function(scanner)\n", + " \n", + "both_hyper_functions.in_parallel = True" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "e8e5848c", + "metadata": {}, + "outputs": [], + "source": [ + "scanner.set_hyper_data_acquisition_function(both_hyper_functions)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "9aa29ed2", + "metadata": {}, + "outputs": [], + "source": [ + "scanner.run_scan()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "17324e75", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "artist = ax.imshow(scanner.get_count_rate(), cmap='gray', extent = scanner.get_completed_scan_range())\n", + "fig.colorbar(artist, ax=ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "03ff4c84", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import scipy.special as sps\n", + "\n", + "#randomly choose one of elements from other_data\n", + "\n", + "position, s = other_data[ np.random.choice(np.arange(len(other_data))) ]\n", + "\n", + "count, bins, ignored = plt.hist(s, 50, density=True)\n", + "y = bins**(shape-1)*(np.exp(-bins/scale) /\n", + " (sps.gamma(shape)*scale**shape))\n", + "plt.plot(bins, y, linewidth=2, color='r')\n", + "plt.title(position)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e221024a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index 74157e39..87eeba69 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,7 +10,7 @@ description = "A package for performing experiments in the QT3 lab at UW." readme = "README.md" requires-python = ">=3.8" license = {file = "LICENSE"} -keywords = ["qt3", "confocal scan", "nidaqmx", "piezo", "stage", "control", "electron spin control"] +keywords = ["qt3", "confocal scan", "nidaqmx", "electron spin control", "quantum computing", "nitrogen-vacancy center"] authors = [ {name = "G. Adam Cox", email = "gadamc@gmail.com" }, diff --git a/src/applications/piezoscan.py b/src/applications/piezoscan.py index 95b17795..d5bc5692 100644 --- a/src/applications/piezoscan.py +++ b/src/applications/piezoscan.py @@ -80,18 +80,18 @@ def __init__(self, mplcolormap = 'gray'): self.ax.set_ylabel('y position (um)') self.log_data = False - def update(self, model): + def update(self, scanner): if self.log_data: - data = np.log10(model.scanned_count_rate) + data = np.log10(scanner.get_count_rate()) data[np.isinf(data)] = 0 #protect against +-inf else: - data = model.scanned_count_rate + data = scanner.get_count_rate() - self.artist = self.ax.imshow(data, cmap=self.cmap, extent=[model.xmin, - model.xmax + model.step_size, - model.current_y + model.step_size, - model.ymin]) + self.artist = self.ax.imshow(data, cmap=self.cmap, extent=[scanner.xmin, + scanner.xmax + scanner.step_size, + scanner.get_current_position('y') + scanner.step_size, + scanner.ymin]) if self.cbar is None: self.cbar = self.fig.colorbar(self.artist, ax=self.ax) else: @@ -294,8 +294,8 @@ class MainTkApplication(): def __init__(self, counter_scanner): self.root = tk.Tk() self.counter_scanner = counter_scanner - scan_range = [counter_scanner.stage_controller.minimum_allowed_position, - counter_scanner.stage_controller.maximum_allowed_position] + scan_range = [counter_scanner.actuator_controller.minimum_allowed_position, + counter_scanner.actuator_controller.maximum_allowed_position] self.view = MainApplicationView(self.root, scan_range) self.view.sidepanel.startButton.bind("