PROJECT_Group11_PhysicsRun.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    " \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PROJECT: PARTICLE DETECTOR DATA ANALYSIS\n",
    "### Dataset: Run330, Physics Run\n",
    "\n",
    "<a id =6></a><br>\n",
    "The same code is applied to the physics run. The description of these codes, however, are in the calibration run notebook. In this notebook, we show the main differences between the calibration run and the physics run. The highlights are linked below.\n",
    " \n",
    " - [HISTOGRAM OF HITS PER CHANNEL](#1)\n",
    " \n",
    " - [EVENTS OF PHYSICS RUN](#2)\n",
    " \n",
    " - [DISTRIBUTION OF DRIFT TIMES](#3)\n",
    " \n",
    " - [RATIO OF USEFUL EVENTS](#5)\n",
    " \n",
    " - [DETECTOR MATRIX](#4)\n",
    " \n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Important imports\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import display\n",
    "from os import listdir\n",
    "from os.path import isfile, join, getsize\n",
    "from IPython.display import Markdown, display\n",
    "def printmd(string):\n",
    "    display(Markdown(string)) # for markdown purposes\n",
    "from numba import vectorize, int64, int32, jit, njit, cuda, float64"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "\n",
    "# I. THE DATA\n",
    "[Content Outline](#6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "## DESCRIPTION OF THE DATA"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files concatenated: \n",
      " ['data/Run000333/data_000000.txt', 'data/Run000333/data_000001.txt', 'data/Run000333/data_000002.txt', 'data/Run000333/data_000003.txt', 'data/Run000333/data_000004.txt', 'data/Run000333/data_000005.txt', 'data/Run000333/data_000006.txt'] \n",
      "\n",
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 9174912 entries, 0 to 9174911\n",
      "Data columns (total 5 columns):\n",
      " #   Column       Dtype\n",
      "---  ------       -----\n",
      " 0   FPGA         int64\n",
      " 1   TDC_CHANNEL  int64\n",
      " 2   ORBIT_CNT    int64\n",
      " 3   BX_COUNTER   int64\n",
      " 4   TDC_MEAS     int64\n",
      "dtypes: int64(5)\n",
      "memory usage: 350.0 MB\n",
      "None\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "## THE DATAFRAME"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "The dataframe below presents the first 10 hits as presented in the raw data."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>FPGA</th>\n",
       "      <th>TDC_CHANNEL</th>\n",
       "      <th>ORBIT_CNT</th>\n",
       "      <th>BX_COUNTER</th>\n",
       "      <th>TDC_MEAS</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2703</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>62</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2695</td>\n",
       "      <td>25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>12</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2698</td>\n",
       "      <td>22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>50</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2698</td>\n",
       "      <td>23</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>14</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2708</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>57</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2707</td>\n",
       "      <td>25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2704</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0</td>\n",
       "      <td>64</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2706</td>\n",
       "      <td>21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2705</td>\n",
       "      <td>19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0</td>\n",
       "      <td>59</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2708</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   FPGA  TDC_CHANNEL   ORBIT_CNT  BX_COUNTER  TDC_MEAS\n",
       "0     1            4  3838279555        2703         1\n",
       "1     0           62  3838279555        2695        25\n",
       "2     1           12  3838279555        2698        22\n",
       "3     0           50  3838279555        2698        23\n",
       "4     1           14  3838279555        2708        14\n",
       "5     0           57  3838279555        2707        25\n",
       "6     1            1  3838279555        2704        10\n",
       "7     0           64  3838279555        2706        21\n",
       "8     1            2  3838279555        2705        19\n",
       "9     0           59  3838279555        2708         1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Set as True for Physics run \n",
    "REAL_DATA = True\n",
    "\n",
    "# Limit the amount of data we are accepting \n",
    "if REAL_DATA == True:\n",
    "    mypath = 'data/Run000333/'\n",
    "else:\n",
    "    mypath = 'data/Run000260/'\n",
    "\n",
    "max_mb = 256 # maximum size of data in mb to read\n",
    "files = [join(mypath, f) for f in listdir(mypath) if isfile(join(mypath, f))]\n",
    "mb = 0\n",
    "for i in range(len(files)):\n",
    "    mb += getsize(files[i])/1024**2 # getsize returns size in bytes\n",
    "    if mb >= max_mb:\n",
    "        files = files[:(i-1)]\n",
    "        break\n",
    "\n",
    "# Concatenate the files and load the data\n",
    "data = pd.concat([pd.read_csv(file) for file in files], axis = 0)\n",
    "data.reset_index(inplace=True, drop=True) #This resets the index from 0 to onwards\n",
    "# data = pd.read_csv(files[0])\n",
    "\n",
    "# Drop the 'HEAD' column\n",
    "data.drop('HEAD', inplace=True, axis=1) # We remove the 'HEAD', inplace = True because we return nothing\n",
    "\n",
    "# Print the description of the data\n",
    "printmd('## DESCRIPTION OF THE DATA')\n",
    "print('Files concatenated:', '\\n', files, '\\n') # To check which files are read\n",
    "print(data.info())\n",
    "# display(data.describe())\n",
    "\n",
    "#Visualize the first 10 entries of the file\n",
    "printmd('## THE DATAFRAME')\n",
    "printmd('The dataframe below presents the first 10 hits as presented in the raw data.')\n",
    "display(data.head(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       " ## HISTOGRAM OF HITS PER TDC CHANNEL <a id =1></a><br>"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Remark: There are a lot of hits falling under the mean time trigger channel: 139."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmkAAAEICAYAAAAEMWOwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3df5CkdX3g8fcnrCiBEEDiHNnlMhj3EpGNCFOwhqurUSIs6LmkInVLbcmu4WpTBu70srk4xKtw0ViFl0MSrpRzI3ssFhE5orLlopu9lT6PKvkZkQWR7AS3ZFhkgwsbB6NxyOf+6O8svUP3dM/udPcz0+9XVdf083m+z/N5np7u73z6eZ7vPJGZSJIkqVp+pt8bIEmSpFeySJMkSaogizRJkqQKskiTJEmqIIs0SZKkCrJIkyRJqiCLNEmSpAqySFPXRcSeiPjHiJhsePxiRAxHRDbE9kTEWMNyERFXRcQjEfGjiPh+RNQiYk2THDdHxFRE/GKbbYmI+HhE/KA8/ltERDf2W9JgqVhf97aIuDsiDkTEni7srnrAIk298m8z87iGx96GeSdk5nHAZcAfRcSqEr8B+CCwEXgtsBT4L8CqxhVHxLHAbwEHgLVttmMDcAnwZuDXgHcBv3NEeyZJL6tKX/cisBn4z0e6Q+ofizRVRmZ+A3gMOCMi/hXwu8CazNyRmf+YmS9l5j2ZuX7Gor8FvAB8BFjXJs064LrMnMjMp4HrgJnrk6Su6UVfl5n3Z+ZngSfnfw/UKxZpqoRyuP884E3AN4G3A09l5oMdLL4O+BxwG/CrEXHWLG3fBHyrYfpbJSZJXdfDvk6LgEWaeuVLEfFCeXxpxrzngP3AZ4CxzNwJnAx8v7FRREyU5X8cEb9UYv8SeBvwl5n5LLCT2b9hHkf9VMG0A8BxXpcmaZ5Upa/TIrCk3xuggXFJZv6fFvNOzsypGbEfAKc0BjJzWUQsAX4KTBdV7wUez8yHy/StwHUR8fuZ+dMmuSaB4xumjwcmMzPnsC+S1EpV+jotAh5JU1V9DVgWESNt2l0OvL6Mhvo+8Anq30wvatH+MeqDBqa9ucQkqR+61ddpEbBIUyVl5hPAp4HbIuIdEXFMRBwF/Pp0m4h4K/DLwDnAmeVxBvCXtD4NcAvwexGxtAxh3wjc3LUdkaRZdKuvi4ifiYjXAK+qT8ZrIuLo7u6N5punO1VlVwL/gfo3xjdQH9X0t8C/A74HjAF3ZuauxoUi4s+B/xcRJ2Xm/hnr/DTwemB6mc+UmCT1Szf6un8D3N0w/Y/A/wVGu7ED6o7wUhxJkqTq8XSnJElSBVmkSZIkVZBFmiRJUgVZpEmSJFXQohvdefLJJ+fw8PCsbV588UWOPfbY3myQ+c1v/jnnf+ihh57LzF/o0SYtSJ30dbAwft/mX5z5B3nf55J/1v4uMxfV4+yzz8527r777rZtusn85jf/7IAHswL9SZUfnfR1mQvj923+xZl/kPd9Lvln6+883SlJklRBFmmSJEkVZJEmSZJUQRZpkiRJFWSRJkmSVEEWaZIkSRVkkSZJklRBFmmSJEkVZJEmSZJUQRZpkrpueGxbvzdBkrpueGzbvPZ3FmmSJEkVZJEmSZJUQRZpkjQgPO0sLSwWaZIkSRVkkSZJklRBHRVpEbEnInZFxMMR8WCJnRQROyJid/l5YolHRNwQEeMR8UhEnNWwnnWl/e6IWNcQP7usf7wsG7PlkCRJWuzmciTtbZl5ZmaOlOkxYGdmLgd2lmmAi4Dl5bEBuBHqBRdwDXAucA5wTUPRdWNpO73cqjY5JEmSFrUjOd25GthSnm8BLmmI35J19wInRMQpwIXAjszcn5nPAzuAVWXe8Zn5jcxM4JYZ62qWQ5IkaVFb0mG7BP46IhL4dGZuAoYy8xmAzHwmIl5X2i4FnmpYdqLEZotPNIkzS45DRMQG6kfiGBoaolarzbozk5OTbdt0k/nNP2j5N66YOpiz3/svSQtFp0XaeZm5txRJOyLiO7O0jSaxPIx4x0rRuAlgZGQkR0dHZ21fq9Vo16abzG/+Qcu/fmwbe9aO9i2/JC1EHZ3uzMy95ec+4IvUryl7tpyqpPzcV5pPAKc2LL4M2NsmvqxJnFlySJIkLWpti7SIODYifm76OXAB8CiwFZgeobkOuLM83wpcXkZ5rgQOlFOW24ELIuLEMmDgAmB7mffDiFhZRnVePmNdzXJIkiQtap2c7hwCvlj+K8YS4C8z86sR8QBwe0RcAXwPuLS0vwu4GBgHfgS8DyAz90fER4EHSruPZOb+8vz9wM3AMcBXygPg2hY5JEmSFrW2RVpmPgm8uUn8B8D5TeIJXNliXZuBzU3iDwJndJpDkiRpsfOOA5IkSRVkkSZJklRBFmmSJEkVZJEmSZJUQRZpkiRJFWSRJkmSVEEWaZIERMSpEXF3RDweEY9FxAdK/KSI2BERu8vPE0s8IuKGiBiPiEci4qyGda0r7XdHxLqG+NkRsassc0P5B94tc0gabBZpklQ3BWzMzDcCK4ErI+J0YAzYmZnLgZ1lGuAiYHl5bABuhHrBBVwDnEv9FnrXNBRdN5a208utKvFWOSQNMIs0SQIy85nM/Jvy/IfA48BSYDWwpTTbAlxSnq8Gbsm6e4ETyj2GLwR2ZOb+zHwe2AGsKvOOz8xvlH/6fcuMdTXLIWmAdXJbKEkaKBExDLwFuA8YKvcYJjOfiYjXlWZLgacaFpsosdniE03izJJj5nZtoH4kjqGhIWq1Wtt9mZycPNhu44qpjpaZT435+8H8/cs/iPu+ccUUALVabV7yW6RJUoOIOA74K+CDmfkP5bKxpk2bxPIw4h3LzE3AJoCRkZEcHR1tu0ytVmO63fqxbexZ236Z+dSYvx/M37/8g7jv68e2AbBn7ei85Pd0pyQVEfEq6gXarZn5hRJ+tpyqpPzcV+ITwKkNiy8D9raJL2sSny2HpAFmkabKGC7fQKR+KCMtbwIez8xPNMzaCkyP0FwH3NkQv7yM8lwJHCinLLcDF0TEiWXAwAXA9jLvhxGxsuS6fMa6muWYF8Nj2/x8SQuQpzslqe484L3Aroh4uMT+ELgWuD0irgC+B1xa5t0FXAyMAz8C3geQmfsj4qPAA6XdRzJzf3n+fuBm4BjgK+XBLDkkDTCLNEkCMvMeml83BnB+k/YJXNliXZuBzU3iDwJnNIn/oFkOSYPN052SJEkV5JE09Z3XykiS9EoeSZMkSaogizRJkqQKskiTJEmqIIs0SZKkCrJIkyRJqiCLNEmSpAqySJMkSaogizRJGkDez1OqPos0SZKkCrJIkyRJqiCLNEmSpAqySJMkSaogizRJkqQK6rhIi4ijIuKbEfHlMn1aRNwXEbsj4vMRcXSJv7pMj5f5ww3ruLrEn4iICxviq0psPCLGGuJNc0iSJC12czmS9gHg8YbpjwPXZ+Zy4HngihK/Ang+M98AXF/aERGnA2uANwGrgE+Vwu8o4JPARcDpwGWl7Ww5JEmSFrWOirSIWAa8E/hMmQ7g7cAdpckW4JLyfHWZpsw/v7RfDdyWmT/JzO8C48A55TGemU9m5j8BtwGr2+SQJEla1JZ02O7PgD8Afq5MvxZ4ITOnyvQEsLQ8Xwo8BZCZUxFxoLRfCtzbsM7GZZ6aET+3TY5DRMQGYAPA0NAQtVpt1p2ZnJxs26abzH9o/o0rpg4+78V2VW3/ByH/xhVTB3P2e/8laaFoW6RFxLuAfZn5UESMToebNM0281rFmx3Nm639K4OZm4BNACMjIzk6Otqs2UG1Wo12bbrJ/IfmX9/wX8/3rB195QJdzt9rg5h//di2g7/bfu+/JC0UnRxJOw94d0RcDLwGOJ76kbUTImJJOdK1DNhb2k8ApwITEbEE+Hlgf0N8WuMyzeLPzZJDkiRpUWt7TVpmXp2ZyzJzmPqF/1/LzLXA3cB7SrN1wJ3l+dYyTZn/tczMEl9TRn+eBiwH7gceAJaXkZxHlxxbyzKtckiSJC1qR/J/0j4E/F5EjFO/fuymEr8JeG2J/x4wBpCZjwG3A98GvgpcmZkvlaNkVwHbqY8evb20nS2HJEnSotbpwAEAMrMG1MrzJ6mPzJzZ5sfApS2W/xjwsSbxu4C7msSb5pAkSVrsvOOAJElSBVmkSZIkVZBFmiRJUgVZpEmSJFWQRZokSVIFWaRJkiRVkEWaJElSBVmkSZIkVZBFmiRJUgVZpEmSJFWQRZokSVIFWaRJkiRVkEWaJElSBVmkSVIREZsjYl9EPNoQ+68R8XREPFweFzfMuzoixiPiiYi4sCG+qsTGI2KsIX5aRNwXEbsj4vMRcXSJv7pMj5f5w93ax+GxbQyPbevW6iXNI4s0SXrZzcCqJvHrM/PM8rgLICJOB9YAbyrLfCoijoqIo4BPAhcBpwOXlbYAHy/rWg48D1xR4lcAz2fmG4DrSztJA84iTZKKzPw6sL/D5quB2zLzJ5n5XWAcOKc8xjPzycz8J+A2YHVEBPB24I6y/BbgkoZ1bSnP7wDOL+0lDbAl/d4ASVoAroqIy4EHgY2Z+TywFLi3oc1EiQE8NSN+LvBa4IXMnGrSfun0Mpk5FREHSvvnGjciIjYAGwCGhoao1WptN3xycpKNK15qOb+TdRyJycnJrucwfzXzD+K+b1xR/3jXarV5yW+RJkmzuxH4KJDl53XAbwPNjnQlzc9Q5CztaTPv5UDmJmATwMjISI6OjrbZ9Pofi+vuebHl/D1r26/jSNRqNTrZTvMvvvyDuO/ry/Wee9aOzkt+T3eqL7x4WQtFZj6bmS9l5j8Df0H9dCbUj4Sd2tB0GbB3lvhzwAkRsWRG/JB1lfk/T+enXSUtUhZp6isLNVVdRJzSMPmbwPTIz63AmjIy8zRgOXA/8ACwvIzkPJr64IKtmZnA3cB7yvLrgDsb1rWuPH8P8LXSXtIA83SnJBUR8TlgFDg5IiaAa4DRiDiT+unHPcDvAGTmYxFxO/BtYAq4MjNfKuu5CtgOHAVszszHSooPAbdFxJ8A3wRuKvGbgM9GxDj1I2hruryrkhYAizRJKjLzsibhm5rEptt/DPhYk/hdwF1N4k/y8unSxviPgUvntLGSFj1Pd0qSJFWQRZokSVIFWaRJkiRVkEWaJElSBVmkSZIkVZBFmiRJUgVZpEmSJFWQRZokSVIFWaSpp4bHtrHr6QP93gxJkiqvbZEWEa+JiPsj4lsR8VhE/HGJnxYR90XE7oj4fLlHHeU+dp+PiPEyf7hhXVeX+BMRcWFDfFWJjUfEWEO8aQ5J0vwZHtvmfXSlCurkSNpPgLdn5puBM4FVEbES+DhwfWYuB54HrijtrwCez8w3ANeXdkTE6dTvR/cmYBXwqYg4KiKOAj4JXAScDlxW2jJLDkmSpEWtbZGWdZNl8lXlkcDbgTtKfAtwSXm+ukxT5p8fEVHit2XmTzLzu8A49XvYnQOMZ+aTmflPwG3A6rJMqxySJEmLWkc3WC9Hux4C3kD9qNffAS9k5lRpMgEsLc+XAk8BZOZURBwAXlvi9zastnGZp2bEzy3LtMoxc/s2ABsAhoaGqNVqs+7P5ORk2zbdNMj5N66YYuiY+s9merFdg/z69yv/xhVTB3P2e/8laaHoqEjLzJeAMyPiBOCLwBubNSs/o8W8VvFmR/Nma99s+zYBmwBGRkZydHS0WbODarUa7dp00yDnXz+2jY0rprhuV/O33p61o13fhkF+/fuVf/3YtoO/237vvyQtFHMa3ZmZLwA1YCVwQkRM/6VdBuwtzyeAUwHK/J8H9jfGZyzTKv7cLDkkSZIWtU5Gd/5COYJGRBwD/AbwOHA38J7SbB1wZ3m+tUxT5n8tM7PE15TRn6cBy4H7gQeA5WUk59HUBxdsLcu0yiFJkrSodXK68xRgS7ku7WeA2zPzyxHxbeC2iPgT4JvATaX9TcBnI2Kc+hG0NQCZ+VhE3A58G5gCriynUYmIq4DtwFHA5sx8rKzrQy1ySJIkLWpti7TMfAR4S5P4k9RHZs6M/xi4tMW6PgZ8rEn8LuCuTnNIkrpj+v+l7bn2nX3eEknecUCSJKmCLNLUM/5Hc0mSOmeRJkmSVEEWaZIkSRVkkSZJklRBFmmSJEkVZJEmSZJUQRZpkiRJFWSRJkmSVEEWaZIkSRVkkSZJklRBFmmSJEkVZJEmSZJUQRZpkiRJFWSRJkmSVEEWaZIkSRVkkSZJA2x4bFu/N0FSCxZpkiRJFWSRJklFRGyOiH0R8WhD7KSI2BERu8vPE0s8IuKGiBiPiEci4qyGZdaV9rsjYl1D/OyI2FWWuSEiYrYckgabRZq6bnhsm6dUtFDcDKyaERsDdmbmcmBnmQa4CFheHhuAG6FecAHXAOcC5wDXNBRdN5a208utapND0gCzSJOkIjO/DuyfEV4NbCnPtwCXNMRvybp7gRMi4hTgQmBHZu7PzOeBHcCqMu/4zPxGZiZwy4x1NcshaYAt6fcGSFLFDWXmMwCZ+UxEvK7ElwJPNbSbKLHZ4hNN4rPlOEREbKB+JI6hoSFqtVrbjZ+cnGTjipfatgOo1WpsXDF18Pl8mJycnLd1mX9h5R/EfW/8/MxHfos0STo80SSWhxHvWGZuAjYBjIyM5OjoaNtlarUa193zYkfr37N2lPXl0oQ9a9uvuxO1Wo1OtrNbzN+//IO4742fn/nI7+lOSZrds+VUJeXnvhKfAE5taLcM2NsmvqxJfLYckgaYRZq6ygEDWgS2AtMjNNcBdzbELy+jPFcCB8opy+3ABRFxYhkwcAGwvcz7YUSsLKM6L5+xrmY5JA0wT3dKUhERnwNGgZMjYoL6KM1rgdsj4grge8ClpfldwMXAOPAj4H0Ambk/Ij4KPFDafSQzpwcjvJ/6CNJjgK+UB7PkkDTALNIkqcjMy1rMOr9J2wSubLGezcDmJvEHgTOaxH/QLEeveeRbqhZPd0qSJFWQRZokSVIFWaRJkiRVUNsiLSJOjYi7I+LxiHgsIj5Q4t7PTpIkqUs6OZI2BWzMzDcCK4ErI+J0vJ+dJC16DiaQ+qdtkZaZz2Tm35TnPwQep34rE+9np5a8qbq0+PiZlnprTtekRcQw8BbgPmbcaw7o+v3sGnJIkiQtah3/n7SIOA74K+CDmfkP5bKxpk2bxLp6P7u53nR4EG/62uv80zeZbWbomNbze/G6DMLrX7X8G1dMHczZ7/2XpIWioyItIl5FvUC7NTO/UMLPRsQpmfnMHO5nNzojXqOD+9k1yXGIud50eBBv+trr/OtnOS2yccUU1+1q/tabr5s6z2YQXv+q5V8/tu3g77bf+y9JC0UnozsDuAl4PDM/0TDL+9lJkiR1SSdH0s4D3gvsioiHS+wP8X52kiRJXdO2SMvMe2h+3RgMyP3sJEmSes07DkiSJFWQRZokSVIFWaRJkiRVkEWaJElSBVmkSZIkVZBFmiRJUgVZpEmSJFWQRZokSVIFWaRJkiRVkEWa5s3w2DaGZ7mxuiRJ6pxFmiRJUgVZpEmSJFWQRZokSVIFWaRJkiRVkEWaJElSBS3p9wZo4XNEp7S4+RmX+sMjaZIkSRVkkSZJklRBFmmSJEkVZJEmSZozr1OTus8iTZJ0RLwlnNQdFmmSJEkVZJEmSZJUQRZpOiye3pAkqbss0qQBZrEtSdVlkSZJHYiIPRGxKyIejogHS+ykiNgREbvLzxNLPCLihogYj4hHIuKshvWsK+13R8S6hvjZZf3jZdno/V5KqhKLNEnq3Nsy88zMHCnTY8DOzFwO7CzTABcBy8tjA3Aj1Is64BrgXOAc4Jrpwq602dCw3Kru746kKrNIk6TDtxrYUp5vAS5piN+SdfcCJ0TEKcCFwI7M3J+ZzwM7gFVl3vGZ+Y3MTOCWhnVJGlDeYF3SwevS9lz7zj5vSaUl8NcRkcCnM3MTMJSZzwBk5jMR8brSdinwVMOyEyU2W3yiSfwQEbGB+tE2hoaGqNVqbTd6cnKSjSte6mT/DjG97o0rplrGZ7Zptj2Tk5MdbWe3mL9/+Qdx3xs/C/OR3yJNbc38A+6F5hpQ52Xm3lKI7YiI78zSttn1ZHkY8UMD9cJwE8DIyEiOjo623eharcZ197zYtt1Me9bW171+xue9MT6zzfT0zPydbGe3mL9/+Qdx3xs/C/OR39OdktSBzNxbfu4Dvkj9mrJny6lKys99pfkEcGrD4suAvW3iy5rEJQ2wtkVaRGyOiH0R8WhDrOsjmlrlkKRei4hjI+Lnpp8DFwCPAluB6f5sHXBneb4VuLz0iSuBA+W06Hbggog4sfRpFwDby7wfRsTK0gde3rAuSQOqkyNpN/PKUUa9GNHUKock9doQcE9EfAu4H9iWmV8FrgXeERG7gXeUaYC7gCeBceAvgN8FyMz9wEeBB8rjIyUG8H7gM2WZvwO+0oP9klRhba9Jy8yvR8TwjPBqYLQ83wLUgA/RMKIJuDcipkc0jVJGNAFExPSIphplRFOJT49o+sosOSSppzLzSeDNTeI/AM5vEk/gyhbr2gxsbhJ/EDjjiDdW0qJxuAMHejGiqVWOV5jriKdBHHFyJPmnR6v8j1vvLNMvz6vVak1Hf82MNRo65pUjxhqX7baF9vp3M3+rkXvzrXEkYL/3X0fGgUNS78z36M6ujGhqZ64jngZxxMmR5J85uqvRnrWjTUd/zbbMxhVTXLer+Vuv2eiw+bbQXv9u5m81cm++NY4E7Pf+S9JCcbijO3sxoqlVDkmSpEXvcIu0XoxoapVDklQBw2PbZj39OTy2jV1PH+jhFkmLS9vTnRHxOeoX8J8cERPUR2leC9weEVcA3wMuLc3vAi6mPjrpR8D7oD6iKSKmRzTBK0c03QwcQ33AwPSIplY5JEmSFr1ORnde1mJWV0c0tRo1pd7yImFJkvrDOw7ooHanLiSpHfsRaf547041ZScrSVJ/eSRNkiSpgizSJEmSKsgiTZIkqYIs0iRJkirIIk2S1HMOTpLas0gbQO3+A7idpyRJ/ee/4JBFmSRJFeSRtAFngSZJUjVZpEmS5kW7L31+KZTmxiJNkjTvDrcg87ZS0sss0hYpOzpJkhY2izRJkqQKskgbEDOPqnmkTf7+JanaLNIWOIstzdWupw/4ntGCY1+nQWSRJknqK4svqTmLNEmSpAqySFsg/KYpaaFqPFXZjdOW9o9arLwt1CLU2GHZeanR8Ng2Nq7o91ZInZnuv/Zc+84+b4nUHx5JkyQtSsNj29j19IF+b4Z02DySViFz+dboETJJi0kv+zSP0Gmh8EhaH3T6LxDm0mlZtElaaI7k+jT7PA0Cj6RVnB2R5oPvI6kzw2PbPMKmyvBIWhd1erSs0z+g/jNHSYNormcVutFPzrbeucalTlmkVYQfZkl62WL+klulbdHLqvg78XRnh470QtPGX367f4FQxTeKFibfS1psunWUzFOcg6vK/aRF2gzz8WGdyzc7ab75vtIgmvm+n49TkK2+nM/2pb3V3xBHlOpwWKQdhsYPebsPnH8wq6X+z1ynGOXIfjd7rn2nna60QBzpaPr5vBbNvwmt2ae+0sAXae2+EXUSm477xuq9xte9l/+ypNW39n6/B/wDIHVuPousVvFdTx9gvX83DtGunzrSL9DT65j+Qr6QDXSR1ur2Sf6h67/GoqebH+j50KqY73bn2+/9lnTkZn7BW2yFW6/7qXanvQ/nS30/Vb5Ii4hVwJ8DRwGfycxr+7xJ6qKF8sFppVWxP5+d7kJ/jdSa/d3g6kXf0U3NzmpsXDHFAigzKq3Sr15EHAV8EngHMAE8EBFbM/Pb/d0yaW4OHd071fL0hwaX/Z2amcuXsmYDHKb7m7kOcmg1WGK+tlWdqXSRBpwDjGfmkwARcRuwGrDTGhB+6DVAKtXf+dlbeHo1+EG9E5nZ721oKSLeA6zKzH9fpt8LnJuZV81otwHYUCZ/BXiizapPBp6b582dC/Ob3/yz+6XM/IVebExVdNLfHUZfBwvj923+xZl/kPd9Lvlb9ndVP5IWTWKvqCozcxOwqeOVRjyYmSNHsmFHwvzmN3//8ldY2/5urn0d9P/1Nv/g5h/kfZ+v/FW/LdQEcGrD9DJgb5+2RZK6yf5O0iGqXqQ9ACyPiNMi4mhgDbC1z9skSd1gfyfpEJU+3ZmZUxFxFbCd+pD0zZn52Dysek6nC7rA/OY3vw5hf2f+RZh/kPd9XvJXeuCAJEnSoKr66U5JkqSBZJEmSZJUQQNXpEXEqoh4IiLGI2KsB/lOjYi7I+LxiHgsIj5Q4idFxI6I2F1+ntjFbTgqIr4ZEV8u06dFxH0l9+fLRcpdExEnRMQdEfGd8jq8tVf7HxH/qbzuj0bE5yLiNd3e/4jYHBH7IuLRhljT/Y26G8r78ZGIOKtL+f+0vP6PRMQXI+KEhnlXl/xPRMSF3cjfMO/3IyIj4uQyPe/7r7pB7OtKvr71d/3s60r+nvZ39nXd7+sGqkiLl2+7chFwOnBZRJze5bRTwMbMfCOwEriy5BwDdmbmcmBnme6WDwCPN0x/HLi+5H4euKKLuaF+L8KvZuavAm8u29L1/Y+IpcB/BEYy8wzqF2Ovofv7fzOwakas1f5eBCwvjw3AjV3KvwM4IzN/Dfhb4GqA8l5cA7ypLPOp8jmZ7/xExKnUb3n0vYZwN/Z/4A1wXwf97e/60tdB3/q7m7Gv625fl5kD8wDeCmxvmL4auLrH23Bn+eU9AZxSYqcAT3Qp3zLqH5S3A1+m/g8znwOWNHtNupD/eOC7lEEqDfGu7z+wFHgKOIn6SOYvAxf2Yv+BYeDRdvsLfBq4rFm7+cw/Y95vAreW54d8BqiPLHxrN/IDd1D/w7UHOLmb+z/oj0Hs68r6+9bf9bOvK+vuS39nX9fdvm6gjqTx8pt42kSJ9UREDANvAe4DhjLzGYDy83VdSvtnwB8A/1ymXwu8kJlTZbrbr8Hrgb8H/lc5BfGZiDiWHux/Zj4N/Hfq32aeAQ4AD9Hb/Z/Wan/78Z78beArvcwfEe8Gns7Mb82Y1dfP5CI2iH0d9Le/61tfV9Zdlf7Ovm4e+7pBK9I6us1UVxJHHAf8FfDBzPyHHuV8F7AvMx9qDDdp2s3XYAlwFnBjZr4FeJHun+4AoFwLsRo4Da5bjwUAAAJQSURBVPhF4Fjqh5xn6uf/oenp7yMiPkz9tNStvcofET8LfBj4o2azu51/QA1UX1fy9ru/61tfBwuiv7OvO4z8g1ak9eW2KxHxKuqd1q2Z+YUSfjYiTinzTwH2dSH1ecC7I2IPcBv1UwB/BpwQEdP/yLjbr8EEMJGZ95XpO6h3ZL3Y/98AvpuZf5+ZPwW+APw6vd3/aa32t2fvyYhYB7wLWJvleHuP8v8y9T8c3yrvxWXA30TEv+hR/kE0aH0d9L+/62dfB9Xp7+zr5rGvG7Qiree3XYmIAG4CHs/MTzTM2gqsK8/XUb9+Y15l5tWZuSwzh6nv69cycy1wN/CebuZu2IbvA09FxK+U0PnAt+nB/lM/7L8yIn62/B6mc/ds/xu02t+twOVl5M9K4MD0qYL5FBGrgA8B787MH83YrjUR8eqIOI36Ra33z2fuzNyVma/LzOHyXpwAzirvjZ7s/wAaqL4O+t/f9bmvg+r0d/Z189nXHelFcwvtAVxMfcTH3wEf7kG+f039kOYjwMPlcTH1ayV2ArvLz5O6vB2jwJfL89dTf3OOA/8beHWXc58JPFhegy8BJ/Zq/4E/Br4DPAp8Fnh1t/cf+Bz1a0J+Wj6kV7TaX+qHwD9Z3o+7qI/M6kb+cerXQ0y/B/9nQ/sPl/xPABd1I/+M+Xt4+WLaed9/Hwdf54Hs68q29KW/62dfV/L3tL+zr+t+X+dtoSRJkipo0E53SpIkLQgWaZIkSRVkkSZJklRBFmmSJEkVZJEmSZJUQRZpkiRJFWSRJkmSVEH/Hy9mnbvy78sgAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot histogram\n",
    "fig, (ax1,ax2) = plt.subplots(1,2,figsize=(10,4))\n",
    "\n",
    "df_0 = data[data['FPGA']==0]\n",
    "df_1 = data[data['FPGA']==1]\n",
    "\n",
    "max_channel = data['TDC_CHANNEL'].max()\n",
    "df_0.hist('TDC_CHANNEL', ax=ax1, bins=max_channel)#, range=(137,138))\n",
    "df_1.hist('TDC_CHANNEL', ax=ax2, bins=max_channel)#, range=(137,138))\n",
    "ax1.set_title('FPGA 0')\n",
    "ax2.set_title('FPGA 1')\n",
    "\n",
    "printmd(' ## HISTOGRAM OF HITS PER TDC CHANNEL <a id =1></a><br>')\n",
    "printmd('Remark: There are a lot of hits falling under the mean time trigger channel: 139.')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "# The difference between the channel distributions reflect the difference between the beams used in \n",
    "# the calibration run and the physics run. \n",
    "# Discontinuity and lesser amplitudes: shift in chamber"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "## HISTOGRAM (Calibration Run)"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "From observation, the distribution of hits in the calibration run is more \"flat\" as compared to the physics"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd('## HISTOGRAM (Calibration Run)')\n",
    "plt.figure(figsize = (12, 5))\n",
    "calib_hist = plt.imread('histogram1.png')\n",
    "#fig, ax = plt.subplots(figsize=(12, 6))\n",
    "plt.imshow(calib_hist, aspect = 'auto')\n",
    "plt.axis('off')\n",
    "plt.show()\n",
    "\n",
    "printmd('From observation, the distribution of hits in the calibration run is more \"flat\" as compared to the physics')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "# II. ADDING NEW COLUMNS: TIME, DETECTOR, LAYER, AND CELL\n",
    " [Content Outline](#6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CONSTANTS: TRIGGER CHANNELS AND TMAX, L, Vd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "st1 = 137  # Scintillator trigger channel 1\n",
    "st2 = 138  # Scintillator trigger channel 2\n",
    "mtt = 139  # Mean-time trigger channel\n",
    "T_M = 390  #(maximum drift time in ns)\n",
    "L = 42  # (lenght of the cell in mm)\n",
    "v_d = L/(2*T_M)  # (constant drift velocity in mm/ns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TIME, DETECTOR, LAYER, AND CELL COLUMNS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Time column\n",
    "data['time'] = data['BX_COUNTER']*25 + data['TDC_MEAS']*25/30\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(2, 3, 1), (2, 3, 2), (2, 3, 3), (2, 3, 4), (2, 3, 5), (2, 3, 6), (2, 3, 7), (2, 3, 8), (2, 3, 9), (2, 3, 10), (2, 3, 11), (2, 3, 12), (2, 3, 13), (2, 3, 14), (2, 3, 15), (2, 3, 16)]\n"
     ]
    }
   ],
   "source": [
    "# Define function to add the detector, layer and cell columns \n",
    "\n",
    "@vectorize([int64(int64, int64)])\n",
    "def giveDetector(fpga, channel):\n",
    "    if channel > 128:\n",
    "        return -1\n",
    "\n",
    "    channel -= 1\n",
    "    return fpga*2 + 1 + channel // 64\n",
    "\n",
    "@vectorize([int64(int64)])\n",
    "def giveLayer(channel):\n",
    "    if channel > 128:\n",
    "        return -1\n",
    "\n",
    "    layer_map = {0 : 1,\n",
    "                 1 : 4,\n",
    "                 2 : 2,\n",
    "                 3 : 3}\n",
    "\n",
    "    cell_index = channel % 64\n",
    "    layer = layer_map[cell_index % 4]\n",
    "    \n",
    "    return layer\n",
    "\n",
    "@vectorize([int64(int64)])\n",
    "def giveCell(channel):\n",
    "    if channel > 128:\n",
    "        return -1\n",
    "\n",
    "    channel -= 1\n",
    "    cell_index = channel % 64\n",
    "    cell = cell_index // 4 + 1\n",
    "\n",
    "    return cell\n",
    "\n",
    "# Test of functions(one particular layer and detector arrangement)\n",
    "if __name__ == '__main__':\n",
    "    first_cell_of_layer = 67\n",
    "    a = np.arange(first_cell_of_layer,first_cell_of_layer+16*4,4)\n",
    "    print(list(zip(giveDetector(0,a), giveLayer(a), giveCell(a))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Dataframe now has new columns: time, detector, layer, and cell."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>FPGA</th>\n",
       "      <th>TDC_CHANNEL</th>\n",
       "      <th>ORBIT_CNT</th>\n",
       "      <th>BX_COUNTER</th>\n",
       "      <th>TDC_MEAS</th>\n",
       "      <th>time</th>\n",
       "      <th>detector</th>\n",
       "      <th>layer</th>\n",
       "      <th>cell</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2703</td>\n",
       "      <td>1</td>\n",
       "      <td>67575.833333</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>62</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2695</td>\n",
       "      <td>25</td>\n",
       "      <td>67395.833333</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>12</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2698</td>\n",
       "      <td>22</td>\n",
       "      <td>67468.333333</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>50</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2698</td>\n",
       "      <td>23</td>\n",
       "      <td>67469.166667</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>14</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2708</td>\n",
       "      <td>14</td>\n",
       "      <td>67711.666667</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   FPGA  TDC_CHANNEL   ORBIT_CNT  BX_COUNTER  TDC_MEAS          time  \\\n",
       "0     1            4  3838279555        2703         1  67575.833333   \n",
       "1     0           62  3838279555        2695        25  67395.833333   \n",
       "2     1           12  3838279555        2698        22  67468.333333   \n",
       "3     0           50  3838279555        2698        23  67469.166667   \n",
       "4     1           14  3838279555        2708        14  67711.666667   \n",
       "\n",
       "   detector  layer  cell  \n",
       "0         3      1     1  \n",
       "1         1      2    16  \n",
       "2         3      1     3  \n",
       "3         1      2    13  \n",
       "4         3      2     4  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Calculate the detector, layer & cell columns according to the previous functions\n",
    "data['detector'] = giveDetector(data['FPGA'], data['TDC_CHANNEL'])\n",
    "data['layer'] = giveLayer(data['TDC_CHANNEL'])\n",
    "data['cell'] = giveCell(data['TDC_CHANNEL'])\n",
    "\n",
    "printmd(\"Dataframe now has new columns: time, detector, layer, and cell.\")\n",
    "display(data.head(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "# III. FINDING EVENTS \n",
    " [Content Outline](#6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A trigger dataset is formed by applying a mask to the original data in order to isolate the hits that correspond to the TDC_CHANNEL 139. Similar lines of code are presented for the two other trigger channels, scintillator 1 and 2. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "trigger_mtt = data.loc[data['TDC_CHANNEL']==mtt, ['ORBIT_CNT','time']]\n",
    "trigger_st = data.loc[(data['TDC_CHANNEL']==st1) | (data['TDC_CHANNEL']==st2), ['ORBIT_CNT','time']]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the .isin() function, the orbits found in trigger_mtt data is isolated from the original dataset to produce the 'events' dataset because, supposedly, **one event corresponds to one common orbit.** The next lines of code sorts the by orbits and reindexed to present the data for each event."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "### Events in the Mean time Trigger <a id =2></a><br>"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>FPGA</th>\n",
       "      <th>TDC_CHANNEL</th>\n",
       "      <th>ORBIT_CNT</th>\n",
       "      <th>BX_COUNTER</th>\n",
       "      <th>TDC_MEAS</th>\n",
       "      <th>time</th>\n",
       "      <th>detector</th>\n",
       "      <th>layer</th>\n",
       "      <th>cell</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>event</th>\n",
       "      <th>index</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"5\" valign=\"top\">1</th>\n",
       "      <th>76</th>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>3200</td>\n",
       "      <td>12</td>\n",
       "      <td>80010.000000</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>88</th>\n",
       "      <td>0</td>\n",
       "      <td>32</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>3206</td>\n",
       "      <td>25</td>\n",
       "      <td>80170.833333</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2730</td>\n",
       "      <td>12</td>\n",
       "      <td>68260.000000</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>96</th>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>3202</td>\n",
       "      <td>19</td>\n",
       "      <td>80065.833333</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>42</th>\n",
       "      <td>0</td>\n",
       "      <td>44</td>\n",
       "      <td>3838279555</td>\n",
       "      <td>2831</td>\n",
       "      <td>28</td>\n",
       "      <td>70798.333333</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             FPGA  TDC_CHANNEL   ORBIT_CNT  BX_COUNTER  TDC_MEAS  \\\n",
       "event index                                                        \n",
       "1     76        0            4  3838279555        3200        12   \n",
       "      88        0           32  3838279555        3206        25   \n",
       "      11        0           40  3838279555        2730        12   \n",
       "      96        0           40  3838279555        3202        19   \n",
       "      42        0           44  3838279555        2831        28   \n",
       "\n",
       "                     time  detector  layer  cell  \n",
       "event index                                       \n",
       "1     76     80010.000000         1      1     1  \n",
       "      88     80170.833333         1      1     8  \n",
       "      11     68260.000000         1      1    10  \n",
       "      96     80065.833333         1      1    10  \n",
       "      42     70798.333333         1      1    11  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "#.isin function compares the two arrays and takes only the orbits that are found in the trigger\n",
    "events_mtt = data.loc[data['ORBIT_CNT'].isin(trigger_mtt['ORBIT_CNT'])]\n",
    "events_st = data.loc[data['ORBIT_CNT'].isin(trigger_st['ORBIT_CNT'])]\n",
    "\n",
    "def create_events(df):\n",
    "    events = df.copy(deep=False)\n",
    "    # We remove the events that are in channels above 128\n",
    "    events = events[events['TDC_CHANNEL'] <= 128]\n",
    "\n",
    "    # We now group by orbit\n",
    "    events['event'] = events.groupby('ORBIT_CNT').ngroup()+1\n",
    "\n",
    "    # Common orbits correspond to a single event\n",
    "    events.set_index(['event', events.index], inplace=True) # We make the events column an index\n",
    "    events.rename_axis(('event','index'), inplace=True)\n",
    "    events.sort_values(['ORBIT_CNT','detector','layer','cell'], inplace=True) # We sort according to these categories\n",
    "    \n",
    "    return events\n",
    "\n",
    "printmd('### Events in the Mean time Trigger <a id =2></a><br>')\n",
    "events_mtt = create_events(events_mtt)\n",
    "display(events_mtt.head(5))\n",
    "if not trigger_st.empty:\n",
    "    printmd('### Events in the Scintillator Trigger')\n",
    "    events_st = create_events(events_st)\n",
    "    display(events_st.head(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "\n",
    "# IV. FINDING TRAJECTORIES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findTrajectories(df):\n",
    "    data = df.copy(deep=False)\n",
    "    data['t0_123'] = 0\n",
    "    data['t0_234'] = 0\n",
    "    for i in data.index.get_level_values(0).unique():\n",
    "        present_detectors = data.loc[i,'detector'].unique()\n",
    "        ev = data.loc[i].copy(deep=False)\n",
    "        \n",
    "        for det in present_detectors:\n",
    "            sub_ev = ev.loc[ev['detector'] == det].copy(deep=False)\n",
    "            for l in range(1,4):\n",
    "                fst_layer = sub_ev.loc[sub_ev['layer'] == l, 'cell']\n",
    "                sec_layer = sub_ev.loc[sub_ev['layer'] == l+1, 'cell']\n",
    "\n",
    "                # Find successor for each cell in layer\n",
    "                if l % 2 == 0:\n",
    "                    successor_mask = fst_layer.isin(sec_layer) | fst_layer.isin(sec_layer+1)\n",
    "                else:\n",
    "                    successor_mask = fst_layer.isin(sec_layer) | fst_layer.isin(sec_layer-1)\n",
    "                \n",
    "                # Drop whole sub_event if the current layer is completely empty\n",
    "                if successor_mask.sum() == 0:\n",
    "                    sub_ev['t0_1'] = np.nan\n",
    "                    sub_ev['t0_2'] = np.nan\n",
    "                    break\n",
    "\n",
    "                else:\n",
    "                    # Drop rows where no successor was found\n",
    "                    sub_ev.loc[(successor_mask==False).index, 't0_1'] = np.nan\n",
    "                    sub_ev.loc[(successor_mask==False).index, 't0_2'] = np.nan\n",
    "\n",
    "            na_mask = sub_ev['t0_1'].notna()\n",
    "            if na_mask.sum() > 0:\n",
    "                t_1 = sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==1).index, 't0_1'].iloc[0]\n",
    "                t_2 = sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==2).index, 't0_1'].iloc[0]\n",
    "                t_3 = sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==3).index, 't0_1'].iloc[0]\n",
    "                t_4 = sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==4).index, 't0_1'].iloc[0]\n",
    "                sub_ev.loc[na_mask,'t0_1'] = 0.5*(0.5*(t_1 + t_3) + t_2)\n",
    "                sub_ev.loc[na_mask, 't0_2'] = 0.5*(0.5*(t_2 + t_4) + t_3)\n",
    "\n",
    "    return data\n",
    "\n",
    "\n",
    "# np.isin or in function of numpy/python is not supported by numba\n",
    "# That's why we make a new .isin function to be able to use the @njit decorator\n",
    "@njit\n",
    "def myIsin(array_a, array_b):\n",
    "    result = np.zeros(len(array_a), dtype=np.bool_)\n",
    "    for i,a in enumerate(array_a):\n",
    "        for j,b in enumerate(array_b):\n",
    "            if a == b:\n",
    "                result[i] = True\n",
    "                break\n",
    "    return result\n",
    "\n",
    "\n",
    "@njit\n",
    "def findTrajectories_np(data, inds, columns):\n",
    "    det_ind, lay_ind, cel_ind, time_ind, t0_1_ind, t0_2_ind = columns #detector, layer, cel, time, 1t0, 2t0 are the columns\n",
    "    #np.roll (array, shift, axis)  #elements of the input array are being shifted\n",
    "    ev_locs = np.where(inds - np.roll(inds,1)!=0)[0]  #np.where(condition,[x,y]) return elements chosen from x or y depending on condition.\n",
    "    ev_locs = np.append(ev_locs, [len(inds)])\n",
    "\n",
    "    for i in range(len(ev_locs)-1):\n",
    "    \n",
    "        ev = data[ev_locs[i]:ev_locs[i+1]]\n",
    "\n",
    "        # Every row registered in same detector?\n",
    "        if np.unique(ev[:,det_ind]).size != 1:\n",
    "            sub_ev_locs = np.where(ev[:,det_ind]-np.roll(ev[:,det_ind],1)!=0)[0]\n",
    "            sub_ev_locs = np.append(sub_ev_locs, [len(ev[:,det_ind])])\n",
    "\n",
    "        else:\n",
    "            sub_ev_locs = np.array([0,len(ev[:,det_ind])])\n",
    "\n",
    "        for j in range(len(sub_ev_locs)-1):\n",
    "            sub_ev = ev[sub_ev_locs[j]:sub_ev_locs[j+1]]\n",
    "\n",
    "            for l in range(1,4):\n",
    "                fst_layer = sub_ev[sub_ev[:,lay_ind]==l,cel_ind]\n",
    "                sec_layer = sub_ev[sub_ev[:,lay_ind]==l+1,cel_ind]\n",
    "\n",
    "                # Find successor for each cell in layer\n",
    "                if l % 2 == 0:\n",
    "                    successor_mask = myIsin(fst_layer, sec_layer) | myIsin(fst_layer, sec_layer+1)\n",
    "                else:\n",
    "                    successor_mask = myIsin(fst_layer, sec_layer) | myIsin(fst_layer, sec_layer-1)\n",
    "\n",
    "                # Drop whole sub_event if the current layer is completely empty\n",
    "                if np.any(successor_mask) == False:\n",
    "                    sub_ev[:,t0_1_ind] = np.nan\n",
    "                    sub_ev[:,t0_2_ind] = np.nan\n",
    "                    break\n",
    "\n",
    "                # Else mark rows where no predecessor was found\n",
    "                # if one cell was found with no predecessor\n",
    "                elif np.all(successor_mask) == False: # False has to be np.array([False]) so that numba broadcasts\n",
    "                    idx = np.nonzero(successor_mask==np.array([False]))[0] + np.nonzero(sub_ev[:,lay_ind]==l)[0][0]\n",
    "                    sub_ev[idx,t0_1_ind] = np.nan\n",
    "                    sub_ev[idx,t0_2_ind] = np.nan\n",
    "\n",
    "            # Compute t0 if a trajectory was found\n",
    "            mask = ~np.isnan(sub_ev[:,t0_1_ind]) # mask where values are numbers and not NaN\n",
    "            if np.any(mask) == True:\n",
    "                t_1 = sub_ev[sub_ev[mask,lay_ind]==1,time_ind][0]\n",
    "                t_2 = sub_ev[sub_ev[mask,lay_ind]==2,time_ind][0]\n",
    "                t_3 = sub_ev[sub_ev[mask,lay_ind]==3,time_ind][0]\n",
    "                t_4 = sub_ev[sub_ev[mask,lay_ind]==4,time_ind][0]\n",
    "                sub_ev[mask,t0_1_ind] = 0.5*(0.5*(t_1 + t_3) + t_2 - T_M)\n",
    "                sub_ev[mask,t0_2_ind] = 0.5*(0.5*(t_2 + t_4) + t_3 - T_M)\n",
    "\n",
    "    return data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Computing $t_0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "### $t_0$ for Mean Time Trigger"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>FPGA</th>\n",
       "      <th>TDC_CHANNEL</th>\n",
       "      <th>ORBIT_CNT</th>\n",
       "      <th>BX_COUNTER</th>\n",
       "      <th>TDC_MEAS</th>\n",
       "      <th>time</th>\n",
       "      <th>detector</th>\n",
       "      <th>layer</th>\n",
       "      <th>cell</th>\n",
       "      <th>t0_123</th>\n",
       "      <th>t0_234</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>event</th>\n",
       "      <th>index</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"5\" valign=\"top\">1</th>\n",
       "      <th>76</th>\n",
       "      <td>0.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>3.838280e+09</td>\n",
       "      <td>3200.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>80010.000000</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>88</th>\n",
       "      <td>0.0</td>\n",
       "      <td>32.0</td>\n",
       "      <td>3.838280e+09</td>\n",
       "      <td>3206.0</td>\n",
       "      <td>25.0</td>\n",
       "      <td>80170.833333</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>0.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>3.838280e+09</td>\n",
       "      <td>2730.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>68260.000000</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>10</td>\n",
       "      <td>76573.125</td>\n",
       "      <td>73416.875</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>96</th>\n",
       "      <td>0.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>3.838280e+09</td>\n",
       "      <td>3202.0</td>\n",
       "      <td>19.0</td>\n",
       "      <td>80065.833333</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>10</td>\n",
       "      <td>76573.125</td>\n",
       "      <td>73416.875</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>42</th>\n",
       "      <td>0.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>3.838280e+09</td>\n",
       "      <td>2831.0</td>\n",
       "      <td>28.0</td>\n",
       "      <td>70798.333333</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>11</td>\n",
       "      <td>76573.125</td>\n",
       "      <td>73416.875</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             FPGA  TDC_CHANNEL     ORBIT_CNT  BX_COUNTER  TDC_MEAS  \\\n",
       "event index                                                          \n",
       "1     76      0.0          4.0  3.838280e+09      3200.0      12.0   \n",
       "      88      0.0         32.0  3.838280e+09      3206.0      25.0   \n",
       "      11      0.0         40.0  3.838280e+09      2730.0      12.0   \n",
       "      96      0.0         40.0  3.838280e+09      3202.0      19.0   \n",
       "      42      0.0         44.0  3.838280e+09      2831.0      28.0   \n",
       "\n",
       "                     time  detector  layer  cell     t0_123     t0_234  \n",
       "event index                                                             \n",
       "1     76     80010.000000         1      1     1        NaN        NaN  \n",
       "      88     80170.833333         1      1     8        NaN        NaN  \n",
       "      11     68260.000000         1      1    10  76573.125  73416.875  \n",
       "      96     80065.833333         1      1    10  76573.125  73416.875  \n",
       "      42     70798.333333         1      1    11  76573.125  73416.875  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def calculate_t0(df):\n",
    "    events = df.copy(deep=False)\n",
    "\n",
    "    events['t0_123'] = 0\n",
    "    events['t0_234'] = 0\n",
    "    level0_inds = events.index.get_level_values(0).to_numpy()\n",
    "    c_names = ['detector', 'layer', 'cell', 'time', 't0_123', 't0_234']\n",
    "    columns = np.array([events.columns.get_loc(column) for column in c_names])\n",
    "\n",
    "    data = findTrajectories_np(events.to_numpy(), level0_inds, columns)\n",
    "    events = pd.DataFrame(data=data, index=events.index, columns=events.columns)\n",
    "\n",
    "    events['detector'] = events['detector'].astype(np.int32)\n",
    "    events['layer'] = events['layer'].astype(np.int32)\n",
    "    events['cell'] = events['cell'].astype(np.int32)\n",
    "\n",
    "    return events\n",
    "\n",
    "printmd(\"### $t_0$ for Mean Time Trigger\")\n",
    "events_mtt = calculate_t0(events_mtt)\n",
    "display(events_mtt.head(5))\n",
    "if not trigger_st.empty:\n",
    "    printmd(\"### $t_0$ for Scintillator Trigger\")\n",
    "    events_st = calculate_t0(events_st)\n",
    "    display(events_st.head(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "# V. CHARACTERIZING THE EVENTS\n",
    " [Content Outline](#6)\n",
    "## CALCULATION OF DRIFT TIMES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "#### For the Mean time Trigger"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def make_hist(df):\n",
    "    events = df.copy(deep=False)\n",
    "\n",
    "    #  Check if t0_123 & t0_234 are \"reasonable close\" to each other, if they are compute average\n",
    "    mask = np.abs(events['t0_123'] - events['t0_234']) < T_M/4\n",
    "    events.loc[mask, 't0'] = (events['t0_123'] + events['t0_234'])/2\n",
    "    events.loc[~mask, 't0'] = np.nan\n",
    "\n",
    "    #  Optionally drop t0_123 and t0_234\n",
    "    events.drop(['t0_123', 't0_234'], inplace=True, axis=1)\n",
    "\n",
    "    #  Compute drift time and position\n",
    "    events['drift_time'] = events['time'] - events['t0']\n",
    "    events['x'] = v_d*events['drift_time']\n",
    "\n",
    "    #  Clean up data for events which have a negative drift time or a position over 21mm\n",
    "    events.loc[(events['drift_time']<0) | (events['x']>L/2), 't0'] = np.nan\n",
    "\n",
    "    hist, edges,_ = plt.hist(events.loc[events['t0'].notna(), 'drift_time'], bins=100)\n",
    "    mid_edges = (edges[:-1] + edges[1:])/2\n",
    "\n",
    "    plt.title('Distribution of Drift Times')\n",
    "    plt.axvline(mid_edges[np.argmax(hist)], c='r', ls='--')\n",
    "    plt.xlabel('Drift time (ns)')\n",
    "    plt.ylabel('Number of Occurrences')\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "    return events\n",
    "\n",
    "\n",
    "printmd('#### For the Mean time Trigger')    \n",
    "events_mtt = make_hist(events_mtt)\n",
    "if not trigger_st.empty:\n",
    "    printmd('#### For the Scintillator Trigger')    \n",
    "    events_st = make_hist(events_st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "#### Drift Times (Calibration Run)  <a id =3></a><br>"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Both the calibration run and physics run show similar behavior: a maximum around 200 ns."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd('#### Drift Times (Calibration Run)  <a id =3></a><br>')\n",
    "printmd('Both the calibration run and physics run show similar behavior: a maximum around 200 ns.')\n",
    "plt.figure(figsize = (12, 5))\n",
    "calib_hist = plt.imread('drift_mtt.png')\n",
    "#fig, ax = plt.subplots(figsize=(12, 6))\n",
    "plt.imshow(calib_hist)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FILTERING THE DATA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "### Useful Events <a id =5></a><br>"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Time Trigger (Physics Run):\n",
      "\"useful rows\" / \"all rows\":  0.007690596077508771\n",
      "\"useful events\" / \"all events\" 0.9319010544988666\n",
      "\n",
      " Mean Time Trigger (Calibration Run):\n",
      "\"useful rows\" / \"all rows\":  0.7248652838992968\n",
      "\"useful events\" / \"all events\" 0.9690319274265875\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Remark: There is less useful hits in the Physics Run."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def print_useful_events(df):\n",
    "    events = df.copy(deep=False)\n",
    "\n",
    "    # Ratio of \"useful rows\" to all rows\n",
    "    try:\n",
    "        print('\"useful rows\" / \"all rows\": ', 1 - len(events[events['t0'].isna()])/events.shape[0])\n",
    "    except ZeroDivisionError:\n",
    "        print('Error: Dataframe is empty')\n",
    "\n",
    "    #  Event is counted as useful if 4 or more times are available\n",
    "    event_groups = events.loc[events['t0'].notna(),'time'].groupby('event').count()\n",
    "    # print(event_groups) \n",
    "    try:\n",
    "        print('\"useful events\" / \"all events\"', (event_groups>3).sum()/len(event_groups))  # some events only have 3 (or below) hits\n",
    "    except ZeroDivisionError:\n",
    "        print('Error: Dataframe is empty')\n",
    "\n",
    "printmd('### Useful Events <a id =5></a><br>')\n",
    "print('Mean Time Trigger (Physics Run):')\n",
    "print_useful_events(events_mtt)\n",
    "print('\\n Mean Time Trigger (Calibration Run):')\n",
    "print('\"useful rows\" / \"all rows\":  0.7248652838992968')\n",
    "print('\"useful events\" / \"all events\" 0.9690319274265875')\n",
    "printmd('Remark: There is less useful hits in the Physics Run.')\n",
    "\n",
    "if not trigger_st.empty:\n",
    "    print('\\n','Scintillator Trigger')\n",
    "    print_useful_events(events_st)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now we filter the data with the following criteria\n",
    "1. Drop hits that do not align\n",
    "2. Obtain events that have at least one hit per layer (i.e. 4 layer representation)\n",
    "3. Sort out events that have only one detector representation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "### Event 1 for the Mean time Trigger"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>FPGA</th>\n",
       "      <th>TDC_CHANNEL</th>\n",
       "      <th>ORBIT_CNT</th>\n",
       "      <th>BX_COUNTER</th>\n",
       "      <th>TDC_MEAS</th>\n",
       "      <th>time</th>\n",
       "      <th>detector</th>\n",
       "      <th>layer</th>\n",
       "      <th>cell</th>\n",
       "      <th>t0</th>\n",
       "      <th>drift_time</th>\n",
       "      <th>x</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>event</th>\n",
       "      <th>index</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"8\" valign=\"top\">1</th>\n",
       "      <th>24562</th>\n",
       "      <td>0.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>3.838280e+09</td>\n",
       "      <td>1382.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>34554.166667</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>34277.8125</td>\n",
       "      <td>276.354167</td>\n",
       "      <td>14.880609</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24557</th>\n",
       "      <td>0.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>3.838280e+09</td>\n",
       "      <td>1375.0</td>\n",
       "      <td>29.0</td>\n",
       "      <td>34399.166667</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>34277.8125</td>\n",
       "      <td>121.354167</td>\n",
       "      <td>6.534455</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24559</th>\n",
       "      <td>0.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>3.838280e+09</td>\n",
       "      <td>1379.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>34485.833333</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>34277.8125</td>\n",
       "      <td>208.020833</td>\n",
       "      <td>11.201122</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24561</th>\n",
       "      <td>0.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>3.838280e+09</td>\n",
       "      <td>1382.0</td>\n",
       "      <td>28.0</td>\n",
       "      <td>34573.333333</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>2</td>\n",
       "      <td>34277.8125</td>\n",
       "      <td>295.520833</td>\n",
       "      <td>15.912660</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24547</th>\n",
       "      <td>0.0</td>\n",
       "      <td>76.0</td>\n",
       "      <td>3.838280e+09</td>\n",
       "      <td>843.0</td>\n",
       "      <td>24.0</td>\n",
       "      <td>21095.000000</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>20909.6875</td>\n",
       "      <td>185.312500</td>\n",
       "      <td>9.978365</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24544</th>\n",
       "      <td>0.0</td>\n",
       "      <td>74.0</td>\n",
       "      <td>3.838280e+09</td>\n",
       "      <td>842.0</td>\n",
       "      <td>21.0</td>\n",
       "      <td>21067.500000</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>20909.6875</td>\n",
       "      <td>157.812500</td>\n",
       "      <td>8.497596</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24545</th>\n",
       "      <td>0.0</td>\n",
       "      <td>86.0</td>\n",
       "      <td>3.838280e+09</td>\n",
       "      <td>844.0</td>\n",
       "      <td>25.0</td>\n",
       "      <td>21120.833333</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>6</td>\n",
       "      <td>20909.6875</td>\n",
       "      <td>211.145833</td>\n",
       "      <td>11.369391</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24550</th>\n",
       "      <td>0.0</td>\n",
       "      <td>83.0</td>\n",
       "      <td>3.838280e+09</td>\n",
       "      <td>851.0</td>\n",
       "      <td>21.0</td>\n",
       "      <td>21292.500000</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>5</td>\n",
       "      <td>20909.6875</td>\n",
       "      <td>382.812500</td>\n",
       "      <td>20.612981</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             FPGA  TDC_CHANNEL     ORBIT_CNT  BX_COUNTER  TDC_MEAS  \\\n",
       "event index                                                          \n",
       "1     24562   0.0          8.0  3.838280e+09      1382.0       5.0   \n",
       "      24557   0.0          6.0  3.838280e+09      1375.0      29.0   \n",
       "      24559   0.0          7.0  3.838280e+09      1379.0      13.0   \n",
       "      24561   0.0          5.0  3.838280e+09      1382.0      28.0   \n",
       "      24547   0.0         76.0  3.838280e+09       843.0      24.0   \n",
       "      24544   0.0         74.0  3.838280e+09       842.0      21.0   \n",
       "      24545   0.0         86.0  3.838280e+09       844.0      25.0   \n",
       "      24550   0.0         83.0  3.838280e+09       851.0      21.0   \n",
       "\n",
       "                     time  detector  layer  cell          t0  drift_time  \\\n",
       "event index                                                                \n",
       "1     24562  34554.166667         1      1     2  34277.8125  276.354167   \n",
       "      24557  34399.166667         1      2     2  34277.8125  121.354167   \n",
       "      24559  34485.833333         1      3     2  34277.8125  208.020833   \n",
       "      24561  34573.333333         1      4     2  34277.8125  295.520833   \n",
       "      24547  21095.000000         2      1     3  20909.6875  185.312500   \n",
       "      24544  21067.500000         2      2     3  20909.6875  157.812500   \n",
       "      24545  21120.833333         2      2     6  20909.6875  211.145833   \n",
       "      24550  21292.500000         2      3     5  20909.6875  382.812500   \n",
       "\n",
       "                     x  \n",
       "event index             \n",
       "1     24562  14.880609  \n",
       "      24557   6.534455  \n",
       "      24559  11.201122  \n",
       "      24561  15.912660  \n",
       "      24547   9.978365  \n",
       "      24544   8.497596  \n",
       "      24545  11.369391  \n",
       "      24550  20.612981  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def prepare_for_vis(df):\n",
    "    # Drop all not aligning hits\n",
    "    visual_evs = df.dropna(subset = ['t0']).copy() \n",
    "    \n",
    "    #  Sort out events which do not go through each layer for each present detector \n",
    "    go_through_each_lay = (visual_evs.loc[:,['layer','detector']].groupby(['event','detector']).nunique() == 4).loc[:,'layer']\n",
    "    go_through_each_lay = go_through_each_lay.groupby('event').all()\n",
    "    \n",
    "    #  Sort out events which are only registered in one detector\n",
    "    multiple_detectors = visual_evs.loc[:,'detector'].groupby('event').nunique() > 1\n",
    "    \n",
    "    #  Combine the two masks\n",
    "    index_mask = go_through_each_lay & multiple_detectors\n",
    "\n",
    "    #  Apply mask to the dataframe\n",
    "    visual_evs = visual_evs.loc[visual_evs.index.get_level_values(0).map(index_mask),:]\n",
    "\n",
    "    #  Reindex the event index level starting from 1\n",
    "    visual_evs.reset_index(level='event', inplace=True)\n",
    "    visual_evs.loc[:,'event'] = (visual_evs.loc[:,'event'].diff()!=0).cumsum()\n",
    "    visual_evs.set_index(['event', visual_evs.index], inplace=True)\n",
    "    \n",
    "    return visual_evs\n",
    "\n",
    "\n",
    "events_mtt_vis = prepare_for_vis(events_mtt)\n",
    "printmd('### Event 1 for the Mean time Trigger')\n",
    "display(events_mtt_vis.head(8))\n",
    "if not trigger_st.empty:\n",
    "    events_st_vis = prepare_for_vis(events_st)\n",
    "    printmd('### Event 1 for the Scintillator Trigger')\n",
    "    display(events_st_vis.head(8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "# <a id =4></a><br> VI. THE DETECTOR MATRIX \n",
    " [Content Outline](#6)\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "The following paths represent some of the event trajectories found in the data. <span style='color:blue'> Blue </span> dots indicate paths at the right of the anodic wire, while <span style='color:green'> green </span> dots indicate paths at the left as in the project description"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "#### Event Path 1"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "This event follows a trajectory of a particle through detectors 1 and 2."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "#### Event Path 2"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "This event follows a trajectory of a particle through detectors 3 and 4."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "#### Event Path 3"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Like in the Calibration run, we get these noisy trajectories. It is noticeable that we get these erratic trajectories much more common in the physics run."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plotDetector(ax, event, is_empty):\n",
    "    detector = np.zeros((4,16*2+1))\n",
    "\n",
    "    even_layers = event['layer']%2 == 0\n",
    "    odd_layers = even_layers == False\n",
    "\n",
    "    def fillDetectorMatrix(matrix, i, j, s=0):\n",
    "        matrix[i,j*2+s] = 1\n",
    "        matrix[i,j*2+1+s] = 1\n",
    "\n",
    "    def plotLeftRight(ax, cell, position, layer, odd, left):\n",
    "        if left == True:\n",
    "            ax.scatter((cell-1-position/L)*2+0.5+odd, layer-1, s=10, c='g', marker='+')\n",
    "        else:\n",
    "            ax.scatter((cell-1+position/L)*2+0.5+odd, layer-1, s=10, c='b', marker='+')\n",
    "    \n",
    "    if is_empty == False:\n",
    "        fillDetectorMatrix(detector, event.loc[even_layers,'layer']-1,\n",
    "                    event.loc[even_layers,'cell']-1, s=0)\n",
    "        fillDetectorMatrix(detector, event.loc[odd_layers,'layer']-1,\n",
    "                    event.loc[odd_layers,'cell']-1, s=1)\n",
    "\n",
    "        for odd,left in [[odd, left] for odd in [True, False] for left in [True,False]]:\n",
    "            if odd == True:\n",
    "                layers = odd_layers\n",
    "            else:\n",
    "                layers = even_layers\n",
    "\n",
    "            plotLeftRight(ax, event.loc[layers, 'cell'], event.loc[layers, 'x'],\n",
    "                     event.loc[layers, 'layer'], odd, left)\n",
    "\n",
    "    detector[(0,1,2,3),(0,32,0,32)] = 0.5 # Mark \"cell offset\"\n",
    "    ax.matshow(detector, origin='lower', cmap='bone', vmin=0, vmax=1)\n",
    "\n",
    "    # Major ticks\n",
    "    ax.set_xticks(np.arange(1.5, 32, 2));\n",
    "    ax.set_yticks(np.arange(0, 4, 1));\n",
    "\n",
    "    # # Labels for major ticks\n",
    "    ax.set_xticklabels(np.arange(1, 17, 1));\n",
    "    ax.set_yticklabels(np.arange(1, 5, 1));\n",
    "\n",
    "    # # Minor ticks\n",
    "    # # ax.set_xticks(np.arange(-.5, 32, 2), minor=True);\n",
    "    ax.set_yticks(np.arange(0.5, 4, 1), minor=True);\n",
    "\n",
    "    ax.grid(which='minor', axis='y', color='w', linewidth=1)\n",
    "    ax.xaxis.set_ticks_position('bottom')\n",
    "    \n",
    "    vert_line = np.array([0,1])\n",
    "    for l in range(4):\n",
    "        for c in range(16):\n",
    "            if l%2 == 0:\n",
    "                ax.plot([c*2+0.5,c*2+0.5], vert_line+l-0.5, c='w')\n",
    "            else:\n",
    "                ax.plot([c*2+1.5,c*2+1.5], vert_line+l-0.5, c='w')\n",
    "\n",
    "def plotEvent(event):\n",
    "    fig, axes = plt.subplots(2, 2, figsize=(12,4))\n",
    "\n",
    "    for i in range(0,4):\n",
    "        sub_ev = event.loc[event['detector']==i+1, :]\n",
    "        plotDetector(axes[1-i%2,i//2], sub_ev, sub_ev.empty)\n",
    "        axes[1-i%2,i//2].set_title('Detector {}'.format(i+1))\n",
    "    # TODO legend\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "printmd(\"The following paths represent some of the event trajectories found in the data. <span style='color:blue'> Blue </span> dots indicate paths at the right of the anodic wire, while <span style='color:green'> green </span> dots indicate paths at the left as in the project description\")\n",
    "printmd(\"#### Event Path 1\")\n",
    "printmd(\"This event follows a trajectory of a particle through detectors 1 and 2.\")\n",
    "plotEvent(events_mtt_vis.loc[11])\n",
    "\n",
    "printmd(\"#### Event Path 2\")\n",
    "printmd(\"This event follows a trajectory of a particle through detectors 3 and 4.\")\n",
    "plotEvent(events_mtt_vis.loc[273])\n",
    "\n",
    "printmd(\"#### Event Path 3\")\n",
    "printmd(\"Like in the Calibration run, we get these noisy trajectories. It is noticeable that we get these erratic trajectories much more common in the physics run.\")\n",
    "plotEvent(events_mtt_vis.loc[116])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Final Remarks: \n",
    "The Physics Run showed more noise in the data. Nonetheless, the code that was done for the calibration run still worked well."
   ]
  }
 ],
 "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.8.1"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}