PWG/CaloTrackCorrBase/AliCalorimeterUtils.h

   1 #ifndef ALICALORIMETERUTILS_H
   2 #define ALICALORIMETERUTILS_H
   3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice     */
   5
   6 //_________________________________________________________________________
   7 // Class utility for Calorimeter specific selection methods                ///
   8 //
   9 //
  10 //
  11 //-- Author: Gustavo Conesa (LPSC-Grenoble)
  12 //////////////////////////////////////////////////////////////////////////////
  13
  14 // --- ROOT system ---
  15 #include <TObject.h>
  16 #include <TString.h>
  17 #include <TObjArray.h>
  18 class TArrayF;
  19 #include <TH2I.h>
  20 #include <TGeoMatrix.h>
  21
  22 //--- ANALYSIS system ---
  23 class AliVEvent;
  24 class AliVTrack;
  25 class AliAODPWG4Particle;
  26 class AliAODCaloCluster;
  27 class AliVCaloCells;
  28 class AliPHOSGeoUtils;
  29 class AliEMCALGeometry;
  30 class AliAODMCParticle;
  31 class TParticle;
  32
  33 #include "AliEMCALRecoUtils.h"
  34
  35 class AliCalorimeterUtils : public TObject {
  36
  37  public:
  38   AliCalorimeterUtils() ; // ctor
  39   virtual ~AliCalorimeterUtils() ;//virtual dtor
  40
  41   virtual void  InitParameters();
  42   virtual void  Print(const Option_t * opt)          const ;
  43
  44   virtual Int_t GetDebug()                           const { return fDebug                ; }
  45   virtual void  SetDebug(Int_t d)                          { fDebug = d                   ; }
  46
  47   //virtual void Init();
  48
  49   // Cluster contents
  50
  51   Bool_t        AreNeighbours(TString calo, Int_t absId1, Int_t absId2) const ;
  52
  53   Bool_t        IsClusterSharedByTwoSuperModules(const AliEMCALGeometry * geom,
  54                                                  AliVCluster* cluster);
  55
  56   Int_t         GetNumberOfLocalMaxima(AliVCluster* cluster, AliVCaloCells* cells)  ;
  57
  58   Int_t         GetNumberOfLocalMaxima(AliVCluster* cluster, AliVCaloCells* cells,
  59                                        Int_t *absIdList,     Float_t *maxEList)  ;
  60
  61   Float_t       GetLocalMaximaCutE()                 const { return fLocMaxCutE           ; }
  62   void          SetLocalMaximaCutE(Float_t cut)            { fLocMaxCutE     = cut        ; }
  63
  64   Float_t       GetLocalMaximaCutEDiff()             const { return fLocMaxCutEDiff       ; }
  65   void          SetLocalMaximaCutEDiff(Float_t c)          { fLocMaxCutEDiff = c          ; }
  66
  67   Int_t         GetMaxEnergyCell(AliVCaloCells* cells, const AliVCluster* clu, Float_t & fraction) const ;
  68
  69   void          SplitEnergy(Int_t absId1, Int_t absId2, AliVCluster *cluster, AliVCaloCells* cells,
  70                             //Float_t & e1, Float_t & e2,
  71                             AliAODCaloCluster *cluster1, AliAODCaloCluster *cluster2,
  72                             Int_t nMax, Int_t eventNumber = 0);//, Int_t *absIdList, Float_t *maxEList,
  73
  74   void          SwitchOnClusterPlot()                      { fPlotCluster = kTRUE         ; }
  75   void          SwitchOffClusterPlot()                     { fPlotCluster = kFALSE        ; }
  76
  77   Float_t       GetMCECellClusFracCorrection(Float_t eCell, Float_t eCluster) const ;
  78   void          SetMCECellClusFracCorrectionParamters(Int_t i, Float_t param) { if(i<4) fMCECellClusFracCorrParam[i] = param; }
  79
  80   Bool_t        IsMCECellClusFracCorrectionOn()   const    { return fMCECellClusFracCorrOn   ; }
  81   void          SwitchOnMCECellClusFracCorrection()        { fMCECellClusFracCorrOn = kTRUE  ; }
  82   void          SwitchOffMCECellClusFracCorrection()       { fMCECellClusFracCorrOn = kFALSE ; }
  83
  84
  85   //Calorimeters Geometry Methods
  86   AliEMCALGeometry * GetEMCALGeometry()              const { return fEMCALGeo             ; }
  87   TString       EMCALGeometryName()                  const { return fEMCALGeoName         ; }
  88   void          SetEMCALGeometryName(TString name)         { fEMCALGeoName = name         ; }
  89   void          InitEMCALGeometry(Int_t runnumber = 180000) ;
  90   Bool_t        IsEMCALGeoMatrixSet()                const { return fEMCALGeoMatrixSet    ; }
  91
  92   AliPHOSGeoUtils * GetPHOSGeometry()                const { return fPHOSGeo              ; }
  93   TString       PHOSGeometryName()                   const { return fPHOSGeoName          ; }
  94   void          SetPHOSGeometryName(TString name)          { fPHOSGeoName = name          ; }
  95   void          InitPHOSGeometry(Int_t runnumber = 180000) ;
  96   Bool_t        IsPHOSGeoMatrixSet()                 const { return fPHOSGeoMatrixSet     ; }
  97
  98   void          AccessGeometry(AliVEvent* inputEvent) ;
  99
 100   void          SetImportGeometryFromFile(Bool_t import,
 101                                           TString path = ""){
 102                                                              fImportGeometryFromFile = import    ;
 103                                                              fImportGeometryFilePath = path      ; } // EMCAL
 104
 105   Bool_t        IsMCParticleInCalorimeterAcceptance(TString calo, TParticle* particle);
 106   Bool_t        IsMCParticleInCalorimeterAcceptance(TString calo, AliAODMCParticle* particle);
 107
 108   void          SwitchOnLoadOwnEMCALGeometryMatrices()     { fLoadEMCALMatrices = kTRUE   ; }
 109   void          SwitchOffLoadOwnEMCALGeometryMatrices()    { fLoadEMCALMatrices = kFALSE  ; }
 110   void          SetEMCALGeometryMatrixInSM(TGeoHMatrix* m, Int_t i) { fEMCALMatrix[i] = m ; }
 111
 112   void          SwitchOnLoadOwnPHOSGeometryMatrices()      { fLoadPHOSMatrices = kTRUE    ; }
 113   void          SwitchOffLoadOwnPHOSGeometryMatrices()     { fLoadPHOSMatrices = kFALSE   ; }
 114   void          SetPHOSGeometryMatrixInSM(TGeoHMatrix* m, Int_t i) { fPHOSMatrix[i] = m   ; }
 115
 116   // Bad channels
 117   Bool_t        IsBadChannelsRemovalSwitchedOn()     const { return fRemoveBadChannels                                ; }
 118   void          SwitchOnBadChannelsRemoval ()              { fRemoveBadChannels = kTRUE   ;
 119                                                              fEMCALRecoUtils->SwitchOnBadChannelsRemoval();
 120                                                              if(!fPHOSBadChannelMap) InitPHOSBadChannelStatusMap()    ; }
 121   void          SwitchOffBadChannelsRemoval()              { fRemoveBadChannels = kFALSE ;
 122                                                              fEMCALRecoUtils->SwitchOffBadChannelsRemoval()           ; }
 123
 124   Bool_t        IsDistanceToBadChannelRecalculated() const { return  IsDistanceToBadChannelRecalculated()             ; }
 125   void          SwitchOnDistToBadChannelRecalculation ()   { fEMCALRecoUtils->SwitchOnDistToBadChannelRecalculation() ; }
 126   void          SwitchOffDistToBadChannelRecalculation()   { fEMCALRecoUtils->SwitchOffDistToBadChannelRecalculation(); }
 127
 128   void          InitPHOSBadChannelStatusMap () ;
 129
 130   Int_t         GetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow) const {
 131                   return fEMCALRecoUtils->GetEMCALChannelStatus(iSM,iCol,iRow); }//Channel is ok by default
 132
 133   Int_t         GetPHOSChannelStatus (Int_t imod, Int_t iCol, Int_t iRow) const {
 134                   if(fPHOSBadChannelMap) return (Int_t) ((TH2I*)fPHOSBadChannelMap->At(imod))->GetBinContent(iCol,iRow);
 135                   else return 0 ; }//Channel is ok by default
 136
 137   void          SetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) {
 138                   fEMCALRecoUtils->SetEMCALChannelStatus(iSM,iCol,iRow,c) ; }
 139
 140   void          SetPHOSChannelStatus (Int_t imod, Int_t iCol, Int_t iRow, Double_t c = 1) {
 141                   if(!fPHOSBadChannelMap) InitPHOSBadChannelStatusMap() ;
 142                   ((TH2I*)fPHOSBadChannelMap->At(imod))->SetBinContent(iCol,iRow,c) ; }
 143
 144   void          SetEMCALChannelStatusMap(Int_t iSM , TH2I* h) { fEMCALRecoUtils->SetEMCALChannelStatusMap(iSM,h)      ; }
 145   void          SetPHOSChannelStatusMap(Int_t imod , TH2I* h) { fPHOSBadChannelMap ->AddAt(h,imod)                    ; }
 146
 147   TH2I *        GetEMCALChannelStatusMap(Int_t iSM)  const { return fEMCALRecoUtils->GetEMCALChannelStatusMap(iSM)    ; }
 148   TH2I *        GetPHOSChannelStatusMap(Int_t imod)  const { return (TH2I*)fPHOSBadChannelMap->At(imod)               ; }
 149
 150   void          SetEMCALChannelStatusMap(TObjArray *map)   { fEMCALRecoUtils->SetEMCALChannelStatusMap(map)           ; }
 151   void          SetPHOSChannelStatusMap (TObjArray *map)   { fPHOSBadChannelMap  = map                                ; }
 152
 153   Bool_t        ClusterContainsBadChannel(TString calorimeter,UShort_t* cellList, Int_t nCells);
 154
 155   // Mask clusters in front of frame, EMCAL only
 156   Int_t         GetNMaskCellColumns()                const { return fNMaskCellColumns;}
 157   void          SetNMaskCellColumns(Int_t n) {
 158                   if(n > fNMaskCellColumns) { delete [] fMaskCellColumns ; fMaskCellColumns = new Int_t[n] ; }
 159                   fNMaskCellColumns = n                                                                               ; }
 160   void          SetMaskCellColumn(Int_t ipos, Int_t icol) {
 161                   if(ipos < fNMaskCellColumns) fMaskCellColumns[ipos] = icol;
 162                   else printf("Not set, position larger than allocated set size first")                               ; }
 163   Bool_t        MaskFrameCluster(Int_t iSM, Int_t ieta) const ;
 164
 165
 166   //Calorimeter indexes information
 167   Int_t         GetModuleNumber(AliAODPWG4Particle * particle, AliVEvent* inputEvent) const;
 168   Int_t         GetModuleNumber(AliVCluster * cluster) const;
 169   Int_t         GetModuleNumberCellIndexes(Int_t absId, TString calo, Int_t & icol, Int_t & irow, Int_t &iRCU) const ;
 170
 171   //Modules fiducial region
 172   Bool_t        CheckCellFiducialRegion(AliVCluster* cluster, AliVCaloCells* cells) const ;
 173   Bool_t        CheckCellFiducialRegion(AliVCluster* cluster, AliVCaloCells* cells, AliVEvent* /**/, Int_t /**/)
 174                 { return CheckCellFiducialRegion(cluster, cells) ; } // Stupid thing to do but just to avoid compilation break in AliTrackComparisonESD while I find the authors
 175   void          SetNumberOfCellsFromPHOSBorder(Int_t n)    { fNCellsFromPHOSBorder = n                                ; }
 176   Int_t         GetNumberOfCellsFromPHOSBorder()     const { return fNCellsFromPHOSBorder                             ; }
 177   void          SetNumberOfCellsFromEMCALBorder(Int_t n)   { fEMCALRecoUtils->SetNumberOfCellsFromEMCALBorder(n)      ; }
 178   Int_t         GetNumberOfCellsFromEMCALBorder()    const { return fEMCALRecoUtils->GetNumberOfCellsFromEMCALBorder(); }
 179   void          SwitchOnNoFiducialBorderInEMCALEta0()      { fEMCALRecoUtils->SwitchOnNoFiducialBorderInEMCALEta0()   ; }
 180   void          SwitchOffNoFiducialBorderInEMCALEta0()     { fEMCALRecoUtils->SwitchOffNoFiducialBorderInEMCALEta0()  ; }
 181   Bool_t        IsEMCALNoBorderAtEta0()              const { return fEMCALRecoUtils->IsEMCALNoBorderAtEta0()          ; }
 182
 183   // Recalibration
 184   Bool_t        IsRecalibrationOn()                  const { return fRecalibration                                    ; }
 185   void          SwitchOnRecalibration()                    { fRecalibration = kTRUE ;
 186                   InitPHOSRecalibrationFactors(); fEMCALRecoUtils->SwitchOnRecalibration()                            ; }
 187   void          SwitchOffRecalibration()                   { fRecalibration = kFALSE;
 188                   fEMCALRecoUtils->SwitchOffRecalibration()                                                           ; }
 189
 190   void          InitPHOSRecalibrationFactors () ;
 191
 192   Float_t       GetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow) const {
 193                   return fEMCALRecoUtils->GetEMCALChannelRecalibrationFactor(iSM , iCol, iRow)                        ; }
 194
 195   Float_t       GetPHOSChannelRecalibrationFactor (Int_t imod, Int_t iCol, Int_t iRow) const {
 196                   if(fPHOSRecalibrationFactors)
 197                     return (Float_t) ((TH2F*)fPHOSRecalibrationFactors->At(imod))->GetBinContent(iCol,iRow);
 198                   else return 1                                                                                       ; }
 199
 200   void          SetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) {
 201                   fEMCALRecoUtils->SetEMCALChannelRecalibrationFactor(iSM,iCol,iRow,c)                                ; }
 202
 203   void          SetPHOSChannelRecalibrationFactor (Int_t imod, Int_t iCol, Int_t iRow, Double_t c = 1) {
 204                   if(!fPHOSRecalibrationFactors)  InitPHOSRecalibrationFactors();
 205                   ((TH2F*)fPHOSRecalibrationFactors->At(imod))->SetBinContent(iCol,iRow,c)                            ; }
 206
 207   void          SetEMCALChannelRecalibrationFactors(Int_t iSM , TH2F* h) { fEMCALRecoUtils->SetEMCALChannelRecalibrationFactors(iSM,h)      ; }
 208   void          SetPHOSChannelRecalibrationFactors(Int_t imod , TH2F* h) { fPHOSRecalibrationFactors ->AddAt(h,imod)                        ; }
 209
 210   TH2F *        GetEMCALChannelRecalibrationFactors(Int_t iSM)     const { return fEMCALRecoUtils->GetEMCALChannelRecalibrationFactors(iSM) ; }
 211   TH2F *        GetPHOSChannelRecalibrationFactors(Int_t imod)     const { return (TH2F*)fPHOSRecalibrationFactors->At(imod)                ; }
 212
 213   void          SetEMCALChannelRecalibrationFactors(TObjArray *map)      { fEMCALRecoUtils->SetEMCALChannelRecalibrationFactors(map)        ; }
 214   void          SetPHOSChannelRecalibrationFactors (TObjArray *map)      { fPHOSRecalibrationFactors  = map;}
 215
 216   void          RecalibrateCellTime     (Double_t & time, TString calo, Int_t absId, Int_t bunchCrossNumber) const ;
 217   void          RecalibrateCellAmplitude(Float_t  & amp,  TString calo, Int_t absId) const ;
 218   Float_t       RecalibrateClusterEnergy(AliVCluster* cluster, AliVCaloCells * cells);
 219   Float_t       RecalibrateClusterEnergyWeightCell(AliVCluster* cluster, AliVCaloCells * cells, Float_t energyOrg);
 220
 221   // Run dependent energy calibrations (EMCAL)
 222
 223   void          SwitchOffRunDepCorrection()                              {  fRunDependentCorrection = kFALSE  ; }
 224   void          SwitchOnRunDepCorrection()                               {  fRunDependentCorrection = kTRUE   ; }
 225
 226   // Time Recalibration (EMCAL)
 227
 228   Bool_t       IsTimeRecalibrationOn()                             const { return fEMCALRecoUtils->IsTimeRecalibrationOn() ; }
 229   void         SwitchOffTimeRecalibration()                              { fEMCALRecoUtils->SwitchOffTimeRecalibration()   ; }
 230   void         SwitchOnTimeRecalibration()                               { fEMCALRecoUtils->SwitchOnTimeRecalibration()    ; }
 231
 232   Float_t      GetEMCALChannelTimeRecalibrationFactor(Int_t bc, Int_t absID) const
 233   { return fEMCALRecoUtils->GetEMCALChannelTimeRecalibrationFactor(bc, absID) ; }
 234
 235   void         SetEMCALChannelTimeRecalibrationFactor(Int_t bc, Int_t absID, Double_t c = 0)
 236   { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactor(bc, absID, c) ; }
 237
 238   TH1F *       GetEMCALChannelTimeRecalibrationFactors(Int_t bc) const     { return fEMCALRecoUtils-> GetEMCALChannelTimeRecalibrationFactors(bc) ; }
 239   void         SetEMCALChannelTimeRecalibrationFactors(TObjArray *map)     { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactors(map)        ; }
 240   void         SetEMCALChannelTimeRecalibrationFactors(Int_t bc , TH1F* h) { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactors(bc , h)     ; }
 241
 242   //EMCAL specific utils for the moment
 243   void          SetEMCALRecoUtils(AliEMCALRecoUtils * ru)  { fEMCALRecoUtils = ru          ; }
 244   AliEMCALRecoUtils* GetEMCALRecoUtils()             const { return fEMCALRecoUtils        ; }
 245
 246   Bool_t        IsCorrectionOfClusterEnergyOn()      const { return fCorrectELinearity     ; }
 247   void          SwitchOnCorrectClusterLinearity()          { fCorrectELinearity = kTRUE    ; }
 248   void          SwitchOffCorrectClusterLinearity()         { fCorrectELinearity = kFALSE   ; }
 249   void          CorrectClusterEnergy(AliVCluster *cl);
 250
 251   Bool_t        IsRecalculationOfClusterPositionOn() const { return fRecalculatePosition   ; }
 252   void          SwitchOnRecalculateClusterPosition()       { fRecalculatePosition = kTRUE  ; }
 253   void          SwitchOffRecalculateClusterPosition()      { fRecalculatePosition = kFALSE ; }
 254   void          RecalculateClusterPosition(AliVCaloCells* cells, AliVCluster* clu);
 255   void          RecalculateClusterShowerShapeParameters(AliVCaloCells* cells, AliVCluster* clu){
 256                   fEMCALRecoUtils->RecalculateClusterShowerShapeParameters((AliEMCALGeometry*)fEMCALGeo, cells, clu)  ; }
 257
 258   void          RecalculateClusterDistanceToBadChannel(AliVCaloCells* cells, AliVCluster* clu){
 259                   fEMCALRecoUtils->RecalculateClusterDistanceToBadChannel((AliEMCALGeometry*)fEMCALGeo, cells, clu)   ; }
 260
 261   void          RecalculateClusterPID(AliVCluster* clu)    { fEMCALRecoUtils->RecalculateClusterPID(clu)              ; }
 262
 263   // *** Track Matching ***
 264
 265   AliVTrack *   GetMatchedTrack(AliVCluster * cluster, AliVEvent * event, Int_t index = 0) const ;
 266
 267   // Recalculation
 268   void          RecalculateClusterTrackMatching(AliVEvent * event, TObjArray* clusterArray = 0x0) ;
 269
 270   void          GetMatchedResiduals(Int_t index, Float_t &dR, Float_t &dZ) {
 271                   if (fRecalculateMatching) fEMCALRecoUtils->GetMatchedResiduals(index,dR,dZ)   ; }
 272
 273   //This could be used for PHOS ...
 274   void          SwitchOnRecalculateClusterTrackMatching()       { fRecalculateMatching = kTRUE  ; }
 275   void          SwitchOffRecalculateClusterTrackMatching()      { fRecalculateMatching = kFALSE ; }
 276   Bool_t        IsRecalculationOfClusterTrackMatchingOn() const { return fRecalculateMatching   ; }
 277
 278   Float_t       GetCutZ()                                 const { return fCutZ                  ; } // PHOS only
 279   void          SetCutZ(Float_t z)                              { fCutZ = z                     ; } // PHOS only
 280
 281
 282   Float_t       GetCutR()                                 const { return fCutR                  ; } // PHOS and EMCAL
 283   void          SetCutR(Float_t r)                              { fCutR = r                     ;   // PHOS and EMCA
 284                                                                   fEMCALRecoUtils->SetCutR(r)   ; }
 285
 286   Float_t       GetCutEta()                               const { return fCutEta                ; } // EMCAL only
 287   void          SetCutEta(Float_t e)                            { fCutEta = e                   ;   // EMCAL only
 288                                                                   fEMCALRecoUtils->SetCutEta(e) ; }
 289
 290   Float_t       GetCutPhi()                               const { return fCutPhi                ; } // EMCAL only
 291   void          SetCutPhi(Float_t p)                            { fCutPhi = p                   ;   // EMCAL only
 292                                                                   fEMCALRecoUtils->SetCutPhi(p) ; }
 293   // OADB options settings
 294
 295   void          AccessOADB(AliVEvent * event) ;
 296
 297   TString       GetPass() ;
 298
 299   void          SwitchOnEMCALOADB()                             { fOADBForEMCAL = kTRUE         ; }
 300   void          SwitchOffEMCALOADB()                            { fOADBForEMCAL = kFALSE        ; }
 301
 302   void          SwitchOnPHOSOADB()                              { fOADBForPHOS  = kTRUE         ; }
 303   void          SwitchOffPHOSOADB()                             { fOADBForPHOS  = kFALSE        ; }
 304
 305   void          SetEMCALOADBFilePath(TString path)              { fOADBFilePathEMCAL  = path    ; }
 306   void          SetPHOSOADBFilePath (TString path)              { fOADBFilePathPHOS   = path    ; }
 307
 308   void          SetNumberOfSuperModulesUsed(Int_t nSM)          { fNSuperModulesUsed  = nSM     ; }
 309   Int_t         GetNumberOfSuperModulesUsed()             const { return fNSuperModulesUsed     ; }
 310
 311  private:
 312
 313   Int_t              fDebug;                 //  Debugging level
 314   TString            fEMCALGeoName;          //  Name of geometry to use for EMCAL.
 315   TString            fPHOSGeoName;           //  Name of geometry to use for PHOS.
 316   AliEMCALGeometry * fEMCALGeo ;             //! EMCAL geometry pointer
 317   AliPHOSGeoUtils  * fPHOSGeo  ;             //! PHOS  geometry pointer
 318   Bool_t             fEMCALGeoMatrixSet;     //  Check if the transformation matrix is set for EMCAL
 319   Bool_t             fPHOSGeoMatrixSet ;     //  Check if the transformation matrix is set for PHOS
 320   Bool_t             fLoadEMCALMatrices;     //  Matrices set from configuration, not get from geometry.root or from ESDs/AODs
 321   TGeoHMatrix *      fEMCALMatrix[12];       //  Geometry matrices with alignments
 322   Bool_t             fLoadPHOSMatrices;      //  Matrices set from configuration, not get from geometry.root or from ESDs/AODs
 323   TGeoHMatrix *      fPHOSMatrix[5];         //  Geometry matrices with alignments
 324   Bool_t             fRemoveBadChannels;     //  Check the channel status provided and remove clusters with bad channels
 325   TObjArray        * fPHOSBadChannelMap;     //  Array of histograms with map of bad channels, PHOS
 326   Int_t              fNCellsFromPHOSBorder;  //  Number of cells from PHOS  border the cell with maximum amplitude has to be.
 327   Int_t              fNMaskCellColumns;      //  Number of masked columns
 328   Int_t*             fMaskCellColumns;       //[fNMaskCellColumns] list of masked cell collumn
 329   Bool_t             fRecalibration;         //  Switch on or off the recalibration
 330   Bool_t             fRunDependentCorrection;//  Switch on or off the recalibration dependent on T
 331   TObjArray        * fPHOSRecalibrationFactors;  // Array of histograms with map of recalibration factors, PHOS
 332   AliEMCALRecoUtils* fEMCALRecoUtils;        //  EMCAL utils for cluster rereconstruction
 333   Bool_t             fRecalculatePosition;   //  Recalculate cluster position
 334   Bool_t             fCorrectELinearity  ;   //  Correct cluster energy linearity
 335   Bool_t             fRecalculateMatching;   //  Recalculate cluster position
 336   Float_t            fCutR;                  //  dR cut on matching (PHOS)
 337   Float_t            fCutZ;                  //  dZ cut on matching (EMCAL/PHOS)
 338   Float_t            fCutEta;                //  dEta cut on matching (EMCAL)
 339   Float_t            fCutPhi;                //  dPhi cut on matching (EMCAL)
 340   Float_t            fLocMaxCutE;            //  Local maxima cut must have more than this energy
 341   Float_t            fLocMaxCutEDiff;        //  Local maxima cut, when aggregating cells, next can be a bit higher
 342   Bool_t             fPlotCluster;           //  Plot cluster in splitting method
 343   Bool_t             fOADBSet ;              //  AODB parameters already set
 344   Bool_t             fOADBForEMCAL ;         //  Get calibration from OADB for EMCAL
 345   Bool_t             fOADBForPHOS ;          //  Get calibration from OADB for PHOS
 346   TString            fOADBFilePathEMCAL ;    //  Default path $ALICE_ROOT/OADB/EMCAL, if needed change
 347   TString            fOADBFilePathPHOS ;     //  Default path $ALICE_ROOT/OADB/PHOS, if needed change
 348   Bool_t             fImportGeometryFromFile;// Import geometry settings in geometry.root file
 349   TString            fImportGeometryFilePath;// path fo geometry.root file
 350
 351   Int_t              fNSuperModulesUsed;     // Number of supermodules to be used in analysis, can be different than the real geo,
 352                                              // to be used at initialization of histograms
 353
 354   Bool_t             fMCECellClusFracCorrOn; // Correct or not the weight of cells in cluster
 355   Float_t            fMCECellClusFracCorrParam[4]; // Parameters for the function correcting the weight of the cells in the cluster
 356
 357   AliCalorimeterUtils(              const AliCalorimeterUtils & cu) ; // cpy ctor
 358   AliCalorimeterUtils & operator = (const AliCalorimeterUtils & cu) ; // cpy assignment
 359
 360   ClassDef(AliCalorimeterUtils,17)
 361 } ;
 362
 363
 364 #endif //ALICALORIMETERUTILS_H
 365
 366
 367