Store and recover the index of the matched track, possibility to do matching with...
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 22 Feb 2011 16:42:31 +0000 (16:42 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 22 Feb 2011 16:42:31 +0000 (16:42 +0000)
EMCAL/AliEMCALRecoUtils.cxx
EMCAL/AliEMCALRecoUtils.h

index 34aaa26..85fdcd6 100644 (file)
@@ -22,6 +22,8 @@
 //
 //
 // Author:  Gustavo Conesa (LPSC- Grenoble) 
+//          Track matching part: Rongrong Ma (Yale)
+
 ///////////////////////////////////////////////////////////////////////////////
 
 // --- standard c ---
 #include <TGeoBBox.h>
 
 // STEER includes
-#include "AliEMCALRecoUtils.h"
-#include "AliEMCALGeometry.h"
 #include "AliVCluster.h"
 #include "AliVCaloCells.h"
 #include "AliVEvent.h"
 #include "AliLog.h"
-#include "AliEMCALPIDUtils.h"
 #include "AliPID.h"
 #include "AliESDEvent.h"
 #include "AliESDtrack.h"
+
+// EMCAL includes
+#include "AliEMCALRecoUtils.h"
+#include "AliEMCALGeometry.h"
 #include "AliEMCALTrack.h"
 #include "AliEMCALCalibTimeDepCorrection.h"
+#include "AliEMCALPIDUtils.h"
 
 ClassImp(AliEMCALRecoUtils)
   
@@ -57,7 +61,8 @@ AliEMCALRecoUtils::AliEMCALRecoUtils():
   fRecalibration(kFALSE), fEMCALRecalibrationFactors(),
   fRemoveBadChannels(kFALSE), fRecalDistToBadChannels(kFALSE), fEMCALBadChannelMap(),
   fNCellsFromEMCALBorder(0), fNoEMCALBorderAtEta0(kTRUE),
-  fMatchedClusterIndex(0x0), fResidualZ(0x0), fResidualR(0x0), fCutR(20), fCutZ(20),
+  fMatchedTrackIndex(0x0), fMatchedClusterIndex(0x0), 
+  fResidualZ(0x0), fResidualR(0x0), fCutR(20), fCutZ(20),
   fCutMinNClusterTPC(0), fCutMinNClusterITS(0), fCutMaxChi2PerClusterTPC(0), fCutMaxChi2PerClusterITS(0),
   fCutRequireTPCRefit(0), fCutRequireITSRefit(0), fCutAcceptKinkDaughters(0),
   fCutMaxDCAToVertexXY(0), fCutMaxDCAToVertexZ(0),fCutDCAToVertex2D(0),fPIDUtils(),
@@ -69,23 +74,29 @@ AliEMCALRecoUtils::AliEMCALRecoUtils():
   // during Reco algorithm execution
   //
   
+  //Misalignment matrices
   for(Int_t i = 0; i < 15 ; i++) {
       fMisalTransShift[i] = 0.; 
-      fMisalRotShift[i] = 0.; 
+      fMisalRotShift[i]   = 0.; 
   }
+  
+  //Non linearity
   for(Int_t i = 0; i < 6  ; i++) fNonLinearityParams[i] = 0.; 
   //For kPi0GammaGamma case, but default is no correction
   fNonLinearityParams[0] = 0.1457/0.1349766/1.038;
   fNonLinearityParams[1] = -0.02024/0.1349766/1.038;
   fNonLinearityParams[2] = 1.046;
 
+  //Track matching
+  fMatchedTrackIndex   = new TArrayI();
   fMatchedClusterIndex = new TArrayI();
-  fResidualZ = new TArrayF();
-  fResidualR = new TArrayF();
+  fResidualZ           = new TArrayF();
+  fResidualR           = new TArrayF();
   
-  fPIDUtils = new AliEMCALPIDUtils();
-
   InitTrackCuts();
+  
+  fPIDUtils            = new AliEMCALPIDUtils();
+
 
 }
 
