From 8a43826e77b56397b7223d49e8da08444e832681 Mon Sep 17 00:00:00 2001 From: RealPolitiX Date: Tue, 20 Oct 2020 04:37:53 -0500 Subject: [PATCH] Title change --- Tutorial/Tutorial_01_Basic_Binning.ipynb | 345 +++++++++++++++++++++++ processor/__init__.py | 2 +- setup.py | 2 +- 3 files changed, 347 insertions(+), 2 deletions(-) create mode 100644 Tutorial/Tutorial_01_Basic_Binning.ipynb diff --git a/Tutorial/Tutorial_01_Basic_Binning.ipynb b/Tutorial/Tutorial_01_Basic_Binning.ipynb new file mode 100644 index 0000000..7788eb8 --- /dev/null +++ b/Tutorial/Tutorial_01_Basic_Binning.ipynb @@ -0,0 +1,345 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This tutorial will get you through the basics of running the software and get you to binning your hextof data in no time!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 1: setup the software" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following commands will compile the cython scripts and generate the settings file.\n", + "It is recommended that the SETTINGS.ini file be updated after running this tutorial.\n", + "The directories should be changed to the appropriate values." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "running build_ext\n", + " -> No Settings found. Initializing new Settings file.\n", + " -> New setting file generated.\n" + ] + } + ], + "source": [ + "%%bash\n", + "cd ..\n", + "python3 setup.py build_ext --inplace\n", + "yes | python3 InitializeSettings.py" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "/!\\ Please make sure you are using python3, as some of the libraries are not python2 compatible" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "/!\\ The repo does not include a copy of the PAH library. A good idea would be to install it, then change the SETTINGS.ini file accordingly. By running the following command, the SETTINGS.ini file should be already be confired correctly\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Process is interrupted.\n" + ] + } + ], + "source": [ + "%%bash\n", + "cd ../..\n", + "git clone https://stash.desy.de/scm/cs/pah.git" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 2: main imports" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Most of these imports are either necessary or very important for the online analysis\n", + "It is recommended that missing libs be installed with pip3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Imports needed for the user machine at FLASH (as we needed to install code locally as a user)\n", + "import sys, os\n", + "from datetime import datetime\n", + "\n", + "repo = os.path.dirname(os.getcwd())\n", + "sys.path.append(repo)\n", + "\n", + "import math\n", + "import pylab as pl\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from importlib import reload\n", + "import processor.DldFlashDataframeCreator as DldFlashProcessor\n", + "import processor.utils as utils" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following libraries were written by Patrick Xian and they have been very useful for visualizing data on the beamline in the past. They are necessary for some parts of the tutorial (that do not exist yet)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Process is terminated.\n" + ] + } + ], + "source": [ + "%%bash\n", + "pip3 install git+https://github.com/RealPolitiX/mpes.git\n", + "pip3 install git+https://github.com/RealPolitiX/animo.git" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Patrick's libs:\n", + "import animo as a\n", + "from mpes import visualization as vis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 3: loading data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The tutorial folder contains some sample data that can be loaded and sliced (binned)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2018-07-22 20:47:29.285247\n", + "Reading DAQ data from run 22097... Please wait...\n", + "Run 22097 contains 7,064 Macrobunches, from 99,007,477 to 99,014,541\n", + "Number of electrons: 6,952,657; 984 e/Mb \n", + "Creating dataframes... Please wait...\n", + "[########################################] | 100% Completed | 5.6s\n", + "Electron dataframe created.\n", + "Microbunch dataframe created.\n" + ] + } + ], + "source": [ + "runNumber = 22097\n", + "\n", + "print(format(datetime.now()))\n", + "\n", + "processor = DldFlashProcessor.DldFlashProcessor()\n", + "processor.runNumber=runNumber\n", + "processor.readData()\n", + "processor.storeDataframes()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "after running this code, the data has been loaded, the dataframes have been created, and they have been saved to disk in parquet format for easy loading in RAM." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 4: slicing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cells defines all the necessary parameters for binning in the following cells" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "runNumber = 22097\n", + "\n", + "# Time of flight parameters\n", + "ToFfrom = 650\n", + "ToFto = 700\n", + "ToFstep = processor.TOF_STEP_TO_NS*10\n", + "\n", + "# delay parameters\n", + "delayFrom=-517\n", + "delayTo=-512.5\n", + "delayStep=0.05\n", + "\n", + "# detector position parameters\n", + "dldFrom=0\n", + "dldTo=3000\n", + "dldStep=30" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell actually performs the binning after loading the pre-processed dataframes" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 3/3 [00:05<00:00, 1.86s/it]\n" + ] + } + ], + "source": [ + "processor = DldFlashProcessor.DldFlashProcessor()\n", + "processor.runNumber = runNumber\n", + "processor.readDataframes()\n", + "processor.postProcess()\n", + "\n", + "processor.resetBins()\n", + "ToF = processor.addBinning('dldTime', ToFfrom,ToFto,ToFstep)\n", + "\n", + "result = processor.computeBinnedData()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And here are the results!" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD8CAYAAAB+UHOxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJztnX2QHGed37+/mW3Js4LTrLAg1lhCisvIhU5Ia+/ZShQCNolk4zPe8wvCZxcOXOIKgatI4Ta1Ci5LNiZWWMCECscVFxwg9pm1sW9PnHyRfUgXqhxkWLErC91JWJyxrJHBItKInHZsjXaf/DHdo56efvptuuel5/up2tqZZ3pm+pmZfn7P712UUiCEENJ7ZNp9AoQQQtoDBQAhhPQoFACEENKjUAAQQkiPQgFACCE9CgUAIYT0KBQAhBDSo1AAEEJIj0IBQAghPUpfu0/Ai4svvlgtX7683adBCCFdxf79+3+tlFrsd1xHC4Dly5djcnKy3adBCCFdhYi8EuQ4moAIIaRHoQAghJAehQKAEEJ6FAoAQgjpUSgACCGkR+noKCBCCEkzE1NFjO0+ghOlMpbkcxjZuBLDg4WWvT8FACGEtIGJqSK2Pn0Q5cosAKBYKmPr0wcBoGVCgCYgQghpA2O7j9QWf4tyZRZju4+07BwoAAghpA2cKJVDjScBBQAhhLSBJflcqPEkoAAghJA2MLJxJXJGtm4sZ2QxsnFly86BTmBCCGkDlqOXUUCEENKDDA8WWrrgO6EJiBBCehQKAEII6VEoAAghpEehACCEkB6FAoAQQnoUCgBCCOlRKAAIIaRHoQAghJAehYlghBDSQtrdA8COKKXa8sZBGBoaUpOTk+0+DUIIiQVnDwAAMDKCt1zUh9JMJTaBICL7lVJDfsdRAyCEkBbh1gOgMqdweqYCoPVNYegDIISQFhGk1n8rm8JQABBCSIvI9xuBjiuWyli/Yw8mpoqJng8FACGEtIgwLlfLHJSkEKAPgBBCEsAt2udMuRLqNSxzUFL+AAoAQgiJGWe0T7FUxsiTByASTgsAku0RTAFACCExo4v2iUJQv0EU6AMghJCYiXPX/oZDkMSJrwAQkUdE5HUR+altbK2I7BORaRGZFJGrzXERka+IyFEReVFErrQ9524Recn8uzuZ6RBCSPuJc9derswl5ggOogF8E8D1jrHPA7hfKbUWwH3mfQC4AcDl5t89AL4GACKyCMA2ANcAuBrANhEZaPbkCSGk05iYKuLMTDhnrx9J5QX4+gCUUj8QkeXOYQC/Zd5eCOCEeftmAN9W1foS+0QkLyKXAHg/gOeUUqcAQESeQ1WoPN7sBAghpN3YI34yIpiL+fWTcgRHdQJvBrBbRL6AqhbxT83xAoBXbccdN8d04w2IyD2oag9YtmxZxNMjhJDWcO/EQTy27xgsF+9sAvXVluRzsb8mEN0J/AkAW5RSSwFsAfCNuE5IKfV1pdSQUmpo8eLFcb0sIYTEzsRUsW7xT4KckcXIxpWJvHZUAXA3gKfN20+iatcHgCKApbbjLjXHdOOEENK1jO0+kujiX8jn8NAtqxNLBIsqAE4AeJ95+zoAL5m3dwL4qBkNtA7AGaXUawB2A9ggIgOm83eDOUYIIV1LUrb5+X0ZfHnTWjw/el2iVUF9fQAi8jiqTtyLReQ4qtE8/wbAfxWRPgBvwLTZA3gGwAcBHAUwA+BjAKCUOiUinwXwY/O4ByyHMCGExEXSzVacr5/vN2qlnOPkzfNzGPnuAQDJloVmQxhCSCpwa7aSM7KhTCj2BX5hzoAIao1alr8th+d/Xr9vzQDIZgWV2WTW0UI+h+dHrwv9PDaEIYT0FG7lF3TF1Nw0BQAY+e6B2mJeshVuK5bKKLqYe+YAzNkW/3zOqHtesyRZBwigACCEpATdYukcd4ZtWmWXM4Kmd/JxLv5AcuGfFqwFRAhJBbrF0j6uC9ssV2Zx9lxyNXeiMnPufKL9ACgACCGpYGTjSuSMbN2YM4Y+6bDNuDk9U0m0KQwFACEkFQwPFvDQLatRyOcgcI+h97KpSwvO0Y2BfgMDHsXjkuwRTB8AISQ1DA8WPCN+luRzrs5cAMgZGcxU4q7i40//vD5fZ29SzmBqAISQnsHNTGQRZvEv5HO4a108tcqsSCQvOq0WECGEdB12M1EznCiV8eDw6ljMRlYYqk4wdWItIEII6UqGBwtNL6jWjrzZnbm1uDsFU1aqoiXpWkDMBCaE9Bzrd+zR+gKC0B+Dv6CQQKkKC2YCE0KIhmadqnEs/lFKPMQNTUCEkJ5hYqqItfc/25JcAMuM40bSJR6CQgFACOkJJqaKGHnyQOzlGnTMKaV1Nidd4iEoNAERQlKNVfitGZt/FJbkc7j2isUNpSeSjOoJCwUAISS1uJWIbgU5I4trr1iMp/YX6xZ/AXDrVd7Jaq2EAoAQklrcSkS7IUBtoc4IMNekk+AiI4NH9x1rGFcA9h4+2dyLxwh9AISQ1BLU2Wpf75td/AF4dgnrFAcwQAFACEkxneJstdNJ50QBQAjpeiamili/Yw9WjO7C+h17auWTvUostINOcgAD9AGQFpB0o27S2zgdvVaHL+BCQ/V2RAE5STLzNyoUACRRglychDSDVy9g6/Gk7O5GRlDxcRoYWcHYbWs68vdOExBJFL+Lk5Bm0S3u1majWConkvmbFf/FHwA6uQUZBQBJlKCNugmJipdT1S8ENGo555yRxWzAQpqVOdWxGx4KAJIoQRp1E9IMURy9VsvIO9ct86zZYycrUtdqMkxPgU7d8NAHQBJlZOPKhkzMTouEIN2N3dF7olRGRsRzd25V4rT8U0F28jkj61qX3/nbtieU2enUDQ8FAEkU58XJKCCSBPZewCtGd2mPMzKCmXPnsWJ0l1ZQZEVwxzVLsffwSc/frNtv2yr/0C0bHjaEIYR0BM2GC/sVfRMAfVlBZdZ7zRMAL++4McSZu59HOzc8bAhDCOkawoYLOxdZt523k/55WZw9518XSGeuCbqw27WRTocCgBDSdrzChZ2LqZuwcJZcdiPI4q8z19w7cbDuPdKSz0IBQAhpO0HChb1MPHEYsgf6DWy7aZWrwHETMDoB1U34hoGKyCMi8rqI/NQx/ociclhEDonI523jW0XkqIgcEZGNtvHrzbGjIjIa7zQIId2MX7iwtetPspzD6ZkKxnYfqdURshjbfUQrYDo1vDMoQfIAvgngevuAiFwL4GYAa5RSqwB8wRx/N4CPAFhlPuePRSQrIlkAXwVwA4B3A7jDPJYQQlxj+e3mmKB1/ZulWCpj8/g0Bh94tiYIvBb5Tg3vDIqvCUgp9QMRWe4Y/gSAHUqpN81jXjfHbwbwHXP8ZRE5CuBq87GjSqm/BwAR+Y557N82PQNCSNfjFy7c6p326ZlKzca/JJ9z1TwEqPMXdEL0T1ii+gDeBeC9IvI5AG8A+COl1I8BFADssx133BwDgFcd49dEfG/S4XTjhUDaj1f0jG4RThLLxu+WzAhUo4osurXoYdRSEH0AFgFYB2AEwBMiAfOpfRCRe0RkUkQmT57snNZpJBh2W61C9ULYMj6NeycOtvvUSBdi1fkvlsoNdXuMjCATy6qj50SpjOHBAh66ZTXyOaPusbPnZrH16YO1DU83Fj2MKgCOA3haVfkRgDkAFwMoAlhqO+5Sc0w33oBS6utKqSGl1NDixYsjnh5pF24XggLw2L5jDc41QrxwOn4VLhRvy+cMIETvXp2cyOcMzzpClo1/eLCABfMbDSbWIt+tRQ+jmoAmAFwLYK+IvAvAPAC/BrATwJ+JyJcALAFwOYAfofr5Xy4iK1Bd+D8C4PebPHfSgeh+8ArA5vFpjO0+gmuvWFyXZm/dL5bKyJrp+Z3YPIO0Ft1mIp8zsGB+H0plfd9dJzo5caZcwcOb1mL7zkMNr+fMCfBa5HUmqk53EvsKABF5HMD7AVwsIscBbAPwCIBHzNDQcwDuVtWaEodE5AlUnbvnAXxSKTVrvs6nAOwGkAXwiFLqUALzIW3Gz1ZbLJXx6L5j2vtWbZZusaGSeLD7jRbmDIjoG6uXypVQi78XS/K5mu9B57uyxnVCxDq2G4seshYQiZWJqSK2jE/H1gPDqtxI0ovTgdoMOSODcmUu8PFf3rTWc4Phd272KqGdFPzAWkCkLQwPFjD5yqlAqflB6HQbKmmeuGL8c0YWF4UQAPmc4btAe52b00zZTTWALNgQhsTOg8Or8fCmtaEaZujodBsqaZ44hHxGgIduWY2SxmzkJGdksf1Dq3yP052bAHh+9LquW/CdUAMgseK05fYbGcyEUMntdIMNlQRHZyKJI8Z/TlWDDDIC+Fm1syKuzV3c6FbnblCoAZDYcOYAlMqVhsV/oN/AXeuWoZDP1drrWfcB1NrzWW33un2HRaq45YdYMfRRWjrqCBIW+sUPrwn8u/IrUdHtUAMgkXDbzQWx5fbP68ODw6tbdJakU9AlSm0en0Yhn8OVyxbi//z8VGzBA37nYr8dtutXmsKTGQVEQjExVdTGTAdx5Nm7LXVS1ARJlhWjuzwXd10v3aQwMgIIGrqD6UpCdxuMAiKx4xUSV67M1pK4vHCW97XXTtk8Po3N49OeddkpMLoTPzt/q7ehFY2tyF4Erhd+W/QBkMD4mXhmldKm3FsUS2UsH92F//DEtPa1Ts9UMPLdA3WlI7xsyKTzufaKxb6/jU6hG2r4xAU1ABKYIOF6QXdyfs66yqzC9p2Hajv+jIt2kYaOTGnATzObmCriqf3F0Lt8IyMwshI5iqwZeiX/hBoACUyrQ99K5Uptx68zLfXKhdqpBNHMoiR6FfI5jN2+BgML5sd8xhcwsnqdJC1hnn5QAJDAxBmuFxe9cqF2KkHKIIcV0lmRWpJVEgJeANy1bhnGblvTUOIZSFeYpx8UACQwVl30ODJ846CXLtROJUgZ5LBC2q7tRRXwd61b5rpZGeg38PCmtXhwuJpjMr1tA75sZq1beSm9lH9CHwAJhVXvxGrS0SwZAS7qC54tnBXBnFKMAuoQgmTK6jpq6bB25RNTRZx983zoc8qK4MHh1Rh656JAUWPdWMMnLigASCTCXtRGRlxD7+YUQjn5wmRxkuQJUgbZ+r7c8kfcOHvuPO780x9GTgyzNIheXtiDQhMQicTwYAG3XuV9cdnLOmy6eqnnsUEIUr2RtBa7WdDPhPLm+WCCvjKr8LzH4p/PGRjob7TdW3SKibIboAZAIjExVcT4j171PGZWqdpusNm4agHqqjcyKaxzCLLTjqvkswCY3rYBgHtiIv1C4aAAIKGwFt6g9v9yZRaffuKAb4awH3euW1ZbZNyyiHspe7MbiSuaZ6EtaiftdXpaAQUACUzUzk3NLv7rL1tUV0DOK/SQF397cNPIAHgm8unwqgt09tx5TEwVu7oJSyfBYnCkAZ15ZfCBZ7V9WpPE3nYP8C4sxmbyrefeiYMNHeB0xdaCsP6yRfjJsTOeG41CPodrr1iMvYdPcvfvAovBkUjozCtPTh5ry+IPXDAjAfBtIEJzUGuZmCq6tv/UFVsLwk+OncGtVxXw6L5j2mOKpXLd4/bvHaBZKCjUAEgdccX3J4GlCQDwNUWxmXxrSPL3EqS6rJN8zsCb5+caHMO9lNwFUAMgIQnr3G0H5costu88hAXz+3zLT7NGUGtI8nOO4jtyyzOgf0gPBQCJ7NyNizDNQErlSu0it8pPuz13oUuNFxI/cfTzbQXcELjDRDASW4x2FIyMQJooFK8THKVyBfdOHNQ8SuKikwoE5oysNkGMRQPdoQAgie2OgqzrlTkVqJF3FB7bd4wNYxImaoFAe5b4+ssWhX7fQj6Hu9Yta8hA3nbTqlQ3cY8bmoBIImp8zsji1qsKeOyFY2hXnIECaPttAVYsvl/fXytE14rQsd8PgwC+Dn5GAQWDUUAkVh+AAHWJQCNPHmgqJDCO87Ga0JP4uXfiIB5/4dXADlsjK3W5Ac77QWCElz+MAiKBGR4sYPKVU67x3GFwXpjrd+xp6+IPVLWA9Tv2cBeYAPdOHPSM1XfDudhXZhUy4t8i1ILmnHihACAAgL2HTza1+Auqjb/X79hTU707JTqEyWHxMzFVDL3465hT1YVdp4HO78vg3Pk5mnMSgE5gAqB5R7BC1elq7w2rIyviWc43nzMiR5ZkNSFFzjaFJDoTU0WMfPdArK/50C2rtd/dxW+Zj5d33FhrE0niw1cAiMgjIvK6iPzU5bFPi4gSkYvN+yIiXxGRoyLyoohcaTv2bhF5yfy7O95pkGaJI0wuiAaRM7L44ofXYNtNq6r1YhwYWcH2D63yXBC8mDNzA9xgLLg/E1NFrN+xBytGd2H9jj2uUVT3f+9QpBo/Oqw+D3NM6ms5QTSAbwK43jkoIksBbABg1wNvAHC5+XcPgK+Zxy4CsA3ANQCuBrBNRAaaOXESLyMbVwYK22wGe7OQ4cECxm6vb8o90G9g7LY1tcd1C4IXS/I5rTBjLLg3VjCAXYvb+vTBBiEQZ00oIyO1Pg/83lqPrwBQSv0AwCmXhx4G8B9Rv/G7GcC3VZV9APIicgmAjQCeU0qdUkqdBvAcXIQKaR/DgwXcuW5ZYkLACt2z1/Qf230EZ8oVFPI5fHnTWkzdt6FOxQ974Quqi9bZN8/DyNbPhM5Df3Rltj/9xAFPjSAqA/0Gxm6/0OLTLamM31uyRPIBiMjNAIpKKachsADA3ibquDmmGycdxIPDq/HwprW15JpmMnSdWIv5xFQRa+9/FpvHp313miMbV7qaiXRYO5FSuQKo6gLj16aQXEBnaplVqu576jficR0qVRU6lnABELi9JImH0FFAItIP4D+hav6JHRG5B1XzEZYtW5bEWxAHzvr/Vp31uKJ4rF2cV76BW8Gu4cEC7v/eoUgmh8qcQv+8Pkzdl8jPNJUEidwqV2aRzxmozKq6EN8MgGzImH57XSdLuDx0y2rG+LeQKKL8MgArABwQkV8AuBTAT0TkHwEoArB3/77UHNONN6CU+rpSakgpNbR48eIIp0fC4Gb3fdSM5gmKtUe3TDlftmkR9l2cX80htx1oqQl7M52H4Qha1+dMuYKx29fUfcdf2rQWY7etaaohOyO1Wk9oDUApdRDA2637phAYUkr9WkR2AviUiHwHVYfvGaXUayKyG8B/tjl+NwDY2vTZk6aJWgguK4I5pbSx2W5qu9+C7GbzbyafgM7DcDh77OraOC7J57StGIOUhPCCQru1+AoAEXkcwPsBXCwixwFsU0p9Q3P4MwA+COAogBkAHwMApdQpEfksgB+bxz2glHJzLJMW0Uz9/6gNNrwWc52zb2TjykhlKug8jIZ9YdeZ7GYcfXmd6L5n+6Zh5tx5V9MehXZr8RUASqk7fB5fbrutAHxSc9wjAB4JeX4kAZqp/dNMz13dYj7Qb2DbTau0O0oAWh+FWz+AjNSbE3rRiajr6xwG6/jtOw/VNVo5PVPB5vFp3P+9Qw3f28RUEWffPN/wWs5Ng9tv0Momj+v8iT8sBteDNNPG7xdNFlaL88IO0qS+F9sB6hZXhWgC3Otztn++uo2Fm4CvHvsiypW5hte79aoCntpf7Pm2js3AYnBESzN21hWju5pauHW247BMTBUDRQc5G8r3Am5+HWubF7Yukt/nbI/e0vmT+uf1uSz+BxsWf+v13KqLsq1jMlAA9CDNOFbt8eBA9EW1WU0gTLTIrFIYefIA7v/eIZRmKqk3KfgJ+DCLaZDP2Xo/3fsWS+W6jYNf4AH7PLcOFoPrQeJwjjYTshe05IAXYReDypzC6ZlK7f22jE9jeQLZrZ1AEEeq3+dn1QQKslGw3i/vUeDP/j37vaauBhQdxPFDDaAHsEf8ZM3QvjCN2HVE3ZHpSg6EUfGbLTetM4mkwfkYJHLKazENGyRgOW6DuBPLldnab9ANLx8Ao7rihxpAyrHvtoEL6nUcrv+oOzKd4AgjUOJcDCzhE4dm0gk4+/Q699M5I1vr3eBW4ydsbshfHngNQDVBLAizSrkmnA30G3joltV4cHg1S0K0CGoAKSdqopcTZ+u+ZnZkut17EIFi36HHyYlSORbNpFOwnO0TU8W6MM6BfgM3vueSuh22ZRLbPD6NQgTNynrtoFqZALj1qgL2Hj6p1bTiChYg3lAApJw4Fsp8zsD2D62KzTTiZqIIIlDi7F3sZEk+F4tm0km4fV5vVOaw68XXPKOEorD2/mfrcgW8UKh2oGPNn/ZDAZBymrWV54wstn9oVaw7MrfkriACJS5txoklfHSZ0RmRpsNfW83EVBGffuKAazhlEp+h2+I/0G9oQ0i7VaimDQqAlOPlEDQygrdc1Ke9SL0ydJslikCJe9EQoGFRd/usrEW0W3oLWzt/naO1VfTP60P/vL7I5j6SPBQAKcQZyWLZW+1RQFZGKICGCKFmyj0kiVeNmbCLXSGfazBBBCmG5ucTaHcUkW7n3w5OlMp4eNPaSOY+0hooAFKG0+5bLJXx1P6iaxSF81grOqMTF39A7zt46JbVANx3724I6qOIdIv28tFdrs/XaSJun30rNYZO2flbWFVDgfDmPtIaKABShi6SZfvOQw0XXbdFvfgtJpOvnMJj+455hrgKgDvXLdMWJbMW7clXTmlzJXTmi1Z/nk7BNXPufCL2/SgYWakJWUb0dC4UAClDtzstlSsNJXy7MerFazHZe/ik5+KfFcEd1yzFg8NVjcHLUfrovmOur+HUHuy08vN0E1xexJH4F5QkfUckXpgIljK8nGubx6frkn50x3arg85voZ1VCk/tL2JiqhjZXKKgN+e08vMMExGVFcGd65YF6vbVLAJg6r4NXPy7BAqAlOHnXCuWytg8Po3BB57F8re5L0xWan+3EWShLVdmsdlMeoraD0GHW0vFZh2eVk0eZ8ZuUK0iZ2TxxQ+vwYPDq3HrVckvyt26eehVKABSxvBgAQMeRbksTs9U8PzP3Zuy7T18Mu7TaglJR5YYGcHMufOu5ROA+hIMcZQw8CpNsTDn/h3njIz2/ZP+Xu12f9Id0AeQQm58zyVaG3YQOtkH4MXwYAGf+fODOHsufkeoAJgDajkTugifOB2eXk5lTcFMXGRktRm2SX+vCxx1/0nnQw0ghTS70+tmNf5zv7caRlazOjaBAjA7554TkBRe9fV1yXunZypYProLl219BvdOHKx7LOnvNWgxONI5UANIIc3s9Lo9ScfagW4en470fKtxuVsSmBvOZif2ktLNJtd5lfHwi+qZVaqmBT44vFrbqzdOunnj0KtQA0ghUS/ErEgqyu4ODxY8nbVe/FauDw9vWou5ENFBdvv8vRMHXctvRykt7eZUtr9nEB7dd6x2TkGLtUWlW4MHehkKgJQRdadnZAVf/PCarl/8LaJqMadnKtgyPo3+eeFDJq1+trroIi+TkVu0j+VUbpZH9x1rSYKYFWJLugcKgBRhRY1E2emN3ZaexR8IHg3lhgIiO5L9zEZu5jmvaJ9mtJmkyOcM17aNSftESPxQAKSIqOWS43eZdgbbblrVkuQnO7p+thYKCNSBy76YJuWTyRnhL3+rPLjORNatEWS9CgVAioha918Bqdy5+bVGjJuckcUd1yz1jUJy+gP8Skg0o814Ua7MIRPwQ3HmFaQti7xXYRRQSmjW9prWnZs9Lt/ZHjFO7OW1x3/0qu/x5costjwxjS3j09qIo4U5A+t37MGJUhkLc0ZDW844mAvwcm6ls6N2dSOdBTWAFGDZkJtBl1maJoYHC5jetiGR3bQV4jm2+wgqQVZVAEqZ+QUac0qpXKn5BUrlSqRqbmG1HufxgqrG4jRbxZ31TNoDNYAUEEerRB/TdarYdtOq2HsLWyWfm9Gk/GL7gwoWoL5PQtAGMTkjW9c8yH4+bpnPLPPc/VAAdBluSUZxUNJklqYRa9GKs3OWtfA304O5mTMxMsCcqv4eBEBGgC3j01iSz2HdPx7Q1n2yU67M1pq1r9+xp2EendwrgkSDJqAuwh4uCPiHHIah15x3w4OFUMleflj2emvn3EoyAsC2GbDCWK2Q0iCLv4UlyLqxVwQJDwVAFxGHqccNryYnaWViqohMTHavDC7Y64H6nXy/kUE2aKhNCLIiNdv7wpwRm3PYClPNa/wkvbZRSDu+AkBEHhGR10Xkp7axMRE5LCIvisifi0je9thWETkqIkdEZKNt/Hpz7KiIjMY/lfSTxO7L2SKxF4ijd65I9bPL5wzMeRw3U5lrKCIXB3NK4eUdN+L50etiN98VS2X8wxvnG8JZGeWTPoJoAN8EcL1j7DkAv62Ueg+AnwHYCgAi8m4AHwGwynzOH4tIVkSyAL4K4AYA7wZwh3ksCUHcu6+sCB7etLbWIrFXaFaTMjKCvBk19f/eSLbAmg4F1Cp+JrErr8wpLJjXxyiflOPrBFZK/UBEljvGnrXd3QfgNvP2zQC+o5R6E8DLInIUwNXmY0eVUn8PACLyHfPYv23q7HsMt9jrZphTqicv6GY0qXzOwNlz52vlmOP0w4TFqvg5LyvISLCY/jCcKVcwvW1DvC9KOoo4fAAfB/BX5u0CAHsWzHFzTDfegIjcIyKTIjJ58mR3dqZKCiv2Oh8yZl9nge5Ve65u3n5lHL68aS0WzO+LPRmrWc7NqtgXf6B3fx+9RFMCQEQ+A+A8gMfiOR1AKfV1pdSQUmpo8WKWl7WwqkVuGZ/Ggvl9WBCwWuWCeVnXhuC9bM/VlVm2QijdyOeMpuP8/cgZ2USS1ILgnHcv/z56ich5ACLyrwD8LoAPKFXTg4sAltoOu9Qcg8c48cFyWlqmn6Bx5kYGOPRA1X0z9M5FGNt9BCdK5brmJb2IVx6AQmNCllUADWguzt8NMd9sia2URNRmNlExsoJNv7MUew+f5O+jxxAVwIZp+gD+Uin12+b96wF8CcD7lFInbcetAvBnqNr9lwD4PoDLUb2mfgbgA6gu/D8G8PtKqUNe7zs0NKQmJydDTyptuCXlBMHISurKPMfJitFd2uSrQj7nuhg6hXEQ/DJ871q3rG7xLc2cS6SvsY58zqCtP2WIyH6l1JDfcUHCQB8H8EMAK0XkuIj8AYD/BuCtAJ4TkWkR+RMAMBf0J1B17v4vAJ9USs38SMRoAAAO7UlEQVQqpc4D+BSA3QD+DsATfos/uUBUs0NlVqWyymdcePkCdDvhKH4YS6vQ8ei+Y3W9AM6dn0ukr7EO9vLtXYJEAd3hMvwNj+M/B+BzLuPPAHgm1NkRAM2ZHZi5qUcXVeVs4wigQYv6zRvhFs0wPtrK3IVyDnE6d3WaCJ29vQszgbuAkY0rI5cX4MWtx1nRMmiXq/u/dyiRqBs7CvEu/gP9BoMBSAMUAF3A8GABd65bFloI8OL2Z3iwgOdHr8PLO24M3OXqdBcWzvtN+TyG3rmIJZxJHT1TDdSqotmNUQ4TU0XsPXwydLVIXtzh0Jna0qBFzSqFrU8fxEO3rG5o7kJ6l9RrABNTRay9/1lsHp92bbrd6TgrgAYlK4It49MNjTyIHrf8ADctKmwiXivxymVj03biJNUCwFo83VoAdsvFELVuzaxSXSfs2k3QLlfbP7QKRgIVPuPAL6qbQQHETqpNQH6LZzdcDHGcIxt5BCdIlyvr8aT6CwchnzMgEt4fkQZzFomPVGsAfotnqy4Gq4zDitFdoU0ycZ1jNwi7bmJ4sIAF81u/fxJUaxJNb9uAqfs2eAYGMOKH+JFqAeC3eF57RfK1huw2fDeTjJ9wiOuC5c4vOEEFdtxCNYhRSaE+J0H3vVrmK0b8EC9SbQLyK5+893Dy1UbdzFB2/4Ozxo8z8WjyleDt/IBqrXoI6ipWcucXHLe6S7pksCgJel7JXUGivAqOBd/tN25932zaTvxItQZgOfV0tMIs4tVb1U84AMDjL7zqfGod+ZxRt8sbu30Nxm5bw51fRPy+E7t2cPbNxq5Z1r1CPuda2XNOBdvpu+EmyIM6rglxI9UaAFC9QMZ2Hwkd3x1X3oBul5gR0e4ei6Uy1u/Yg5GNK30bjvzumktcO3pxAYiGl8B2agelcgVGRjDQb6A0U2n4nawY3eX6WmHyObIimFPK8zfInT6JSuoFAOCtJrsR1AwQREj41ZvRYb2nXz2YVpixegmvZDA37aAyp9A/rw9T9zVW02y2dDSruZKkSbUJyCKsmhzENOPn3NW9t1/XKed7+tWDKZo7UxIPXslgOu3A0tjcHPhujWeCsmBeHxd/kig9oQEA4dRkLzOAhZeQcL6P/b2Xa8wCXmQAzHk8rnNSkvBYn6GbZqczJQJ6LXF+X6b2O7F8AkFj91mmmSRNKjWAZuLuAb1vICNSe60gQsLtvKI4AOdQdfbqdpPdktXcLdgLxD0/el1tQffb0Tudxc4s9Dcqc7jxPZcE1goYukuSJnUCIKhpxguvnrHWa+kuTq+Ldmz3kdAF3SxK5Qrm9+m/LiZ6JY/dnKfD+h50GuLewyfx0C2rfU2BDN0lrSB1AiCI/d4P60LX1YffvvNQ4MJhdppdpEvlilaD4G6xNVjagU4IWFqil4Y4PFjQlp4GGMpJWkfqBEBU04zTZDQ8WNBG6lhqvd25m88ZuMjIeFbgXBhDFUm39oLcLbYePy0x75IDAFwQ1F4ZvHazEyFJkjonsF9Nd2fo5rVXLMZT+4sNIZ+Tr5zybOY9tvtI7UJ1CxvdMj6NzePTKNiciOfOx9PoW0HftJy0Buvz/vQTBxo2CuXKLOb3ZZAzstrQ47ChyYQkQeoEgNeF5bZQP7rvWMNrlCuzruN2/CKCrCXBHh0yU/GK5QmOtUsk7WV4sIAt49Ouj50pV/DwprXaPBGvaCNCWkXqBIDXhTX4wLORauu7YTfn+Nn2y5VZbNYsFFFoRRE7EgwvjdMv9JgZvKTdpE4AAO4X1sRUMdZerqVyBYMPPIvSTAWetqIEYPZv50BTDulmUikALDt/sVRGVgSzSoXKwA1KTaC0cPEHGPLZSdCUQ7qZ1AkAp53fctD51d7pJhjy2VnQlEO6ldSFgUbtodtN0LxACImD1AmAZs0jA/1GrWCcWz33dpMzMtxtEkJiIXUmoGZK8AqAbTetqi2wE1NFjDx5ABW/kpwtwsgIHrrlPe0+DUJISkidBjCycWW1LWIEFIDN49O4bOszuHfiYLUC5O1rkHdk8A70G7hr3TLPmjA6FsyrZo+GPUMBsOnqpdz9E0JiI3UCYHiwgLdc1JxiM6sUHt13DP/yS3+Dsd1HcKZcQSGfqy36pZkK9h4+iZGNK/GLHTfirnXLAkcZnT03i4F+A3ear2WVkbDMTbpXUWD4JyEkXkR1cHTM0NCQmpycDP28FaO7WhaZOdBv1MxG63fsCWx+0nV7mpgqapPGBMDLO25s9pQJISlHRPYrpYb8jvPVAETkERF5XUR+ahtbJCLPichL5v8Bc1xE5CsiclREXhSRK23Puds8/iURuTvqxIIQR9G1oJyeqdRKRIdxQFdmlWuF0uHBgta0xPBPQkicBDEBfRPA9Y6xUQDfV0pdDuD75n0AuAHA5ebfPQC+BlQFBoBtAK4BcDWAbZbQSIIEcr48sUpEZ0K+sU5gRCk1TQghYfEVAEqpHwA45Ri+GcC3zNvfAjBsG/+2qrIPQF5ELgGwEcBzSqlTSqnTAJ5Do1CJjVKMJR8Cv2e5EjrZTLejD9vDmBBCohDVW/oOpdRr5u1fAniHebsA4FXbccfNMd14IjQTCtoqjKx47uiZXUoISZqmo4BU1Yscm89VRO4RkUkRmTx5MlrUSzOhoK1gwbysqwOYEEJaSVQB8CvTtAPz/+vmeBHAUttxl5pjuvEGlFJfV0oNKaWGFi+OVvbYit/PGZ0Z5Zrvn8fFnxDSdqKukDsBWJE8dwP4C9v4R81ooHUAzpimot0ANojIgOn83WCOJcbwYAF/99kbknyLyLCaJyGkE/D1AYjI4wDeD+BiETmOajTPDgBPiMgfAHgFwIfNw58B8EEARwHMAPgYACilTonIZwH82DzuAaWU07GcCIUO9Ae0MkyVEEJ0pDIRzI6zPHQnoEsCI4SQOAiaCJa6YnAW9ubvC3MGLjIyKM1UWt27BSKAU8ZaSWAUAISQdtKZXtImsXb9xVIZCtUY/Tcqc3h409pEOoPpyBnZhsXfgn4AQki7SaUAcGsKU67MYmz3EdxxzVLNs+LBEi9W8hbLOhBCOpVUCgDd7vpEqYwHh1fjrnXLQr/mvKzUNYvRVQBV5uPPj16H4cECyzoQQjqWVPoAdJnA1q77weHVAIDH9h2r8wkYGdE2f1n81ovw/Oh1dWOP7TvmeqxdALFpOCGkU0mlABjZuLIh8se+656YKuKp/cW6xd9quPJogEXdIt9v4LRL3SGneYdlHQghnUgqBYDfrtvNR2A1XNHlDTgX9YmpIv7hjfMNx/nV+LGeS42AENJuUikAAO9dt5eP4OFNaz21B4ux3UdczUUL5vV5LubOvIRiqYytTx+snTMhhLSKVDqB/dBF4CzJ5wKXYtYJkTNl71LUXhFKhBDSSlKrAXjh5yMIYrP3czTr8NI+CCGklfSkBhBHw5Wo4Z1e2gchhLSSntQAgOYjc6KGd/ppH4QQ0ip6VgDEQRQhwrwAQkinQAHQBpgXQAjpBHrSB0AIIYQCgBBCehYKAEII6VEoAAghpEehACCEkB6lo3sCi8hJVJvOR+FiAL+O8XS6Ac65N+Cce4Nm5vxOpdRiv4M6WgA0g4hMBmmKnCY4596Ac+4NWjFnmoAIIaRHoQAghJAeJc0C4OvtPoE2wDn3Bpxzb5D4nFPrAyCEEOJNmjUAQgghHnS1ABCRvIh8V0QOi8jficg/EZHtIlIUkWnz74O247eKyFEROSIiG9t57lFxm7M5/ofm2CER+bzt+FTOWUTGbd/xL0Rk2nZ8Wue8VkT2mXOeFJGrzWNFRL5izvlFEbmy3ecfBc2c14jID0XkoIh8T0R+y3Z8V3/PIrLS9hueFpHfiMhmEVkkIs+JyEvm/wHz+Pi/Z6VU1/4B+BaAf23engcgD2A7gD9yOfbdAA4AmA9gBYCfA8i2ew4xzflaAH8NYL45/va0z9nx+BcB3Jf2OQN4FsAN5tgHAfyN7fZfARAA6wC80O7zj3HOPwbwPnPs4wA+m6bv2Tb3LIBfAngngM8DGDXHRwH8l6S+567VAERkIYB/DuAbAKCUOqeUKnk85WYA31FKvamUehnAUQBXJ3+m8eEx508A2KGUetMcf918SprnbD0uAD4M4HFzKM1zVgCsHfBCACfM2zcD+Laqsg9AXkQuafFpN4XHnN8F4AfmYc8BuNW83fXfs4MPAPi5UuoVVOf2LXP8WwCGzduxf89dKwBQlfonAfwPEZkSkf8uIgvMxz5lqkiPWOoTgAKAV23PP26OdRO6Ob8LwHtF5AUR+d8i8jvm8Wmes8V7AfxKKfWSeT/Nc94MYExEXgXwBQBbzePTPOdDqC58AHA7gKXm7TTM2c5HcGET8w6l1Gvm7V8CeId5O/Y5d7MA6ANwJYCvKaUGAZxFVV36GoDLAKwF8Bqq5oG0oJtzH4BFqKqFIwCeMHfGaUA3Z4s7cOHCSQu6OX8CwBal1FIAW2DullOCbs4fB/DvRGQ/gLcCONe+U0wGEZkH4EMAnnQ+pqq2n8RCNbtZABwHcFwp9YJ5/7sArlRK/UopNauUmgPwp7igFhZxYfcAAJeaY92E65zN8adN1fBHAOZQrSOS5jlDRPoA3AJg3HZ8mud8N4CnzbEn0QO/baXUYaXUBqXUVagK+p+bj6dhzhY3APiJUupX5v1fWaYd879l0o19zl0rAJRSvwTwqohY3dQ/AOBvHTax3wPwU/P2TgAfEZH5IrICwOUAftSyE44B3ZwBTKDqCIaIvAtVB9qvke45A8C/AHBYKXXc9pQ0z/kEgPeZY9cBsMxeOwF81IwSWQfgjM2E0BV4XM9vBwARyQC4F8CfmI93/fdsw6nF7kRV2MP8/xe28Xi/53Z7v5v5Q9XMMwngRVQXwQEA/xPAQXNsJ4BLbMd/BtUdxBGY0RTd9qeZ8zwAj6Iq7H4C4Lq0z9kc/yaAf+tyfCrnDOCfAdiPavTLCwCuMo8VAF8153wQwFC7zz/GOf97AD8z/3bATF5N0fe8AMD/BbDQNvY2AN9HVcD/NYBFSX3PzAQmhJAepWtNQIQQQpqDAoAQQnoUCgBCCOlRKAAIIaRHoQAghJAehQKAEEJ6FAoAQgjpUSgACCGkR/n/XvtseCLUM8sAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pl.plot(ToF,result,'o')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/processor/__init__.py b/processor/__init__.py index 6045f15..750dd80 100644 --- a/processor/__init__.py +++ b/processor/__init__.py @@ -1,4 +1,4 @@ # -*- coding: utf-8 -*- __version__ = '0.9.5' -__author__ = 'Yves Acremann, Steinn Ymir Agustsson, Davide Curcio, Patrick Xian, Maciej Dendzik' \ No newline at end of file +__author__ = 'Yves Acremann, Steinn Ymir Agustsson, Davide Curcio, Rui Patrick Xian, Maciej Dendzik' \ No newline at end of file diff --git a/setup.py b/setup.py index cb98147..3a3af12 100644 --- a/setup.py +++ b/setup.py @@ -21,7 +21,7 @@ name="HextofOfflineAnalyzer", version='0.9.5', description='Hextof Offline Analyzer', - author='Yves Acremann, Steinn Ymir Agustsson, Davide Curcio, Patrick Xian, Maciej Dendzik', + author='Yves Acremann, Steinn Ymir Agustsson, Davide Curcio, Rui Patrick Xian, Maciej Dendzik', url='https://github.com/momentoscope/hextof-processor', packages=['distutils', 'distutils.command'], ext_modules=cythonize(extensions)