Restore independence of libEMCALRecoUtils on libSTEER
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALRecoUtils.h
1 #ifndef ALIEMCALRECOUTILS_H
2 #define ALIEMCALRECOUTILS_H
3
4 /* $Id: AliEMCALRecoUtils.h 33808 2009-07-15 09:48:08Z gconesab $ */
5
6 ///////////////////////////////////////////////////////////////////////////////
7 //
8 // Class AliEMCALRecoUtils
9 // Some utilities to recalculate the cluster position or energy linearity
10 //
11 //
12 // Author:  Gustavo Conesa (LPSC- Grenoble) 
13 //          Track matching part: Rongrong Ma (Yale)
14 ///////////////////////////////////////////////////////////////////////////////
15
16 //Root includes
17 #include <TNamed.h>
18 #include <TMath.h>
19 class TObjArray;
20 class TArrayI;
21 class TArrayF;
22 #include <TH2I.h>
23 class TH2F;
24 #include <TRandom3.h>
25
26 //AliRoot includes
27 class AliVCluster;
28 class AliVCaloCells;
29 class AliVEvent;
30
31 // EMCAL includes
32 class AliEMCALGeometry;
33 class AliEMCALPIDUtils;
34 class AliESDtrack;
35 class AliExternalTrackParam;
36
37 class AliEMCALRecoUtils : public TNamed {
38   
39 public:
40   
41   AliEMCALRecoUtils();
42   AliEMCALRecoUtils(const AliEMCALRecoUtils&); 
43   AliEMCALRecoUtils& operator=(const AliEMCALRecoUtils&); 
44   virtual ~AliEMCALRecoUtils() ;  
45   void     Print(const Option_t*) const;
46
47   //enums
48   enum     NonlinearityFunctions{kPi0MC=0,kPi0GammaGamma=1,kPi0GammaConversion=2,kNoCorrection=3,kBeamTest=4,kBeamTestCorrected=5};
49   enum     PositionAlgorithms{kUnchanged=-1,kPosTowerIndex=0, kPosTowerGlobal=1};
50   enum     ParticleType{kPhoton=0, kElectron=1,kHadron =2, kUnknown=-1};
51   enum     { kNCuts = 11 }; //track matching
52   enum     TrackCutsType{kTPCOnlyCut=0, kGlobalCut=1, kLooseCut=2};
53
54   //-----------------------------------------------------
55   //Position recalculation
56   //-----------------------------------------------------
57
58   void     RecalculateClusterPosition               (AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu); 
59   void     RecalculateClusterPositionFromTowerIndex (AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu); 
60   void     RecalculateClusterPositionFromTowerGlobal(AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu); 
61   
62   Float_t  GetCellWeight(const Float_t eCell, const Float_t eCluster) const { return TMath::Max( 0., fW0 + TMath::Log( eCell / eCluster )) ; }
63   
64   Float_t  GetDepth(const Float_t eCluster, const Int_t iParticle, const Int_t iSM) const ; 
65   
66   void     GetMaxEnergyCell(AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu, 
67                             Int_t & absId,  Int_t& iSupMod, Int_t& ieta, Int_t& iphi, Bool_t &shared);
68   
69   Float_t  GetMisalTransShift(const Int_t i)       const { if(i < 15 ) { return fMisalTransShift[i] ; }
70                                                            else        { AliInfo(Form("Index %d larger than 15, do nothing\n",i)) ; 
71                                                                          return 0.                  ; } }
72   Float_t* GetMisalTransShiftArray()                     { return fMisalTransShift ; }
73
74   void     SetMisalTransShift(const Int_t i, const Float_t shift) {
75                                                            if(i < 15 ) { fMisalTransShift[i] = shift ; }
76                                                            else        { AliInfo(Form("Index %d larger than 15, do nothing\n",i)) ; } }
77   void     SetMisalTransShiftArray(Float_t * misal)               { for(Int_t i = 0; i < 15; i++) fMisalTransShift[i] = misal[i]  ; }
78
79   Float_t  GetMisalRotShift(const Int_t i)         const { if(i < 15 ) { return fMisalRotShift[i]    ; }
80                                                            else        { AliInfo(Form("Index %d larger than 15, do nothing\n",i)) ; 
81                                                                          return 0.                   ; } }
82   
83   Float_t* GetMisalRotShiftArray()                       { return fMisalRotShift                     ; }
84   
85   void     SetMisalRotShift(const Int_t i, const Float_t shift) {
86                                                            if(i < 15 ) { fMisalRotShift[i] = shift   ; }
87                                                            else        { AliInfo(Form("Index %d larger than 15, do nothing\n",i)) ; } }
88   
89   void     SetMisalRotShiftArray(Float_t * misal)        { for(Int_t i = 0; i < 15; i++)fMisalRotShift[i] = misal[i] ; }
90   
91   Int_t    GetParticleType()                       const { return  fParticleType    ; }
92   void     SetParticleType(Int_t particle)               { fParticleType = particle ; }
93   
94   Int_t    GetPositionAlgorithm()                  const { return fPosAlgo          ; }
95   void     SetPositionAlgorithm(Int_t alg)               { fPosAlgo = alg           ; }
96   
97   Float_t  GetW0()                                 const { return fW0               ; }
98   void     SetW0(Float_t w0)                             { fW0  = w0                ; }
99
100   //-----------------------------------------------------
101   //Non Linearity
102   //-----------------------------------------------------
103
104   Float_t  CorrectClusterEnergyLinearity(AliVCluster* clu) ;
105   
106   Float_t  GetNonLinearityParam(const Int_t i)     const { if(i < 7 ){ return fNonLinearityParams[i] ; }
107                                                           else      { AliInfo(Form("Index %d larger than 7, do nothing\n",i)) ; 
108                                                                        return 0.                     ; } }
109   void     SetNonLinearityParam(const Int_t i, const Float_t param) {
110                                                           if(i < 7 ){fNonLinearityParams[i] = param ; }
111                                                           else { AliInfo(Form("Index %d larger than 7, do nothing\n",i)) ; } }
112   void     InitNonLinearityParam();
113
114   Int_t    GetNonLinearityFunction() const               { return fNonLinearityFunction    ; }
115   void     SetNonLinearityFunction(Int_t fun)            { fNonLinearityFunction = fun     ; InitNonLinearityParam() ; }
116
117   void     SetNonLinearityThreshold(Int_t threshold)     { fNonLinearThreshold = threshold ; } //only for Alexie's non linearity correction
118   Int_t    GetNonLinearityThreshold()              const { return fNonLinearThreshold      ; }
119 //  
120   //-----------------------------------------------------
121   // MC clusters energy smearing
122   //-----------------------------------------------------
123   
124   Float_t  SmearClusterEnergy(AliVCluster* clu) ;
125   void     SwitchOnClusterEnergySmearing()               { fSmearClusterEnergy = kTRUE         ; }
126   void     SwitchOffClusterEnergySmearing()              { fSmearClusterEnergy = kFALSE        ; }
127   Bool_t   IsClusterEnergySmeared()                const { return fSmearClusterEnergy          ; }   
128   void     SetSmearingParameters(Int_t i, Float_t param) { if(i < 3){ fSmearClusterParam[i] = param ; }
129                                                            else     { AliInfo(Form("Index %d larger than 2, do nothing\n",i)) ; } }
130   
131   //-----------------------------------------------------
132   // Energy Recalibration
133   //-----------------------------------------------------
134   
135   void     RecalibrateCells(AliEMCALGeometry* geom, AliVCaloCells * cells, Int_t bc) ; // Energy and Time
136   void     RecalibrateClusterEnergy(AliEMCALGeometry* geom, AliVCluster* cluster, AliVCaloCells * cells, const Int_t bc=0) ; // Energy and time
137
138   Bool_t   IsRecalibrationOn()                     const { return fRecalibration ; }
139   void     SwitchOffRecalibration()                      { fRecalibration = kFALSE ; }
140   void     SwitchOnRecalibration()                       { fRecalibration = kTRUE  ; 
141                                                            if(!fEMCALRecalibrationFactors)InitEMCALRecalibrationFactors() ; }
142   void     InitEMCALRecalibrationFactors() ;
143
144   TH2F *   GetEMCALChannelRecalibrationFactors(Int_t iSM)     const { return (TH2F*)fEMCALRecalibrationFactors->At(iSM) ; }     
145   void     SetEMCALChannelRecalibrationFactors(TObjArray *map)      { fEMCALRecalibrationFactors = map                  ; }
146   void     SetEMCALChannelRecalibrationFactors(Int_t iSM , TH2F* h) { fEMCALRecalibrationFactors->AddAt(h,iSM)          ; }
147   
148   Float_t  GetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow) const { 
149     if(fEMCALRecalibrationFactors) 
150       return (Float_t) ((TH2F*)fEMCALRecalibrationFactors->At(iSM))->GetBinContent(iCol,iRow); 
151     else return 1 ; } 
152         
153   void     SetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) { 
154     if(!fEMCALRecalibrationFactors) InitEMCALRecalibrationFactors() ;
155     ((TH2F*)fEMCALRecalibrationFactors->At(iSM))->SetBinContent(iCol,iRow,c) ; }
156   
157   //Recalibrate channels energy with run dependent corrections
158   void     SwitchOffRunDepCorrection()                   { fUseRunCorrectionFactors = kFALSE ; }
159   void     SwitchOnRunDepCorrection()                    { fUseRunCorrectionFactors = kTRUE  ; 
160                                                            SwitchOnRecalibration()           ; }
161   void     SetRunDependentCorrections(Int_t runnumber);
162       
163   //-----------------------------------------------------
164   // Time Recalibration
165   //-----------------------------------------------------
166   
167   void     RecalibrateCellTime(const Int_t absId, const Int_t bc, Double_t & time);
168   
169   Bool_t   IsTimeRecalibrationOn()                 const { return fTimeRecalibration   ; }
170   void     SwitchOffTimeRecalibration()                  { fTimeRecalibration = kFALSE ; }
171   void     SwitchOnTimeRecalibration()                   { fTimeRecalibration = kTRUE  ; 
172     if(!fEMCALTimeRecalibrationFactors)InitEMCALTimeRecalibrationFactors() ; }
173   void     InitEMCALTimeRecalibrationFactors() ;
174   
175   Float_t  GetEMCALChannelTimeRecalibrationFactor(Int_t bc, Int_t absID) const { 
176     if(fEMCALTimeRecalibrationFactors) 
177       return (Float_t) ((TH1F*)fEMCALTimeRecalibrationFactors->At(bc))->GetBinContent(absID); 
178     else return 1 ; } 
179         
180   void     SetEMCALChannelTimeRecalibrationFactor(Int_t bc,Int_t absID, Double_t c = 1) { 
181     if(!fEMCALTimeRecalibrationFactors) InitEMCALTimeRecalibrationFactors() ;
182     ((TH1F*)fEMCALTimeRecalibrationFactors->At(bc))->SetBinContent(absID,c) ; }  
183   
184   TH1F *   GetEMCALChannelTimeRecalibrationFactors(Int_t bc)      const { return (TH1F*)fEMCALTimeRecalibrationFactors->At(bc) ; }      
185   void     SetEMCALChannelTimeRecalibrationFactors(TObjArray *map)      { fEMCALTimeRecalibrationFactors = map                 ; }
186   void     SetEMCALChannelTimeRecalibrationFactors(Int_t bc , TH1F* h)  { fEMCALTimeRecalibrationFactors->AddAt(h,bc)          ; }
187   
188   //-----------------------------------------------------
189   // Modules fiducial region, remove clusters in borders
190   //-----------------------------------------------------
191
192   Bool_t   CheckCellFiducialRegion(AliEMCALGeometry* geom, AliVCluster* cluster, AliVCaloCells* cells) ;
193   void     SetNumberOfCellsFromEMCALBorder(Int_t n)      { fNCellsFromEMCALBorder = n      ; }
194   Int_t    GetNumberOfCellsFromEMCALBorder()      const  { return fNCellsFromEMCALBorder   ; }
195     
196   void     SwitchOnNoFiducialBorderInEMCALEta0()         { fNoEMCALBorderAtEta0 = kTRUE    ; }
197   void     SwitchOffNoFiducialBorderInEMCALEta0()        { fNoEMCALBorderAtEta0 = kFALSE   ; }
198   Bool_t   IsEMCALNoBorderAtEta0()                 const { return fNoEMCALBorderAtEta0     ; }
199   
200   //-----------------------------------------------------
201   // Bad channels
202   //-----------------------------------------------------
203
204   Bool_t   IsBadChannelsRemovalSwitchedOn()        const { return fRemoveBadChannels       ; }
205   void     SwitchOffBadChannelsRemoval()                 { fRemoveBadChannels = kFALSE     ; }
206   void     SwitchOnBadChannelsRemoval ()                 { fRemoveBadChannels = kTRUE ; 
207                                                            if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap() ; }
208         
209   Bool_t   IsDistanceToBadChannelRecalculated()    const { return fRecalDistToBadChannels   ; }
210   void     SwitchOffDistToBadChannelRecalculation()      { fRecalDistToBadChannels = kFALSE ; }
211   void     SwitchOnDistToBadChannelRecalculation()       { fRecalDistToBadChannels = kTRUE  ; 
212                                                            if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap() ; }
213   
214   void     InitEMCALBadChannelStatusMap() ;
215         
216   Int_t    GetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow) const { 
217     if(fEMCALBadChannelMap) return (Int_t) ((TH2I*)fEMCALBadChannelMap->At(iSM))->GetBinContent(iCol,iRow); 
218     else return 0;}//Channel is ok by default
219         
220   void     SetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) { 
221                                                            if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap()               ;
222                                                            ((TH2I*)fEMCALBadChannelMap->At(iSM))->SetBinContent(iCol,iRow,c)    ; }
223         
224   TH2I *   GetEMCALChannelStatusMap(Int_t iSM)     const { return (TH2I*)fEMCALBadChannelMap->At(iSM) ; }
225   void     SetEMCALChannelStatusMap(TObjArray *map)      { fEMCALBadChannelMap = map                  ; }
226   void     SetEMCALChannelStatusMap(Int_t iSM , TH2I* h) { fEMCALBadChannelMap->AddAt(h,iSM)          ; }
227
228   Bool_t   ClusterContainsBadChannel(AliEMCALGeometry* geom, UShort_t* cellList, const Int_t nCells);
229  
230   //-----------------------------------------------------
231   // Recalculate other cluster parameters
232   //-----------------------------------------------------
233
234   void     RecalculateClusterDistanceToBadChannel (AliEMCALGeometry * geom, AliVCaloCells* cells, AliVCluster * cluster);
235   void     RecalculateClusterShowerShapeParameters(AliEMCALGeometry * geom, AliVCaloCells* cells, AliVCluster * cluster);
236   void     RecalculateClusterPID(AliVCluster * cluster);
237
238   AliEMCALPIDUtils * GetPIDUtils() { return fPIDUtils;}
239
240
241   //----------------------------------------------------
242   // Track matching
243   //----------------------------------------------------
244
245   void     FindMatches(AliVEvent *event, TObjArray * clusterArr=0x0, AliEMCALGeometry *geom=0x0);
246   Int_t    FindMatchedClusterInEvent(AliESDtrack *track, AliVEvent *event, AliEMCALGeometry *geom, Float_t &dEta, Float_t &dPhi);
247   Int_t    FindMatchedClusterInClusterArr(AliExternalTrackParam *emcalParam, AliExternalTrackParam *trkParam, TObjArray * clusterArr, Float_t &dEta, Float_t &dPhi);
248   
249   static Bool_t ExtrapolateTrackToEMCalSurface(AliExternalTrackParam *trkParam, Double_t emcalR, Double_t mass, Double_t step, Float_t &eta, Float_t &phi);
250   static Bool_t ExtrapolateTrackToPosition(AliExternalTrackParam *trkParam, Float_t *clsPos, Double_t mass, Double_t step, Float_t &tmpEta, Float_t &tmpPhi);
251   static Bool_t ExtrapolateTrackToCluster(AliExternalTrackParam *trkParam, AliVCluster *cluster, Double_t mass, Double_t step, Float_t &tmpEta, Float_t &tmpPhi);
252   Bool_t ExtrapolateTrackToCluster(AliExternalTrackParam *trkParam, AliVCluster *cluster, Float_t &tmpEta, Float_t &tmpPhi);
253
254   UInt_t   FindMatchedPosForCluster(Int_t clsIndex) const;
255   UInt_t   FindMatchedPosForTrack(Int_t trkIndex)   const;
256   
257   void     GetMatchedResiduals(Int_t clsIndex, Float_t &dEta, Float_t &dPhi);
258   void     GetMatchedClusterResiduals(Int_t trkIndex, Float_t &dEta, Float_t &dPhi);
259   Int_t    GetMatchedTrackIndex(Int_t clsIndex);
260   Int_t    GetMatchedClusterIndex(Int_t trkIndex);
261   
262   Bool_t   IsClusterMatched(Int_t clsIndex)         const;
263   Bool_t   IsTrackMatched(Int_t trkIndex)           const;
264
265
266   void     SwitchOnCutEtaPhiSum()                     { fCutEtaPhiSum      = kTRUE    ; 
267                                                         fCutEtaPhiSeparate = kFALSE   ; }
268   void     SwitchOnCutEtaPhiSeparate()                { fCutEtaPhiSeparate = kTRUE    ;
269                                                         fCutEtaPhiSum      = kFALSE   ; }
270
271   Float_t  GetCutR()                            const { return fCutR                  ; }
272   Float_t  GetCutEta()                          const { return fCutEta                ; }
273   Float_t  GetCutPhi()                          const { return fCutPhi                ; }
274   Double_t GetClusterWindow()                   const { return fClusterWindow         ; }
275   void     SetCutR(Float_t cutR)                      { fCutR   = cutR                ; }
276   void     SetCutEta(Float_t cutEta)                  { fCutEta = cutEta              ; }
277   void     SetCutPhi(Float_t cutPhi)                  { fCutPhi = cutPhi              ; }
278   void     SetClusterWindow(Double_t window)          { fClusterWindow = window       ; }
279   void     SetCutZ(Float_t cutZ)                      { printf("Obsolete fucntion of cutZ=%1.1f\n",cutZ) ; } //Obsolete
280
281   Double_t GetMass()                            const { return fMass                  ; }
282   Double_t GetStep()                            const { return fStepCluster           ; }
283   Double_t GetStepSurface()                     const { return fStepSurface           ; }
284   void     SetMass(Double_t mass)                     { fMass = mass                  ; }
285   void     SetStep(Double_t step)                     { fStepCluster = step           ; }
286   void     SetStepSurface(Double_t step)              { fStepSurface = step           ; }
287  
288   //Cluster cut
289   Bool_t   IsGoodCluster(AliVCluster *cluster, AliEMCALGeometry *geom, AliVCaloCells* cells);
290   Bool_t   IsExoticCluster(AliVCluster *cluster) const ;
291
292   void     SwitchOnRejectExoticCluster()              { fRejectExoticCluster=kTRUE     ; }
293   void     SwitchOffRejectExoticCluster()             { fRejectExoticCluster=kFALSE    ; }
294   Bool_t   IsRejectExoticCluster()              const { return fRejectExoticCluster    ; }
295
296
297   //Track Cuts 
298   Bool_t   IsAccepted(AliESDtrack *track);
299   void     InitTrackCuts();
300   void     SetTrackCutsType(Int_t type)              { fTrackCutsType = type           ; 
301                                                        InitTrackCuts()                 ; }
302   Int_t    GetTrackCutsType() const                  { return fTrackCutsType; }
303
304   // track quality cut setters  
305   void     SetMinTrackPt(Double_t pt=0)              { fCutMinTrackPt           = pt   ; }
306   void     SetMinNClustersTPC(Int_t min=-1)          { fCutMinNClusterTPC       = min  ; }
307   void     SetMinNClustersITS(Int_t min=-1)          { fCutMinNClusterITS       = min  ; }
308   void     SetMaxChi2PerClusterTPC(Float_t max=1e10) { fCutMaxChi2PerClusterTPC = max  ; }
309   void     SetMaxChi2PerClusterITS(Float_t max=1e10) { fCutMaxChi2PerClusterITS = max  ; }
310   void     SetRequireTPCRefit(Bool_t b=kFALSE)       { fCutRequireTPCRefit      = b    ; }
311   void     SetRequireITSRefit(Bool_t b=kFALSE)       { fCutRequireITSRefit      = b    ; }
312   void     SetAcceptKinkDaughters(Bool_t b=kTRUE)    { fCutAcceptKinkDaughters  = b    ; }
313   void     SetMaxDCAToVertexXY(Float_t dist=1e10)    { fCutMaxDCAToVertexXY     = dist ; }
314   void     SetMaxDCAToVertexZ(Float_t dist=1e10)     { fCutMaxDCAToVertexZ      = dist ; }
315   void     SetDCAToVertex2D(Bool_t b=kFALSE)         { fCutDCAToVertex2D        = b    ; }
316
317   // getters                                                            
318   Double_t GetMinTrackPt()                     const { return fCutMinTrackPt           ; }
319   Int_t    GetMinNClusterTPC()                 const { return fCutMinNClusterTPC       ; }
320   Int_t    GetMinNClustersITS()                const { return fCutMinNClusterITS       ; }
321   Float_t  GetMaxChi2PerClusterTPC()           const { return fCutMaxChi2PerClusterTPC ; }
322   Float_t  GetMaxChi2PerClusterITS()           const { return fCutMaxChi2PerClusterITS ; }
323   Bool_t   GetRequireTPCRefit()                const { return fCutRequireTPCRefit      ; }
324   Bool_t   GetRequireITSRefit()                const { return fCutRequireITSRefit      ; }
325   Bool_t   GetAcceptKinkDaughters()            const { return fCutAcceptKinkDaughters  ; }
326   Float_t  GetMaxDCAToVertexXY()               const { return fCutMaxDCAToVertexXY     ; }
327   Float_t  GetMaxDCAToVertexZ()                const { return fCutMaxDCAToVertexZ      ; }
328   Bool_t   GetDCAToVertex2D()                  const { return fCutDCAToVertex2D        ; }
329
330
331 private:  
332   //Position recalculation
333   Float_t    fMisalTransShift[15];       // Shift parameters
334   Float_t    fMisalRotShift[15];         // Shift parameters
335   Int_t      fParticleType;              // Particle type for depth calculation
336   Int_t      fPosAlgo;                   // Position recalculation algorithm
337   Float_t    fW0;                        // Weight0
338     
339   // Non linearity
340   Int_t      fNonLinearityFunction;      // Non linearity function choice
341   Float_t    fNonLinearityParams[7];     // Parameters for the non linearity function
342   Int_t      fNonLinearThreshold;        // Non linearity threshold value for kBeamTesh non linearity function 
343   
344   // Energy smearing for MC
345   Bool_t     fSmearClusterEnergy;        // Smear cluster energy, to be done only for simulated data to match real data
346   Float_t    fSmearClusterParam[3];      // Smearing parameters
347   TRandom3   fRandom;                    // Random generator
348     
349   // Energy Recalibration 
350   Bool_t     fCellsRecalibrated;         // Internal bool to check if cells (time/energy) where recalibrated and not recalibrate them when recalculating different things
351   Bool_t     fRecalibration;             // Switch on or off the recalibration
352   TObjArray* fEMCALRecalibrationFactors; // Array of histograms with map of recalibration factors, EMCAL
353     
354   // Time Recalibration 
355   Bool_t     fTimeRecalibration;             // Switch on or off the time recalibration
356   TObjArray* fEMCALTimeRecalibrationFactors; // Array of histograms with map of time recalibration factors, EMCAL
357   
358   // Recalibrate with run dependent corrections, energy
359   Bool_t     fUseRunCorrectionFactors;   // Use Run Dependent Correction
360   Bool_t     fRunCorrectionFactorsSet;   // Run Correction set at leat once
361     
362   // Bad Channels
363   Bool_t     fRemoveBadChannels;         // Check the channel status provided and remove clusters with bad channels
364   Bool_t     fRecalDistToBadChannels;    // Calculate distance from highest energy tower of cluster to closes bad channel
365   TObjArray* fEMCALBadChannelMap;        // Array of histograms with map of bad channels, EMCAL
366
367   // Border cells
368   Int_t      fNCellsFromEMCALBorder;     // Number of cells from EMCAL border the cell with maximum amplitude has to be.
369   Bool_t     fNoEMCALBorderAtEta0;       // Do fiducial cut in EMCAL region eta = 0?
370   
371   // Cluster cuts
372   Bool_t     fRejectExoticCluster;       // Switch on or off exotic cluster rejection
373   
374   // PID
375   AliEMCALPIDUtils * fPIDUtils;          // Recalculate PID parameters
376     
377   //Track matching
378   UInt_t     fAODFilterMask;             // Filter mask to select AOD tracks. Refer to $ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C
379   TArrayI  * fMatchedTrackIndex;         // Array that stores indexes of matched tracks      
380   TArrayI  * fMatchedClusterIndex;       // Array that stores indexes of matched clusters
381   TArrayF  * fResidualEta;               // Array that stores the residual eta
382   TArrayF  * fResidualPhi;               // Array that stores the residual phi
383   Bool_t     fCutEtaPhiSum;              // Place cut on sqrt(dEta^2+dPhi^2)
384   Bool_t     fCutEtaPhiSeparate;         // Cut on dEta and dPhi separately
385   Float_t    fCutR;                      // sqrt(dEta^2+dPhi^2) cut on matching
386   Float_t    fCutEta;                    // dEta cut on matching
387   Float_t    fCutPhi;                    // dPhi cut on matching
388   Double_t   fClusterWindow;             // Select clusters in the window to be matched
389   Double_t   fMass;                      // Mass hypothesis of the track
390   Double_t   fStepSurface;               // Length of step to extrapolate tracks to EMCal surface
391   Double_t   fStepCluster;               // Length of step to extrapolate tracks to clusters
392
393   // Track cuts  
394   Int_t      fTrackCutsType;             // Esd track cuts type for matching
395   Double_t   fCutMinTrackPt;             // Cut on track pT
396   Int_t      fCutMinNClusterTPC;         // Min number of tpc clusters
397   Int_t      fCutMinNClusterITS;         // Min number of its clusters  
398   Float_t    fCutMaxChi2PerClusterTPC;   // Max tpc fit chi2 per tpc cluster
399   Float_t    fCutMaxChi2PerClusterITS;   // Max its fit chi2 per its cluster
400   Bool_t     fCutRequireTPCRefit;        // Require TPC refit
401   Bool_t     fCutRequireITSRefit;        // Require ITS refit
402   Bool_t     fCutAcceptKinkDaughters;    // Accepting kink daughters?
403   Float_t    fCutMaxDCAToVertexXY;       // Track-to-vertex cut in max absolute distance in xy-plane
404   Float_t    fCutMaxDCAToVertexZ;        // Track-to-vertex cut in max absolute distance in z-plane
405   Bool_t     fCutDCAToVertex2D;          // If true a 2D DCA cut is made.
406   
407   ClassDef(AliEMCALRecoUtils, 16)
408   
409 };
410
411 #endif // ALIEMCALRECOUTILS_H
412
413