diff --git a/notebooks/4TracksAnalysis.ipynb b/notebooks/4TracksAnalysis.ipynb
index e51f689..c4512dd 100644
--- a/notebooks/4TracksAnalysis.ipynb
+++ b/notebooks/4TracksAnalysis.ipynb
@@ -1,6 +1,8 @@
 {
  "cells": [
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "# $\\rho'$ analysis notes\n",
     "\n",
@@ -10,56 +12,69 @@
     "\n",
     "Events:\n",
     "\n",
-    "    * >= 4 tracks\n",
+    "- >= 4 tracks\n",
     "    \n",
     "Tracks:\n",
     "\n",
-    "    * Has Point On inner OR outer ITS Layer\n",
-    "    * Not ITS SA\n",
-    "    * |dca1| < 3 && |dca0| < 3;\n",
+    "- Has Point On inner OR outer ITS Layer\n",
+    "- Not ITS SA\n",
+    "- |dca1| < 3 && |dca0| < 3;\n",
     "\n",
     "### Data info"
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
-     "output_type": "stream",
      "name": "stdout",
+     "output_type": "stream",
      "text": [
-      "name                 | typename                 | interpretation                \n---------------------+--------------------------+-------------------------------\nRunNum               | int32_t                  | AsDtype('>i4')\nPeriodNumber         | uint32_t                 | AsDtype('>u4')\nOrbitNumber          | uint32_t                 | AsDtype('>u4')\nBunchCrossNumber     | uint16_t                 | AsDtype('>u2')\nMass                 | float                    | AsDtype('>f4')\nPt                   | float                    | AsDtype('>f4')\nQ                    | int16_t                  | AsDtype('>i2')\nRapidity             | float                    | AsDtype('>f4')\nPhi                  | float                    | AsDtype('>f4')\nZNAenergy            | float                    | AsDtype('>f4')\nZNCenergy            | float                    | AsDtype('>f4')\nZPAenergy            | float                    | AsDtype('>f4')\nZPCenergy            | float                    | AsDtype('>f4')\nVtxX                 | float                    | AsDtype('>f4')\nVtxY                 | float                    | AsDtype('>f4')\nVtxZ                 | float                    | AsDtype('>f4')\nVtxContrib           | int32_t                  | AsDtype('>i4')\nVtxChi2              | float                    | AsDtype('>f4')\nVtxNDF               | float                    | AsDtype('>f4')\nSpdVtxX              | float                    | AsDtype('>f4')\nSpdVtxY              | float                    | AsDtype('>f4')\nSpdVtxZ              | float                    | AsDtype('>f4')\nSpdVtxContrib        | int32_t                  | AsDtype('>i4')\nV0Adecision          | int32_t                  | AsDtype('>i4')\nV0Cdecision          | int32_t                  | AsDtype('>i4')\nADAdecision          | int32_t                  | AsDtype('>i4')\nADCdecision          | int32_t                  | AsDtype('>i4')\nUBAfired             | bool                     | AsDtype('bool')\nUBCfired             | bool                     | AsDtype('bool')\nVBAfired             | bool                     | AsDtype('bool')\nVBCfired             | bool                     | AsDtype('bool')\nnTracklets           | int32_t                  | AsDtype('>i4')\nnTracks              | int32_t                  | AsDtype('>i4')\nT_NumberOfSigmaIT... | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\nT_NumberOfSigmaIT... | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\nT_NumberOfSigmaTP... | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\nT_NumberOfSigmaTP... | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\nTPCsignal            | std::vector<int32_t>     | AsJagged(AsDtype('>i4'), he...\nT_P                  | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\nT_Eta                | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\nT_Phi                | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\nT_Px                 | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\nT_Py                 | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\nT_Pz                 | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\nT_Q                  | std::vector<int16_t>     | AsJagged(AsDtype('>i2'), he...\nT_HasPointOnITSLa... | std::vector<bool>        | AsJagged(AsDtype('bool'), h...\nT_HasPointOnITSLa... | std::vector<bool>        | AsJagged(AsDtype('bool'), h...\nT_ITSModuleInner     | std::vector<int32_t>     | AsJagged(AsDtype('>i4'), he...\nT_ITSModuleOuter     | std::vector<int32_t>     | AsJagged(AsDtype('>i4'), he...\nT_TPCNCls            | std::vector<int32_t>     | AsJagged(AsDtype('>i4'), he...\nT_ITSNCls            | std::vector<int32_t>     | AsJagged(AsDtype('>i4'), he...\nT_Dca0               | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\nT_Dca1               | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\nT_TPCRefit           | std::vector<bool>        | AsJagged(AsDtype('bool'), h...\nT_ITSRefit           | std::vector<bool>        | AsJagged(AsDtype('bool'), h...\nTLets_Theta          | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\nTLets_Phi            | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\nT_ITSSensorNum       | std::vector<int32_t>     | AsJagged(AsDtype('>i4'), he...\n\nTree name: events\nTree title: Selected events for 4proungs analysis\nEvents number: 114648\nTracks number 4610890\n"
+      "Events attributes:\n",
+      "Index(['RunNum', 'PeriodNumber', 'OrbitNumber', 'BunchCrossNumber', 'Mass',\n",
+      "       'Pt', 'Q', 'Rapidity', 'Phi', 'ZNAenergy', 'ZNCenergy', 'ZPAenergy',\n",
+      "       'ZPCenergy', 'VtxX', 'VtxY', 'VtxZ', 'VtxContrib', 'VtxChi2', 'VtxNDF',\n",
+      "       'SpdVtxX', 'SpdVtxY', 'SpdVtxZ', 'SpdVtxContrib', 'V0Adecision',\n",
+      "       'V0Cdecision', 'ADAdecision', 'ADCdecision', 'V0Afired', 'V0Cfired',\n",
+      "       'ADAfired', 'ADCfired', 'STPfired', 'SMBfired', 'SM2fired', 'SH1fired',\n",
+      "       'OM2fired', 'OMUfired', 'IsTriggered', 'nTracklets', 'nTracks',\n",
+      "       'FORChip'],\n",
+      "      dtype='object')\n",
+      "Track attributes:\n",
+      "Index(['T_NumberOfSigmaTPCPion', 'T_Eta', 'T_Phi', 'T_Px', 'T_Py', 'T_Pz',\n",
+      "       'T_Q', 'T_HasPointOnITSLayer0', 'T_HasPointOnITSLayer1',\n",
+      "       'T_ITSModuleInner', 'T_ITSModuleOuter', 'T_TPCNCls', 'T_TPCRefit'],\n",
+      "      dtype='object')\n",
+      "\n",
+      "Events count: 106,705\n",
+      "Tracks count: 25,117,847\n"
      ]
     }
    ],
    "source": [
-    "from modules.FourTrackEvents import *\n",
-    "\n",
-    "ccup9_2015_file = r'D:\\GoogleDrive\\Job\\cern\\Alice\\analysis\\data\\RhoPrime\\2015\\4Prongs2015o.root'\n",
-    "ccup9_2015_local_test = r'D:\\GoogleDrive\\Job\\cern\\Alice\\analysis\\dev\\grid\\selection\\RhoPrime\\macro\\AnalysisResults.root'\n",
-    "\n",
-    "tree_name = '4Prongs/events'\n",
-    "# dfs.loc[0] # get dataframe part with entry = 0\n",
-    "\n",
-    "branches = ['T_Px', 'T_Py', 'T_Pz',  'T_Q', 'T_NumberOfSigmaTPCPion', 'T_TPCRefit', 'T_TPCNCls', 'T_Phi', 'T_Eta', 'T_HasPointOnITSLayer0','T_HasPointOnITSLayer1', 'T_ITSModuleInner', 'T_ITSModuleOuter']\n",
-    "\n",
-    "ft = FourTrackEvents(ccup9_2015_file,tree_name,branches)\n",
-    "\n",
-    "ft.orig_events.show()\n",
-    "\n",
-    "print()\n",
-    "print('Tree name:', ft.orig_events.name)\n",
-    "print('Tree title:', ft.orig_events.title)\n",
-    "print('Events number:', ft.orig_tracks.reset_index().entry.max())\n",
-    "print('Tracks number', len(ft.orig_tracks))\n",
-    "\n"
+    "from modules.FourTrackEvents import *\r\n",
+    "\r\n",
+    "ccup9_2015_file = r'D:\\GoogleDrive\\Job\\cern\\Alice\\analysis\\data\\RhoPrime\\2015\\4Prongs2015oLast.root'\r\n",
+    "ccup9_2015_local_test = r'D:\\GoogleDrive\\Job\\cern\\Alice\\analysis\\dev\\grid\\selection\\RhoPrime\\macro\\AnalysisResults.root'\r\n",
+    "\r\n",
+    "# dfs.loc[0] # get dataframe part with entry = 0\r\n",
+    "\r\n",
+    "ft = FourTrackEvents()\r\n",
+    "\r\n",
+    "print('Events attributes:')\r\n",
+    "print(ft.orig_events.columns)\r\n",
+    "print('Track attributes:')\r\n",
+    "print(ft.orig_tracks.columns)\r\n",
+    "print()\r\n",
+    "print('Events count:', \"{:,}\".format(len(ft.orig_events.index)))\r\n",
+    "print('Tracks count:', \"{:,}\".format(len(ft.orig_tracks.index)))"
    ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "## Analysis criteria\n",
     "\n",
@@ -68,13 +83,7 @@
     "\n",
     "* |NumberOfSigmaTPCPion| < 3\n",
     "* Number of TPC Clusters > 50\n",
-    "* TPCRefit\n"
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
-  },
-  {
-   "source": [
+    "* TPCRefit\n",
     "## Low energy tracks and TPC\n",
     "\n",
     "There is an idea about that tracks with small energies (low pt) not able to reach TPC.\n",
@@ -112,141 +121,151 @@
     "|TPC|-|-|-|-|\n",
     "\n",
     "We can see statistics gain ration equal 2.5 between std criteria and total combinations:\n"
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
-    "ft_zq_Pt_nTpc = []\n",
-    "ft_zq_Mass_nTpc = []\n",
-    "\n",
-    "for i in range(5):\n",
-    "    ft_zq_Pt_nTpc[i]   = kinematics.pt_events(ft.GetTracksWithNTPC(ft.four_tracks_zq,i)\n",
-    "    ft_zq_Mass_nTpc[i] = kinematics.mass_events(ft.GetTracksWithPtLt(ft.GetTracksWithNTPC(ft.four_tracks_zq,i))))"
+    "from modules.physics import kinematics\r\n",
+    "\r\n",
+    "ft_zq_Pt_nTpc = []\r\n",
+    "ft_zq_Mass_nTpc = []\r\n",
+    "\r\n",
+    "# TODO: fill this in parallel!\r\n",
+    "# NOTE: I'm not sure that I can because of memory will be overtaken\r\n",
+    "for i in range(5):\r\n",
+    "    ft_zq_Pt_nTpc.append(kinematics.pt_events(ft.GetTracksWithNTPC(ft.four_tracks_zq,i)))\r\n",
+    "    ft_zq_Mass_nTpc.append(kinematics.mass_events(ft.GetTracksWithPtLt(ft.GetTracksWithNTPC(ft.four_tracks_zq,i))))"
    ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "## Transversal momentum distribution"
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
-     "output_type": "display_data",
      "data": {
-      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
       "application/vnd.jupyter.widget-view+json": {
+       "model_id": "905ad0eaee8c4719a7991e92763fc9f9",
        "version_major": 2,
-       "version_minor": 0,
-       "model_id": "7c006b0bce474c629fa7afb2c7821e19"
-      }
+       "version_minor": 0
+      },
+      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": "<Figure size 2000x1000 with 1 Axes>"
      },
-     "metadata": {}
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "from modules.physics import kinematics\n",
-    "from modules.physics.analysis.ITSvsTPC_events import *\n",
-    "from matplotlib.patches import Rectangle \n",
-    "\n",
-    "%matplotlib widget\n",
-    "\n",
-    "tpcimpPt = []\n",
-    "colors = ['red', 'green', 'yellow', 'orange', 'black']\n",
-    "labels = ['ITS & (>= 0TPC)', 'ITS & (>= 1TPC)',\n",
-    "          'ITS & (>= 2TPC)', 'ITS & (>= 3TPC)', 'ITS & ( =  4TPC)']\n",
-    "for i in range(5):\n",
-    "    tmpPt = kinematics.pt_events(ft.GetTracksWithNTPC(ft.four_tracks_zq,i))\n",
-    "    tpcimpPt.append(tmpPt)\n",
-    "\n",
-    "ShowComparisonSame('', tpcimpPt, r'$p_t \\pi^+\\pi^-\\pi^+\\pi^-$,GeV',\n",
-    "                   labels, colors, nBins=100, ranges=(0, 2),showPatch=True)"
+    "from modules.physics import kinematics\r\n",
+    "from modules.physics.analysis.ITSvsTPC_events import *\r\n",
+    "from matplotlib.patches import Rectangle \r\n",
+    "import matplotlib.pyplot as plt\r\n",
+    "\r\n",
+    "%matplotlib widget\r\n",
+    "\r\n",
+    "colors = ['red', 'green', 'yellow', 'orange', 'black']\r\n",
+    "labels = ['ITS & (>= 0TPC)', 'ITS & (>= 1TPC)',\r\n",
+    "          'ITS & (>= 2TPC)', 'ITS & (>= 3TPC)', 'ITS & ( =  4TPC)']\r\n",
+    "\r\n",
+    "ShowComparisonSame('', ft_zq_Pt_nTpc, r'$p_t \\pi^+\\pi^-\\pi^+\\pi^-$,GeV',\r\n",
+    "                   labels, colors, nBins=100, ranges=(0, 2),showPatch=True)\r\n",
+    "\r\n"
    ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "As we can see here pt for $Q \\neq 0$ contains only background events:"
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
-     "output_type": "display_data",
      "data": {
-      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
       "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c3e29f8374f848cc8d19a6a27a9504bd",
        "version_major": 2,
-       "version_minor": 0,
-       "model_id": "bf25e4225be34202aae481d2a197d5f7"
-      }
+       "version_minor": 0
+      },
+      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      },
-     "metadata": {}
+     "metadata": {},
+     "output_type": "display_data"
     },
     {
-     "output_type": "execute_result",
      "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x1fb0a654490>"
-      ]
+      "text/plain": "<matplotlib.legend.Legend at 0x1fa657feb80>"
      },
