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 new file mode 100644 index 0000000..6ba423a --- /dev/null +++ b/Data_Analysis.ipynb @@ -0,0 +1,2768 @@ +{ + "cells": [ + { + "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", + " - [INTRODUCTION: 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", + " \n", + " - [DETECTOR MATRIX](#7)\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "# Important imports\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from IPython.display import display\n", + "from os import listdir\n", + "from os.path import isfile, join, getsize\n", + "from IPython.display import Markdown, display\n", + "def printmd(string):\n", + " display(Markdown(string)) # for markdown purposes\n", + "from numba import vectorize, int64, int32, jit, njit, cuda, float64" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "\n", + "#
I. 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": 62, + "metadata": { + "scrolled": true + }, + "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 = False\n", + "\n", + "# Limit the amount of data we are accepting \n", + "if REAL_DATA == True:\n", + " mypath = '../data/Run000333/'\n", + "else:\n", + " mypath = '../data/Run000260/'\n", + "\n", + "max_mb = 256 # maximum size of data in mb to read\n", + "files = [join(mypath, f) for f in listdir(mypath) if isfile(join(mypath, f))]\n", + "mb = 0\n", + "for i in range(len(files)):\n", + " mb += getsize(files[i])/1024**2 # getsize returns size in bytes\n", + " if mb >= max_mb:\n", + " files = files[:(i-1)]\n", + " break\n", + "\n", + "# Concatenate the files and load the data\n", + "data = pd.concat([pd.read_csv(file) for file in files], axis = 0)\n", + "data.reset_index(inplace=True, drop=True) #This resets the index from 0 to onwards\n", + "# data = pd.read_csv(files[0])\n", + "\n", + "# Drop the 'HEAD' column\n", + "data.drop('HEAD', inplace=True, axis=1) # We remove the 'HEAD', inplace = True because we return nothing\n", + "\n", + "# Print the description of the data\n", + "printmd('## DESCRIPTION OF THE DATA')\n", + "print('Files concatenated:', '\\n', files, '\\n') # To check which files are read\n", + "print(data.info())\n", + "# display(data.describe())" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "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": [ + "#Visualize the first 10 entries of the file\n", + "printmd('## THE DATAFRAME')\n", + "printmd('The dataframe below presents the first 10 hits as presented in the raw data.')\n", + "display(data.head(10))" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "scrolled": true + }, + "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", + "df_1 = data[data['FPGA']==1]\n", + "\n", + "max_channel = data['TDC_CHANNEL'].max()\n", + "df_0.hist('TDC_CHANNEL', ax=ax1, bins=max_channel)#, range=(137,138))\n", + "df_1.hist('TDC_CHANNEL', ax=ax2, bins=max_channel)#, range=(137,138))\n", + "ax1.set_title('FPGA 0')\n", + "ax2.set_title('FPGA 1')\n", + "\n", + "printmd('## HISTOGRAM OF HITS PER TDC CHANNEL')\n", + "printmd('Remark: There are a lot of hits falling under the mean time trigger channel: 139.')\n", + "plt.show()\n", + "\n", + "# The difference between the channel distributions reflect the difference between the beams used in \n", + "# the calibration run and the physics run. \n", + "# Discontinuity and lesser amplitudes: shift in chamber" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "#
II. ADDING NEW COLUMNS: TIME, DETECTOR, LAYER, AND CELL\n", + " [Content Outline](#6)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## CONSTANTS: TRIGGER CHANNELS AND TMAX, L, Vd" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "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", + "#!!! deleted the detector -1 setting (useless)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " ## 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": 66, + "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", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEAStime
0111618974148841533.024.038345.000000
117118974148871650.021.041267.500000
21671897414914980.08.024506.666667
317018974149221287.08.032181.666667
405718974149222162.022.054068.333333
\n", + "
" + ], + "text/plain": [ + " 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": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "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": [ + "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. " + ] + }, + { + "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). " + ] + }, + { + "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": 67, + "metadata": {}, + "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": [ + "# Define function to add the detector, layer and cell columns \n", + "\n", + "@vectorize([int64(int64, int64)])\n", + "def giveDetector(fpga, channel):\n", + " if channel > 128:\n", + " return -1\n", + "\n", + " channel -= 1\n", + " return fpga*2 + 1 + channel // 64\n", + "\n", + "@vectorize([int64(int64)])\n", + "def giveLayer(channel):\n", + " if channel > 128:\n", + " return -1\n", + "\n", + " layer_map = {0 : 1,\n", + " 1 : 4,\n", + " 2 : 2,\n", + " 3 : 3}\n", + "\n", + " cell_index = channel % 64\n", + " layer = layer_map[cell_index % 4]\n", + " \n", + " return layer\n", + "\n", + "@vectorize([int64(int64)])\n", + "def giveCell(channel):\n", + " if channel > 128:\n", + " return -1\n", + "\n", + " channel -= 1\n", + " cell_index = channel % 64\n", + " cell = cell_index // 4 + 1\n", + "\n", + " return cell\n", + "\n", + "# Test of functions(one particular layer and detector arrangement)\n", + "if __name__ == '__main__':\n", + " first_cell_of_layer = 67\n", + " a = np.arange(first_cell_of_layer,first_cell_of_layer+16*4,4)\n", + " print('(Detectory, Layer, Cell) example: \\n',list(zip(giveDetector(0,a), giveLayer(a), giveCell(a))))\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": { + "scrolled": true + }, + "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_MEAStimedetectorlayercell
0111618974148841533.024.038345.0000004113
117118974148871650.021.041267.500000432
21671897414914980.08.024506.666667431
317018974149221287.08.032181.666667422
405718974149222162.022.054068.3333331415
\n", + "
" + ], + "text/plain": [ + " 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", + " 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": [ + "# Calculate the detector, layer & cell columns according to the previous functions\n", + "data['detector'] = giveDetector(data['FPGA'], data['TDC_CHANNEL'])\n", + "data['layer'] = giveLayer(data['TDC_CHANNEL'])\n", + "data['cell'] = giveCell(data['TDC_CHANNEL'])\n", + "\n", + "printmd(\"Dataframe now has new columns: time, detector, layer, and cell.\")\n", + "display(data.head(5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "#
III. FINDING EVENTS \n", + " [Content Outline](#6)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A trigger dataset is formed by applying a mask to the original data in order to isolate the hits that correspond to the TDC_CHANNEL 139. Similar lines of code are presented for the two other trigger channels, scintillator 1 and 2. " + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "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", + "
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", + "\n", + "display(trigger_mtt.head())\n", + "if not trigger_st.empty:\n", + " display(trigger_st.head())" + ] + }, + { + "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." + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": { + "scrolled": true + }, + "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_MEAStimedetectorlayercell
eventindex
1502418974149342014.013.050360.833333116
602618974149342014.020.050366.666667127
702618974149342026.013.050660.833333127
1002718974149342024.011.050609.166667137
1102918974149342026.09.050657.500000148
\n", + "
" + ], + "text/plain": [ + " 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 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": {}, + "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_MEAStimedetectorlayercell
eventindex
12424218018975375071857.011.046434.166667414
2244481016191850550526.017.0664.166667114
244485011191850550534.012.0860.000000133
24448309191850550527.012.0685.000000143
244482168191850550534.025.0870.833333411
\n", + "
" + ], + "text/plain": [ + " 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 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": {}, + "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", + "events_st = data.loc[data['ORBIT_CNT'].isin(trigger_st['ORBIT_CNT'])]\n", + "\n", + "def create_events(df):\n", + " events = df.copy(deep=False)\n", + " # We remove the events that are in channels above 128\n", + " events = events[events['TDC_CHANNEL'] <= 128]\n", + "\n", + " # We now group by orbit\n", + " events['event'] = events.groupby('ORBIT_CNT').ngroup()+1\n", + "\n", + " # Common orbits correspond to a single event\n", + " events.set_index(['event', events.index], inplace=True) # We make the events column an index\n", + " events.rename_axis(('event','index'), inplace=True)\n", + " events.sort_values(['ORBIT_CNT','detector','layer','cell'], inplace=True) # We sort according to these categories\n", + " \n", + " return events\n", + "\n", + "printmd('## Events in the Mean time Trigger')\n", + "events_mtt = create_events(events_mtt)\n", + "display(events_mtt.head(5))\n", + "if not trigger_st.empty:\n", + " printmd('## Events in the Scintillator Trigger')\n", + " events_st = create_events(events_st)\n", + " display(events_st.head(5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "#
IV. FINDING THE TRAJECTORIES\n", + " [Content Outline](#6)" + ] + }, + { + "cell_type": "code", + "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_123'] = 0\n", + " data['t0_234'] = 0\n", + " for i in data.index.get_level_values(0).unique():\n", + " present_detectors = data.loc[i,'detector'].unique()\n", + " ev = data.loc[i].copy(deep=False)\n", + " \n", + " for det in present_detectors:\n", + " sub_ev = ev.loc[ev['detector'] == det].copy(deep=False)\n", + " for l in range(1,4):\n", + " fst_layer = sub_ev.loc[sub_ev['layer'] == l, 'cell']\n", + " sec_layer = sub_ev.loc[sub_ev['layer'] == l+1, 'cell']\n", + "\n", + " # Find successor for each cell in layer\n", + " if l % 2 == 0:\n", + " successor_mask = fst_layer.isin(sec_layer) | fst_layer.isin(sec_layer+1)\n", + " else:\n", + " successor_mask = fst_layer.isin(sec_layer) | fst_layer.isin(sec_layer-1)\n", + " \n", + " # Drop whole sub_event if the current layer is completely empty\n", + " if successor_mask.sum() == 0:\n", + " sub_ev['t0_1'] = np.nan\n", + " sub_ev['t0_2'] = np.nan\n", + " break\n", + "\n", + " else:\n", + " # Drop rows where no successor was found\n", + " sub_ev.loc[(successor_mask==False).index, 't0_1'] = np.nan\n", + " sub_ev.loc[(successor_mask==False).index, 't0_2'] = np.nan\n", + "\n", + " na_mask = sub_ev['t0_1'].notna()\n", + " if na_mask.sum() > 0:\n", + " t_1 = sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==1).index, 't0_1'].iloc[0]\n", + " t_2 = sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==2).index, 't0_1'].iloc[0]\n", + " t_3 = sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==3).index, 't0_1'].iloc[0]\n", + " t_4 = sub_ev.loc[(sub_ev.loc[na_mask, 'layer']==4).index, 't0_1'].iloc[0]\n", + " sub_ev.loc[na_mask,'t0_1'] = 0.5*(0.5*(t_1 + t_3) + t_2)\n", + " sub_ev.loc[na_mask, 't0_2'] = 0.5*(0.5*(t_2 + t_4) + t_3)\n", + "\n", + " return data\n", + "\n", + "\n", + "# np.isin or in function of numpy/python is not supported by numba\n", + "# That's why we make a new .isin function to be able to use the @njit decorator\n", + "@njit\n", + "def myIsin(array_a, array_b):\n", + " result = np.zeros(len(array_a), dtype=np.bool_)\n", + " for i,a in enumerate(array_a):\n", + " for j,b in enumerate(array_b):\n", + " if a == b:\n", + " result[i] = True\n", + " break\n", + " return result\n", + "\n", + "\n", + "@njit\n", + "def findTrajectories_np(data, inds, columns):\n", + " det_ind, lay_ind, cel_ind, time_ind, t0_1_ind, t0_2_ind = columns #detector, layer, cel, time, 1t0, 2t0 are the columns !!! (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", + "\n", + " for i in range(len(ev_locs)-1):\n", + " \n", + " ev = data[ev_locs[i]:ev_locs[i+1]]\n", + "\n", + " # Every row registered in same detector?\n", + " if np.unique(ev[:,det_ind]).size != 1: #!!! (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", + " else:\n", + " sub_ev_locs = np.array([0,len(ev[:,det_ind])])\n", + "\n", + " for j in range(len(sub_ev_locs)-1):\n", + " sub_ev = ev[sub_ev_locs[j]:sub_ev_locs[j+1]]\n", + "\n", + " for l in range(1,4):\n", + " fst_layer = sub_ev[sub_ev[:,lay_ind]==l,cel_ind]\n", + " sec_layer = sub_ev[sub_ev[:,lay_ind]==l+1,cel_ind]\n", + "\n", + " # Find successor for each cell in layer\n", + " if l % 2 == 0:\n", + " successor_mask = myIsin(fst_layer, sec_layer) | myIsin(fst_layer, sec_layer+1)\n", + " else:\n", + " successor_mask = myIsin(fst_layer, sec_layer) | myIsin(fst_layer, sec_layer-1)\n", + "\n", + " # Drop whole sub_event if the current layer is completely empty\n", + " if np.any(successor_mask) == False:\n", + " sub_ev[:,t0_1_ind] = np.nan\n", + " sub_ev[:,t0_2_ind] = np.nan\n", + " break\n", + "\n", + " # Else mark rows where no predecessor was found\n", + " # if one cell was found with no predecessor\n", + " elif np.all(successor_mask) == False: # False has to be np.array([False]) so that numba broadcasts\n", + " idx = np.nonzero(successor_mask==np.array([False]))[0] + np.nonzero(sub_ev[:,lay_ind]==l)[0][0]\n", + " sub_ev[idx,t0_1_ind] = np.nan\n", + " sub_ev[idx,t0_2_ind] = np.nan\n", + "\n", + " # Compute t0 if a trajectory was found\n", + " mask = ~np.isnan(sub_ev[:,t0_1_ind]) # mask where values are numbers and not NaN\n", + " if np.any(mask) == True:\n", + " t_1 = sub_ev[sub_ev[mask,lay_ind]==1,time_ind][0]\n", + " t_2 = sub_ev[sub_ev[mask,lay_ind]==2,time_ind][0]\n", + " t_3 = sub_ev[sub_ev[mask,lay_ind]==3,time_ind][0]\n", + " t_4 = sub_ev[sub_ev[mask,lay_ind]==4,time_ind][0]\n", + " sub_ev[mask,t0_1_ind] = 0.5*(0.5*(t_1 + t_3) + t_2 - T_M)\n", + " sub_ev[mask,t0_2_ind] = 0.5*(0.5*(t_2 + t_4) + t_3 - T_M)\n", + "\n", + " return data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Computing $t_0$\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": 72, + "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", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEAStimedetectorlayercellt0_123t0_234
eventindex
150.024.01.897415e+092014.013.050360.83333311650230.83333350365.625
60.026.01.897415e+092014.020.050366.66666712750230.83333350365.625
70.026.01.897415e+092026.013.050660.83333312750230.83333350365.625
100.027.01.897415e+092024.011.050609.16666713750230.83333350365.625
110.029.01.897415e+092026.09.050657.50000014850230.83333350365.625
\n", + "
" + ], + "text/plain": [ + " 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 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": {}, + "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_MEAStimedetectorlayercellt0_123t0_234
eventindex
1242421.080.01.897538e+091857.011.046434.166667414NaNNaN
22444810.016.01.918506e+0926.017.0664.166667114NaNNaN
2444850.011.01.918506e+0934.012.0860.000000133NaNNaN
2444830.09.01.918506e+0927.012.0685.000000143NaNNaN
2444821.068.01.918506e+0934.025.0870.833333411NaNNaN
\n", + "
" + ], + "text/plain": [ + " 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 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": {}, + "output_type": "display_data" + } + ], + "source": [ + "def calculate_t0(df, numba_optimized=True):\n", + " events = df.copy(deep=False)\n", + "\n", + " if not numba_optimized:\n", + " events = findTrajectories(events)\n", + "\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", + " 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", + "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", + "#
IV. CHARACTERIZING THE EVENTS\n", + " [Content Outline](#6)\n", + "## CALCULATION OF DRIFT TIMES " + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "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", + " # !!! 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", + "\n", + " # Clean up data for events which have a negative drift time or a position over 21mm\n", + " events.loc[(events['drift_time']<0) | (events['x']>L/2), 't0'] = np.nan\n", + "\n", + " hist, edges,_ = plt.hist(events.loc[events['t0'].notna(), 'drift_time'], bins=100)\n", + " mid_edges = (edges[:-1] + edges[1:])/2\n", + "\n", + " plt.title('Distribution of Drift Times')\n", + " plt.axvline(mid_edges[np.argmax(hist)], c='r', ls='--')\n", + " plt.xlabel('Drift time (ns)')\n", + " plt.ylabel('Number of Occurrences')\n", + "\n", + " plt.show()\n", + "\n", + " return events\n", + "\n", + "\n", + "printmd('#### For the Mean time Trigger') \n", + "events_mtt = make_hist(events_mtt)\n", + "if not trigger_st.empty:\n", + " printmd('#### For the Scintillator Trigger') \n", + " events_st = make_hist(events_st)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## FILTERING THE DATA " + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "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.7248652838992968\n", + "\"useful events\" / \"all events\" 0.9690319274265875\n", + "\n", + " Scintillator Trigger\n", + "\"useful rows\" / \"all rows\": 0.6337090354499126\n", + "\"useful events\" / \"all events\" 0.9809257375381485\n" + ] + } + ], + "source": [ + "def print_useful_events(df):\n", + " events = df.copy(deep=False)\n", + "\n", + " # Ratio of \"useful rows\" to all rows !!!\n", + " try:\n", + " print('\"useful rows\" / \"all rows\": ', 1 - len(events[events['t0'].isna()])/events.shape[0]) #!!!\n", + " except ZeroDivisionError:\n", + " print('Error: Dataframe is empty')\n", + "\n", + " # Event is counted as useful if 4 or more times are available\n", + " event_groups = events.loc[events['t0'].notna(),'time'].groupby('event').count() #!!!\n", + " # print(event_groups) \n", + " try:\n", + " print('\"useful events\" / \"all events\"', (event_groups>3).sum()/len(event_groups)) # some events only have 3 (or below) hits\n", + " except ZeroDivisionError:\n", + " print('Error: Dataframe is empty')\n", + "\n", + "printmd('### Useful Events')\n", + "print('Mean Time Trigger:')\n", + "print_useful_events(events_mtt)\n", + "if not trigger_st.empty:\n", + " print('\\n','Scintillator Trigger')\n", + " print_useful_events(events_st)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now we filter the data 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": 77, + "metadata": {}, + "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", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEAStimedetectorlayercellt0drift_timex
eventindex
14151.016.01.897417e+09452.017.011314.16666731411130.520833183.6458339.888622
4111.014.01.897417e+09450.09.011257.50000032411130.520833126.9791676.837340
4171.015.01.897417e+09458.09.011457.50000033411130.520833326.97916717.606571
4091.013.01.897417e+09445.024.011145.00000034411130.52083314.4791670.779647
4141.0104.01.897417e+09459.024.011495.000000411011123.229167371.77083320.018429
4101.0102.01.897417e+09447.08.011181.666667421011123.22916758.4375003.146635
4121.099.01.897417e+09455.027.011397.50000043911123.229167274.27083314.768429
4161.0101.01.897417e+09452.016.011313.333333441011123.229167190.10416710.236378
\n", + "
" + ], + "text/plain": [ + " 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 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 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": {}, + "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", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEAStimedetectorlayercellt0drift_timex
eventindex
12466851.016.01.918507e+092112.026.052821.66666731452672.812500148.8541678.015224
2466901.014.01.918507e+092118.020.052966.66666732452672.812500293.85416715.822917
2466811.015.01.918507e+092109.01.052725.83333333452672.81250053.0208332.854968
2466871.013.01.918507e+092121.022.053043.33333334452672.812500370.52083319.951122
2466861.068.01.918507e+092112.010.052808.33333341152548.229167260.10416714.005609
2466881.066.01.918507e+092109.06.052730.00000042152548.229167181.7708339.787660
2466801.067.01.918507e+092108.013.052710.83333343152548.229167162.6041678.755609
2466841.065.01.918507e+092112.018.052815.00000044152548.229167266.77083314.364583
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS \\\n", + "event index \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", + " 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": {}, + "output_type": "display_data" + } + ], + "source": [ + "def prepare_for_vis(df):\n", + " # Drop all not aligning hits\n", + " visual_evs = df.dropna(subset = ['t0']).copy() #!!!\n", + "\n", + " # 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", + " multiple_detectors = visual_evs.loc[:,'detector'].groupby('event').nunique() > 1\n", + " \n", + " # Combine the two masks\n", + " index_mask = go_through_each_lay & multiple_detectors\n", + "\n", + " # Apply mask to the dataframe\n", + " visual_evs = visual_evs.loc[visual_evs.index.get_level_values(0).map(index_mask),:]\n", + "\n", + " # Reindex the event index level starting from 1\n", + " visual_evs.reset_index(level='event', inplace=True)\n", + " visual_evs.loc[:,'event'] = (visual_evs.loc[:,'event'].diff()!=0).cumsum()\n", + " visual_evs.set_index(['event', visual_evs.index], inplace=True)\n", + " \n", + " return visual_evs\n", + "\n", + "# !!! 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", + "if not trigger_st.empty:\n", + " events_st_vis = prepare_for_vis(events_st)\n", + " printmd('### Event 1 for the Scintillator Trigger')\n", + " display(events_st_vis.head(8))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "#
V. THE DETECTOR MATRIX \n", + " [Content Outline](#6)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "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 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": [ + "" + ] + }, + "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 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": "iVBORw0KGgoAAAANSUhEUgAAArkAAADMCAYAAAB3LrvvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3de5BcdZ338feHJEgCQW4J5EZQERaX2g08kUVRMlx2FyJEcdldxAusLLhbqIi4qE+eQq1dLMBLsCwXConGRy4WK3dqWQHNxMsuUAEmEggKroSEhCTAhruI5Pv8cX7D08bMzOlzTk+6f/m8qrqmZ+b0p7+n+8x3fn369PkpIjAzMzMzy8l2W7sAMzMzM7OmeZBrZmZmZtnxINfMzMzMsuNBrpmZmZllx4NcMzMzM8uOB7lmZmZmlh0Pcs3MzMwsOx7kWiWSHpX0kqTnJG2U9J+S/kFSqW1KUp+k1Q3VskjSvzSR1ZL5ZUkPp/V7SNKHmsw3MxtNuffsluzdJG2Q9NNO5Ftv8SDX6jg+IiYCM4ELgE8DC7duSe2TNGYLP34BOB54PXAK8DVJbx/VwszMmpVzzx50IbBitGqx7uZBrtUWEc9ExE3A3wKnSDoQQNLr0h7RxyStk3SppPGSdgRuBaZKej5dpkraTtJnJP1K0lOSrpG02+D9SHpH2vuwUdIqSadKOgN4P3Buyrk5LXuApP607AOS5rXkLJJ0iaR/l/QCcMQW1ulzEfFQRGyKiLuAnwBv6+DDaGY2KnLs2Wm5twEHAt/u0ENnPcaDXGtMRNwNrAbemX50IbAfMAvYF5gGnBcRLwDHAmsiYqd0WQN8HHgPMAeYCvwP8A0ASXtTNNmvA5NS5kBEXAZcCVyUco6XNA64GbgNmAx8DLhS0v4t5Z4MnA9MBIZ9W0vSeOCtwANVHxszs26TU89Oe3e/AXwUiAYeHsuAB7nWtDXAbpIEnA6cHRFPR8RzwBeBk4a57UeA+RGxOiJeBj4PnChpLMUr/zsi4uqIeCUinoqIgSFyDgV2Ai6IiN9GxI+AW4D3tSxzY0T8LO2p/c0I63QpsAz4wQjLmZn1mlx69seBuyLinvKrbrkbu7ULsOxMA56meOU+Abin6J0ACBjuWKqZwPWSNrX87FVgT2AG8KuSNUwFVkVEa87KVNugVWWCJH2J4u2vIyLCewfMLDc937MlTaUY5P6vkvdn2wgPcq0xkt5K0ZR+CjwJvAT8cUQ8voXFtzRgXAV8OCJ+toXsVcAhQ9z15llrgBmStmtpmnsDvxzh/je/zy9QvEU3JyKeHWl5M7NeklHPPgSYAjyYBujjgfGSngCmRcSrw9zWMubDFaw2STtLOg74HnBFRNyfGtU3gQWSJqflpkn6y3SzdcDukl7fEnUpcL6kmWn5SZLenX53JXC0pL+RNFbS7pJmtWS9sSXnLoqzI5wraZykPoozJXyvjXX6LMUxYH8eEU+VvZ2ZWbfLsGffCuxDcdzvLOA84D5glge42zYPcq2OmyU9R/Fqfj7wVeDvWn7/aeAR4E5JzwJ3APsDRMRDwNXAf6dP004FvgbcBNyWcu8E/iwt/xgwFziH4q21AeBP0/0sBN6Scm6IiN8C8yj2wj4J/CvwoXSfZX2RYk/Cwy2fJv7fbdzezKzbZNmzI+LliHhi8AI8A7ySrts2TD7M0MzMzMxy4z25ZmZmZpYdD3LNzMzMLDse5JqZmZlZdjzINTMzM7PseJBrZmZmZtnxINfMzMzMstPojGeSjgeOnzhx4un77bdfk9FmZqPigQcf4qUXn9fIS/Y+92wz63XD9eyOnCdXUu3QxYsXA3DEEUd0RY5rck3dmOOa2s+68Y6BYZe7auFXWLd21TYxyB00e/bsWLp0ae2c/v7+7Lefbqkp53VzTa6pNadOzy59uIKkMZLuk3RLO0Wamdnoc882s21dO8fkngWs6FQhZmbWqLZ7dt+iPvoW9ZVfvq+4mJl1o1KDXEnTgXcBl3e2HDMzq6tKz+5b1MeSlUtYsnJJqYFuXx8sWVJcPNA1s25Udk/uxcC5wKahFpB0hqSlkuof2GVmZnW01bM3bNgwepWZmY2SEQe5ko4D1kfEPcMtFxGXRcTsiJjdWHVmZtaWKj170qRJ9J/az5yZc5gzcw79p/aPeD/9/TBnTnHpH3lxM7NRV+YUYocB8yTNBXYAdpZ0RUR8oLOlmZlZBZV7dpnB7e8t397iZmajasQ9uRHx2YiYHhH7ACcBP/IA18ysO7lnm5kVGp0MYtDkvaZz8mnnDPn798ydw313L+Hss8+udT8LFiwAqJ3TZFbONeW8bq6pd2tqN+fi8+s/BrlZ9fg6zv4/Fw/5+/fMncOctx80Yk5fXx9lzr0u1T8Ncbdth66pd2vKed1yqKlOz250MojB2XP23Xff0x9++OHGcs3MRoskImKbmAzCPdvMet1wPXvEQa6kHYAfA6+j2PP7/Yj43HC32XPKjBhuT+6Zp53I6pWPZD1DR4415bxurql3a2py3Qb18iC3Uz173zdMb7LG2hnduP24pt6sKed1y72mQUP17DKHK7wMHBkRz0saB/xU0q0RcWcjlZmZWZNGpWcPnkt3qA+rDZ471x9OM7OtpcwHzyIink/fjkuX5o5xMDOzxoxGzx5p4ghPFGFm3aDsjGdjJA0A64HbI+KuLSzz2onFX3rxhabrNDOzktyzzcxKnl0hIl4FZknaBbhe0oERsXyzZS4DLoPi+K7GKzUzs1I63bP7T+0f9nCF/n4frmBmW19bpxCLiI2S+oFjgOUjLG5mZltRJ3v2SBNHeHBrZltbmWl9J6W9AUgaDxwNPNTpwszMrH3u2WZmhTJ7cqcA35E0hmJQfE1E3NLZsnr/5MWuyTWNRo5r2jpZXW6r9Owm5bz9dFuOa3JNOdfkySDMzFrsOWUG69au6tnz5LbDPdvMet1wPXvEPbmSZgD/F9gL2ARcFhFf29KyEXEzcLOk0+ue7Dvnkxe7JteU87p1e0033jFQO6ubVenZs2fPPr2J++7v789+++mWmnJeN9fkmlpz6vTsMocr/A44JyLulTQRuEfS7RHxYOV7NTOzTqndsz3Rg5nloMxkEGsj4t50/TlgBTCt04WZmVn76vZsT/RgZrkoNRnEIEn7AAcBw55YvJnSzMysjrI9e8OGDaNdmplZx5U+T66knYBrgU9ExLOb/771xOKSPBmEmdlW1E7Pnj179ms92xM9mFkuSg1yJY2jaJZXRsR1nS3JzMzqqNuzPdGDmeWgzGQQAhYCKyLiq50vyczMqnLPNjMrlDkm9zDgg8CRkgbSZW6dO12wYMFrJ/nthpwms3KuKed1azLLNfVmTkYa79lNyXk7bDLLNfVmTpNZrqkZngzCzKyFJCLCk0GYmfWA4Xr2iINcSd8CjgPWR8SBZe5wzykz4uTTzhny92eediKrVz6S9cmLc6wp53VzTb1bU5PrNqjXB7nt9u0yPXvfN0xvsr7aGd24/bim3qwp53XLvaZBQ/XsMocrLAKOaaQKMzMbDYtw3zazbVyZySB+DDw9CrWYmVkDOtm3+xb1bXGSiCGX7/OkEWa2dbQ1GYSZmW27RpoN7Q+W7/PsaGa29TQ2yG2dPeelF19oKtbMzDrAPdvMcld6xrORtM6es+eUGZ7xzMysi1Xp2SPNhvYHy/d7djQz23oaG+SamVn+ygxuf2/59hY3M2tMmRnPrgb+C9hf0mpJp3W+LDMzq8p928ys4ckgXguVNgArG4jaA3iyi3KazHJNo5vTZFa35TSZ5ZpgZkRMauj+ekIX9uwms3KuKed1azLLNY1uTpNZtXp2Rwa5TZG0NCJmd0uOa3JN3ZjjmrZOlv2hbnyucq4p53VzTa6piRyfQszMzMzMsuNBrpmZmZllp9sHuZd1WU6TWa5pdHOazOq2nCazXJPV0Y3PVc415bxuTWa5ptHNaTKrVk5XH5NrZmZmZlZFt+/JNTMzMzNrmwe5ZmZmZpadrhzkSvqWpPWSltfMmSFpsaQVkh6QdFaNrB0k3S1pWcr6Qs3axki6T9ItNTIelXS/pAFJS2vWs4uk70t6KD1eb6uQsX+qZfDyrKRP1Kjp7PRYL5d0taQdKuaclTIeaLeeLW2LknaTdLukh9PXXSvm/HWqaZOk0qdIGSLrS+m5+7mk6yXtUjHnn1PGgKTbJE2tWlPL7z4lKSTtUbGmz0t6vGW7mlu1Hkkfk/SL9LhfVGbdbGTu2W3lNNK3m+jZKaexvu2e3VaWe3bJmmr17YjougtwOHAwsLxmzhTg4HR9IvBL4C0VswTslK6PA+4CDq1R2yeBq4BbamQ8CuzR0GP+HeDv0/XtgV1q5o0BnqA4SXOV208Dfg2MT99fA5xaIedAYDkwgWIa6zuAN9fZFoGLgM+k658BLqyYcwCwP9APzK5Z018AY9P1C2vUtHPL9Y8Dl1atKf18BvADiokGRtxWh6jp88Cn2nzet5RzRHr+X5e+n1xnG/dl5Oe/Qk7WPTvlNNK3m+7ZKady33bPbjvLPbtcVq2+3ZV7ciPix8DTDeSsjYh70/XngBUUf4hVsiIink/fjkuXSp/akzQdeBdweZXbN03SzhQb10KAiPhtRGysGXsU8KuIqDOL0lhgvKSxFA1vTYWMA4A7I+LFiPgdsAQ4oeyNh9gW303xD4b09T1VciJiRUT8omwtI2TdltYP4E5gesWcZ1u+3ZGS2/gwf7MLgHMbyGnLEDn/CFwQES+nZdbXvR8ruGePrg71bKjft92zy2e5Z5fLqtW3u3KQ2wmS9gEOong1XzVjjKQBYD1we0RUzbqYYiPaVLWWJIDbJN0j6YwaOW8ENgDfTm/HXS5px5q1nQRcXfXGEfE48GXgMWAt8ExE3FYhajlwuKTdJU0A5lK8Uq1jz4hYm+pcC0yumde0DwO3Vr2xpPMlrQLeD5xXI2ce8HhELKua0eKj6S25b5V5q3EI+wHvlHSXpCWS3tpAXdYhmfZsaKZvd6JnQ42+7Z5di3v20Gr17W1ikCtpJ+Ba4BObveppS0S8GhGzKF5xHSLpwAq1HAesj4h7qtbR4rCIOBg4FjhT0uEVc8ZSvEVwSUQcBLxA8ZZOJZK2B+YB/1YjY1eKV99vAKYCO0r6QLs5EbGC4q2g24H/AJYBvxv2Rj1M0nyK9buyakZEzI+IGSnjoxXrmADMp0bDbXEJ8CZgFsU/z69UzBkL7AocCvwTcI0kNVCfNSzjng3N9O1GezbU79vu2dW4Z4+oVt/OfpAraRxFs7wyIq5rIjO9LdQPHFPh5ocB8yQ9CnwPOFLSFRXrWJO+rgeuBw6pkgOsBla37OX4PkUDrepY4N6IWFcj42jg1xGxISJeAa4D3l4lKCIWRsTBEXE4xVshD9eoC2CdpCkA6WtXvO0t6RTgOOD9kQ5equkq4K8q3vZNFP/slqVtfTpwr6S92g2KiHVpsLIJ+Cb1tvPr0tvYd1PslRvxgxU2unLu2amWJvp20z0b6vdt9+w2uWeXUqtvZz3ITaP9hcCKiPhqzaxJg59+lDSe4g/6oXZzIuKzETE9IvaheGvoRxHR9qtdSTtKmjh4neIg9kqfbI6IJ4BVkvZPPzoKeLBKVvI+ahyqkDwGHCppQnoej6I4Pq9tkianr3sD722gtpuAU9L1U4Aba+bVJukY4NPAvIh4sUbOm1u+nUeFbRwgIu6PiMkRsU/a1ldTfKDoiQo1TWn59gQqbufADcCRKXM/ig/rPFkxyzog556d6mikb3egZ0P9vu2e3Qb37NLq9e1o89Nvo3Gh2KDXAq9QPNCnVcx5B8XxTz8HBtJlbsWsPwHuS1nLgfMaWM8+Kn5Sl+KYrGXp8gAwv2Yts4Claf1uAHatmDMBeAp4fQOPzxco/mCXA98lfbqyQs5PKP4BLAOOqrstArsDP6TYu/BDYLeKOSek6y8D64Af1KjpEWBVy3Y+4idsh8i5Nj3ePwduBqZVrWmz3z9KuU/qbqmm7wL3p5puAqZUzNkeuCKt373AkXW3UV/KPf9t5GTbs9PtG+vbTfXslNVI33bPbivLPbtcVq2+7Wl9zczMzCw7WR+uYGZmZmbbJg9yzczMzCw7HuSamZmZWXY8yDUzMzOz7HiQa2ZmZmbZ8SDXzMzMzLLjQa6ZmZmZZceDXDMzMzPLjge5ZmZmZpYdD3LNzMzMLDse5JqZmZlZdjzINTMzM7PseJBrZmZmZtnxINfMzMzMsuNBrpmZmZllx4NcMzMzM8uOB7lmZmZmlh0Pcs3MzMwsOx7kmpmZmVl2PMg1MzMzs+x4kGtmZmZm2fEg18zMzMyy40GumZmZmWXHg1wzMzMzy44HuWZmZmaWHQ9yzczMzCw7HuSamZmZWXY8yDUzMzOz7HiQa2ZmZmbZ8SDXzMzMzLLjQa6ZmZmZZceDXDMzMzPLjge5ZmZmZpYdD3LNzMzMLDse5JqZmZlZdjzINTMzM7PseJBrZmZmZtnxINfMzMzMsuNBrpmZmZllx4NcMzMzM8uOB7lmZmZmlh0Pcs3MzMwsOx7kmpmZmVl2PMg1MzMzs+x4kGtmZmZm2fEg18zMzMyy40GumZmZmWXHg1wzMzMzy44HuWZmZmaWHQ9yrRJJj0p6SdJzkjZK+k9J/yCp1DYlqU/S6oZqWSTpX5rIasn8m7ROL0rqbzLbzGy0bQM9+yJJqyQ9K2mlpPlN5ltv8iDX6jg+IiYCM4ELgE8DC7duSe2TNGYLP34auJhivczMcpBzz14I/FFE7Ay8HThZ0ntHtzLrNh7kWm0R8UxE3AT8LXCKpAMBJL1O0pclPSZpnaRLJY2XtCNwKzBV0vPpMlXSdpI+I+lXkp6SdI2k3QbvR9I70t6HjekV+6mSzgDeD5ybcm5Oyx4gqT8t+4CkeS05iyRdIunfJb0AHLGFdbojIq4B1nTysTMzG22Z9uxfRMQLLT/aBOzbgYfPeogHudaYiLgbWA28M/3oQmA/YBZFs5kGnJca0bHAmojYKV3WAB8H3gPMAaYC/wN8A0DS3hRN9uvApJQ5EBGXAVcCF6Wc4yWNA24GbgMmAx8DrpS0f0u5JwPnAxOBn3bi8TAz62a59ew04H4+rdOOwFU1HyLrcR7kWtPWALtJEnA6cHZEPB0RzwFfBE4a5rYfAeZHxOqIeBn4PHCipLEUr/zviIirI+KViHgqIgaGyDkU2Am4ICJ+GxE/Am4B3teyzI0R8bOI2BQRv6mzwmZmPSybnh0RF1AMgg8Gvgs8U+4hsFyN3doFWHamURzPOgmYANxT9E4ABGzpWKpBM4HrJW1q+dmrwJ7ADOBXJWuYCqyKiNaclam2QatKZpmZ5Syrnh0RAdwn6S+BLwCfLFmDZciDXGuMpLdSNKWfAk8CLwF/HBGPb2Hx2MLPVgEfjoifbSF7FXDIEHe9edYaYIak7Vqa5t7AL0e4fzOzbUbmPXss8KY2b2OZ8eEKVpuknSUdB3wPuCIi7k+N6pvAAkmT03LT0qtrgHXA7pJe3xJ1KXC+pJlp+UmS3p1+dyVwdDq111hJu0ua1ZL1xpacu4AXKD7YME5SH3B8qq/sOo2RtANFo9xO0g7puDEzs56WW89OH4D7iKRdVTgEOBP4YTuPi+XHg1yr42ZJz1G8mp8PfBX4u5bffxp4BLhT0rPAHcD+ABHxEHA18N/p07RTga8BNwG3pdw7gT9Lyz8GzAXOoXhrbQD403Q/C4G3pJwbIuK3wDyKD0o8Cfwr8KF0n2V9kGKvxiUUH8p4ieIfgJlZr8q5Z59AcXjEc8AVFB94+3obt7cMqTh8xczMzMwsH96Ta2ZmZmbZ8SDXzMzMzLLjQa6ZmZmZZceDXDMzMzPLjge5ZmZmZpYdD3LNzMzMLDuNzngm6Xjg+IkTJ56+3377NRltZjYqHnjwIV568XmNvGTvc882s143XM8ufZ5cSWOApcDjEXHcCMvWPvnu4sWLATjiiCO6Isc1uaZuzHFN7WfdeMfAsMtdtfArrFu7qucHub3as5vMWrx4MX19fbXrGdTf398123S3Pt6uyTU1XVOdnt3O4QpnASvaWN7MzLYe92wz26aVGuRKmg68C7i8s+WYmVld7tn/38ATA/Qt6quV0dcHA8PvTDKzLlR2T+7FwLnApg7WYmZmzXDPBtgLNv5mI0tWLqk80O3rgyVLYONGgFkNFmdmnTbiIFfSccD6iLhnhOXOkLRU0tLGqjMzs7a4Z5uZFcrsyT0MmCfpUeB7wJGSrth8oYi4LCJmR8Tshms0M7Py3LMHPQG77LALc2bOof/U/koR/f0wZw7ssguAj1kw6yUjDnIj4rMRMT0i9gFOAn4UER/oeGVmZtY29+zfN2uvWZUHuIP6+2GWj1Qw6zlbZTKIBQsWsGDBgq7JaTIr55pyXrcms1xTb+bY0LrxuerG5z3nxynnmnJetyazurGmkZQ+T26psHRi8X333ff0hx9+uLFcM7PRIomI6Pnz5Jbhnm1mvW64nj3iIFfSDsCPgddRzJD2/Yj43HC32XPKjDj5tHOG/P2Zp53I6pWPZH3y4hxrynndXFPv1tTkug3q5UGue3a1nKYmjeimCSOazMq5ppzXLfeaBg3Vs8tM6/sycGREPC9pHPBTSbdGxJ2NVGZmZk1yzzYzo8QgN4pdvc+nb8elS3PHOJiZWWPcs5s1eH7d/lP7GdzZ29+/taoxs3aU2ZM7OAf6PcC+wDci4q6OVmVmZpW5Zzejb1EfS1YuAWCXPxrgmV8Up1jo6/NA16wXlDq7QkS8GhGzgOnAIZIO3HyZ1hOLv/TiC03XaWZmJblnm5m1eQqxiNgI9APHbOF3r51YfPyEHRsqz8zMqnLPrqf/1H7mzJzDnJlz2PjQLObMKSaG8F5cs94w4uEKkiYBr0TERknjgaOBCztemZmZtc09u1mtE0l4cGvWW8ockzsF+E46xms74JqIuKWzZfHaSYLPPvvsrshxTa6pG3Nc09bJ6nI93bObzOrG57wb1801uaZca/JkEGZmLTwZhJlZ7xiuZ5c6u0JZEXEzcLOk06V6/yNyPnmxa3JNOa9bt9d04x0Dwy43ea/pte+rV3Rjz24ya/HixY1N8gDdNdFDtz7ersk1NV1TnZ494gfPJM2QtFjSCkkPSDqrzTrNzGyUuGebmRXK7Mn9HXBORNwraSJwj6TbI+LBDtdmZmbtc8/eTOuEDm3drriZP3Bm1qNG3JMbEWsj4t50/TlgBTCt04WZmVn73LN/38ATAyxZuYQlK5e8Ntgto68PliwpLg0e8WBmo6itY3Il7QMcBPzB7DmSzgDOaKQqMzOrzT3bzLZlpQe5knYCrgU+ERHPbv77iLgMuCwt63nSzcy2Ivfswqy9ZjFn5hygvcMV+vt9uIJZrys1yJU0jqJZXhkR13W2JDMzq8M9+/e1eyzua7erdjMz6xJlzq4gYCGwIiK+2vmSzMysKvdsM7PCiINc4DDgg8CRkgbSZW6dO12wYMFrM1l0Q06TWTnXlPO6NZnlmnozJyPu2VtJzo9TzjXlvG5NZnVjTSPxjGdmZi0845mZWe8YrmePOMiV9C3gOGB9RBxY5g73nDIjTj7tnCF/f+ZpJ7J65SNZz9CRY005r5tr6t2amly3Qb0+yG23b7tn09jMaN00K1qTWTnXlPO65V7ToKF6dpnDFRYBxzRShZmZjYZFuG/X0reob8jz6vb1+dy5Zr2gzGQQPwaeHoVazMysAe7b9fQt6htyAglPEmHWO8rsyS1F0hmSlkpa+tKLLzQVa2ZmHeCebWa5a2vGs+G0nlh8zykzsj2xuJlZDtyzh9Z/av9re3A3P8euJ4kw6x2NDXLNzMxyMdwEEh7cmvWGxg5XMDMzMzPrFmVmPLsa+C9gf0mrJZ3W+bLMzKwq920zs4Yng3gtVNoArGwgag/gyS7KaTLLNY1uTpNZ3ZbTZJZrgpkRMamh++sJXdizm8zKuaac163JLNc0ujlNZtXq2R0Z5DZF0tKImN0tOa7JNXVjjmvaOln2h7rxucq5ppzXzTW5piZyfEyumZmZmWXHg1wzMzMzy063D3Iv67KcJrNc0+jmNJnVbTlNZrkmq6Mbn6uca8p53ZrMck2jm9NkVq2crj4m18zMzMysim7fk2tmZmZm1jYPcs3MzMwsO105yJX0LUnrJS2vmTND0mJJKyQ9IOmsGlk7SLpb0rKU9YWatY2RdJ+kW2pkPCrpfkkDkpbWrGcXSd+X9FB6vN5WIWP/VMvg5VlJn6hR09npsV4u6WpJO1TMOStlPNBuPVvaFiXtJul2SQ+nr7tWzPnrVNMmSaVPkTJE1pfSc/dzSddL2qVizj+njAFJt0maWrWmlt99SlJI2qNiTZ+X9HjLdjW3aj2SPibpF+lxv6jMutnI3LPbymmkbzfRs1NOY33bPbutLPfskjXV6tsR0XUX4HDgYGB5zZwpwMHp+kTgl8BbKmYJ2CldHwfcBRxao7ZPAlcBt9TIeBTYo6HH/DvA36fr2wO71MwbAzxBcZLmKrefBvwaGJ++vwY4tULOgcByYAIwFrgDeHOdbRG4CPhMuv4Z4MKKOQcA+wP9wOyaNf0FMDZdv7BGTTu3XP84cGnVmtLPZwA/oJhoYMRtdYiaPg98qs3nfUs5R6Tn/3Xp+8l1tnFfRn7+K+Rk3bNTTiN9u+menXIq92337Laz3LPLZdXq2125Jzcifgw83UDO2oi4N11/DlhB8YdYJSsi4vn07bh0qfSpPUnTgXcBl1e5fdMk7UyxcS0EiIjfRsTGmrFHAb+KiDqzKI0FxksaS9Hw1lTIOAC4MyJejIjfAUuAE8reeIht8d0U/2BIX99TJSciVkTEL8rWMkLWbWn9AO4EplfMebbl2x0puY0P8ze7ADi3gZy2DJHzj8AFEfFyWmZ93fuxgnv26OpQz4b6fds9u3yWe3a5rFp9uysHuZ0gaR/gIIpX81UzxkgaANYDt0dE1ayLKTaiTVVrSQK4TdI9ks6okfNGYAPw7fR23OWSdqxZ20nA1VVvHBGPA18GHgPWAs9ExG0VopYDh0vaXdIEYC7FK9U69oyItanOtcDkmnlN+zBwa9UbSzpf0irg/cB5NXLmAY9HxLKqGS0+mt6S+1aZt4RTRn8AAAN/SURBVBqHsB/wTkl3SVoi6a0N1GUdkmnPhmb6did6NtTo2+7ZtbhnD61W394mBrmSdgKuBT6x2auetkTEqxExi+IV1yGSDqxQy3HA+oi4p2odLQ6LiIOBY4EzJR1eMWcsxVsEl0TEQcALFG/pVCJpe2Ae8G81MnalePX9BmAqsKOkD7SbExErKN4Kuh34D2AZ8Lthb9TDJM2nWL8rq2ZExPyImJEyPlqxjgnAfGo03BaXAG8CZlH88/xKxZyxwK7AocA/AddIUgP1WcMy7tnQTN9utGdD/b7tnl2Ne/aIavXt7Ae5ksZRNMsrI+K6JjLT20L9wDEVbn4YME/So8D3gCMlXVGxjjXp63rgeuCQKjnAamB1y16O71M00KqOBe6NiHU1Mo4Gfh0RGyLiFeA64O1VgiJiYUQcHBGHU7wV8nCNugDWSZoCkL52xdvekk4BjgPeH+ngpZquAv6q4m3fRPHPblna1qcD90raq92giFiXBiubgG9Sbzu/Lr2NfTfFXrkRP1hhoyvnnp1qaaJvN92zoX7fds9uk3t2KbX6dtaD3DTaXwisiIiv1syaNPjpR0njKf6gH2o3JyI+GxHTI2IfireGfhQRbb/albSjpImD1ykOYq/0yeaIeAJYJWn/9KOjgAerZCXvo8ahCsljwKGSJqTn8SiK4/PaJmly+ro38N4GarsJOCVdPwW4sWZebZKOAT4NzIuIF2vkvLnl23lU2MYBIuL+iJgcEfukbX01xQeKnqhQ05SWb0+g4nYO3AAcmTL3o/iwzpMVs6wDcu7ZqY5G+nYHejbU79vu2W1wzy6tXt+ONj/9NhoXig16LfAKxQN9WsWcd1Ac//RzYCBd5lbM+hPgvpS1HDivgfXso+IndSmOyVqWLg8A82vWMgtYmtbvBmDXijkTgKeA1zfw+HyB4g92OfBd0qcrK+T8hOIfwDLgqLrbIrA78EOKvQs/BHarmHNCuv4ysA74QY2aHgFWtWznI37Cdoica9Pj/XPgZmBa1Zo2+/2jlPuk7pZq+i5wf6rpJmBKxZztgSvS+t0LHFl3G/Wl3PPfRk62PTvdvrG+3VTPTlmN9G337Lay3LPLZdXq257W18zMzMyyk/XhCmZmZma2bfIg18zMzMyy40GumZmZmWXHg1wzMzMzy44HuWZmZmaWHQ9yzczMzCw7HuSamZmZWXb+H4vB+vK2luTeAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def plotDetector(ax, event, is_empty):\n", + " detector = np.zeros((4,16*2+1))\n", + "\n", + " even_layers = event['layer']%2 == 0\n", + " odd_layers = even_layers == False\n", + "\n", + " def fillDetectorMatrix(matrix, i, j, s=0):\n", + " matrix[i,j*2+s] = 1\n", + " matrix[i,j*2+1+s] = 1\n", + "\n", + " def plotLeftRight(ax, cell, position, layer, odd, left):\n", + " if left == True:\n", + " ax.scatter((cell-1-position/L)*2+0.5+odd, layer-1, s=10, c='g', marker='+')\n", + " else:\n", + " ax.scatter((cell-1+position/L)*2+0.5+odd, layer-1, s=10, c='b', marker='+')\n", + " \n", + " if is_empty == False:\n", + " fillDetectorMatrix(detector, event.loc[even_layers,'layer']-1,\n", + " event.loc[even_layers,'cell']-1, s=0)\n", + " fillDetectorMatrix(detector, event.loc[odd_layers,'layer']-1,\n", + " event.loc[odd_layers,'cell']-1, s=1)\n", + "\n", + " for odd,left in [[odd, left] for odd in [True, False] for left in [True,False]]:\n", + " if odd == True:\n", + " layers = odd_layers\n", + " else:\n", + " layers = even_layers\n", + "\n", + " plotLeftRight(ax, event.loc[layers, 'cell'], event.loc[layers, 'x'],\n", + " event.loc[layers, 'layer'], odd, left)\n", + "\n", + " detector[(0,1,2,3),(0,32,0,32)] = 0.5 # Mark \"cell offset\"\n", + " ax.matshow(detector, origin='lower', cmap='bone', vmin=0, vmax=1)\n", + "\n", + " # Major ticks\n", + " ax.set_xticks(np.arange(1.5, 32, 2));\n", + " ax.set_yticks(np.arange(0, 4, 1));\n", + "\n", + " # # Labels for major ticks\n", + " ax.set_xticklabels(np.arange(1, 17, 1));\n", + " ax.set_yticklabels(np.arange(1, 5, 1));\n", + "\n", + " # # Minor ticks\n", + " # # ax.set_xticks(np.arange(-.5, 32, 2), minor=True);\n", + " ax.set_yticks(np.arange(0.5, 4, 1), minor=True);\n", + "\n", + " ax.grid(which='minor', axis='y', color='w', linewidth=1)\n", + " ax.xaxis.set_ticks_position('bottom')\n", + " \n", + " vert_line = np.array([0,1])\n", + " for l in range(4):\n", + " for c in range(16):\n", + " if l%2 == 0:\n", + " ax.plot([c*2+0.5,c*2+0.5], vert_line+l-0.5, c='w')\n", + " else:\n", + " ax.plot([c*2+1.5,c*2+1.5], vert_line+l-0.5, c='w')\n", + "\n", + "def plotEvent(event):\n", + " fig, axes = plt.subplots(2, 2, figsize=(12,4))\n", + "\n", + " for i in range(0,4):\n", + " sub_ev = event.loc[event['detector']==i+1, :]\n", + " plotDetector(axes[1-i%2,i//2], sub_ev, sub_ev.empty)\n", + " axes[1-i%2,i//2].set_title('Detector {}'.format(i+1))\n", + " # TODO legend\n", + "\n", + " plt.show()\n", + "\n", + "\n", + "printmd(\"The following paths represent some of the event trajectories found in the data. 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", + "printmd(\"This event follows a trajectory of a particle through detectors 1 and 2.\")\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 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])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Final Remarks: \n", + "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": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.1" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} 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 }