ROOT logo
#ifndef ALIEMCALRECOUTILS_H
#define ALIEMCALRECOUTILS_H

/* $Id: AliEMCALRecoUtils.h | Tue Jul 23 09:11:15 2013 +0000 | gconesab  $ */

///////////////////////////////////////////////////////////////////////////////
//
// Class AliEMCALRecoUtils
// Some utilities to recalculate the cluster position or energy linearity
//
//
// Author:  Gustavo Conesa (LPSC- Grenoble) 
//          Track matching part: Rongrong Ma (Yale)
///////////////////////////////////////////////////////////////////////////////

//Root includes
#include <TNamed.h>
#include <TMath.h>
class TObjArray;
class TArrayI;
class TArrayF;
#include <TH2I.h>
class TH2F;
#include <TRandom3.h>

//AliRoot includes
class AliVCluster;
class AliVCaloCells;
class AliVEvent;
#include "AliLog.h"

// EMCAL includes
class AliEMCALGeometry;
class AliEMCALPIDUtils;
class AliESDtrack;
class AliExternalTrackParam;
class AliVTrack;

class AliEMCALRecoUtils : public TNamed {
  
public:
  
  AliEMCALRecoUtils();
  AliEMCALRecoUtils(const AliEMCALRecoUtils&); 
  AliEMCALRecoUtils& operator=(const AliEMCALRecoUtils&); 
  virtual ~AliEMCALRecoUtils() ;  
  
  void     InitParameters();
  void     Print(const Option_t*) const;

  //enums
  enum     NonlinearityFunctions{ kPi0MC   = 0, kPi0GammaGamma = 1,
                                  kPi0GammaConversion = 2, kNoCorrection = 3,
                                  kBeamTest= 4, kBeamTestCorrected = 5,
                                  kPi0MCv2 = 6, kPi0MCv3 = 7,
                                  kBeamTestCorrectedv2   = 8,
                                  kSDMv5   = 9, kPi0MCv5 = 10,
                                  kSDMv6   =11, kPi0MCv6 = 12};
  
  enum     PositionAlgorithms{kUnchanged=-1,kPosTowerIndex=0, kPosTowerGlobal=1};
  enum     ParticleType{kPhoton=0, kElectron=1,kHadron =2, kUnknown=-1};
  enum     { kNCuts = 12 }; //track matching Marcel
  enum     TrackCutsType{kTPCOnlyCut=0, kGlobalCut=1, kLooseCut=2, kITSStandAlone=3};  //Marcel

  //-----------------------------------------------------
  //Position recalculation
  //-----------------------------------------------------
  void     RecalculateClusterPosition               (const AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu); 
  void     RecalculateClusterPositionFromTowerIndex (const AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu); 
  void     RecalculateClusterPositionFromTowerGlobal(const AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu); 
  Float_t  GetCellWeight(Float_t eCell, Float_t eCluster) const { if (eCell > 0 && eCluster > 0) return TMath::Max( 0., fW0 + TMath::Log( eCell / eCluster )) ;
                                                                  else                           return 0.                                                    ; }
  Float_t  GetDepth(Float_t eCluster, Int_t iParticle, Int_t iSM) const; 
  void     GetMaxEnergyCell(const AliEMCALGeometry *geom, AliVCaloCells* cells, const AliVCluster* clu, 
                            Int_t & absId,  Int_t& iSupMod, Int_t& ieta, Int_t& iphi, Bool_t &shared);
  
  Float_t  GetMisalTransShift(Int_t i)       const { if(i < 15 ) { return fMisalTransShift[i] ; }
                                                     else        { AliInfo(Form("Index %d larger than 15, do nothing\n",i)) ; 
                                                                   return 0.                  ; } }
  Float_t* GetMisalTransShiftArray()                  { return fMisalTransShift ; }
  void     SetMisalTransShift(Int_t i, Float_t shift) { if(i < 15 ) { fMisalTransShift[i] = shift ; }
                                                        else        { AliInfo(Form("Index %d larger than 15, do nothing\n",i)) ; } }
  void     SetMisalTransShiftArray(Float_t * misal)   { for(Int_t i = 0; i < 15; i++) fMisalTransShift[i] = misal[i]  ; }
  Float_t  GetMisalRotShift(Int_t i)         const    { if(i < 15 ) { return fMisalRotShift[i]    ; }
                                                        else        { AliInfo(Form("Index %d larger than 15, do nothing\n",i)) ; 
                                                                      return 0.                   ; } }
  Float_t* GetMisalRotShiftArray()                    { return fMisalRotShift                     ; }
  void     SetMisalRotShift(Int_t i, Float_t shift)   { if(i < 15 ) { fMisalRotShift[i] = shift   ; }
                                                        else        { AliInfo(Form("Index %d larger than 15, do nothing\n",i)) ; } }
  void     SetMisalRotShiftArray(Float_t * misal)     { for(Int_t i = 0; i < 15; i++)fMisalRotShift[i] = misal[i] ; }
  Int_t    GetParticleType()                       const { return  fParticleType    ; }
  void     SetParticleType(Int_t particle)               { fParticleType = particle ; }
  Int_t    GetPositionAlgorithm()                  const { return fPosAlgo          ; }
  void     SetPositionAlgorithm(Int_t alg)               { fPosAlgo = alg           ; }
  Float_t  GetW0()                                 const { return fW0               ; }
  void     SetW0(Float_t w0)                             { fW0  = w0                ; }

  //-----------------------------------------------------
  // Non Linearity
  //-----------------------------------------------------
  Float_t  CorrectClusterEnergyLinearity(AliVCluster* clu) ;
  Float_t  GetNonLinearityParam(Int_t i)     const { if(i < 7 && i >=0 ){ return fNonLinearityParams[i]  ; }
                                                     else  { AliInfo(Form("Index %d larger than 6 or negative, do nothing\n",i)) ;
                                                                         return 0.                     ; } }
  void     SetNonLinearityParam(Int_t i, Float_t param)  { if(i < 7 && i >=0 ){ fNonLinearityParams[i] = param ; }
                                                           else { AliInfo(Form("Index %d larger than 6 or negative, do nothing\n",i)) ; } }
  void     InitNonLinearityParam();
  Int_t    GetNonLinearityFunction() const               { return fNonLinearityFunction    ; }
  void     SetNonLinearityFunction(Int_t fun)            { fNonLinearityFunction = fun     ; InitNonLinearityParam() ; }
  void     SetNonLinearityThreshold(Int_t threshold)     { fNonLinearThreshold = threshold ; } //only for Alexie's non linearity correction
  Int_t    GetNonLinearityThreshold()              const { return fNonLinearThreshold      ; }