+     "execution_count": 17,
      "metadata": {},
-     "execution_count": 5
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "from matplotlib.patches import Rectangle \n",
-    "from modules.physics import kinematics\n",
-    "\n",
-    "%matplotlib widget\n",
-    "\n",
-    "plt.style.use(hep.style.ROOT)\n",
-    "fig = plt.figure(figsize=(10,5))\n",
-    "ax = fig.add_subplot()\n",
-    "\n",
-    "fig.suptitle(f'$p_t$ of events', fontsize=32)\n",
-    "b = 100\n",
-    "r = 0,2\n",
-    "counts,bin_edges = np.histogram(kinematics.pt_events(ft.GetTracksWithNTPC(ft.four_tracks_zq)), bins=b, range=r)\n",
-    "bin_centres = (bin_edges[:-1] + bin_edges[1:])/2.\n",
-    "errs = np.sqrt(counts)\n",
-    "ax.errorbar(bin_centres, counts, yerr=errs, fmt='.', label=r'$Q=0$', color=colors[0])\n",
-    "\n",
-    "val=(r[1]-r[0])*1000 // b\n",
-    "ax.set_xlabel('$p_t, GeV$')\n",
-    "ax.set_ylabel(f'#events / {val}MeV')\n",
-    "ax.add_patch(Rectangle((0, 0.15), 0.15, 900, fc='lightgrey', alpha=0.4))\n",
-    "ax.text(0.15,0,\"0.15\", size=20)\n",
-    "counts,bin_edges = np.histogram(kinematics.pt_events(ft.GetTracksWithNTPC(ft.four_tracks_nzq)), bins=b, range=r)\n",
-    "bin_centres = (bin_edges[:-1] + bin_edges[1:])/2.\n",
-    "errs = np.sqrt(counts)\n",
-    "ax.errorbar(bin_centres, counts, yerr=errs, fmt='.', label=r'$Q\\neq0$', color=colors[2])\n",
-    "ax.legend()"
+    "from matplotlib.patches import Rectangle \r\n",
+    "from modules.physics import kinematics\r\n",
+    "import matplotlib.pyplot as plt\r\n",
+    "\r\n",
+    "%matplotlib widget\r\n",
+    "\r\n",
+    "plt.style.use(hep.style.ROOT)\r\n",
+    "fig = plt.figure(figsize=(10,5))\r\n",
+    "ax = fig.add_subplot()\r\n",
+    "\r\n",
+    "fig.suptitle(f'$p_t$ of events', fontsize=32)\r\n",
+    "b = 100\r\n",
+    "r = 0,2\r\n",
+    "counts,bin_edges = np.histogram(ft_zq_Pt_nTpc[3], bins=b, range=r)\r\n",
+    "bin_centres = (bin_edges[:-1] + bin_edges[1:])/2.\r\n",
+    "errs = np.sqrt(counts)\r\n",
+    "ax.errorbar(bin_centres, counts, yerr=errs, fmt='.', label=r'$Q=0$', color=colors[0])\r\n",
+    "\r\n",
+    "val=(r[1]-r[0])*1000 // b\r\n",
+    "ax.set_xlabel('$p_t, GeV$')\r\n",
+    "ax.set_ylabel(f'#events / {val}MeV')\r\n",
+    "ax.add_patch(Rectangle((0, 0.15), 0.15, 900, fc='lightgrey', alpha=0.4))\r\n",
+    "ax.text(0.15,0,\"0.15\", size=20)\r\n",
+    "counts,bin_edges = np.histogram(kinematics.pt_events(ft.GetTracksWithNTPC(ft.four_tracks_nzq)), bins=b, range=r)\r\n",
+    "bin_centres = (bin_edges[:-1] + bin_edges[1:])/2.\r\n",
+    "errs = np.sqrt(counts)\r\n",
+    "ax.errorbar(bin_centres, counts, yerr=errs, fmt='.', label=r'$Q\\neq0$', color=colors[2])\r\n",
+    "ax.legend()\r\n"
    ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "Now  let's try to see what tracks we lost from signal area and what contribution they have:"
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "TPC and ITS has different coverage for polar angle:\n",
     "\n",
@@ -261,23 +280,21 @@
     "3. All tracks from events were reconstructed by ITS or TPC\n",
     "\n",
     "We can see small gaps with for the second case, that allow to speak about correctness of the suggestion, but anyway low energy of tracks is the main reason why TPC can't reconstructed tracks.  "
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
-     "output_type": "error",
      "ename": "NameError",
      "evalue": "name 'ShowComparison' is not defined",
+     "output_type": "error",
      "traceback": [
       "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
       "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[1;32m<ipython-input-4-4feb77cac62d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mShowComparison\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'$\\\\theta$'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mAllTPCTracksTheta\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mITSDiffTPCTracksTheta\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mTotalLowPtTheta\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'$^\\\\circ$'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m'ITS&&TPC'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'OnlyITSFromNTPCEvents'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'ITS||TPC'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnBins\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m80\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mranges\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m25\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m150\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;32m<ipython-input-18-4feb77cac62d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mShowComparison\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'$\\\\theta$'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mAllTPCTracksTheta\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mITSDiffTPCTracksTheta\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mTotalLowPtTheta\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'$^\\\\circ$'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m'ITS&&TPC'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'OnlyITSFromNTPCEvents'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'ITS||TPC'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnBins\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m80\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mranges\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m25\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m150\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
       "\u001b[1;31mNameError\u001b[0m: name 'ShowComparison' is not defined"
      ]
     }
@@ -287,134 +304,147 @@
    ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "## Mass\n",
     "Let's see on the mass distribution of the events\n"
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
-     "output_type": "display_data",
      "data": {
-      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
       "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2d57b63850944749a75aff9db8dd1cf8",
        "version_major": 2,
-       "version_minor": 0,
-       "model_id": "533d31167a5041d7a1a03d54142831b5"
-      }
+       "version_minor": 0
+      },
+      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      },
-     "metadata": {}
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": "<Figure size 2000x1000 with 1 Axes>"
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "from modules.physics import kinematics\n",
-    "from modules.physics.analysis.ITSvsTPC_events import *\n",
-    "\n",
-    "%matplotlib widget\n",
-    "\n",
-    "tpcimpMass = []\n",
-    "colors = ['red', 'orange', 'black']\n",
-    "labels = ['ITS & (>= 2TPC)', 'ITS & (>= 3TPC)', 'ITS & ( =  4TPC)']\n",
-    "\n",
-    "for i in range(2,5):\n",
-    "    tpcimpMass.append(kinematics.mass_events(ft.GetTracksWithPtLt(ft.GetTracksWithNTPC(ft.four_tracks_zq,i))))\n",
-    "\n",
-    "ShowComparisonSame('4track events Mass', tpcimpMass, '$Mass, GeV$',\n",
-    "                   labels, colors, nBins=100, ranges=(0.5, 3.5))\n"
+    "from modules.physics import kinematics\r\n",
+    "from modules.physics.analysis.ITSvsTPC_events import *\r\n",
+    "\r\n",
+    "%matplotlib widget\r\n",
+    "\r\n",
+    "colors = ['red', 'orange', 'black']\r\n",
+    "labels = ['ITS & (>= 2TPC)', 'ITS & (>= 3TPC)', 'ITS & ( =  4TPC)']\r\n",
+    "\r\n",
+    "\r\n",
+    "ShowComparisonSame('4track events Mass', ft_zq_Mass_nTpc[2:], '$Mass, GeV$',\r\n",
+    "                   labels, colors, nBins=100, ranges=(0.5, 3.5))\r\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
-     "output_type": "display_data",
      "data": {
-      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
       "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1ecef08b2540440aadd68c36cebdfca2",
        "version_major": 2,
-       "version_minor": 0,
-       "model_id": "45cd2d5535bb4a0daf27c8afc5028133"
-      }
+       "version_minor": 0
+      },
+      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      },
-     "metadata": {}
+     "metadata": {},
+     "output_type": "display_data"
     },
     {
-     "output_type": "execute_result",
      "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x1fb0a675850>"
-      ]
+      "text/plain": "<matplotlib.legend.Legend at 0x1fa65b22d30>"
      },
+     "execution_count": 21,
      "metadata": {},
-     "execution_count": 7
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "from modules.physics import kinematics\n",
-    "\n",
-    "%matplotlib widget\n",
-    "\n",
-    "plt.style.use(hep.style.ROOT)\n",
-    "fig = plt.figure(figsize=(15,7))\n",
-    "ax = fig.add_subplot()\n",
-    "\n",
-    "fig.suptitle(f'Масса $\\pi^+\\pi^-\\pi^+\\pi^-$', fontsize=32)\n",
-    "b = 100\n",
-    "r = 0.5,3.5\n",
-    "counts,bin_edges = np.histogram(tpcimpMass[1], bins=b, range=r)\n",
-    "bin_centres = (bin_edges[:-1] + bin_edges[1:])/2.\n",
-    "errs = np.sqrt(counts)\n",
-    "ax.errorbar(bin_centres, counts, yerr=errs, fmt='.', label='Q = 0', color=colors[0])\n",
-    "\n",
-    "val=(r[1]-r[0])*1000 // b\n",
-    "ax.set_xlabel('$Mass, GeV$')\n",
-    "ax.set_ylabel(f'#events / {val}MeV')\n",
-    "\n",
-    "counts,bin_edges = np.histogram(kinematics.mass_events(ft.GetTracksWithPtLt(ft.GetTracksWithNTPC(ft.four_tracks_nzq))), bins=b, range=r)\n",
-    "bin_centres = (bin_edges[:-1] + bin_edges[1:])/2.\n",
-    "errs = np.sqrt(counts)\n",
-    "ax.errorbar(bin_centres, counts, yerr=errs, fmt='.', color=colors[1], label=r\"$Q\\neq0$\")\n",
-    "\n",
-    "val=(r[1]-r[0])*1000 // b\n",
-    "ax.set_xlabel('$Mass, GeV$')\n",
-    "ax.set_ylabel(f'#events / {val}MeV')\n",
+    "from modules.physics import kinematics\r\n",
+    "\r\n",
+    "%matplotlib widget\r\n",
+    "\r\n",
+    "plt.style.use(hep.style.ROOT)\r\n",
+    "fig = plt.figure(figsize=(15,7))\r\n",
+    "ax = fig.add_subplot()\r\n",
+    "\r\n",
+    "fig.suptitle(f'Масса $\\pi^+\\pi^-\\pi^+\\pi^-$', fontsize=32)\r\n",
+    "b = 100\r\n",
+    "r = 0.5,3.5\r\n",
+    "counts,bin_edges = np.histogram(ft_zq_Mass_nTpc[1], bins=b, range=r)\r\n",
+    "bin_centres = (bin_edges[:-1] + bin_edges[1:])/2.\r\n",
+    "errs = np.sqrt(counts)\r\n",
+    "ax.errorbar(bin_centres, counts, yerr=errs, fmt='.', label='Q = 0', color=colors[0])\r\n",
+    "\r\n",
+    "val=(r[1]-r[0])*1000 // b\r\n",
+    "ax.set_xlabel('$Mass, GeV$')\r\n",
+    "ax.set_ylabel(f'#events / {val}MeV')\r\n",
+    "\r\n",
+    "counts,bin_edges = np.histogram(kinematics.mass_events(ft.GetTracksWithPtLt(ft.GetTracksWithNTPC(ft.four_tracks_nzq))), bins=b, range=r)\r\n",
+    "bin_centres = (bin_edges[:-1] + bin_edges[1:])/2.\r\n",
+    "errs = np.sqrt(counts)\r\n",
+    "ax.errorbar(bin_centres, counts, yerr=errs, fmt='.', color=colors[1], label=r\"$Q\\neq0$\")\r\n",
+    "\r\n",
+    "val=(r[1]-r[0])*1000 // b\r\n",
+    "ax.set_xlabel('$Mass, GeV$')\r\n",
+    "ax.set_ylabel(f'#events / {val}MeV')\r\n",
     "ax.legend()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 667,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [
     {
-     "output_type": "display_data",
      "data": {
-      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
       "application/vnd.jupyter.widget-view+json": {
+       "model_id": "00cfbf27e1274879881c4d9b7374cf4b",
        "version_major": 2,
-       "version_minor": 0,
-       "model_id": "ea3d69ce166f4a1a97b2e2d4e1e779c6"
-      }
+       "version_minor": 0
+      },
+      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      },
-     "metadata": {}
+     "metadata": {},
+     "output_type": "display_data"
     },
     {
-     "output_type": "execute_result",
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x14e53563d30>"
-      ]
-     },
-     "metadata": {},
-     "execution_count": 667
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "d:\\GoogleDrive\\Job\\cern\\Alice\\analysis\\dev\\physics\\notebooks\\modules\\FourTrackEvents.py:67: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
+      "  \"\"\"\n"
+     ]
+    },
+    {
+     "ename": "NameError",
+     "evalue": "name 'untriggered_events' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-42-13c2cbd17091>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[0mr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0.5\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3.5\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     12\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 13\u001b[1;33m \u001b[0mcounts\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mbin_edges\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mhistogram\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkinematics\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmass_events\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mft\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mGetTracksWithPtLt\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mft\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mGetTracksWithNTPC\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mft\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfour_tracks_zq\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mloc\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0muntriggered_events\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbins\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mr\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     14\u001b[0m \u001b[0mbin_centres\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mbin_edges\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mbin_edges\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m2.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[0merrs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcounts\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;31mNameError\u001b[0m: name 'untriggered_events' is not defined"
+     ]
     }
    ],
    "source": [
@@ -442,6 +472,8 @@
    ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "+### Pions subsystems\n",
     "\n",
@@ -456,84 +488,80 @@
     "\n",
     "1. Make all possible(4) combinations of pairs. Then take lightest and pair that belong to one combination with that. Plot masses of these two pairs.\n",
     "2. Plot masses of masses from possible combinations."
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
-     "output_type": "display_data",
      "data": {
-      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
       "application/vnd.jupyter.widget-view+json": {
+       "model_id": "91b47bbae54447148cf4b8ab58714fff",
        "version_major": 2,
-       "version_minor": 0,
-       "model_id": "5c9d9df0935040dca1c7a8f390776145"
-      }
+       "version_minor": 0
+      },
+      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      },
-     "metadata": {}
+     "metadata": {},
+     "output_type": "display_data"
     },
     {
-     "output_type": "stream",
      "name": "stderr",
+     "output_type": "stream",
      "text": [
       "No handles with labels found to put in legend.\n"
      ]
     }
    ],
    "source": [
-    "from modules.physics.analysis import pairs\n",
-    "\n",
-    "%matplotlib widget\n",
-    "# ShowMassComaprison(LiteHeavyRecoil, 'Lightest and Recoil Pairs')\n",
-    "LiteHeavyRecoil, LiteHeavyTotal = pairs.GetPairs(ft.GetTracksWithPtLt(ft.GetTracksWithNTPC(ft.four_tracks_zq,4).loc[triggered_events]))\n",
+    "from modules.physics.analysis import pairs\r\n",
+    "\r\n",
+    "%matplotlib widget\r\n",
+    "# ShowMassComaprison(LiteHeavyRecoil, 'Lightest and Recoil Pairs')\r\n",
+    "LiteHeavyRecoil, LiteHeavyTotal = pairs.GetPairs(ft.GetTracksWithPtLt(ft.GetTracksWithNTPC(ft.four_tracks_zq,4)))\r\n",
     "pairs.ShowMassComaprison(LiteHeavyTotal, r'$\\rho^0 \\rightarrow \\pi^+\\pi^-$   and    $\\pi^+\\pi^-$ masses')"
    ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "As we can see above, for second case (all possible pairs) we've got stronger signal in comparison with light-recoil pair as it made in [STAR work](http://arxiv.org/abs/0912.0604v2). Let's build 2d distirbuition and marginals component separately:"
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [
     {
-     "output_type": "display_data",
      "data": {
-      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
       "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e1d4b0bb82094d4189f30f0e38685620",
        "version_major": 2,
-       "version_minor": 0,
-       "model_id": "ffc9fc7fbbf549bcb0fed13a8745e00a"
-      }
+       "version_minor": 0
+      },
+      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      },
-     "metadata": {}
+     "metadata": {},
+     "output_type": "display_data"
     },
     {
-     "output_type": "stream",
      "name": "stderr",
+     "output_type": "stream",
      "text": [
       "No handles with labels found to put in legend.\n"
      ]
     },
     {
-     "output_type": "execute_result",
      "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x20724a48610>"
-      ]
+      "text/plain": "<matplotlib.legend.Legend at 0x2249db84910>"
      },