@@ -97,6 +108,7 @@ AliEMCALRecoUtils::AliEMCALRecoUtils(const AliEMCALRecoUtils & reco)
   fRemoveBadChannels(reco.fRemoveBadChannels),fRecalDistToBadChannels(reco.fRecalDistToBadChannels),
   fEMCALBadChannelMap(reco.fEMCALBadChannelMap),
   fNCellsFromEMCALBorder(reco.fNCellsFromEMCALBorder),fNoEMCALBorderAtEta0(reco.fNoEMCALBorderAtEta0),
+  fMatchedTrackIndex(reco.fMatchedTrackIndex?new TArrayI(*reco.fMatchedTrackIndex):0x0),
   fMatchedClusterIndex(reco.fMatchedClusterIndex?new TArrayI(*reco.fMatchedClusterIndex):0x0),
   fResidualZ(reco.fResidualZ?new TArrayF(*reco.fResidualZ):0x0),
   fResidualR(reco.fResidualR?new TArrayF(*reco.fResidualR):0x0),
@@ -188,6 +200,17 @@ AliEMCALRecoUtils & AliEMCALRecoUtils::operator = (const AliEMCALRecoUtils & rec
     fResidualZ = 0;
   }
   
+  if(reco.fMatchedTrackIndex){
+    // assign or copy construct
+    if(fMatchedTrackIndex){ 
+      *fMatchedTrackIndex = *reco.fMatchedTrackIndex;
+    }
+    else fMatchedTrackIndex = new TArrayI(*reco.fMatchedTrackIndex);
+  }
+  else{
+    if(fMatchedTrackIndex)delete fMatchedTrackIndex;
+    fMatchedTrackIndex = 0;
+  }  
   
   if(reco.fMatchedClusterIndex){
     // assign or copy construct
@@ -221,6 +244,7 @@ AliEMCALRecoUtils::~AliEMCALRecoUtils()
                delete  fEMCALBadChannelMap;
        }
  
+  if(fMatchedTrackIndex)   {delete fMatchedTrackIndex;   fMatchedTrackIndex=0;}
   if(fMatchedClusterIndex) {delete fMatchedClusterIndex; fMatchedClusterIndex=0;}
   if(fResidualR)           {delete fResidualR;           fResidualR=0;}
   if(fResidualZ)           {delete fResidualZ;           fResidualZ=0;}
@@ -947,8 +971,8 @@ void AliEMCALRecoUtils::RecalculateClusterShowerShapeParameters(AliEMCALGeometry
   
 }
 