  //-----------------------------------------------------
  // MC clusters energy smearing
  //-----------------------------------------------------
  Float_t  SmearClusterEnergy(const AliVCluster* clu) ;
  void     SwitchOnClusterEnergySmearing()               { fSmearClusterEnergy = kTRUE         ; }
  void     SwitchOffClusterEnergySmearing()              { fSmearClusterEnergy = kFALSE        ; }
  Bool_t   IsClusterEnergySmeared()                const { return fSmearClusterEnergy          ; }   
  void     SetSmearingParameters(Int_t i, Float_t param) { if(i < 3){ fSmearClusterParam[i] = param ; }
                                                           else     { AliInfo(Form("Index %d larger than 2, do nothing\n",i)) ; } }
  //-----------------------------------------------------
  // Recalibration
  //-----------------------------------------------------
  Bool_t   AcceptCalibrateCell(Int_t absId, Int_t bc,
                               Float_t & amp, Double_t & time, AliVCaloCells* cells) ; // Energy and Time
  void     RecalibrateCells(AliVCaloCells * cells, Int_t bc) ; // Energy and Time
  void     RecalibrateClusterEnergy(const AliEMCALGeometry* geom, AliVCluster* cluster, AliVCaloCells * cells, Int_t bc=-1) ; // Energy and time
  void     ResetCellsCalibrated()                        { fCellsRecalibrated = kFALSE; }