+     "execution_count": 45,
      "metadata": {},
-     "execution_count": 31
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -576,59 +604,77 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 47,
    "metadata": {},
    "outputs": [
     {
-     "output_type": "display_data",
      "data": {
-      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
       "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c9232b4e03264d4489922fb1d0ded7ef",
        "version_major": 2,
-       "version_minor": 0,
-       "model_id": "22fa3cbddbd24962a6f97e6cb5772612"
-      }
+       "version_minor": 0
+      },
+      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      },
-     "metadata": {}
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "<ipython-input-47-3182a64b8363>:11: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  _ = ax.hist(counts1/counts2,bins=bins1, histtype='step', color='black', linewidth=2)\n"
+     ]
     },
     {
-     "output_type": "display_data",
      "data": {
-      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
       "application/vnd.jupyter.widget-view+json": {
+       "model_id": "29f003f4c058455e932b6aad16f2ffe3",
        "version_major": 2,
-       "version_minor": 0,
-       "model_id": "39cc759c1dcd4085acd07530772503b4"
-      }
+       "version_minor": 0
+      },
+      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      },
-     "metadata": {}
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "<ipython-input-47-3182a64b8363>:21: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  _ = ax.hist(counts1/counts2,bins=bins1, histtype='step', color='black', linewidth=2)\n"
+     ]
     }
    ],
    "source": [
-    "%matplotlib widget\n",
-    "\n",
-    "\n",
-    "plt.style.use(hep.style.ROOT)\n",
-    "fig = plt.figure(figsize=(15,7))\n",
-    "ax = fig.add_subplot()\n",
-    "\n",
-    "counts1, bins1  = np.histogram(LiteHeavyRecoil.Recoil, bins=100, range=(0,2))\n",
-    "counts2, bins2  = np.histogram(LiteHeavyTotal.Recoil, bins=100, range=(0,2))\n",
-    "\n",
-    "_ = ax.hist(counts1/counts2,bins=bins1, histtype='step', color='black', linewidth=2)\n",
-    "\n",
-    "\n",
-    "plt.style.use(hep.style.ROOT)\n",
-    "fig = plt.figure(figsize=(15,7))\n",
-    "ax = fig.add_subplot()\n",
-    "\n",
-    "counts1, bins1  = np.histogram(LiteHeavyRecoil.Lite, bins=100, range=(0,2))\n",
-    "counts2, bins2  = np.histogram(LiteHeavyTotal.Lite, bins=100, range=(0,2))\n",
-    "\n",
+    "%matplotlib widget\r\n",
+    "\r\n",
+    "\r\n",
+    "plt.style.use(hep.style.ROOT)\r\n",
+    "fig = plt.figure(figsize=(10,7))\r\n",
+    "ax = fig.add_subplot()\r\n",
+    "\r\n",
+    "counts1, bins1  = np.histogram(LiteHeavyRecoil.Recoil, bins=100, range=(0,2))\r\n",
+    "counts2, bins2  = np.histogram(LiteHeavyTotal.Recoil, bins=100, range=(0,2))\r\n",
+    "\r\n",
+    "_ = ax.hist(counts1/counts2,bins=bins1, histtype='step', color='black', linewidth=2)\r\n",
+    "\r\n",
+    "\r\n",
+    "plt.style.use(hep.style.ROOT)\r\n",
+    "fig = plt.figure(figsize=(15,7))\r\n",
+    "ax = fig.add_subplot()\r\n",
+    "\r\n",
+    "counts1, bins1  = np.histogram(LiteHeavyRecoil.Lite, bins=100, range=(0,2))\r\n",
+    "counts2, bins2  = np.histogram(LiteHeavyTotal.Lite, bins=100, range=(0,2))\r\n",
+    "\r\n",
     "_ = ax.hist(counts1/counts2,bins=bins1, histtype='step', color='black', linewidth=2)"
    ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "## Cross section\n",
     "\n",
@@ -647,40 +693,32 @@
     "Cross section of phenomena should be flat and independent from runs. \n",
     "\n",
     "Let's check it:"
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
-     "output_type": "execute_result",
-     "data": {
-      "text/plain": [
-       "count    119.000000\n",
-       "mean       4.454220\n",
-       "std        1.266880\n",
-       "min        1.432162\n",
-       "25%        3.573470\n",
-       "50%        4.136248\n",
-       "75%        5.128244\n",
-       "max        8.824594\n",
-       "Name: sigma, dtype: float64"
-      ]
-     },
-     "metadata": {},
-     "execution_count": 8
+     "ename": "ImportError",
+     "evalue": "cannot import name 'events' from 'modules' (d:\\GoogleDrive\\Job\\cern\\Alice\\analysis\\dev\\physics\\notebooks\\modules\\__init__.py)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mImportError\u001b[0m                               Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-23-d748ed004c94>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mfrom\u001b[0m \u001b[0mmodules\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mphysics\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0manalysis\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcrossection\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mGetCrossSection\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mdf_cs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mGetCrossSection\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mft\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mGetTracksWithPtLt\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mft\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mGetTracksWithNTPC\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mft\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfour_tracks_zq\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mdf_cs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'sigma'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdf_cs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnEvFT\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mdf_cs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mLumi\u001b[0m \u001b[1;33m*\u001b[0m \u001b[1;36m1000\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mdf_cs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msigma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdescribe\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;32md:\\GoogleDrive\\Job\\cern\\Alice\\analysis\\dev\\physics\\notebooks\\modules\\physics\\analysis\\crossection.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mcollections\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;31m# from modules.data.selection import GetITSnTPCTracksDF\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[1;32mfrom\u001b[0m \u001b[0mmodules\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mevents\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpd\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mmath\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mjson\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;31mImportError\u001b[0m: cannot import name 'events' from 'modules' (d:\\GoogleDrive\\Job\\cern\\Alice\\analysis\\dev\\physics\\notebooks\\modules\\__init__.py)"
+     ]
     }
    ],
    "source": [
-    "from modules.physics.analysis.crossection import GetCrossSection\n",
-    "\n",
-    "df_cs = GetCrossSection(ft.GetTracksWithPtLt(ft.GetTracksWithNTPC(ft.four_tracks_zq)))\n",
-    "df_cs['sigma'] = df_cs.nEvFT / (df_cs.Lumi * 1000)\n",
-    "df_cs.sigma.describe()\n"
+    "from modules.physics.analysis.crossection import GetCrossSection\r\n",
+    "\r\n",
+    "df_cs = GetCrossSection(ft.GetTracksWithPtLt(ft.GetTracksWithNTPC(ft.four_tracks_zq)))\r\n",
+    "df_cs['sigma'] = df_cs.nEvFT / (df_cs.Lumi * 1000)\r\n",
+    "df_cs.sigma.describe()\r\n"
    ]
   },
   {
@@ -689,26 +727,28 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "display_data",
      "data": {
-      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
       "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5c4a84f9526743db926797d38230fcb6",
        "version_major": 2,
-       "version_minor": 0,
-       "model_id": "5c4a84f9526743db926797d38230fcb6"
-      }
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
      },