-//__________________________________________________
-void AliEMCALRecoUtils::FindMatches(AliVEvent *event)
+//____________________________________________________________________________
+void AliEMCALRecoUtils::FindMatches(AliVEvent *event, TObjArray * clusterArr)
 {
   //This function should be called before the cluster loop
   //Before call this function, please recalculate the cluster positions
@@ -956,13 +980,15 @@ void AliEMCALRecoUtils::FindMatches(AliVEvent *event)
   //Store matched cluster indexes and residuals
   //It only works with ESDs, not AODs
   
+  fMatchedTrackIndex  ->Reset();
   fMatchedClusterIndex->Reset();
-  fResidualZ->Reset();
-  fResidualR->Reset();
+  fResidualZ          ->Reset();
+  fResidualR          ->Reset();
   
+  fMatchedTrackIndex  ->Set(100);
   fMatchedClusterIndex->Set(100);
-  fResidualZ->Set(100);
-  fResidualR->Set(100);
+  fResidualZ          ->Set(100);
+  fResidualR          ->Set(100);
   
   Int_t    matched=0;
   Float_t  clsPos[3];
@@ -975,42 +1001,66 @@ void AliEMCALRecoUtils::FindMatches(AliVEvent *event)
     Float_t dRMax = fCutR, dZMax = fCutZ;
     Int_t index = -1;
     AliEMCALTrack *emctrack = new AliEMCALTrack(*track);
-    for(Int_t icl=0; icl<event->GetNumberOfCaloClusters(); icl++)
-    {
-      AliVCluster *cluster = (AliVCluster*) event->GetCaloCluster(icl);
-      if(!cluster->IsEMCAL()) continue;
-      cluster->GetPosition(clsPos); //Has been recalculated
-      if(!emctrack->PropagateToGlobal(clsPos[0],clsPos[1],clsPos[2],0.,0.) )  continue;
-      emctrack->GetXYZ(trkPos);
-      Float_t tmpR = TMath::Sqrt( TMath::Power(clsPos[0]-trkPos[0],2)+TMath::Power(clsPos[1]-trkPos[1],2)+TMath::Power(clsPos[2]-trkPos[2],2) );
-      Float_t tmpZ = TMath::Abs(clsPos[2]-trkPos[2]);
+    if(!clusterArr){// get clusters from event
+      for(Int_t icl=0; icl<event->GetNumberOfCaloClusters(); icl++)
+      {
+        AliVCluster *cluster = (AliVCluster*) event->GetCaloCluster(icl);
+        if(!cluster->IsEMCAL()) continue;
+        cluster->GetPosition(clsPos); //Has been recalculated
+        if(!emctrack->PropagateToGlobal(clsPos[0],clsPos[1],clsPos[2],0.,0.) )  continue;
+        emctrack->GetXYZ(trkPos);
+        Float_t tmpR = TMath::Sqrt( TMath::Power(clsPos[0]-trkPos[0],2)+TMath::Power(clsPos[1]-trkPos[1],2)+TMath::Power(clsPos[2]-trkPos[2],2) );
+        Float_t tmpZ = TMath::Abs(clsPos[2]-trkPos[2]);
       
-      if(tmpR<dRMax)
-           {
-             dRMax=tmpR;
-             dZMax=tmpZ;
-             index=icl;
-           }
-      
-    }//cluser loop
-    
+        if(tmpR<dRMax)
+        {
+          dRMax=tmpR;
+          dZMax=tmpZ;
+          index=icl;
+        }
+      }//cluster loop
+    } else { // external cluster array, not from ESD event
+      for(Int_t icl=0; icl<clusterArr->GetEntriesFast(); icl++)
+      {
+        AliVCluster *cluster = (AliVCluster*) clusterArr->At(icl);
+        if(!cluster->IsEMCAL()) continue;
+        cluster->GetPosition(clsPos); //Has been recalculated
+        if(!emctrack->PropagateToGlobal(clsPos[0],clsPos[1],clsPos[2],0.,0.) )  continue;
+        emctrack->GetXYZ(trkPos);
+        Float_t tmpR = TMath::Sqrt( TMath::Power(clsPos[0]-trkPos[0],2)+TMath::Power(clsPos[1]-trkPos[1],2)+TMath::Power(clsPos[2]-trkPos[2],2) );
+        Float_t tmpZ = TMath::Abs(clsPos[2]-trkPos[2]);
+        
+        if(tmpR<dRMax)
+        {
+          dRMax=tmpR;
+          dZMax=tmpZ;
+          index=icl;
+        }
+      }//cluster loop
+    }// external list of clusters
+
     if(index>-1)
     {
+      fMatchedTrackIndex  ->AddAt(itr,matched);
       fMatchedClusterIndex->AddAt(index,matched);
-      fResidualZ->AddAt(dZMax,matched);
-      fResidualR->AddAt(dRMax,matched);
+      fResidualZ          ->AddAt(dZMax,matched);
+      fResidualR          ->AddAt(dRMax,matched);
       matched++;
     }
     delete emctrack;
   }//track loop
+  
+  AliDebug(2,Form("Number of matched pairs = %d !\n",matched));
+  
+  fMatchedTrackIndex  ->Set(matched);
   fMatchedClusterIndex->Set(matched);
-  fResidualZ->Set(matched);
-  fResidualR->Set(matched);
+  fResidualZ          ->Set(matched);
+  fResidualR          ->Set(matched);
   
   //printf("Number of matched pairs: %d\n",matched);
 }
 