  // Energy recalibration
  Bool_t   IsRecalibrationOn()                     const { return fRecalibration ; }
  void     SwitchOffRecalibration()                      { fRecalibration = kFALSE ; }
  void     SwitchOnRecalibration()                       { fRecalibration = kTRUE  ; 
                                                           if(!fEMCALRecalibrationFactors)InitEMCALRecalibrationFactors() ; }
  void     InitEMCALRecalibrationFactors() ;
  TObjArray* GetEMCALRecalibrationFactorsArray()   const { return fEMCALRecalibrationFactors ; }
  TH2F *   GetEMCALChannelRecalibrationFactors(Int_t iSM)     const { return (TH2F*)fEMCALRecalibrationFactors->At(iSM) ; }	
  void     SetEMCALChannelRecalibrationFactors(TObjArray *map)      { fEMCALRecalibrationFactors = map                  ; }
  void     SetEMCALChannelRecalibrationFactors(Int_t iSM , TH2F* h) { fEMCALRecalibrationFactors->AddAt(h,iSM)          ; }
  Float_t  GetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow) const { 
    if(fEMCALRecalibrationFactors) 
      return (Float_t) ((TH2F*)fEMCALRecalibrationFactors->At(iSM))->GetBinContent(iCol,iRow); 
    else return 1 ; } 
  void     SetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) { 
    if(!fEMCALRecalibrationFactors) InitEMCALRecalibrationFactors() ;
    ((TH2F*)fEMCALRecalibrationFactors->At(iSM))->SetBinContent(iCol,iRow,c) ; }
  
  //Recalibrate channels energy with run dependent corrections
  Bool_t   IsRunDepRecalibrationOn()               const { return fUseRunCorrectionFactors ; }
  void     SwitchOffRunDepCorrection()                   { fUseRunCorrectionFactors = kFALSE ; }
  void     SwitchOnRunDepCorrection()                    { fUseRunCorrectionFactors = kTRUE  ; 
                                                           SwitchOnRecalibration()           ; }      
  // Time Recalibration  
  void     RecalibrateCellTime(Int_t absId, Int_t bc, Double_t & time) const;
  
  Bool_t   IsTimeRecalibrationOn()                 const { return fTimeRecalibration   ; }
  void     SwitchOffTimeRecalibration()                  { fTimeRecalibration = kFALSE ; }
  void     SwitchOnTimeRecalibration()                   { fTimeRecalibration = kTRUE  ; 
                                                           if(!fEMCALTimeRecalibrationFactors)InitEMCALTimeRecalibrationFactors() ; }
  void     InitEMCALTimeRecalibrationFactors() ;
  TObjArray* GetEMCALTimeRecalibrationFactorsArray() const { return fEMCALTimeRecalibrationFactors ; }

  Float_t  GetEMCALChannelTimeRecalibrationFactor(Int_t bc, Int_t absID) const { 
    if(fEMCALTimeRecalibrationFactors) 
      return (Float_t) ((TH1F*)fEMCALTimeRecalibrationFactors->At(bc))->GetBinContent(absID); 
    else return 0 ; } 
  void     SetEMCALChannelTimeRecalibrationFactor(Int_t bc, Int_t absID, Double_t c = 0) { 
    if(!fEMCALTimeRecalibrationFactors) InitEMCALTimeRecalibrationFactors() ;
    ((TH1F*)fEMCALTimeRecalibrationFactors->At(bc))->SetBinContent(absID,c) ; }  
  
  TH1F *   GetEMCALChannelTimeRecalibrationFactors(Int_t bc)const       { return (TH1F*)fEMCALTimeRecalibrationFactors->At(bc) ; }	
  void     SetEMCALChannelTimeRecalibrationFactors(TObjArray *map)            { fEMCALTimeRecalibrationFactors = map                 ; }
  void     SetEMCALChannelTimeRecalibrationFactors(Int_t bc , TH1F* h)  { fEMCALTimeRecalibrationFactors->AddAt(h,bc)          ; }
  
  //-----------------------------------------------------
  // Modules fiducial region, remove clusters in borders
  //-----------------------------------------------------
  Bool_t   CheckCellFiducialRegion(const AliEMCALGeometry* geom, 
                                   const AliVCluster* cluster, 
                                   AliVCaloCells* cells) ;
  void     SetNumberOfCellsFromEMCALBorder(Int_t n){ fNCellsFromEMCALBorder = n      ; }
  Int_t    GetNumberOfCellsFromEMCALBorder()      const  { return fNCellsFromEMCALBorder   ; }
    
  void     SwitchOnNoFiducialBorderInEMCALEta0()         { fNoEMCALBorderAtEta0 = kTRUE    ; }
  void     SwitchOffNoFiducialBorderInEMCALEta0()        { fNoEMCALBorderAtEta0 = kFALSE   ; }
  Bool_t   IsEMCALNoBorderAtEta0()                 const { return fNoEMCALBorderAtEta0     ; }
  
  //-----------------------------------------------------
  // Bad channels
  //-----------------------------------------------------
  Bool_t   IsBadChannelsRemovalSwitchedOn()        const { return fRemoveBadChannels       ; }
  void     SwitchOffBadChannelsRemoval()                 { fRemoveBadChannels = kFALSE     ; }
  void     SwitchOnBadChannelsRemoval ()                 { fRemoveBadChannels = kTRUE ; 
                                                           if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap() ; }
  Bool_t   IsDistanceToBadChannelRecalculated()    const { return fRecalDistToBadChannels   ; }
  void     SwitchOffDistToBadChannelRecalculation()      { fRecalDistToBadChannels = kFALSE ; }
  void     SwitchOnDistToBadChannelRecalculation()       { fRecalDistToBadChannels = kTRUE  ; 
                                                           if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap() ; }
  TObjArray* GetEMCALBadChannelStatusMapArray()    const { return fEMCALBadChannelMap ; }
  void     InitEMCALBadChannelStatusMap() ;
  Int_t    GetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow) const { 
    if(fEMCALBadChannelMap) return (Int_t) ((TH2I*)fEMCALBadChannelMap->At(iSM))->GetBinContent(iCol,iRow); 
    else return 0;}//Channel is ok by default
  void     SetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) { 
    if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap()               ;
    ((TH2I*)fEMCALBadChannelMap->At(iSM))->SetBinContent(iCol,iRow,c)    ; }
  TH2I *   GetEMCALChannelStatusMap(Int_t iSM)     const { return (TH2I*)fEMCALBadChannelMap->At(iSM) ; }
  void     SetEMCALChannelStatusMap(TObjArray *map)      { fEMCALBadChannelMap = map                  ; }
  void     SetEMCALChannelStatusMap(Int_t iSM , TH2I* h) { fEMCALBadChannelMap->AddAt(h,iSM)          ; }
  Bool_t   ClusterContainsBadChannel(const AliEMCALGeometry* geom, const UShort_t* cellList, Int_t nCells);
 
  //-----------------------------------------------------
  // Recalculate other cluster parameters
  //-----------------------------------------------------
  void     RecalculateClusterDistanceToBadChannel (const AliEMCALGeometry * geom, AliVCaloCells* cells, AliVCluster * cluster);
  void     RecalculateClusterShowerShapeParameters(const AliEMCALGeometry * geom, AliVCaloCells* cells, AliVCluster * cluster);
  void     RecalculateClusterShowerShapeParameters(const AliEMCALGeometry * geom, AliVCaloCells* cells, AliVCluster * cluster,
                                                   Float_t & l0,   Float_t & l1,   
                                                   Float_t & disp, Float_t & dEta, Float_t & dPhi,
                                                   Float_t & sEta, Float_t & sPhi, Float_t & sEtaPhi);
  void     RecalculateClusterPID(AliVCluster * cluster);
  AliEMCALPIDUtils * GetPIDUtils() { return fPIDUtils;}

  //----------------------------------------------------
  // Track matching
  //----------------------------------------------------
  void     FindMatches(AliVEvent *event, TObjArray * clusterArr=0x0, const AliEMCALGeometry *geom=0x0);
  Int_t    FindMatchedClusterInEvent(const AliESDtrack *track, const AliVEvent *event, 
                                     const AliEMCALGeometry *geom, Float_t &dEta, Float_t &dPhi);
  Int_t    FindMatchedClusterInClusterArr(const AliExternalTrackParam *emcalParam, 
                                          AliExternalTrackParam *trkParam, 
                                          const TObjArray * clusterArr, 
                                          Float_t &dEta, Float_t &dPhi);
  static Bool_t ExtrapolateTrackToEMCalSurface(AliVTrack *track, /*note, on success the call will change the track*/
                                               Double_t emcalR=440, Double_t mass=0.1396,
                                               Double_t step=20, Double_t minpT=0.35,
                                               Bool_t useMassForTracking = kFALSE);
  static Bool_t ExtrapolateTrackToEMCalSurface(AliExternalTrackParam *trkParam, 
                                               Double_t emcalR, Double_t mass, Double_t step, 
                                               Float_t &eta, Float_t &phi, Float_t &pt);
  static Bool_t ExtrapolateTrackToPosition(AliExternalTrackParam *trkParam, const Float_t *clsPos, 
                                           Double_t mass, Double_t step, 
                                           Float_t &tmpEta, Float_t &tmpPhi);
  static Bool_t ExtrapolateTrackToCluster (AliExternalTrackParam *trkParam, const AliVCluster *cluster, 
                                           Double_t mass, Double_t step,
                                           Float_t &tmpEta, Float_t &tmpPhi);
  Bool_t        ExtrapolateTrackToCluster (AliExternalTrackParam *trkParam, const AliVCluster *cluster, 
                                           Float_t &tmpEta, Float_t &tmpPhi);
  UInt_t   FindMatchedPosForCluster(Int_t clsIndex) const;
  UInt_t   FindMatchedPosForTrack  (Int_t trkIndex) const;
  void     GetMatchedResiduals       (Int_t clsIndex, Float_t &dEta, Float_t &dPhi);
  void     GetMatchedClusterResiduals(Int_t trkIndex, Float_t &dEta, Float_t &dPhi);
  Int_t    GetMatchedTrackIndex(Int_t clsIndex);
  Int_t    GetMatchedClusterIndex(Int_t trkIndex);
  Bool_t   IsClusterMatched(Int_t clsIndex)         const;
  Bool_t   IsTrackMatched  (Int_t trkIndex)         const;
  void     SetClusterMatchedToTrack (const AliVEvent *event);
  void     SetTracksMatchedToCluster(const AliVEvent *event);  
  void     SwitchOnCutEtaPhiSum()                     { fCutEtaPhiSum      = kTRUE    ; 
                                                        fCutEtaPhiSeparate = kFALSE   ; }
  void     SwitchOnCutEtaPhiSeparate()                { fCutEtaPhiSeparate = kTRUE    ;
                                                        fCutEtaPhiSum      = kFALSE   ; }
  Float_t  GetCutR()                            const { return fCutR                  ; }
  Float_t  GetCutEta()                          const { return fCutEta                ; }
  Float_t  GetCutPhi()                          const { return fCutPhi                ; }
  Double_t GetClusterWindow()                   const { return fClusterWindow         ; }
  void     SetCutR(Float_t cutR)                      { fCutR   = cutR                ; }
  void     SetCutEta(Float_t cutEta)                  { fCutEta = cutEta              ; }
  void     SetCutPhi(Float_t cutPhi)                  { fCutPhi = cutPhi              ; }
  void     SetClusterWindow(Double_t window)          { fClusterWindow = window       ; }
  void     SetCutZ(Float_t cutZ)                      { printf("Obsolete fucntion of cutZ=%1.1f\n",cutZ) ; } //Obsolete
  void     SetEMCalSurfaceDistance(Double_t d)        { fEMCalSurfaceDistance = d     ; }
  Double_t GetMass()                            const { return fMass                  ; }
  Double_t GetStep()                            const { return fStepCluster           ; }
  Double_t GetStepSurface()                     const { return fStepSurface           ; }
  void     SetMass(Double_t mass)                     { fMass = mass                  ; }
  void     SetStep(Double_t step)                     { fStepSurface = step           ; }
  void     SetStepCluster(Double_t step)              { fStepCluster = step           ; }
  void     SetITSTrackSA(Bool_t isITS)                { fITSTrackSA = isITS           ; } //Special Handle of AliExternTrackParam    
    
  // Exotic cells / clusters
  Bool_t   IsExoticCell(Int_t absId, AliVCaloCells* cells, Int_t bc =-1) ;
  void     SwitchOnRejectExoticCell()                 { fRejectExoticCells = kTRUE     ; }
  void     SwitchOffRejectExoticCell()                { fRejectExoticCells = kFALSE    ; } 
  Bool_t   IsRejectExoticCell()                 const { return fRejectExoticCells      ; }
  Float_t  GetECross(Int_t absID, Double_t tcell,
                     AliVCaloCells* cells, Int_t bc);
  Float_t  GetExoticCellFractionCut()           const { return fExoticCellFraction     ; }
  Float_t  GetExoticCellDiffTimeCut()           const { return fExoticCellDiffTime     ; }
  Float_t  GetExoticCellMinAmplitudeCut()       const { return fExoticCellMinAmplitude ; }
  void     SetExoticCellFractionCut(Float_t f)        { fExoticCellFraction     = f    ; }
  void     SetExoticCellDiffTimeCut(Float_t dt)       { fExoticCellDiffTime     = dt   ; }
  void     SetExoticCellMinAmplitudeCut(Float_t ma)   { fExoticCellMinAmplitude = ma   ; }
  Bool_t   IsExoticCluster(const AliVCluster *cluster, AliVCaloCells* cells, Int_t bc=0) ;
  void     SwitchOnRejectExoticCluster()              { fRejectExoticCluster = kTRUE   ;
                                                        fRejectExoticCells   = kTRUE   ; }
  void     SwitchOffRejectExoticCluster()             { fRejectExoticCluster = kFALSE  ; }
  Bool_t   IsRejectExoticCluster()              const { return fRejectExoticCluster    ; }

  //Cluster cut
  Bool_t   IsGoodCluster(AliVCluster *cluster, const AliEMCALGeometry *geom, 
                         AliVCaloCells* cells, Int_t bc =-1);

  //Track Cuts 
  Bool_t   IsAccepted(AliESDtrack *track);
  void     InitTrackCuts();
  void     SetTrackCutsType(Int_t type)              { fTrackCutsType = type           ; 
                                                       InitTrackCuts()                 ; }
  Int_t    GetTrackCutsType() const                  { return fTrackCutsType; }

  // Define AOD track type for matching
  void     SwitchOffAODHybridTracksMatch()           { fAODHybridTracks         = kFALSE ; }
  void     SwitchOffAODTPCOnlyTracksMatch()          { fAODTPCOnlyTracks        = kFALSE ; }
  void     SwitchOnAODHybridTracksMatch()            { fAODHybridTracks         = kTRUE  ; SwitchOffAODTPCOnlyTracksMatch() ; }
  void     SwitchOnAODTPCOnlyTracksMatch()           { fAODTPCOnlyTracks        = kTRUE  ; SwitchOffAODHybridTracksMatch()  ; }
  void     SetAODTrackFilterMask( UInt_t mask)       { fAODFilterMask           = mask   ;
                                                       SwitchOffAODTPCOnlyTracksMatch()  ; SwitchOffAODHybridTracksMatch()  ; }

  // track quality cut setters
  void     SetMinTrackPt(Double_t pt=0)              { fCutMinTrackPt           = pt   ; }
  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     SetRequireITSStandAlone(Bool_t b=kFALSE)    {fCutRequireITSStandAlone = b;} //Marcel
  void     SetRequireITSPureStandAlone(Bool_t b=kFALSE){fCutRequireITSpureSA     = b;}
  
  // getters								
  Double_t GetMinTrackPt()                     const { return fCutMinTrackPt           ; }
  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        ; }
  Bool_t   GetRequireITSStandAlone()           const { return fCutRequireITSStandAlone ; } //Marcel	