-     "metadata": {}
+     "metadata": {},
+     "output_type": "display_data"
     },
     {
-     "output_type": "execute_result",
      "data": {
       "text/plain": [
        "<matplotlib.legend.Legend at 0x1fb186273d0>"
       ]
      },
+     "execution_count": 53,
      "metadata": {},
-     "execution_count": 53
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -737,6 +777,8 @@
    ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "## Other decays\n",
     "\n",
@@ -750,21 +792,54 @@
     "- 2. $\\rho' \\rightarrow 4 \\pi$ | ?\n",
     "\n",
     "What about $\\rho' \\rightarrow \\rho_0 \\rho_0$ is it possible?"
-   ],
+   ]
+  },
+  {
    "cell_type": "markdown",
-   "metadata": {}
+   "metadata": {},
+   "source": [
+    "## False triggering\r\n",
+    "\r\n",
+    "There are some situations when CUP9 triggering could be false.\r\n",
+    "\r\n",
+    "![img](https://sun9-58.userapi.com/impf/x7UtIW5ElLKpDl4ASPuz0FXhNjwnxYcAy0BuHw/wJZr1On9l4o.jpg?size=1280x718&quality=96&sign=1ed3d5f08fcdefd89ab4e02a5041c6d0&type=album)\r\n",
+    "\r\n"
+   ]
   },
   {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
    "source": [
-    "## False triggering\n",
-    "\n",
-    "There are some situations when CUP9 triggering could be false.\n",
-    "\n",
-    "\n",
-    "\n"
+    "FORs = ft.orig_events.FORChip\r\n",
+    "FORs = FORs.loc[ft.four_tracks_zq.reset_index().entry]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "0             4\n1             4\n2             4\n3             4\n4             8\n          ...  \n76771    106687\n76772    106691\n76773    106691\n76774    106691\n76775    106691\nName: entry, Length: 76776, dtype: int64"
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
    ],
-   "cell_type": "markdown",
-   "metadata": {}
+   "source": [
+    "pd.unift.four_tracks_zq.reset_index().entry"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   },
   {
    "cell_type": "code",
@@ -772,8 +847,8 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "stream",
      "name": "stderr",
+     "output_type": "stream",
      "text": [
       "100%|██████████| 81496/81496 [03:31<00:00, 385.60it/s]\n",
       "100%|██████████| 20069/20069 [00:24<00:00, 806.51it/s]\n"
@@ -781,81 +856,82 @@
     }
    ],
    "source": [
-    "from tqdm import tqdm\n",
-    "\n",
-    "# let's upload ITSSensorNum. This param contains numbers of fired FORs in EVENT \n",
-    "ITSSensorNums = ft.orig_events.arrays(filter_name=['T_ITSSensorNum'], library='pd')\n",
-    "\n",
-    "# form arrays of numbers of sensor that linked with TRACKS \n",
-    "track_modules = ft.four_tracks_zq[['T_ITSModuleInner','T_ITSModuleOuter']] // 1000000\n",
-    "\n",
-    "# get FORs number for only four track events with zero total charge\n",
-    "for_sensors = ITSSensorNums.loc[pd.unique(track_modules.reset_index().entry)]\n",
-    "\n",
-    "# combine into one dataframe\n",
-    "df = pd.merge(track_modules.reset_index(),for_sensors.groupby('entry').T_ITSSensorNum.apply(np.array),on='entry')\n",
-    "\n",
-    "# check that sensor linked with track will provide trigger (match with FOR sensor)\n",
-    "df[\"Inner_matched\"] = (abs(abs(df.T_ITSModuleInner - df.T_ITSSensorNum) - 2/5).apply(lambda x: x <= 2/5)) * df.T_ITSSensorNum.apply(lambda x: x < 80)\n",
-    "\n",
-    "df[\"Outer_matched\"] = (abs(abs(df.T_ITSModuleOuter - df.T_ITSSensorNum) - 2/5).apply(lambda x: x <= 2/5)) * df.T_ITSSensorNum.apply(lambda x: x >= 80)\n",
-    "df[\"vPhiInner\"] = np.nan\n",
-    "df.vPhiInner = df.vPhiInner.astype('object')\n",
-    "df[\"vPhiOuter\"] = np.nan\n",
-    "df.vPhiOuter = df.vPhiOuter.astype('object')\n",
-    "\n",
-    "df[\"vPhiInnerValue\"] = np.nan\n",
-    "df.vPhiInnerValue = df.vPhiInnerValue.astype('object')\n",
-    "df[\"vPhiOuterValue\"] = np.nan\n",
-    "df.vPhiOuterValue = df.vPhiOuterValue.astype('object')\n",
-    "\n",
-    "for i in tqdm(range(len(df))):\n",
-    "    vPhiInner1 = np.zeros(20, dtype=np.bool)\n",
-    "    vPhiOuter1 = np.zeros(40, dtype=np.bool)\n",
-    "\n",
-    "    vPhiInnerValues = pd.unique(df.T_ITSSensorNum[i][df.Inner_matched[i]]//4)\n",
-    "    vPhiOuterValues = pd.unique((df.T_ITSSensorNum[i][df.Outer_matched[i]]-80)//4)\n",
-    "\n",
-    "    vPhiInner1[vPhiInnerValues]=True\n",
-    "    df.vPhiInner[i] = vPhiInner1\n",
-    "\n",
-    "    vPhiOuter1[vPhiOuterValues]=True\n",
-    "    df.vPhiOuter[i] = vPhiOuter1\n",
-    "\n",
-    "    df.vPhiInnerValue[i] = vPhiInnerValues\n",
-    "    df.vPhiOuterValue[i] = vPhiOuterValues\n",
-    "\n",
-    "df_dbg = df.copy()\n",
-    "\n",
-    "# take only matched tracks and fill vPhi arrays for inner and outer\n",
-    "df = df[(df.Inner_matched.apply(any) + df.Outer_matched.apply(any))][['entry', 'vPhiInner', 'vPhiOuter']].groupby('entry').sum()\n",
-    "\n",
-    "df[\"triggered\"] = False\n",
-    "\n",
-    "# check incorrect topology \n",
-    "\n",
-    "for t in tqdm(df.index):\n",
-    "    for i in range(10):\n",
-    "        for j in range(2):\n",
-    "            k = 2*i+j\n",
-    "            if  (df.vPhiOuter[t][k]    or df.vPhiOuter[t][k+1]        or df.vPhiOuter[t][k+2]) \\\n",
-    "\t\t    and (df.vPhiOuter[t][k+20] or df.vPhiOuter[t][(k+21)%40]  or df.vPhiOuter[t][(k+22)%40]) \\\n",
-    "\t\t    and (df.vPhiInner[t][i]    or df.vPhiInner[t][i+1]) \\\n",
-    "\t\t    and (df.vPhiInner[t][i+10] or df.vPhiInner[t][(i+11)%20]):\n",
-    "                df.at[t,'triggered'] = True\n",
-    "\n",
-    "triggered_events = df.index[df.triggered]\n",
+    "from tqdm import tqdm\r\n",
+    "import pandas as pd\r\n",
+    "\r\n",
+    "# let's upload ITSSensorNum. This param contains numbers of fired FORs in EVENT \r\n",
+    "ITSSensorNums = ft.orig_events.arrays(filter_name=['FORCchip'], library='pd')\r\n",
+    "\r\n",
+    "# form arrays of numbers of sensor that linked with TRACKS \r\n",
+    "track_modules = ft.four_tracks_zq[['T_ITSModuleInner','T_ITSModuleOuter']] // 1000000\r\n",
+    "\r\n",
+    "# get FORs number for only four track events with zero total charge\r\n",
+    "for_sensors = ITSSensorNums.loc[pd.unique(track_modules.reset_index().entry)]\r\n",
+    "\r\n",
+    "# combine into one dataframe\r\n",
+    "df = pd.merge(track_modules.reset_index(),for_sensors.groupby('entry').T_ITSSensorNum.apply(np.array),on='entry')\r\n",
+    "\r\n",
+    "# check that sensor linked with track will provide trigger (match with FOR sensor)\r\n",
+    "df[\"Inner_matched\"] = (abs(abs(df.T_ITSModuleInner - df.T_ITSSensorNum) - 2/5).apply(lambda x: x <= 2/5)) * df.T_ITSSensorNum.apply(lambda x: x < 80)\r\n",
+    "\r\n",
+    "df[\"Outer_matched\"] = (abs(abs(df.T_ITSModuleOuter - df.T_ITSSensorNum) - 2/5).apply(lambda x: x <= 2/5)) * df.T_ITSSensorNum.apply(lambda x: x >= 80)\r\n",
+    "df[\"vPhiInner\"] = np.nan\r\n",
+    "df.vPhiInner = df.vPhiInner.astype('object')\r\n",
+    "df[\"vPhiOuter\"] = np.nan\r\n",
+    "df.vPhiOuter = df.vPhiOuter.astype('object')\r\n",
+    "\r\n",
+    "df[\"vPhiInnerValue\"] = np.nan\r\n",
+    "df.vPhiInnerValue = df.vPhiInnerValue.astype('object')\r\n",
+    "df[\"vPhiOuterValue\"] = np.nan\r\n",
+    "df.vPhiOuterValue = df.vPhiOuterValue.astype('object')\r\n",
+    "\r\n",
+    "for i in tqdm(range(len(df))):\r\n",
+    "    vPhiInner1 = np.zeros(20, dtype=np.bool)\r\n",
+    "    vPhiOuter1 = np.zeros(40, dtype=np.bool)\r\n",
+    "\r\n",
+    "    vPhiInnerValues = pd.unique(df.T_ITSSensorNum[i][df.Inner_matched[i]]//4)\r\n",
+    "    vPhiOuterValues = pd.unique((df.T_ITSSensorNum[i][df.Outer_matched[i]]-80)//4)\r\n",
+    "\r\n",
+    "    vPhiInner1[vPhiInnerValues]=True\r\n",
+    "    df.vPhiInner[i] = vPhiInner1\r\n",
+    "\r\n",
+    "    vPhiOuter1[vPhiOuterValues]=True\r\n",
+    "    df.vPhiOuter[i] = vPhiOuter1\r\n",
+    "\r\n",
+    "    df.vPhiInnerValue[i] = vPhiInnerValues\r\n",
+    "    df.vPhiOuterValue[i] = vPhiOuterValues\r\n",
+    "\r\n",
+    "df_dbg = df.copy()\r\n",
+    "\r\n",
+    "# take only matched tracks and fill vPhi arrays for inner and outer\r\n",
+    "df = df[(df.Inner_matched.apply(any) + df.Outer_matched.apply(any))][['entry', 'vPhiInner', 'vPhiOuter']].groupby('entry').sum()\r\n",
+    "\r\n",
+    "df[\"triggered\"] = False\r\n",
+    "\r\n",
+    "# check incorrect topology \r\n",
+    "\r\n",
+    "for t in tqdm(df.index):\r\n",
+    "    for i in range(10):\r\n",
+    "        for j in range(2):\r\n",
+    "            k = 2*i+j\r\n",
+    "            if  (df.vPhiOuter[t][k]    or df.vPhiOuter[t][k+1]        or df.vPhiOuter[t][k+2]) \\\r\n",
+    "\t\t    and (df.vPhiOuter[t][k+20] or df.vPhiOuter[t][(k+21)%40]  or df.vPhiOuter[t][(k+22)%40]) \\\r\n",
+    "\t\t    and (df.vPhiInner[t][i]    or df.vPhiInner[t][i+1]) \\\r\n",
+    "\t\t    and (df.vPhiInner[t][i+10] or df.vPhiInner[t][(i+11)%20]):\r\n",
+    "                df.at[t,'triggered'] = True\r\n",
+    "\r\n",
+    "triggered_events = df.index[df.triggered]\r\n",
     "untriggered_events = df.index[~df.triggered]"
    ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "> Comparison with Valeri data\n",
     "\n",
     "$\\downarrow \\downarrow \\downarrow \\downarrow$ TO BE REMOVED $\\downarrow \\downarrow \\downarrow \\downarrow $"
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
@@ -887,8 +963,100 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "execute_result",
      "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>entry</th>\n",
+       "      <th>subentry</th>\n",
+       "      <th>T_ITSModuleInner</th>\n",
+       "      <th>T_ITSModuleOuter</th>\n",
+       "      <th>T_ITSSensorNum</th>\n",
+       "      <th>Inner_matched</th>\n",
+       "      <th>Outer_matched</th>\n",
+       "      <th>vPhiInner</th>\n",
+       "      <th>vPhiOuter</th>\n",
+       "      <th>vPhiInnerValue</th>\n",
+       "      <th>vPhiOuterValue</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>44</th>\n",
+       "      <td>76</td>\n",
+       "      <td>0</td>\n",
+       "      <td>70.0</td>\n",
+       "      <td>218.0</td>\n",
+       "      <td>[1, 5, 9, 21, 49, 57, 58, 61, 70, 72, 74, 78, ...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[17]</td>\n",
+       "      <td>[34]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>45</th>\n",
+       "      <td>76</td>\n",
+       "      <td>1</td>\n",
+       "      <td>61.0</td>\n",
+       "      <td>201.0</td>\n",
+       "      <td>[1, 5, 9, 21, 49, 57, 58, 61, 70, 72, 74, 78, ...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[15]</td>\n",
+       "      <td>[30]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>46</th>\n",
+       "      <td>76</td>\n",
+       "      <td>2</td>\n",
+       "      <td>74.0</td>\n",
+       "      <td>230.0</td>\n",
+       "      <td>[1, 5, 9, 21, 49, 57, 58, 61, 70, 72, 74, 78, ...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[18]</td>\n",
+       "      <td>[37]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>47</th>\n",
+       "      <td>76</td>\n",
+       "      <td>3</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>97.0</td>\n",
+       "      <td>[1, 5, 9, 21, 49, 57, 58, 61, 70, 72, 74, 78, ...</td>\n",
+       "      <td>[False, False, True, False, False, False, Fals...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[False, False, True, False, False, False, Fals...</td>\n",
+       "      <td>[False, False, False, False, True, False, Fals...</td>\n",
+       "      <td>[2]</td>\n",
+       "      <td>[4]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
       "text/plain": [
        "    entry  subentry  T_ITSModuleInner  T_ITSModuleOuter  \\\n",
        "44     76         0              70.0             218.0   \n",
@@ -931,11 +1099,11 @@
        "45           [30]  \n",
        "46           [37]  \n",
        "47            [4]  "
-      ],
-      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>entry</th>\n      <th>subentry</th>\n      <th>T_ITSModuleInner</th>\n      <th>T_ITSModuleOuter</th>\n      <th>T_ITSSensorNum</th>\n      <th>Inner_matched</th>\n      <th>Outer_matched</th>\n      <th>vPhiInner</th>\n      <th>vPhiOuter</th>\n      <th>vPhiInnerValue</th>\n      <th>vPhiOuterValue</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>44</th>\n      <td>76</td>\n      <td>0</td>\n      <td>70.0</td>\n      <td>218.0</td>\n      <td>[1, 5, 9, 21, 49, 57, 58, 61, 70, 72, 74, 78, ...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[17]</td>\n      <td>[34]</td>\n    </tr>\n    <tr>\n      <th>45</th>\n      <td>76</td>\n      <td>1</td>\n      <td>61.0</td>\n      <td>201.0</td>\n      <td>[1, 5, 9, 21, 49, 57, 58, 61, 70, 72, 74, 78, ...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[15]</td>\n      <td>[30]</td>\n    </tr>\n    <tr>\n      <th>46</th>\n      <td>76</td>\n      <td>2</td>\n      <td>74.0</td>\n      <td>230.0</td>\n      <td>[1, 5, 9, 21, 49, 57, 58, 61, 70, 72, 74, 78, ...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[18]</td>\n      <td>[37]</td>\n    </tr>\n    <tr>\n      <th>47</th>\n      <td>76</td>\n      <td>3</td>\n      <td>9.0</td>\n      <td>97.0</td>\n      <td>[1, 5, 9, 21, 49, 57, 58, 61, 70, 72, 74, 78, ...</td>\n      <td>[False, False, True, False, False, False, Fals...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[False, False, True, False, False, False, Fals...</td>\n      <td>[False, False, False, False, True, False, Fals...</td>\n      <td>[2]</td>\n      <td>[4]</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
+      ]
      },
+     "execution_count": 132,
      "metadata": {},
-     "execution_count": 132
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -948,10 +1116,189 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "stream",
      "name": "stdout",
+     "output_type": "stream",
      "text": [
-      "0 0\nInner barrel:\nFalse False\nFalse False\n\nOuter barrel:\nFalse False False\nFalse False False\nuntriggered\n1 1\nInner barrel:\nFalse False\nFalse False\n\nOuter barrel:\nFalse False False\nFalse False False\nuntriggered\n0 2\nInner barrel:\nFalse True\nFalse False\n\nOuter barrel:\nFalse False True\nFalse False False\nuntriggered\n1 3\nInner barrel:\nFalse True\nFalse False\n\nOuter barrel:\nFalse True False\nFalse False False\nuntriggered\n0 4\nInner barrel:\nTrue False\nFalse False\n\nOuter barrel:\nTrue False False\nFalse False False\nuntriggered\n1 5\nInner barrel:\nTrue False\nFalse False\n\nOuter barrel:\nFalse False False\nFalse False False\nuntriggered\n0 6\nInner barrel:\nFalse False\nFalse False\n\nOuter barrel:\nFalse False False\nFalse False False\nuntriggered\n1 7\nInner barrel:\nFalse False\nFalse False\n\nOuter barrel:\nFalse False False\nFalse False False\nuntriggered\n0 8\nInner barrel:\nFalse False\nFalse True\n\nOuter barrel:\nFalse False False\nFalse False True\nuntriggered\n1 9\nInner barrel:\nFalse False\nFalse True\n\nOuter barrel:\nFalse False False\nFalse True False\nuntriggered\n0 10\nInner barrel:\nFalse False\nTrue False\n\nOuter barrel:\nFalse False False\nTrue False False\nuntriggered\n1 11\nInner barrel:\nFalse False\nTrue False\n\nOuter barrel:\nFalse False False\nFalse False False\nuntriggered\n0 12\nInner barrel:\nFalse False\nFalse True\n\nOuter barrel:\nFalse False False\nFalse False True\nuntriggered\n1 13\nInner barrel:\nFalse False\nFalse True\n\nOuter barrel:\nFalse False False\nFalse True False\nuntriggered\n0 14\nInner barrel:\nFalse False\nTrue True\n\nOuter barrel:\nFalse False False\nTrue False False\nuntriggered\n1 15\nInner barrel:\nFalse False\nTrue True\n\nOuter barrel:\nFalse False False\nFalse False True\nuntriggered\n0 16\nInner barrel:\nFalse False\nTrue False\n\nOuter barrel:\nFalse False False\nFalse True False\nuntriggered\n1 17\nInner barrel:\nFalse False\nTrue False\n\nOuter barrel:\nFalse False False\nTrue False False\nuntriggered\n0 18\nInner barrel:\nFalse False\nFalse False\n\nOuter barrel:\nFalse False False\nFalse False False\nuntriggered\n1 19\nInner barrel:\nFalse False\nFalse False\n\nOuter barrel:\nFalse False False\nFalse False False\nuntriggered\n"
+      "0 0\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "False False\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "False False False\n",
+      "untriggered\n",
+      "1 1\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "False False\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "False False False\n",
+      "untriggered\n",
+      "0 2\n",
+      "Inner barrel:\n",
+      "False True\n",
+      "False False\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False True\n",
+      "False False False\n",
+      "untriggered\n",
+      "1 3\n",
+      "Inner barrel:\n",
+      "False True\n",
+      "False False\n",
+      "\n",
+      "Outer barrel:\n",
+      "False True False\n",
+      "False False False\n",
+      "untriggered\n",
+      "0 4\n",
+      "Inner barrel:\n",
+      "True False\n",
+      "False False\n",
+      "\n",
+      "Outer barrel:\n",
+      "True False False\n",
+      "False False False\n",
+      "untriggered\n",
+      "1 5\n",
+      "Inner barrel:\n",
+      "True False\n",
+      "False False\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "False False False\n",
+      "untriggered\n",
+      "0 6\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "False False\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "False False False\n",
+      "untriggered\n",
+      "1 7\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "False False\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "False False False\n",
+      "untriggered\n",
+      "0 8\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "False True\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "False False True\n",
+      "untriggered\n",
+      "1 9\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "False True\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "False True False\n",
+      "untriggered\n",
+      "0 10\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "True False\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "True False False\n",
+      "untriggered\n",
+      "1 11\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "True False\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "False False False\n",
+      "untriggered\n",
+      "0 12\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "False True\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "False False True\n",
+      "untriggered\n",
+      "1 13\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "False True\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "False True False\n",
+      "untriggered\n",
+      "0 14\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "True True\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "True False False\n",
+      "untriggered\n",
+      "1 15\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "True True\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "False False True\n",
+      "untriggered\n",
+      "0 16\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "True False\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "False True False\n",
+      "untriggered\n",
+      "1 17\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "True False\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "True False False\n",
+      "untriggered\n",
+      "0 18\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "False False\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "False False False\n",
+      "untriggered\n",
+      "1 19\n",
+      "Inner barrel:\n",
+      "False False\n",
+      "False False\n",
+      "\n",
+      "Outer barrel:\n",
+      "False False False\n",
+      "False False False\n",
+      "untriggered\n"
      ]
     }
    ],
@@ -984,8 +1331,109 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "execute_result",
      "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>vPhiInner</th>\n",
+       "      <th>vPhiOuter</th>\n",
+       "      <th>triggered</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>entry</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>[True, False, False, False, False, False, Fals...</td>\n",
+       "      <td>[True, False, False, False, False, False, Fals...</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>[False, False, True, False, False, False, Fals...</td>\n",
+       "      <td>[False, False, False, False, False, True, Fals...</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>26</th>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>27</th>\n",
+       "      <td>[False, False, False, False, True, False, Fals...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>39</th>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>114609</th>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>114623</th>\n",
+       "      <td>[False, False, True, False, False, False, Fals...</td>\n",
+       "      <td>[False, False, False, False, True, False, Fals...</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>114635</th>\n",
+       "      <td>[False, False, True, False, False, False, Fals...</td>\n",
+       "      <td>[False, False, False, False, True, False, Fals...</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>114638</th>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>[False, False, False, False, False, False, Fal...</td>\n",
+       "      <td>False</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>114647</th>\n",
+       "      <td>[False, False, True, False, False, False, Fals...</td>\n",
+       "      <td>[False, False, False, False, True, False, Fals...</td>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>20069 rows × 3 columns</p>\n",
+       "</div>"
+      ],
       "text/plain": [
        "                                                vPhiInner  \\\n",
        "entry                                                       \n",
@@ -1016,11 +1464,11 @@
        "114647  [False, False, False, False, True, False, Fals...       True  \n",
        "\n",
        "[20069 rows x 3 columns]"
-      ],
-      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>vPhiInner</th>\n      <th>vPhiOuter</th>\n      <th>triggered</th>\n    </tr>\n    <tr>\n      <th>entry</th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>6</th>\n      <td>[True, False, False, False, False, False, Fals...</td>\n      <td>[True, False, False, False, False, False, Fals...</td>\n      <td>False</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>[False, False, True, False, False, False, Fals...</td>\n      <td>[False, False, False, False, False, True, Fals...</td>\n      <td>True</td>\n    </tr>\n    <tr>\n      <th>26</th>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>False</td>\n    </tr>\n    <tr>\n      <th>27</th>\n      <td>[False, False, False, False, True, False, Fals...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>True</td>\n    </tr>\n    <tr>\n      <th>39</th>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>True</td>\n    </tr>\n    <tr>\n      <th>...</th>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n    </tr>\n    <tr>\n      <th>114609</th>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>True</td>\n    </tr>\n    <tr>\n      <th>114623</th>\n      <td>[False, False, True, False, False, False, Fals...</td>\n      <td>[False, False, False, False, True, False, Fals...</td>\n      <td>True</td>\n    </tr>\n    <tr>\n      <th>114635</th>\n      <td>[False, False, True, False, False, False, Fals...</td>\n      <td>[False, False, False, False, True, False, Fals...</td>\n      <td>True</td>\n    </tr>\n    <tr>\n      <th>114638</th>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>[False, False, False, False, False, False, Fal...</td>\n      <td>False</td>\n    </tr>\n    <tr>\n      <th>114647</th>\n      <td>[False, False, True, False, False, False, Fals...</td>\n      <td>[False, False, False, False, True, False, Fals...</td>\n      <td>True</td>\n    </tr>\n  </tbody>\n</table>\n<p>20069 rows × 3 columns</p>\n</div>"
+      ]
      },
+     "execution_count": 151,
      "metadata": {},
-     "execution_count": 151
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -1033,7 +1481,6 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "execute_result",
      "data": {
       "text/plain": [
        "Int64Index([     9,     27,     39,     46,     49,     50,     73,     80,\n",
@@ -1044,8 +1491,9 @@
        "           dtype='int64', name='entry', length=10757)"
       ]
      },
+     "execution_count": 147,
      "metadata": {},
-     "execution_count": 147
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -1058,10 +1506,29 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "stream",
      "name": "stdout",
+     "output_type": "stream",
      "text": [
-      "1 False\n5 False\n9 True\n21 False\n49 False\n57 False\n58 False\n61 True\n70 True\n72 False\n74 True\n78 False\n97 True\n117 False\n121 False\n196 False\n201 True\n218 True\n230 True\n236 False\n"
+      "1 False\n",
+      "5 False\n",
+      "9 True\n",
+      "21 False\n",
+      "49 False\n",
+      "57 False\n",
+      "58 False\n",
+      "61 True\n",
+      "70 True\n",
+      "72 False\n",
+      "74 True\n",
+      "78 False\n",
+      "97 True\n",
+      "117 False\n",
+      "121 False\n",
+      "196 False\n",
+      "201 True\n",
+      "218 True\n",
+      "230 True\n",
+      "236 False\n"
      ]
     }
    ],
@@ -1078,22 +1545,22 @@
    ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "$\\uparrow \\uparrow \\uparrow \\uparrow$ TO BE REMOVED $\\uparrow \\uparrow \\uparrow \\uparrow $\n"
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "### Triggered ratios\n",
     "|class|total|triggered|untriggered|triggered, %\n",
     "|:--:|:--:|:--:|:--:|\n",
     "|four track zq|20069|10757|9312|46|\n",
     "|four track zq 4 TPC|6292|3658|2559|58|"
-   ],
-   "cell_type": "markdown",
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
@@ -1101,14 +1568,14 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "execute_result",
      "data": {
       "text/plain": [
        "0.46399920275051076"
       ]
      },
+     "execution_count": 99,
      "metadata": {},
-     "execution_count": 99
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -1131,26 +1598,28 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "display_data",
      "data": {
-      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
       "application/vnd.jupyter.widget-view+json": {
+       "model_id": "54f46b0373704688b3816c24abc26667",
        "version_major": 2,
-       "version_minor": 0,
-       "model_id": "54f46b0373704688b3816c24abc26667"
-      }
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
      },
-     "metadata": {}
+     "metadata": {},
+     "output_type": "display_data"
     },
     {
-     "output_type": "execute_result",
      "data": {
       "text/plain": [
        "<matplotlib.legend.Legend at 0x1fb0b6be220>"
       ]
      },
+     "execution_count": 16,
      "metadata": {},
-     "execution_count": 16
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -1187,26 +1656,28 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "display_data",
      "data": {
-      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
       "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2ff2e3a2f50d4027ada7eccdbe8887dd",
        "version_major": 2,
-       "version_minor": 0,
-       "model_id": "2ff2e3a2f50d4027ada7eccdbe8887dd"
-      }
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
      },
-     "metadata": {}
+     "metadata": {},
+     "output_type": "display_data"
     },
     {
-     "output_type": "execute_result",
      "data": {
       "text/plain": [
        "<matplotlib.legend.Legend at 0x1fb0b74db80>"
       ]
      },
+     "execution_count": 34,
      "metadata": {},
-     "execution_count": 34
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -1247,26 +1718,28 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "display_data",
      "data": {
-      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
       "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c84d442d51a24540b365061b9933e17e",
        "version_major": 2,
-       "version_minor": 0,
-       "model_id": "c84d442d51a24540b365061b9933e17e"
-      }
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
      },
-     "metadata": {}
+     "metadata": {},
+     "output_type": "display_data"
     },
     {
-     "output_type": "execute_result",
      "data": {
       "text/plain": [
        "<matplotlib.legend.Legend at 0x1fb0a37bac0>"
       ]
      },
+     "execution_count": 46,
      "metadata": {},
-     "execution_count": 46
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -1300,7 +1773,6 @@
    "metadata": {},
    "outputs": [
     {
-     "output_type": "execute_result",
      "data": {
       "text/plain": [
        "(array([0.        , 0.        , 0.        , 0.        , 0.02078998,\n",
@@ -1336,8 +1808,9 @@
        " [<matplotlib.patches.Polygon at 0x1fb08375280>])"
       ]
      },
+     "execution_count": 47,
      "metadata": {},
-     "execution_count": 47
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -1347,13 +1820,13 @@
  ],
  "metadata": {
   "kernelspec": {
-   "name": "python3",
    "display_name": "Python 3.8.6 64-bit",
    "metadata": {
     "interpreter": {
      "hash": "2db524e06e9f5f4ffedc911c917cb75e12dbc923643829bf417064a77eb14d37"
     }
-   }
+   },
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -1365,7 +1838,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.6-final"
+   "version": "3.8.6"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/Draft.ipynb b/notebooks/Draft.ipynb
index ff03cba..1a10816 100644
--- a/notebooks/Draft.ipynb
+++ b/notebooks/Draft.ipynb
@@ -9,260 +9,189 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 8,
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "import uproot4\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import mplhep as hep\n",
-    "import pandas as pd\n",
-    "import awkward1\n",
-    "import concurrent.futures\n",
-    "\n",
-    "from modules.FourTrackEvents import *\n",
-    "\n",
-    "ccup9_2015_file = r'D:\\GoogleDrive\\Job\\cern\\Alice\\analysis\\data\\RhoPrime\\2015\\4Prongs2015oLast.root'\n",
-    "ccup9_2015_local_test = r'D:\\GoogleDrive\\Job\\cern\\Alice\\analysis\\dev\\grid\\selection\\RhoPrime\\macro\\AnalysisResults.root'\n",
-    "\n",
-    "tree_name = '4Prongs/events'\n",
-    "# dfs.loc[0] # get dataframe part with entry = 0    \n",
-    "\n",
-    "executor = concurrent.futures.ThreadPoolExecutor()\n",
-    "\n",
-    "\n",
-    "branches = ['T_Px', 'T_Py', 'T_Pz',  'T_Q', 'T_NumberOfSigmaTPCPion', 'T_TPCRefit', 'T_TPCNCls', 'T_Phi', 'T_Eta', 'T_HasPointOnITSLayer0','T_HasPointOnITSLayer1', 'T_ITSModuleInner', 'T_ITSModuleOuter']\n",
-    "events = uproot4.open(ccup9_2015_file, object_cache = 5000, num_workers=8, interpretation_executor=executor)[tree_name]\n",
-    "# ft = FourTrackEvents(ccup9_2015_file,tree_name,branches)\n",
-    "\n",
-    "# ft.orig_events.show()"
+    "import uproot4\r\n",
+    "import numpy as np\r\n",
+    "import pandas as pd\r\n",
+    "import concurrent.futures\r\n",
+    "\r\n",
+    "from modules.FourTrackEvents import *\r\n",
+    "\r\n",
+    "ccup9_2015_file = r'D:\\GoogleDrive\\Job\\cern\\Alice\\analysis\\data\\RhoPrime\\2015\\4Prongs2015oLast.root'\r\n",
+    "\r\n",
+    "tree_name = '4Prongs/events'\r\n",
+    "# dfs.loc[0] # get dataframe part with entry = 0    \r\n",
+    "\r\n",
+    "executor = concurrent.futures.ThreadPoolExecutor()\r\n",
+    "\r\n",
+    "branches = ['T_Px', 'T_Py', 'T_Pz',  'T_Q', 'T_NumberOfSigmaTPCPion', 'T_TPCRefit', 'T_TPCNCls', 'T_Phi', 'T_Eta', 'T_HasPointOnITSLayer0','T_HasPointOnITSLayer1', 'T_ITSModuleInner', 'T_ITSModuleOuter']\r\n",
+    "\r\n",
+    "evColumns = [\"RunNum\", \"PeriodNumber\", \"OrbitNumber\", \"BunchCrossNumber\", \"Mass\", \"Pt\", \"Q\", \"Rapidity\", \"Phi\", \"ZNAenergy\", \"ZNCenergy\", \"ZPAenergy\", \"ZPCenergy\", \"VtxX\", \"VtxY\", \"VtxZ\", \"VtxContrib\", \"VtxChi2\", \"VtxNDF\", \"SpdVtxX\", \"SpdVtxY\", \"SpdVtxZ\", \"SpdVtxContrib\", \"V0Adecision\", \"V0Cdecision\", \"ADAdecision\", \"ADCdecision\", \"V0Afired\", \"V0Cfired\", \"ADAfired\", \"ADCfired\", \"STPfired\", \"SMBfired\", \"SM2fired\", \"SH1fired\", \"OM2fired\", \"OMUfired\", \"IsTriggered\", \"nTracklets\", \"nTracks\"] #, \"FORChip\"]\r\n",
+    "\r\n",
+    "events = uproot4.open(ccup9_2015_file, object_cache = 5000, num_workers=12, interpretation_executor=executor)[tree_name]\r\n",
+    "\r\n",
+    "data_tracks = events.arrays(filter_name=branches, library='pd', array_cache=5000)#, entry_stop=1000000)\r\n",
+    "chips = events.arrays(filter_name=['FORChip'], library='pd') #, array_cache=5000)#, entry_stop=1000000)\r\n",
+    "chips = chips.groupby('entry').FORChip.apply(list)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
-   "source": [
-    "\n",
-    "data = events.arrays(filter_name=branches, library='np')"
-   ]
+   "source": []
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
-     "output_type": "execute_result",
      "data": {
-      "text/plain": [
-       "(array([     4,      8,     15, ..., 106689, 106691, 106704], dtype=int64),)"
-      ]
+      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>RunNum</th>\n      <th>PeriodNumber</th>\n      <th>OrbitNumber</th>\n      <th>BunchCrossNumber</th>\n      <th>Mass</th>\n      <th>Pt</th>\n      <th>Q</th>\n      <th>Rapidity</th>\n      <th>Phi</th>\n      <th>ZNAenergy</th>\n      <th>...</th>\n      <th>ADCfired</th>\n      <th>STPfired</th>\n      <th>SMBfired</th>\n      <th>SM2fired</th>\n      <th>SH1fired</th>\n      <th>OM2fired</th>\n      <th>OMUfired</th>\n      <th>IsTriggered</th>\n      <th>nTracklets</th>\n      <th>nTracks</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>245145</td>\n      <td>0</td>\n      <td>13362961</td>\n      <td>674</td>\n      <td>2.802221</td>\n      <td>0.567083</td>\n      <td>-1718026238</td>\n      <td>0.056647</td>\n      <td>-2.397827</td>\n      <td>-92.604172</td>\n      <td>...</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>4</td>\n      <td>8</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>245145</td>\n      <td>3</td>\n      <td>3674210</td>\n      <td>3438</td>\n      <td>2.996301</td>\n      <td>3.597858</td>\n      <td>-1718026240</td>\n      <td>-0.318146</td>\n      <td>1.097847</td>\n      <td>-428.223267</td>\n      <td>...</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>4</td>\n      <td>6</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>245145</td>\n      <td>1</td>\n      <td>12644173</td>\n      <td>2126</td>\n      <td>3.198086</td>\n      <td>1.573138</td>\n      <td>-1717960705</td>\n      <td>-0.360621</td>\n      <td>1.949035</td>\n      <td>9.372114</td>\n      <td>...</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>3</td>\n      <td>5</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>245145</td>\n      <td>1</td>\n      <td>16213555</td>\n      <td>3239</td>\n      <td>3.103773</td>\n      <td>0.797095</td>\n      <td>-1718026238</td>\n      <td>0.011698</td>\n      <td>1.207371</td>\n      <td>291.203796</td>\n      <td>...</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>12</td>\n      <td>8</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>245145</td>\n      <td>1</td>\n      <td>5525160</td>\n      <td>2195</td>\n      <td>1.679243</td>\n      <td>0.388082</td>\n      <td>-1718026240</td>\n      <td>-0.595928</td>\n      <td>0.879197</td>\n      <td>344.992584</td>\n      <td>...</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>27</td>\n      <td>4</td>\n    </tr>\n    <tr>\n      <th>...</th>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n    </tr>\n    <tr>\n      <th>106700</th>\n      <td>246994</td>\n      <td>3</td>\n      <td>3847039</td>\n      <td>3472</td>\n      <td>5.037951</td>\n      <td>7.349191</td>\n      <td>-1717960706</td>\n      <td>-0.550232</td>\n      <td>0.569475</td>\n      <td>-384.684784</td>\n      <td>...</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>1</td>\n      <td>6</td>\n    </tr>\n    <tr>\n      <th>106701</th>\n      <td>246994</td>\n      <td>2</td>\n      <td>62739</td>\n      <td>532</td>\n      <td>8.490516</td>\n      <td>5.970900</td>\n      <td>-1717960708</td>\n      <td>-1.047591</td>\n      <td>-2.963939</td>\n      <td>6169.960449</td>\n      <td>...</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>74</td>\n      <td>22</td>\n    </tr>\n    <tr>\n      <th>106702</th>\n      <td>246994</td>\n      <td>1</td>\n      <td>566110</td>\n      <td>3361</td>\n      <td>5.639124</td>\n      <td>0.815031</td>\n      <td>-1717960707</td>\n      <td>0.497559</td>\n      <td>2.903033</td>\n      <td>-624.092224</td>\n      <td>...</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>6</td>\n      <td>5</td>\n    </tr>\n    <tr>\n      <th>106703</th>\n      <td>246994</td>\n      <td>2</td>\n      <td>3250243</td>\n      <td>1830</td>\n      <td>3.033328</td>\n      <td>2.172899</td>\n      <td>-1718026239</td>\n      <td>0.083928</td>\n      <td>-2.649607</td>\n      <td>75394.562500</td>\n      <td>...</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>4</td>\n      <td>7</td>\n    </tr>\n    <tr>\n      <th>106704</th>\n      <td>246994</td>\n      <td>2</td>\n      <td>3245492</td>\n      <td>1603</td>\n      <td>0.695303</td>\n      <td>0.673679</td>\n      <td>-1718026238</td>\n      <td>0.195638</td>\n      <td>0.555802</td>\n      <td>-284.629578</td>\n      <td>...</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>1</td>\n      <td>4</td>\n    </tr>\n  </tbody>\n</table>\n<p>106705 rows × 40 columns</p>\n</div>",
+      "text/plain": "        RunNum  PeriodNumber  OrbitNumber  BunchCrossNumber      Mass  \\\n0       245145             0     13362961               674  2.802221   \n1       245145             3      3674210              3438  2.996301   \n2       245145             1     12644173              2126  3.198086   \n3       245145             1     16213555              3239  3.103773   \n4       245145             1      5525160              2195  1.679243   \n...        ...           ...          ...               ...       ...   \n106700  246994             3      3847039              3472  5.037951   \n106701  246994             2        62739               532  8.490516   \n106702  246994             1       566110              3361  5.639124   \n106703  246994             2      3250243              1830  3.033328   \n106704  246994             2      3245492              1603  0.695303   \n\n              Pt           Q  Rapidity       Phi     ZNAenergy  ...  ADCfired  \\\n0       0.567083 -1718026238  0.056647 -2.397827    -92.604172  ...     False   \n1       3.597858 -1718026240 -0.318146  1.097847   -428.223267  ...     False   \n2       1.573138 -1717960705 -0.360621  1.949035      9.372114  ...     False   \n3       0.797095 -1718026238  0.011698  1.207371    291.203796  ...     False   \n4       0.388082 -1718026240 -0.595928  0.879197    344.992584  ...     False   \n...          ...         ...       ...       ...           ...  ...       ...   \n106700  7.349191 -1717960706 -0.550232  0.569475   -384.684784  ...     False   \n106701  5.970900 -1717960708 -1.047591 -2.963939   6169.960449  ...     False   \n106702  0.815031 -1717960707  0.497559  2.903033   -624.092224  ...     False   \n106703  2.172899 -1718026239  0.083928 -2.649607  75394.562500  ...     False   \n106704  0.673679 -1718026238  0.195638  0.555802   -284.629578  ...     False   \n\n        STPfired  SMBfired  SM2fired  SH1fired  OM2fired  OMUfired  \\\n0           True      True      True      True     False     False   \n1           True      True      True      True      True     False   \n2           True      True      True      True      True      True   \n3           True      True      True      True      True      True   \n4           True      True      True      True     False     False   \n...          ...       ...       ...       ...       ...       ...   \n106700      True      True      True      True     False     False   \n106701      True      True      True      True      True     False   \n106702      True      True      True      True      True      True   \n106703      True      True      True      True      True      True   \n106704      True      True      True      True     False     False   \n\n        IsTriggered  nTracklets  nTracks  \n0             False           4        8  \n1             False           4        6  \n2             False           3        5  \n3             False          12        8  \n4             False          27        4  \n...             ...         ...      ...  \n106700        False           1        6  \n106701        False          74       22  \n106702        False           6        5  \n106703        False           4        7  \n106704        False           1        4  \n\n[106705 rows x 40 columns]"
      },
+     "execution_count": 11,
      "metadata": {},
-     "execution_count": 28
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "np.where(np.array(list(map(lambda x : len(x), data['T_Q']))) == 4)"
+    "data"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [
-    {
-     "output_type": "execute_result",
-     "data": {
-      "text/plain": [
-       "array([ 0.17769662, -0.56042844,  0.5997385 ,  0.03050027], dtype=float32)"
-      ]
-     },
-     "metadata": {},
-     "execution_count": 29
-    }
-   ],
-   "source": [
-    "data['T_Px'][4]"
-   ]
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 51,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# let's upload ITSSensorNum. This param contains numbers of fired FORs in EVENT \n",
-    "ITSSensorNums = ft.orig_events.arrays(filter_name=['FORChip','IsTriggered', 'STPfired','V0Afired','V0Cfired','ADAfired','ADCfired','STPfired','SMBfired','SM2fired','SH1fired','OM2fired','OMUfired'], library='pd')\n",
-    "\n",
-    "# form arrays of numbers of sensor that linked with TRACKS \n",
-    "track_modules = ft.four_tracks_zq[['T_ITSModuleInner','T_ITSModuleOuter']] // 1000000\n",
-    "\n",
-    "# get FORs number for only four track events with zero total charge\n",
-    "for_sensors = ITSSensorNums.loc[pd.unique(track_modules.reset_index().entry)]\n",
-    "\n",
-    "# combine into one dataframe\n",
-    "df = pd.merge(track_modules.reset_index(),for_sensors.groupby('entry').FORChip.apply(np.array)//5,on='entry')"
+    "four_tracks_events = np.where(np.array(list(map(lambda x : len(x), data['T_Q'][is_triggered]))) == 4)\r\n",
+    "zero_charged_events = np.where(np.array(list(map(lambda x : sum(x), data['T_Q'][is_triggered]))) == 0)\r\n",
+    "four_tracks_zero_charged_events = np.intersect1d(four_tracks_events, zero_charged_events)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [
     {
-     "output_type": "execute_result",
      "data": {
-      "text/plain": [
-       "                V0Afired  V0Cfired  ADAfired  ADCfired  STPfired  SMBfired  \\\n",
-       "entry subentry                                                               \n",
-       "0     0            False     False     False     False      True      True   \n",
-       "      1            False     False     False     False      True      True   \n",
-       "      2            False     False     False     False      True      True   \n",
-       "      3            False     False     False     False      True      True   \n",
-       "      4            False     False     False     False      True      True   \n",
-       "      5            False     False     False     False      True      True   \n",
-       "      6            False     False     False     False      True      True   \n",
-       "      7            False     False     False     False      True      True   \n",
-       "      8            False     False     False     False      True      True   \n",
-       "      9            False     False     False     False      True      True   \n",
-       "      10           False     False     False     False      True      True   \n",
-       "      11           False     False     False     False      True      True   \n",
-       "      12           False     False     False     False      True      True   \n",
-       "      13           False     False     False     False      True      True   \n",
-       "      14           False     False     False     False      True      True   \n",
-       "1     0            False     False     False     False      True      True   \n",
-       "      1            False     False     False     False      True      True   \n",
-       "      2            False     False     False     False      True      True   \n",
-       "      3            False     False     False     False      True      True   \n",
-       "      4            False     False     False     False      True      True   \n",
-       "      5            False     False     False     False      True      True   \n",
-       "      6            False     False     False     False      True      True   \n",
-       "      7            False     False     False     False      True      True   \n",
-       "      8            False     False     False     False      True      True   \n",
-       "      9            False     False     False     False      True      True   \n",
-       "      10           False     False     False     False      True      True   \n",
-       "      11           False     False     False     False      True      True   \n",
-       "      12           False     False     False     False      True      True   \n",
-       "2     0            False     False     False     False      True      True   \n",
-       "      1            False     False     False     False      True      True   \n",
-       "      2            False     False     False     False      True      True   \n",
-       "      3            False     False     False     False      True      True   \n",
-       "      4            False     False     False     False      True      True   \n",
-       "      5            False     False     False     False      True      True   \n",
-       "      6            False     False     False     False      True      True   \n",
-       "3     0            False     False     False     False      True      True   \n",
-       "      1            False     False     False     False      True      True   \n",
-       "      2            False     False     False     False      True      True   \n",
-       "      3            False     False     False     False      True      True   \n",
-       "      4            False     False     False     False      True      True   \n",
-       "      5            False     False     False     False      True      True   \n",
-       "      6            False     False     False     False      True      True   \n",
-       "      7            False     False     False     False      True      True   \n",
-       "      8            False     False     False     False      True      True   \n",
-       "      9            False     False     False     False      True      True   \n",
-       "      10           False     False     False     False      True      True   \n",
-       "      11           False     False     False     False      True      True   \n",
-       "      12           False     False     False     False      True      True   \n",
-       "      13           False     False     False     False      True      True   \n",
-       "      14           False     False     False     False      True      True   \n",
-       "      15           False     False     False     False      True      True   \n",
-       "      16           False     False     False     False      True      True   \n",
-       "      17           False     False     False     False      True      True   \n",
-       "      18           False     False     False     False      True      True   \n",
-       "      19           False     False     False     False      True      True   \n",
-       "      20           False     False     False     False      True      True   \n",
-       "      21           False     False     False     False      True      True   \n",
-       "      22           False     False     False     False      True      True   \n",
-       "      23           False     False     False     False      True      True   \n",
-       "\n",
-       "                SM2fired  SH1fired  OM2fired  OMUfired  IsTriggered  FORChip  \n",
-       "entry subentry                                                                \n",
-       "0     0             True      True     False     False        False       48  \n",
-       "      1             True      True     False     False        False      168  \n",
-       "      2             True      True     False     False        False      310  \n",
-       "      3             True      True     False     False        False      369  \n",
-       "      4             True      True     False     False        False      387  \n",
-       "      5             True      True     False     False        False      389  \n",
-       "      6             True      True     False     False        False      748  \n",
-       "      7             True      True     False     False        False      820  \n",
-       "      8             True      True     False     False        False      830  \n",
-       "      9             True      True     False     False        False      872  \n",
-       "      10            True      True     False     False        False      900  \n",
-       "      11            True      True     False     False        False      920  \n",
-       "      12            True      True     False     False        False      991  \n",
-       "      13            True      True     False     False        False     1070  \n",
-       "      14            True      True     False     False        False     1147  \n",
-       "1     0             True      True      True     False        False       71  \n",
-       "      1             True      True      True     False        False       88  \n",
-       "      2             True      True      True     False        False      126  \n",
-       "      3             True      True      True     False        False      127  \n",
-       "      4             True      True      True     False        False      149  \n",
-       "      5             True      True      True     False        False      331  \n",
-       "      6             True      True      True     False        False      358  \n",
-       "      7             True      True      True     False        False      386  \n",
-       "      8             True      True      True     False        False      387  \n",
-       "      9             True      True      True     False        False      534  \n",
-       "      10            True      True      True     False        False      587  \n",
-       "      11            True      True      True     False        False      665  \n",
-       "      12            True      True      True     False        False     1113  \n",
-       "2     0             True      True      True     False        False       71  \n",
-       "      1             True      True      True     False        False      188  \n",
-       "      2             True      True      True     False        False      391  \n",
-       "      3             True      True      True     False        False      534  \n",
-       "      4             True      True      True     False        False      651  \n",
-       "      5             True      True      True     False        False      787  \n",
-       "      6             True      True      True     False        False     1193  \n",
-       "3     0             True      True      True     False        False       14  \n",
-       "      1             True      True      True     False        False       89  \n",
-       "      2             True      True      True     False        False      150  \n",
-       "      3             True      True      True     False        False      153  \n",
-       "      4             True      True      True     False        False      155  \n",
-       "      5             True      True      True     False        False      195  \n",
-       "      6             True      True      True     False        False      196  \n",
-       "      7             True      True      True     False        False      198  \n",
-       "      8             True      True      True     False        False      244  \n",
-       "      9             True      True      True     False        False      254  \n",
-       "      10            True      True      True     False        False      268  \n",
-       "      11            True      True      True     False        False      351  \n",
-       "      12            True      True      True     False        False      369  \n",
-       "      13            True      True      True     False        False      376  \n",
-       "      14            True      True      True     False        False      402  \n",
-       "      15            True      True      True     False        False      411  \n",
-       "      16            True      True      True     False        False      422  \n",
-       "      17            True      True      True     False        False      715  \n",
-       "      18            True      True      True     False        False      776  \n",
-       "      19            True      True      True     False        False      888  \n",
-       "      20            True      True      True     False        False      893  \n",
-       "      21            True      True      True     False        False     1129  \n",
-       "      22            True      True      True     False        False     1157  \n",
-       "      23            True      True      True     False        False     1184  "
-      ],
-      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th></th>\n      <th>V0Afired</th>\n      <th>V0Cfired</th>\n      <th>ADAfired</th>\n      <th>ADCfired</th>\n      <th>STPfired</th>\n      <th>SMBfired</th>\n      <th>SM2fired</th>\n      <th>SH1fired</th>\n      <th>OM2fired</th>\n      <th>OMUfired</th>\n      <th>IsTriggered</th>\n      <th>FORChip</th>\n    </tr>\n    <tr>\n      <th>entry</th>\n      <th>subentry</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th rowspan=\"15\" valign=\"top\">0</th>\n      <th>0</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>48</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>168</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>310</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>369</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>387</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>389</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>748</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>820</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>830</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>872</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>900</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>920</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>991</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>1070</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>1147</td>\n    </tr>\n    <tr>\n      <th rowspan=\"13\" valign=\"top\">1</th>\n      <th>0</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>71</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>88</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>126</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>127</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>149</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>331</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>358</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>386</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>387</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>534</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>587</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>665</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>1113</td>\n    </tr>\n    <tr>\n      <th rowspan=\"7\" valign=\"top\">2</th>\n      <th>0</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>71</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>188</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>391</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>534</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>651</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>787</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>1193</td>\n    </tr>\n    <tr>\n      <th rowspan=\"24\" valign=\"top\">3</th>\n      <th>0</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>14</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>89</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>150</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>153</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>155</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>195</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>196</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>198</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>244</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>254</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>268</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>351</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>369</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>376</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>402</td>\n    </tr>\n    <tr>\n      <th>15</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>411</td>\n    </tr>\n    <tr>\n      <th>16</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>422</td>\n    </tr>\n    <tr>\n      <th>17</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>715</td>\n    </tr>\n    <tr>\n      <th>18</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>776</td>\n    </tr>\n    <tr>\n      <th>19</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>888</td>\n    </tr>\n    <tr>\n      <th>20</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>893</td>\n    </tr>\n    <tr>\n      <th>21</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>1129</td>\n    </tr>\n    <tr>\n      <th>22</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>1157</td>\n    </tr>\n    <tr>\n      <th>23</th>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>1184</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
+      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>RunNum</th>\n      <th>PeriodNumber</th>\n      <th>OrbitNumber</th>\n      <th>BunchCrossNumber</th>\n      <th>Mass</th>\n      <th>Pt</th>\n      <th>Q</th>\n      <th>Rapidity</th>\n      <th>Phi</th>\n      <th>ZNAenergy</th>\n      <th>...</th>\n      <th>STPfired</th>\n      <th>SMBfired</th>\n      <th>SM2fired</th>\n      <th>SH1fired</th>\n      <th>OM2fired</th>\n      <th>OMUfired</th>\n      <th>IsTriggered</th>\n      <th>nTracklets</th>\n      <th>nTracks</th>\n      <th>FORChip</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>245145</td>\n      <td>0</td>\n      <td>13362961</td>\n      <td>674</td>\n      <td>2.802221</td>\n      <td>0.567083</td>\n      <td>-1718026238</td>\n      <td>0.056647</td>\n      <td>-2.397827</td>\n      <td>-92.604172</td>\n      <td>...</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>4</td>\n      <td>8</td>\n      <td>[4, 15, 22, 107, 167, 233, 247, 262, 295, 315,...</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>245145</td>\n      <td>3</td>\n      <td>3674210</td>\n      <td>3438</td>\n      <td>2.996301</td>\n      <td>3.597858</td>\n      <td>-1718026240</td>\n      <td>-0.318146</td>\n      <td>1.097847</td>\n      <td>-428.223267</td>\n      <td>...</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>4</td>\n      <td>6</td>\n      <td>[30, 49, 89, 290, 309, 352, 370, 393, 472, 509...</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>245145</td>\n      <td>1</td>\n      <td>12644173</td>\n      <td>2126</td>\n      <td>3.198086</td>\n      <td>1.573138</td>\n      <td>-1717960705</td>\n      <td>-0.360621</td>\n      <td>1.949035</td>\n      <td>9.372114</td>\n      <td>...</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>3</td>\n      <td>5</td>\n      <td>[27, 33, 160, 171, 302, 306, 308, 366, 384, 39...</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>245145</td>\n      <td>1</td>\n      <td>16213555</td>\n      <td>3239</td>\n      <td>3.103773</td>\n      <td>0.797095</td>\n      <td>-1718026238</td>\n      <td>0.011698</td>\n      <td>1.207371</td>\n      <td>291.203796</td>\n      <td>...</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>12</td>\n      <td>8</td>\n      <td>[12, 29, 33, 36, 50, 71, 168, 215, 268, 284, 3...</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>245145</td>\n      <td>1</td>\n      <td>5525160</td>\n      <td>2195</td>\n      <td>1.679243</td>\n      <td>0.388082</td>\n      <td>-1718026240</td>\n      <td>-0.595928</td>\n      <td>0.879197</td>\n      <td>344.992584</td>\n      <td>...</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>27</td>\n      <td>4</td>\n      <td>[0, 7, 28, 31, 37, 38, 39, 45, 46, 55, 57, 71,...</td>\n    </tr>\n    <tr>\n      <th>...</th>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n    </tr>\n    <tr>\n      <th>106700</th>\n      <td>246994</td>\n      <td>3</td>\n      <td>3847039</td>\n      <td>3472</td>\n      <td>5.037951</td>\n      <td>7.349191</td>\n      <td>-1717960706</td>\n      <td>-0.550232</td>\n      <td>0.569475</td>\n      <td>-384.684784</td>\n      <td>...</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>1</td>\n      <td>6</td>\n      <td>[19, 27, 232, 399, 448, 469, 877]</td>\n    </tr>\n    <tr>\n      <th>106701</th>\n      <td>246994</td>\n      <td>2</td>\n      <td>62739</td>\n      <td>532</td>\n      <td>8.490516</td>\n      <td>5.970900</td>\n      <td>-1717960708</td>\n      <td>-1.047591</td>\n      <td>-2.963939</td>\n      <td>6169.960449</td>\n      <td>...</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>74</td>\n      <td>22</td>\n      <td>[26, 34, 38, 41, 87, 120, 202, 204, 206, 209, ...</td>\n    </tr>\n    <tr>\n      <th>106702</th>\n      <td>246994</td>\n      <td>1</td>\n      <td>566110</td>\n      <td>3361</td>\n      <td>5.639124</td>\n      <td>0.815031</td>\n      <td>-1717960707</td>\n      <td>0.497559</td>\n      <td>2.903033</td>\n      <td>-624.092224</td>\n      <td>...</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>6</td>\n      <td>5</td>\n      <td>[47, 86, 168, 212, 267, 305, 358, 505, 523, 52...</td>\n    </tr>\n    <tr>\n      <th>106703</th>\n      <td>246994</td>\n      <td>2</td>\n      <td>3250243</td>\n      <td>1830</td>\n      <td>3.033328</td>\n      <td>2.172899</td>\n      <td>-1718026239</td>\n      <td>0.083928</td>\n      <td>-2.649607</td>\n      <td>75394.562500</td>\n      <td>...</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>4</td>\n      <td>7</td>\n      <td>[49, 163, 203, 248, 287, 353, 452, 472, 584, 6...</td>\n    </tr>\n    <tr>\n      <th>106704</th>\n      <td>246994</td>\n      <td>2</td>\n      <td>3245492</td>\n      <td>1603</td>\n      <td>0.695303</td>\n      <td>0.673679</td>\n      <td>-1718026238</td>\n      <td>0.195638</td>\n      <td>0.555802</td>\n      <td>-284.629578</td>\n      <td>...</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>False</td>\n      <td>False</td>\n      <td>1</td>\n      <td>4</td>\n      <td>[3, 106, 126, 127, 167, 192, 402, 444, 541, 60...</td>\n    </tr>\n  </tbody>\n</table>\n<p>106705 rows × 41 columns</p>\n</div>",
+      "text/plain": "        RunNum  PeriodNumber  OrbitNumber  BunchCrossNumber      Mass  \\\n0       245145             0     13362961               674  2.802221   \n1       245145             3      3674210              3438  2.996301   \n2       245145             1     12644173              2126  3.198086   \n3       245145             1     16213555              3239  3.103773   \n4       245145             1      5525160              2195  1.679243   \n...        ...           ...          ...               ...       ...   \n106700  246994             3      3847039              3472  5.037951   \n106701  246994             2        62739               532  8.490516   \n106702  246994             1       566110              3361  5.639124   \n106703  246994             2      3250243              1830  3.033328   \n106704  246994             2      3245492              1603  0.695303   \n\n              Pt           Q  Rapidity       Phi     ZNAenergy  ...  STPfired  \\\n0       0.567083 -1718026238  0.056647 -2.397827    -92.604172  ...      True   \n1       3.597858 -1718026240 -0.318146  1.097847   -428.223267  ...      True   \n2       1.573138 -1717960705 -0.360621  1.949035      9.372114  ...      True   \n3       0.797095 -1718026238  0.011698  1.207371    291.203796  ...      True   \n4       0.388082 -1718026240 -0.595928  0.879197    344.992584  ...      True   \n...          ...         ...       ...       ...           ...  ...       ...   \n106700  7.349191 -1717960706 -0.550232  0.569475   -384.684784  ...      True   \n106701  5.970900 -1717960708 -1.047591 -2.963939   6169.960449  ...      True   \n106702  0.815031 -1717960707  0.497559  2.903033   -624.092224  ...      True   \n106703  2.172899 -1718026239  0.083928 -2.649607  75394.562500  ...      True   \n106704  0.673679 -1718026238  0.195638  0.555802   -284.629578  ...      True   \n\n        SMBfired  SM2fired  SH1fired  OM2fired  OMUfired  IsTriggered  \\\n0           True      True      True     False     False        False   \n1           True      True      True      True     False        False   \n2           True      True      True      True      True        False   \n3           True      True      True      True      True        False   \n4           True      True      True     False     False        False   \n...          ...       ...       ...       ...       ...          ...   \n106700      True      True      True     False     False        False   \n106701      True      True      True      True     False        False   \n106702      True      True      True      True      True        False   \n106703      True      True      True      True      True        False   \n106704      True      True      True     False     False        False   \n\n        nTracklets  nTracks                                            FORChip  \n0                4        8  [4, 15, 22, 107, 167, 233, 247, 262, 295, 315,...  \n1                4        6  [30, 49, 89, 290, 309, 352, 370, 393, 472, 509...  \n2                3        5  [27, 33, 160, 171, 302, 306, 308, 366, 384, 39...  \n3               12        8  [12, 29, 33, 36, 50, 71, 168, 215, 268, 284, 3...  \n4               27        4  [0, 7, 28, 31, 37, 38, 39, 45, 46, 55, 57, 71,...  \n...            ...      ...                                                ...  \n106700           1        6                  [19, 27, 232, 399, 448, 469, 877]  \n106701          74       22  [26, 34, 38, 41, 87, 120, 202, 204, 206, 209, ...  \n106702           6        5  [47, 86, 168, 212, 267, 305, 358, 505, 523, 52...  \n106703           4        7  [49, 163, 203, 248, 287, 353, 452, 472, 584, 6...  \n106704           1        4  [3, 106, 126, 127, 167, 192, 402, 444, 541, 60...  \n\n[106705 rows x 41 columns]"
      },
+     "execution_count": 32,
      "metadata": {},
-     "execution_count": 5
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "ITSSensorNums"
+    "data"
    ]
   },
   {
-   "source": [
-    "You will be mailed back with the serial number of your request. Then\n",
-    "you should completely fill the paper request form and go to your\n",
-    "Registration Authority to complete your request. You will need your\n",
-    "public key modulus:\n",
-    "   D21C7F4A27  458583F2DD"
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "name                 | typename                 | interpretation                \n",
+      "---------------------+--------------------------+-------------------------------\n",
+      "RunNum               | int32_t                  | AsDtype('>i4')\n",
+      "PeriodNumber         | uint32_t                 | AsDtype('>u4')\n",
+      "OrbitNumber          | uint32_t                 | AsDtype('>u4')\n",
+      "BunchCrossNumber     | uint32_t                 | AsDtype('>u4')\n",
+      "Mass                 | float                    | AsDtype('>f4')\n",
+      "Pt                   | float                    | AsDtype('>f4')\n",
+      "Q                    | int32_t                  | AsDtype('>i4')\n",
+      "Rapidity             | float                    | AsDtype('>f4')\n",
+      "Phi                  | float                    | AsDtype('>f4')\n",
+      "ZNAenergy            | float                    | AsDtype('>f4')\n",
+      "ZNCenergy            | float                    | AsDtype('>f4')\n",
+      "ZPAenergy            | float                    | AsDtype('>f4')\n",
+      "ZPCenergy            | float                    | AsDtype('>f4')\n",
+      "VtxX                 | float                    | AsDtype('>f4')\n",
+      "VtxY                 | float                    | AsDtype('>f4')\n",
+      "VtxZ                 | float                    | AsDtype('>f4')\n",
+      "VtxContrib           | int32_t                  | AsDtype('>i4')\n",
+      "VtxChi2              | float                    | AsDtype('>f4')\n",
+      "VtxNDF               | float                    | AsDtype('>f4')\n",
+      "SpdVtxX              | float                    | AsDtype('>f4')\n",
+      "SpdVtxY              | float                    | AsDtype('>f4')\n",
+      "SpdVtxZ              | float                    | AsDtype('>f4')\n",
+      "SpdVtxContrib        | int32_t                  | AsDtype('>i4')\n",
+      "V0Adecision          | int32_t                  | AsDtype('>i4')\n",
+      "V0Cdecision          | int32_t                  | AsDtype('>i4')\n",
+      "ADAdecision          | int32_t                  | AsDtype('>i4')\n",
+      "ADCdecision          | int32_t                  | AsDtype('>i4')\n",
+      "V0Afired             | bool                     | AsDtype('bool')\n",
+      "V0Cfired             | bool                     | AsDtype('bool')\n",
+      "ADAfired             | bool                     | AsDtype('bool')\n",
+      "ADCfired             | bool                     | AsDtype('bool')\n",
+      "STPfired             | bool                     | AsDtype('bool')\n",
+      "SMBfired             | bool                     | AsDtype('bool')\n",
+      "SM2fired             | bool                     | AsDtype('bool')\n",
+      "SH1fired             | bool                     | AsDtype('bool')\n",
+      "OM2fired             | bool                     | AsDtype('bool')\n",
+      "OMUfired             | bool                     | AsDtype('bool')\n",
+      "IsTriggered          | bool                     | AsDtype('bool')\n",
+      "nTracklets           | int32_t                  | AsDtype('>i4')\n",
+      "nTracks              | int32_t                  | AsDtype('>i4')\n",
+      "T_NumberOfSigmaIT... | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\n",
+      "T_NumberOfSigmaIT... | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\n",
+      "T_NumberOfSigmaTP... | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\n",
+      "T_NumberOfSigmaTP... | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\n",
+      "TPCsignal            | std::vector<int32_t>     | AsJagged(AsDtype('>i4'), he...\n",
+      "T_P                  | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\n",
+      "T_Eta                | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\n",
+      "T_Phi                | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\n",
+      "T_Px                 | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\n",
+      "T_Py                 | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\n",
+      "T_Pz                 | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\n",
+      "T_Q                  | std::vector<int32_t>     | AsJagged(AsDtype('>i4'), he...\n",
+      "T_HasPointOnITSLa... | std::vector<bool>        | AsJagged(AsDtype('bool'), h...\n",
+      "T_HasPointOnITSLa... | std::vector<bool>        | AsJagged(AsDtype('bool'), h...\n",
+      "T_ITSModuleInner     | std::vector<int32_t>     | AsJagged(AsDtype('>i4'), he...\n",
+      "T_ITSModuleOuter     | std::vector<int32_t>     | AsJagged(AsDtype('>i4'), he...\n",
+      "T_TPCNCls            | std::vector<int32_t>     | AsJagged(AsDtype('>i4'), he...\n",
+      "T_ITSNCls            | std::vector<int32_t>     | AsJagged(AsDtype('>i4'), he...\n",
+      "T_Dca0               | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\n",
+      "T_Dca1               | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\n",
+      "T_TPCRefit           | std::vector<bool>        | AsJagged(AsDtype('bool'), h...\n",
+      "T_ITSRefit           | std::vector<bool>        | AsJagged(AsDtype('bool'), h...\n",
+      "TLets_Theta          | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\n",
+      "TLets_Phi            | std::vector<float>       | AsJagged(AsDtype('>f4'), he...\n",
+      "FORChip              | std::vector<int32_t>     | AsJagged(AsDtype('>i4'), he...\n"
+     ]
+    }
    ],
-   "cell_type": "markdown",
-   "metadata": {}
+   "source": [
+    "events.show()"
+   ]
   }
  ],
  "metadata": {
@@ -281,7 +210,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.6-final"
+   "version": "3.8.6"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/modules/FourTrackEvents.py b/notebooks/modules/FourTrackEvents.py
index ea2d541..7fc810f 100644
--- a/notebooks/modules/FourTrackEvents.py
+++ b/notebooks/modules/FourTrackEvents.py
@@ -3,24 +3,24 @@
 import pandas as pd
 from particle import Particle
 
-
 Rho0 = Particle.from_pdgid(113)
 Pi0 = Particle.from_pdgid(111)
 PiPlus = Particle.from_pdgid(211)
 
-# when my data file size was 500mb work with pandas was comfort, but now the size is 1.5gb and parsing to pandas takes forever and eats all my memory despite on the fact that I have 32gb on my laptop.
-# So I'll move to numpy, but for a start only for data loading.
-
 
 class FourTrackEvents:
-    def __init__(self, path, tree, branches, uprootLibType='np'):
-        self.orig_events = uproot4.open(
-            path,  object_cache=5000, num_workers=8)[tree]
-        self.orig_tracks = self.orig_events.arrays(
-            filter_name=branches, library=uprootLibType)  # , entry_stop=100)
+    def __init__(self):
+        self.orig_events = pd.read_parquet(
+            r'D:\GoogleDrive\Job\cern\Alice\analysis\data\RhoPrime\2015\4Prongs2015oEvents.parquet')
+        self.orig_tracks = pd.read_parquet(
+            r'D:\GoogleDrive\Job\cern\Alice\analysis\data\RhoPrime\2015\4Prongs2015oTracks.parquet')
 
         # 4 tracks events mask
-        # NOTE: may be it's not obviously, but dataframe able to work with mask only in case mask cover whole dataframe. This means I have to find events with four tracks in all events, than events with zero total charge again in all events, and than put mask about charge on the mask about numbers of tracks. In this case e.g. we have 6 tracks in events (four_track_mask is false), but total charge is zero (zq_mask is true). Such event will threw out because of four_track_mask is false.
+        # NOTE: may be it's not obviously, but dataframe able to work with mask only in case mask cover whole dataframe.
+        # This means I have to find events with four tracks in all events, than events with zero total charge again in all events, and than put the zero charge mask  on the 4tracks mask.
+        # In this case e.g. we have 6 tracks in events (four_track_mask is false), but total charge is zero (zq_mask is true).
+        # Such event will threw out because of four_track_mask is false, but it could be a useful event.
+
         self._four_tracks_mask = (
             self.orig_tracks.reset_index().groupby('entry').count() == 4)
 
diff --git a/notebooks/modules/__init__.py b/notebooks/modules/__init__.py
index c82ed32..c3857d9 100644
--- a/notebooks/modules/__init__.py
+++ b/notebooks/modules/__init__.py
@@ -6,9 +6,9 @@
 from particle import Particle
 
 
-ccup9_2015 = r'D:\GoogleDrive\Job\cern\Alice\analysis\data\RhoPrime\2015\4Prongs2015o.root'
+# ccup9_2015 = r'D:\GoogleDrive\Job\cern\Alice\analysis\data\RhoPrime\2015\4Prongs2015o.root'
 
-events = uproot4.open(ccup9_2015)['4Prongs/events']
+# events = uproot4.open(ccup9_2015)['4Prongs/events']
 # events.show()
 # dfs.loc[0] # get dataframe part with entry = 0
 
diff --git a/notebooks/modules/data/convertion/__init__.py b/notebooks/modules/data/convertion/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/notebooks/modules/data/convertion/convert_to_parquet.py b/notebooks/modules/data/convertion/convert_to_parquet.py
new file mode 100644
index 0000000..253f997
--- /dev/null
+++ b/notebooks/modules/data/convertion/convert_to_parquet.py
@@ -0,0 +1,35 @@
+import uproot4
+import numpy as np
+import pandas as pd
+import concurrent.futures
+
+# TODO: not a method! (still specific script)
+
+
+def convert_root_file_to_parquet(root_path, tree_name, branches, parq_path):
+
+    ccup9_2015_file = r'D:\GoogleDrive\Job\cern\Alice\analysis\data\RhoPrime\2015\4Prongs2015oLast.root'
+
+    tree_name = '4Prongs/events'
+
+    executor = concurrent.futures.ThreadPoolExecutor()
+
+    branches = ['T_Px', 'T_Py', 'T_Pz',  'T_Q', 'T_NumberOfSigmaTPCPion', 'T_TPCRefit', 'T_TPCNCls', 'T_Phi',
+                'T_Eta', 'T_HasPointOnITSLayer0', 'T_HasPointOnITSLayer1', 'T_ITSModuleInner', 'T_ITSModuleOuter']
+
+    evColumns = ["RunNum", "PeriodNumber", "OrbitNumber", "BunchCrossNumber", "Mass", "Pt", "Q", "Rapidity", "Phi", "ZNAenergy", "ZNCenergy", "ZPAenergy", "ZPCenergy", "VtxX", "VtxY", "VtxZ", "VtxContrib", "VtxChi2", "VtxNDF", "SpdVtxX", "SpdVtxY",
+                 "SpdVtxZ", "SpdVtxContrib", "V0Adecision", "V0Cdecision", "ADAdecision", "ADCdecision", "V0Afired", "V0Cfired", "ADAfired", "ADCfired", "STPfired", "SMBfired", "SM2fired", "SH1fired", "OM2fired", "OMUfired", "IsTriggered", "nTracklets", "nTracks"]
+
+    events = uproot4.open(ccup9_2015_file, object_cache=5000,
+                          num_workers=12, interpretation_executor=executor)[tree_name]
+
+    data_tracks = events.arrays(
+        filter_name=branches, library='pd', array_cache=5000)  # , entry_stop=1000000)
+    data_tracks.to_parquet(
+        r'D:\GoogleDrive\Job\cern\Alice\analysis\data\RhoPrime\2015\4Prongs2015oTracks.parquet')
+    data_events = events.arrays(filter_name=evColumns, library='pd')
+    chips = events.arrays(filter_name=['FORChip'], library='pd')
+    chips = chips.groupby('entry').FORChip.apply(list)
+    data_events['FORChip'] = chips
+    data_events.to_parquet(
+        r'D:\GoogleDrive\Job\cern\Alice\analysis\data\RhoPrime\2015\4Prongs2015oEvents.parquet')
diff --git a/notebooks/modules/physics/analysis/ITSvsTPC_events.py b/notebooks/modules/physics/analysis/ITSvsTPC_events.py
index c972e1a..4dff541 100644
--- a/notebooks/modules/physics/analysis/ITSvsTPC_events.py
+++ b/notebooks/modules/physics/analysis/ITSvsTPC_events.py
@@ -26,3 +26,5 @@ def ShowComparisonSame(title, arrs, xlabel, labels, colors, nBins=100, ranges=(0
         ax.add_patch(Rectangle((0, 0.15), 0.15, 900,
                                fc='lightgrey', alpha=0.4))
         ax.text(0.15, 0, "0.15", size=14)
+
+    return fig
diff --git a/notebooks/modules/physics/kinematics.py b/notebooks/modules/physics/kinematics.py
index 08b12f1..92bd192 100644
--- a/notebooks/modules/physics/kinematics.py
+++ b/notebooks/modules/physics/kinematics.py
@@ -11,7 +11,7 @@ def pt_events(tracks):
 
 
 def mass_events(tracks):
-    ETracks = np.sqrt((tracks.T_Px**2 + tracks.T_Py**2 + tracks.T_Pz **
-                       2 + (0.001*PiPlus.mass)**2)).groupby("entry").sum()
+    ETracks = np.sqrt((tracks.T_Px**2 + tracks.T_Py**2 +
+                      tracks.T_Pz**2 + (0.001*PiPlus.mass)**2)).groupby("entry").sum()
     SumTracks = tracks.groupby("entry").sum()
     return np.sqrt(ETracks**2 - SumTracks.T_Px**2 - SumTracks.T_Py**2 - SumTracks.T_Pz**2)