From 2eeff5e3deefc15a66e16910da11a6b65ca0576a Mon Sep 17 00:00:00 2001 From: Holgerillo Date: Mon, 10 Feb 2020 11:30:25 +0100 Subject: [PATCH 1/4] Finished event detection and plotting --- Data_Analysis.ipynb | 1345 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1345 insertions(+) create mode 100644 Data_Analysis.ipynb diff --git a/Data_Analysis.ipynb b/Data_Analysis.ipynb new file mode 100644 index 0000000..60473d6 --- /dev/null +++ b/Data_Analysis.ipynb @@ -0,0 +1,1345 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 1310592 entries, 0 to 1310591\n", + "Data columns (total 5 columns):\n", + " # Column Non-Null Count Dtype\n", + "--- ------ -------------- -----\n", + " 0 FPGA 1310592 non-null int64\n", + " 1 TDC_CHANNEL 1310592 non-null int64\n", + " 2 ORBIT_CNT 1310592 non-null int64\n", + " 3 BX_COUNTER 1310592 non-null int64\n", + " 4 TDC_MEAS 1310592 non-null int64\n", + "dtypes: int64(5)\n", + "memory usage: 50.0 MB\n", + "None\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEAS
count1.310592e+061.310592e+061.310592e+061.310592e+061.310592e+06
mean6.110017e-016.731868e+011.917389e+091.780785e+031.342183e+01
std4.875231e-014.093277e+016.613721e+061.028466e+039.154085e+00
min0.000000e+001.000000e+001.897415e+090.000000e+000.000000e+00
25%0.000000e+003.100000e+011.918696e+098.910000e+025.000000e+00
50%1.000000e+006.800000e+011.919401e+091.781000e+031.300000e+01
75%1.000000e+009.900000e+011.920162e+092.670000e+032.100000e+01
max1.000000e+001.390000e+021.920955e+093.563000e+032.900000e+01
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS\n", + "count 1.310592e+06 1.310592e+06 1.310592e+06 1.310592e+06 1.310592e+06\n", + "mean 6.110017e-01 6.731868e+01 1.917389e+09 1.780785e+03 1.342183e+01\n", + "std 4.875231e-01 4.093277e+01 6.613721e+06 1.028466e+03 9.154085e+00\n", + "min 0.000000e+00 1.000000e+00 1.897415e+09 0.000000e+00 0.000000e+00\n", + "25% 0.000000e+00 3.100000e+01 1.918696e+09 8.910000e+02 5.000000e+00\n", + "50% 1.000000e+00 6.800000e+01 1.919401e+09 1.781000e+03 1.300000e+01\n", + "75% 1.000000e+00 9.900000e+01 1.920162e+09 2.670000e+03 2.100000e+01\n", + "max 1.000000e+00 1.390000e+02 1.920955e+09 3.563000e+03 2.900000e+01" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from IPython.display import display\n", + "\n", + "file = '../data/Run000260/data_000000.txt'\n", + "run260 = pd.read_csv(file)\n", + "run260.drop('HEAD', inplace=True, axis=1)\n", + "\n", + "print(run260.info())\n", + "display(run260.describe())" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax1,ax2) = plt.subplots(1,2,figsize=(10,4))\n", + "\n", + "df_0 = run260[run260['FPGA']==0]\n", + "df_1 = run260[run260['FPGA']==1]\n", + "\n", + "max_channel = run260['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", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "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": [ + "from numba import vectorize, int64, jit, njit\n", + "# run260['time'] = run260['ORBIT_CNT']*2564*25 + run260['BX_COUNTER']*25 + run260['TDC_MEAS']*25/30\n", + "run260['time'] = run260['BX_COUNTER']*25 + run260['TDC_MEAS']*25/30\n", + "\n", + "# Scintillator trigger channel 1 & 2\n", + "st1 = 137\n", + "st2 = 138\n", + "# Mean-time trigger channel\n", + "mtt = 139\n", + "# params\n", + "T_M = 390 # ms\n", + "L = 42 # mm\n", + "v_d = L/(2*T_M)\n", + "\n", + "# Detector column displays -1 for trigger and detector number else\n", + "run260['detector'] = -1\n", + "run260.loc[run260['TDC_CHANNEL']<=128,'detector'] = run260['FPGA']*2+1 + run260['TDC_CHANNEL']//64\n", + "# add layer column\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\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))))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEAStimedetectorlayercell
01116189741488415332438345.0000004113
1171189741488716502141267.500000432
21671897414914980824506.666667431
317018974149221287832181.666667422
4057189741492221622254068.3333331415
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS time \\\n", + "0 1 116 1897414884 1533 24 38345.000000 \n", + "1 1 71 1897414887 1650 21 41267.500000 \n", + "2 1 67 1897414914 980 8 24506.666667 \n", + "3 1 70 1897414922 1287 8 32181.666667 \n", + "4 0 57 1897414922 2162 22 54068.333333 \n", + "\n", + " detector layer cell \n", + "0 4 1 13 \n", + "1 4 3 2 \n", + "2 4 3 1 \n", + "3 4 2 2 \n", + "4 1 4 15 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# run260.groupby('ORBIT_CNT')\n", + "run260['detector'] = giveDetector(run260['FPGA'], run260['TDC_CHANNEL'])\n", + "run260['layer'] = giveLayer(run260['TDC_CHANNEL'])\n", + "run260['cell'] = giveCell(run260['TDC_CHANNEL'])\n", + "# display(run260[run260['TDC_CHANNEL']==st1].head())\n", + "# display(run260[run260['TDC_CHANNEL']==st2].head())\n", + "display(run260.head(5))" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEAStimedetectorlayercell
8013918974149342028050700.0-1-1-1
72013918974153012812070300.0-1-1-1
87113918974154251335033375.0-1-1-1
115113918974155441234030850.0-1-1-1
140113918974156741198029950.0-1-1-1
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS time detector \\\n", + "8 0 139 1897414934 2028 0 50700.0 -1 \n", + "72 0 139 1897415301 2812 0 70300.0 -1 \n", + "87 1 139 1897415425 1335 0 33375.0 -1 \n", + "115 1 139 1897415544 1234 0 30850.0 -1 \n", + "140 1 139 1897415674 1198 0 29950.0 -1 \n", + "\n", + " layer cell \n", + "8 -1 -1 \n", + "72 -1 -1 \n", + "87 -1 -1 \n", + "115 -1 -1 \n", + "140 -1 -1 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ORBIT_CNTtime
8189741493450700.0
72189741530170300.0
87189741542533375.0
115189741554430850.0
140189741567429950.0
\n", + "
" + ], + "text/plain": [ + " ORBIT_CNT time\n", + "8 1897414934 50700.0\n", + "72 1897415301 70300.0\n", + "87 1897415425 33375.0\n", + "115 1897415544 30850.0\n", + "140 1897415674 29950.0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ORBIT_CNTtime
24235189753750726853.333333
24238189753750726857.500000
24239189753750726850.833333
24241189753750726860.000000
24448719185055051525.833333
\n", + "
" + ], + "text/plain": [ + " ORBIT_CNT time\n", + "24235 1897537507 26853.333333\n", + "24238 1897537507 26857.500000\n", + "24239 1897537507 26850.833333\n", + "24241 1897537507 26860.000000\n", + "244487 1918505505 1525.833333" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "trigger_mtt = run260.loc[run260['TDC_CHANNEL']==mtt, ['ORBIT_CNT','time']]\n", + "display(run260.loc[run260['TDC_CHANNEL']==mtt].head())\n", + "trigger_st = run260.loc[(run260['TDC_CHANNEL']==st1) | (run260['TDC_CHANNEL']==st2), ['ORBIT_CNT','time']]\n", + "trigger_st1 = run260.loc[run260['TDC_CHANNEL']==st1, ['ORBIT_CNT','time']]\n", + "display(trigger_mtt.head())\n", + "display(trigger_st.head())" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": {}, + "outputs": [], + "source": [ + "events = run260.loc[run260['ORBIT_CNT'].isin(trigger_mtt['ORBIT_CNT'])]\n", + "events = events[events['TDC_CHANNEL'] <= 128]\n", + "# events['trigger_time'] = trigger_mtt['time'].reindex(events.index, method='backfill')\n", + "changes = (events['ORBIT_CNT'].diff() != 0).cumsum()\n", + "events.set_index([changes.to_numpy(), events.index], inplace=True)\n", + "# events['trigger_time'] = trigger_mtt['time']\n", + "events.rename_axis(('event','index'), inplace=True)\n", + "events.sort_values(['event','detector','layer','cell'], inplace=True)\n", + "events.drop(['FPGA','TDC_CHANNEL','ORBIT_CNT','BX_COUNTER','TDC_MEAS'], inplace=True, axis=1)\n", + "\n", + "# display(events.loc[55])" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
timedetectorlayercell
index
550360.833333116
650366.666667127
750660.833333127
1050609.166667137
1150657.500000148
950661.666667149
\n", + "
" + ], + "text/plain": [ + " time detector layer cell\n", + "index \n", + "5 50360.833333 1 1 6\n", + "6 50366.666667 1 2 7\n", + "7 50660.833333 1 2 7\n", + "10 50609.166667 1 3 7\n", + "11 50657.500000 1 4 8\n", + "9 50661.666667 1 4 9" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "first_event = events.loc[1].copy()\n", + "\n", + "display(first_event)\n", + "# first_event['cell'] = [1,1,1,1]\n", + "\n", + "def plot_event(event):\n", + " detector_m = np.zeros((4,16*2+1))\n", + "\n", + " fig, ax = plt.subplots(figsize=(9,2))\n", + "\n", + " even_layers = first_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", + " fillDetectorMatrix(detector_m, first_event.loc[even_layers,'layer']-1,\n", + " first_event.loc[even_layers,'cell']-1, s=0)\n", + " fillDetectorMatrix(detector_m, first_event.loc[odd_layers,'layer']-1,\n", + " first_event.loc[odd_layers,'cell']-1, s=1)\n", + "\n", + " detector_m[(0,1,2,3),(0,32,0,32)] = 0.5 # Mark \"cell offset\"\n", + "\n", + " ax.matshow(detector_m, origin='lower', cmap='bone')\n", + " ax.scatter((first_event.loc[even_layers, 'cell']-1)*2+0.5,\n", + " first_event.loc[even_layers, 'layer']-1, s=10, c='r', marker='+')\n", + " ax.scatter((first_event.loc[odd_layers, 'cell']-1)*2+1.5,\n", + " first_event.loc[odd_layers, 'layer']-1, s=10, c='r', marker='+')\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", + " plt.plot([c*2+0.5,c*2+0.5], vert_line+l-0.5, c='w')\n", + " else:\n", + " plt.plot([c*2+1.5,c*2+1.5], vert_line+l-0.5, c='w')\n", + "\n", + " plt.show()\n", + "\n", + "plot_event(first_event)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAABzCAYAAACxdkgEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAK6ElEQVR4nO3df6zVdR3H8ecrwARERYFCICl/MJtriOQsixm4hqiUtTZ/zpbOrWVhZaZjc7rmSivzP5uh5fzVTNGMzYRULLeUAQKCV9Mm/kQgmr/SmeC7P74f2hXvvZzD9/O993PufT22s/M9nHtfvM893+/7++N8v+ejiMDMzMr1kYEuwMzM+uZGbWZWODdqM7PCuVGbmRXOjdrMrHBu1GZmhRveROi4ceNi27ZtWTOPPvpoVq1aVWyeM48meDNrphjTMa/dmUMrs4kaASJCPf27mjiPeubMmbFq1ZqsmRHbkfKtV3LnOXM723csz5o5fNjxHfPanTm0MpuoEXb02qh96MPMrHBu1GZmhXOjNjMrnBu1mVnh3KjNzArXcqOWNEzS45KWNFmQmZl9UDtb1AuArqYKMTOznrXUqCVNBk4CFjVbjpmZ7arVLeprgYuB9xusxYaIMxa9M9AlmHWU3TZqSScDWyKiz+slJZ0vaaWklVu3bs1WoA0uZyx6hxXPeX1v1o7dXkIu6afA2cB2YG9gX2BxRJzV2+/4EvKhmelLyJ05VDKLu4Q8Ii6NiMkRMRU4DXiwryZtZmZ5+TxqM7PCtbXtHhHLgeWNVGJmZj3yFrWZWeHcqM3MCudGbWZWODdqM7PCuVGbmRUu6xnbkk4BTjn00EOJ2J4zGiB7ZifU2EmZw4cdnz2zU167M4deZu48qcdrXarnPLhtPp2U6asInenMcvIqHtzWzKxjuVGbmRXOjdrMrHBu1GZmhXOjNjMrXCsDB+wtaYWktZI2SLqiPwozM7NKK+eXvAvMjoi3JI0AHpF0X0Q82nBtZmZGawMHRES8lR6OSLf8J19bkTy+odnAa3UU8mGS1gBbgGUR8VgPP+MxEwcZj29oVoaWGnVE7IiI6cBk4BhJR/bwM9dHxMyImDl+/PjcddoAuO28kTx75eiBLsNsyGvrrI+IeI1qhJe5jVRjZmYf0spZH+Ml7Z+mRwInAE81XZiZmVVaOetjInCTpGFUjf2OiFjSbFlmZrbTbht1RKwDjuqHWszMrAe+MtHMrHBu1GZmhXOjNjMrnBu1mVnh3KjNzArnwW0z65RMD0TrTGeWlefBbfshr9MyPbitM51ZTl7Fg9uamXUsN2ozs8K5UZuZFc6N2syscG7UZmaFa+VrTqdIekhSVxrcdkF/FGZmZpVWzi/ZDvwwIlZLGgOskrQsIp5suDYzM6O1wW03RcTqNP0m0AVMarowK4MHtzUbeG0do5Y0leq7qT247RDgwW3NytByo5a0D3AXcGFEvLHr8x7cdvDx4LZmZWipUUsaQdWkb42Ixc2WZGZm3bVy1oeAG4CuiLim+ZLMzKy7VraojwPOBmZLWpNu8xquy8zMklYGt30E6P3798zMrFG+MtHMrHBu1GZmhXOjNjMrnBu1mVnh3KjNzArnwW0z65RMD27rTGeWlefBbfshr9MyPbitM51ZTl7Fg9uamXUsN2ozs8K5UZuZFc6N2syscK18e96NkrZIWt8fBZmZ2Qe1skX9O2Buw3WYmVkvWhkz8a/Av/uhFjMz64GPUVufPLit2cDL1qg9uO3g48FtzcqQrVF7cNvBx4PbmpXBhz7MzArXyul5twN/B6ZJeknSuc2XZWZmO7UyZuLp/VGImZn1zIc+zMwK50ZtZlY4N2ozs8K5UZuZFc6N2syscG7UZmaFa2RwW+BtoKuFXxkH/KvF7P2A13NltpHnzNbeo46oM/d85MyhmdnQMnRwr89ERPYbcH2LP7dyoDJbzXPm0MwcyHnTmeVnNjFv9nVr6tDHnzogsxNqdKYznVlmZhM19qqRRh0R2V9E7sxOqNGZznRmmZlN1NiXgf4w8XpnOrPQzE6o0ZlDJFPpGIqZmRVqoLeozcxsNwakUTcxsrmkKZIektQlaYOkBTXz9pa0QtLalHdFxlqHSXpc0pJMeRslPSFpjaSVmTL3l3SnpKfS3/RzNfOmpfp23t6QdGGGOr+f3p/1km6XtHeGzAUpb8Oe1tjTPC7pAEnLJD2T7sdmyPxGqvN9STMz1fnz9L6vk3S3pP0zZP4k5a2RtFTSQXUzuz13kaSQNC5DnZdLernbfDovR52Svivp6fReXd1OJtDM6XktnK4yC5gBrM+YORGYkabHAP8APl0jT8A+aXoE8BhwbKZafwDcBizJlLcRGJf5PboJOC9N7wXsnzF7GPAqcHDNnEnAc8DI9PgO4Js1M48E1gOjqK4z+Atw2B7kfGgeB64GLknTlwBXZcg8ApgGLAdmZqrzy8DwNH1Vpjr37Tb9PeDXdTPTv08B7geeb3cZ6KXOy4GLasw/PWV+Kc1HH02PJ7SbOyBb1NHAyOYRsSkiVqfpN6kuuJlUIy8i4q30cES61T6gL2kycBKwqG5WUyTtSzXD3QAQEf+NiNcy/hdzgH9GxPMZsoYDIyUNp2qur9TMOwJ4NCLejojtwMPAqe2G9DKPf4VqBUi6/2rdzIjoioin261vN5lL02sHeBSYnCHzjW4PR9PmstRHz/gVcHG7ebvJ3GO9ZH4b+FlEvJt+Zku7uYPyGLWkqcBRVFvBdXKGSVoDbAGWRUStvORaqhkr56ixASyVtErS+RnyPgVsBX6bDtEskpRz8MTTgNvrhkTEy8AvgBeATcDrEbG0Zux6YJakAyWNAuZRbbXl8LGI2ATVhgUwIVNuk74F3JcjSNKVkl4EzgQuy5A3H3g5ItbWLu6DLkiHaW5s9/BULw4HvijpMUkPS/psuwGDrlFL2ge4C7hwl7V42yJiR0RMp9qiOEbSkTVrOxnYEhGr6uT04LiImAGcCHxH0qyaecOpdt+ui4ijgP9Q7arXJmkvYD7whwxZY6m2Uj8JHASMlnRWncyI6KLa3V8G/BlYC2zv85cGKUkLqV77rTnyImJhRExJeRfUrG0UsJAMDX8X1wGHANOpVv6/zJA5HBgLHAv8CLhDktoJGFSNWtIIqiZ9a0QszpWbdvuXA3NrRh0HzJe0Efg9MFvSLTUziYhX0v0W4G7gmJqRLwEvdduDuJOqcedwIrA6IjZnyDoBeC4itkbEe8Bi4PN1QyPihoiYERGzqHZjn6mbmWyWNBEg3be9C9xfJJ0DnAycGenAaka3AV+vmXEI1Qp6bVqeJgOrJX28TmhEbE4baO8Dv6H+sgTV8rQ4HU5dQbU33dYHn4OmUac11A1AV0RckyFv/M5PuyWNpGoKT9XJjIhLI2JyREyl2v1/MCJqbQFKGi1pzM5pqg+Cap1NExGvAi9Kmpb+aQ7wZJ3Mbk4nw2GP5AXgWEmj0vs/h9a+DKxPkiak+08AXyNfvfcC56Tpc4A/ZsrNStJc4MfA/Ih4O1PmYd0ezqf+svREREyIiKlpeXqJ6mSCV+vk7lyRJqdSc1lK7gFmp/zDqT6cb+nLpP5vTz/drHOjmvE3Ae9R/YHPzZD5BapjteuANek2r0beZ4DHU9564LLMf4PjyXDWB9Xx5LXptgFYmKm+6cDK9PrvAcZmyBwFbAP2y/h3vIJqoV8P3Ez6ZL1m5t+oVkxrgTl7mPGheRw4EHiAagv9AeCADJmnpul3gc3A/RkynwVe7LYctXuGRk+Zd6X3aB3V92RMqpu5y/Mbaf+sj57qvBl4ItV5LzAxQ+ZewC3p9a8GZrc7P/nKRDOzwg2aQx9mZoOVG7WZWeHcqM3MCudGbWZWODdqM7PCuVGbmRXOjdrMrHBu1GZmhfsfINF/kpfnPBUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "first_event = events.loc[2].copy()\n", + "# first_event['time'] = first_event['time'] - first_event['time'].iloc[0]\n", + "# first_event['x'] = v_d * first_event['time']\n", + "# display(first_event)\n", + "# display(events.loc[1])\n", + "detector_m = np.zeros((4,16))\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "detector_m[first_event['layer']-1, first_event['cell']-1] = 1\n", + "# detector_m[first_event['layer']-1, first_event['cell']-1] = 1\n", + "ax.matshow(detector_m, origin='lower', cmap='magma')\n", + "ax.xaxis.set_ticks_position('bottom')\n", + "ax.scatter(first_event['cell']-1, first_event['layer']-1, 1, marker='+')\n", + "\n", + "# Major ticks\n", + "ax.set_xticks(np.arange(0, 16, 1));\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, 15, 1), minor=True);\n", + "ax.set_yticks(np.arange(-.5, 3, 1), minor=True);\n", + "\n", + "ax.grid(which='minor', axis='both', color='w', linewidth=1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Get $t_0$\n", + "\n", + "$$T_{Max} = \\frac{(t'_1-t_0)+(t'_3-t_0)}{2}+(t'_2-t_0)$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$t_0 = \\frac{1}{2}\\left(\\frac{t'_1+t'_3}{2}+t'_2-T_{Max}\\right)$$" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
timedetectorlayercellflag
eventindex
1550360.8333331.01.06.00.0
650366.6666671.02.07.00.0
750660.8333331.02.07.00.0
1050609.1666671.03.07.00.0
1150657.5000001.04.08.00.0
950661.6666671.04.09.01.0
27370270.0000002.01.06.00.0
7070072.5000002.02.06.00.0
7169957.5000002.03.06.00.0
7470197.5000002.04.07.00.0
\n", + "
" + ], + "text/plain": [ + " time detector layer cell flag\n", + "event index \n", + "1 5 50360.833333 1.0 1.0 6.0 0.0\n", + " 6 50366.666667 1.0 2.0 7.0 0.0\n", + " 7 50660.833333 1.0 2.0 7.0 0.0\n", + " 10 50609.166667 1.0 3.0 7.0 0.0\n", + " 11 50657.500000 1.0 4.0 8.0 0.0\n", + " 9 50661.666667 1.0 4.0 9.0 1.0\n", + "2 73 70270.000000 2.0 1.0 6.0 0.0\n", + " 70 70072.500000 2.0 2.0 6.0 0.0\n", + " 71 69957.500000 2.0 3.0 6.0 0.0\n", + " 74 70197.500000 2.0 4.0 7.0 0.0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[False True True False False True False]\n" + ] + } + ], + "source": [ + "display(events.head(10))\n", + "\n", + "def findTrajectories(df):\n", + " for i in events.index.get_level_values(0).unique():\n", + " if events.loc[i,'detector'].nunique() != 1:\n", + " events.drop(i, inplace=True)\n", + " continue\n", + "\n", + " for l in range(1,4):\n", + " fst_layer = events.loc[(i, events['layer'] == l), 'cell']\n", + " sec_layer = events.loc[(i, events['layer'] == l+1), 'cell']\n", + "\n", + " # Find predecessor for each cell in layer\n", + " if l % 2 == 0:\n", + " predecessor_mask = sec_layer.isin(fst_layer) | sec_layer.isin(fst_layer-1) # change if drawing not wrong???\n", + " else:\n", + " predecessor_mask = sec_layer.isin(fst_layer) | sec_layer.isin(fst_layer+1)\n", + "\n", + " idx = predecessor_mask[predecessor_mask == False].index\n", + "\n", + " # Drop rows where no predecessor was found\n", + " events.drop(idx, inplace=True)\n", + "\n", + " # Drop whole event if the current layer is completely empty\n", + " if len(idx) == len(sec_layer):\n", + " events.drop(i, inplace=True)\n", + " break\n", + "\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", + "print(myIsin(np.array([1,2,2,3,4,5,0]), np.array([2,5])))\n", + "\n", + "@njit\n", + "def findTrajectories_np(data, inds):\n", + " event_locs = np.where(level0_inds-np.roll(level0_inds,1) !=0)[0]\n", + "\n", + " for i in range(len(event_locs)-1):\n", + " \n", + " ev = data[event_locs[i]:event_locs[i+1]]\n", + "\n", + " # Every row registered in same detector?\n", + " if np.unique(ev[:,1]).size != 1:\n", + " ev[:,4] = 1\n", + " continue\n", + "\n", + " for l in range(1,4):\n", + " fst_layer = ev[ev[:,2]==l,3]\n", + " sec_layer = ev[ev[:,2]==l+1,3]\n", + "\n", + " # Find predecessor for each cell in layer\n", + " if l % 2 == 0:\n", + "# predecessor_mask = np.array([item in fst_layer for item in sec_layer]) | np.array([item in fst_layer-1 for item in sec_layer])\n", + "# predecessor_mask = np.isin(sec_layer, fst_layer) | np.isin(sec_layer, fst_layer-1) # change if drawing not wrong???\n", + " predecessor_mask = myIsin(sec_layer, fst_layer) | myIsin(sec_layer, fst_layer-1)\n", + " else:\n", + "# predecessor_mask = np.array([item in fst_layer for item in sec_layer]) | np.array([item in (fst_layer+1) for item in sec_layer])\n", + "# predecessor_mask = np.isin(sec_layer, fst_layer) | np.isin(sec_layer, fst_layer+1)\n", + " predecessor_mask = myIsin(sec_layer, fst_layer) | myIsin(sec_layer, fst_layer+1)\n", + "\n", + " # Drop whole event if the current layer is completely empty\n", + " if np.any(predecessor_mask) == False:\n", + " ev[:,4] = 1\n", + " break\n", + "\n", + " # Else mark rows where no predecessor was found\n", + " # False has to be np.array([False]) so that numba broadcasts\n", + " elif np.all(predecessor_mask) == False:\n", + " idx = np.nonzero(predecessor_mask==np.array([False]))[0] + np.nonzero(ev[:,2]==l+1)[0][0]\n", + " ev[idx,4] = 1\n", + "\n", + " return data" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
timedetectorlayercellflag
eventindex
1550360.8333331160
650366.6666671270
750660.8333331270
1050609.1666671370
1150657.5000001480
950661.6666671491
27370270.0000002160
7070072.5000002260
7169957.5000002360
7470197.5000002470
\n", + "
" + ], + "text/plain": [ + " time detector layer cell flag\n", + "event index \n", + "1 5 50360.833333 1 1 6 0\n", + " 6 50366.666667 1 2 7 0\n", + " 7 50660.833333 1 2 7 0\n", + " 10 50609.166667 1 3 7 0\n", + " 11 50657.500000 1 4 8 0\n", + " 9 50661.666667 1 4 9 1\n", + "2 73 70270.000000 2 1 6 0\n", + " 70 70072.500000 2 2 6 0\n", + " 71 69957.500000 2 3 6 0\n", + " 74 70197.500000 2 4 7 0" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "events['flag'] = 0\n", + "level0_inds = events.index.get_level_values(0).to_numpy()\n", + "data = findTrajectories_np(events.to_numpy(), level0_inds)\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", + "events['flag'] = events['flag'].astype(np.int32)\n", + "\n", + "events.drop(events[events['flag']==1].index, inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From d7e271463cc851db2f7d876101ce51fa57cf287a Mon Sep 17 00:00:00 2001 From: Holgerillo Date: Mon, 16 Mar 2020 17:13:41 +0100 Subject: [PATCH 2/4] Updated Data Analysis, Pre final version --- .gitignore | 1 + Data_Analysis.ipynb | 1830 ++++++++++++++++--------------------------- Project.ipynb | 8 +- 3 files changed, 671 insertions(+), 1168 deletions(-) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..54257da --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/Old \ No newline at end of file diff --git a/Data_Analysis.ipynb b/Data_Analysis.ipynb index 60473d6..db5a26d 100644 --- a/Data_Analysis.ipynb +++ b/Data_Analysis.ipynb @@ -1,221 +1,292 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "The project is outlined as following:\n", + " \n", + " - [THE DATA](#1)\n", + " \n", + " - [ADDING NEW COLUMNS](#2)\n", + " \n", + " - [GATHERING EVENTS](#3)\n", + " \n", + " - [FINDING TRAJECTORIES](#4)\n", + " \n", + " - [VISUALIZING THE EVENTS](#5)\n", + " - [DETECTOR MATRIX](#7)\n", + " \n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#

THE DATA: Calibration run 260 / Real Measurement run 333\n", + "\n", + "\n", + "In this project, we analyze the data obtained through a set of particle detectors. The detectors consist on four layers of cells fulls of a gas. Each of the cells is traversed by an anodic cable in its middle. When a particle traverses the gas, it ionizes it, with the ions being then attracted towards the cable. The cell then emmits a signal when the ions reach the cable. \\\n", + "The ions can be considered to travel at a constat drift velocity $v_d$ towards the cable. The impact possition in a cell $x$ can be expressed as\n", + " \n", + " \n", + "$$\n", + "x = v_d (t - t_0),\n", + "$$\n", + " \n", + "being $t_0$ a pedestal time and $t$ the time recorded by the detector. As the maximum drift time $T_{Max} = \\frac{L}{2 v_d} = 390$ ns ($L=42$ mm is the lenght of the cell) is a known country, t0 can be calculated. This will be explained later. \n", + "\\\n", + "The data obtained are encoded in a CSV file. The way we can interpret its content is exlained as it is needed. It is the goal of this project to analyze these data so that we can track the trajectories of the particles through them. More specifically, the tasks to do are:\n", + " \n", + " -Grouping the data into events corresponding to a particle hitting the detector\n", + " -Obtain and plot the drift times\n", + " \n", + "This was done for both a calibration run and for a the data obtained in a real experiment.\n", + "\n" + ] + }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "RangeIndex: 1310592 entries, 0 to 1310591\n", - "Data columns (total 5 columns):\n", - " # Column Non-Null Count Dtype\n", - "--- ------ -------------- -----\n", - " 0 FPGA 1310592 non-null int64\n", - " 1 TDC_CHANNEL 1310592 non-null int64\n", - " 2 ORBIT_CNT 1310592 non-null int64\n", - " 3 BX_COUNTER 1310592 non-null int64\n", - " 4 TDC_MEAS 1310592 non-null int64\n", - "dtypes: int64(5)\n", - "memory usage: 50.0 MB\n", - "None\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEAS
count1.310592e+061.310592e+061.310592e+061.310592e+061.310592e+06
mean6.110017e-016.731868e+011.917389e+091.780785e+031.342183e+01
std4.875231e-014.093277e+016.613721e+061.028466e+039.154085e+00
min0.000000e+001.000000e+001.897415e+090.000000e+000.000000e+00
25%0.000000e+003.100000e+011.918696e+098.910000e+025.000000e+00
50%1.000000e+006.800000e+011.919401e+091.781000e+031.300000e+01
75%1.000000e+009.900000e+011.920162e+092.670000e+032.100000e+01
max1.000000e+001.390000e+021.920955e+093.563000e+032.900000e+01
\n", - "
" - ], - "text/plain": [ - " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS\n", - "count 1.310592e+06 1.310592e+06 1.310592e+06 1.310592e+06 1.310592e+06\n", - "mean 6.110017e-01 6.731868e+01 1.917389e+09 1.780785e+03 1.342183e+01\n", - "std 4.875231e-01 4.093277e+01 6.613721e+06 1.028466e+03 9.154085e+00\n", - "min 0.000000e+00 1.000000e+00 1.897415e+09 0.000000e+00 0.000000e+00\n", - "25% 0.000000e+00 3.100000e+01 1.918696e+09 8.910000e+02 5.000000e+00\n", - "50% 1.000000e+00 6.800000e+01 1.919401e+09 1.781000e+03 1.300000e+01\n", - "75% 1.000000e+00 9.900000e+01 1.920162e+09 2.670000e+03 2.100000e+01\n", - "max 1.000000e+00 1.390000e+02 1.920955e+09 3.563000e+03 2.900000e+01" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "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", - "file = '../data/Run000260/data_000000.txt'\n", - "run260 = pd.read_csv(file)\n", - "run260.drop('HEAD', inplace=True, axis=1)\n", - "\n", - "print(run260.info())\n", - "display(run260.describe())" + "#
THE DATA: Calibration run 260 / Real Measurement run 333\n", + "[Content Outline](#6)" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "## Set as FALSE for Calibration run \n", + "REAL_DATA = True\n", + "\n", + "# We limit the amount of data we are accepting \n", + "if REAL_DATA:\n", + " mypath = '../data/Run000333/'\n", + "else:\n", + " mypath = '../data/Run000260/'\n", + "\n", + "max_mb = 65 # maximum size of data in mb to read in\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", + "# 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", + "#Let's drop the column named 'HEAD'\n", + "data.drop('HEAD', inplace=True, axis=1) # We remove the 'HEAD', inplace = True because we return nothing\n", + "\n", + "# We print the description\n", + "printmd('## DESCRIPTION OF THE DATA')\n", + "print('Used files:', '\\n', files, '\\n') # To check which files are read\n", + "print(data.info())\n", + "display(data.describe())" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAEICAYAAABswuGIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAbYUlEQVR4nO3df5Bl5V3n8fcnTEgICRAg6SUzrJMsY6IGQdKVRVNmJ0F3ATWwZdglxcrAsjWWYowyq466ZWrdtUrcJTGgG50NEbDID4zGwcC6QaBX3TJoSAgDwYQJzkLLBCT80A7JmnG/+8d9Gi5Nz8ydmX667515v6pu9TnPec7pz+2Zfurb57nnnFQVkiRJWlovWOkAkiRJByOLLEmSpA4ssiRJkjqwyJIkSerAIkuSJKkDiyxJkqQOLLIkSZI6sMjSopLsSPK1JHNDr1clWZukhtp2JNk8tF+S/FiSu5M8neTLSWaSnL/I97gmya4kr9pLliS5PMlX2utXkqTH+5Z0aBmzse4tSW5P8lSSHR3erpaZRZb25Aeq6qVDr4eHth1TVS8F3gH8QpIzW/uVwE8Am4DjgNXAfwDOHD5wkiOBHwSeAi7YS46NwLnAKcC3A98P/PABvTNJeta4jHVfBT4I/NSBviGNB4ssHZCq+jPgXuD1Sb4Z+FHg/Kq6paq+VlX/UFV/WlUXLdj1B4EngV8ENuzl22wArqiq2ar6a+AKYOHxJKmb5RjrqurPq+q3gQeW/h1oJVhkab+10+VvAr4N+CzwVuChqvr0CLtvAD4MfAR4XZLT9tD324DPDa1/rrVJUnfLONbpIGORpT35/SRPttfvL9j2GPA48AFgc1XdChwPfHm4U5LZtv/Xk3xTa/vHwFuAD1XVI8Ct7PkvvJcyONU+7yngpX4uS9ISGZexTgeZVSsdQGPt3Kr6o91sO76qdi1o+wpwwnBDVa1Jsgr4BjBfFP0QcF9V3dXWrweuSPLvq+obi3yvOeCoofWjgLny6eaSlsa4jHU6yHgmS0vpNmBNkum99LsQeE27GufLwHsY/GV41m7638vgQ+/zTmltkrQSeo11OshYZGnJVNUXgN8EPpLke5MckeQw4Lvm+yT5TuCfAG8ETm2v1wMfYven0a8DLkuyul0CvQm4ptsbkaQ96DXWJXlBkhcDLxys5sVJDu/7btST04VaapcC72TwF9tJDK6q+SLwr4EHgc3A1qraNrxTkvcBf5Lk2Kp6fMExfxN4DTC/zwdamyStlB5j3ZuB24fWvwb8L2B9jzeg/uLHWiRJkpae04WSJEkdWGRJkiR1YJElSZLUgUWWJElSB2NxdeHxxx9fa9euHanvV7/6VY488si+gZaQefuatLwweZn3Je+dd975WFW9onOkiXUwj3UweZnN29fBnHfksa6qVvz1hje8oUZ1++23j9x3HJi3r0nLWzV5mfclL/DpGoMxZVxfB/NYVzV5mc3b18Gcd9SxzulCSZKkDiyyJEmSOrDIkiRJ6sAiS5IkqQOLLEmSpA4ssiRJkjqwyJIkSerAIkuSgCSvTXLX0Otvk/xEkmOT3JLk/vb15a1/klyZZHuSu5OcttLvQdJ4sciSJKCqvlBVp1bVqcAbgKeBjwObgVurah1wa1sHOAtY114bgfcvf2pJ42ziiqxtf/0UazfftNIxpIPe2s03Hcq/a2cAX6qq/wOcA1zb2q8Fzm3L5wDXtRtAfwo4JskJSxXAsU6afGPx7EJJGjPnAx9uy1NVtROgqnYmeWVrXw08NLTPbGvbOXygJBsZnOliamqKmZmZkQJMHQGbTt41cv9xMDc3Z96OzNtXj7wWWZI0JMnhwNuAn91b10Xa6nkNVVuALQDT09O1fv36kXJcdf1Wrti2ih0XjNZ/HMzMzDDq+xsH5u3LvBM4XShJnZ0FfKaqHmnrj8xPA7avj7b2WeDEof3WAA8vW0pJY88iS5Ke6x08O1UIcCOwoS1vALYOtV/YrjI8HXhqflpRksDpQkl6RpKXAN8L/PBQ8y8DNyS5BHgQOK+13wycDWxncCXixcsYVdIEsMiSpKaqngaOW9D2FQZXGy7sW8ClyxRN0gRyulCSJKkDiyxJkqQOLLIkSZI6sMiSJEnqwCJLkiSpA4ssSZKkDiyyJEmSOrDIkiRJ6sAiS5IkqQOLLEmSpA4ssiRJkjqwyJIkSepgpCIryU8muTfJPUk+nOTFSV6d5I4k9yf5aJLDW98XtfXtbfvanm9AkiRpHO21yEqyGvhxYLqqXg8cBpwPXA68t6rWAU8Al7RdLgGeqKqTgPe2fpIkSYeUUacLVwFHJFkFvATYCbwV+Fjbfi1wbls+p63Ttp+RJEsTV5IkaTKs2luHqvrrJP8VeBD4GvBJ4E7gyara1brNAqvb8mrgobbvriRPAccBjw0fN8lGYCPA1NQUMzMzIwWeOgI2nbxr5P4rbW5ubmKygnmXw6Rk3nTy4Nd7UvJK0rjZa5GV5OUMzk69GngS+B3grEW61vwue9j2bEPVFmALwPT0dK1fv36kwFddv5Urtq1ixwWj9V9pMzMzjPrexoF5+5uUzBdtvgmAa848ciLyStK4GWW68HuAv6qqv6mqbwC/B3wXcEybPgRYAzzclmeBEwHa9qOBx5c0tSRJ0pgbpch6EDg9yUvaZ6vOAD4P3A68vfXZAGxtyze2ddr226rqeWeyJEmSDmZ7LbKq6g4GH2D/DLCt7bMF+BngsiTbGXzm6uq2y9XAca39MmBzh9ySJEljba+fyQKoqncD717Q/ADwxkX6fh0478CjSZIkTS7v+C5JTZJjknwsyV8muS/JdyY5Nskt7cbLt7SLgcjAle3Gy3cnOW2l80saLxZZkvSs9wF/WFWvA04B7mPwkYdb242Xb+XZj0CcBaxrr43A+5c/rqRxZpElSUCSo4A30z5fWlV/X1VP8twbLC+88fJ1NfApBldcn7DMsSWNsZE+kyVJh4DXAH8D/FaSUxjcdPldwFRV7QSoqp1JXtn6P3Pj5Wb+psw7hw96qNx4GSbvxrXm7cu8FlmSNG8VcBrwzqq6I8n72PPV0d54eYFJudHuPPP2ZV6nCyVp3iww225bA4Nb15wGPDI/Ddi+PjrU/8Sh/YdvyixJFlmSBFBVXwYeSvLa1jR/4+XhGywvvPHyhe0qw9OBp+anFSUJnC6UpGHvBK5PcjiDewFezOCP0RuSXMLgCRjz9wG8GTgb2A483fpK0jMssiSpqaq7gOlFNp2xSN8CLu0eStLEcrpQkiSpA4ssSZKkDiyyJEmSOrDIkiRJ6sAiS5IkqQOLLEmSpA4ssiRJkjqwyJIkSerAIkuSJKkDiyxJkqQOLLIkSZI6sMiSJEnqwCJLkiSpA4ssSZKkDiyyJEmSOrDIkiRJ6sAiS5IkqQOLLEmSpA4ssiRJkjqwyJIkSerAIkuSmiQ7kmxLcleST7e2Y5PckuT+9vXlrT1JrkyyPcndSU5b2fSSxo1FliQ911uq6tSqmm7rm4Fbq2odcGtbBzgLWNdeG4H3L3tSSWPNIkuS9uwc4Nq2fC1w7lD7dTXwKeCYJCesREBJ42nVSgeQpDFSwCeTFPCbVbUFmKqqnQBVtTPJK1vf1cBDQ/vOtradwwdMspHBmS6mpqaYmZkZKcjUEbDp5F0j9x8Hc3Nz5u3IvH31yGuRJUnPelNVPdwKqVuS/OUe+maRtnpew6BQ2wIwPT1d69evHynIVddv5Yptq9hxwWj9x8HMzAyjvr9xYN6+zOt0oSQ9o6oebl8fBT4OvBF4ZH4asH19tHWfBU4c2n0N8PDypZU07iyyJAlIcmSSl80vA/8cuAe4EdjQum0AtrblG4EL21WGpwNPzU8rShI4XShJ86aAjyeBwdj4oar6wyR/AdyQ5BLgQeC81v9m4GxgO/A0cPHyR5Y0zkYqspIcA3wAeD2Dzxz8W+ALwEeBtcAO4F9V1RMZjFDvYzD4PA1cVFWfWfLkkrSEquoB4JRF2r8CnLFIewGXLkM0SRNq1OnC9wF/WFWvYzAI3Yf3jpEkSdqtvRZZSY4C3gxcDVBVf19VT+K9YyRJknZrlOnC1wB/A/xWklOAO4F34b1jRuJ9QvqatLwwOZk3nbwLmJy8kjRuRimyVgGnAe+sqjuSvI9npwYX471jhnifkL4mLS9MTuaLNt8EwDVnHjkReSVp3IzymaxZYLaq7mjrH2NQdHnvGEmSpN3Ya5FVVV8GHkry2tZ0BvB5vHeMJEnSbo16n6x3AtcnORx4gMH9YF6A946RJEla1EhFVlXdBUwvssl7x0iSJC3Cx+pIkiR1YJElSZLUgUWWJElSBxZZkiRJHVhkSZIkdWCRJUmS1IFFliRJUgcWWZIkSR1YZEmSJHVgkSVJktSBRZYkSVIHFlmSJEkdWGRJ0pAkhyX5bJJPtPVXJ7kjyf1JPprk8Nb+ora+vW1fu5K5JY0fiyxJeq53AfcNrV8OvLeq1gFPAJe09kuAJ6rqJOC9rZ8kPcMiS5KaJGuA7wM+0NYDvBX4WOtyLXBuWz6nrdO2n9H6SxIAq1Y6gCSNkV8Ffhp4WVs/Dniyqna19VlgdVteDTwEUFW7kjzV+j82fMAkG4GNAFNTU8zMzIwUZOoI2HTyrpH7j4O5uTnzdmTevnrktciSJCDJ9wOPVtWdSdbPNy/StUbY9mxD1RZgC8D09HStX79+YZdFXXX9Vq7YtoodF4zWfxzMzMww6vsbB+bty7wWWZI0703A25KcDbwYOIrBma1jkqxqZ7PWAA+3/rPAicBsklXA0cDjyx9b0rjyM1mSBFTVz1bVmqpaC5wP3FZVFwC3A29v3TYAW9vyjW2dtv22qnremSxJhy6LLEnas58BLkuyncFnrq5u7VcDx7X2y4DNK5RP0phyulCSFqiqGWCmLT8AvHGRPl8HzlvWYJImimeyJEmSOrDIkiRJ6sAiS5IkqQOLLEmSpA4ssiRJkjqwyJIkSerAIkuSJKkDiyxJkqQOLLIkSZI6sMiSJEnqwCJLkiSpA4ssSZKkDiyyJEmSOrDIkiRJ6sAiS5IkqQOLLEmSpA5GLrKSHJbks0k+0dZfneSOJPcn+WiSw1v7i9r69rZ9bZ/okiRJ42tfzmS9C7hvaP1y4L1VtQ54AriktV8CPFFVJwHvbf0kSZIOKSMVWUnWAN8HfKCtB3gr8LHW5Vrg3LZ8TlunbT+j9ZckSTpkrBqx368CPw28rK0fBzxZVbva+iywui2vBh4CqKpdSZ5q/R8bPmCSjcBGgKmpKWZmZkYKMnUEbDp518j9V9rc3NzEZAXzLodJybzp5MGv96TklaRxs9ciK8n3A49W1Z1J1s83L9K1Rtj2bEPVFmALwPT0dK1fv35hl0Vddf1Wrti2ih0XjNZ/pc3MzDDqexsH5u1vUjJftPkmAK4588iJyCtJ42aU6cI3AW9LsgP4CINpwl8FjkkyX6StAR5uy7PAiQBt+9HA40uYWZKWXJIXJ/nzJJ9Lcm+S/9javchH0n7Za5FVVT9bVWuqai1wPnBbVV0A3A68vXXbAGxtyze2ddr226rqeWeyJGnM/F/grVV1CnAqcGaS0/EiH0n76UDuk/UzwGVJtjP4zNXVrf1q4LjWfhmw+cAiSlJ/NTDXVl/YXoUX+UjaT6N+8B2AqpoBZtryA8AbF+nzdeC8JcgmScsqyWHAncBJwK8DX8KLfEY2aRdJmLcv8+5jkSVJB7Oq+gfg1CTHAB8HvmWxbu2rF/ksMCkXdcwzb1/m9bE6kvQ8VfUkg7P2p+NFPpL2k0WWJAFJXtHOYJHkCOB7GDzlwot8JO0XpwslaeAE4Nr2uawXADdU1SeSfB74SJL/DHyW517k89vtIp/HGVx9LUnPsMiSJKCq7ga+Y5F2L/KRtF+cLpQkSerAIkuSJKkDiyxJkqQOLLIkSZI6sMiSJEnqwCJLkiSpA4ssSZKkDiyyJEmSOrDIkiRJ6sAiS5IkqQOLLEmSpA4ssiRJkjqwyJIkSerAIkuSJKkDiyxJkqQOLLIkSZI6sMiSJEnqwCJLkiSpA4ssSZKkDiyyJEmSOrDIkiQgyYlJbk9yX5J7k7yrtR+b5JYk97evL2/tSXJlku1J7k5y2sq+A0njxiJLkgZ2AZuq6luA04FLk3wrsBm4tarWAbe2dYCzgHXttRF4//JHljTOLLIkCaiqnVX1mbb8d8B9wGrgHODa1u1a4Ny2fA5wXQ18CjgmyQnLHFvSGFu10gEkadwkWQt8B3AHMFVVO2FQiCV5Zeu2GnhoaLfZ1rZzwbE2MjjTxdTUFDMzMyNlmDoCNp28a+T+42Bubs68HZm3rx55LbIkaUiSlwK/C/xEVf1tkt12XaStntdQtQXYAjA9PV3r168fKcdV12/lim2r2HHBaP3HwczMDKO+v3Fg3r7M63ShJD0jyQsZFFjXV9XvteZH5qcB29dHW/sscOLQ7muAh5crq6TxZ5ElSQyuFgSuBu6rqvcMbboR2NCWNwBbh9ovbFcZng48NT+tKEngdKEkzXsT8EPAtiR3tbafA34ZuCHJJcCDwHlt283A2cB24Gng4uWNK2ncWWRJElBVf8rin7MCOGOR/gVc2jWUpInmdKEkSVIHFlmSJEkdWGRJkiR1sNciy+d5SZIk7btRzmT5PC9JkqR9tNciy+d5SZIk7bt9+kzWnp7nBezteV6SJEmHjJHvk7XUz/M6VB6a6gMy+5q0vDA5mTedvAuYnLySNG5GKrL29Dyv9lT6fX6e16Hy0FQfkNnXpOWFycl80eabALjmzCMnIq8kjZtRri70eV6SJEn7aJQzWT7PS5IkaR/ttcjyeV6SJEn7zju+S5IkdWCRJUmS1IFFliRJUgcWWZIkSR1YZEmSJHVgkSVJktSBRZYkSVIHFlmSJEkdWGRJUpPkg0keTXLPUNuxSW5Jcn/7+vLWniRXJtme5O4kp61ccknjyCJLkp51DXDmgrbNwK1VtQ64ta0DnAWsa6+NwPuXKaOkCWGRJUlNVf0x8PiC5nOAa9vytcC5Q+3X1cCngGOSnLA8SSVNglEeEC1Jh7KpqtoJUFU7k7yyta8GHhrqN9vadg7vnGQjgzNdTE1NMTMzM9o3PQI2nbxr5P7jYG5uzrwdmbevHnktsiRp/2SRtnpeQ9UWYAvA9PR0rV+/fqSDX3X9Vq7YtoodF4zWfxzMzMww6vsbB+bty7xOF0rS3jwyPw3Yvj7a2meBE4f6rQEeXuZsksaYRZYk7dmNwIa2vAHYOtR+YbvK8HTgqflpRUkCpwsl6RlJPgysB45PMgu8G/hl4IYklwAPAue17jcDZwPbgaeBi5c9sKSxZpElSU1VvWM3m85YpG8Bl/ZNJGmSOV0oSZLUgUWWJElSBxZZkiRJHVhkSZIkdWCRJUmS1IFFliRJUgcWWZIkSR1YZEmSJHVgkSVJktSBRZYkSVIHFlmSJEkdWGRJkiR1YJElSZLUgUWWJElSBxZZkiRJHVhkSZIkdWCRJUmS1IFFliRJUgcWWZIkSR1YZEmSJHVgkSVJktRBlyIryZlJvpBke5LNPb6HJI0DxztJu7PkRVaSw4BfB84CvhV4R5JvXervI0krzfFO0p70OJP1RmB7VT1QVX8PfAQ4p8P3kaSV5ngnabdWdTjmauChofVZ4J8u7JRkI7Cxrc4l+cKIxz8eeCyXH1DG5XQ88NhKh9gH5u1vojK/5fJ9yvtNPbOMob2Od4fQWAcT9n8b8/Z2MOcdaazrUWRlkbZ6XkPVFmDLPh88+XRVTe9PsJVg3r4mLS9MXuZJy7vM9jreHSpjHUxeZvP2Zd4+04WzwIlD62uAhzt8H0laaY53knarR5H1F8C6JK9OcjhwPnBjh+8jSSvN8U7Sbi35dGFV7UryY8D/BA4DPlhV9y7ht9jn0+4rzLx9TVpemLzMk5Z32XQe7ybx5z5pmc3b1yGfN1XP+7iUJEmSDpB3fJckSerAIkuSJKmDFS2yknwwyaNJ7hlq+09J7k5yV5JPJnlVa/+p1nZXknuS/EOSYxc55quT3JHk/iQfbR9GHee817dHctzTjv/Ccc47dJyrkswtVdZeeTPwS0m+mOS+JD8+5nnPSPKZ1u9Pk5y0VHn3I/PRSf4gyeeS3Jvk4t0c8w1JtmXwWJkrkyx2W4NDmmNd37GuV+ah4zjeTdh4NzZjXVWt2At4M3AacM9Q21FDyz8O/MYi+/0AcNtujnkDcH5b/g3gR8Y879kM7rUT4MPjnrdtnwZ+G5ibgP8PFwPXAS9o668c87xfBL6lLf8ocM1K/YyBnwMub8uvAB4HDl/kmH8OfGf7P/w/gLOWMvPB8HKs6zvW9crctjve9cvbbbwbl7FuRc9kVdUfM3gzw21/O7R6JIvcyBR4B4Nf0udoVeVbgY+1pmuBc5ckLEuft+1/czUM/gHXLFHcLnkzeFbbfwF+eoliDmdb8rzAjwC/WFX/rx3v0SWIOp+tR94CjmrLR7PE91zax8wFvKz9Xr207bdreN8kJzAYuP6s/R++jiX8nTtYONb1Heva8R3vHO+Gs43HWLdUVeMBVJtrGao0W9svMXhUxT3AKxZse0n7ARy7yLGOZ/Acsfn1Excee5zyLuj3QuAzwHePc17gXcBPtuUl/cuuU96vAD8PfJrBXx7rxjzvd7fMs8DnGfrLa7kzAy8Dbgd2AnPA9y1yrGngjxbk/8RSZz4YXo51z/TrMtb1yOx41z1v1/FuHMa6sfzge1X9fFWdCFwP/NiCzT8A/O+qevz5e472SJ+ldgB5h/034I+r6k96ZBy2v3nb/PV5wFW9Mw47wJ/vi4Cv1+BRCf8d+GC/pAMHmPcngbOrag3wW8B7+iV91m4y/wvgLuBVwKnAryU5asGuK/I7d7BwrOvP8a6vSRvvlnusG8sia8iHgB9c0HY+uz/1+BhwTJL5m6wu9yMu9jUvAEnezWAe+LJOuXZnX/N+B3ASsD3JDuAlSbb3i/c8+/PznQV+ty1/HPj2Drl2Z5/yJnkFcEpV3dGaPgp8V794ixrOfDHwezWwHfgr4HUL+s/y3GkfHyuzfxzr+nO862vSxrtlGevGrshKsm5o9W3AXw5tOxr4Z8DWxfatwTm824G3t6YNu+u7VA4kb+vz7xhU0e+oNo/e0wH+fG+qqn9UVWurai3wdFUt6dVvS5m3+X0Gn12h9f3iUmccdoB5nwCOTvLNbf17gft65By2h8wPAme0PlPAa4EHhvetqp3A3yU5vX2e4UI6/84dLBzr+nO8c7wbtiJj3VLOf+7HfOmHGcyBfoNBlXgJgyr8HuBu4A+A1UP9LwI+sshxbgZe1ZZfw+BDlduB3wFeNOZ5dwFfYnCq8i7gF8Y574L2pb7apsfP9xjgJmAb8GcM/nIa57z/smX9HDADvGalfsYMTp1/suW5B/g3Q8e5a2h5um3/EvBrtCdJ+Or+f8WxrnPmBe2OdxM03u1LXjqOdT5WR5IkqYOxmy6UJEk6GFhkSZIkdWCRJUmS1IFFliRJUgcWWZIkSR1YZEmSJHVgkSVJktTB/we+tGv5MJfifQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], + "source": [ + "#Visualization of the first 5 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": null, + "metadata": { + "scrolled": true + }, + "outputs": [], "source": [ "fig, (ax1,ax2) = plt.subplots(1,2,figsize=(10,4))\n", "\n", - "df_0 = run260[run260['FPGA']==0]\n", - "df_1 = run260[run260['FPGA']==1]\n", + "df_0 = data[data['FPGA']==0]\n", + "df_1 = data[data['FPGA']==1]\n", "\n", - "max_channel = run260['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", + "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", - "plt.show()" + "printmd('## HISTOGRAM OF HITS PER CHANNEL')\n", + "plt.show()\n", + "printmd('#### There are a lot of hits falling under the mean time trigger')\n", + "# Remark: There is a lot of data in the trigger" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "#
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": 45, + "execution_count": null, + "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)\n", + "\n", + "# We set the detector column to display -1 for trigger and detector number\n", + "data['detector'] = -1" + ] + }, + { + "cell_type": "markdown", "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": [ - "from numba import vectorize, int64, jit, njit\n", - "# run260['time'] = run260['ORBIT_CNT']*2564*25 + run260['BX_COUNTER']*25 + run260['TDC_MEAS']*25/30\n", - "run260['time'] = run260['BX_COUNTER']*25 + run260['TDC_MEAS']*25/30\n", - "\n", - "# Scintillator trigger channel 1 & 2\n", - "st1 = 137\n", - "st2 = 138\n", - "# Mean-time trigger channel\n", - "mtt = 139\n", - "# params\n", - "T_M = 390 # ms\n", - "L = 42 # mm\n", - "v_d = L/(2*T_M)\n", - "\n", - "# Detector column displays -1 for trigger and detector number else\n", - "run260['detector'] = -1\n", - "run260.loc[run260['TDC_CHANNEL']<=128,'detector'] = run260['FPGA']*2+1 + run260['TDC_CHANNEL']//64\n", - "# add layer column\n", + " ## TIME COLUMN\n", + " \n", + " Let's add a column to the existing data.\n", + "\n", + "This new column will be the time measurements(ns). The time measurement in nanoseconds is given by:\n", + "\n", + "```python\n", + " data['time']=data['ORBIT_CNT']*2564*25+data['BX_COUNTER']*25+data['TDC_MEAS']*25/30\n", + "```\n", + " \n", + "Now, the rate of passage of particles through the detector was rather limited, i.e. the chance to get two particle within the same orbit is extremely small. Therefore we can drop the orbit part of the formula yields" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data['time'] = data['BX_COUNTER']*25 + data['TDC_MEAS']*25/30\n", + "\n", + "# We have added a new time column to the data. The first 5 rows are\n", + "data.head(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The actual time taken by the ionization to reach the anodic wire (drift time) is proportional to the distance:\n", + "\n", + "$$\n", + "x = v_d t_i= v_d(t_R-t_0)\n", + "$$\n", + "\n", + "where $v_d$ is the constant drift velocity, $t_R$ is the time recorded by the electronics and $t_0$ is a time pedestal which needs to be determined for every particles crossing the detector (the drift time is $t_R-t_0$). This is possible thanks to the geometry of the layers, more precisely by the fact that they are staggered by exactly half a cell. \n", + "\n", + "To compute the constant $t_0$, which is different for every event, we can use the following relation:\n", + "\n", + "$$T_{MAX}=\\frac{t_{1}+t_{3}}{2}+t_{2}$$\n", + "\n", + "where $t_1 = t_{1'}-t_0$, $t_2 = t_{2'}-t_0$ and $t_3 = t_{3'}-t_0$, are the drift times of those three cells and $t_{i'}$ is the time measurement of the respective cell. The drift times can be calculated in this way because $t_0$ is essentially the same for each cell in one event, because the particle velocity of the muons(?) is much higher than the drift velocity of the electrons. Then the relation becomes:\n", + "\n", + "$$T_{MAX}=\\frac{t_{1'}-t_0+t_{3'}-t_0}{2}+t_{2'}-t_0$$\n", + "\n", + "from which we get:\n", + "\n", + "$$t_0=\\frac{t_{1'}+t_{3'}+2t_{2'}-2T_{MAX}}{4}$$\n", + "\n", + "Finally we notice that $t_{1'}$, $t_{2'}$, $t_{3'}$ are the times recorded by each cell, which are already available in our dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## DETECTOR, LAYER, AND CELL COLUMNS\n", + "\n", + "Before processing the dataset, we have to create some missing columns, in fact the DataFrame with the events must contain the following information:\n", + "* CHAMBER, which is the Detector number. The data to be analyzed have been gathered by a series of (4) particle detectors: [1-4]\n", + "* LAYER. Such detectors were composed by four layers of cells: [1-4];\n", + "* CELL, which is in the number of the cell. The actual detector has 16 cells per layer: [1-16]\n", + "* POSTION, which is the position where a particle traverses the cell [0-21] (in mm. The maximum 21 mm value corresponds to the position of the anodic wire to where the particles travel. In this case the left-right ambiguity is NOT resolved). \n", + "\n", + "\n", + "\n", + "![(Picture of detector configuration)](./Detector.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The channels are mapped to the four detectors in the following ways:\n", + "\n", + "* Detector 1 $\\rightarrow$ FPGA 0, TDC_CHANNEL in [1-64]\n", + "* Detector 2 $\\rightarrow$ FPGA 0, TDC_CHANNEL in [65-128]\n", + "* Detector 3 $\\rightarrow$ FPGA 1, TDC_CHANNEL in [1-64]\n", + "* Detector 4 $\\rightarrow$ FPGA 1, TDC_CHANNEL in [65-128]\n", + "\n", + "Notice that since we have 4 layers with 16 cells per layes, each detector will have 64 cells. Therefore, we can assume that the TDC_CHANNEL is a label for all the cells in the chamber.\n", + "\n", + "Even though not used as such, an external trigger was present anyway. When it fired a special 64 bit word (a row in the csv file) were produced enconding the trigger information, i.e. the timing at which it occurred and which of the kind of trigger fired. More precisely:\n", + "\n", + "* Mean-time trigger: TDC_CHANNEL=139\n", + "* Scintillator trigger: TDC_CHANNEL=137 or 138" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# adding detector, layer and cell columns \n", + "\n", "@vectorize([int64(int64, int64)])\n", "def giveDetector(fpga, channel):\n", " if channel > 128:\n", @@ -254,1063 +325,489 @@ "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))))\n" + " print(list(zip(giveDetector(0,a), giveLayer(a), giveCell(a))))" ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# Calculation of detector, layer & cell 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", + "display(data.head(5))" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEAStimedetectorlayercell
01116189741488415332438345.0000004113
1171189741488716502141267.500000432
21671897414914980824506.666667431
317018974149221287832181.666667422
4057189741492221622254068.3333331415
\n", - "
" - ], - "text/plain": [ - " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS time \\\n", - "0 1 116 1897414884 1533 24 38345.000000 \n", - "1 1 71 1897414887 1650 21 41267.500000 \n", - "2 1 67 1897414914 980 8 24506.666667 \n", - "3 1 70 1897414922 1287 8 32181.666667 \n", - "4 0 57 1897414922 2162 22 54068.333333 \n", - "\n", - " detector layer cell \n", - "0 4 1 13 \n", - "1 4 3 2 \n", - "2 4 3 1 \n", - "3 4 2 2 \n", - "4 1 4 15 " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ - "# run260.groupby('ORBIT_CNT')\n", - "run260['detector'] = giveDetector(run260['FPGA'], run260['TDC_CHANNEL'])\n", - "run260['layer'] = giveLayer(run260['TDC_CHANNEL'])\n", - "run260['cell'] = giveCell(run260['TDC_CHANNEL'])\n", - "# display(run260[run260['TDC_CHANNEL']==st1].head())\n", - "# display(run260[run260['TDC_CHANNEL']==st2].head())\n", - "display(run260.head(5))" + "***\n", + "#
FINDING EVENTS \n", + " [Content Outline](#6)" ] }, { - "cell_type": "code", - "execution_count": 36, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEAStimedetectorlayercell
8013918974149342028050700.0-1-1-1
72013918974153012812070300.0-1-1-1
87113918974154251335033375.0-1-1-1
115113918974155441234030850.0-1-1-1
140113918974156741198029950.0-1-1-1
\n", - "
" - ], - "text/plain": [ - " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS time detector \\\n", - "8 0 139 1897414934 2028 0 50700.0 -1 \n", - "72 0 139 1897415301 2812 0 70300.0 -1 \n", - "87 1 139 1897415425 1335 0 33375.0 -1 \n", - "115 1 139 1897415544 1234 0 30850.0 -1 \n", - "140 1 139 1897415674 1198 0 29950.0 -1 \n", - "\n", - " layer cell \n", - "8 -1 -1 \n", - "72 -1 -1 \n", - "87 -1 -1 \n", - "115 -1 -1 \n", - "140 -1 -1 " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ORBIT_CNTtime
8189741493450700.0
72189741530170300.0
87189741542533375.0
115189741554430850.0
140189741567429950.0
\n", - "
" - ], - "text/plain": [ - " ORBIT_CNT time\n", - "8 1897414934 50700.0\n", - "72 1897415301 70300.0\n", - "87 1897415425 33375.0\n", - "115 1897415544 30850.0\n", - "140 1897415674 29950.0" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ORBIT_CNTtime
24235189753750726853.333333
24238189753750726857.500000
24239189753750726850.833333
24241189753750726860.000000
24448719185055051525.833333
\n", - "
" - ], - "text/plain": [ - " ORBIT_CNT time\n", - "24235 1897537507 26853.333333\n", - "24238 1897537507 26857.500000\n", - "24239 1897537507 26850.833333\n", - "24241 1897537507 26860.000000\n", - "244487 1918505505 1525.833333" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ - "trigger_mtt = run260.loc[run260['TDC_CHANNEL']==mtt, ['ORBIT_CNT','time']]\n", - "display(run260.loc[run260['TDC_CHANNEL']==mtt].head())\n", - "trigger_st = run260.loc[(run260['TDC_CHANNEL']==st1) | (run260['TDC_CHANNEL']==st2), ['ORBIT_CNT','time']]\n", - "trigger_st1 = run260.loc[run260['TDC_CHANNEL']==st1, ['ORBIT_CNT','time']]\n", - "display(trigger_mtt.head())\n", - "display(trigger_st.head())" + "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": 142, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "events = run260.loc[run260['ORBIT_CNT'].isin(trigger_mtt['ORBIT_CNT'])]\n", - "events = events[events['TDC_CHANNEL'] <= 128]\n", - "# events['trigger_time'] = trigger_mtt['time'].reindex(events.index, method='backfill')\n", - "changes = (events['ORBIT_CNT'].diff() != 0).cumsum()\n", - "events.set_index([changes.to_numpy(), events.index], inplace=True)\n", - "# events['trigger_time'] = trigger_mtt['time']\n", - "events.rename_axis(('event','index'), inplace=True)\n", - "events.sort_values(['event','detector','layer','cell'], inplace=True)\n", - "events.drop(['FPGA','TDC_CHANNEL','ORBIT_CNT','BX_COUNTER','TDC_MEAS'], inplace=True, axis=1)\n", - "\n", - "# display(events.loc[55])" + "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", + "\n", + "display(trigger_mtt.head())\n", + "if not trigger_st.empty:\n", + " display(trigger_st.head())" ] }, { - "cell_type": "code", - "execution_count": 124, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
timedetectorlayercell
index
550360.833333116
650366.666667127
750660.833333127
1050609.166667137
1150657.500000148
950661.666667149
\n", - "
" - ], - "text/plain": [ - " time detector layer cell\n", - "index \n", - "5 50360.833333 1 1 6\n", - "6 50366.666667 1 2 7\n", - "7 50660.833333 1 2 7\n", - "10 50609.166667 1 3 7\n", - "11 50657.500000 1 4 8\n", - "9 50661.666667 1 4 9" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ - "first_event = events.loc[1].copy()\n", + "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": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "#.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", - "display(first_event)\n", - "# first_event['cell'] = [1,1,1,1]\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", - "def plot_event(event):\n", - " detector_m = np.zeros((4,16*2+1))\n", + " # We now group by orbit\n", + " events['event'] = events.groupby('ORBIT_CNT').ngroup()+1\n", "\n", - " fig, ax = plt.subplots(figsize=(9,2))\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", - " even_layers = first_event['layer']%2 == 0\n", - " odd_layers = even_layers == False\n", + " printmd('## EVENTS DATAFRAME')\n", + " display(events.head(4))\n", + " \n", + " return events\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", + "events_mtt = create_events(events_mtt)\n", + "display(events_mtt.head(5))\n", + "if not trigger_st.empty:\n", + " events_st = create_events(events_st)\n", + " display(events_st.head(5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "#
FINDING THE TRAJECTORIES, computing t0\n", + " [Content Outline](#6)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def findTrajectories(df):\n", + " data = df.copy(deep=False)\n", + " data['t0_1'] = 0\n", + " data['t0_2'] = 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", + " sub_ev.loc[na_mask,'t0_1'] = 0.5*(0.5*(sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==1).index, 't0_1'].iloc[0]+\n", + " sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==3).index, 't0_1'].iloc[0])+\n", + " sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==2).index, 't0_1'].iloc[0])\n", + " sub_ev.loc[na_mask, 't0_2'] = 0.5*(0.5*(sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==2).index, 't0_1'].iloc[0]+\n", + " sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==4).index, 't0_1'].iloc[0])+\n", + " sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==3).index, 't0_1'].iloc[0])\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", - " fillDetectorMatrix(detector_m, first_event.loc[even_layers,'layer']-1,\n", - " first_event.loc[even_layers,'cell']-1, s=0)\n", - " fillDetectorMatrix(detector_m, first_event.loc[odd_layers,'layer']-1,\n", - " first_event.loc[odd_layers,'cell']-1, s=1)\n", "\n", - " detector_m[(0,1,2,3),(0,32,0,32)] = 0.5 # Mark \"cell offset\"\n", + "@njit\n", + "def findTrajectories_np(data, inds, columns): # data, index, 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 # use old version???\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", - " ax.matshow(detector_m, origin='lower', cmap='bone')\n", - " ax.scatter((first_event.loc[even_layers, 'cell']-1)*2+0.5,\n", - " first_event.loc[even_layers, 'layer']-1, s=10, c='r', marker='+')\n", - " ax.scatter((first_event.loc[odd_layers, 'cell']-1)*2+1.5,\n", - " first_event.loc[odd_layers, 'layer']-1, s=10, c='r', marker='+')\n", + " for i in range(len(ev_locs)-1):\n", + " \n", + " ev = data[ev_locs[i]:ev_locs[i+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", + " # 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 successor was found\n", + " # if one cell was found with no successor\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", + " sub_ev[mask,t0_1_ind] = 0.5*(0.5*(sub_ev[sub_ev[mask,lay_ind]==1,time_ind][0]+\n", + " sub_ev[sub_ev[mask,lay_ind]==3,time_ind][0])+\n", + " sub_ev[sub_ev[mask,lay_ind]==2,time_ind][0]-T_M)\n", + " sub_ev[mask,t0_2_ind] = 0.5*(0.5*(sub_ev[sub_ev[mask,lay_ind]==2,time_ind][0]+\n", + " sub_ev[sub_ev[mask,lay_ind]==4,time_ind][0])+\n", + " sub_ev[sub_ev[mask,lay_ind]==3,time_ind][0]-T_M)\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", + " return data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_t0(df, numba_optimized=True):\n", + " events = df.copy(deep=False)\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", + " if not numba_optimized:\n", + " events = findTrajectories(events)\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", - " plt.plot([c*2+0.5,c*2+0.5], vert_line+l-0.5, c='w')\n", - " else:\n", - " plt.plot([c*2+1.5,c*2+1.5], vert_line+l-0.5, c='w')\n", + " else:\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", - " plt.show()\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", - "plot_event(first_event)" + "events_mtt = calculate_t0(events_mtt)\n", + "display(events_mtt.head(5))\n", + "if not trigger_st.empty:\n", + " events_st = calculate_t0(events_st)\n", + " display(events_st.head(5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "#
'VISUALIZING' THE EVENTS\n", + " [Content Outline](#6)\n", + "## CALCULATION OF DRIFT TIMES " ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "first_event = events.loc[2].copy()\n", - "# first_event['time'] = first_event['time'] - first_event['time'].iloc[0]\n", - "# first_event['x'] = v_d * first_event['time']\n", - "# display(first_event)\n", - "# display(events.loc[1])\n", - "detector_m = np.zeros((4,16))\n", + "def make_hist(df):\n", + " events = df.copy(deep=False)\n", "\n", - "fig, ax = plt.subplots()\n", + " events['drift_time'] = events['time'] - events['t0_123'] # use one t0???\n", + " events['x'] = v_d*events['drift_time']\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_123'] = np.nan\n", "\n", - "detector_m[first_event['layer']-1, first_event['cell']-1] = 1\n", - "# detector_m[first_event['layer']-1, first_event['cell']-1] = 1\n", - "ax.matshow(detector_m, origin='lower', cmap='magma')\n", - "ax.xaxis.set_ticks_position('bottom')\n", - "ax.scatter(first_event['cell']-1, first_event['layer']-1, 1, marker='+')\n", + " events.loc[events['t0_123'].notna(),'drift_time'].plot(kind='hist', title='Distribution of Drift Times',\n", + " bins=100) # driftime instead of x???\n", "\n", - "# Major ticks\n", - "ax.set_xticks(np.arange(0, 16, 1));\n", - "ax.set_yticks(np.arange(0, 4, 1));\n", + " plt.xlabel('Drift time (ns)')\n", + " plt.ylabel('Number of Occurrences')\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", + " plt.show()\n", "\n", - "# Minor ticks\n", - "ax.set_xticks(np.arange(-.5, 15, 1), minor=True);\n", - "ax.set_yticks(np.arange(-.5, 3, 1), minor=True);\n", + " printmd('#### Remark: the maximum amount of occurences happen around 10 mm from the anodic wire.')\n", + " \n", + " return events\n", "\n", - "ax.grid(which='minor', axis='both', color='w', linewidth=1)\n", "\n", - "plt.show()" + "display(events_mtt.head(5))\n", + "events_mtt = make_hist(events_mtt)\n", + "if not trigger_st.empty:\n", + " events_st = make_hist(events_st)\n", + " display(events_st.head(5))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Get $t_0$\n", + "## FILTERING THE DATA \n", "\n", - "$$T_{Max} = \\frac{(t'_1-t_0)+(t'_3-t_0)}{2}+(t'_2-t_0)$$" + "### Useful events: showing the percentage of events that have more than 3 hits?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def print_useful_events(df):\n", + " events = df.copy(deep=False)\n", + "\n", + " # Ratio of \"useful events\" to all events\n", + " try:\n", + " print('\"useful rows\" / \"all rows\": ', 1 - len(events[events['t0_123'].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_123'].isna(),'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", + "\n", + "print('Mean Time Trigger:')\n", + "print_useful_events(events_mtt)\n", + "if not trigger_st.empty:\n", + " print('Scintillator Trigger')\n", + " print_useful_events(events_st)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "$$t_0 = \\frac{1}{2}\\left(\\frac{t'_1+t'_3}{2}+t'_2-T_{Max}\\right)$$" + "### Filter 2: Drop hits that do not align\n", + "### Filter 3: Obtain events that have at least one hit per layer (i.e. 4 layer representation)\n", + "### Filter 4: Sort OUT events that have only ONE detector representation" ] }, { "cell_type": "code", - "execution_count": 137, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
timedetectorlayercellflag
eventindex
1550360.8333331.01.06.00.0
650366.6666671.02.07.00.0
750660.8333331.02.07.00.0
1050609.1666671.03.07.00.0
1150657.5000001.04.08.00.0
950661.6666671.04.09.01.0
27370270.0000002.01.06.00.0
7070072.5000002.02.06.00.0
7169957.5000002.03.06.00.0
7470197.5000002.04.07.00.0
\n", - "
" - ], - "text/plain": [ - " time detector layer cell flag\n", - "event index \n", - "1 5 50360.833333 1.0 1.0 6.0 0.0\n", - " 6 50366.666667 1.0 2.0 7.0 0.0\n", - " 7 50660.833333 1.0 2.0 7.0 0.0\n", - " 10 50609.166667 1.0 3.0 7.0 0.0\n", - " 11 50657.500000 1.0 4.0 8.0 0.0\n", - " 9 50661.666667 1.0 4.0 9.0 1.0\n", - "2 73 70270.000000 2.0 1.0 6.0 0.0\n", - " 70 70072.500000 2.0 2.0 6.0 0.0\n", - " 71 69957.500000 2.0 3.0 6.0 0.0\n", - " 74 70197.500000 2.0 4.0 7.0 0.0" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[False True True False False True False]\n" - ] - } - ], + "outputs": [], "source": [ - "display(events.head(10))\n", + "def prepare_for_vis(df):\n", + " # Drop all not aligning hits\n", + " visual_evs = df.dropna(subset=['t0_123']).copy() # subset = array which limits the dropping process to passed rows/columns through list.\n", + "\n", + " # Sort out events which are not in every layer, each event must have 4 layers\n", + " go_through_each_lay = visual_evs.loc[:,'layer'].groupby(level=0).nunique() == 4\n", + "\n", + " # Sort out events which are only registered in one 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", + " # Sort out events which are only registered in one detector\n", + " multiple_detectors = visual_evs.loc[:,'detector'].groupby('event').nunique() > 1\n", + " # Combine the two masks\n", + " index_mask = go_through_each_lay & multiple_detectors\n", + "\n", + " # Apply it to 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", - "def findTrajectories(df):\n", - " for i in events.index.get_level_values(0).unique():\n", - " if events.loc[i,'detector'].nunique() != 1:\n", - " events.drop(i, inplace=True)\n", - " continue\n", - "\n", - " for l in range(1,4):\n", - " fst_layer = events.loc[(i, events['layer'] == l), 'cell']\n", - " sec_layer = events.loc[(i, events['layer'] == l+1), 'cell']\n", - "\n", - " # Find predecessor for each cell in layer\n", - " if l % 2 == 0:\n", - " predecessor_mask = sec_layer.isin(fst_layer) | sec_layer.isin(fst_layer-1) # change if drawing not wrong???\n", - " else:\n", - " predecessor_mask = sec_layer.isin(fst_layer) | sec_layer.isin(fst_layer+1)\n", "\n", - " idx = predecessor_mask[predecessor_mask == False].index\n", + "events_mtt_vis = prepare_for_vis(events_mtt)\n", + "display(events_mtt_vis.head(4))\n", + "if not trigger_st.empty:\n", + " events_st_vis = prepare_for_vis(events_st)\n", + " display(events_st_vis.head(4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##
MAKING THE DETECTOR MATRIX \n", + " [Content Outline](#6)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "printmd(\"### Event Data\")\n", + "def plotDetector(ax, event, is_empty):\n", + " detector = np.zeros((4,16*2+1))\n", "\n", - " # Drop rows where no predecessor was found\n", - " events.drop(idx, inplace=True)\n", + " even_layers = event['layer']%2 == 0\n", + " odd_layers = even_layers == False\n", "\n", - " # Drop whole event if the current layer is completely empty\n", - " if len(idx) == len(sec_layer):\n", - " events.drop(i, inplace=True)\n", - " break\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", - "@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", + " 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", - "print(myIsin(np.array([1,2,2,3,4,5,0]), np.array([2,5])))\n", + " plotLeftRight(ax, event.loc[layers, 'cell'], event.loc[layers, 'x'],\n", + " event.loc[layers, 'layer'], odd, left)\n", "\n", - "@njit\n", - "def findTrajectories_np(data, inds):\n", - " event_locs = np.where(level0_inds-np.roll(level0_inds,1) !=0)[0]\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", - " for i in range(len(event_locs)-1):\n", - " \n", - " ev = data[event_locs[i]:event_locs[i+1]]\n", + " # Major ticks\n", + " ax.set_xticks(np.arange(1.5, 32, 2));\n", + " ax.set_yticks(np.arange(0, 4, 1));\n", "\n", - " # Every row registered in same detector?\n", - " if np.unique(ev[:,1]).size != 1:\n", - " ev[:,4] = 1\n", - " continue\n", - "\n", - " for l in range(1,4):\n", - " fst_layer = ev[ev[:,2]==l,3]\n", - " sec_layer = ev[ev[:,2]==l+1,3]\n", - "\n", - " # Find predecessor for each cell in layer\n", - " if l % 2 == 0:\n", - "# predecessor_mask = np.array([item in fst_layer for item in sec_layer]) | np.array([item in fst_layer-1 for item in sec_layer])\n", - "# predecessor_mask = np.isin(sec_layer, fst_layer) | np.isin(sec_layer, fst_layer-1) # change if drawing not wrong???\n", - " predecessor_mask = myIsin(sec_layer, fst_layer) | myIsin(sec_layer, fst_layer-1)\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", - "# predecessor_mask = np.array([item in fst_layer for item in sec_layer]) | np.array([item in (fst_layer+1) for item in sec_layer])\n", - "# predecessor_mask = np.isin(sec_layer, fst_layer) | np.isin(sec_layer, fst_layer+1)\n", - " predecessor_mask = myIsin(sec_layer, fst_layer) | myIsin(sec_layer, fst_layer+1)\n", + " ax.plot([c*2+1.5,c*2+1.5], vert_line+l-0.5, c='w')\n", "\n", - " # Drop whole event if the current layer is completely empty\n", - " if np.any(predecessor_mask) == False:\n", - " ev[:,4] = 1\n", - " break\n", + "def plotEvent(event):\n", + " fig, axes = plt.subplots(2, 2, figsize=(12,4))\n", "\n", - " # Else mark rows where no predecessor was found\n", - " # False has to be np.array([False]) so that numba broadcasts\n", - " elif np.all(predecessor_mask) == False:\n", - " idx = np.nonzero(predecessor_mask==np.array([False]))[0] + np.nonzero(ev[:,2]==l+1)[0][0]\n", - " ev[idx,4] = 1\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", - " return data" - ] - }, - { - "cell_type": "code", - "execution_count": 146, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
timedetectorlayercellflag
eventindex
1550360.8333331160
650366.6666671270
750660.8333331270
1050609.1666671370
1150657.5000001480
950661.6666671491
27370270.0000002160
7070072.5000002260
7169957.5000002360
7470197.5000002470
\n", - "
" - ], - "text/plain": [ - " time detector layer cell flag\n", - "event index \n", - "1 5 50360.833333 1 1 6 0\n", - " 6 50366.666667 1 2 7 0\n", - " 7 50660.833333 1 2 7 0\n", - " 10 50609.166667 1 3 7 0\n", - " 11 50657.500000 1 4 8 0\n", - " 9 50661.666667 1 4 9 1\n", - "2 73 70270.000000 2 1 6 0\n", - " 70 70072.500000 2 2 6 0\n", - " 71 69957.500000 2 3 6 0\n", - " 74 70197.500000 2 4 7 0" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "events['flag'] = 0\n", - "level0_inds = events.index.get_level_values(0).to_numpy()\n", - "data = findTrajectories_np(events.to_numpy(), level0_inds)\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", - "events['flag'] = events['flag'].astype(np.int32)\n", + "printmd('Blue dots indicate paths at the right of the anodic wire, Green dots indicate paths at the left as in the project description')\n", + "printmd(\"### Event Path 1\")\n", + "plotEvent(events_mtt_vis.loc[47])\n", "\n", - "events.drop(events[events['flag']==1].index, inplace=True)" + "printmd(\"### Event Path 2\")\n", + "plotEvent(events_mtt_vis.loc[500])\n", + "\n", + "printmd(\"### Event Path 3\")\n", + "plotEvent(events_mtt_vis.loc[450])" ] }, { @@ -1337,7 +834,14 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.8.1" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } } }, "nbformat": 4, diff --git a/Project.ipynb b/Project.ipynb index aad53e5..d4642b3 100644 --- a/Project.ipynb +++ b/Project.ipynb @@ -119,9 +119,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [] } @@ -142,9 +140,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.4" + "version": "3.8.1" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From 7781c11c3896eadcc547cf92cb77832079a2eb1e Mon Sep 17 00:00:00 2001 From: Holgerillo Date: Mon, 16 Mar 2020 17:47:50 +0100 Subject: [PATCH 3/4] Fix of pandas find trajectories function --- Data_Analysis.ipynb | 2174 ++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 2028 insertions(+), 146 deletions(-) diff --git a/Data_Analysis.ipynb b/Data_Analysis.ipynb index db5a26d..d540f60 100644 --- a/Data_Analysis.ipynb +++ b/Data_Analysis.ipynb @@ -4,10 +4,22 @@ "cell_type": "markdown", "metadata": {}, "source": [ + " \n", + " \n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# PROJECT: PARTICLE DETECTOR DATA ANALYSIS\n", + "### Dataset: Run260, Calibration Run\n", + "\n", "
\n", "The project is outlined as following:\n", " \n", - " - [THE DATA](#1)\n", + " - [INTRODUCTION: THE DATA](#1)\n", " \n", " - [ADDING NEW COLUMNS](#2)\n", " \n", @@ -16,40 +28,15 @@ " - [FINDING TRAJECTORIES](#4)\n", " \n", " - [VISUALIZING THE EVENTS](#5)\n", + " \n", " - [DETECTOR MATRIX](#7)\n", " \n", " " ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#

THE DATA: Calibration run 260 / Real Measurement run 333\n", - "\n", - "\n", - "In this project, we analyze the data obtained through a set of particle detectors. The detectors consist on four layers of cells fulls of a gas. Each of the cells is traversed by an anodic cable in its middle. When a particle traverses the gas, it ionizes it, with the ions being then attracted towards the cable. The cell then emmits a signal when the ions reach the cable. \\\n", - "The ions can be considered to travel at a constat drift velocity $v_d$ towards the cable. The impact possition in a cell $x$ can be expressed as\n", - " \n", - " \n", - "$$\n", - "x = v_d (t - t_0),\n", - "$$\n", - " \n", - "being $t_0$ a pedestal time and $t$ the time recorded by the detector. As the maximum drift time $T_{Max} = \\frac{L}{2 v_d} = 390$ ns ($L=42$ mm is the lenght of the cell) is a known country, t0 can be calculated. This will be explained later. \n", - "\\\n", - "The data obtained are encoded in a CSV file. The way we can interpret its content is exlained as it is needed. It is the goal of this project to analyze these data so that we can track the trajectories of the particles through them. More specifically, the tasks to do are:\n", - " \n", - " -Grouping the data into events corresponding to a particle hitting the detector\n", - " -Obtain and plot the drift times\n", - " \n", - "This was done for both a calibration run and for a the data obtained in a real experiment.\n", - "\n" - ] - }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -72,28 +59,83 @@ "source": [ "***\n", "\n", - "#
THE DATA: Calibration run 260 / Real Measurement run 333\n", - "[Content Outline](#6)" + "#
I. INTRODUCTION: THE DATA\n", + "[Content Outline](#6)\n", + "\n", + "In this project, we analyze the data obtained through a set of particle detectors. As shown in the figure below, the detectors consist on four layers of cells fulls of a gas. Each of the cells is traversed by an anodic cable in its middle. When a particle traverses the gas, it ionizes it, with the ions being then attracted towards the cable. The cell then emmits a signal when the ions reach the cable. \\\n", + "The ions can be considered to travel at a constat drift velocity $v_d$ towards the cable. The impact possition in a cell $x$ can be expressed as\n", + " \n", + " \n", + "$$\n", + "x = v_d (t_R - t_0),\n", + "$$\n", + " \n", + "being $t_0$ as the pedestal time and $t_R$ the time recorded by the detector. As the maximum drift time $T_{Max} = \\frac{L}{2 v_d} = 390$ ns ($L=42$ mm is the lenght of the cell) is a known country, $t_0$ can be calculated, which will be explained later. \n", + "\\\n", + "The data obtained are encoded in a CSV file. The way we can interpret its content is exlained as it is needed. It is the goal of this project to analyze these data so that we can track the trajectories of the particles through them. More specifically, the tasks to do are:\n", + " \n", + " - grouping the data into events corresponding to a particle hitting the detector,\n", + " - obtain and plot the drift times, and\n", + " - plot the trajectory of the particle with left - right ambiguity.\n", + " \n", + "This was done for both a calibration run and for the data obtained in a real experiment.\n", + "\n", + "![(Picture of detector configuration)](./detector.jpg)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/markdown": [ + "## DESCRIPTION OF THE DATA" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files concatenated: \n", + " ['../data/Run000260/data_000000.txt', '../data/Run000260/data_000001.txt', '../data/Run000260/data_000002.txt', '../data/Run000260/data_000003.txt', '../data/Run000260/data_000004.txt', '../data/Run000260/data_000005.txt', '../data/Run000260/data_000006.txt', '../data/Run000260/data_000007.txt'] \n", + "\n", + "\n", + "RangeIndex: 9879056 entries, 0 to 9879055\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 float64\n", + " 4 TDC_MEAS float64\n", + "dtypes: float64(2), int64(3)\n", + "memory usage: 376.9 MB\n", + "None\n" + ] + } + ], "source": [ - "## Set as FALSE for Calibration run \n", - "REAL_DATA = True\n", + "# Set as FALSE for Calibration run \n", + "REAL_DATA = False\n", "\n", - "# We limit the amount of data we are accepting \n", - "if REAL_DATA:\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 = 65 # maximum size of data in mb to read in\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", @@ -102,41 +144,234 @@ " files = files[:(i-1)]\n", " break\n", "\n", - "# Load the data\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", - "#Let's drop the column named 'HEAD'\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", - "# We print the description\n", + "# Print the description of the data\n", "printmd('## DESCRIPTION OF THE DATA')\n", - "print('Used files:', '\\n', files, '\\n') # To check which files are read\n", + "print('Files concatenated:', '\\n', files, '\\n') # To check which files are read\n", "print(data.info())\n", - "display(data.describe())" + "# display(data.describe())" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/markdown": [ + "## THE DATAFRAME" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "The dataframe below presents the first 10 hits as presented in the raw data." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEAS
0111618974148841533.024.0
117118974148871650.021.0
21671897414914980.08.0
317018974149221287.08.0
405718974149222162.022.0
502418974149342014.013.0
602618974149342014.020.0
702618974149342026.013.0
8013918974149342028.00.0
903318974149342026.014.0
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS\n", + "0 1 116 1897414884 1533.0 24.0\n", + "1 1 71 1897414887 1650.0 21.0\n", + "2 1 67 1897414914 980.0 8.0\n", + "3 1 70 1897414922 1287.0 8.0\n", + "4 0 57 1897414922 2162.0 22.0\n", + "5 0 24 1897414934 2014.0 13.0\n", + "6 0 26 1897414934 2014.0 20.0\n", + "7 0 26 1897414934 2026.0 13.0\n", + "8 0 139 1897414934 2028.0 0.0\n", + "9 0 33 1897414934 2026.0 14.0" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "#Visualization of the first 5 entries of the file\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", + "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": null, + "execution_count": 5, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/markdown": [ + "## HISTOGRAM OF HITS PER TDC CHANNEL" + ], + "text/plain": [ + "" + ] + }, + "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": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "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", @@ -148,10 +383,13 @@ "ax1.set_title('FPGA 0')\n", "ax2.set_title('FPGA 1')\n", "\n", - "printmd('## HISTOGRAM OF HITS PER CHANNEL')\n", + "printmd('## HISTOGRAM OF HITS PER TDC CHANNEL')\n", + "printmd('Remark: There are a lot of hits falling under the mean time trigger channel: 139.')\n", "plt.show()\n", - "printmd('#### There are a lot of hits falling under the mean time trigger')\n", - "# Remark: There is a lot of data in the trigger" + "\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" ] }, { @@ -159,7 +397,7 @@ "metadata": {}, "source": [ "***\n", - "#
ADDING NEW COLUMNS: TIME, DETECTOR, LAYER, AND CELL\n", + "#
II. ADDING NEW COLUMNS: TIME, DETECTOR, LAYER, AND CELL\n", " [Content Outline](#6)" ] }, @@ -172,7 +410,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -206,9 +444,108 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEASdetectortime
0111618974148841533.024.0-138345.000000
117118974148871650.021.0-141267.500000
21671897414914980.08.0-124506.666667
317018974149221287.08.0-132181.666667
405718974149222162.022.0-154068.333333
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector time\n", + "0 1 116 1897414884 1533.0 24.0 -1 38345.000000\n", + "1 1 71 1897414887 1650.0 21.0 -1 41267.500000\n", + "2 1 67 1897414914 980.0 8.0 -1 24506.666667\n", + "3 1 70 1897414922 1287.0 8.0 -1 32181.666667\n", + "4 0 57 1897414922 2162.0 22.0 -1 54068.333333" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "data['time'] = data['BX_COUNTER']*25 + data['TDC_MEAS']*25/30\n", "\n", @@ -220,27 +557,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The actual time taken by the ionization to reach the anodic wire (drift time) is proportional to the distance:\n", + "As stated earlier, the actual time taken by the ionization to reach the anodic wire (drift time) is proportional to the distance:\n", "\n", "$$\n", "x = v_d t_i= v_d(t_R-t_0)\n", "$$\n", "\n", - "where $v_d$ is the constant drift velocity, $t_R$ is the time recorded by the electronics and $t_0$ is a time pedestal which needs to be determined for every particles crossing the detector (the drift time is $t_R-t_0$). This is possible thanks to the geometry of the layers, more precisely by the fact that they are staggered by exactly half a cell. \n", - "\n", - "To compute the constant $t_0$, which is different for every event, we can use the following relation:\n", - "\n", - "$$T_{MAX}=\\frac{t_{1}+t_{3}}{2}+t_{2}$$\n", - "\n", - "where $t_1 = t_{1'}-t_0$, $t_2 = t_{2'}-t_0$ and $t_3 = t_{3'}-t_0$, are the drift times of those three cells and $t_{i'}$ is the time measurement of the respective cell. The drift times can be calculated in this way because $t_0$ is essentially the same for each cell in one event, because the particle velocity of the muons(?) is much higher than the drift velocity of the electrons. Then the relation becomes:\n", - "\n", - "$$T_{MAX}=\\frac{t_{1'}-t_0+t_{3'}-t_0}{2}+t_{2'}-t_0$$\n", - "\n", - "from which we get:\n", - "\n", - "$$t_0=\\frac{t_{1'}+t_{3'}+2t_{2'}-2T_{MAX}}{4}$$\n", - "\n", - "Finally we notice that $t_{1'}$, $t_{2'}$, $t_{3'}$ are the times recorded by each cell, which are already available in our dataset." + "where $v_d$ is the constant drift velocity, $t_R$ is the time recorded by the electronics and $t_0$ is a time pedestal which needs to be determined for every particles crossing the detector (the drift time is $t_R-t_0$). This is possible thanks to the geometry of the layers, more precisely by the fact that they are staggered by exactly half a cell. " ] }, { @@ -253,11 +576,7 @@ "* CHAMBER, which is the Detector number. The data to be analyzed have been gathered by a series of (4) particle detectors: [1-4]\n", "* LAYER. Such detectors were composed by four layers of cells: [1-4];\n", "* CELL, which is in the number of the cell. The actual detector has 16 cells per layer: [1-16]\n", - "* POSTION, which is the position where a particle traverses the cell [0-21] (in mm. The maximum 21 mm value corresponds to the position of the anodic wire to where the particles travel. In this case the left-right ambiguity is NOT resolved). \n", - "\n", - "\n", - "\n", - "![(Picture of detector configuration)](./Detector.png)" + "* POSTION, which is the position where a particle traverses the cell [0-21] (in mm. The maximum 21 mm value corresponds to the position of the anodic wire to where the particles travel. In this case the left-right ambiguity is NOT resolved). " ] }, { @@ -281,11 +600,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(Detectory, Layer, Cell) example: \n", + " [(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": [ - "# adding detector, layer and cell columns \n", + "# Define function to add the detector, layer and cell columns \n", "\n", "@vectorize([int64(int64, int64)])\n", "def giveDetector(fpga, channel):\n", @@ -321,26 +649,157 @@ "\n", " return cell\n", "\n", - "# Test of functions\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))))" + " print('(Detectory, Layer, Cell) example: \\n',list(zip(giveDetector(0,a), giveLayer(a), giveCell(a))))\n", + " " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/markdown": [ + "Dataframe now has new columns: time, detector, layer, and cell." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEASdetectortimelayercell
0111618974148841533.024.0438345.000000113
117118974148871650.021.0441267.50000032
21671897414914980.08.0424506.66666731
317018974149221287.08.0432181.66666722
405718974149222162.022.0154068.333333415
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector \\\n", + "0 1 116 1897414884 1533.0 24.0 4 \n", + "1 1 71 1897414887 1650.0 21.0 4 \n", + "2 1 67 1897414914 980.0 8.0 4 \n", + "3 1 70 1897414922 1287.0 8.0 4 \n", + "4 0 57 1897414922 2162.0 22.0 1 \n", + "\n", + " time layer cell \n", + "0 38345.000000 1 13 \n", + "1 41267.500000 3 2 \n", + "2 24506.666667 3 1 \n", + "3 32181.666667 2 2 \n", + "4 54068.333333 4 15 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Calculation of detector, layer & cell according to the previous functions\n", + "# 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))" ] }, @@ -349,7 +808,7 @@ "metadata": {}, "source": [ "***\n", - "#
FINDING EVENTS \n", + "#
III. FINDING EVENTS \n", " [Content Outline](#6)" ] }, @@ -362,9 +821,144 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ORBIT_CNTtime
8189741493450700.0
72189741530170300.0
87189741542533375.0
115189741554430850.0
140189741567429950.0
\n", + "
" + ], + "text/plain": [ + " ORBIT_CNT time\n", + "8 1897414934 50700.0\n", + "72 1897415301 70300.0\n", + "87 1897415425 33375.0\n", + "115 1897415544 30850.0\n", + "140 1897415674 29950.0" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ORBIT_CNTtime
24235189753750726853.333333
24238189753750726857.500000
24239189753750726850.833333
24241189753750726860.000000
24448719185055051525.833333
\n", + "
" + ], + "text/plain": [ + " ORBIT_CNT time\n", + "24235 1897537507 26853.333333\n", + "24238 1897537507 26857.500000\n", + "24239 1897537507 26850.833333\n", + "24241 1897537507 26860.000000\n", + "244487 1918505505 1525.833333" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "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", @@ -378,16 +972,308 @@ "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." + "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 hits by orbits and reindexed to present the data for each event." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/markdown": [ + "## Events in the Mean time Trigger" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEASdetectortimelayercell
eventindex
1502418974149342014.013.0150360.83333316
602618974149342014.020.0150366.66666727
702618974149342026.013.0150660.83333327
1002718974149342024.011.0150609.16666737
1102918974149342026.09.0150657.50000048
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector \\\n", + "event index \n", + "1 5 0 24 1897414934 2014.0 13.0 1 \n", + " 6 0 26 1897414934 2014.0 20.0 1 \n", + " 7 0 26 1897414934 2026.0 13.0 1 \n", + " 10 0 27 1897414934 2024.0 11.0 1 \n", + " 11 0 29 1897414934 2026.0 9.0 1 \n", + "\n", + " time layer cell \n", + "event index \n", + "1 5 50360.833333 1 6 \n", + " 6 50366.666667 2 7 \n", + " 7 50660.833333 2 7 \n", + " 10 50609.166667 3 7 \n", + " 11 50657.500000 4 8 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "## Events in the Scintillator Trigger" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEASdetectortimelayercell
eventindex
12424218018975375071857.011.0446434.16666714
2244481016191850550526.017.01664.16666714
244485011191850550534.012.01860.00000033
24448309191850550527.012.01685.00000043
244482168191850550534.025.04870.83333311
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector \\\n", + "event index \n", + "1 24242 1 80 1897537507 1857.0 11.0 4 \n", + "2 244481 0 16 1918505505 26.0 17.0 1 \n", + " 244485 0 11 1918505505 34.0 12.0 1 \n", + " 244483 0 9 1918505505 27.0 12.0 1 \n", + " 244482 1 68 1918505505 34.0 25.0 4 \n", + "\n", + " time layer cell \n", + "event index \n", + "1 24242 46434.166667 1 4 \n", + "2 244481 664.166667 1 4 \n", + " 244485 860.000000 3 3 \n", + " 244483 685.000000 4 3 \n", + " 244482 870.833333 1 1 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "#.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", @@ -405,15 +1291,14 @@ " 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", - " printmd('## EVENTS DATAFRAME')\n", - " display(events.head(4))\n", " \n", " return events\n", "\n", + "printmd('## Events in the Mean time Trigger')\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))" ] @@ -423,13 +1308,13 @@ "metadata": {}, "source": [ "***\n", - "#
FINDING THE TRAJECTORIES, computing t0\n", + "#
IV. FINDING THE TRAJECTORIES\n", " [Content Outline](#6)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -474,7 +1359,7 @@ " sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==3).index, 't0_1'].iloc[0])\n", "\n", " return data\n", - " \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", @@ -490,7 +1375,7 @@ "\n", "\n", "@njit\n", - "def findTrajectories_np(data, inds, columns): # data, index, columns??\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 # use old version???\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", @@ -501,7 +1386,7 @@ " 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", + " if np.unique(ev[:,det_ind]).size != 1: #??? change to \"subevents\"\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", @@ -527,8 +1412,8 @@ " sub_ev[:,t0_2_ind] = np.nan\n", " break\n", "\n", - " # Else mark rows where no successor was found\n", - " # if one cell was found with no successor\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", @@ -547,11 +1432,329 @@ " return data" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Computing $t_0$\n", + "\n", + "To compute the constant $t_0$, which is different for every event, we can use the following relation:\n", + "\n", + "$$T_{MAX}=\\frac{t_{1}+t_{3}}{2}+t_{2}$$\n", + "\n", + "where $t_1 = t_{1'}-t_0$, $t_2 = t_{2'}-t_0$ and $t_3 = t_{3'}-t_0$, are the drift times of those three cells and $t_{i'}$ is the time measurement of the respective cell. The drift times can be calculated in this way because $t_0$ is essentially the same for each cell in one event, because the particle velocity of the muons(?) is much higher than the drift velocity of the electrons. Then the relation becomes:\n", + "\n", + "$$T_{MAX}=\\frac{t_{1'}-t_0+t_{3'}-t_0}{2}+t_{2'}-t_0$$\n", + "\n", + "from which we get:\n", + "\n", + "$$t_0=\\frac{t_{1'}+t_{3'}+2t_{2'}-2T_{MAX}}{4}$$\n", + "\n", + "Finally we notice that $t_{1'}$, $t_{2'}$, $t_{3'}$ are the times recorded by each cell, which are already available in our dataset." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEASdetectortimelayercellt0_123t0_234
eventindex
150.024.01.897415e+092014.013.0150360.8333331650230.83333350365.625
60.026.01.897415e+092014.020.0150366.6666672750230.83333350365.625
70.026.01.897415e+092026.013.0150660.8333332750230.83333350365.625
100.027.01.897415e+092024.011.0150609.1666673750230.83333350365.625
110.029.01.897415e+092026.09.0150657.5000004850230.83333350365.625
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector \\\n", + "event index \n", + "1 5 0.0 24.0 1.897415e+09 2014.0 13.0 1 \n", + " 6 0.0 26.0 1.897415e+09 2014.0 20.0 1 \n", + " 7 0.0 26.0 1.897415e+09 2026.0 13.0 1 \n", + " 10 0.0 27.0 1.897415e+09 2024.0 11.0 1 \n", + " 11 0.0 29.0 1.897415e+09 2026.0 9.0 1 \n", + "\n", + " time layer cell t0_123 t0_234 \n", + "event index \n", + "1 5 50360.833333 1 6 50230.833333 50365.625 \n", + " 6 50366.666667 2 7 50230.833333 50365.625 \n", + " 7 50660.833333 2 7 50230.833333 50365.625 \n", + " 10 50609.166667 3 7 50230.833333 50365.625 \n", + " 11 50657.500000 4 8 50230.833333 50365.625 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEASdetectortimelayercellt0_123t0_234
eventindex
1242421.080.01.897538e+091857.011.0446434.16666714NaNNaN
22444810.016.01.918506e+0926.017.01664.16666714NaNNaN
2444850.011.01.918506e+0934.012.01860.00000033NaNNaN
2444830.09.01.918506e+0927.012.01685.00000043NaNNaN
2444821.068.01.918506e+0934.025.04870.83333311NaNNaN
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector \\\n", + "event index \n", + "1 24242 1.0 80.0 1.897538e+09 1857.0 11.0 4 \n", + "2 244481 0.0 16.0 1.918506e+09 26.0 17.0 1 \n", + " 244485 0.0 11.0 1.918506e+09 34.0 12.0 1 \n", + " 244483 0.0 9.0 1.918506e+09 27.0 12.0 1 \n", + " 244482 1.0 68.0 1.918506e+09 34.0 25.0 4 \n", + "\n", + " time layer cell t0_123 t0_234 \n", + "event index \n", + "1 24242 46434.166667 1 4 NaN NaN \n", + "2 244481 664.166667 1 4 NaN NaN \n", + " 244485 860.000000 3 3 NaN NaN \n", + " 244483 685.000000 4 3 NaN NaN \n", + " 244482 870.833333 1 1 NaN NaN " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def calculate_t0(df, numba_optimized=True):\n", " events = df.copy(deep=False)\n", @@ -587,59 +1790,129 @@ "metadata": {}, "source": [ "***\n", - "#
'VISUALIZING' THE EVENTS\n", + "#
IV. CHARACTERIZING THE EVENTS\n", " [Content Outline](#6)\n", "## CALCULATION OF DRIFT TIMES " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/markdown": [ + "#### For the Mean time Trigger" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "#### For the Scintillator Trigger" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "def make_hist(df):\n", " events = df.copy(deep=False)\n", "\n", - " events['drift_time'] = events['time'] - events['t0_123'] # use one t0???\n", + " events['drift_time'] = events['time'] - events['t0_123']\n", " events['x'] = v_d*events['drift_time']\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_123'] = np.nan\n", "\n", " events.loc[events['t0_123'].notna(),'drift_time'].plot(kind='hist', title='Distribution of Drift Times',\n", - " bins=100) # driftime instead of x???\n", + " bins=100)\n", "\n", " plt.xlabel('Drift time (ns)')\n", " plt.ylabel('Number of Occurrences')\n", "\n", " plt.show()\n", - "\n", - " printmd('#### Remark: the maximum amount of occurences happen around 10 mm from the anodic wire.')\n", - " \n", " return events\n", "\n", "\n", - "display(events_mtt.head(5))\n", + "printmd('#### For the Mean time Trigger') \n", "events_mtt = make_hist(events_mtt)\n", "if not trigger_st.empty:\n", - " events_st = make_hist(events_st)\n", - " display(events_st.head(5))" + " printmd('#### For the Scintillator Trigger') \n", + " events_st = make_hist(events_st)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## FILTERING THE DATA \n", - "\n", - "### Useful events: showing the percentage of events that have more than 3 hits?" + "## FILTERING THE DATA " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/markdown": [ + "### Useful Events" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean Time Trigger:\n", + "\"useful rows\" / \"all rows\": 0.7480358723252831\n", + "\"useful events\" / \"all events\" 0.9521337729201057\n", + "\n", + " Scintillator Trigger\n", + "\"useful rows\" / \"all rows\": 0.6541494624855857\n", + "\"useful events\" / \"all events\" 0.9760179865101174\n" + ] + } + ], "source": [ "def print_useful_events(df):\n", " events = df.copy(deep=False)\n", @@ -658,11 +1931,11 @@ " except ZeroDivisionError:\n", " print('Error: Dataframe is empty')\n", "\n", - "\n", + "printmd('### Useful Events')\n", "print('Mean Time Trigger:')\n", "print_useful_events(events_mtt)\n", "if not trigger_st.empty:\n", - " print('Scintillator Trigger')\n", + " print('\\n','Scintillator Trigger')\n", " print_useful_events(events_st)" ] }, @@ -670,33 +1943,513 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Filter 2: Drop hits that do not align\n", - "### Filter 3: Obtain events that have at least one hit per layer (i.e. 4 layer representation)\n", - "### Filter 4: Sort OUT events that have only ONE detector representation" + "### Now we filter the data according to 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": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/markdown": [ + "### Event 1 for the Mean time Trigger" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEASdetectortimelayercellt0_123t0_234drift_timex
eventindex
14151.016.01.897417e+09452.017.0311314.1666671411126.66666711134.375187.50000010.096154
4111.014.01.897417e+09450.09.0311257.5000002411126.66666711134.375130.8333337.044872
4171.015.01.897417e+09458.09.0311457.5000003411126.66666711134.375330.83333317.814103
4091.013.01.897417e+09445.024.0311145.0000004411126.66666711134.37518.3333330.987179
4141.0104.01.897417e+09459.024.0411495.00000011011118.95833311127.500376.04166720.248397
4101.0102.01.897417e+09447.08.0411181.66666721011118.95833311127.50062.7083333.376603
4121.099.01.897417e+09455.027.0411397.5000003911118.95833311127.500278.54166714.998397
4161.0101.01.897417e+09452.016.0411313.33333341011118.95833311127.500194.37500010.466346
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector \\\n", + "event index \n", + "1 415 1.0 16.0 1.897417e+09 452.0 17.0 3 \n", + " 411 1.0 14.0 1.897417e+09 450.0 9.0 3 \n", + " 417 1.0 15.0 1.897417e+09 458.0 9.0 3 \n", + " 409 1.0 13.0 1.897417e+09 445.0 24.0 3 \n", + " 414 1.0 104.0 1.897417e+09 459.0 24.0 4 \n", + " 410 1.0 102.0 1.897417e+09 447.0 8.0 4 \n", + " 412 1.0 99.0 1.897417e+09 455.0 27.0 4 \n", + " 416 1.0 101.0 1.897417e+09 452.0 16.0 4 \n", + "\n", + " time layer cell t0_123 t0_234 drift_time \\\n", + "event index \n", + "1 415 11314.166667 1 4 11126.666667 11134.375 187.500000 \n", + " 411 11257.500000 2 4 11126.666667 11134.375 130.833333 \n", + " 417 11457.500000 3 4 11126.666667 11134.375 330.833333 \n", + " 409 11145.000000 4 4 11126.666667 11134.375 18.333333 \n", + " 414 11495.000000 1 10 11118.958333 11127.500 376.041667 \n", + " 410 11181.666667 2 10 11118.958333 11127.500 62.708333 \n", + " 412 11397.500000 3 9 11118.958333 11127.500 278.541667 \n", + " 416 11313.333333 4 10 11118.958333 11127.500 194.375000 \n", + "\n", + " x \n", + "event index \n", + "1 415 10.096154 \n", + " 411 7.044872 \n", + " 417 17.814103 \n", + " 409 0.987179 \n", + " 414 20.248397 \n", + " 410 3.376603 \n", + " 412 14.998397 \n", + " 416 10.466346 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "### Event 1 for the Scintillator Trigger" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEASdetectortimelayercellt0_123t0_234drift_timex
eventindex
12466851.016.01.918507e+092112.026.0352821.6666671452675.20833352670.416667146.4583337.886218
2466901.014.01.918507e+092118.020.0352966.6666672452675.20833352670.416667291.45833315.693910
2466811.015.01.918507e+092109.01.0352725.8333333452675.20833352670.41666750.6250002.725962
2466871.013.01.918507e+092121.022.0353043.3333334452675.20833352670.416667368.12500019.822115
2466861.068.01.918507e+092112.010.0452808.3333331152549.79166752546.666667258.54166713.921474
2466881.066.01.918507e+092109.06.0452730.0000002152549.79166752546.666667180.2083339.703526
2466801.067.01.918507e+092108.013.0452710.8333333152549.79166752546.666667161.0416678.671474
2466841.065.01.918507e+092112.018.0452815.0000004152549.79166752546.666667265.20833314.280449
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector \\\n", + "event index \n", + "1 246685 1.0 16.0 1.918507e+09 2112.0 26.0 3 \n", + " 246690 1.0 14.0 1.918507e+09 2118.0 20.0 3 \n", + " 246681 1.0 15.0 1.918507e+09 2109.0 1.0 3 \n", + " 246687 1.0 13.0 1.918507e+09 2121.0 22.0 3 \n", + " 246686 1.0 68.0 1.918507e+09 2112.0 10.0 4 \n", + " 246688 1.0 66.0 1.918507e+09 2109.0 6.0 4 \n", + " 246680 1.0 67.0 1.918507e+09 2108.0 13.0 4 \n", + " 246684 1.0 65.0 1.918507e+09 2112.0 18.0 4 \n", + "\n", + " time layer cell t0_123 t0_234 \\\n", + "event index \n", + "1 246685 52821.666667 1 4 52675.208333 52670.416667 \n", + " 246690 52966.666667 2 4 52675.208333 52670.416667 \n", + " 246681 52725.833333 3 4 52675.208333 52670.416667 \n", + " 246687 53043.333333 4 4 52675.208333 52670.416667 \n", + " 246686 52808.333333 1 1 52549.791667 52546.666667 \n", + " 246688 52730.000000 2 1 52549.791667 52546.666667 \n", + " 246680 52710.833333 3 1 52549.791667 52546.666667 \n", + " 246684 52815.000000 4 1 52549.791667 52546.666667 \n", + "\n", + " drift_time x \n", + "event index \n", + "1 246685 146.458333 7.886218 \n", + " 246690 291.458333 15.693910 \n", + " 246681 50.625000 2.725962 \n", + " 246687 368.125000 19.822115 \n", + " 246686 258.541667 13.921474 \n", + " 246688 180.208333 9.703526 \n", + " 246680 161.041667 8.671474 \n", + " 246684 265.208333 14.280449 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def prepare_for_vis(df):\n", " # Drop all not aligning hits\n", - " visual_evs = df.dropna(subset=['t0_123']).copy() # subset = array which limits the dropping process to passed rows/columns through list.\n", - "\n", + " visual_evs = df.dropna(subset = ['t0_123']).copy() \n", + " \n", " # Sort out events which are not in every layer, each event must have 4 layers\n", " go_through_each_lay = visual_evs.loc[:,'layer'].groupby(level=0).nunique() == 4\n", "\n", " # Sort out events which are only registered in one 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 it to dataframe\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", @@ -706,30 +2459,155 @@ " \n", " return visual_evs\n", "\n", - "\n", + "# Check if filter is applied\n", "events_mtt_vis = prepare_for_vis(events_mtt)\n", - "display(events_mtt_vis.head(4))\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", - " display(events_st_vis.head(4))" + " printmd('### Event 1 for the Scintillator Trigger')\n", + " display(events_st_vis.head(8))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "##
MAKING THE DETECTOR MATRIX \n", + "***\n", + "#
V. THE DETECTOR MATRIX \n", " [Content Outline](#6)\n", " " ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 22, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/markdown": [ + "The following paths represent some of the event trajectories found in the data. Blue dots indicate paths at the right of the anodic wire, while green dots indicate paths at the left as in the project description" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "#### Event Path 1" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "This event follows a trajectory of a particle through detectors 3 and 4." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "#### Event Path 2" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "This event follows a trajectory of a particle through detectors 1 and 2." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "#### Event Path 3" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "This trajectory presents a particle that has excited electrons in the cells, therefore a detection of multiple hits is present. Further filtration would be needed to avoid these kinds of path from showing up, nevertheless, we can use this to characterize the behavior of the particle as it traverses the detectors." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "printmd(\"### Event Data\")\n", "def plotDetector(ax, event, is_empty):\n", " detector = np.zeros((4,16*2+1))\n", "\n", @@ -799,23 +2677,27 @@ " plt.show()\n", "\n", "\n", - "printmd('Blue dots indicate paths at the right of the anodic wire, Green dots indicate paths at the left as in the project description')\n", - "printmd(\"### Event Path 1\")\n", + "printmd(\"The following paths represent some of the event trajectories found in the data. Blue dots indicate paths at the right of the anodic wire, while green 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 3 and 4.\")\n", "plotEvent(events_mtt_vis.loc[47])\n", "\n", - "printmd(\"### Event Path 2\")\n", - "plotEvent(events_mtt_vis.loc[500])\n", + "printmd(\"#### Event Path 2\")\n", + "printmd(\"This event follows a trajectory of a particle through detectors 1 and 2.\")\n", + "plotEvent(events_mtt_vis.loc[163])\n", "\n", - "printmd(\"### Event Path 3\")\n", - "plotEvent(events_mtt_vis.loc[450])" + "printmd(\"#### Event Path 3\")\n", + "printmd(\"This trajectory presents a particle that has excited electrons in the cells, therefore a detection of multiple hits is present. Further filtration would be needed to avoid these kinds of path from showing up, nevertheless, we can use this to characterize the behavior of the particle as it traverses the detectors.\")\n", + "plotEvent(events_mtt_vis.loc[131])\n" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "#### Final Remarks: \n", + "The team has fulfilled the project goals through previous code. In the end, valid trajectories were found through the sorting and filtering of the data using the trigger channels, mean time and scintillator. " + ] } ], "metadata": { From 3d6bacb0984c0bccf6f7480454c3538983cc0fd6 Mon Sep 17 00:00:00 2001 From: Holgerillo Date: Mon, 16 Mar 2020 23:22:57 +0100 Subject: [PATCH 4/4] Some fixes --- Data_Analysis.ipynb | 689 +++++++++++++++++++++++--------------------- 1 file changed, 363 insertions(+), 326 deletions(-) diff --git a/Data_Analysis.ipynb b/Data_Analysis.ipynb index d540f60..6ba423a 100644 --- a/Data_Analysis.ipynb +++ b/Data_Analysis.ipynb @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 61, "metadata": {}, "outputs": [], "source": [ @@ -85,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 62, "metadata": { "scrolled": true }, @@ -161,7 +161,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 63, "metadata": {}, "outputs": [ { @@ -328,7 +328,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 64, "metadata": { "scrolled": true }, @@ -410,7 +410,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 65, "metadata": {}, "outputs": [], "source": [ @@ -421,8 +421,7 @@ "L = 42 # (lenght of the cell in mm)\n", "v_d = L/(2*T_M) # (constant drift velocity in mm/ns)\n", "\n", - "# We set the detector column to display -1 for trigger and detector number\n", - "data['detector'] = -1" + "#!!! deleted the detector -1 setting (useless)" ] }, { @@ -444,7 +443,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 66, "metadata": {}, "outputs": [ { @@ -473,7 +472,6 @@ " ORBIT_CNT\n", " BX_COUNTER\n", " TDC_MEAS\n", - " detector\n", " time\n", " \n", " \n", @@ -485,7 +483,6 @@ " 1897414884\n", " 1533.0\n", " 24.0\n", - " -1\n", " 38345.000000\n", " \n", " \n", @@ -495,7 +492,6 @@ " 1897414887\n", " 1650.0\n", " 21.0\n", - " -1\n", " 41267.500000\n", " \n", " \n", @@ -505,7 +501,6 @@ " 1897414914\n", " 980.0\n", " 8.0\n", - " -1\n", " 24506.666667\n", " \n", " \n", @@ -515,7 +510,6 @@ " 1897414922\n", " 1287.0\n", " 8.0\n", - " -1\n", " 32181.666667\n", " \n", " \n", @@ -525,7 +519,6 @@ " 1897414922\n", " 2162.0\n", " 22.0\n", - " -1\n", " 54068.333333\n", " \n", " \n", @@ -533,15 +526,15 @@ "" ], "text/plain": [ - " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector time\n", - "0 1 116 1897414884 1533.0 24.0 -1 38345.000000\n", - "1 1 71 1897414887 1650.0 21.0 -1 41267.500000\n", - "2 1 67 1897414914 980.0 8.0 -1 24506.666667\n", - "3 1 70 1897414922 1287.0 8.0 -1 32181.666667\n", - "4 0 57 1897414922 2162.0 22.0 -1 54068.333333" + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS time\n", + "0 1 116 1897414884 1533.0 24.0 38345.000000\n", + "1 1 71 1897414887 1650.0 21.0 41267.500000\n", + "2 1 67 1897414914 980.0 8.0 24506.666667\n", + "3 1 70 1897414922 1287.0 8.0 32181.666667\n", + "4 0 57 1897414922 2162.0 22.0 54068.333333" ] }, - "execution_count": 7, + "execution_count": 66, "metadata": {}, "output_type": "execute_result" } @@ -600,7 +593,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 67, "metadata": {}, "outputs": [ { @@ -659,7 +652,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 68, "metadata": { "scrolled": true }, @@ -702,8 +695,8 @@ " ORBIT_CNT\n", " BX_COUNTER\n", " TDC_MEAS\n", - " detector\n", " time\n", + " detector\n", " layer\n", " cell\n", " \n", @@ -716,8 +709,8 @@ " 1897414884\n", " 1533.0\n", " 24.0\n", - " 4\n", " 38345.000000\n", + " 4\n", " 1\n", " 13\n", " \n", @@ -728,8 +721,8 @@ " 1897414887\n", " 1650.0\n", " 21.0\n", - " 4\n", " 41267.500000\n", + " 4\n", " 3\n", " 2\n", " \n", @@ -740,8 +733,8 @@ " 1897414914\n", " 980.0\n", " 8.0\n", - " 4\n", " 24506.666667\n", + " 4\n", " 3\n", " 1\n", " \n", @@ -752,8 +745,8 @@ " 1897414922\n", " 1287.0\n", " 8.0\n", - " 4\n", " 32181.666667\n", + " 4\n", " 2\n", " 2\n", " \n", @@ -764,8 +757,8 @@ " 1897414922\n", " 2162.0\n", " 22.0\n", - " 1\n", " 54068.333333\n", + " 1\n", " 4\n", " 15\n", " \n", @@ -774,19 +767,19 @@ "" ], "text/plain": [ - " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector \\\n", - "0 1 116 1897414884 1533.0 24.0 4 \n", - "1 1 71 1897414887 1650.0 21.0 4 \n", - "2 1 67 1897414914 980.0 8.0 4 \n", - "3 1 70 1897414922 1287.0 8.0 4 \n", - "4 0 57 1897414922 2162.0 22.0 1 \n", + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS time \\\n", + "0 1 116 1897414884 1533.0 24.0 38345.000000 \n", + "1 1 71 1897414887 1650.0 21.0 41267.500000 \n", + "2 1 67 1897414914 980.0 8.0 24506.666667 \n", + "3 1 70 1897414922 1287.0 8.0 32181.666667 \n", + "4 0 57 1897414922 2162.0 22.0 54068.333333 \n", "\n", - " time layer cell \n", - "0 38345.000000 1 13 \n", - "1 41267.500000 3 2 \n", - "2 24506.666667 3 1 \n", - "3 32181.666667 2 2 \n", - "4 54068.333333 4 15 " + " detector layer cell \n", + "0 4 1 13 \n", + "1 4 3 2 \n", + "2 4 3 1 \n", + "3 4 2 2 \n", + "4 1 4 15 " ] }, "metadata": {}, @@ -821,7 +814,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 69, "metadata": {}, "outputs": [ { @@ -972,12 +965,12 @@ "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 hits by orbits and reindexed to present the data for each event." + "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 hits by orbits and reindexed to present the data for each event." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 70, "metadata": { "scrolled": true }, @@ -1021,8 +1014,8 @@ " ORBIT_CNT\n", " BX_COUNTER\n", " TDC_MEAS\n", - " detector\n", " time\n", + " detector\n", " layer\n", " cell\n", " \n", @@ -1049,9 +1042,9 @@ " 1897414934\n", " 2014.0\n", " 13.0\n", - " 1\n", " 50360.833333\n", " 1\n", + " 1\n", " 6\n", " \n", " \n", @@ -1061,8 +1054,8 @@ " 1897414934\n", " 2014.0\n", " 20.0\n", - " 1\n", " 50366.666667\n", + " 1\n", " 2\n", " 7\n", " \n", @@ -1073,8 +1066,8 @@ " 1897414934\n", " 2026.0\n", " 13.0\n", - " 1\n", " 50660.833333\n", + " 1\n", " 2\n", " 7\n", " \n", @@ -1085,8 +1078,8 @@ " 1897414934\n", " 2024.0\n", " 11.0\n", - " 1\n", " 50609.166667\n", + " 1\n", " 3\n", " 7\n", " \n", @@ -1097,8 +1090,8 @@ " 1897414934\n", " 2026.0\n", " 9.0\n", - " 1\n", " 50657.500000\n", + " 1\n", " 4\n", " 8\n", " \n", @@ -1107,21 +1100,21 @@ "" ], "text/plain": [ - " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector \\\n", - "event index \n", - "1 5 0 24 1897414934 2014.0 13.0 1 \n", - " 6 0 26 1897414934 2014.0 20.0 1 \n", - " 7 0 26 1897414934 2026.0 13.0 1 \n", - " 10 0 27 1897414934 2024.0 11.0 1 \n", - " 11 0 29 1897414934 2026.0 9.0 1 \n", + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS \\\n", + "event index \n", + "1 5 0 24 1897414934 2014.0 13.0 \n", + " 6 0 26 1897414934 2014.0 20.0 \n", + " 7 0 26 1897414934 2026.0 13.0 \n", + " 10 0 27 1897414934 2024.0 11.0 \n", + " 11 0 29 1897414934 2026.0 9.0 \n", "\n", - " time layer cell \n", - "event index \n", - "1 5 50360.833333 1 6 \n", - " 6 50366.666667 2 7 \n", - " 7 50660.833333 2 7 \n", - " 10 50609.166667 3 7 \n", - " 11 50657.500000 4 8 " + " time detector layer cell \n", + "event index \n", + "1 5 50360.833333 1 1 6 \n", + " 6 50366.666667 1 2 7 \n", + " 7 50660.833333 1 2 7 \n", + " 10 50609.166667 1 3 7 \n", + " 11 50657.500000 1 4 8 " ] }, "metadata": {}, @@ -1166,8 +1159,8 @@ " ORBIT_CNT\n", " BX_COUNTER\n", " TDC_MEAS\n", - " detector\n", " time\n", + " detector\n", " layer\n", " cell\n", " \n", @@ -1194,8 +1187,8 @@ " 1897537507\n", " 1857.0\n", " 11.0\n", - " 4\n", " 46434.166667\n", + " 4\n", " 1\n", " 4\n", " \n", @@ -1207,9 +1200,9 @@ " 1918505505\n", " 26.0\n", " 17.0\n", - " 1\n", " 664.166667\n", " 1\n", + " 1\n", " 4\n", " \n", " \n", @@ -1219,8 +1212,8 @@ " 1918505505\n", " 34.0\n", " 12.0\n", - " 1\n", " 860.000000\n", + " 1\n", " 3\n", " 3\n", " \n", @@ -1231,8 +1224,8 @@ " 1918505505\n", " 27.0\n", " 12.0\n", - " 1\n", " 685.000000\n", + " 1\n", " 4\n", " 3\n", " \n", @@ -1243,8 +1236,8 @@ " 1918505505\n", " 34.0\n", " 25.0\n", - " 4\n", " 870.833333\n", + " 4\n", " 1\n", " 1\n", " \n", @@ -1253,21 +1246,21 @@ "" ], "text/plain": [ - " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector \\\n", - "event index \n", - "1 24242 1 80 1897537507 1857.0 11.0 4 \n", - "2 244481 0 16 1918505505 26.0 17.0 1 \n", - " 244485 0 11 1918505505 34.0 12.0 1 \n", - " 244483 0 9 1918505505 27.0 12.0 1 \n", - " 244482 1 68 1918505505 34.0 25.0 4 \n", + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS \\\n", + "event index \n", + "1 24242 1 80 1897537507 1857.0 11.0 \n", + "2 244481 0 16 1918505505 26.0 17.0 \n", + " 244485 0 11 1918505505 34.0 12.0 \n", + " 244483 0 9 1918505505 27.0 12.0 \n", + " 244482 1 68 1918505505 34.0 25.0 \n", "\n", - " time layer cell \n", - "event index \n", - "1 24242 46434.166667 1 4 \n", - "2 244481 664.166667 1 4 \n", - " 244485 860.000000 3 3 \n", - " 244483 685.000000 4 3 \n", - " 244482 870.833333 1 1 " + " time detector layer cell \n", + "event index \n", + "1 24242 46434.166667 4 1 4 \n", + "2 244481 664.166667 1 1 4 \n", + " 244485 860.000000 1 3 3 \n", + " 244483 685.000000 1 4 3 \n", + " 244482 870.833333 4 1 1 " ] }, "metadata": {}, @@ -1314,14 +1307,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 71, "metadata": {}, "outputs": [], "source": [ + "#!!! whole cell is a bit different\n", + "\n", "def findTrajectories(df):\n", " data = df.copy(deep=False)\n", - " data['t0_1'] = 0\n", - " data['t0_2'] = 0\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", @@ -1351,12 +1346,12 @@ "\n", " na_mask = sub_ev['t0_1'].notna()\n", " if na_mask.sum() > 0:\n", - " sub_ev.loc[na_mask,'t0_1'] = 0.5*(0.5*(sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==1).index, 't0_1'].iloc[0]+\n", - " sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==3).index, 't0_1'].iloc[0])+\n", - " sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==2).index, 't0_1'].iloc[0])\n", - " sub_ev.loc[na_mask, 't0_2'] = 0.5*(0.5*(sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==2).index, 't0_1'].iloc[0]+\n", - " sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==4).index, 't0_1'].iloc[0])+\n", - " sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==3).index, 't0_1'].iloc[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", @@ -1376,7 +1371,7 @@ "\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 # use old version???\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 !!! (deleted ???)\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", @@ -1386,7 +1381,7 @@ " 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: #??? change to \"subevents\"\n", + " if np.unique(ev[:,det_ind]).size != 1: #!!! (deleted ???)\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", @@ -1422,12 +1417,12 @@ " # 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", - " sub_ev[mask,t0_1_ind] = 0.5*(0.5*(sub_ev[sub_ev[mask,lay_ind]==1,time_ind][0]+\n", - " sub_ev[sub_ev[mask,lay_ind]==3,time_ind][0])+\n", - " sub_ev[sub_ev[mask,lay_ind]==2,time_ind][0]-T_M)\n", - " sub_ev[mask,t0_2_ind] = 0.5*(0.5*(sub_ev[sub_ev[mask,lay_ind]==2,time_ind][0]+\n", - " sub_ev[sub_ev[mask,lay_ind]==4,time_ind][0])+\n", - " sub_ev[sub_ev[mask,lay_ind]==3,time_ind][0]-T_M)\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" ] @@ -1443,7 +1438,7 @@ "\n", "$$T_{MAX}=\\frac{t_{1}+t_{3}}{2}+t_{2}$$\n", "\n", - "where $t_1 = t_{1'}-t_0$, $t_2 = t_{2'}-t_0$ and $t_3 = t_{3'}-t_0$, are the drift times of those three cells and $t_{i'}$ is the time measurement of the respective cell. The drift times can be calculated in this way because $t_0$ is essentially the same for each cell in one event, because the particle velocity of the muons(?) is much higher than the drift velocity of the electrons. Then the relation becomes:\n", + "where $t_1 = t_{1'}-t_0$, $t_2 = t_{2'}-t_0$ and $t_3 = t_{3'}-t_0$, are the drift times of those three cells and $t_{i'}$ is the time measurement of the respective cell. The drift times can be calculated in this way because $t_0$ is essentially the same for each cell in one event, because the particle velocity of the muons is much higher than the drift velocity of the electrons. Then the relation becomes:\n", "\n", "$$T_{MAX}=\\frac{t_{1'}-t_0+t_{3'}-t_0}{2}+t_{2'}-t_0$$\n", "\n", @@ -1456,7 +1451,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 72, "metadata": {}, "outputs": [ { @@ -1486,8 +1481,8 @@ " ORBIT_CNT\n", " BX_COUNTER\n", " TDC_MEAS\n", - " detector\n", " time\n", + " detector\n", " layer\n", " cell\n", " t0_123\n", @@ -1518,9 +1513,9 @@ " 1.897415e+09\n", " 2014.0\n", " 13.0\n", - " 1\n", " 50360.833333\n", " 1\n", + " 1\n", " 6\n", " 50230.833333\n", " 50365.625\n", @@ -1532,8 +1527,8 @@ " 1.897415e+09\n", " 2014.0\n", " 20.0\n", - " 1\n", " 50366.666667\n", + " 1\n", " 2\n", " 7\n", " 50230.833333\n", @@ -1546,8 +1541,8 @@ " 1.897415e+09\n", " 2026.0\n", " 13.0\n", - " 1\n", " 50660.833333\n", + " 1\n", " 2\n", " 7\n", " 50230.833333\n", @@ -1560,8 +1555,8 @@ " 1.897415e+09\n", " 2024.0\n", " 11.0\n", - " 1\n", " 50609.166667\n", + " 1\n", " 3\n", " 7\n", " 50230.833333\n", @@ -1574,8 +1569,8 @@ " 1.897415e+09\n", " 2026.0\n", " 9.0\n", - " 1\n", " 50657.500000\n", + " 1\n", " 4\n", " 8\n", " 50230.833333\n", @@ -1586,21 +1581,21 @@ "" ], "text/plain": [ - " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector \\\n", - "event index \n", - "1 5 0.0 24.0 1.897415e+09 2014.0 13.0 1 \n", - " 6 0.0 26.0 1.897415e+09 2014.0 20.0 1 \n", - " 7 0.0 26.0 1.897415e+09 2026.0 13.0 1 \n", - " 10 0.0 27.0 1.897415e+09 2024.0 11.0 1 \n", - " 11 0.0 29.0 1.897415e+09 2026.0 9.0 1 \n", + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS \\\n", + "event index \n", + "1 5 0.0 24.0 1.897415e+09 2014.0 13.0 \n", + " 6 0.0 26.0 1.897415e+09 2014.0 20.0 \n", + " 7 0.0 26.0 1.897415e+09 2026.0 13.0 \n", + " 10 0.0 27.0 1.897415e+09 2024.0 11.0 \n", + " 11 0.0 29.0 1.897415e+09 2026.0 9.0 \n", "\n", - " time layer cell t0_123 t0_234 \n", - "event index \n", - "1 5 50360.833333 1 6 50230.833333 50365.625 \n", - " 6 50366.666667 2 7 50230.833333 50365.625 \n", - " 7 50660.833333 2 7 50230.833333 50365.625 \n", - " 10 50609.166667 3 7 50230.833333 50365.625 \n", - " 11 50657.500000 4 8 50230.833333 50365.625 " + " time detector layer cell t0_123 t0_234 \n", + "event index \n", + "1 5 50360.833333 1 1 6 50230.833333 50365.625 \n", + " 6 50366.666667 1 2 7 50230.833333 50365.625 \n", + " 7 50660.833333 1 2 7 50230.833333 50365.625 \n", + " 10 50609.166667 1 3 7 50230.833333 50365.625 \n", + " 11 50657.500000 1 4 8 50230.833333 50365.625 " ] }, "metadata": {}, @@ -1633,8 +1628,8 @@ " ORBIT_CNT\n", " BX_COUNTER\n", " TDC_MEAS\n", - " detector\n", " time\n", + " detector\n", " layer\n", " cell\n", " t0_123\n", @@ -1665,8 +1660,8 @@ " 1.897538e+09\n", " 1857.0\n", " 11.0\n", - " 4\n", " 46434.166667\n", + " 4\n", " 1\n", " 4\n", " NaN\n", @@ -1680,9 +1675,9 @@ " 1.918506e+09\n", " 26.0\n", " 17.0\n", - " 1\n", " 664.166667\n", " 1\n", + " 1\n", " 4\n", " NaN\n", " NaN\n", @@ -1694,8 +1689,8 @@ " 1.918506e+09\n", " 34.0\n", " 12.0\n", - " 1\n", " 860.000000\n", + " 1\n", " 3\n", " 3\n", " NaN\n", @@ -1708,8 +1703,8 @@ " 1.918506e+09\n", " 27.0\n", " 12.0\n", - " 1\n", " 685.000000\n", + " 1\n", " 4\n", " 3\n", " NaN\n", @@ -1722,8 +1717,8 @@ " 1.918506e+09\n", " 34.0\n", " 25.0\n", - " 4\n", " 870.833333\n", + " 4\n", " 1\n", " 1\n", " NaN\n", @@ -1734,21 +1729,21 @@ "" ], "text/plain": [ - " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector \\\n", - "event index \n", - "1 24242 1.0 80.0 1.897538e+09 1857.0 11.0 4 \n", - "2 244481 0.0 16.0 1.918506e+09 26.0 17.0 1 \n", - " 244485 0.0 11.0 1.918506e+09 34.0 12.0 1 \n", - " 244483 0.0 9.0 1.918506e+09 27.0 12.0 1 \n", - " 244482 1.0 68.0 1.918506e+09 34.0 25.0 4 \n", + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS \\\n", + "event index \n", + "1 24242 1.0 80.0 1.897538e+09 1857.0 11.0 \n", + "2 244481 0.0 16.0 1.918506e+09 26.0 17.0 \n", + " 244485 0.0 11.0 1.918506e+09 34.0 12.0 \n", + " 244483 0.0 9.0 1.918506e+09 27.0 12.0 \n", + " 244482 1.0 68.0 1.918506e+09 34.0 25.0 \n", "\n", - " time layer cell t0_123 t0_234 \n", - "event index \n", - "1 24242 46434.166667 1 4 NaN NaN \n", - "2 244481 664.166667 1 4 NaN NaN \n", - " 244485 860.000000 3 3 NaN NaN \n", - " 244483 685.000000 4 3 NaN NaN \n", - " 244482 870.833333 1 1 NaN NaN " + " time detector layer cell t0_123 t0_234 \n", + "event index \n", + "1 24242 46434.166667 4 1 4 NaN NaN \n", + "2 244481 664.166667 1 1 4 NaN NaN \n", + " 244485 860.000000 1 3 3 NaN NaN \n", + " 244483 685.000000 1 4 3 NaN NaN \n", + " 244482 870.833333 4 1 1 NaN NaN " ] }, "metadata": {}, @@ -1797,7 +1792,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 75, "metadata": {}, "outputs": [ { @@ -1814,7 +1809,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1838,7 +1833,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEWCAYAAACNJFuYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3debwcVZ338c+XEAhL2EJgQgIJEUbBZSQTFp+MiIQZBSOLD4w4oOCLAWUbWeaBsCigDoIOMoPOwCAwiaJEZEBWZQ9RHIMhgCwBiTFKJBKQNUiQJL/njzqXNLfv7Vv3dldXL9/369WvrjpVXfXrurf71+ecqlOKCMzMzCqtVXYAZmbWepwczMysipODmZlVcXIwM7MqTg5mZlbFycHMzKo4OVhDSLpE0ucbtK1tJC2XNCzNz5b0j43YdtrejyQd1qjtDWK/X5b0nKQ/NHi7yyVNTNPrSbpR0kuSftCAbR8i6bb6o7R24+RgA5K0WNJrkl6R9KKkn0n6rKQ3/38i4rMR8aWc29qr1joR8buI2DAiVjUg9rMlXdlr+3tHxMx6tz3IOLYGTgZ2jIi/6GP5HpJWpy/65ZKWSLpa0s4DbTsdq0Vp9kBgS2BURBwk6XBJP60R16MV+1wlaUXF/OkR8d2I+Lshvm1rY04OltdHI2IkMB44DzgVuLzRO5G0dqO32SLGA3+MiGU11nk6IjYERgK7AY8DP5E0ta+V+zlW44FfRcTKPEFFxDtTctkQ+AlwXM98RJybZxvWoSLCDz9qPoDFwF69ynYBVgPvSvMzgC+n6c2Bm4AXgefJvnTWAr6TXvMasBw4BZgABHAE8DtgTkXZ2ml7s4GvAPcBLwHXA5ulZXsAS/qKF/gw8GfgjbS/hyq2949pei3gTOC3wDLg28DGaVlPHIel2J4DzqhxnDZOr382be/MtP290nteneKY0cdrq95HKv8mMK9iPoBjgSeB31SUbQec0+v9HgusAFal+RcH+Du/eVwqyg4Hftpr/8ek/b8CfAl4G/C/wMvA1cA6FetPAx5M/ws/A95TsexU4PdpO08AU8v+X/djzaNTf6VZwSLiPklLgPcDj/RafDKwBBid5nfLXhKflPR+si+gOwAkTUjrfADYgewLdMs+dvkp4EPAb8i+gC8CDh0gxh9LOhfYLiL6W/fw9Pgga5LDN4FPVqzzN8Dbgb8E7pN0bUQs6GNb3yBLEBOBUcBtwNKIuFzS3sCVETGuVsx9uBY4RtIGEfFqKtsf2JUs4VS+37MkReX7lfQq2fH+m0Hut5YPA38NbA3MB/4PcAjwR7Ik8QlgpqRJwBXAR4F5ZH+vGyS9nSzxHgfsHBFPp/+DYQ2M0erkZiWrx9PAZn2UvwGMAcZHxBsR8ZNIPxVrODsiXo2I1/pZ/p2IeCR9QX4e+PueDus6HQJ8PSIWRcRy4DTg4F5NNudExGsR8RDwEPBXvTeSYvk4cFpEvBIRi4ELeGuSGYqnAQGbVJR9JSKer3GsinZ+RLwcEY+S/TC4LR2/l4AfATul9Y4E/isi5kbEqsj6eV4n+7GwClgX2FHS8IhYHBG/LuG9WD+cHKweY8majXr7GrAQuE3SIknTc2zrqUEs/y0wnKz5ql5bpe1Vbntt3lp7qTy76E/Ahn1sZ3NgnT62NbbO+MaSNeW8WFE20LEq2jMV06/1Md9zfMYDJ6eTGF6U9CJZbWOriFgInACcDSyTNEvSVsWHbnk5OdiQpLNoxgJVZ8KkX84nR8REsiaFkyo6VfurQQxUs9i6YnobstrJc8CrwPoVcQ1jTXNWnu0+TfYlVrntlbz1Cy+P51JMvbf1+0Fup7cDgPkVTUow8HuqVOawy08B/xIRm1Q81o+IqwAi4nupuWt8ivP8EmO1XpwcbFAkbSRpGjCLrA394T7WmSZpO0ki66RclR6QfelOHMKuD5W0o6T1gS8C10R2quuvgBGSPiJpOFkn8LoVr3sGmFB52m0vVwEnStpW0obAucD3I+fZPj1SLFcD/yJppKTxwEnAlbVfWU2ZsZLOAv4ROH2w26jwDDBO0jp1bGOovgV8VtKu6T1tkP5OIyW9XdKektYl6zR/jTX/I9YCnBwsrxslvUL2a/AM4OvAp/tZd3vgDrIzZP4X+M+ImJ2WfQU4MzUz/PMg9v8dsjOi/gCMAP4JILVzHwNcRvYr/VWyzvAePReC/VHS/D62e0Xa9hyyzu4VwPGDiKvS8Wn/i8hqVN9L289rK0nLyY7bL4B3A3tERD0Xod0FPAr8QdJzdWxn0CJiHlm/wzeBF8iaGg9Pi9clOyX6ObK/6RbUlwStwTRwP6GZmXUb1xzMzKyKk4OZmVVxcjAzsypODmZmVqWth8/YfPPNY8KECWWHYd3uiSey57e/vdw4zHK6//77n4uI0bXWaevkMGHCBObNm1d2GNbt9tgje549u8wozHKT9NuB1nGzkpmZVWnrmoNZSzjzzLIjMGs4Jwezeu1V88Z2Zm3JzUpm9Xrwwexh1kFcczCr1wknZM/ukLYO4pqDmZlVcXIwM7MqTg5mZlbFycHMzKq4Q9qsDhOm38ykcdMAuLbkWMwaycnButKE6Te/Ob34vI/Uta3543aoNxyzluPkYF2jMiE00qQlC9JUfUnGrJU4OZjV6ZQ5M9PUYG6Jbdba3CFtZmZVnBzMzKyKm5XMcqi3A7uRHeBmzeCag5mZVXHNwaxOX5x6FAC3lByHWSM5OZjV6bEtJ5YdglnDOTmY1WnK4p57ObgvwTqHk4NZnY7/2aw0dUapcZg1kjukzcysipODmZlVcbOSvYXPxzczcM3BzMz64JqDdZxm135O/9BxACxyrcs6iJODWZ0WjRpXVVbU8OBmzeJmJbM6TV04l6kL55YdhllDueZgVmEoTVJH3ncdAHdut2shMZmVwcnB2pbPrDIrjpODdb1W7x9wErQyuM/BzMyqFF5zkDQMmAf8PiKmSdoWmAVsBswHPhkRf5a0LvBt4K+BPwIfj4jFRcdn1q5co7AiNaNZ6XPAAmCjNH8+cGFEzJJ0CXAEcHF6fiEitpN0cFrv402Iz+rQu0mmG7+kTpx2ctkhOFFYwxXarCRpHNk4xpeleQF7AtekVWYC+6fp/dI8afnUtH7XmzD95jcf1nqWbjSapRuNLjsMs4Yqus/h34BTgNVpfhTwYkSsTPNLgLFpeizwFEBa/lJa/y0kHSVpnqR5zz77bJGxm+UybcEcpi2YU3YYZg1VWLOSpGnAsoi4X9IePcV9rBo5lq0piLgUuBRg8uTJVcuts/VXeyqzVnXoA9kNQm/aYffSYjBrtCL7HKYA+0raBxhB1ufwb8AmktZOtYNxwNNp/SXA1sASSWsDGwPPFxif2ZC4ec+6QWHNShFxWkSMi4gJwMHAXRFxCHA3cGBa7TDg+jR9Q5onLb8rIlwzsI7m/iRrVWVcBHcqMEvSl4EHgMtT+eXAdyQtJKsxHFxCbB2tGWe0dNJZM934hd1Jfz+rT1OSQ0TMBman6UXALn2sswI4qBnxdAp/kAfWjV/wlfw/YkPl4TPM6nT0/qeVHYJZwzk5dCD/WmyuF9bfuOwQrEH82VnDycFaUjt9SA98+A4Arnn3XnVtp53es3U+Jwdrik7+4mtUcrDm6eT/x0ZxcugQ9XS85nntUD5M3d4ZbNbOnBxs0PylXzwfYyubk4OVytV7s9bk5NCi/MvRzMo0qOQgaS1gw4h4uaB4upoTQns6/KCzyw7BrOEGHFtJ0vckbSRpA+Ax4AlJ/6/40Mzaw4rhI1gxfETZYZg1VJ6aw44R8bKkQ4BbyMZGuh/4WqGRWddp15rTofOzuK+c5D4T6xx5ksNwScPJ7tj2zYh4Q5JHSy1Ju36BdrJpj/8EyJ8cWuFv6BMBbCB5ksN/AYuBh4A5ksYD7nMw6xCtkKyaYbDvs9sT6IDJISIuAi6qKPqtpA8WF5J1um75MiqLj681woDJQdKWwLnAVhGxt6Qdgfex5j4MZmZN1+2/7IuWp1lpBvDfwBlp/lfA93FyaAj/yhuYj1H5+vsb+Eu5c+VJDptHxNWSTgOIiJWSVhUcl7UAfynnc/A/nFd2CFbBNYrGyJMcXpU0CggASbsBLxUalZk1XD0dst2uG2tOeZLDScANwNsk3QuMBg4sNCqzNnLk3GsB+NauHys5knKV+Yu96FGJu1Ges5XmS/oA8HZAwBMR8UbhkVlD+B+/eFN/fR/g5JBH7//HTv7l3e7yDJ9xLNl4So9GxCPAhpKOKT40MzMrS55mpSMj4j96ZiLiBUlHAv9ZXFhm1inqrb3W01zlmvPQ5UkOa0lSRPR0SA8D1ik2LDPri7/sWlennSWVJzncClwt6RKyM5Y+C/y40KjM2siKtdctO4SW4yTW/vIkh1OBzwBHk3VI3wZcVmRQZu3k8L8/p+wQzBouz9lKq4GL08PMrHCueZQvz9hKU4CzgfFpfQEREROLDc2sPRx/71UAfGPKJ0qOpP10Wjt9J8nTrHQ5cCLZDX48bMYQ+UPQuab89iHAyaEZXKNonjzJ4aWI+FHhkVhT+UNmrcb/k60lT3K4W9LXgGuB13sKI2J+YVGZmVmp8iSHXdPz5IqyAPZsfDhmZu2jk2s7ec5W8l3fzGp4Yb2Nyg6hNJ385djthnwnuIjwzX7MgKMPOL3sEMwabsCB98juBHcrsFWa/xVwQlEBmZlZ+fIkh80j4mpgNWR3gsOntJq96ZR7ZnDKPTPKDsOsoXwnOLM6Tfr942WHYNZweWoOve8E923g+IFeJGmEpPskPSTpUUnnpPJtJc2V9KSk70taJ5Wvm+YXpuUThvyuzMysLjVrDpLWAkYAQ7kT3OvAnhGxXNJw4KeSfkSWbC6MiFlppNcjyMZtOgJ4ISK2k3QwcD7w8aG+MTOzsnTCiAg1aw5p0L0LImJlz53g8t4iNDLL0+zw9Oi5PuKaVD4T2D9N75fmScunSlL+t2JmZo2Sp1npNkn/dyhf1JKGSXoQWAbcDvwaeDF1agMsAcam6bHAU/Bmp/dLwKg+tnmUpHmS5j377LODDcms4ZaO3JylIzcvOwyzhsrTIX0SsAGwUtIK1ozKOuCVPxGxCnivpE2A64Ad+lotPfeVfKKqIOJS4FKAyZMnVy03a7YTP/rPZYdg1nA1aw6ptvDOiFgrItaJiI0iYmSexFApIl4EZgO7AZtI6klK44Cn0/QSYOu037WBjYHnB7MfMzNrjJo1h4gISdcBfz3YDUsaDbwRES9KWg/Yi6yT+W7gQGAWcBhwfXrJDWn+f9Pyu3ruW91pPORAZ/nCHZcC8MW9jio5ErPGydOs9HNJO0fELwa57THATEnDyGooV0fETZIeA2ZJ+jLwANn9IkjP35G0kKzGcPAg92dWih2XLSo7BLOGy5McPgh8RtJvgVdZ0+fwnloviohfAjv1Ub4I2KWP8hXAQXmCNjOzYuVJDnsXHoWZmbWUPMmhI9v9zcysf3mSw81kCUJkV0tvCzwBvLPAuMzaxqLNxg68klmbyXOzn3dXzkuaBHymsIjM2szpHx5wqDGztpOn5vAWETFf0s5FBNNpfMqqmbWrPHeCO6lidi1gEuBxK8ySc3/8DcA1COsseWoOIyumV5L1QfxPMeGYtZ+Jz/++7BDMGi5Pn8M5zQjEzMxax4Cjskq6PQ2c1zO/qaRbiw3LzMzKlKdZaXQaOA+AiHhB0hYFxmRm1jHa9cY/eZLDKknbRMTvACSNxxfGmb3psS0mlh2CWcPlSQ5nkN3i8540vzvg4SfNEo/Gap0oT4f0j9OFb7uRXSV9YkQ8V3hkZmZWmjwd0geQ3Zfhpoi4keyOcPsP9DqzbnHhjf/KhTf+a9lhmDVUnmalsyLiup6ZdPOes4AfFhdW+/JV0d1nzCuuSFvnGbDm0M86gx52w8zM2kee5DBP0tclvU3SREkXAvcXHZiZmZUnTw3geODzwPfJOqRvA44tMigzs07UTtc85Dlb6dV0v+cvRcSrTYjJrK3MH/uOskMwa7iayUHSMcB0YIM0vxw4PyL+swmxmbWFr37g8LJDMGu4fvscJJ0JTAP2iIhRETEK+CCwd1pmZmYdqlbN4ZPAX0XEip6CiFgk6e+Bh4AvFx1cu/Dpq93t4uvOBeDoA04vORKzxqnZrFSZGCrKXpO0uriQzNrLpq+9XHYIZg1X61TWJZKm9i6UtCewtLiQzMysbLVqDv8EXC/pp2TXNQSwMzAF2K8JsZmZWUn6rTlExKPAu4A5wARgYpp+V1pmZmYdKk+fwxVNisWsLd07/q/KDsHaUKtfEOcxkszq9I0pnyg7BLOGyzO2kpmZdZlaF8HdmZ7Pb144Zu1nxtVnMePqs8oOw6yhajUrjZH0AWBfSbPIBt17U0TMLzQyszYxYuXrZYdg1nC1ksMXyMZVGgd8vdeyAPYsKigzMytXv8khIq4BrpH0+Yj4UhNjMjOzkuUZsvtLkvYFdk9FsyPipmLDMjOzMg2YHCR9BdgF+G4q+pykKRFxWqGRmbWJO9+2S9khmDVcnuscPgK8NyJWA0iaCTwAODmYAd/a9WNlh2DWcHmvc9ikYnrjPC+QtLWkuyUtkPSopM+l8s0k3S7pyfS8aSqXpIskLZT0S0mTBvdWzMysUfIkh68AD0iakWoN9wPn5njdSuDkiNgB2A04VtKOZGdA3RkR2wN3pnmAvYHt0+Mo4OJBvROzksz63nRmfW/6wCuatZE8HdJXSZpNNiKrgFMj4g85XreUNLR3RLwiaQEwlmxE1z3SajOB2cCpqfzbERHAzyVtImlM2o6ZmTVRrrGV0hf0DUPdiaQJwE7AXGDLni/8iFgqaYu02ljgqYqXLUllb0kOko4iq1mwzTbbDDUkMzOrofCxlSRtCPwPcEJE1Lpllvooi6qCiEsjYnJETB49enSjwjQzswqFJgdJw8kSw3cj4tpU/IykMWn5GGBZKl8CbF3x8nHA00XGZ2ZmfauZHCStJemRoWxYkoDLgQURUTn8xg3AYWn6MOD6ivJPpbOWdgNecn+DtYOb3vF+bnrH+8sOw6yhBrrZz2pJD0naJiJ+N8htTwE+CTws6cFUdjpwHnC1pCOA3wEHpWW3APsAC4E/AZ8e5P7MSnHlpNa7UYtZvfJ0SI8BHpV0H/BqT2FE7FvrRRHxU/ruRwCY2sf6ARybIx6zljLijRUArBg+ouRIzBonT3I4p/AozNrYjB+cDcDB/3BeuYGYNVCe6xzukTQe2D4i7pC0PjCs+NDMzKwsA56tJOlI4Brgv1LRWOCHRQZlZmblytOsdCzZqKxzASLiyYoL17rWhOk3lx2CmVlh8lzn8HpE/LlnRtLa9HFxmpmZdY48NYd7JJ0OrCfpb4FjgBuLDcusfVzz7r3KDsGs4fIkh+nAEcDDwGfIrke4rMigzNqJk4N1ojxnK61OQ3XPJWtOeiJdk9BV3Mdg/dn0Ty8B8ML6uW51YtYW8twm9CPAJcCvyS5q21bSZyLiR0UHZ9YOLv7hVwBf52CdJU+z0gXAByNiIYCktwE3A04OZmYdKs/ZSst6EkOyiDUjqZqZWQfqt+Ygqeeu6Y9KugW4mqzP4SDgF02IzczMSlKrWemjFdPPAB9I088CmxYWkZlZl+l9wsvi88of6bff5BARHjLbLIcrd9qn7BDMGi7P2UrbAscDEyrXH2jIbrNucdMOu5cdglnD5Tlb6Ydkd3S7EVhdbDhm7WfMy88CsHQj39PcOkee5LAiIi4qPBKzNnXhTRcAvs7BOkue5PDvks4CbgNe7ymMiPmFRWVmZqXKkxzeTXYv6D1Z06wUad7MzDpQnuRwADCxcthuMzPrbHmukH4I2KToQMzMrHXkqTlsCTwu6Re8tc/Bp7KaAd/a5YCyQzBruDzJ4azCozBrY3dut2vZIViHqbxiuqyrpfPcz+GeZgTSinwPB8tj4h+XALBo1LiSIzFrnDxXSL/CmntGrwMMB16NiI2KDMysXZx76zcBX+dgnSVPzWFk5byk/YFdCovIzMxKl+dspbeIiB/iaxzMzDpanmalj1XMrgVMZk0zk5mZdaA8ZytV3tdhJbAY2K+QaMzMrCXk6XPwfR3MavjG/zm47BCsg5V1Wmut24R+ocbrIiK+VEA8Zm3n3gnvLTsEs4arVXN4tY+yDYAjgFGAk4MZsOMziwB4bMuJJUdina6ZtYhatwm9oGda0kjgc8CngVnABf29zqzbfOHOSwFf52CdpWafg6TNgJOAQ4CZwKSIeKEZgZmZWXlq9Tl8DfgYcCnw7ohY3rSoSuQhM8zMal8EdzKwFXAm8LSkl9PjFUkvNyc8MzMrQ7/JISLWioj1ImJkRGxU8RiZZ1wlSVdIWibpkYqyzSTdLunJ9LxpKpekiyQtlPRLSZMa8/bMzGwoBj18xiDMAD7cq2w6cGdEbA/cmeYB9ga2T4+jgIsLjMusob66+2F8dffDyg7DrKHyXCE9JBExR9KEXsX7AXuk6ZnAbODUVP7tiAjg55I2kTQmIpYWFZ9Zo8wft0PZIZg1XJE1h75s2fOFn563SOVjgacq1luSysxa3qQlC5i0ZEHZYZg1VLOTQ3/UR1mfg/tJOkrSPEnznn322YLDMhvYKXNmcsqcmWWHYdZQzU4Oz0gaA5Cel6XyJcDWFeuNA57uawMRcWlETI6IyaNHjy40WDOzbtXs5HAD0NNzdxhwfUX5p9JZS7sBL7m/wcysPIV1SEu6iqzzeXNJS4CzgPOAqyUdAfwOOCitfguwD7AQ+BPZMB1mZlaSIs9W+kQ/i6b2sW4AxxYVi5mZDU5hycGsW3xx6lFlh2DWcE4OZnXyUN3WiVrlVFaztjVl8YNMWfxg2WGYNZRrDngkVqvP8T+bBfiOcNZZXHMwM7MqTg5mZlbFycHMzKo4OZiZWRV3SJvV6fQPHVd2CGYN5+RgVqdFo8aVHYJZw7lZyaxOUxfOZerCuWWHYdZQrjmY1enI+64D4M7tdi05ErPGcc3BzMyqODmYmVkVJwczM6vStX0OHk/JzKx/XZsczBrlxGknlx2CWcM5OZjVaelGo8sOwazh3OdgVqdpC+YwbcGcssMwayjXHMzqdOgDtwBw0w67lxyJWeO45mBmZlWcHMzMrIqTg5mZVXFyMDOzKu6QNqvT0fufVnYIZg3n5GBWpxfW37jsEMwazs1KZnU68OE7OPDhO8oOw6yhnBzM6uTkYJ3IycHMzKo4OZiZWRUnBzMzq+LkYGZmVXwqq1mdDj/o7LJDMGs4JwezOq0YPqLsEMwazs1KZnU6dP7NHDrft521zuLkYFanaY//hGmP/6TsMMwaysnBzMyqtFRykPRhSU9IWihpetnxmJl1q5ZJDpKGAf8B7A3sCHxC0o7lRmVm1p1aJjkAuwALI2JRRPwZmAXsV3JMZmZdqZVOZR0LPFUxvwTYtfdKko4CjkqzyyU9McT9bQ48N8TXFs2xDU0psb2vZ+L8abVW83EbGsfWD51fc/FAsY0faPutlBzUR1lUFURcClxa986keRExud7tFMGxDY1jGxrHNjSdHlsrNSstAbaumB8HPF1SLGZmXa2VksMvgO0lbStpHeBg4IaSYzIz60ot06wUESslHQfcCgwDroiIRwvcZd1NUwVybEPj2IbGsQ1NR8emiKpmfTMz63Kt1KxkZmYtwsnBzMyqdGVyaLVhOiQtlvSwpAclzUtlm0m6XdKT6XnTJsVyhaRlkh6pKOszFmUuSsfxl5ImlRDb2ZJ+n47dg5L2qVh2WortCUkfKji2rSXdLWmBpEclfS6Vl37sasRW+rGTNELSfZIeSrGdk8q3lTQ3Hbfvp5NUkLRuml+Ylk8oIbYZkn5Tcdzem8qb+nlI+xwm6QFJN6X5xh23iOiqB1ln96+BicA6wEPAjiXHtBjYvFfZV4HpaXo6cH6TYtkdmAQ8MlAswD7Aj8iuUdkNmFtCbGcD/9zHujumv+26wLbpbz6swNjGAJPS9EjgVymG0o9djdhKP3bp/W+YpocDc9PxuBo4OJVfAhydpo8BLknTBwPfL/C49RfbDODAPtZv6uch7fMk4HvATWm+YcetG2sO7TJMx37AzDQ9E9i/GTuNiDnA8zlj2Q/4dmR+DmwiaUyTY+vPfsCsiHg9In4DLCT72xcV29KImJ+mXwEWkF31X/qxqxFbf5p27NL7X55mh6dHAHsC16Ty3set53heA0yV1NcFtEXG1p+mfh4kjQM+AlyW5kUDj1s3Joe+humo9UFphgBuk3S/suFBALaMiKWQfbiBLUqLrv9YWuVYHpeq8VdUNL+VFluqsu9E9kuzpY5dr9igBY5dahp5EFgG3E5WU3kxIlb2sf83Y0vLXwJGNSu2iOg5bv+SjtuFktbtHVsfcRfh34BTgNVpfhQNPG7dmBxyDdPRZFMiYhLZiLTHStq95HjyaoVjeTHwNuC9wFLgglReSmySNgT+BzghIl6utWofZYXG10dsLXHsImJVRLyXbFSEXYAdauy/1NgkvQs4DXgHsDOwGXBqs2OTNA1YFhH3VxbX2P+gY+vG5NByw3RExNPpeRlwHdkH5JmeKml6XlZehP3GUvqxjIhn0gd4NfAt1jR/ND02ScPJvny/GxHXpuKWOHZ9xdZKxy7F8yIwm6y9fhNJPRfpVu7/zdjS8o3J39TYiNg+nJrpIiJeB/6bco7bFGBfSYvJmsb3JKtJNOy4dWNyaKlhOiRtIGlkzzTwd8AjKabD0mqHAdeXEyHUiOUG4FPpLI3dgJd6mlCapVeb7gFkx64ntoPTWRrbAtsD9xUYh4DLgQUR8fWKRaUfu/5ia4VjJ2m0pE3S9HrAXmR9IncDB6bVeh+3nuN5IHBXpF7WJsX2eEWyF1mbfuVxa8rfNCJOi4hxETGB7Dvsrog4hEYet6J701vxQXZWwa/I2jbPKDmWiWRnhjwEPNoTD1l74J3Ak+l5sybFcxVZE8MbZL82jugvFrKq6n+k4/gwMLmE2L6T9v3L9AEYU7H+GSm2J4C9C47tb8iq6b8EHkyPfVrh2NWIrfRjB7wHeCDF8AjwhYrPxX1kneE/ANZN5SPS/MK0fGIJsd2VjtsjwJWsOaOpqZ+Hijj3YM3ZSg07bh4+w8zMqnRjs5KZmQ3AyUokqtQAAAMNSURBVMHMzKo4OZiZWRUnBzMzq+LkYGZmVZwcrKNIWpVGynw0jaZ5kqQ+/88lbSXpmor5q9KQCCdKOlzSVv287i3LJF0maccC3st6ku6RNGwIrz1O0qcbHZN1D5/Kah1F0vKI2DBNb0E2YuW9EXFWr/XWjjVj0CDpL8hG0Ryf5meTjVg6r4999LuskSQdC6wdEf8+hNeuT/a+d2p8ZNYNXHOwjhXZcCRHkQ0up/SL/weSbiQb6HCC1twb4jZgi1Tr+DwwGfhuml+vZ5uSDuy9TNJsSZPT8uWSzk+DKN4haZe0fJGkfdM6wyR9TdIvUk3lM/28hUNIV7hK2iNt5xpJj0v6brpCF0nnSXosbetf03v/E7BYUmEj0VpnW3vgVczaV0QsSs1KPaOhvg94T0Q8r7fe8GRfsqtMe27cMpU+agcRcY2k4yqX6a0jH28AzI6IUyVdB3wZ+FuyeyTMJLsS+QiyoRV2Vjai572SbotseGzSNtchu4p1ccW2dwLeSTZezr3AFEmPkQ198Y6IiJ7hHpJ5wPspcNgQ61yuOVg3qPz2vj0iihyo7c/Aj9P0w8A9EfFGmp6Qyv+ObAyeB8mGzh5FNn5Rpc2BF3uV3RcRSyIbKO/BtL2XgRXAZZI+BvypYv1lQJ/9JmYDcc3BOpqkicAq1oyG+mrBu3wj1nTkrQZeB4iI1VozWqaA4yPi1hrbeY1sPJxKr1dMryLrj1iZmo6mkg3AdhzZCJ2k17825HdiXc01B+tYkkaT3SrxmxVf2Hm9QnZLzcEuy+NW4Ghlw2gj6S/TiLxviogXgGGSeieIt1B2j4aNI+IW4ASyezP0+EvWjBhqNiiuOVinWS811wwHVpKNPPr12i/p0wzgEkmvAe+LiNf6WzaEbV9G1iQ0P3UqP0vft4G9jWxE1TtqbGskcH1KIgJOrFg2BThnCPGZ+VRWs1YlaSfgpIj4ZDNfawZuVjJrWRHxAHD3UC6CI+vQ/nyDQ7Iu4pqDmZlVcc3BzMyqODmYmVkVJwczM6vi5GBmZlWcHMzMrMr/B8llp6/C6wVVAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -1853,18 +1848,33 @@ "def make_hist(df):\n", " events = df.copy(deep=False)\n", "\n", - " events['drift_time'] = events['time'] - events['t0_123']\n", + " # !!! whole cell is a bit different\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", - " # 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_123'] = np.nan\n", "\n", - " events.loc[events['t0_123'].notna(),'drift_time'].plot(kind='hist', title='Distribution of Drift Times',\n", - " bins=100)\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", @@ -1884,7 +1894,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 76, "metadata": {}, "outputs": [ { @@ -1904,12 +1914,12 @@ "output_type": "stream", "text": [ "Mean Time Trigger:\n", - "\"useful rows\" / \"all rows\": 0.7480358723252831\n", - "\"useful events\" / \"all events\" 0.9521337729201057\n", + "\"useful rows\" / \"all rows\": 0.7248652838992968\n", + "\"useful events\" / \"all events\" 0.9690319274265875\n", "\n", " Scintillator Trigger\n", - "\"useful rows\" / \"all rows\": 0.6541494624855857\n", - "\"useful events\" / \"all events\" 0.9760179865101174\n" + "\"useful rows\" / \"all rows\": 0.6337090354499126\n", + "\"useful events\" / \"all events\" 0.9809257375381485\n" ] } ], @@ -1917,14 +1927,14 @@ "def print_useful_events(df):\n", " events = df.copy(deep=False)\n", "\n", - " # Ratio of \"useful events\" to all events\n", + " # Ratio of \"useful rows\" to all rows !!!\n", " try:\n", - " print('\"useful rows\" / \"all rows\": ', 1 - len(events[events['t0_123'].isna()])/events.shape[0])\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_123'].isna(),'time'].groupby('event').count()\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", @@ -1951,7 +1961,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 77, "metadata": {}, "outputs": [ { @@ -1993,12 +2003,11 @@ " ORBIT_CNT\n", " BX_COUNTER\n", " TDC_MEAS\n", - " detector\n", " time\n", + " detector\n", " layer\n", " cell\n", - " t0_123\n", - " t0_234\n", + " t0\n", " drift_time\n", " x\n", " \n", @@ -2017,7 +2026,6 @@ " \n", " \n", " \n", - " \n", " \n", " \n", " \n", @@ -2029,14 +2037,13 @@ " 1.897417e+09\n", " 452.0\n", " 17.0\n", - " 3\n", " 11314.166667\n", + " 3\n", " 1\n", " 4\n", - " 11126.666667\n", - " 11134.375\n", - " 187.500000\n", - " 10.096154\n", + " 11130.520833\n", + " 183.645833\n", + " 9.888622\n", " \n", " \n", " 411\n", @@ -2045,14 +2052,13 @@ " 1.897417e+09\n", " 450.0\n", " 9.0\n", - " 3\n", " 11257.500000\n", + " 3\n", " 2\n", " 4\n", - " 11126.666667\n", - " 11134.375\n", - " 130.833333\n", - " 7.044872\n", + " 11130.520833\n", + " 126.979167\n", + " 6.837340\n", " \n", " \n", " 417\n", @@ -2061,14 +2067,13 @@ " 1.897417e+09\n", " 458.0\n", " 9.0\n", - " 3\n", " 11457.500000\n", " 3\n", + " 3\n", " 4\n", - " 11126.666667\n", - " 11134.375\n", - " 330.833333\n", - " 17.814103\n", + " 11130.520833\n", + " 326.979167\n", + " 17.606571\n", " \n", " \n", " 409\n", @@ -2077,14 +2082,13 @@ " 1.897417e+09\n", " 445.0\n", " 24.0\n", - " 3\n", " 11145.000000\n", + " 3\n", " 4\n", " 4\n", - " 11126.666667\n", - " 11134.375\n", - " 18.333333\n", - " 0.987179\n", + " 11130.520833\n", + " 14.479167\n", + " 0.779647\n", " \n", " \n", " 414\n", @@ -2093,14 +2097,13 @@ " 1.897417e+09\n", " 459.0\n", " 24.0\n", - " 4\n", " 11495.000000\n", + " 4\n", " 1\n", " 10\n", - " 11118.958333\n", - " 11127.500\n", - " 376.041667\n", - " 20.248397\n", + " 11123.229167\n", + " 371.770833\n", + " 20.018429\n", " \n", " \n", " 410\n", @@ -2109,14 +2112,13 @@ " 1.897417e+09\n", " 447.0\n", " 8.0\n", - " 4\n", " 11181.666667\n", + " 4\n", " 2\n", " 10\n", - " 11118.958333\n", - " 11127.500\n", - " 62.708333\n", - " 3.376603\n", + " 11123.229167\n", + " 58.437500\n", + " 3.146635\n", " \n", " \n", " 412\n", @@ -2125,14 +2127,13 @@ " 1.897417e+09\n", " 455.0\n", " 27.0\n", - " 4\n", " 11397.500000\n", + " 4\n", " 3\n", " 9\n", - " 11118.958333\n", - " 11127.500\n", - " 278.541667\n", - " 14.998397\n", + " 11123.229167\n", + " 274.270833\n", + " 14.768429\n", " \n", " \n", " 416\n", @@ -2141,52 +2142,51 @@ " 1.897417e+09\n", " 452.0\n", " 16.0\n", - " 4\n", " 11313.333333\n", " 4\n", + " 4\n", " 10\n", - " 11118.958333\n", - " 11127.500\n", - " 194.375000\n", - " 10.466346\n", + " 11123.229167\n", + " 190.104167\n", + " 10.236378\n", " \n", " \n", "\n", "" ], "text/plain": [ - " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector \\\n", - "event index \n", - "1 415 1.0 16.0 1.897417e+09 452.0 17.0 3 \n", - " 411 1.0 14.0 1.897417e+09 450.0 9.0 3 \n", - " 417 1.0 15.0 1.897417e+09 458.0 9.0 3 \n", - " 409 1.0 13.0 1.897417e+09 445.0 24.0 3 \n", - " 414 1.0 104.0 1.897417e+09 459.0 24.0 4 \n", - " 410 1.0 102.0 1.897417e+09 447.0 8.0 4 \n", - " 412 1.0 99.0 1.897417e+09 455.0 27.0 4 \n", - " 416 1.0 101.0 1.897417e+09 452.0 16.0 4 \n", + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS \\\n", + "event index \n", + "1 415 1.0 16.0 1.897417e+09 452.0 17.0 \n", + " 411 1.0 14.0 1.897417e+09 450.0 9.0 \n", + " 417 1.0 15.0 1.897417e+09 458.0 9.0 \n", + " 409 1.0 13.0 1.897417e+09 445.0 24.0 \n", + " 414 1.0 104.0 1.897417e+09 459.0 24.0 \n", + " 410 1.0 102.0 1.897417e+09 447.0 8.0 \n", + " 412 1.0 99.0 1.897417e+09 455.0 27.0 \n", + " 416 1.0 101.0 1.897417e+09 452.0 16.0 \n", "\n", - " time layer cell t0_123 t0_234 drift_time \\\n", - "event index \n", - "1 415 11314.166667 1 4 11126.666667 11134.375 187.500000 \n", - " 411 11257.500000 2 4 11126.666667 11134.375 130.833333 \n", - " 417 11457.500000 3 4 11126.666667 11134.375 330.833333 \n", - " 409 11145.000000 4 4 11126.666667 11134.375 18.333333 \n", - " 414 11495.000000 1 10 11118.958333 11127.500 376.041667 \n", - " 410 11181.666667 2 10 11118.958333 11127.500 62.708333 \n", - " 412 11397.500000 3 9 11118.958333 11127.500 278.541667 \n", - " 416 11313.333333 4 10 11118.958333 11127.500 194.375000 \n", + " time detector layer cell t0 drift_time \\\n", + "event index \n", + "1 415 11314.166667 3 1 4 11130.520833 183.645833 \n", + " 411 11257.500000 3 2 4 11130.520833 126.979167 \n", + " 417 11457.500000 3 3 4 11130.520833 326.979167 \n", + " 409 11145.000000 3 4 4 11130.520833 14.479167 \n", + " 414 11495.000000 4 1 10 11123.229167 371.770833 \n", + " 410 11181.666667 4 2 10 11123.229167 58.437500 \n", + " 412 11397.500000 4 3 9 11123.229167 274.270833 \n", + " 416 11313.333333 4 4 10 11123.229167 190.104167 \n", "\n", " x \n", "event index \n", - "1 415 10.096154 \n", - " 411 7.044872 \n", - " 417 17.814103 \n", - " 409 0.987179 \n", - " 414 20.248397 \n", - " 410 3.376603 \n", - " 412 14.998397 \n", - " 416 10.466346 " + "1 415 9.888622 \n", + " 411 6.837340 \n", + " 417 17.606571 \n", + " 409 0.779647 \n", + " 414 20.018429 \n", + " 410 3.146635 \n", + " 412 14.768429 \n", + " 416 10.236378 " ] }, "metadata": {}, @@ -2231,12 +2231,11 @@ " ORBIT_CNT\n", " BX_COUNTER\n", " TDC_MEAS\n", - " detector\n", " time\n", + " detector\n", " layer\n", " cell\n", - " t0_123\n", - " t0_234\n", + " t0\n", " drift_time\n", " x\n", " \n", @@ -2255,7 +2254,6 @@ " \n", " \n", " \n", - " \n", " \n", " \n", " \n", @@ -2267,14 +2265,13 @@ " 1.918507e+09\n", " 2112.0\n", " 26.0\n", - " 3\n", " 52821.666667\n", + " 3\n", " 1\n", " 4\n", - " 52675.208333\n", - " 52670.416667\n", - " 146.458333\n", - " 7.886218\n", + " 52672.812500\n", + " 148.854167\n", + " 8.015224\n", " \n", " \n", " 246690\n", @@ -2283,14 +2280,13 @@ " 1.918507e+09\n", " 2118.0\n", " 20.0\n", - " 3\n", " 52966.666667\n", + " 3\n", " 2\n", " 4\n", - " 52675.208333\n", - " 52670.416667\n", - " 291.458333\n", - " 15.693910\n", + " 52672.812500\n", + " 293.854167\n", + " 15.822917\n", " \n", " \n", " 246681\n", @@ -2299,14 +2295,13 @@ " 1.918507e+09\n", " 2109.0\n", " 1.0\n", - " 3\n", " 52725.833333\n", " 3\n", + " 3\n", " 4\n", - " 52675.208333\n", - " 52670.416667\n", - " 50.625000\n", - " 2.725962\n", + " 52672.812500\n", + " 53.020833\n", + " 2.854968\n", " \n", " \n", " 246687\n", @@ -2315,14 +2310,13 @@ " 1.918507e+09\n", " 2121.0\n", " 22.0\n", - " 3\n", " 53043.333333\n", + " 3\n", " 4\n", " 4\n", - " 52675.208333\n", - " 52670.416667\n", - " 368.125000\n", - " 19.822115\n", + " 52672.812500\n", + " 370.520833\n", + " 19.951122\n", " \n", " \n", " 246686\n", @@ -2331,14 +2325,13 @@ " 1.918507e+09\n", " 2112.0\n", " 10.0\n", - " 4\n", " 52808.333333\n", + " 4\n", " 1\n", " 1\n", - " 52549.791667\n", - " 52546.666667\n", - " 258.541667\n", - " 13.921474\n", + " 52548.229167\n", + " 260.104167\n", + " 14.005609\n", " \n", " \n", " 246688\n", @@ -2347,14 +2340,13 @@ " 1.918507e+09\n", " 2109.0\n", " 6.0\n", - " 4\n", " 52730.000000\n", + " 4\n", " 2\n", " 1\n", - " 52549.791667\n", - " 52546.666667\n", - " 180.208333\n", - " 9.703526\n", + " 52548.229167\n", + " 181.770833\n", + " 9.787660\n", " \n", " \n", " 246680\n", @@ -2363,14 +2355,13 @@ " 1.918507e+09\n", " 2108.0\n", " 13.0\n", - " 4\n", " 52710.833333\n", + " 4\n", " 3\n", " 1\n", - " 52549.791667\n", - " 52546.666667\n", - " 161.041667\n", - " 8.671474\n", + " 52548.229167\n", + " 162.604167\n", + " 8.755609\n", " \n", " \n", " 246684\n", @@ -2379,52 +2370,51 @@ " 1.918507e+09\n", " 2112.0\n", " 18.0\n", - " 4\n", " 52815.000000\n", " 4\n", + " 4\n", " 1\n", - " 52549.791667\n", - " 52546.666667\n", - " 265.208333\n", - " 14.280449\n", + " 52548.229167\n", + " 266.770833\n", + " 14.364583\n", " \n", " \n", "\n", "" ], "text/plain": [ - " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS detector \\\n", - "event index \n", - "1 246685 1.0 16.0 1.918507e+09 2112.0 26.0 3 \n", - " 246690 1.0 14.0 1.918507e+09 2118.0 20.0 3 \n", - " 246681 1.0 15.0 1.918507e+09 2109.0 1.0 3 \n", - " 246687 1.0 13.0 1.918507e+09 2121.0 22.0 3 \n", - " 246686 1.0 68.0 1.918507e+09 2112.0 10.0 4 \n", - " 246688 1.0 66.0 1.918507e+09 2109.0 6.0 4 \n", - " 246680 1.0 67.0 1.918507e+09 2108.0 13.0 4 \n", - " 246684 1.0 65.0 1.918507e+09 2112.0 18.0 4 \n", - "\n", - " time layer cell t0_123 t0_234 \\\n", + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS \\\n", "event index \n", - "1 246685 52821.666667 1 4 52675.208333 52670.416667 \n", - " 246690 52966.666667 2 4 52675.208333 52670.416667 \n", - " 246681 52725.833333 3 4 52675.208333 52670.416667 \n", - " 246687 53043.333333 4 4 52675.208333 52670.416667 \n", - " 246686 52808.333333 1 1 52549.791667 52546.666667 \n", - " 246688 52730.000000 2 1 52549.791667 52546.666667 \n", - " 246680 52710.833333 3 1 52549.791667 52546.666667 \n", - " 246684 52815.000000 4 1 52549.791667 52546.666667 \n", + "1 246685 1.0 16.0 1.918507e+09 2112.0 26.0 \n", + " 246690 1.0 14.0 1.918507e+09 2118.0 20.0 \n", + " 246681 1.0 15.0 1.918507e+09 2109.0 1.0 \n", + " 246687 1.0 13.0 1.918507e+09 2121.0 22.0 \n", + " 246686 1.0 68.0 1.918507e+09 2112.0 10.0 \n", + " 246688 1.0 66.0 1.918507e+09 2109.0 6.0 \n", + " 246680 1.0 67.0 1.918507e+09 2108.0 13.0 \n", + " 246684 1.0 65.0 1.918507e+09 2112.0 18.0 \n", + "\n", + " time detector layer cell t0 drift_time \\\n", + "event index \n", + "1 246685 52821.666667 3 1 4 52672.812500 148.854167 \n", + " 246690 52966.666667 3 2 4 52672.812500 293.854167 \n", + " 246681 52725.833333 3 3 4 52672.812500 53.020833 \n", + " 246687 53043.333333 3 4 4 52672.812500 370.520833 \n", + " 246686 52808.333333 4 1 1 52548.229167 260.104167 \n", + " 246688 52730.000000 4 2 1 52548.229167 181.770833 \n", + " 246680 52710.833333 4 3 1 52548.229167 162.604167 \n", + " 246684 52815.000000 4 4 1 52548.229167 266.770833 \n", "\n", - " drift_time x \n", - "event index \n", - "1 246685 146.458333 7.886218 \n", - " 246690 291.458333 15.693910 \n", - " 246681 50.625000 2.725962 \n", - " 246687 368.125000 19.822115 \n", - " 246686 258.541667 13.921474 \n", - " 246688 180.208333 9.703526 \n", - " 246680 161.041667 8.671474 \n", - " 246684 265.208333 14.280449 " + " x \n", + "event index \n", + "1 246685 8.015224 \n", + " 246690 15.822917 \n", + " 246681 2.854968 \n", + " 246687 19.951122 \n", + " 246686 14.005609 \n", + " 246688 9.787660 \n", + " 246680 8.755609 \n", + " 246684 14.364583 " ] }, "metadata": {}, @@ -2434,32 +2424,31 @@ "source": [ "def prepare_for_vis(df):\n", " # Drop all not aligning hits\n", - " visual_evs = df.dropna(subset = ['t0_123']).copy() \n", - " \n", - " # Sort out events which are not in every layer, each event must have 4 layers\n", - " go_through_each_lay = visual_evs.loc[:,'layer'].groupby(level=0).nunique() == 4\n", + " visual_evs = df.dropna(subset = ['t0']).copy() #!!!\n", "\n", - " # Sort out events which are only registered in one detector\n", + " # deleted something !!!\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", + " # 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", + " # Combine the two masks\n", " index_mask = go_through_each_lay & multiple_detectors\n", "\n", - " # Apply mask to the dataframe\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", + " # 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", - "# Check if filter is applied\n", + "# !!! deleted comment\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", @@ -2481,7 +2470,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 121, "metadata": { "scrolled": true }, @@ -2524,7 +2513,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2560,7 +2549,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2585,7 +2574,7 @@ { "data": { "text/markdown": [ - "This trajectory presents a particle that has excited electrons in the cells, therefore a detection of multiple hits is present. Further filtration would be needed to avoid these kinds of path from showing up, nevertheless, we can use this to characterize the behavior of the particle as it traverses the detectors." + "This trajectory presents a particle that may !!!(I would add the 'may' because maybe its also just noise :D) has excited electrons in the cells, therefore a detection of multiple hits is present. Further filtration would be needed to avoid these kinds of path from showing up, nevertheless, we can use this to characterize the behavior of the particle as it traverses the detectors." ], "text/plain": [ "" @@ -2596,7 +2585,43 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "#### Event Path 4" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "Trajectory of event detected by scintillator trigger." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -2684,11 +2709,16 @@ "\n", "printmd(\"#### Event Path 2\")\n", "printmd(\"This event follows a trajectory of a particle through detectors 1 and 2.\")\n", - "plotEvent(events_mtt_vis.loc[163])\n", + "plotEvent(events_mtt_vis.loc[5]) # !!! had to change this because old one didnt go through 1 and 2\n", "\n", "printmd(\"#### Event Path 3\")\n", - "printmd(\"This trajectory presents a particle that has excited electrons in the cells, therefore a detection of multiple hits is present. Further filtration would be needed to avoid these kinds of path from showing up, nevertheless, we can use this to characterize the behavior of the particle as it traverses the detectors.\")\n", - "plotEvent(events_mtt_vis.loc[131])\n" + "printmd(\"This trajectory presents a particle that may !!!(I would add the 'may' because maybe its also just noise :D) has excited electrons in the cells, therefore a detection of multiple hits is present. Further filtration would be needed to avoid these kinds of path from showing up, nevertheless, we can use this to characterize the behavior of the particle as it traverses the detectors.\")\n", + "plotEvent(events_mtt_vis.loc[57]) # !!! also had to change\n", + "\n", + "if not trigger_st.empty: #!!! added one event for scintillator\n", + " printmd(\"#### Event Path 4\")\n", + " printmd(\"Trajectory of event detected by scintillator trigger.\")\n", + " plotEvent(events_st_vis.loc[1])" ] }, { @@ -2696,8 +2726,15 @@ "metadata": {}, "source": [ "#### Final Remarks: \n", - "The team has fulfilled the project goals through previous code. In the end, valid trajectories were found through the sorting and filtering of the data using the trigger channels, mean time and scintillator. " + "We have (!!! sounds strange to say 'the team' I think :D) fulfilled the project goals through the previous code. In the end, valid trajectories were found through the sorting and filtering of the data using the trigger channels, mean time and scintillator. " ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": {