private:  
  //Position recalculation
  Float_t    fMisalTransShift[15];       // Shift parameters
  Float_t    fMisalRotShift[15];         // Shift parameters
  Int_t      fParticleType;              // Particle type for depth calculation
  Int_t      fPosAlgo;                   // Position recalculation algorithm
  Float_t    fW0;                        // Weight0
    
  // Non linearity
  Int_t      fNonLinearityFunction;      // Non linearity function choice
  Float_t    fNonLinearityParams[7];     // Parameters for the non linearity function
  Int_t	     fNonLinearThreshold;        // Non linearity threshold value for kBeamTesh non linearity function 
  
  // Energy smearing for MC
  Bool_t     fSmearClusterEnergy;        // Smear cluster energy, to be done only for simulated data to match real data
  Float_t    fSmearClusterParam[3];      // Smearing parameters
  TRandom3   fRandom;                    // Random generator
    
  // Energy Recalibration 
  Bool_t     fCellsRecalibrated;         // Internal bool to check if cells (time/energy) where recalibrated and not recalibrate them when recalculating different things
  Bool_t     fRecalibration;             // Switch on or off the recalibration
  TObjArray* fEMCALRecalibrationFactors; // Array of histograms with map of recalibration factors, EMCAL
    
  // Time Recalibration 
  Bool_t     fTimeRecalibration;             // Switch on or off the time recalibration
  TObjArray* fEMCALTimeRecalibrationFactors; // Array of histograms with map of time recalibration factors, EMCAL
  
  // Recalibrate with run dependent corrections, energy
  Bool_t     fUseRunCorrectionFactors;   // Use Run Dependent Correction
    
  // 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?
  
  // Exotic cell / cluster
  Bool_t     fRejectExoticCluster;       // Switch on or off exotic cluster rejection
  Bool_t     fRejectExoticCells;         // Remove exotic cells
  Float_t    fExoticCellFraction;        // Good cell if fraction < 1-ecross/ecell
  Float_t    fExoticCellDiffTime;        // If time of candidate to exotic and close cell is too different (in ns), it must be noisy, set amp to 0
  Float_t    fExoticCellMinAmplitude;    // Check for exotic only if amplitud is larger than this value
  
  // PID
  AliEMCALPIDUtils * fPIDUtils;          // Recalculate PID parameters
    
  //Track matching
  UInt_t     fAODFilterMask;             // Filter mask to select AOD tracks. Refer to $ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C
  Bool_t     fAODHybridTracks;           // Match with hybrid
  Bool_t     fAODTPCOnlyTracks;          // Match with TPC only tracks
  
  TArrayI  * fMatchedTrackIndex;         // Array that stores indexes of matched tracks      
  TArrayI  * fMatchedClusterIndex;       // Array that stores indexes of matched clusters
  TArrayF  * fResidualEta;               // Array that stores the residual eta
  TArrayF  * fResidualPhi;               // Array that stores the residual phi
  Bool_t     fCutEtaPhiSum;              // Place cut on sqrt(dEta^2+dPhi^2)
  Bool_t     fCutEtaPhiSeparate;         // Cut on dEta and dPhi separately
  Float_t    fCutR;                      // sqrt(dEta^2+dPhi^2) cut on matching
  Float_t    fCutEta;                    // dEta cut on matching
  Float_t    fCutPhi;                    // dPhi cut on matching
  Double_t   fClusterWindow;             // Select clusters in the window to be matched
  Double_t   fMass;                      // Mass hypothesis of the track
  Double_t   fStepSurface;               // Length of step to extrapolate tracks to EMCal surface
  Double_t   fStepCluster;               // Length of step to extrapolate tracks to clusters
  Bool_t     fITSTrackSA;                // If track matching is to be done with ITS tracks standing alone	
  Double_t   fEMCalSurfaceDistance;      // EMCal surface distance (= 430 by default, the last 10 cm are propagated on a cluster-track pair basis)
 
  // Track cuts  
  Int_t      fTrackCutsType;             // Esd track cuts type for matching
  Double_t   fCutMinTrackPt;             // Cut on track pT
  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
  Float_t    fCutMaxChi2PerClusterITS;   // Max its fit chi2 per its cluster
  Bool_t     fCutRequireTPCRefit;        // Require TPC refit
  Bool_t     fCutRequireITSRefit;        // Require ITS refit
  Bool_t     fCutAcceptKinkDaughters;    // Accepting kink daughters?
  Float_t    fCutMaxDCAToVertexXY;       // Track-to-vertex cut in max absolute distance in xy-plane
  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.
  Bool_t     fCutRequireITSStandAlone;   // Require ITSStandAlone
  Bool_t     fCutRequireITSpureSA;       // ITS pure standalone tracks
  
  ClassDef(AliEMCALRecoUtils, 22)
};
#endif // ALIEMCALRECOUTILS_H


 AliEMCALRecoUtils.h:1
 AliEMCALRecoUtils.h:2
 AliEMCALRecoUtils.h:3
 AliEMCALRecoUtils.h:4
 AliEMCALRecoUtils.h:5
 AliEMCALRecoUtils.h:6
 AliEMCALRecoUtils.h:7
 AliEMCALRecoUtils.h:8
 AliEMCALRecoUtils.h:9
 AliEMCALRecoUtils.h:10
 AliEMCALRecoUtils.h:11
 AliEMCALRecoUtils.h:12
 AliEMCALRecoUtils.h:13
 AliEMCALRecoUtils.h:14
 AliEMCALRecoUtils.h:15
 AliEMCALRecoUtils.h:16
 AliEMCALRecoUtils.h:17
 AliEMCALRecoUtils.h:18
 AliEMCALRecoUtils.h:19
 AliEMCALRecoUtils.h:20
 AliEMCALRecoUtils.h:21
 AliEMCALRecoUtils.h:22
 AliEMCALRecoUtils.h:23
 AliEMCALRecoUtils.h:24
 AliEMCALRecoUtils.h:25
 AliEMCALRecoUtils.h:26
 AliEMCALRecoUtils.h:27
 AliEMCALRecoUtils.h:28
 AliEMCALRecoUtils.h:29
 AliEMCALRecoUtils.h:30
 AliEMCALRecoUtils.h:31
 AliEMCALRecoUtils.h:32
 AliEMCALRecoUtils.h:33
 AliEMCALRecoUtils.h:34
 AliEMCALRecoUtils.h:35
 AliEMCALRecoUtils.h:36
 AliEMCALRecoUtils.h:37
 AliEMCALRecoUtils.h:38
 AliEMCALRecoUtils.h:39
 AliEMCALRecoUtils.h:40
 AliEMCALRecoUtils.h:41
 AliEMCALRecoUtils.h:42
 AliEMCALRecoUtils.h:43
 AliEMCALRecoUtils.h:44
 AliEMCALRecoUtils.h:45
 AliEMCALRecoUtils.h:46
 AliEMCALRecoUtils.h:47
 AliEMCALRecoUtils.h:48
 AliEMCALRecoUtils.h:49
 AliEMCALRecoUtils.h:50
 AliEMCALRecoUtils.h:51
 AliEMCALRecoUtils.h:52
 AliEMCALRecoUtils.h:53
 AliEMCALRecoUtils.h:54
 AliEMCALRecoUtils.h:55
 AliEMCALRecoUtils.h:56
 AliEMCALRecoUtils.h:57
 AliEMCALRecoUtils.h:58
 AliEMCALRecoUtils.h:59
 AliEMCALRecoUtils.h:60
 AliEMCALRecoUtils.h:61
 AliEMCALRecoUtils.h:62
 AliEMCALRecoUtils.h:63
 AliEMCALRecoUtils.h:64
 AliEMCALRecoUtils.h:65
 AliEMCALRecoUtils.h:66
 AliEMCALRecoUtils.h:67
 AliEMCALRecoUtils.h:68
 AliEMCALRecoUtils.h:69
 AliEMCALRecoUtils.h:70
 AliEMCALRecoUtils.h:71
 AliEMCALRecoUtils.h:72
 AliEMCALRecoUtils.h:73
 AliEMCALRecoUtils.h:74
 AliEMCALRecoUtils.h:75
 AliEMCALRecoUtils.h:76
 AliEMCALRecoUtils.h:77
 AliEMCALRecoUtils.h:78
 AliEMCALRecoUtils.h:79
 AliEMCALRecoUtils.h:80
 AliEMCALRecoUtils.h:81
 AliEMCALRecoUtils.h:82
 AliEMCALRecoUtils.h:83
 AliEMCALRecoUtils.h:84
 AliEMCALRecoUtils.h:85
 AliEMCALRecoUtils.h:86
 AliEMCALRecoUtils.h:87
 AliEMCALRecoUtils.h:88
 AliEMCALRecoUtils.h:89
 AliEMCALRecoUtils.h:90
 AliEMCALRecoUtils.h:91
 AliEMCALRecoUtils.h:92
 AliEMCALRecoUtils.h:93
 AliEMCALRecoUtils.h:94
 AliEMCALRecoUtils.h:95
 AliEMCALRecoUtils.h:96
 AliEMCALRecoUtils.h:97
 AliEMCALRecoUtils.h:98
 AliEMCALRecoUtils.h:99
 AliEMCALRecoUtils.h:100
 AliEMCALRecoUtils.h:101
 AliEMCALRecoUtils.h:102
 AliEMCALRecoUtils.h:103
 AliEMCALRecoUtils.h:104
 AliEMCALRecoUtils.h:105
 AliEMCALRecoUtils.h:106
 AliEMCALRecoUtils.h:107
 AliEMCALRecoUtils.h:108
 AliEMCALRecoUtils.h:109
 AliEMCALRecoUtils.h:110
 AliEMCALRecoUtils.h:111
 AliEMCALRecoUtils.h:112
 AliEMCALRecoUtils.h:113
 AliEMCALRecoUtils.h:114
 AliEMCALRecoUtils.h:115
 AliEMCALRecoUtils.h:116
 AliEMCALRecoUtils.h:117
 AliEMCALRecoUtils.h:118
 AliEMCALRecoUtils.h:119
 AliEMCALRecoUtils.h:120
 AliEMCALRecoUtils.h:121
 AliEMCALRecoUtils.h:122
 AliEMCALRecoUtils.h:123
 AliEMCALRecoUtils.h:124
 AliEMCALRecoUtils.h:125
 AliEMCALRecoUtils.h:126
 AliEMCALRecoUtils.h:127
 AliEMCALRecoUtils.h:128
 AliEMCALRecoUtils.h:129
 AliEMCALRecoUtils.h:130
 AliEMCALRecoUtils.h:131
 AliEMCALRecoUtils.h:132
 AliEMCALRecoUtils.h:133
 AliEMCALRecoUtils.h:134
 AliEMCALRecoUtils.h:135
 AliEMCALRecoUtils.h:136
 AliEMCALRecoUtils.h:137
 AliEMCALRecoUtils.h:138
 AliEMCALRecoUtils.h:139
 AliEMCALRecoUtils.h:140
 AliEMCALRecoUtils.h:141
 AliEMCALRecoUtils.h:142
 AliEMCALRecoUtils.h:143
 AliEMCALRecoUtils.h:144
 AliEMCALRecoUtils.h:145
 AliEMCALRecoUtils.h:146
 AliEMCALRecoUtils.h:147
 AliEMCALRecoUtils.h:148
 AliEMCALRecoUtils.h:149
 AliEMCALRecoUtils.h:150
 AliEMCALRecoUtils.h:151
 AliEMCALRecoUtils.h:152
 AliEMCALRecoUtils.h:153
 AliEMCALRecoUtils.h:154
 AliEMCALRecoUtils.h:155
 AliEMCALRecoUtils.h:156
 AliEMCALRecoUtils.h:157
 AliEMCALRecoUtils.h:158
 AliEMCALRecoUtils.h:159
 AliEMCALRecoUtils.h:160
 AliEMCALRecoUtils.h:161
 AliEMCALRecoUtils.h:162
 AliEMCALRecoUtils.h:163
 AliEMCALRecoUtils.h:164
 AliEMCALRecoUtils.h:165
 AliEMCALRecoUtils.h:166
 AliEMCALRecoUtils.h:167
 AliEMCALRecoUtils.h:168
 AliEMCALRecoUtils.h:169
 AliEMCALRecoUtils.h:170
 AliEMCALRecoUtils.h:171
 AliEMCALRecoUtils.h:172
 AliEMCALRecoUtils.h:173
 AliEMCALRecoUtils.h:174
 AliEMCALRecoUtils.h:175
 AliEMCALRecoUtils.h:176
 AliEMCALRecoUtils.h:177
 AliEMCALRecoUtils.h:178
 AliEMCALRecoUtils.h:179
 AliEMCALRecoUtils.h:180
 AliEMCALRecoUtils.h:181
 AliEMCALRecoUtils.h:182
 AliEMCALRecoUtils.h:183
 AliEMCALRecoUtils.h:184
 AliEMCALRecoUtils.h:185
 AliEMCALRecoUtils.h:186
 AliEMCALRecoUtils.h:187
 AliEMCALRecoUtils.h:188
 AliEMCALRecoUtils.h:189
 AliEMCALRecoUtils.h:190
 AliEMCALRecoUtils.h:191
 AliEMCALRecoUtils.h:192
 AliEMCALRecoUtils.h:193
 AliEMCALRecoUtils.h:194
 AliEMCALRecoUtils.h:195
 AliEMCALRecoUtils.h:196
 AliEMCALRecoUtils.h:197
 AliEMCALRecoUtils.h:198
 AliEMCALRecoUtils.h:199
 AliEMCALRecoUtils.h:200
 AliEMCALRecoUtils.h:201
 AliEMCALRecoUtils.h:202
 AliEMCALRecoUtils.h:203
 AliEMCALRecoUtils.h:204
 AliEMCALRecoUtils.h:205
 AliEMCALRecoUtils.h:206
 AliEMCALRecoUtils.h:207
 AliEMCALRecoUtils.h:208
 AliEMCALRecoUtils.h:209
 AliEMCALRecoUtils.h:210
 AliEMCALRecoUtils.h:211
 AliEMCALRecoUtils.h:212
 AliEMCALRecoUtils.h:213
 AliEMCALRecoUtils.h:214
 AliEMCALRecoUtils.h:215
 AliEMCALRecoUtils.h:216
 AliEMCALRecoUtils.h:217
 AliEMCALRecoUtils.h:218
 AliEMCALRecoUtils.h:219
 AliEMCALRecoUtils.h:220
 AliEMCALRecoUtils.h:221
 AliEMCALRecoUtils.h:222
 AliEMCALRecoUtils.h:223
 AliEMCALRecoUtils.h:224
 AliEMCALRecoUtils.h:225
 AliEMCALRecoUtils.h:226
 AliEMCALRecoUtils.h:227
 AliEMCALRecoUtils.h:228
 AliEMCALRecoUtils.h:229
 AliEMCALRecoUtils.h:230
 AliEMCALRecoUtils.h:231
 AliEMCALRecoUtils.h:232
 AliEMCALRecoUtils.h:233
 AliEMCALRecoUtils.h:234
 AliEMCALRecoUtils.h:235
 AliEMCALRecoUtils.h:236
 AliEMCALRecoUtils.h:237
 AliEMCALRecoUtils.h:238
 AliEMCALRecoUtils.h:239
 AliEMCALRecoUtils.h:240
 AliEMCALRecoUtils.h:241
 AliEMCALRecoUtils.h:242
 AliEMCALRecoUtils.h:243
 AliEMCALRecoUtils.h:244
 AliEMCALRecoUtils.h:245
 AliEMCALRecoUtils.h:246
 AliEMCALRecoUtils.h:247
 AliEMCALRecoUtils.h:248
 AliEMCALRecoUtils.h:249
 AliEMCALRecoUtils.h:250
 AliEMCALRecoUtils.h:251
 AliEMCALRecoUtils.h:252
 AliEMCALRecoUtils.h:253
 AliEMCALRecoUtils.h:254
 AliEMCALRecoUtils.h:255
 AliEMCALRecoUtils.h:256
 AliEMCALRecoUtils.h:257
 AliEMCALRecoUtils.h:258
 AliEMCALRecoUtils.h:259
 AliEMCALRecoUtils.h:260
 AliEMCALRecoUtils.h:261
 AliEMCALRecoUtils.h:262
 AliEMCALRecoUtils.h:263
 AliEMCALRecoUtils.h:264
 AliEMCALRecoUtils.h:265
 AliEMCALRecoUtils.h:266
 AliEMCALRecoUtils.h:267
 AliEMCALRecoUtils.h:268
 AliEMCALRecoUtils.h:269
 AliEMCALRecoUtils.h:270
 AliEMCALRecoUtils.h:271
 AliEMCALRecoUtils.h:272
 AliEMCALRecoUtils.h:273
 AliEMCALRecoUtils.h:274
 AliEMCALRecoUtils.h:275
 AliEMCALRecoUtils.h:276
 AliEMCALRecoUtils.h:277
 AliEMCALRecoUtils.h:278
 AliEMCALRecoUtils.h:279
 AliEMCALRecoUtils.h:280
 AliEMCALRecoUtils.h:281
 AliEMCALRecoUtils.h:282
 AliEMCALRecoUtils.h:283
 AliEMCALRecoUtils.h:284
 AliEMCALRecoUtils.h:285
 AliEMCALRecoUtils.h:286
 AliEMCALRecoUtils.h:287
 AliEMCALRecoUtils.h:288
 AliEMCALRecoUtils.h:289
 AliEMCALRecoUtils.h:290
 AliEMCALRecoUtils.h:291
 AliEMCALRecoUtils.h:292
 AliEMCALRecoUtils.h:293
 AliEMCALRecoUtils.h:294
 AliEMCALRecoUtils.h:295
 AliEMCALRecoUtils.h:296
 AliEMCALRecoUtils.h:297
 AliEMCALRecoUtils.h:298
 AliEMCALRecoUtils.h:299
 AliEMCALRecoUtils.h:300
 AliEMCALRecoUtils.h:301
 AliEMCALRecoUtils.h:302
 AliEMCALRecoUtils.h:303
 AliEMCALRecoUtils.h:304
 AliEMCALRecoUtils.h:305
 AliEMCALRecoUtils.h:306
 AliEMCALRecoUtils.h:307
 AliEMCALRecoUtils.h:308
 AliEMCALRecoUtils.h:309
 AliEMCALRecoUtils.h:310
 AliEMCALRecoUtils.h:311
 AliEMCALRecoUtils.h:312
 AliEMCALRecoUtils.h:313
 AliEMCALRecoUtils.h:314
 AliEMCALRecoUtils.h:315
 AliEMCALRecoUtils.h:316
 AliEMCALRecoUtils.h:317
 AliEMCALRecoUtils.h:318
 AliEMCALRecoUtils.h:319
 AliEMCALRecoUtils.h:320
 AliEMCALRecoUtils.h:321
 AliEMCALRecoUtils.h:322
 AliEMCALRecoUtils.h:323
 AliEMCALRecoUtils.h:324
 AliEMCALRecoUtils.h:325
 AliEMCALRecoUtils.h:326
 AliEMCALRecoUtils.h:327
 AliEMCALRecoUtils.h:328
 AliEMCALRecoUtils.h:329
 AliEMCALRecoUtils.h:330
 AliEMCALRecoUtils.h:331
 AliEMCALRecoUtils.h:332
 AliEMCALRecoUtils.h:333
 AliEMCALRecoUtils.h:334
 AliEMCALRecoUtils.h:335
 AliEMCALRecoUtils.h:336
 AliEMCALRecoUtils.h:337
 AliEMCALRecoUtils.h:338
 AliEMCALRecoUtils.h:339
 AliEMCALRecoUtils.h:340
 AliEMCALRecoUtils.h:341
 AliEMCALRecoUtils.h:342
 AliEMCALRecoUtils.h:343
 AliEMCALRecoUtils.h:344
 AliEMCALRecoUtils.h:345
 AliEMCALRecoUtils.h:346
 AliEMCALRecoUtils.h:347
 AliEMCALRecoUtils.h:348
 AliEMCALRecoUtils.h:349
 AliEMCALRecoUtils.h:350
 AliEMCALRecoUtils.h:351
 AliEMCALRecoUtils.h:352
 AliEMCALRecoUtils.h:353
 AliEMCALRecoUtils.h:354
 AliEMCALRecoUtils.h:355
 AliEMCALRecoUtils.h:356
 AliEMCALRecoUtils.h:357
 AliEMCALRecoUtils.h:358
 AliEMCALRecoUtils.h:359
 AliEMCALRecoUtils.h:360
 AliEMCALRecoUtils.h:361
 AliEMCALRecoUtils.h:362
 AliEMCALRecoUtils.h:363
 AliEMCALRecoUtils.h:364
 AliEMCALRecoUtils.h:365
 AliEMCALRecoUtils.h:366
 AliEMCALRecoUtils.h:367
 AliEMCALRecoUtils.h:368
 AliEMCALRecoUtils.h:369
 AliEMCALRecoUtils.h:370
 AliEMCALRecoUtils.h:371
 AliEMCALRecoUtils.h:372
 AliEMCALRecoUtils.h:373
 AliEMCALRecoUtils.h:374
 AliEMCALRecoUtils.h:375
 AliEMCALRecoUtils.h:376
 AliEMCALRecoUtils.h:377
 AliEMCALRecoUtils.h:378
 AliEMCALRecoUtils.h:379
 AliEMCALRecoUtils.h:380
 AliEMCALRecoUtils.h:381
 AliEMCALRecoUtils.h:382
 AliEMCALRecoUtils.h:383
 AliEMCALRecoUtils.h:384
 AliEMCALRecoUtils.h:385
 AliEMCALRecoUtils.h:386
 AliEMCALRecoUtils.h:387
 AliEMCALRecoUtils.h:388
 AliEMCALRecoUtils.h:389
 AliEMCALRecoUtils.h:390
 AliEMCALRecoUtils.h:391
 AliEMCALRecoUtils.h:392
 AliEMCALRecoUtils.h:393
 AliEMCALRecoUtils.h:394
 AliEMCALRecoUtils.h:395
 AliEMCALRecoUtils.h:396
 AliEMCALRecoUtils.h:397
 AliEMCALRecoUtils.h:398
 AliEMCALRecoUtils.h:399
 AliEMCALRecoUtils.h:400
 AliEMCALRecoUtils.h:401
 AliEMCALRecoUtils.h:402
 AliEMCALRecoUtils.h:403
 AliEMCALRecoUtils.h:404
 AliEMCALRecoUtils.h:405
 AliEMCALRecoUtils.h:406
 AliEMCALRecoUtils.h:407
 AliEMCALRecoUtils.h:408
 AliEMCALRecoUtils.h:409
 AliEMCALRecoUtils.h:410
 AliEMCALRecoUtils.h:411
 AliEMCALRecoUtils.h:412
 AliEMCALRecoUtils.h:413
 AliEMCALRecoUtils.h:414
 AliEMCALRecoUtils.h:415
 AliEMCALRecoUtils.h:416
 AliEMCALRecoUtils.h:417
 AliEMCALRecoUtils.h:418
 AliEMCALRecoUtils.h:419
 AliEMCALRecoUtils.h:420
 AliEMCALRecoUtils.h:421
 AliEMCALRecoUtils.h:422
 AliEMCALRecoUtils.h:423
 AliEMCALRecoUtils.h:424
 AliEMCALRecoUtils.h:425
 AliEMCALRecoUtils.h:426
 AliEMCALRecoUtils.h:427
 AliEMCALRecoUtils.h:428
 AliEMCALRecoUtils.h:429
 AliEMCALRecoUtils.h:430
 AliEMCALRecoUtils.h:431
 AliEMCALRecoUtils.h:432
 AliEMCALRecoUtils.h:433
 AliEMCALRecoUtils.h:434
 AliEMCALRecoUtils.h:435
 AliEMCALRecoUtils.h:436
 AliEMCALRecoUtils.h:437
 AliEMCALRecoUtils.h:438
 AliEMCALRecoUtils.h:439