-//__________________________________________________
+//________________________________________________________________________________
 void AliEMCALRecoUtils::GetMatchedResiduals(Int_t index, Float_t &dR, Float_t &dZ)
 {
   //Given a cluster index as in AliESDEvent::GetCaloCluster(index)
@@ -1029,6 +1079,20 @@ void AliEMCALRecoUtils::GetMatchedResiduals(Int_t index, Float_t &dR, Float_t &d
   //printf("dR %f, dZ %f\n",dR, dZ);
 }
 
+//__________________________________________________________
+Int_t AliEMCALRecoUtils::GetMatchedTrackIndex(Int_t index)
+{
+  //Given a cluster index as in AliESDEvent::GetCaloCluster(index)
+  //Get the index of matched track for this cluster
+  //It only works with ESDs, not AODs
+  
+  if(IsMatched(index))
+    return fMatchedTrackIndex->At(FindMatchedPos(index));
+  else 
+    return -1; 
+}
+
+
 //__________________________________________________
 Bool_t AliEMCALRecoUtils::IsMatched(Int_t index)
 {
@@ -1039,26 +1103,27 @@ Bool_t AliEMCALRecoUtils::IsMatched(Int_t index)
   else
     return kFALSE;
 }
-//__________________________________________________
+//__________________________________________________________
 UInt_t AliEMCALRecoUtils::FindMatchedPos(Int_t index) const
 {
   //Given a cluster index as in AliESDEvent::GetCaloCluster(index)
   //Returns the position of the match in the fMatchedClusterIndex array
   Float_t tmpR = fCutR;
   UInt_t pos = 999;
-
+  
   for(Int_t i=0; i<fMatchedClusterIndex->GetSize(); i++)
+  {
+    if(fMatchedClusterIndex->At(i)==index && fResidualR->At(i)<tmpR)
     {
-      if(fMatchedClusterIndex->At(i)==index && fResidualR->At(i)<tmpR)
-       {
-         pos=i;
-         tmpR=fResidualR->At(i);
-       }
+      pos=i;
+      tmpR=fResidualR->At(i);
       AliDebug(3,Form("Matched cluster pos: %d, index: %d, dR: %2.4f, dZ: %2.4f.\n",i,fMatchedClusterIndex->At(i),fResidualR->At(i),fResidualZ->At(i)));
     }
+  }
   return pos;
 }
 
+//__________________________________________________________
 Bool_t AliEMCALRecoUtils::IsAccepted(AliESDtrack *esdTrack)
 {
   // Given a esd track, return whether the track survive all the cuts
@@ -1165,7 +1230,7 @@ void AliEMCALRecoUtils::InitTrackCuts()
   SetMinNClustersITS();
 }
 
-//__________________________________________________
+//___________________________________________________
 void AliEMCALRecoUtils::Print(const Option_t *) const 
 {
   // Print Parameters
@@ -1189,10 +1254,9 @@ void AliEMCALRecoUtils::Print(const Option_t *) const
   printf("MaxChi2TPC = %2.2f, MaxChi2ITS = %2.2f\n",fCutMaxChi2PerClusterTPC,fCutMaxChi2PerClusterITS);
   printf("DCSToVertex2D = %d, MaxDCAToVertexXY = %2.2f, MaxDCAToVertexZ = %2.2f\n",fCutDCAToVertex2D,fCutMaxDCAToVertexXY,fCutMaxDCAToVertexZ);
 
-    
 }
 
-//__________________________________________________
+//_____________________________________________________________________
 void AliEMCALRecoUtils::SetTimeDependentCorrections(Int_t runnumber){
   //Get EMCAL time dependent corrections from file and put them in the recalibration histograms
   //Do it only once and only if it is requested
index 6d32416..745d509 100644 (file)
@@ -10,6 +10,7 @@
 //
 //
 // Author:  Gustavo Conesa (LPSC- Grenoble) 
+//          Track matching part: Rongrong Ma (Yale)
 ///////////////////////////////////////////////////////////////////////////////
 
 //Root includes
@@ -25,6 +26,8 @@ class AliVCluster;
 class AliVCaloCells;
 class AliVEvent;
 #include "AliLog.h"
+
+// EMCAL includes
 class AliEMCALGeometry;
 class AliEMCALPIDUtils;
 class AliESDtrack;
@@ -36,13 +39,19 @@ public:
   AliEMCALRecoUtils();
   AliEMCALRecoUtils(const AliEMCALRecoUtils&); 
   AliEMCALRecoUtils& operator=(const AliEMCALRecoUtils&); 
-  virtual ~AliEMCALRecoUtils() ;
-  
+  virtual ~AliEMCALRecoUtils() ;  
+  void Print(const Option_t*) const;
+
+  //enums
   enum NonlinearityFunctions{kPi0MC=0,kPi0GammaGamma=1,kPi0GammaConversion=2,kNoCorrection=3,kBeamTest=4};
   enum PositionAlgorithms{kUnchanged=-1,kPosTowerIndex=0, kPosTowerGlobal=1};
   enum ParticleType{kPhoton=0, kElectron=1,kHadron =2, kUnknown=-1};
-  
+  enum { kNCuts = 11 }; //track matching
+
+  //-----------------------------------------------------
   //Position recalculation
+  //-----------------------------------------------------
+
   void     RecalculateClusterPosition(AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu); 
   void     RecalculateClusterPositionFromTowerIndex (AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu); 
   void     RecalculateClusterPositionFromTowerGlobal(AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu); 
@@ -89,8 +98,10 @@ public:
   Float_t  GetW0()                 const   { return fW0               ;}
   void     SetW0(Float_t w0)               { fW0  = w0                ;}
 
+  //-----------------------------------------------------
   //Non Linearity
-  
+  //-----------------------------------------------------
+
   Float_t CorrectClusterEnergyLinearity(AliVCluster* clu);
   
   Float_t  GetNonLinearityParam(const Int_t i) const {
@@ -104,20 +115,21 @@ public:
   
   Int_t GetNonLinearityFunction() const    { return fNonLinearityFunction ;}
   void  SetNonLinearityFunction(Int_t fun) { fNonLinearityFunction = fun  ;}
-  
-  void Print(const Option_t*) const;
-  
+    
+  //-----------------------------------------------------
   //Recalibration
+  //-----------------------------------------------------
+
   void RecalibrateClusterEnergy(AliEMCALGeometry* geom, AliVCluster* cluster, AliVCaloCells * cells);
 
-  Bool_t IsRecalibrationOn()  const        { return fRecalibration ; }
-  void SwitchOnRecalibration()             { fRecalibration = kTRUE ; if(!fEMCALRecalibrationFactors)InitEMCALRecalibrationFactors();}
-  void SwitchOffRecalibration()            { fRecalibration = kFALSE ; }
-  void InitEMCALRecalibrationFactors() ;
+  Bool_t IsRecalibrationOn()           const { return fRecalibration ; }
+  void   SwitchOnRecalibration()             { fRecalibration = kTRUE ; if(!fEMCALRecalibrationFactors)InitEMCALRecalibrationFactors();}
+  void   SwitchOffRecalibration()            { fRecalibration = kFALSE ; }
+  void   InitEMCALRecalibrationFactors() ;
 
   //Recalibrate channels with time dependent corrections
-  void SwitchOnTimeDepCorrection()        { fUseTimeCorrectionFactors = kTRUE ; SwitchOnRecalibration();}
-  void SwitchOffTimeDepCorrection()       { fUseTimeCorrectionFactors = kFALSE;}
+  void SwitchOnTimeDepCorrection()          { fUseTimeCorrectionFactors = kTRUE ; SwitchOnRecalibration();}
+  void SwitchOffTimeDepCorrection()         { fUseTimeCorrectionFactors = kFALSE;}
   void SetTimeDependentCorrections(Int_t runnumber);
     
   Float_t GetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow) const { 
@@ -132,7 +144,10 @@ public:
   void SetEMCALChannelRecalibrationFactors(TObjArray *map)      { fEMCALRecalibrationFactors = map                  ;}
   void SetEMCALChannelRecalibrationFactors(Int_t iSM , TH2F* h) { fEMCALRecalibrationFactors->AddAt(h,iSM)          ;}
 
+  //-----------------------------------------------------
   //Modules fiducial region, remove clusters in borders
+  //-----------------------------------------------------
+
   Bool_t CheckCellFiducialRegion(AliEMCALGeometry* geom, AliVCluster* cluster, AliVCaloCells* cells) ;
   void   SetNumberOfCellsFromEMCALBorder(Int_t n) { fNCellsFromEMCALBorder = n    ;}
   Int_t  GetNumberOfCellsFromEMCALBorder() const  { return fNCellsFromEMCALBorder ;}
@@ -141,14 +156,17 @@ public:
   void   SwitchOffNoFiducialBorderInEMCALEta0()   { fNoEMCALBorderAtEta0 = kFALSE ;}
   Bool_t IsEMCALNoBorderAtEta0()                  { return fNoEMCALBorderAtEta0   ;}
   
+  //-----------------------------------------------------
   // Bad channels
-  Bool_t IsBadChannelsRemovalSwitchedOn()  const { return fRemoveBadChannels      ;}
-  void SwitchOnBadChannelsRemoval ()             { fRemoveBadChannels = kTRUE ; if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap();}
-  void SwitchOffBadChannelsRemoval()             { fRemoveBadChannels = kFALSE    ;}
+  //-----------------------------------------------------
+
+  Bool_t IsBadChannelsRemovalSwitchedOn()     const { return fRemoveBadChannels       ;}
+  void SwitchOnBadChannelsRemoval ()                { fRemoveBadChannels = kTRUE ; if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap();}
+  void SwitchOffBadChannelsRemoval()                { fRemoveBadChannels = kFALSE     ;}
        
-  Bool_t IsDistanceToBadChannelRecalculated() const { return fRecalDistToBadChannels;}
-  void SwitchOnDistToBadChannelRecalculation()   { fRecalDistToBadChannels = kTRUE  ; if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap();}
-  void SwitchOffDistToBadChannelRecalculation()  { fRecalDistToBadChannels = kFALSE ;}
+  Bool_t IsDistanceToBadChannelRecalculated() const { return fRecalDistToBadChannels  ;}
+  void SwitchOnDistToBadChannelRecalculation()      { fRecalDistToBadChannels = kTRUE  ; if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap();}
+  void SwitchOffDistToBadChannelRecalculation()     { fRecalDistToBadChannels = kFALSE ;}
   
   void InitEMCALBadChannelStatusMap() ;
        
@@ -166,7 +184,10 @@ public:
 
   Bool_t ClusterContainsBadChannel(AliEMCALGeometry* geom, UShort_t* cellList, Int_t nCells);
  
-  //Recalculate other cluster parameters
+  //-----------------------------------------------------
+  // Recalculate other cluster parameters
+  //-----------------------------------------------------
+
   void RecalculateClusterDistanceToBadChannel(AliEMCALGeometry * geom, AliVCaloCells* cells, AliVCluster * cluster);
   void RecalculateClusterPID(AliVCluster * cluster);
 
@@ -174,49 +195,53 @@ public:
 
   void RecalculateClusterShowerShapeParameters(AliEMCALGeometry * geom, AliVCaloCells* cells, AliVCluster * cluster);
 
-  //Track matching
-  void FindMatches(AliVEvent *event);
-  void GetMatchedResiduals(Int_t index, Float_t &dR, Float_t &dZ);
-  Bool_t IsMatched(Int_t index);
-  UInt_t FindMatchedPos(Int_t index) const;
+  //----------------------------------------------------
+  // Track matching
+  //----------------------------------------------------
 
-  Float_t GetCutR()    const { return fCutR ;}
-  Float_t GetCutZ()    const { return fCutZ ;}
-  void SetCutR(Float_t cutR) { fCutR=cutR   ;}
-  void SetCutZ(Float_t cutZ) { fCutZ=cutZ   ;}
+  void    FindMatches(AliVEvent *event, TObjArray * clusterArr=0x0);
+  void    GetMatchedResiduals(Int_t index, Float_t &dR, Float_t &dZ);
+  Int_t   GetMatchedTrackIndex(Int_t index);
+  Bool_t  IsMatched(Int_t index);
+  UInt_t  FindMatchedPos(Int_t index) const;
+
+  Float_t GetCutR()       const { return fCutR ;}
+  Float_t GetCutZ()       const { return fCutZ ;}
+  void    SetCutR(Float_t cutR) { fCutR=cutR   ;}
+  void    SetCutZ(Float_t cutZ) { fCutZ=cutZ   ;}
 
   //Track Cuts 
-  Bool_t IsAccepted(AliESDtrack *track);
-  void InitTrackCuts();
+  Bool_t  IsAccepted(AliESDtrack *track);
+  void    InitTrackCuts();
 
   // track quality cut setters  
-  void SetMinNClustersTPC(Int_t min=-1)          {fCutMinNClusterTPC       = min  ;}
-  void SetMinNClustersITS(Int_t min=-1)          {fCutMinNClusterITS       = min  ;}
-  void SetMaxChi2PerClusterTPC(Float_t max=1e10) {fCutMaxChi2PerClusterTPC = max  ;}
-  void SetMaxChi2PerClusterITS(Float_t max=1e10) {fCutMaxChi2PerClusterITS = max  ;}
-  void SetRequireTPCRefit(Bool_t b=kFALSE)       {fCutRequireTPCRefit      = b    ;}
-  void SetRequireITSRefit(Bool_t b=kFALSE)       {fCutRequireITSRefit      = b    ;}
-  void SetAcceptKinkDaughters(Bool_t b=kTRUE)    {fCutAcceptKinkDaughters  = b    ;}
-  void SetMaxDCAToVertexXY(Float_t dist=1e10)    {fCutMaxDCAToVertexXY     = dist ;}
-  void SetMaxDCAToVertexZ(Float_t dist=1e10)     {fCutMaxDCAToVertexZ      = dist ;}
-  void SetDCAToVertex2D(Bool_t b=kFALSE)         {fCutDCAToVertex2D        = b    ;}
+  void    SetMinNClustersTPC(Int_t min=-1)          { fCutMinNClusterTPC       = min  ;}
+  void    SetMinNClustersITS(Int_t min=-1)          { fCutMinNClusterITS       = min  ;}
+  void    SetMaxChi2PerClusterTPC(Float_t max=1e10) { fCutMaxChi2PerClusterTPC = max  ;}
+  void    SetMaxChi2PerClusterITS(Float_t max=1e10) { fCutMaxChi2PerClusterITS = max  ;}
+  void    SetRequireTPCRefit(Bool_t b=kFALSE)       { fCutRequireTPCRefit      = b    ;}
+  void    SetRequireITSRefit(Bool_t b=kFALSE)       { fCutRequireITSRefit      = b    ;}
+  void    SetAcceptKinkDaughters(Bool_t b=kTRUE)    { fCutAcceptKinkDaughters  = b    ;}
+  void    SetMaxDCAToVertexXY(Float_t dist=1e10)    { fCutMaxDCAToVertexXY     = dist ;}
+  void    SetMaxDCAToVertexZ(Float_t dist=1e10)     { fCutMaxDCAToVertexZ      = dist ;}
+  void    SetDCAToVertex2D(Bool_t b=kFALSE)         { fCutDCAToVertex2D        = b    ;}
 
   // getters
-
-  Int_t   GetMinNClusterTPC()        const   { return fCutMinNClusterTPC;}
-  Int_t   GetMinNClustersITS()       const   { return fCutMinNClusterITS;}
-  Float_t GetMaxChi2PerClusterTPC()  const   { return fCutMaxChi2PerClusterTPC;}
-  Float_t GetMaxChi2PerClusterITS()  const   { return fCutMaxChi2PerClusterITS;}
-  Bool_t  GetRequireTPCRefit()       const   { return fCutRequireTPCRefit;}
-  Bool_t  GetRequireITSRefit()       const   { return fCutRequireITSRefit;}
-  Bool_t  GetAcceptKinkDaughters()   const   { return fCutAcceptKinkDaughters;}
-  Float_t GetMaxDCAToVertexXY()      const   { return fCutMaxDCAToVertexXY;}
-  Float_t GetMaxDCAToVertexZ()       const   { return fCutMaxDCAToVertexZ;}
-  Bool_t  GetDCAToVertex2D()         const   { return fCutDCAToVertex2D;}
+  Int_t   GetMinNClusterTPC()               const   { return fCutMinNClusterTPC       ;}
+  Int_t   GetMinNClustersITS()              const   { return fCutMinNClusterITS       ;}
+  Float_t GetMaxChi2PerClusterTPC()         const   { return fCutMaxChi2PerClusterTPC ;}
+  Float_t GetMaxChi2PerClusterITS()         const   { return fCutMaxChi2PerClusterITS ;}
+  Bool_t  GetRequireTPCRefit()              const   { return fCutRequireTPCRefit      ;}
+  Bool_t  GetRequireITSRefit()              const   { return fCutRequireITSRefit      ;}
+  Bool_t  GetAcceptKinkDaughters()          const   { return fCutAcceptKinkDaughters  ;}
+  Float_t GetMaxDCAToVertexXY()             const   { return fCutMaxDCAToVertexXY     ;}
+  Float_t GetMaxDCAToVertexZ()              const   { return fCutMaxDCAToVertexZ      ;}
+  Bool_t  GetDCAToVertex2D()                const   { return fCutDCAToVertex2D        ;}
 
 
 private:
   
+  //Position recalculation
   Float_t    fMisalTransShift[15];       // Shift parameters
   Float_t    fMisalRotShift[15];         // Shift parameters
   Int_t      fNonLinearityFunction;      // Non linearity function choice
@@ -225,21 +250,27 @@ private:
   Int_t      fPosAlgo;                   // Position recalculation algorithm
   Float_t    fW0;                        // Weight0
   
+  // Recalibration 
   Bool_t     fRecalibration;             // Switch on or off the recalibration
   TObjArray* fEMCALRecalibrationFactors; // Array of histograms with map of recalibration factors, EMCAL
+
+  // Bad Channels
   Bool_t     fRemoveBadChannels;         // Check the channel status provided and remove clusters with bad channels
   Bool_t     fRecalDistToBadChannels;    // Calculate distance from highest energy tower of cluster to closes bad channel
   TObjArray* fEMCALBadChannelMap;        // Array of histograms with map of bad channels, EMCAL
+
+  // Border cells
   Int_t      fNCellsFromEMCALBorder;     // Number of cells from EMCAL border the cell with maximum amplitude has to be.
   Bool_t     fNoEMCALBorderAtEta0;       // Do fiducial cut in EMCAL region eta = 0?
-
+  
+  //Track matching 
+  TArrayI  * fMatchedTrackIndex;         // Array that stores indexes of matched tracks      
   TArrayI  * fMatchedClusterIndex;       // Array that stores indexes of matched clusters
   TArrayF  * fResidualZ;                 // Array that stores the residual z
   TArrayF  * fResidualR;                 // Array that stores the residual r
   Float_t    fCutR;                      // dR cut on matching
   Float_t    fCutZ;                      // dZ cut on matching
-
-  enum { kNCuts = 11 }; 
+  
   Int_t      fCutMinNClusterTPC;         // Min number of tpc clusters
   Int_t      fCutMinNClusterITS;         // Min number of its clusters  
   Float_t    fCutMaxChi2PerClusterTPC;   // Max tpc fit chi2 per tpc cluster
@@ -251,13 +282,14 @@ private:
   Float_t    fCutMaxDCAToVertexZ;        // Track-to-vertex cut in max absolute distance in z-plane
   Bool_t     fCutDCAToVertex2D;          // If true a 2D DCA cut is made. Tracks are accepted if sqrt((DCAXY / fCutMaxDCAToVertexXY)^2 + (DCAZ / fCutMaxDCAToVertexZ)^2) < 1 AND sqrt((DCAXY / fCutMinDCAToVertexXY)^2 + (DCAZ / fCutMinDCAToVertexZ)^2) > 1
 
+  //PID
   AliEMCALPIDUtils * fPIDUtils;          // Recalculate PID parameters
   
   //Time Correction
   Bool_t     fUseTimeCorrectionFactors;  // Use Time Dependent Correction
   Bool_t     fTimeCorrectionFactorsSet;  // Time Correction set at leat once
   
-  ClassDef(AliEMCALRecoUtils, 6)
+  ClassDef(AliEMCALRecoUtils, 7)
   
 };