diff --git a/notebooks/La2Ni7_HB1A_resolution.ipynb b/notebooks/La2Ni7_HB1A_resolution.ipynb new file mode 100644 index 00000000..12e190c8 --- /dev/null +++ b/notebooks/La2Ni7_HB1A_resolution.ipynb @@ -0,0 +1,300 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/x4l/Documents/TAVI/src/tavi/data/spice_reader.py:61: UserWarning: genfromtxt: Empty input file: \"../test_data/IPTS9879_HB1A_exp978/exp978/Datafiles/HB1A_exp0978_scan0035.dat\"\n", + " data = np.genfromtxt(file_name, comments=\"#\")\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from tavi.data.tavi import TAVI\n", + "from tavi.instrument.resolution.cooper_nathans import CN\n", + "from tavi.plotter import Plot2D\n", + "from tavi.sample.xtal import Xtal\n", + "\n", + "# load data\n", + "tavi = TAVI()\n", + "path_to_spice_folder = \"../test_data/IPTS9879_HB1A_exp978/exp978/\"\n", + "tavi.load_spice_data_from_disk(path_to_spice_folder)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/x4l/Documents/TAVI/src/tavi/data/scan_data.py:394: RuntimeWarning: invalid value encountered in divide\n", + " self.z = z / counts * norm_val\n", + "/home/x4l/Documents/TAVI/src/tavi/data/scan_data.py:395: RuntimeWarning: invalid value encountered in divide\n", + " self.err = np.sqrt(z) / counts * norm_val\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAGwCAYAAACpYG+ZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABnvElEQVR4nO39f1xUdd4//j/ODDAgwiQYvxRNjUzBLUMD1EJTQVPZrn5Yy16krYt20aakZJl1hXslbP5k07Ly6yUmGn13XcuyJfQqMVY0ZaU3omu1sYIJUoIghjPMmfP5g/XIAIPMnBlmhnncb7dzW+ac1+vMa54b45PXj/MSJEmSQEREROQGVI5uABEREVFvYeJDREREboOJDxEREbkNJj5ERETkNpj4EBERkdtg4kNERERug4kPERERuQ0PRzfAGRmNRly4cAF+fn4QBMHRzSEiIicmSRKuXLmCsLAwqFT260+4du0a9Hq94vt4eXnB29vbBi1yTUx8unDhwgWEh4c7uhlERORCqqurMXjwYLvc+9q1axjo44OrNrhXSEgIKisr3Tb5YeLTBT8/PwBt/xH7+/srutfkETMx7bF4HPxTEQyiiOJ/FdqiiX2CKIqoqKhAZGQk1Gq1o5vjVBgb8xgb8xibrtk7Lk1NTQgPD5f/7bAHvV6PqwB+p1ZBo+A+OgCba2uh1+uZ+NAN14e3/P39FSc+apUHNBpvqFUekIyC4vv1JaIoon///vD39+eXdAeMjXmMjXmMTdd6Ky69MTXCV5CgUfA+HtyliomPvam8tBBUXlB5aaFWiY5uDhERuTCVAKgV5Fdc0cTEx+48tcOh0vi3/a/B6OjmEBGRC/MQ2g6r69uuKS6LyZ+daYLGQO0TAE3QGGiC73J0c4iIiHrMYDDg5ZdfxrBhw+Dj44Phw4fj97//PYzGG3/IS5KEzMxMhIWFwcfHB5MnT0ZFRYXJfXQ6HZ599lkMHDgQvr6+SEpKwvnz503KNDQ0ICUlBVqtFlqtFikpKbh8+bJJmaqqKsyZMwe+vr4YOHAgFi9ebPFKNyY+duYZPBoqnwB4Bo+GZ0iko5tDREQuTC0oPyzx+uuv4+2338bmzZtx5swZrFmzBmvXrsWmTZvkMmvWrMGGDRuwefNmHD9+HCEhIZg+fTquXLkil0lPT8fevXuRn5+P4uJiNDc3Y/bs2RDFG1NAkpOTUVZWhoKCAhQUFKCsrAwpKSnydVEUMWvWLFy9ehXFxcXIz8/Hnj17sGzZMos+E3u97EwVGALBW4QqMASSkXkmERFZz5rkxaT+v/+3qanJ5LxGo4FG03m9WElJCX75y19i1qxZAIDbbrsN77//Pk6cOAGgrbcnJycHK1euxMMPPwwA2LFjB4KDg7F7924sWrQIjY2N2LZtG3bu3Ilp06YBAPLy8hAeHo6DBw8iMTERZ86cQUFBAY4ePYqYmBgAwNatWxEXF4ezZ89i5MiRKCwsxOnTp1FdXY2wsDAAwPr16zF//nysXr26x4uHmPh0Y9JtCVALloXIwyfI5PWtC3IB70tAYCAgqRF352L52rUf/25Vu05eKraqHhEREYBOz6p79dVXkZmZ2ancpEmT8Pbbb+Obb77BHXfcga+//hrFxcXIyckBAFRWVqK2thYJCQlyHY1Gg/j4eBw5cgSLFi1CaWkpWltbTcqEhYUhKioKR44cQWJiIkpKSqDVauWkBwBiY2Oh1Wpx5MgRjBw5EiUlJYiKipKTHgBITEyETqdDaWkppkyZ0qPPzsSnG8X/KlS8/HzmOj3gqYbk5w1JUqPkH2/YqHVERORu1IKksMenbTl7x+fUddXbAwAvvPACGhsbceedd0KtVkMURaxevRq/+tWvAAC1tbUAgODgYJN6wcHBOHfunFzGy8sLAwYM6FTmev3a2loEBZl2HABAUFCQSZmO7zNgwAB4eXnJZXqCiY+dCdcMgGiEcM0AQZJwo6ORiIjIMmqFq7qu/wvU0+fUffDBB8jLy8Pu3bsRGRmJsrIypKenIywsDPPmzZPLdXyGkSRJN32uUccyXZW3pszNcNKJnQkNTYBOD6GhCUJDo6ObQ0RE1GPPP/88XnzxRTzxxBMYM2YMUlJS8NxzzyE7OxtA2/YXADr1uNTV1cm9MyEhIdDr9WhoaOi2zMWLFzu9/48//mhSpuP7NDQ0oLW1tVNPUHeY+NiZsb4O0F2Dsb4Oxkt1jm4OERG5MLVK+WGJn3/+udPGq2q1Wl7OPmzYMISEhODAgQPydb1ej6KiIkyYMAEAEB0dDU9PT5MyNTU1OHXqlFwmLi4OjY2N+Oqrr+Qyx44dQ2Njo0mZU6dOoaamRi5TWFgIjUaD6OjoHn8mDnXZmf77IxCH+UP//Vm0rdqLcnSTiIjIRdlqVVdPzZkzB6tXr8aQIUMQGRmJkydPYsOGDfjNb34DoG3oKT09HVlZWYiIiEBERASysrLQr18/JCcnAwC0Wi0WLFiAZcuWITAwEAEBAcjIyMCYMWPkVV6jRo3CjBkzkJqainfeeQcAsHDhQsyePRsjR44EACQkJGD06NFISUnB2rVrUV9fj4yMDKSmplo0H5eJj501f/8pWsdNQPP3RyAaRABPO7pJREREPbJp0ya88sorSEtLQ11dHcLCwrBo0SL893//t1xm+fLlaGlpQVpaGhoaGhATE4PCwkKTTVs3btwIDw8PzJ07Fy0tLZg6dSpyc3NN9k7btWsXFi9eLK/+SkpKwubNm+XrarUa+/fvR1paGiZOnAgfHx8kJydj3bp1Fn0mhyY+hw8fxtq1a1FaWoqamhrs3bsXDz30kHzd3GSlNWvW4Pnnn+/yWm5uLp566qlO51taWhyyE61R3wjJqIdR3/jvxIeIiMg6vd3j4+fnh5ycHHn5elcEQUBmZmaXy+Gv8/b2xqZNm0wefNhRQEAA8vLyum3PkCFD8Mknn9ys2d1yaOJz9epV3HXXXXjqqafwyCOPdLrefhwPAP76179iwYIFXZZtz9/fH2fPnjU554ikh4iIyJZ6O/Hpixya+MycORMzZ840e/36bPHrPvroI0yZMgXDhw/v9r6CIHSq2x2dTgedTie/vv5ES1EUTR6nbQ21hxqCSoDaQy3fk9qIoghJkhiTLjA25jE25jE2XbN3XHoz3mqVwsRHsl1bXJXLzPG5ePEi9u/fjx07dty0bHNzM4YOHQpRFHH33Xfjf/7nfzB27Fiz5bOzs7Fq1apO5ysqKtC/f39F7U58YgrCbx+ExCemwGiUUF5eruh+fYkkSaivr0dFRYVFz2BwB4yNeYyNeYxN1+wdl+bmZpvfk+zHZRKfHTt2wM/PT94LxJw777wTubm5GDNmDJqamvDHP/4REydOxNdff42IiIgu66xYsQJLly6VXzc1NSE8PByRkZGKn9z8dP5SJDwxBYX5X0A0iMhct1LR/foSURRRUVGByMhIkwluxNh0h7Exj7Hpmr3j0nHfK3tSQVmPj4o9Pq6T+Pzv//4vfv3rX990rk5sbCxiY2Pl1xMnTsQ999yDTZs24Y03ut4uwtzmbGq1WvEviWgQIRkliAYRBoPIL6MOBEGwSZz7IsbGPMbGPMama/aMS2/GWvEcH3YEukbi8+WXX+Ls2bP44IMPLK6rUqkwfvx4fPvtt3ZoGREREbkSl3hy87Zt2xAdHY277rrL4rqSJKGsrAyhoaF2aBkREVHvUamUH+7OoT0+zc3N+O677+TXlZWVKCsrQ0BAAIYMGQKgbez0T3/6E9avX9/lPZ588kkMGjRI3jdk1apViI2NRUREBJqamvDGG2+grKwMb775pv0/EBERkR1xqEs5hyY+J06cwJQpU+TX1ycYz5s3D7m5uQCA/Px8SJKEX/3qV13eo6qqymQfkcuXL2PhwoWora2FVqvF2LFjcfjwYdx77732+yBERETkEhya+EyePBmS1P0U84ULF2LhwoVmrx86dMjk9caNG7Fx40ZbNI+IiMipsMdHOZeY3ExERETW7bBuUt92TXFZnOZEREREboM9Pt2YdFsC1IKyEHl4mObXYwMnWXWfk5eKFbWDiIhcn0poO5TUd3dMfLpR/K9CxU9uHh8cb/KaCQwREVlLpRKgVpC9tA3zuPfjm5n4EBERuQj2+CjHOT5ERETkNtjjQ0RE5CK4qks5Jj5EREQugkNdynGoi4iIiNwGe3yIiIhcBIe6lGPiQ0RE5CJUggCVkuXsEuDuy9k51EVERERugz0+RERELoKTm5Vj4kNEROQiFM/xce9RLgAc6iIiIiI3wh4fIiIiFyGolE1uFtjjw8SHiIjIVXCOj3JMfIiIiFyEStV2WF2fPT5MfOzNUzsCai9/eGpHQGUwOro5REREbo2Jj535hN4Lta8/fELvhSg6ujVEROTKVArn+LDHh4mP3XkNnwC1/yV4DY+CaOQiOiIish6HupRj4mNnwrDhgF8rhGHDIUjcJYWIiMiRmPj00NjAST0q59k/3OS1/8o8GPupoQ/xgQg1xg9+WL5maKnr8fufvFTc47JERNQ3scdHOSY+PWRt4hHzl6vQCyKuaK5BhBonzv/Fxi0jIiJ3wTk+ynHSiZ35X/SGV4sa/he94X/R29HNISIi6rHbbrsNgiB0Op555hkAgCRJyMzMRFhYGHx8fDB58mRUVFSY3EOn0+HZZ5/FwIED4evri6SkJJw/f96kTENDA1JSUqDVaqHVapGSkoLLly+blKmqqsKcOXPg6+uLgQMHYvHixdDr9RZ/JiY+duZZexWqnw3wrL0Kz5qrjm4OERG5MJVwY7jLqsPCzqLjx4+jpqZGPg4cOAAAeOyxxwAAa9aswYYNG7B582YcP34cISEhmD59Oq5cuSLfIz09HXv37kV+fj6Ki4vR3NyM2bNnQ2y31Dk5ORllZWUoKChAQUEBysrKkJKSIl8XRRGzZs3C1atXUVxcjPz8fOzZswfLli2zOIYc6rKzhrz/gu6Re9CwZyNEgxH4/fuObhIREbkoxUNdFnZ33HrrrSav//CHP2DEiBGIj4+HJEnIycnBypUr8fDDbfNXd+zYgeDgYOzevRuLFi1CY2Mjtm3bhp07d2LatGkAgLy8PISHh+PgwYNITEzEmTNnUFBQgKNHjyImJgYAsHXrVsTFxeHs2bMYOXIkCgsLcfr0aVRXVyMsLAwAsH79esyfPx+rV6+Gv79/z2NgWQjIUobm8zC2XoWh+Txam6sd3RwiIiI0NTWZHDqd7qZ19Ho98vLy8Jvf/AaCIKCyshK1tbVISEiQy2g0GsTHx+PIkSMAgNLSUrS2tpqUCQsLQ1RUlFympKQEWq1WTnoAIDY2Flqt1qRMVFSUnPQAQGJiInQ6HUpLSy367Ex8iIiIXISgZJhL1VYfAMLDw+X5NFqtFtnZ2Td97w8//BCXL1/G/PnzAQC1tbUAgODgYJNywcHB8rXa2lp4eXlhwIAB3ZYJCgrq9H5BQUEmZTq+z4ABA+Dl5SWX6SkOdREREbkIQSVAULI7+78Tn+rqapPhIY1Gc9O627Ztw8yZM016XQBAEEzbI0lSp3MddSzTVXlryvQEe3yIiIhchKKJze2eAeTv729y3CzxOXfuHA4ePIjf/va38rmQkBAA6NTjUldXJ/fOhISEQK/Xo6GhodsyFy9e7PSeP/74o0mZju/T0NCA1tbWTj1BN8PEh4iIiLq1fft2BAUFYdasWfK5YcOGISQkRF7pBbTNAyoqKsKECRMAANHR0fD09DQpU1NTg1OnTsll4uLi0NjYiK+++kouc+zYMTQ2NpqUOXXqFGpqauQyhYWF0Gg0iI6OtuizcKiLiIjIRfT2qi4AMBqN2L59O+bNmwcPjxtpgyAISE9PR1ZWFiIiIhAREYGsrCz069cPycnJAACtVosFCxZg2bJlCAwMREBAADIyMjBmzBh5ldeoUaMwY8YMpKam4p133gEALFy4ELNnz8bIkSMBAAkJCRg9ejRSUlKwdu1a1NfXIyMjA6mpqRat6AKY+BAREbkMW83xscTBgwdRVVWF3/zmN52uLV++HC0tLUhLS0NDQwNiYmJQWFgIPz8/uczGjRvh4eGBuXPnoqWlBVOnTkVubi7U6hv7V+7atQuLFy+WV38lJSVh8+bN8nW1Wo39+/cjLS0NEydOhI+PD5KTk7Fu3TqLPw8THyIiIjIrISEBktT1XheCICAzMxOZmZlm63t7e2PTpk3YtGmT2TIBAQHIy8vrth1DhgzBJ5980qM2d4eJDxERua2OG1A7+4bQijcp5cxeJj5EROQabJWkdLyPK3HEUFdfw8SHiIhcUvsExtokyNl7eMj2HJr7HT58GHPmzEFYWBgEQcCHH35ocn3+/PmddoSNjY296X337NmD0aNHQ6PRYPTo0di7d6+dPgEREfWWk5eKTY72xgZOMjn6KpUgyCu7rDosfNhfX+TQxOfq1au46667TGZudzRjxgyTnWE//fTTbu9ZUlKCxx9/HCkpKfj666+RkpKCuXPn4tixY7ZuPhEROZC5JKij2LAHsGfHPsSGPeDySZGgUn64O4cOdc2cORMzZ87stoxGo5GfDtkTOTk5mD59OlasWAEAWLFiBYqKipCTk4P33+fO6EREfVFXPUDXeXiouy1L7sXp5/gcOnQIQUFBuOWWWxAfH4/Vq1d3uZnZdSUlJXjuuedMziUmJiInJ8dsHZ1OZ7IzbVNTEwBAFEWIogig7S8Ga6g91BBUAtT//sUbHxxv1X2OXvjcqnrOTBRFSJIkx5huYGzMY2zMY2xuOFFXJP88cch0k+9hW8enN+OtUgtQqRU8wNBow8a4KKdOfGbOnInHHnsMQ4cORWVlJV555RU88MADKC0tNbuvSFc7uLbfBbYr2dnZWLVqVafzFRUV6N+/PwBg62d/tOoz7N35McJvH4TEJ6bAaJTwyLwkq+5TXl5uVT1nJkkS6uvrUVFRYfEmc30dY2MeY2MeY3PDnh375J8Tn5hi8j2cmbFavmbtd3J7zc3Niu/RU1zVpZxTJz6PP/64/HNUVBTGjRuHoUOHYv/+/Xj44YfN1rN0p9gVK1Zg6dKl8uumpiaEh4cjMjLS4kdhd/R0/lIkPDEFhflfQDSIyFy3UtH9+hJRFFFRUYHIyEiTJ3gSY9MdxsY8xuaG1N1L5J//Vn0AFRUVeHLBf0KtVpv04Bfs/j+Tetb0rl8fJegNglqAoKDHR2CPj3MnPh2FhoZi6NCh+Pbbb82W6WoH1/a7wHZFo9F02YOkVqsVf3mIBhGSUYJoEGEwiG7/ZdSRIAg2iXNfxNiYx9iYx9i0MRhuDD+p1WqTuBy/eGMYrONk53FBN6Yj9HQukLvH2tW4VOJz6dIlVFdXIzQ01GyZuLg4HDhwwGSeT2FhobzDKxER9T3WrtbqblK0U1I41OXYtdzOwaGJT3NzM7777jv5dWVlJcrKyhAQEICAgABkZmbikUceQWhoKP71r3/hpZdewsCBA/Ef//Efcp0nn3wSgwYNQnZ2NgBgyZIluP/++/H666/jl7/8JT766CMcPHgQxcWcxU9E5C7aJzSWTD5uX88Zt7Pg5GblHJr4nDhxAlOmTJFfX59nM2/ePGzZsgXl5eV47733cPnyZYSGhmLKlCn44IMPTHZ9raqqgqrd5iMTJkxAfn4+Xn75ZbzyyisYMWIEPvjgA8TExPTeB2tHUHtDENQQ1N5QSVxpQUTkKpwh0SHbc2jiM3nyZLM7vgLAZ599dtN7HDp0qNO5Rx99FI8++qiSptmMJF6DJImQxGswcokpEZFduEuSwsnNyrnUHB8iIiJ3JghQtpxdMN/Z4C44zYmIiIjcBnt8iIiIXITioS4FdfsKJj5EREQugomPchzqIiIiIrfBHh8iInJbzvisnu4IahUEtfV9FgIfMs3Eh4iIyFVwqEs5Jj5EROQSbNU74/TbUnSDiY9yTHzszFM7Amovf3hqR0Bl4JOjiIis1d2+WtYmQc4+tEW2x8THzrQT0+EVegnaiQ9ANHIuORGRPVjSG+Slvd3ezbEbQaWwx0fJBqd9BBMfOzs3byDubrmKc3cPhEFg4kNEZCvdbSja/vXAcb9D/P2eeP6Ff0AUAc3AqF5ro61xcrNyTHzs7M6Yd3DLmXDcOaoAoloC8HtHN4mIqM/p2MMTHTRN/ll9yyAImqtQ3+ILGAV8fvCJ3m4eOREmPj3U08lwvuHTTV7/9ngx+gmTEexRDKhFxAyfL1/TN37X4/fnODQRUc+V1h2Uf35w0VkIXrVQ3RIEycWnHHBys3JMfHrI2sSjqDEWPxsMCP75KgS1iGPf59q2YURE1MmMFxrkn1WeXoBKDXh6AUYVYiMWydeOfvuOI5pnPbXQdiip7+aY+NjZPt/RuN1zAL7zHQ1JbcT9jm4QEZEbkC7fSHw+fmsoyssb8cJ/DYFarcbYwAr5mqs9wJCUY+JjZx+efAGPXK7FhydnwiCosGGco1tERNT3ibX/bPdqqMm17iZFOzsOdSnHxMfORrz2HfzjjBhR0gxRFIBPIhzdJCKiPmdCZIbJ6yMV6+SfRVE0W88ezwayJ67qUo6Jj51dPv4G9CPux+XjhyEaRAAPOrpJRER9TkvtUZvfk8NgfRMTHzuTxGuQJBGSeA3Gbv7qICIix3P65EalcHIzH2DIxIeIiFyTsw9L2QPn+Cjn2g80ICIit3XyUrF8uA21AKhVCg7LE58ffvgB//mf/4nAwED069cPd999N0pLS+XrkiQhMzMTYWFh8PHxweTJk1FRUWFyD51Oh2effRYDBw6Er68vkpKScP78eZMyDQ0NSElJgVarhVarRUpKCi5fvmxSpqqqCnPmzIGvry8GDhyIxYsXQ6/XW/R5mPgQERFRlxoaGjBx4kR4enrir3/9K06fPo3169fjlltukcusWbMGGzZswObNm3H8+HGEhIRg+vTpuHLlilwmPT0de/fuRX5+PoqLi9Hc3IzZs2ebTDxPTk5GWVkZCgoKUFBQgLKyMqSkpMjXRVHErFmzcPXqVRQXFyM/Px979uzBsmXLLPpMHOoiIiJyEb091PX6668jPDwc27dvl8/ddttt8s+SJCEnJwcrV67Eww8/DADYsWMHgoODsXv3bixatAiNjY3Ytm0bdu7ciWnT2rYSycvLQ3h4OA4ePIjExEScOXMGBQUFOHr0KGJiYgAAW7duRVxcHM6ePYuRI0eisLAQp0+fRnV1NcLCwgAA69evx/z587F69Wr4+/v36DOxx4eIiMhVXH9ys5IDQFNTk8mh0+m6fLt9+/Zh3LhxeOyxxxAUFISxY8di69at8vXKykrU1tYiISFBPqfRaBAfH48jR44AAEpLS9Ha2mpSJiwsDFFRUXKZkpISaLVaOekBgNjYWGi1WpMyUVFRctIDAImJidDpdCZDbzfDxIeIiMjNhIeHy3NptFotsrOzuyz3/fffY8uWLYiIiMBnn32Gp59+GosXL8Z7770HAKitrQUABAcHm9QLDg6Wr9XW1sLLywsDBgzotkxQUFCn9w8KCjIp0/F9BgwYAC8vL7lMT3Coi4iI3FZ3T252xknTyh9gKAEAqqurTYaGNBpNl+WNRiPGjRuHrKwsAMDYsWNRUVGBLVu24Mknn7xxX8F0CE2SpE7nOupYpqvy1pS5Gfb4EBER/ZvTrxRTKRzm+vdzfPz9/U0Oc4lPaGgoRo8ebXJu1KhRqKqqAgCEhIQAQKcel7q6Orl3JiQkBHq9Hg0NDd2WuXjxYqf3//HHH03KdHyfhoYGtLa2duoJ6g4THyIicgljAyeZPcg+Jk6ciLNnz5qc++abbzB0aNv+Z8OGDUNISAgOHDggX9fr9SgqKsKECRMAANHR0fD09DQpU1NTg1OnTsll4uLi0NjYiK+++kouc+zYMTQ2NpqUOXXqFGpqauQyhYWF0Gg0iI6O7vFn4lAXERG5hO721bKESz/4sN0EZavrW+C5557DhAkTkJWVhblz5+Krr77Cu+++i3fffRdA29BTeno6srKyEBERgYiICGRlZaFfv35ITk4GAGi1WixYsADLli1DYGAgAgICkJGRgTFjxsirvEaNGoUZM2YgNTUV77zzDgBg4cKFmD17NkaOHAkASEhIwOjRo5GSkoK1a9eivr4eGRkZSE1N7fGKLoCJDxER9QFus69WLyc+48ePx969e7FixQr8/ve/x7Bhw5CTk4Nf//rXcpnly5ejpaUFaWlpaGhoQExMDAoLC+Hn5yeX2bhxIzw8PDB37ly0tLRg6tSpyM3NhVp9Y9fUXbt2YfHixfLqr6SkJGzevPlG09Vq7N+/H2lpaZg4cSJ8fHyQnJyMdetubEjbE0x8iIjIJbVPbjomPu1fe3ioMSN5KlJ3L4HBwD0TLTV79mzMnj3b7HVBEJCZmYnMzEyzZby9vbFp0yZs2rTJbJmAgADk5eV125YhQ4bgk08+uWmbu8PEh4iIXJ4lw2Au3RukEpRtNMpNSpn49JS1Y8keHmqT1z29j0v/YhIROVj779DxwfEObImNXd9zy+r6ku3a4qKY+PSQtYlIx184JjRERPbXcajL3DWX+07u5Tk+fRGXsxMRUZ929MLneGReEo5e+Nz1Eh2yOfb4EBGRW+luUrTTJ0YqhT0+nOPDxIeIiFxfdwmMKPZ8JZfTD4NxqEsxJj5EROS2bPVQRHIdDp3jc/jwYcyZMwdhYWEQBAEffvihfK21tRUvvPACxowZA19fX4SFheHJJ5/EhQsXur1nbm4uBEHodFy7ds3On4aIiHqTPbascIm9upQebs6hPT5Xr17FXXfdhaeeegqPPPKIybWff/4Zf//73/HKK6/grrvuQkNDA9LT05GUlIQTJ050e19/f/9Oe4t4e3vbvP1EROQcnDZRsTFJLUBSMFylpG5f4dDEZ+bMmZg5c2aX17RarcmGZgCwadMm3HvvvaiqqsKQIUPM3lcQBHnHWCIi6pvcJdkh23KpOT6NjY0QBAG33HJLt+Wam5sxdOhQiKKIu+++G//zP/+DsWPHmi2v0+mg0+nk101NTQDaJsRZMimuK2oPNQSVAPW/nyOh9H59iSiKkCSJMekCY2MeY2MeY9M1e8elV+PNJzcr5jKJz7Vr1/Diiy8iOTm5211Y77zzTuTm5mLMmDFoamrCH//4R0ycOBFff/01IiIiuqyTnZ2NVatWdTpfUVGB/v37K2p34hNTEH77ICQ+MQVGo4Ty8nJF9+tLJElCfX09KioqIAj8ZWyPsTGPsTGPsemavePS3Nxs83uaw6Eu5QRJkpzi+dWCIGDv3r146KGHOl1rbW3FY489hqqqKhw6dMii7eeNRiPuuece3H///XjjjTe6LNNVj094eDjq6+steq+uTBwyHQlPTEFh/hcQDSKOXvhc0f36ElEUUVFRgcjISJMdeomx6Q5jYx5j0zV7x6WpqQkBAQFobGxU/G9Gd++h1WpR/340/PtZ/xmafhYR8KtSu7bV2Tl9j09rayvmzp2LyspKfP755xb/H6VSqTB+/Hh8++23ZstoNBpoNJpO59VqteJfEtEgQjJKEA0iDAaRX0YdCIJgkzj3RYyNeYyNeYxN1+wZl16NtQrK1mNzvwbnTnyuJz3ffvstvvjiCwQGBlp8D0mSUFZWhjFjxtihhURE1Jc4+wMMJbWy4SqJ+bBjE5/m5mZ899138uvKykqUlZUhICAAYWFhePTRR/H3v/8dn3zyCURRRG1tLQAgICAAXl5eAIAnn3wSgwYNQnZ2NgBg1apViI2NRUREBJqamvDGG2+grKwMb775Zu9/QCIicmout2WFoHByM+d+OTbxOXHiBKZMmSK/Xrp0KQBg3rx5yMzMxL59+wAAd999t0m9L774ApMnTwYAVFVVQaW60Xd3+fJlLFy4ELW1tdBqtRg7diwOHz6Me++9174fhoiIepWz986Qc3Jo4jN58mR0N7e6J/OuDx06ZPJ648aN2Lhxo9Km2YyndgTUXv7w1I6AymB0dHOIiNyeK29LIakESAp6fJTU7Suceo5PXzDg0XXwuu07DHj0SYgcXCUishlrd1lXqW88yb+07qDtG2ZHkqrtUFLf3THxsbO7f78YA0/dg7t/8wYktRHAbkc3iYioz2ufCPkPS8DUmYOw5Lf7IBokeGpHOLBl5GhMfOwsPfkzfD9+IP4j6zOojK3Anx3dIiKivqe7XdY9/AdB8PJt+18RKC57tbebZzPs8VGOiY8VuhsfHjhtncnrRz9vgn+oHmWfNwGtrciLzpavNf9rv9n7cKIeEZH12n+HJsz5CIIHoPb1AUTXnuPCJzcrx8THCpYkJS/3U2GoQUD1zypIrSp8Wbqi3dUVZusREZH1pj98SP7ZePUnSAZfiFevQhSB6KBp8jVXm+NDyjHxsbPMNXfg1IBb8NSoO6CGwdHNISJyC4aGavnngwfno7y8HC+9NAZqtRpjA7c7sGXKcKhLOSY+djbivvfw2KVL+FPUXBhUKvzg6AYREfVBMcPnm7z29B9mtqy1q8GcARMf5Zj42NmIZ4qgnRaAEQdPQRQBlHDrDCIiW9M3fmfy+tj3ufLPoij2+D58KGLfx8THznSXzkC8Nrrtf/kAQyIip9LdajBnxB4f5Zj42JlR3wTJqIdR3wQjEx8iIpuxR++Ms/fyGAXAqCB5MXJRFxMfezPqr0ASW2HUX4HR0PPuViIioo7Y46McEx87k0QdIImQRB0kC8aZiYioe87eO0POiYmPnUniNUiSCEm8BiMTHyIiUsCoUjjUxR4fJj5ERESugkNdyjHxISIi+jcuZ+/7mPgQERG5CEnhUBd7fACGgIiI3NbYwEkmh7OTVJLiwxKZmZkQBMHkCAkJudEeSUJmZibCwsLg4+ODyZMno6KiwuQeOp0Ozz77LAYOHAhfX18kJSXh/PnzJmUaGhqQkpICrVYLrVaLlJQUXL582aRMVVUV5syZA19fXwwcOBCLFy+GXq+3LIBg4kNERC7KHgnLyUvF8kFtIiMjUVNTIx/l5eXytTVr1mDDhg3YvHkzjh8/jpCQEEyfPh1XrlyRy6Snp2Pv3r3Iz89HcXExmpubMXv2bJMnaicnJ6OsrAwFBQUoKChAWVkZUlJS5OuiKGLWrFm4evUqiouLkZ+fjz179mDZsmUWfx4OdRERkctztT23rOWIVV0eHh4mvTzXSZKEnJwcrFy5Eg8//DAAYMeOHQgODsbu3buxaNEiNDY2Ytu2bdi5cyemTZsGAMjLy0N4eDgOHjyIxMREnDlzBgUFBTh69ChiYmIAAFu3bkVcXBzOnj2LkSNHorCwEKdPn0Z1dTXCwsIAAOvXr8f8+fOxevVq+Pv79/jzsMeHiIhckrW9M+17itrfwxWSpeuJj5IDAJqamkwOnU5n9j2//fZbhIWFYdiwYXjiiSfw/fffAwAqKytRW1uLhIQEuaxGo0F8fDyOHDkCACgtLUVra6tJmbCwMERFRcllSkpKoNVq5aQHAGJjY6HVak3KREVFyUkPACQmJkKn06G0tNSiGDLxISKiPseV5u1YwqiSFB8AEB4eLs+n0Wq1yM7O7vL9YmJi8N577+Gzzz7D1q1bUVtbiwkTJuDSpUuora0FAAQHB5vUCQ4Olq/V1tbCy8sLAwYM6LZMUFBQp/cOCgoyKdPxfQYMGAAvLy+5TE9xqIuIiFxed5uNxoY9gBnJU5G6ewkMBtElenbsrbq62mR4SKPRdFlu5syZ8s9jxoxBXFwcRowYgR07diA2NhYAIAimG4BJktTpXEcdy3RV3poyPcHExwqW/AXh4aG2qi5/MYmIrNf+O3R8cLwDW2Jbttqk1N/f36J5Mdf5+vpizJgx+Pbbb/HQQw8BaOuNCQ0NlcvU1dXJvTMhISHQ6/VoaGgw6fWpq6vDhAkT5DIXL17s9F4//vijyX2OHTtmcr2hoQGtra2deoJuhomPFSxJSjr+wjGhISKyv/Z/ZHb3B6irfSe3H66ytr4SOp0OZ86cwX333Ydhw4YhJCQEBw4cwNixYwEAer0eRUVFeP311wEA0dHR8PT0xIEDBzB37lwAQE1NDU6dOoU1a9YAAOLi4tDY2IivvvoK9957LwDg2LFjaGxslJOjuLg4rF69GjU1NXKSVVhYCI1Gg+joaIs+AxMfIiLq045e+Bzl5eXIXLcSarW6z837saeMjAzMmTMHQ4YMQV1dHV577TU0NTVh3rx5EAQB6enpyMrKQkREBCIiIpCVlYV+/fohOTkZAKDVarFgwQIsW7YMgYGBCAgIQEZGBsaMGSOv8ho1ahRmzJiB1NRUvPPOOwCAhQsXYvbs2Rg5ciQAICEhAaNHj0ZKSgrWrl2L+vp6ZGRkIDU11eKeKyY+RETk8qxNZlxtGXxvL2c/f/48fvWrX+Gnn37CrbfeitjYWBw9ehRDhw4FACxfvhwtLS1IS0tDQ0MDYmJiUFhYCD8/P/keGzduhIeHB+bOnYuWlhZMnToVubm5UKtv9MTt2rULixcvlld/JSUlYfPmzfJ1tVqN/fv3Iy0tDRMnToSPjw+Sk5Oxbt06i2PAxIeIiPqc9glM+wfldbzmar0/RuHGPB1r61siPz+/2+uCICAzMxOZmZlmy3h7e2PTpk3YtGmT2TIBAQHIy8vr9r2GDBmCTz75pNsyPcHEh4iIXJItkpbuVoM5e+8PWYeJDxERuTxbJSnOnuy0DXUpmdxsw8a4KCY+RERELoK7syvHxIeIiFyCq01EJufExIeIiFwCEx3AKEgwCgqGuhTU7SuY+BAREbkIUdV2KKnv7pj4EBERuYjefo5PX8TEh4iIqAucU9Q3MfEhIiL6N2d/jg/n+CjHxIeIiMhFcI6Pckx8iIjIJdmid4bDWe6HiQ8REbk8d0lgjFC4V5fNWuK6HNrpdfjwYcyZMwdhYWEQBAEffvihyXVJkpCZmYmwsDD4+Phg8uTJqKiouOl99+zZg9GjR0Oj0WD06NHYu3evnT4BERE5yslLxfJhibGBk+Sj/T1cIVkyqm4Md1lzcFWXgxOfq1ev4q677jLZer69NWvWYMOGDdi8eTOOHz+OkJAQTJ8+HVeuXDF7z5KSEjz++ONISUnB119/jZSUFMydOxfHjh2z18cgIiIH65jAtE9uOvLwCZIPcj8OHeqaOXMmZs6c2eU1SZKQk5ODlStX4uGHHwYA7NixA8HBwdi9ezcWLVrUZb2cnBxMnz4dK1asAACsWLECRUVFyMnJwfvvv99lHZ1OB51OJ79uamoCAIiiCFEUrf58AOCh8YVK5QEPjS8EtfL79SWiKEKSJMakC4yNeYyNeYzNDR4eavnnabGvYsqMIXgu9c8QRQlHz/1JvmaLWPVmvI2CwqEuBXX7Cqed41NZWYna2lokJCTI5zQaDeLj43HkyBGziU9JSQmee+45k3OJiYnIyckx+17Z2dlYtWpVp/MVFRXo379/p/N7duzr4acAEuZOQviIUCTMnQTJKCEzY3WP6j0yL6nH7+GqJElCfX09KioqIAj8bWyPsTGPsTGPsblh62d/lH/+ZN8phA3SYOqcfpCMQHl5uU3fq7m52ab3644otB1K6rs7p018amtrAQDBwcEm54ODg3Hu3Llu63VV5/r9urJixQosXbpUft3U1ITw8HBERkbC39+/U/kx68b06DMAwKRhc5Dw2CQU/qkYokFESfWnPa7b14miiIqKCkRGRkKtVt+8ghthbMxjbMxjbG6YHv+m/LPY/C88MOt2fL7/O4gGI/Zt2SpfO3rhc8XvdX2UgFyD0yY+13X8q0WSpJv+JWNpHY1GA41G0+m8Wq1W/OVh0F2F0WiAQXcVBoPo9l9GHQmCYJM490WMjXmMjXmMTZuWn76Tfy6u2Ijy8nK8/PtFUKvVJvN+bBGn3ow1t6xQzmkTn5CQEABtPTihoaHy+bq6uk49Oh3rdezduVkdIiJybR0nMfd04rKrLYPnUJdyTpv7DRs2DCEhIThw4IB8Tq/Xo6ioCBMmTDBbLy4uzqQOABQWFnZbh4iI+pbj5/8iHx250vL1jq5PblZyuDuH9vg0Nzfju+9udEdWVlairKwMAQEBGDJkCNLT05GVlYWIiAhEREQgKysL/fr1Q3JyslznySefxKBBg5CdnQ0AWLJkCe6//368/vrr+OUvf4mPPvoIBw8eRHGx6/0HTkRE5nW1VJ3oZhya+Jw4cQJTpkyRX1+fYDxv3jzk5uZi+fLlaGlpQVpaGhoaGhATE4PCwkL4+fnJdaqqqqBS3ei4mjBhAvLz8/Hyyy/jlVdewYgRI/DBBx8gJiam9z4YERH1Kmt7b1yt10cUBIgKVuwpqdtXODTxmTx5MiTJ/E6xgiAgMzMTmZmZZsscOnSo07lHH30Ujz76qA1aSEREzsLV5uPYA5/jo5zTzvEhIiIisjWnXdVFRETUnjv28HRkVDjUZeRQFxMfIiIiV8Hl7MpxqIuIiIjcBnt8iIiIuuCMk6nbJjcrGeqyYWNcFBMfIiIiF8Hl7Mox8SEiIvq39r08ztDDQ7bHxIeIiFxSd09u7mnS4mpPfxYhQISCHh8FdfuKHic+b7zxRo9vunjxYqsaQ0RE1FPtkxtbJTDO3stjFASFc3yY+PQ48dm4cWOPygmCwMSHiIgcqn0idKKuyOw1VyNCBVHBgmwldfuKHic+lZWV9mwHERGR1Tr21PQ0uXH2Hh6yPavm+FzfTLQnNmzYYM1bEBER2URs2AOYkTwVqbuXwGAQXTrZcfSTm7Ozs/HSSy9hyZIlyMnJAQBIkoRVq1bh3XfflTcUf/PNNxEZGSnX0+l0yMjIwPvvv4+WlhZMnToVb731FgYPHiyXaWhowOLFi7Fv3z4AQFJSEjZt2oRbbrlFLlNVVYVnnnkGn3/+OXx8fJCcnIx169bBy8urx5/BqsTn5MmTKC0thSiKGDlyJADgm2++gVqtxj333COXE/roWKIl3aQeHuoe13XlX0YiImfS/vt0fHC8A1tiW0aoYFQwXKWk7vHjx/Huu+/iF7/4hcn5NWvWYMOGDcjNzcUdd9yB1157DdOnT8fZs2fh5+cHAEhPT8fHH3+M/Px8BAYGYtmyZZg9ezZKS0uhVrf9O5mcnIzz58+joKAAALBw4UKkpKTg448/BgCIoohZs2bh1ltvRXFxMS5duoR58+ZBkiRs2rSpx5/DqsRnzpw58PPzw44dOzBgwAAAbZnaU089hfvuuw/Lli2z5rYuw5IEpeMvHJMbIiL7a/9HZsc/QMlyzc3N+PWvf42tW7fitddek89LkoScnBysXLkSDz/8MABgx44dCA4Oxu7du7Fo0SI0NjZi27Zt2LlzJ6ZNmwYAyMvLQ3h4OA4ePIjExEScOXMGBQUFOHr0KGJiYgAAW7duRVxcHM6ePYuRI0eisLAQp0+fRnV1NcLCwgAA69evx/z587F69Wr4+/v36LNYlfqtX78e2dnZctIDAAMGDMBrr72G9evXW3NLIiIiuzh64XM8Mi8JRy98jpOXijE2cJJ8uJrrDzBUcgBAU1OTyaHT6bp932eeeQazZs2SE5frKisrUVtbi4SEBPmcRqNBfHw8jhw5AgAoLS1Fa2urSZmwsDBERUXJZUpKSqDVauWkBwBiY2Oh1WpNykRFRclJDwAkJiZCp9OhtLS0xzG0qsenqakJFy9eNBm/A4C6ujpcuXLFmlsSERFZrbvtJURR7O3m2I2tVnWFh4ebnH/11VeRmZnZZZ38/Hz8/e9/x/Hjxztdq62tBQAEBwebnA8ODsa5c+fkMl5eXiadJdfLXK9fW1uLoKCgTvcPCgoyKdPxfQYMGAAvLy+5TE9Ylfj8x3/8B5566imsX78esbGxAICjR4/i+eefl7u6iIiI7MnaHpvunv/jLtMRqqurTYaGNBqN2XJLlixBYWEhvL29zd6v45xeSZJuOs+3Y5muyltT5masSnzefvttZGRk4D//8z/R2tradiMPDyxYsABr16615pZERERWc5eExVY9Pv7+/j2aE1NaWoq6ujpER0ffuIco4vDhw9i8eTPOnj0LoK03JjQ0VC5TV1cn986EhIRAr9ejoaHBpNenrq4OEyZMkMtcvHix0/v/+OOPJvc5duyYyfWGhga0trZ26gnqjlWJT79+/fDWW29h7dq1+Oc//wlJknD77bfD19fXmtsRERHdlD3m5LhawmQQ1DAI1k/WNgiSReWnTp2K8vJyk3NPPfUU7rzzTrzwwgsYPnw4QkJCcODAAYwdOxYAoNfrUVRUhNdffx0AEB0dDU9PTxw4cABz584FANTU1ODUqVNYs2YNACAuLg6NjY346quvcO+99wIAjh07hsbGRjk5iouLw+rVq1FTUyMnWYWFhdBoNCaJ2c0o2qvL19e307I2IiKi3uBqSYsr8vPzQ1RUlMk5X19fBAYGyufT09ORlZWFiIgIREREICsrC/369UNycjIAQKvVYsGCBVi2bBkCAwMREBCAjIwMjBkzRp4sPWrUKMyYMQOpqal45513ALQtZ589e7b82JyEhASMHj0aKSkpWLt2Lerr65GRkYHU1NQer+gCuEkpERGRyzBCUDTUZbTDJqXLly9HS0sL0tLS5AcYFhYWys/wAdq2vfLw8MDcuXPlBxjm5ubKz/ABgF27dmHx4sXy6q+kpCRs3rxZvq5Wq7F//36kpaVh4sSJJg8wtAQTHyIicgns4QEMUMGgIPFRUve6Q4cOmbwWBAGZmZlmV4UBgLe3NzZt2tTtgwYDAgKQl5fX7XsPGTIEn3zyiSXN7YSJDxERkYsQoYYI6+f4iDDasDWuidu0EhERkdtgjw8REZGLMEANg4IeHwN7fJj4EBERdcUZH27oDHN8XB0THyIion9zxf27yDJMfIiIyOXZo3fGGXp4OjIqnNxs5FAXEx8iInJfrtbDY5DUUEsK5vhITHyY+NiZoPaGIKghqL2hkvrODsFERM6sfUJzoq7I7LWOnLGXh2yLiY+d+Q5NgIffrfAdmgBRtGyPFCIi6pmOCUt3yY0mIFL++ei379itTfZggApqRau6+Ac4Ex876zflKXgM+g79psyGqKB7koiIrDNjzoeIn6TC8y/9E6II9B/9qKObZDUD1AoTH/47xMTHBrr7yyJ0SQGgVkPy9oIkqdnFSkTUC9p/nz742s9QhZyB54RRUElqfPaKxoEtI0dj4mMD3SUss168BBgMEH7WQZBUTG6IiHrBjCU18s+tZR9BnOoP3f8dhygCeOVpxzVMIVHhAwyVrAjrK5j42NmVwg1ofXAorhTug2iQgNezHN0kIqI+596hvzJ53S88Xv75/4pSUV5ejpdWjoFabdrz7mp/jBokD6gk6//p5qouJj521/JDMQxXNW3/a+CkMiIie2htrjZ5faj4Rq+OKPad714D1FBxjo8iTHyIiMgl2eIZPM64LQXZFxMfIiJyCbZaHNK+rCs+wFCl6AGG7PFx+sTntttuw7lz5zqdT0tLw5tvvtnp/KFDhzBlypRO58+cOYM777zTLm0kIqLe11e3peiOASqFQ13cpNTpE5/jx4+bjM+eOnUK06dPx2OPPdZtvbNnz8Lf319+feutt9qtjUREZB+u1iNDzs/pE5+OCcsf/vAHjBgxAvHx8WZqtAkKCsItt9xix5YREZG9uVqPjL2JkgcMClZ1idw6yfkTn/b0ej3y8vKwdOlSCILQbdmxY8fi2rVrGD16NF5++eUuh7+u0+l00Ol08uumpiYAbSsBlK4GUHuoIagEqD3U8j2pjSiKkCSJMekCY2MeY2MeY9M1e8elN+NtkNQQOMdHEZdKfD788ENcvnwZ8+fPN1smNDQU7777LqKjo6HT6bBz505MnToVhw4dwv33399lnezsbKxatarT+YqKCvTv319RmxOfmILw2wch8YkpMBollJeXK7pfXyJJEurr61FRUXHTRNbdMDbmMTbmMTZds3dcmpubbX5Psh9BkiSX2TkzMTERXl5e+Pjjjy2qN2fOHAiCgH379nV5vasen/DwcNTX15vME7LGxCHTkfDEFBTmfwHRIOLohc8V3a8vEUURFRUViIyMhFrNv0LaY2zMY2zMY2y6Zu+4NDU1ISAgAI2NjYr/zejuPbRaLeb8tAye/tZvudHapMPHA9fbta3OzmV6fM6dO4eDBw/iL3/5i8V1Y2NjkZeXZ/a6RqOBRtP5PyS1Wq34l0Q0iJCMEkSDCINB5JdRB4Ig2CTOfRFjYx5jYx5j0zV7xqU3Y82hLuVcJvHZvn07goKCMGvWLIvrnjx5EqGhoXZoFRER9VU3W1HGideuySUSH6PRiO3bt2PevHnw8DBt8ooVK/DDDz/gvffeAwDk5OTgtttuQ2RkpDwZes+ePdizZ48jmk5ERL3AVk9gdvZ9vAySSmGPD5/j4xKJz8GDB1FVVYXf/OY3na7V1NSgqqpKfq3X65GRkYEffvgBPj4+iIyMxP79+/Hggw/2ZpOJiMgFuNpzgkR4QFDwT7foGv/s25VLRCAhIQHm5mDn5uaavF6+fDmWL1/eC60iIiJn0bF3pn1Cc6KuyOr7OBtR4RwfkXN8XCPxISIishVX6+Uh22LiQ0REfVps2AOYkTwVqbuXwGAwfdigs/fwdGSQ1ABXdSnCxMcGuvvrwcPD9D8yW+0uTERE5rX/Ph0fHG/2mqsRJQ8Iiras4D/7jIANdPdL1Jd+4YiIXEX7PzI7/gFK7o2JDxERuTxL5u04+5L17nCoSzkmPkRE5JJ6OnVAFEWUl5cjc91KqNVql57cbJRUilZmGfkcHyY+RETk+lyt54Ych4kPERG5BFs9nbl9PVvds7eIkgfAyc2KsM+LiIic1tjASfJhDycvFZsczk6U1IoPS2zZsgW/+MUv4O/vD39/f8TFxeGvf/2rfF2SJGRmZiIsLAw+Pj6YPHkyKioqTO6h0+nw7LPPYuDAgfD19UVSUhLOnz9vUqahoQEpKSnQarXQarVISUnB5cuXTcpUVVVhzpw58PX1xcCBA7F48WLo9XrLAggmPkRE5CJcLUnpCwYPHow//OEPOHHiBE6cOIEHHngAv/zlL+XkZs2aNdiwYQM2b96M48ePIyQkBNOnT8eVK1fke6Snp2Pv3r3Iz89HcXExmpubMXv2bIjijWcqJScno6ysDAUFBSgoKEBZWRlSUlLk66IoYtasWbh69SqKi4uRn5+PPXv2YNmyZRZ/JvZ5ERGR02KCY0pUuKrreo9PU1OTyXmNRgONRtOp/Jw5c0xer169Glu2bMHRo0cxevRo5OTkYOXKlXj44YcBADt27EBwcDB2796NRYsWobGxEdu2bcPOnTsxbdo0AEBeXh7Cw8Nx8OBBJCYm4syZMygoKMDRo0cRExMDANi6dSvi4uJw9uxZjBw5EoWFhTh9+jSqq6sRFhYGAFi/fj3mz5+P1atXw9/fv8cxYI8PERGRizBKasUHAISHh8vDSlqtFtnZ2Td9b1EUkZ+fj6tXryIuLg6VlZWora1FQkKCXEaj0SA+Ph5HjhwBAJSWlqK1tdWkTFhYGKKiouQyJSUl0Gq1ctIDALGxsdBqtSZloqKi5KQHABITE6HT6VBaWmpRDNnjQ0RE5CJESaWwx6etv6O6utqkl6Sr3p7rysvLERcXh2vXrqF///7Yu3cvRo8eLSclwcHBJuWDg4Nx7tw5AEBtbS28vLwwYMCATmVqa2vlMkFBQZ3eNygoyKRMx/cZMGAAvLy85DI9xcSHiIjIzVyfrNwTI0eORFlZGS5fvow9e/Zg3rx5KCq6seO9IAgm5SVJ6nSuo45luipvTZme4FAXERGRizBKahiNCg4reou8vLxw++23Y9y4ccjOzsZdd92FP/7xjwgJCQGATj0udXV1cu9MSEgI9Ho9Ghoaui1z8eLFTu/7448/mpTp+D4NDQ1obW3t1BN0M0x8iIiIXIRR4VJ2axKfjiRJgk6nw7BhwxASEoIDBw7I1/R6PYqKijBhwgQAQHR0NDw9PU3K1NTU4NSpU3KZuLg4NDY24quvvpLLHDt2DI2NjSZlTp06hZqaGrlMYWEhNBoNoqOjLWo/h7qIiIh6wNUedmgLL730EmbOnInw8HBcuXIF+fn5OHToEAoKCiAIAtLT05GVlYWIiAhEREQgKysL/fr1Q3JyMgBAq9ViwYIFWLZsGQIDAxEQEICMjAyMGTNGXuU1atQozJgxA6mpqXjnnXcAAAsXLsTs2bMxcuRIAEBCQgJGjx6NlJQUrF27FvX19cjIyEBqaqpFK7oAJj5ERNQH2CMpccZExyipAAX7bVm6V9fFixeRkpKCmpoaaLVa/OIXv0BBQQGmT58OAFi+fDlaWlqQlpaGhoYGxMTEoLCwEH5+fvI9Nm7cCA8PD8ydOxctLS2YOnUqcnNzoVbf6H3atWsXFi9eLK/+SkpKwubNm+XrarUa+/fvR1paGiZOnAgfHx8kJydj3bp1FseAiQ8REfU57ZOWE3VF3ZQ0X88ZEp2OJEkNScFwlaV1t23b1u11QRCQmZmJzMxMs2W8vb2xadMmbNq0yWyZgIAA5OXldfteQ4YMwSeffNJtmZ5g4mNnKi8tBJUXVF5aqFXizSsQEZHFOiYpPd3iwhl7dci+mPjY2YBJK6AJvYIBk+IhGi1bckdERLYXd+diRzfBakajGjBa3+NjVFC3r2DiY2f/WO6HMfXX8I+pfjCouIiOiKg3qL208s9T3hcxVSNh8SkRIoCf16+Wr309y6+L2s5LklSQFMzxUVK3r2DiYwPddalqd38Er9ar0NaFwiConH78mIioLzhRs1/+ueH4/fju8lQsvmUJ1III/3F/c2DLyNGY+NhAdwnMtHdF+PhpcOuVWyBCjS+Y7BAR2V14u8RnyPeFmO5xGgfqX4AINY6Oc2DDFDIaVYBRwaouBXX7CiY+dqZ/+78hPjgU+k//BNEgAQuzHN0kIqI+Z/zgh01eV5//i/xzTEYSjHMnwPD/z4RoEBH9rE6+Vlp3sNfaaAttQ11KVnUx8WHiY2fXak9A/Llf2/8auKqLiMhWejp14Mi/9qK8vByvrnkearW6xyu+nJLC5/goqttHMPGxM0m8BkkSIYnXYBSZ+BARWculExZyGkx8iIjIaXWX7LjjAhHJqIKkYJ6Okrp9BRMfIiJyCbZKdFw6YVL4HB9FdfsIJj5EROS0XDpJIafExIeIiMhVcHKzYkx8iIiIXAWHuhRj6kdERERugz0+RERErkJS2OOj4OGHfQUTHyIiIldhFBRtWQGjYLu2uCgOdREREZHbYI8PERFRD3R8mKIjltoLRjUEBUNdSur2FUx8iIjI5XX3hOcTdUU2v6ejCJIagoJ5Okrq9hVMfIiIyOV17H2xNmlx+i0yjCqFc3w4w8WpI5CZmQlBEEyOkJCQbusUFRUhOjoa3t7eGD58ON5+++1eai0REbmasYGTTI72Tl4qNjmob3D6Hp/IyEgcPHhQfq1Wm++mq6ysxIMPPojU1FTk5eXhb3/7G9LS0nDrrbfikUce6Y3mEhGRC3P2BIdzfJRz+sTHw8Pjpr0817399tsYMmQIcnJyAACjRo3CiRMnsG7dum4TH51OB51OJ79uamoCAIiiCFEUrW88ALWHGoJKgNpDLd+T2oiiCEmSGJMuMDbmMTbmMTY3eHjc+Ad+4pDpSHhiCp7OXwrRYBqbjvN/rIldb8ZbENUQRAWJj4K6fYXTJz7ffvstwsLCoNFoEBMTg6ysLAwfPrzLsiUlJUhISDA5l5iYiG3btqG1tRWenp5d1svOzsaqVas6na+oqED//v0tau+eHftM3/+JKQi/fRASn5gCo1FCZsZq+doj85IsundfI0kS6uvrUVFRAUHgsyXaY2zMY2zMY2xumJE8Vf5ZpRJMvofbf/eWl5crfq/m5mbF96De49SJT0xMDN577z3ccccduHjxIl577TVMmDABFRUVCAwM7FS+trYWwcHBJueCg4NhMBjw008/ITQ0tMv3WbFiBZYuXSq/bmpqQnh4OCIjI+Hv729Rm8esG2Py+vpfGoX5X0A0iDh64XOL7teXiaKIiooKREZGdjuE6Y4YG/MYG/PcOTaxYQ+Yvab2UJt8D2euW2nT974+StAbVEYVVJzcrIhTJz4zZ86Ufx4zZgzi4uIwYsQI7NixwyRRaa/jXzmSJHV5vj2NRgONRtPpvFqtVvzlIRpESEYJokGEwSC63ZfRzQiCYJM490WMjXmMjXnuFJuersAaHxxv1+/h3oy1YFQpnOPDxMepE5+OfH19MWbMGHz77bddXg8JCUFtba3Jubq6Onh4eHTZQ0RERK7D2qXmRy98jvLycmSuWwm1Wm1yH2efzEy251KJj06nw5kzZ3Dfffd1eT0uLg4ff/yxybnCwkKMGzfO7PweIiJyXk7/XJ1eJkgqRb02gsQeH6dOfDIyMjBnzhwMGTIEdXV1eO2119DU1IR58+YBaJub88MPP+C9994DADz99NPYvHkzli5ditTUVJSUlGDbtm14//33HfkxiIioh5jodE9lVEOlZEk6l7M7d+Jz/vx5/OpXv8JPP/2EW2+9FbGxsTh69CiGDh0KAKipqUFVVZVcftiwYfj000/x3HPP4c0330RYWBjeeOMNPsOHiMhF2SPZYQLl3pw68cnPz+/2em5ubqdz8fHx+Pvf/26nFhERkT0xKele2+RmBUNdnNzs3IkPERER3SCIaqgUPIRQ4gMMmfgQERG5CqXP8ZHY4+Pcm5QSERER2RITHyIiIhdxfY6PksMS2dnZGD9+PPz8/BAUFISHHnoIZ8+eNSkjSRIyMzMRFhYGHx8fTJ48GRUVFSZldDodnn32WQwcOBC+vr5ISkrC+fPnTco0NDQgJSUFWq0WWq0WKSkpuHz5skmZqqoqzJkzB76+vhg4cCAWL14MvV5v0Wdi4kNEROQiVKIKqn/P87HusOyf/aKiIjzzzDM4evQoDhw4AIPBgISEBFy9elUus2bNGmzYsAGbN2/G8ePHERISgunTp+PKlStymfT0dOzduxf5+fkoLi5Gc3MzZs+ebbLBa3JyMsrKylBQUICCggKUlZUhJSVFvi6KImbNmoWrV6+iuLgY+fn52LNnD5YtW2bRZ+IcHyIiIjfTcX8xc1s3FRQUmLzevn07goKCUFpaivvvvx+SJCEnJwcrV67Eww8/DADYsWMHgoODsXv3bixatAiNjY3Ytm0bdu7ciWnTpgEA8vLyEB4ejoMHDyIxMRFnzpxBQUEBjh49ipiYGADA1q1bERcXh7Nnz2LkyJEoLCzE6dOnUV1djbCwMADA+vXrMX/+fKxevbrHe2uyx4eIiMhFXJ/crOQAgPDwcHlISavVIjs7u0fv39jYCAAICAgAAFRWVqK2thYJCQlyGY1Gg/j4eBw5cgQAUFpaitbWVpMyYWFhiIqKksuUlJRAq9XKSQ8AxMbGQqvVmpSJioqSkx4ASExMhE6nQ2lpaY9jyB4fIiLqc9o/AfpEXZHN79meKBlscv+eUBlVFg9XtXd9VVd1dbVJD0lXvT2d6koSli5dikmTJiEqKgoA5P0xg4ODTcoGBwfj3LlzchkvLy8MGDCgU5nr9WtraxEUFNTpPYOCgkzKdHyfAQMGwMvLq9M+nd1h4kNERNSF7rbPAG48bLGpqQlarbY3mmQz/v7+PR4auu53v/sd/t//+38oLu78kElBEExeS5LU6VxHHct0Vd6aMjfDxMfOBLU3BEENQe0NlSTevAIRETmMs+8V5qgnNz/77LPYt28fDh8+jMGDB8vnQ0JCALT1xoSGhsrn6+rq5N6ZkJAQ6PV6NDQ0mPT61NXVYcKECXKZixcvdnrfH3/80eQ+x44dM7ne0NCA1tbWTj1B3eEcHzvrP3wWPP2Hov/wWeg/IsnRzSEionbGBk4yOdo7eanY5HAGKlFQfFhCkiT87ne/w1/+8hd8/vnnGDZsmMn1YcOGISQkBAcOHJDP6fV6FBUVyUlNdHQ0PD09TcrU1NTg1KlTcpm4uDg0Njbiq6++ksscO3YMjY2NJmVOnTqFmpoauUxhYSE0Gg2io6N7/JnY42NnPnFPQB3yPXzihkOUmGcSEfWG9onK+OB4zEieitTdS2AwiGbLUWfPPPMMdu/ejY8++gh+fn7yXBqtVgsfHx8IgoD09HRkZWUhIiICERERyMrKQr9+/ZCcnCyXXbBgAZYtW4bAwEAEBAQgIyMDY8aMkVd5jRo1CjNmzEBqaireeecdAMDChQsxe/ZsjBw5EgCQkJCA0aNHIyUlBWvXrkV9fT0yMjKQmppq0bAdEx8b6/gXw62TVsAYaETrN5cgigLGBmbJ1/gLR0RkH9FB0+SfPTRaCCovqLy0UKtEnKjZ78CWKdPbW1Zs2bIFADB58mST89u3b8f8+fMBAMuXL0dLSwvS0tLQ0NCAmJgYFBYWws/PTy6/ceNGeHh4YO7cuWhpacHUqVORm5sLtfrG3mG7du3C4sWL5dVfSUlJ2Lx5s3xdrVZj//79SEtLw8SJE+Hj44Pk5GSsW7fOos/ExMfGOiYz0xPzAdET0rVWSCKTHSIie+hubo4kqgFJhCTqIImuPddSZRSgMlo2XNWeZGFdSZJuWkYQBGRmZiIzM9NsGW9vb2zatAmbNm0yWyYgIAB5eXndvteQIUPwySef3LRN3WHiY2dNp3dDHzUBTaePQDSIAJ5wdJOIiPqEnk5EHh8cD0kSIYnXYHTxxEcQlS1nNyqo21cw8bEzo74RklEPo77x34kPERH11M2WlF9nSW96+3uyF979MPEhIiKnYY/l5EcvfI7y8nJkrlsJtVrd42TKGQmiAMHClVkd67s7Jj5EROS02CNjSiUpm+Ojkpj4MPEhIiKn0RuJDpMp98bEh4iIyEVwqEs5Jj5EREQuQulydiV1+wquayMiIiK3wR4fIiIiFyGIbYeS+u6OiQ8REZGL4FCXchzqIiIiIrfBHh8iIiIXwaEu5Zj4EBERuQjB2HYoqe/umPgQEVGf035bihN1RQ5siW0JRgmCePMd07ur7+6Y+BAREVnhenIlSgYHt4QswcSHiIioCzfbzPT61hdNTU3QarW90SQOddkAEx8iIurTYsMewIzkqUjdvQQGg2iyV5clO7U7wx5fgqhwqEtB3b6CiY+Ndfwl8vBQm73uDL9ERETujN/D7oeJj411/CUaHxzf7XUiIrKOJb01fYZRajuU1HdzTHyIiMgldJfodPdHZcc/QF0Zh7qUY+JDREROw9rkhqinmPgQEZHTskey49JzLTnUpRgTHyIichr2SESOXvgc5eXlyFy3Emq12rXnBonGtkNJfTfHxIeIiNyKy/XykE059e7s2dnZGD9+PPz8/BAUFISHHnoIZ8+e7bbOoUOHIAhCp+Mf//hHL7WaiIjIToxG5Yebc+oen6KiIjzzzDMYP348DAYDVq5ciYSEBJw+fRq+vr7d1j179iz8/f3l17feequ9m0tERGRfRoVDXUx8nDvxKSgoMHm9fft2BAUFobS0FPfff3+3dYOCgnDLLbfYsXVERES9SzAaIShIXpTU7SucOvHpqLGxEQAQEBBw07Jjx47FtWvXMHr0aLz88suYMmWK2bI6nQ46nU5+3dTUBAAQRRGiKCpqs9pDDUElQP3vJzgrvV9fIooiJEliTLrA2JjH2JjH2HTN3nFhvF2LyyQ+kiRh6dKlmDRpEqKiosyWCw0Nxbvvvovo6GjodDrs3LkTU6dOxaFDh8z2EmVnZ2PVqlWdzldUVKB///6K2p34xBSE3z4IiU9MgdEooby8XNH9+hJJklBfX4+KigoIguDo5jgVxsY8xsY8xqZr9o5Lc3Ozze9pFld1KSZIkuQSi/qfeeYZ7N+/H8XFxRg8eLBFdefMmQNBELBv374ur3fV4xMeHo76+nqTeULWmDhkOhKemILC/C8gGkQcvfC5ovv1JaIooqKiApGRkVCr1Tev4EYYG/MYG/MYm67ZOy5NTU0ICAhAY2Oj4n8zunsPrVaLqUv+BQ+N9e9h0DXh//54m13b6uxcosfn2Wefxb59+3D48GGLkx4AiI2NRV5entnrGo0GGo2m03m1Wq34l0Q0iJCMEkSDCINB5JdRB4Ig2CTOfRFjYx5jYx5j0zV7xoWxdi1OnfhIkoRnn30We/fuxaFDhzBs2DCr7nPy5EmEhobauHVERES9TDQCSuYUcajLuROfZ555Brt378ZHH30EPz8/1NbWAgC0Wi18fHwAACtWrMAPP/yA9957DwCQk5OD2267DZGRkdDr9cjLy8OePXuwZ88eh30OIiLqXe2fznyirsiBLbExpc/i4aou5058tmzZAgCYPHmyyfnt27dj/vz5AICamhpUVVXJ1/R6PTIyMvDDDz/Ax8cHkZGR2L9/Px588MHeajYRERE5Kad+crMkSV0e15MeAMjNzcWhQ4fk18uXL8d3332HlpYW1NfX48svv3Ro0uPRfzBUnr7w6D8Ynv3DHdYOIiJ3FRv2APbs2IfYsAdsuk/X2MBJGBs4CZNuS7DZPW9KFJUfFjp8+DDmzJmDsLAwCIKADz/80OS6JEnIzMxEWFgYfHx8MHnyZFRUVJiU0el0ePbZZzFw4ED4+voiKSkJ58+fNynT0NCAlJQUaLVaaLVapKSk4PLlyyZlqqqqMGfOHPj6+mLgwIFYvHgx9Hq9RZ/HqXt8+gLtuKfhFXQV2nH3QjRyeSkRUW9ovx/X+OD4Htdz9g1MJaMIScEcH8loed2rV6/irrvuwlNPPYVHHnmk0/U1a9Zgw4YNyM3NxR133IHXXnsN06dPx9mzZ+Hn5wcASE9Px8cff4z8/HwEBgZi2bJlmD17NkpLS+XJ4cnJyTh//rz88OKFCxciJSUFH3/8MYC21XmzZs3CrbfeiuLiYly6dAnz5s2DJEnYtGlTjz8PEx87E8bHQLi1AsL4SAgSZ/4TETlaT5Obnm5men2peV81c+ZMzJw5s8trkiQhJycHK1euxMMPPwwA2LFjB4KDg7F7924sWrQIjY2N2LZtG3bu3Ilp06YBAPLy8hAeHo6DBw8iMTERZ86cQUFBAY4ePYqYmBgAwNatWxEXF4ezZ89i5MiRKCwsxOnTp1FdXY2wsDAAwPr16zF//nysXr26x8vzmfjYWMdfqICo/4Q41R/6/zvW1sP4/NOOaRgRkRsZFzpL/tmz3ZQDwWCE2PKjfK207qAjmmc9o9h2KKmPGzsUXGfusS43U1lZidraWiQk3Bju02g0iI+Px5EjR7Bo0SKUlpaitbXVpExYWBiioqJw5MgRJCYmoqSkBFqtVk56gLZH0Wi1Whw5cgQjR45ESUkJoqKi5KQHABITE6HT6VBaWtrtDg3tMfGxsY5/IUx/cA8EDxVUvhpIfKo5EZHVLBmG6jjUZWwdCUPzeRgMYo97cpySlfN0TOoDCA83nXP66quvIjMz0+LbXV9tHRwcbHI+ODgY586dk8t4eXlhwIABncpcr19bW4ugoKBO9w8KCjIp0/F9BgwYAC8vL7lMTzDxsbMrp99Ha+S9uHL6K4gGI4DO46NERO5KyZwal05grGU0KuzxaVvOXl1dbTI0ZE1vT3sdtwKRJOmm24N0LNNVeWvK3AwTHzsTW36E0XANYsuPMBjY5UNE1J5bJi9OwN/f3yZbVoSEhABo641p/6Dguro6uXcmJCQEer0eDQ0NJr0+dXV1mDBhglzm4sWLne7/448/mtzn2LFjJtcbGhrQ2traqSeoO069nJ2IiIjaEQ3KDxsaNmwYQkJCcODAAfmcXq9HUVGRnNRER0fD09PTpExNTQ1OnToll4mLi0NjYyO++uorucyxY8fQ2NhoUubUqVOoqamRyxQWFkKj0SA6OrrHbWaPDxERkYuQRIXL2a2o29zcjO+++05+XVlZibKyMgQEBGDIkCFIT09HVlYWIiIiEBERgaysLPTr1w/JyckA2nZbWLBgAZYtW4bAwEAEBAQgIyMDY8aMkVd5jRo1CjNmzEBqaireeecdAG3L2WfPno2RI0cCABISEjB69GikpKRg7dq1qK+vR0ZGBlJTUy3qvWLiQ0REfdrRC5+jvLwcmetWckNRK5w4ccJkxdTSpUsBAPPmzUNubi6WL1+OlpYWpKWloaGhATExMSgsLJSf4QMAGzduhIeHB+bOnYuWlhZMnToVubm5Jv9/7Nq1C4sXL5ZXfyUlJWHz5s3ydbVajf379yMtLQ0TJ06Ej48PkpOTsW7dOos+DxMfIiIiV2E0tB1K6lto8uTJkCTJ7HVBEJCZmdntqjBvb29s2rSp2wcNBgQEIC8vr9u2DBkyBJ988slN29wdJj5ERESuwqhwno6SpKmP4ORmIiIichvs8SEiInIRkihCUlnfa6NkYnRfwcSHiIjIVThgjk9fw6EuIiIichvs8SEiInIVogFQMNRl6wcYuiImPkRERC5CElshqVoV1Xd3HOoiIqI+LTbsAezZsQ+xYQ8o2hTVGUiioS35sfpgjw8THyIiInIbHOoiIiJyFVzVpRgTHyIiIhchGVsVzdORjJzjw8SHiIjcli3m/IgSe1FcCRMfIiJyST1NWjw8THdk767eyUvFFrejqakJWq3W4npWEVsBQUGvDVd1MfEhIiLHsdUqq+4SlvHB8T0u6+wk0QBJQeLDVV1MfIiIyIFcOQkh18TEh4iIyEVIRj0ko/rmBbup7+6Y+BAREbkKsRUQFPzTzTk+THzs7eiFz1FeXo7MdSuhVlufpRMREZFyTHyIiKhP60t/gEpiKyRBwVAXe3yY+BAREbkKyaiHJFq/2xTn+DDxISIichmS2AoJ7PFRgpuUEhERkdtgjw8REZGLkEQ9JAV9FpLIoS4mPkRERC5CMuohCYKi+u6OQ11ERETkNtjjQ0RE5CLahroU9PhwqIuJDxERkatoW9WlJPHhqi4OdRERUZ8WG/YA9uzYh9iwB2y2Gzy5Lvb4EBERuQjJqIMESUF9DnW5RI/PW2+9hWHDhsHb2xvR0dH48ssvuy1fVFSE6OhoeHt7Y/jw4Xj77bd7qaVERER2JOogKTgg6hz9CRzO6ROfDz74AOnp6Vi5ciVOnjyJ++67DzNnzkRVVVWX5SsrK/Hggw/ivvvuw8mTJ/HSSy9h8eLF2LNnTy+3nIiIiJyN0w91bdiwAQsWLMBvf/tbAEBOTg4+++wzbNmyBdnZ2Z3Kv/322xgyZAhycnIAAKNGjcKJEyewbt06PPLII12+h06ng053IwtuamoCAIiiCFEUFbVfFEVIkqT4Pn0RY2MeY2MeY2MeY9O1kP/6EP0Gf4eQ/3oWoqS2eXx6M96SqIckKRnq4uRmp0589Ho9SktL8eKLL5qcT0hIwJEjR7qsU1JSgoSEBJNziYmJ2LZtG1pbW+Hp6dmpTnZ2NlatWtXpfEVFBfr376/gEwCSJKG+vh4VFRUQFDx0qi9ibMxjbMxjbMxzxdjs2bHPJvcROuxY/vOcWPnnzPF/Q4M4CAmhf4UACa///2bI11r+8Zni99bprim+R09Jog6SZLS+PhMf5058fvrpJ4iiiODgYJPzwcHBqK2t7bJObW1tl+UNBgN++uknhIaGdqqzYsUKLF26VH7d1NSE8PBwREZGwt/fX9FnEEURFRUViIyMhFpt/cZyfRFjYx5jYx5jY54rxmbMujF2f4/ZjzRjUixQfHQgRBH464fj2l0dZ7ZeTzU1NWHtls4jEPbAxEc5p058ruv4l4skSd3+NdNV+a7OX6fRaKDRaDqdV6vVNvnyEATBZvfqaxgb8xgb8xgb8xibzn4q2YBrw6bip5L/g8EgQq3+pU3v7w6xfuutt7B27VrU1NQgMjISOTk5uO+++xzdLKs49eTmgQMHQq1Wd+rdqaur69Src11ISEiX5T08PBAYGGi3thIREdmbJOoVreqy5snNli4ycnZOnfh4eXkhOjoaBw4cMDl/4MABTJgwocs6cXFxncoXFhZi3LhxXc7vISIichVG4zUYRQWH0fL5SO0XGY0aNQo5OTkIDw/Hli1b7PAJ7c/ph7qWLl2KlJQUjBs3DnFxcXj33XdRVVWFp59+GkDb/JwffvgB7733HgDg6aefxubNm7F06VKkpqaipKQE27Ztw/vvv9/j97w+NHZ9dZcSoiiiubkZTU1NbtEdagnGxjzGxjzGxjzGpmui0QCd7hpEowGiJNrku7296/dTstqqp0RJ4Urjf9fvGANzUz6sWWTk9CQX8Oabb0pDhw6VvLy8pHvuuUcqKiqSr82bN0+Kj483KX/o0CFp7NixkpeXl3TbbbdJW7Zssej9qqurJQA8ePDgwYNHj4/q6mpb/JPXpZaWFikkJMQm7ezfv3+nc6+++mqX7/vDDz9IAKS//e1vJudXr14t3XHHHXb7vPYkSFIvpKguxmg04sKFC/Dz81O8JPT6CrHq6mrFK8T6GsbGPMbGPMbGPMama/aOiyRJuHLlCsLCwqBS2W8GybVr16DXK99yQupigZC5Hp8LFy5g0KBBOHLkCOLi4uTzq1evxs6dO/GPf/xDcXt6m9MPdTmCSqXC4MGDbXpPf39/fhGZwdiYx9iYx9iYx9h0zZ5x0Wq1drlve97e3vD29rb7+7RnzSIjZ+fUk5uJiIjIcaxZZOTs2ONDREREZt1skZGrYeJjZxqNBq+++mqXY6fujrExj7Exj7Exj7HpGuOizOOPP45Lly7h97//PWpqahAVFYVPP/0UQ4cOdXTTrMLJzUREROQ2OMeHiIiI3AYTHyIiInIbTHyIiIjIbTDxISIiIrfBxMcG3nrrLQwbNgze3t6Ijo7Gl19+2W35oqIiREdHw9vbG8OHD8fbb7/dSy3tfZbE5i9/+QumT5+OW2+9Ff7+/oiLi8Nnn33Wi63tXZb+d3Pd3/72N3h4eODuu++2bwMdyNLY6HQ6rFy5EkOHDoVGo8GIESPwv//7v73U2t5jaVx27dqFu+66C/369UNoaCieeuopXLp0qZda23sOHz6MOXPmICwsDIIg4MMPP7xpHXf6HqYOHLlfRl+Qn58veXp6Slu3bpVOnz4tLVmyRPL19ZXOnTvXZfnvv/9e6tevn7RkyRLp9OnT0tatWyVPT0/pz3/+cy+33P4sjc2SJUuk119/Xfrqq6+kb775RlqxYoXk6ekp/f3vf+/lltufpbG57vLly9Lw4cOlhIQE6a677uqdxvYya2KTlJQkxcTESAcOHJAqKyulY8eOddpbyNVZGpcvv/xSUqlU0h//+Efp+++/l7788kspMjJSeuihh3q55fb36aefSitXrpT27NkjAZD27t3bbXl3+h6mzpj4KHTvvfdKTz/9tMm5O++8U3rxxRe7LL98+XLpzjvvNDm3aNEiKTY21m5tdBRLY9OV0aNHS6tWrbJ10xzO2tg8/vjj0ssvvyy9+uqrfTbxsTQ2f/3rXyWtVitdunSpN5rnMJbGZe3atdLw4cNNzr3xxhvS4MGD7dZGZ9CTxMedvoepMw51KaDX61FaWoqEhAST8wkJCThy5EiXdUpKSjqVT0xMxIkTJ9Da2mq3tvY2a2LTkdFoxJUrVxAQEGCPJjqMtbHZvn07/vnPf+LVV1+1dxMdxprY7Nu3D+PGjcOaNWswaNAg3HHHHcjIyEBLS0tvNLlXWBOXCRMm4Pz58/j0008hSRIuXryIP//5z5g1a1ZvNNmpucv3MHWNT25W4KeffoIoip02agsODu60odt1tbW1XZY3GAz46aefEBoaarf29iZrYtPR+vXrcfXqVcydO9ceTXQYa2Lz7bff4sUXX8SXX34JD4+++2trTWy+//57FBcXw9vbG3v37sVPP/2EtLQ01NfX95l5PtbEZcKECdi1axcef/xxXLt2DQaDAUlJSdi0aVNvNNmpucv3MHWNPT42IAiCyWtJkjqdu1n5rs73BZbG5rr3338fmZmZ+OCDDxAUFGSv5jlUT2MjiiKSk5OxatUq3HHHHb3VPIey5L8bo9EIQRCwa9cu3HvvvXjwwQexYcMG5Obm9qleH8CyuJw+fRqLFy/Gf//3f6O0tBQFBQWorKx02f2VbM2dvofJVN/907EXDBw4EGq1utNfXHV1dZ3+mrguJCSky/IeHh4IDAy0W1t7mzWxue6DDz7AggUL8Kc//QnTpk2zZzMdwtLYXLlyBSdOnMDJkyfxu9/9DkDbP/aSJMHDwwOFhYV44IEHeqXt9mbNfzehoaEYNGgQtFqtfG7UqFGQJAnnz59HRESEXdvcG6yJS3Z2NiZOnIjnn38eAPCLX/wCvr6+uO+++/Daa6+5da+Gu3wPU9fY46OAl5cXoqOjceDAAZPzBw4cwIQJE7qsExcX16l8YWEhxo0bB09PT7u1tbdZExugradn/vz52L17d5+di2BpbPz9/VFeXo6ysjL5ePrppzFy5EiUlZUhJiamt5pud9b8dzNx4kRcuHABzc3N8rlvvvkGKpUKgwcPtmt7e4s1cfn555+hUpl+xavVagA3ejfclbt8D5MZDppU3WdcX2K6bds26fTp01J6errk6+sr/etf/5IkSZJefPFFKSUlRS5/fRnlc889J50+fVratm1bn11GaWlsdu/eLXl4eEhvvvmmVFNTIx+XL1921EewG0tj01FfXtVlaWyuXLkiDR48WHr00UeliooKqaioSIqIiJB++9vfOuoj2IWlcdm+fbvk4eEhvfXWW9I///lPqbi4WBo3bpx07733Ouoj2M2VK1ekkydPSidPnpQASBs2bJBOnjwpL/V35+9h6oyJjw28+eab0tChQyUvLy/pnnvukYqKiuRr8+bNk+Lj403KHzp0SBo7dqzk5eUl3XbbbdKWLVt6ucW9x5LYxMfHSwA6HfPmzev9hvcCS/+7aa8vJz6SZHlszpw5I02bNk3y8fGRBg8eLC1dulT6+eefe7nV9mdpXN544w1p9OjRko+PjxQaGir9+te/ls6fP9/Lrba/L774otvvDnf/HiZTgiS5eZ8nERERuQ3O8SEiIiK3wcSHiIiI3AYTHyIiInIbTHyIiIjIbTDxISIiIrfBxIeIiIjcBhMfIiIichtMfIiIiMhtMPEhIovddtttyMnJcXQziIgsxsSHiIiI3AYTHyIiInIbTHyIqJOrV6/iySefRP/+/REaGor169dj8uTJSE9Pl8v8/PPP+M1vfgM/Pz8MGTIE7777ruMaTETUQ0x8iKiT559/Hl988QX27t2LwsJCHDp0CKWlpSZl1q9fj3HjxuHkyZNIS0vDf/3Xf+Ef//iHg1pMRNQzTHyIyERzczO2bduGdevWYfr06RgzZgx27NgBURRNyj344INIS0vD7bffjhdeeAEDBw7EoUOHHNNoIqIeYuJDRCb++c9/Qq/XIy4uTj4XEBCAkSNHmpT7xS9+If8sCAJCQkJQV1fXa+0kIrIGEx8iMiFJUo/KeXp6mrwWBAFGo9EeTSIishkmPkRk4vbbb4enpyeOHj0qn2toaMA333zjwFYREdmGh6MbQETOpX///liwYAGef/55BAYGIjg4GCtXroRKxb+TiMj1MfEhok7Wrl2L5uZmJCUlwc/PD8uWLUNjY6Ojm0VEpJgg9XRAn4jc2uTJk3H33XdzqwoicmnsuyYiIiK3wcSHiIiI3AaHuoiIiMhtsMeHiIiI3AYTHyIiInIbTHyIiIjIbTDxISIiIrfBxIeIiIjcBhMfIiIichtMfIiIiMhtMPEhIiIit/H/AS/i21qFWIovAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# generate a contour of all scans \n", + "scans = list(range(132, 198 + 1))\n", + "\n", + "scan_group = tavi.combine_scans(scans, name=\"La2Ni7_40-40-40-80\")\n", + "scan_group_data = scan_group.get_data(\n", + " axes=(\"qh\", \"ql\", \"detector\"),\n", + " norm_to=(1, \"mcu\"),\n", + " grid=(0.01, 0.05),\n", + ")\n", + "\n", + "contour = Plot2D()\n", + "contour.add_contour(scan_group_data, cmap=\"turbo\", vmin=0)\n", + "\n", + "fig, ax = plt.subplots()\n", + "im1 = contour.plot(ax)\n", + "fig.colorbar(im1)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from tavi.utilities import MotorAngles, Peak\n", + "\n", + "instrument_config_json_path = \"../test_data/IPTS9879_HB1A_exp978/hb1a_La2Ni7.json\"\n", + "tas = CN(SPICE_CONVENTION=True)\n", + "tas.load_instrument_params_from_json(instrument_config_json_path)\n", + "\n", + "sample_json_path = \"../test_data/IPTS9879_HB1A_exp978/La2Ni7.json\"\n", + "sample = Xtal.from_json(sample_json_path)\n", + "ub_json=sample.ub_mat\n", + "tas.mount_sample(sample)\n", + "\n", + "# check UB calculation\n", + "\n", + "ei = 14.450292\n", + "ef = 14.443601\n", + "\n", + "angles1 = MotorAngles(two_theta=-101.396853, omega=-48.004475, sgl=-0.770162, sgu=1.477665)\n", + "peak1 = Peak(hkl=(0, 0, 16), angles=angles1, ei=ei, ef=ef)\n", + "angles2 = MotorAngles(two_theta=-56.150124, omega=64.624337, sgl=-0.770162, sgu=1.477665)\n", + "peak2 = Peak(hkl=(1, 1, 0), angles=angles2, ei=ei, ef=ef)\n", + "\n", + "tas.calculate_ub_matrix(peaks=(peak1, peak2))\n", + "assert np.allclose(tas.sample.ub_mat,ub_json,atol=1e-4)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# (002) th2th, scan #132\n", + "\n", + "from tavi.data.fit import Fit1D\n", + "from tavi.data.scan import Scan\n", + "from tavi.plotter import Plot1D\n", + "\n", + "\n", + "def analyze_fwhm(hkl, scans, fit_ranges):\n", + " scan1, scan2=scans\n", + " fit_range1,fit_range2=fit_ranges\n", + " # ------------------------- th2th -------------------------\n", + "\n", + " scan_th2th = Scan.from_spice(path_to_spice_folder, scan_num=scan1)\n", + " scan_th2th = scan_th2th.get_data(axes=(\"del_q\",\"detector\"),norm_to=(1, \"mcu\"))\n", + " # perform fit\n", + " scan_th2th_fit = Fit1D(scan_th2th, fit_range=fit_range1)\n", + " scan_th2th_fit.add_signal(model=\"Gaussian\")\n", + " scan_th2th_fit.add_background(model=\"Constant\")\n", + " pars_th2th = scan_th2th_fit.guess()\n", + " pars_th2th[\"b1_c\"].set(min=0)\n", + " result_th2th = scan_th2th_fit.fit(pars_th2th,USE_ERRORBAR=False)\n", + " # print(scan_th2th_fit.result.fit_report())\n", + "\n", + " rez = tas.cooper_nathans(hkl_list=hkl, ei=ei, ef=ef, R0=False, projection=None)\n", + "\n", + " p1 = Plot1D()\n", + " # data\n", + " p1.add_scan(scan_th2th, fmt=\"o\", label=\"#{} ({},{},{}) th2th scan\".format(scan1, *hkl))\n", + " # fits \n", + " p1.add_fit(\n", + " scan_th2th_fit,x=scan_th2th_fit.x_to_plot(),\n", + " label=f\"FWHM={result_th2th.params[\"s1_fwhm\"].value:.4f}+/-{result_th2th.params[\"s1_fwhm\"].stderr:.4f}\",\n", + " )\n", + " # resolution \n", + " x_th2th = scan_th2th_fit.result.params[\"s1_center\"].value\n", + " components_th2th = result_th2th.eval_components(result_th2th.params, x=x_th2th)\n", + " y_th2th = components_th2th[\"s1_\"] / 2 + components_th2th[\"b1_\"]\n", + " p1.add_reso_bar(\n", + " pos=(x_th2th, y_th2th), fwhm=rez.coh_fwhms(axis=0), c=\"C3\", \\\n", + " label=f\"Resolution FWHM={rez.coh_fwhms(axis=0):.04f}\",\n", + " )\n", + "\n", + " # ------------------------- s1 -------------------------\n", + "\n", + " scan_s1 = Scan.from_spice(path_to_spice_folder, scan_num=scan2)\n", + " scan_s1= scan_s1.get_data(axes=(\"del_q\",\"detector\"),norm_to=(1, \"mcu\"))\n", + " # perform fit\n", + " scan_s1_fit = Fit1D(scan_s1,fit_range2)\n", + " scan_s1_fit.add_signal(model=\"Gaussian\")\n", + " scan_s1_fit.add_background(model=\"Constant\")\n", + " pars_s1 = scan_s1_fit.guess()\n", + " #pars_s1[\"b1_c\"].set(min=0)\n", + " result_s1 = scan_s1_fit.fit(pars_s1, USE_ERRORBAR=False)\n", + " #print(scan_s1_fit.result.fit_report())\n", + "\n", + "\n", + " rez = tas.cooper_nathans(hkl_list=hkl, ei=ei, ef=ef, R0=False, projection=None)\n", + "\n", + " p2 = Plot1D()\n", + " # data\n", + " p2.add_scan(scan_s1, fmt=\"o\", label=\"#{} ({},{},{}) s1 scan\".format(scan2, *hkl))\n", + " # fits \n", + " p2.add_fit(\n", + " scan_s1_fit,x=scan_s1_fit.x_to_plot(),\n", + " label=f\"FWHM={result_s1.params[\"s1_fwhm\"].value:.4f}+/-{result_s1.params[\"s1_fwhm\"].stderr:.4f}\",\n", + " )\n", + " # resolution \n", + " x_s1 = result_s1.params[\"s1_center\"].value\n", + " components_s1 = result_s1.eval_components(result_s1.params, x=x_s1)\n", + " y_s1 = components_s1[\"s1_\"] / 2 + components_s1[\"b1_\"]\n", + " p2.add_reso_bar(\n", + " pos=(x_s1, y_s1), fwhm=rez.coh_fwhms(axis=1), c=\"C3\", \\\n", + " label=f\"Resolution FWHM={rez.coh_fwhms(axis=1):.04f}\",\n", + " )\n", + " p2.ylim=(-np.max(scan_s1.y)*0.1,np.max(scan_s1.y)*1.3)\n", + "\n", + " fig, axes = plt.subplots(ncols=2,sharey=True,figsize=(10,5))\n", + " p1.plot(axes[0])\n", + " p2.plot(axes[1])\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hkl=(0,0,2)\n", + "scans=(132,133)\n", + "fit_ranges =(None,None)\n", + "\n", + "scan_info=((hkl, scans,fit_ranges),)\n", + "\n", + "for info in scan_info:\n", + " hkl, scans, fit_ranges = info\n", + " analyze_fwhm(hkl, scans, fit_ranges)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# scan_info = (hkl, (th2th scan num, s1, scan num), (fit ranges in del_q))\n", + "scan_info=(#((0,0,2), (132,133),(None,None)),\n", + " # ((0,0,3), (134,135),(None,None)),\n", + " # ((0,0,4), (136,137),(None,None)),\n", + " # ((0,0,5), (138,139),(None,None)),\n", + " # ((0,0,6), (140,141),(None,None)),\n", + " # ((0,0,7), (142,143),(None,None)),\n", + " # ((0,0,8), (144,145),(None,None)),\n", + " # ((0,0,9), (146,147),(None,None)),\n", + " # ((0,0,10), (148,149),((-0.15,0.09),None)),\n", + " # ((0,0,11), (150,151),((-0.08,0.07),None)),\n", + " # #((0,0,12), (152,153),(None,None)), # having issues if use errorbar\n", + " # ((0,0,13), (154,155),((-0.1,0.15),None)),\n", + " #((0,0,16), (160,161),(None,None)),\n", + " #((1,1,0), (166,167),(None,None)),\n", + " #((1,1,1), (168,169),((-0.16,0.12),None)),\n", + " #((1,1,2), (170,171),((-0.16,0.12),None)),\n", + " #((1,1,3), (172,173),((-0.13,0.05),None)),\n", + " # #((1,1,4), (174,175),((-0.13,0.05),None)),# on a powder line\n", + " ((1,1,5), (176,177),((-0.06,0.15),None)),\n", + " )\n", + "\n", + "for info in scan_info:\n", + " hkl, scans, fit_ranges = info\n", + " analyze_fwhm(hkl, scans, fit_ranges)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tavi", + "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.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/example.ipynb b/notebooks/example.ipynb deleted file mode 100644 index 7fa87015..00000000 --- a/notebooks/example.ipynb +++ /dev/null @@ -1,27 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Overview\n", - "\n", - "This folder is used to store notebooks that demonstrate how to use the library in an interactive environment like Jupyter." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/scripts/test_rez.py b/scripts/CG4C_resolution/test_rez.py similarity index 100% rename from scripts/test_rez.py rename to scripts/CG4C_resolution/test_rez.py diff --git a/scripts/FeSn_film_HB1A.py b/scripts/HB1A_resolution/FeSn_film_HB1A.py similarity index 100% rename from scripts/FeSn_film_HB1A.py rename to scripts/HB1A_resolution/FeSn_film_HB1A.py diff --git a/scripts/HoV6Sn6_contour.py b/scripts/HB1A_resolution/HoV6Sn6_contour.py similarity index 100% rename from scripts/HoV6Sn6_contour.py rename to scripts/HB1A_resolution/HoV6Sn6_contour.py diff --git a/scripts/rez_HB1A.py b/scripts/HB1A_resolution/rez_HB1A.py similarity index 100% rename from scripts/rez_HB1A.py rename to scripts/HB1A_resolution/rez_HB1A.py diff --git a/scripts/rez_HB1A_tweaking.py b/scripts/HB1A_resolution/rez_HB1A_tweaking.py similarity index 100% rename from scripts/rez_HB1A_tweaking.py rename to scripts/HB1A_resolution/rez_HB1A_tweaking.py diff --git a/scripts/MnTe_contour.py b/scripts/HB3_resolution/MnTe_contour.py similarity index 100% rename from scripts/MnTe_contour.py rename to scripts/HB3_resolution/MnTe_contour.py diff --git a/scripts/MnTe_lines.py b/scripts/HB3_resolution/MnTe_lines.py similarity index 100% rename from scripts/MnTe_lines.py rename to scripts/HB3_resolution/MnTe_lines.py diff --git a/scripts/rez_dispH.py b/scripts/Sunny_enabler/rez_dispH.py similarity index 100% rename from scripts/rez_dispH.py rename to scripts/Sunny_enabler/rez_dispH.py diff --git a/scripts/rez_loader.jl b/scripts/Sunny_enabler/rez_loader.jl similarity index 100% rename from scripts/rez_loader.jl rename to scripts/Sunny_enabler/rez_loader.jl diff --git a/scripts/scans_rez.py b/scripts/Sunny_enabler/scans_rez.py similarity index 100% rename from scripts/scans_rez.py rename to scripts/Sunny_enabler/scans_rez.py diff --git a/scripts/test_fit_group.py b/scripts/test_fit_group.py deleted file mode 100644 index c5bd32d5..00000000 --- a/scripts/test_fit_group.py +++ /dev/null @@ -1,53 +0,0 @@ -import matplotlib.pyplot as plt - -from tavi.data.tavi import TAVI -from tavi.plotter import Plot1DManager, Plot2DManager - - -def test_fit_group(tavi): - scan_list1 = [dataset[f"scan{i:04}"] for i in range(90, 121, 5)] + [ - dataset[f"scan{i:04}"] for i in range(127, 128, 5) - ] - sg1 = tavi.generate_scan_group(signals=scan_list1, signal_axes=("persistent_field", "s1", "detector")) - - # --------------- plot contour --------------- - contour1 = sg1.generate_contour(rebin_steps=(None, None), norm_channel="mcu", norm_val=1) - plt2d1 = Plot2DManager() - plt2d1.zlim = [0, 5e2] - plt2d1.title = "(0,0,1)" - plt2d1.plot_contour(*contour1) - - # x, y, xerr, yerr, xlabel, ylabel, title, label = curve1 - # f1 = Fit(x=x, y=y, fit_range=(0.0, 4)) - # f1.add_background(values=(0.7,)) - # f1.add_signal( - # values=(None, 3.5, None), - # vary=(True, True, True), - # ) - # f1.add_signal( - # model="Gaussian", - # values=(None, 0, None), - # vary=(True, False, True), - # mins=(0, 0, 0.1), - # maxs=(None, 0.1, 0.3), - # ) - # f1.perform_fit() - - p1 = Plot1DManager() - # p1.plot_curve(*curve1) - # p1.plot_curve(f1.x_plot, f1.y_plot, fmt="-") - - -if __name__ == "__main__": - tavi = TAVI() - - tavi_file_name = "./test_data/tavi_test_exp1031.h5" - tavi.new(tavi_file_name) - - nexus_file_name = "./test_data/nexus_exp1031.h5" - tavi.load_nexus_data_from_disk(nexus_file_name) - dataset = tavi.data["IPTS32912_HB1A_exp1031"] - - test_fit_group(tavi) - - plt.show() diff --git a/scripts/test_plotter.py b/scripts/test_plotter.py deleted file mode 100644 index 1c329cbf..00000000 --- a/scripts/test_plotter.py +++ /dev/null @@ -1,78 +0,0 @@ -import matplotlib.pylab as plt - -from tavi.data.tavi import TAVI -from tavi.instrument.resolution.cooper_nathans import CN -from tavi.plotter import Plot1DManager, Plot2DManager - -# from tavi.instrument.instrument_params.python_dicts.cg4c import cg4c_config_params -# from tests.test_data_folder.test_samples.python_samples.nitio3 import nitio3 - - -def test_plot_scan(tavi): - datasets = list(tavi.data.keys())[0] - s1 = tavi.data[datasets]["scan0042"] - # x, y, xerr, yerr, xlabel, ylabel, title, label - curve1 = s1.generate_curve(norm_channel="mcu", norm_val=30, rebin_type="grid", rebin_step=0.25) - - s2 = tavi.data[datasets]["scan0043"] - curve2 = s2.generate_curve(norm_channel="mcu", norm_val=30, rebin_type="grid", rebin_step=0.25) - - p1 = Plot1DManager() - p1.plot_curve(*curve1) - p1.plot_curve(*curve2) - - plt.show() - - -def test_2d_plot(tavi, tas): - datasets = list(tavi.data.keys())[0] - - scan_list = [tavi.data[datasets][f"scan{i:04}"] for i in range(42, 49, 1)] + [ - tavi.data[datasets][f"scan{i:04}"] for i in range(70, 76, 1) - ] - - # overplot contour - sg1 = tavi.generate_scan_group(signals=scan_list, signal_axes=("qh", "en", "detector")) - contour1 = sg1.generate_contour(rebin_steps=(0.025, 0.1)) - - plt2d = Plot2DManager() - plt2d.zlim = [0, 80] - plt2d.plot_contour(*contour1) - - # ----------------------------------------------- - # generate 2D rez plot - # ----------------------------------------------- - - projection = ((1, 1, 0), (-1, 1, 0), (0, 0, 1)) - q1 = [-0.5, 0.1, 0.05] # start, stop, step - q2 = 0 - q3 = 3 - en = [0, 4, 0.4] # start, stop, step - - ef = 4.8 - R0 = False - - plt2d.rez_plot(tas, projection, q1, q2, q3, en, ef, R0) - - -if __name__ == "__main__": - tavi = TAVI() - - tavi_file_name = "./test_data/tavi_test_exp424.h5" - tavi.open(tavi_file_name) - - tas = CN() - # tas.load_instrument_from_dicts(cg4c_config_params) - # tas.load_sam ple(nitio3) - - instrument_config_json_path = "./src/tavi/instrument/instrument_params/cg4c.json" - sample_json_path = "./test_data/test_samples/nitio3.json" - - tas.load_instrument_params_from_json(instrument_config_json_path) - tas.load_sample_from_json(sample_json_path) - - test_2d_plot(tavi, tas) - - # test_plot_scan(tavi) - - plt.show() diff --git a/scripts/test_scan.py b/scripts/test_scan.py deleted file mode 100644 index 2a269cff..00000000 --- a/scripts/test_scan.py +++ /dev/null @@ -1,102 +0,0 @@ -import matplotlib.pyplot as plt - -from tavi.data.tavi import TAVI - - -def test_plot_scan(tavi): - print(len(tavi.data)) - datasets = list(tavi.data.keys())[0] - print(datasets) - s = tavi.data[datasets]["scan0042"] - s.plot_curve() - # s.plot_curve(norm_channel="mcu", norm_val=30, rebin_type="grid", rebin_step=0.25) - s.plot_curve(rebin_type="grid", rebin_step=0.25) - s.plot_curve(norm_channel="time", norm_val=30, rebin_type="grid", rebin_step=0.25) - s.plot_curve(rebin_type="tol", rebin_step=0.25) - s.plot_curve(norm_channel="time", norm_val=30, rebin_type="tol", rebin_step=0.25) - - plt.show() - - -def test_scan_group_contour_exp710(): - tavi = TAVI() - - tavi_file_name = "./tests/test_data_folder/tavi_test_exp710.h5" - tavi.new(tavi_file_name) - - nexus_file_name = "./tests/test_data_folder/nexus_exp710.h5" - tavi.load_nexus_data_from_disk(nexus_file_name) - - scan_list = ( - [tavi.data[f"scan{i:04}"] for i in range(214, 225, 1)] - + [tavi.data[f"scan{i:04}"] for i in range(279, 282, 1)] - + [tavi.data[f"scan{i:04}"] for i in range(50, 60, 1)] - # + [tavi.data[f"scan{i:04}"] for i in range(91, 101, 1)] - ) - - sg1 = tavi.generate_scan_group(signals=scan_list, signal_axes=("qh", "en", "detector")) - # contour1 = sg1.generate_contour(rebin_steps=(0.1, 0.5)) - contour1 = sg1.generate_contour(rebin_steps=(None, None)) - sg1.plot_contour(contour1, cmap="turbo", vmax=40, ylim=[0, 70]) - - sg2 = tavi.generate_scan_group(signals=scan_list, signal_axes=("ei", "qk", "detector")) - contour2 = sg2.generate_contour() - sg2.plot_contour(contour2, cmap="turbo", vmax=40) - - plt.show() - - -def test_scan_group_contour(tavi): - dataset = tavi.data["IPTS32124_CG4C_exp424"] - - print(len(dataset)) - scan_list = [dataset[f"scan{i:04}"] for i in range(42, 49, 1)] + [dataset[f"scan{i:04}"] for i in range(70, 76, 1)] - - sg1 = tavi.generate_scan_group(signals=scan_list, signal_axes=("qh", "en", "detector")) - contour1 = sg1.generate_contour(rebin_steps=(0.025, 0.1)) - sg1.plot_contour(contour1, cmap="turbo", vmax=80) - - sg2 = tavi.generate_scan_group(signals=scan_list, signal_axes=("en", "qh", "detector")) - contour2 = sg2.generate_contour(rebin_steps=(0.1, 0.025)) - sg2.plot_contour(contour2, cmap="turbo", vmax=80) - - sg3 = tavi.generate_scan_group( - signals=scan_list, - signal_axes=("qk", "ei", "detector"), - ) - contour3 = sg3.generate_contour(rebin_steps=(0.025, 0.1), norm_channel="mcu", norm_val=30) - sg3.plot_contour(contour3, cmap="turbo", vmax=40) - - plt.show() - - -def test_scan_group_waterfall(tavi): - print(len(tavi.data)) - scan_list = [tavi.data[f"scan{i:04}"] for i in range(42, 49, 1)] + [ - tavi.data[f"scan{i:04}"] for i in range(70, 76, 1) - ] - - # sg1 = tavi.generate_scan_group(signals=scan_list, signal_axes=("qh", "en", "detector")) - # wf1 = sg1.generate_contour(rebin_steps=(0.025, 0.1), norm_channel="mcu", norm_val=120) - # sg1.plot_waterfall(wf1, ylim=[0, 1.4e3], xlim=[0, 6.5], fmt="o", shifts=1e2) - - sg2 = tavi.generate_scan_group(signals=scan_list, signal_axes=("en", "qh", "detector")) - wf2 = sg2.generate_contour(rebin_steps=(0.1, 0.025), norm_channel="mcu", norm_val=120) - sg2.plot_waterfall(wf2, ylim=[0, 1.4e5], xlim=[-0.6, 0.2], fmt="-o", shifts=1e2) - - plt.show() - - -if __name__ == "__main__": - tavi = TAVI() - - tavi_file_name = "./test_data/tavi_test_exp424.h5" - tavi.open(tavi_file_name) - - # test_scan_group_contour(tavi) - - # test_scan_group_waterfall(tavi) - - # test_scan_group_contour_exp710() - - test_plot_scan(tavi) diff --git a/src/tavi/data/fit.py b/src/tavi/data/fit.py index 4ec6c1ea..57b0e3f1 100644 --- a/src/tavi/data/fit.py +++ b/src/tavi/data/fit.py @@ -171,12 +171,15 @@ def x_to_plot( def eval(self, pars: Parameters, x: np.ndarray) -> np.ndarray: return self.model.eval(pars, x=x) - def fit(self, pars: Parameters) -> ModelResult: + def fit(self, pars: Parameters, USE_ERRORBAR=True) -> ModelResult: - result = self.model.fit(self.y, pars, x=self.x, weights=self.err) + if USE_ERRORBAR: + result = self.model.fit(self.y, pars, x=self.x, weights=self.err) + else: + result = self.model.fit(self.y, pars, x=self.x) if result.success: self.result = result self._parameters = result.params return result else: - return None + raise ValueError("Fitting failed") diff --git a/src/tavi/data/scan.py b/src/tavi/data/scan.py index 1ba7b9ab..b7e5cf5c 100644 --- a/src/tavi/data/scan.py +++ b/src/tavi/data/scan.py @@ -183,6 +183,18 @@ def validate_rebin_params(rebin_params: float | int | tuple) -> tuple: raise ValueError(f"Unrecogonized rebin parameters {rebin_params}") return rebin_params + def _get_del_q(self): + """Calculate del_q for aeither a s1 scan or a th2th scan""" + qs = self.data["q"] + q_diff = np.max(qs) - np.min(qs) + mid_idx = int((len(qs) - 1) / 2) + if q_diff > 0.0001: # q changing, must be a th2th scan + return qs - qs[mid_idx] + else: # q not changing, must be a s1 scan + q_abs = np.mean(qs) + s1s = self.data["s1"] + return np.deg2rad(s1s - s1s[mid_idx]) * q_abs + def get_data( self, axes: tuple[Optional[str], Optional[str]] = (None, None), @@ -205,7 +217,11 @@ def get_data( x_str = self.scan_info.def_x if x_str is None else x_str y_str = self.scan_info.def_y if y_str is None else y_str - scan_data_1d = ScanData1D(x=self.data[x_str], y=self.data[y_str]) + if x_str == "del_q": + scan_data_1d = ScanData1D(x=self._get_del_q(), y=self.data[y_str]) + else: + scan_data_1d = ScanData1D(x=self.data[x_str], y=self.data[y_str]) + label = "scan " + str(self.scan_info.scan_num) title = f"{label}: {self.scan_info.scan_title}" diff --git a/test_data/IPTS9879_HB1A_exp978/La2Ni7.json b/test_data/IPTS9879_HB1A_exp978/La2Ni7.json new file mode 100644 index 00000000..79b686cd --- /dev/null +++ b/test_data/IPTS9879_HB1A_exp978/La2Ni7.json @@ -0,0 +1,33 @@ +{ + "type": "xtal", + "a": 5.055640, + "b": 5.055640, + "c": 24.597968, + "alpha": 90, + "beta": 90, + "gamma": 120, + "shape": "cylindrical", + "mosaic_h": 0, + "mosaic_v": 0, + "ub_matrix": [ + -0.007780, + -0.010850, + 0.040605, + -0.194566, + -0.200455, + -0.001928, + 0.119371, + -0.108931, + -0.000496 + ], + "plane_normal": [ + 0.013441, + 0.025785, + 0.999577 + ], + "in_plane_ref": [ + 0.998800, + -0.047426, + -0.012208 + ] +} \ No newline at end of file diff --git a/test_data/IPTS9879_HB1A_exp978/hb1a_2.json b/test_data/IPTS9879_HB1A_exp978/hb1a_2.json index 62eb73ac..c7c5a4f8 100644 --- a/test_data/IPTS9879_HB1A_exp978/hb1a_2.json +++ b/test_data/IPTS9879_HB1A_exp978/hb1a_2.json @@ -13,7 +13,7 @@ "type": "PG002", "mosaic_h": 30, "mosaic_v": 30, - "sense": 1, + "sense": "+", "shape": "rectangular", "width": 10.0, "height": 18.0, @@ -27,14 +27,14 @@ }, "monitor": {}, "goniometer": { - "sense": -1, + "sense": "-", "type": "Y-ZX" }, "analyzer": { "type": "Pg002", "mosaic_h": 30, "mosaic_v": 30, - "sense": 1, + "sense": "+", "shape": "rectangular", "width": 15.0, "height": 15.6, @@ -61,9 +61,9 @@ }, "collimators": { "h_pre_mono": 40, - "h_pre_sample": 20, - "h_post_sample": 20, - "h_post_ana": 20, + "h_pre_sample": 40, + "h_post_sample": 40, + "h_post_ana": 80, "v_pre_mono": 600, "v_pre_sample": 600, "v_post_sample": 600, diff --git a/test_data/IPTS9879_HB1A_exp978/hb1a_La2Ni7.json b/test_data/IPTS9879_HB1A_exp978/hb1a_La2Ni7.json new file mode 100644 index 00000000..c7c5a4f8 --- /dev/null +++ b/test_data/IPTS9879_HB1A_exp978/hb1a_La2Ni7.json @@ -0,0 +1,72 @@ +{ + "source": { + "shape": "rectangular", + "width": 0.0, + "height": 0.0 + }, + "guide": { + "in_use": false, + "div_h": 0.0, + "div_v": 0.0 + }, + "monochromator": { + "type": "PG002", + "mosaic_h": 30, + "mosaic_v": 30, + "sense": "+", + "shape": "rectangular", + "width": 10.0, + "height": 18.0, + "depth": 0.0, + "curved_h": false, + "curvh": 0.0, + "optimally_curved_h": false, + "curved_v": true, + "curvv": 0.0, + "optimally_curved_v": false + }, + "monitor": {}, + "goniometer": { + "sense": "-", + "type": "Y-ZX" + }, + "analyzer": { + "type": "Pg002", + "mosaic_h": 30, + "mosaic_v": 30, + "sense": "+", + "shape": "rectangular", + "width": 15.0, + "height": 15.6, + "depth": 0.0, + "curved_h": false, + "curvh": 0.0, + "optimally_curved_h": false, + "curved_v": true, + "curvv": 0.0, + "optimally_curved_v": false + }, + "detector": { + "shape": "rectangular", + "width": 5.08, + "height": 5.08 + }, + "distances": { + "src_mono1": 474.5, + "mono1_mono2": 227.6, + "src_mono": 474.5, + "mono_sample": 143.13, + "sample_ana": 74.0, + "ana_det": 50.0 + }, + "collimators": { + "h_pre_mono": 40, + "h_pre_sample": 40, + "h_post_sample": 40, + "h_post_ana": 80, + "v_pre_mono": 600, + "v_pre_sample": 600, + "v_post_sample": 600, + "v_post_ana": 600 + } +} \ No newline at end of file