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(Int_t 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(Int_t calo, TParticle* particle);
 106   Bool_t        IsMCParticleInCalorimeterAcceptance(Int_t calo, AliAODMCParticle* particle);
 107   Bool_t        IsMCParticleInCalorimeterAcceptance(Int_t calo, Float_t eta, Float_t theta, Float_t phi, Int_t & absID);
 108
 109   void          SwitchOnLoadOwnEMCALGeometryMatrices()     { fLoadEMCALMatrices = kTRUE   ; }
 110   void          SwitchOffLoadOwnEMCALGeometryMatrices()    { fLoadEMCALMatrices = kFALSE  ; }
 111   void          SetEMCALGeometryMatrixInSM(TGeoHMatrix* m, Int_t i) { fEMCALMatrix[i] = m ; }
 112
 113   void          SwitchOnLoadOwnPHOSGeometryMatrices()      { fLoadPHOSMatrices = kTRUE    ; }
 114   void          SwitchOffLoadOwnPHOSGeometryMatrices()     { fLoadPHOSMatrices = kFALSE   ; }
 115   void          SetPHOSGeometryMatrixInSM(TGeoHMatrix* m, Int_t i) { fPHOSMatrix[i] = m   ; }
 116
 117   // Bad channels
 118   Bool_t        IsBadChannelsRemovalSwitchedOn()     const { return fRemoveBadChannels                                ; }
 119   void          SwitchOnBadChannelsRemoval ()              { fRemoveBadChannels = kTRUE   ;
 120                                                              fEMCALRecoUtils->SwitchOnBadChannelsRemoval();
 121                                                              if(!fPHOSBadChannelMap) InitPHOSBadChannelStatusMap()    ; }
 122   void          SwitchOffBadChannelsRemoval()              { fRemoveBadChannels = kFALSE ;
 123                                                              fEMCALRecoUtils->SwitchOffBadChannelsRemoval()           ; }
 124
 125   Bool_t        IsDistanceToBadChannelRecalculated() const { return  IsDistanceToBadChannelRecalculated()             ; }
 126   void          SwitchOnDistToBadChannelRecalculation ()   { fEMCALRecoUtils->SwitchOnDistToBadChannelRecalculation() ; }
 127   void          SwitchOffDistToBadChannelRecalculation()   { fEMCALRecoUtils->SwitchOffDistToBadChannelRecalculation(); }
 128
 129   void          InitPHOSBadChannelStatusMap () ;
 130
 131   Int_t         GetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow) const {
 132                   return fEMCALRecoUtils->GetEMCALChannelStatus(iSM,iCol,iRow); }//Channel is ok by default
 133
 134   Int_t         GetPHOSChannelStatus (Int_t imod, Int_t iCol, Int_t iRow) const {
 135                   if(fPHOSBadChannelMap) return (Int_t) ((TH2I*)fPHOSBadChannelMap->At(imod))->GetBinContent(iCol,iRow);
 136                   else return 0 ; }//Channel is ok by default
 137
 138   void          SetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) {
 139                   fEMCALRecoUtils->SetEMCALChannelStatus(iSM,iCol,iRow,c) ; }
 140
 141   void          SetPHOSChannelStatus (Int_t imod, Int_t iCol, Int_t iRow, Double_t c = 1) {
 142                   if(!fPHOSBadChannelMap) InitPHOSBadChannelStatusMap() ;
 143                   ((TH2I*)fPHOSBadChannelMap->At(imod))->SetBinContent(iCol,iRow,c) ; }
 144
 145   void          SetEMCALChannelStatusMap(Int_t iSM , TH2I* h) { fEMCALRecoUtils->SetEMCALChannelStatusMap(iSM,h)      ; }
 146   void          SetPHOSChannelStatusMap(Int_t imod , TH2I* h) { fPHOSBadChannelMap ->AddAt(h,imod)                    ; }
 147
 148   TH2I *        GetEMCALChannelStatusMap(Int_t iSM)  const { return fEMCALRecoUtils->GetEMCALChannelStatusMap(iSM)    ; }
 149   TH2I *        GetPHOSChannelStatusMap(Int_t imod)  const { return (TH2I*)fPHOSBadChannelMap->At(imod)               ; }
 150
 151   void          SetEMCALChannelStatusMap(TObjArray *map)   { fEMCALRecoUtils->SetEMCALChannelStatusMap(map)           ; }
 152   void          SetPHOSChannelStatusMap (TObjArray *map)   { fPHOSBadChannelMap  = map                                ; }
 153
 154   Bool_t        ClusterContainsBadChannel(Int_t calo,UShort_t* cellList, Int_t nCells);
 155   Bool_t        ClusterContainsBadChannel(TString /*calo*/,UShort_t* /*cellList*/, Int_t /*nCells*/); // Stupid thing to do but just to avoid compilation break in AliTrackComparisonESD while I find the authors
 156
 157   // Mask clusters in front of frame, EMCAL only
 158   Int_t         GetNMaskCellColumns()                const { return fNMaskCellColumns;}
 159   void          SetNMaskCellColumns(Int_t n) {
 160                   if(n > fNMaskCellColumns) { delete [] fMaskCellColumns ; fMaskCellColumns = new Int_t[n] ; }
 161                   fNMaskCellColumns = n                                                                               ; }
 162   void          SetMaskCellColumn(Int_t ipos, Int_t icol) {
 163                   if(ipos < fNMaskCellColumns) fMaskCellColumns[ipos] = icol;
 164                   else printf("Not set, position larger than allocated set size first")                               ; }
 165   Bool_t        MaskFrameCluster(Int_t iSM, Int_t ieta) const ;
 166
 167
 168   //Calorimeter indexes information
 169   Int_t         GetModuleNumber(AliAODPWG4Particle * particle, AliVEvent* inputEvent) const;
 170   Int_t         GetModuleNumber(AliVCluster * cluster) const;
 171   Int_t         GetModuleNumberCellIndexes(Int_t absId, Int_t calo, Int_t & icol, Int_t & irow, Int_t &iRCU) const ;
 172
 173   //Modules fiducial region
 174   Bool_t        CheckCellFiducialRegion(AliVCluster* cluster, AliVCaloCells* cells) const ;
 175   Bool_t        CheckCellFiducialRegion(AliVCluster* cluster, AliVCaloCells* cells, AliVEvent* /**/, Int_t /**/)
 176                 { return CheckCellFiducialRegion(cluster, cells) ; } // Stupid thing to do but just to avoid compilation break in AliTrackComparisonESD while I find the authors
 177   void          SetNumberOfCellsFromPHOSBorder(Int_t n)    { fNCellsFromPHOSBorder = n                                ; }
 178   Int_t         GetNumberOfCellsFromPHOSBorder()     const { return fNCellsFromPHOSBorder                             ; }
 179   void          SetNumberOfCellsFromEMCALBorder(Int_t n)   { fEMCALRecoUtils->SetNumberOfCellsFromEMCALBorder(n)      ; }
 180   Int_t         GetNumberOfCellsFromEMCALBorder()    const { return fEMCALRecoUtils->GetNumberOfCellsFromEMCALBorder(); }
 181   void          SwitchOnNoFiducialBorderInEMCALEta0()      { fEMCALRecoUtils->SwitchOnNoFiducialBorderInEMCALEta0()   ; }
 182   void          SwitchOffNoFiducialBorderInEMCALEta0()     { fEMCALRecoUtils->SwitchOffNoFiducialBorderInEMCALEta0()  ; }
 183   Bool_t        IsEMCALNoBorderAtEta0()              const { return fEMCALRecoUtils->IsEMCALNoBorderAtEta0()          ; }
 184
 185   // Recalibration
 186   Bool_t        IsRecalibrationOn()                  const { return fRecalibration                                    ; }
 187   void          SwitchOnRecalibration()                    { fRecalibration = kTRUE ;
 188                   InitPHOSRecalibrationFactors(); fEMCALRecoUtils->SwitchOnRecalibration()                            ; }
 189   void          SwitchOffRecalibration()                   { fRecalibration = kFALSE;
 190                   fEMCALRecoUtils->SwitchOffRecalibration()                                                           ; }
 191
 192   void          InitPHOSRecalibrationFactors () ;
 193
 194   Float_t       GetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow) const {
 195                   return fEMCALRecoUtils->GetEMCALChannelRecalibrationFactor(iSM , iCol, iRow)                        ; }
 196
 197   Float_t       GetPHOSChannelRecalibrationFactor (Int_t imod, Int_t iCol, Int_t iRow) const {
 198                   if(fPHOSRecalibrationFactors)
 199                     return (Float_t) ((TH2F*)fPHOSRecalibrationFactors->At(imod))->GetBinContent(iCol,iRow);
 200                   else return 1                                                                                       ; }
 201
 202   void          SetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) {
 203                   fEMCALRecoUtils->SetEMCALChannelRecalibrationFactor(iSM,iCol,iRow,c)                                ; }
 204
 205   void          SetPHOSChannelRecalibrationFactor (Int_t imod, Int_t iCol, Int_t iRow, Double_t c = 1) {
 206                   if(!fPHOSRecalibrationFactors)  InitPHOSRecalibrationFactors();
 207                   ((TH2F*)fPHOSRecalibrationFactors->At(imod))->SetBinContent(iCol,iRow,c)                            ; }
 208
 209   void          SetEMCALChannelRecalibrationFactors(Int_t iSM , TH2F* h) { fEMCALRecoUtils->SetEMCALChannelRecalibrationFactors(iSM,h)      ; }
 210   void          SetPHOSChannelRecalibrationFactors(Int_t imod , TH2F* h) { fPHOSRecalibrationFactors ->AddAt(h,imod)                        ; }
 211
 212   TH2F *        GetEMCALChannelRecalibrationFactors(Int_t iSM)     const { return fEMCALRecoUtils->GetEMCALChannelRecalibrationFactors(iSM) ; }
 213   TH2F *        GetPHOSChannelRecalibrationFactors(Int_t imod)     const { return (TH2F*)fPHOSRecalibrationFactors->At(imod)                ; }
 214
 215   void          SetEMCALChannelRecalibrationFactors(TObjArray *map)      { fEMCALRecoUtils->SetEMCALChannelRecalibrationFactors(map)        ; }
 216   void          SetPHOSChannelRecalibrationFactors (TObjArray *map)      { fPHOSRecalibrationFactors  = map;}
 217
 218   void          RecalibrateCellTime     (Double_t & time, Int_t calo, Int_t absId, Int_t bunchCrossNumber) const ;
 219   void          RecalibrateCellAmplitude(Float_t  & amp,  Int_t calo, Int_t absId) const ;
 220   Float_t       RecalibrateClusterEnergy(AliVCluster* cluster, AliVCaloCells * cells);
 221   Float_t       RecalibrateClusterEnergyWeightCell(AliVCluster* cluster, AliVCaloCells * cells, Float_t energyOrg);
 222
 223   // Run dependent energy calibrations (EMCAL)
 224
 225   void          SwitchOffRunDepCorrection()                              {  fRunDependentCorrection = kFALSE  ; }
 226   void          SwitchOnRunDepCorrection()                               {  fRunDependentCorrection = kTRUE   ; }
 227
 228   // Time Recalibration (EMCAL)
 229
 230   Bool_t       IsTimeRecalibrationOn()                             const { return fEMCALRecoUtils->IsTimeRecalibrationOn() ; }
 231   void         SwitchOffTimeRecalibration()                              { fEMCALRecoUtils->SwitchOffTimeRecalibration()   ; }
 232   void         SwitchOnTimeRecalibration()                               { fEMCALRecoUtils->SwitchOnTimeRecalibration()    ; }
 233
 234   Float_t      GetEMCALChannelTimeRecalibrationFactor(Int_t bc, Int_t absID) const
 235   { return fEMCALRecoUtils->GetEMCALChannelTimeRecalibrationFactor(bc, absID) ; }
 236
 237   void         SetEMCALChannelTimeRecalibrationFactor(Int_t bc, Int_t absID, Double_t c = 0)
 238   { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactor(bc, absID, c) ; }
 239
 240   TH1F *       GetEMCALChannelTimeRecalibrationFactors(Int_t bc) const     { return fEMCALRecoUtils-> GetEMCALChannelTimeRecalibrationFactors(bc) ; }
 241   void         SetEMCALChannelTimeRecalibrationFactors(TObjArray *map)     { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactors(map)        ; }
 242   void         SetEMCALChannelTimeRecalibrationFactors(Int_t bc , TH1F* h) { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactors(bc , h)     ; }
 243
 244   //EMCAL specific utils for the moment
 245   void          SetEMCALRecoUtils(AliEMCALRecoUtils * ru)  { fEMCALRecoUtils = ru          ; }
 246   AliEMCALRecoUtils* GetEMCALRecoUtils()             const { return fEMCALRecoUtils        ; }
 247
 248   Bool_t        IsCorrectionOfClusterEnergyOn()      const { return fCorrectELinearity     ; }
 249   void          SwitchOnCorrectClusterLinearity()          { fCorrectELinearity = kTRUE    ; }
 250   void          SwitchOffCorrectClusterLinearity()         { fCorrectELinearity = kFALSE   ; }
 251   void          CorrectClusterEnergy(AliVCluster *cl);
 252
 253   Bool_t        IsRecalculationOfClusterPositionOn() const { return fRecalculatePosition   ; }
 254   void          SwitchOnRecalculateClusterPosition()       { fRecalculatePosition = kTRUE  ; }
 255   void          SwitchOffRecalculateClusterPosition()      { fRecalculatePosition = kFALSE ; }
 256   void          RecalculateClusterPosition(AliVCaloCells* cells, AliVCluster* clu);
 257   void          RecalculateClusterShowerShapeParameters(AliVCaloCells* cells, AliVCluster* clu){
 258                   fEMCALRecoUtils->RecalculateClusterShowerShapeParameters((AliEMCALGeometry*)fEMCALGeo, cells, clu)  ; }
 259
 260   void          RecalculateClusterDistanceToBadChannel(AliVCaloCells* cells, AliVCluster* clu){
 261                   fEMCALRecoUtils->RecalculateClusterDistanceToBadChannel((AliEMCALGeometry*)fEMCALGeo, cells, clu)   ; }
 262
 263   void          RecalculateClusterPID(AliVCluster* clu)    { fEMCALRecoUtils->RecalculateClusterPID(clu)              ; }
 264
 265   // *** Track Matching ***
 266
 267   AliVTrack *   GetMatchedTrack(AliVCluster * cluster, AliVEvent * event, Int_t index = 0) const ;
 268
 269   // Recalculation
 270   void          RecalculateClusterTrackMatching(AliVEvent * event, TObjArray* clusterArray = 0x0) ;
 271
 272   void          GetMatchedResiduals(Int_t index, Float_t &dR, Float_t &dZ) {
 273                   if (fRecalculateMatching) fEMCALRecoUtils->GetMatchedResiduals(index,dR,dZ)   ; }
 274
 275   //This could be used for PHOS ...
 276   void          SwitchOnRecalculateClusterTrackMatching()       { fRecalculateMatching = kTRUE  ; }
 277   void          SwitchOffRecalculateClusterTrackMatching()      { fRecalculateMatching = kFALSE ; }
 278   Bool_t        IsRecalculationOfClusterTrackMatchingOn() const { return fRecalculateMatching   ; }
 279
 280   Float_t       GetCutZ()                                 const { return fCutZ                  ; } // PHOS only
 281   void          SetCutZ(Float_t z)                              { fCutZ = z                     ; } // PHOS only
 282
 283
 284   Float_t       GetCutR()                                 const { return fCutR                  ; } // PHOS and EMCAL
 285   void          SetCutR(Float_t r)                              { fCutR = r                     ;   // PHOS and EMCA
 286                                                                   fEMCALRecoUtils->SetCutR(r)   ; }
 287
 288   Float_t       GetCutEta()                               const { return fCutEta                ; } // EMCAL only
 289   void          SetCutEta(Float_t e)                            { fCutEta = e                   ;   // EMCAL only
 290                                                                   fEMCALRecoUtils->SetCutEta(e) ; }
 291
 292   Float_t       GetCutPhi()                               const { return fCutPhi                ; } // EMCAL only
 293   void          SetCutPhi(Float_t p)                            { fCutPhi = p                   ;   // EMCAL only
 294                                                                   fEMCALRecoUtils->SetCutPhi(p) ; }
 295   // OADB options settings
 296
 297   void          AccessOADB(AliVEvent * event) ;
 298
 299   TString       GetPass() ;
 300
 301   void          SwitchOnEMCALOADB()                             { fOADBForEMCAL = kTRUE         ; }
 302   void          SwitchOffEMCALOADB()                            { fOADBForEMCAL = kFALSE        ; }
 303
 304   void          SwitchOnPHOSOADB()                              { fOADBForPHOS  = kTRUE         ; }
 305   void          SwitchOffPHOSOADB()                             { fOADBForPHOS  = kFALSE        ; }
 306
 307   void          SetEMCALOADBFilePath(TString path)              { fOADBFilePathEMCAL  = path    ; }
 308   void          SetPHOSOADBFilePath (TString path)              { fOADBFilePathPHOS   = path    ; }
 309
 310   void          SetNumberOfSuperModulesUsed(Int_t nSM)          { fNSuperModulesUsed  = nSM     ; }
 311   Int_t         GetNumberOfSuperModulesUsed()             const { return fNSuperModulesUsed     ; }
 312
 313   enum detector { kEMCAL = 0, kPHOS = 1, kCTS = 2, kDCAL = 3, kDCALPHOS = 4 };
 314
 315  private:
 316
 317   Int_t              fDebug;                 //  Debugging level
 318   TString            fEMCALGeoName;          //  Name of geometry to use for EMCAL.
 319   TString            fPHOSGeoName;           //  Name of geometry to use for PHOS.
 320   AliEMCALGeometry * fEMCALGeo ;             //! EMCAL geometry pointer
 321   AliPHOSGeoUtils  * fPHOSGeo  ;             //! PHOS  geometry pointer
 322   Bool_t             fEMCALGeoMatrixSet;     //  Check if the transformation matrix is set for EMCAL
 323   Bool_t             fPHOSGeoMatrixSet ;     //  Check if the transformation matrix is set for PHOS
 324   Bool_t             fLoadEMCALMatrices;     //  Matrices set from configuration, not get from geometry.root or from ESDs/AODs
 325   TGeoHMatrix *      fEMCALMatrix[12];       //  Geometry matrices with alignments
 326   Bool_t             fLoadPHOSMatrices;      //  Matrices set from configuration, not get from geometry.root or from ESDs/AODs
 327   TGeoHMatrix *      fPHOSMatrix[5];         //  Geometry matrices with alignments
 328   Bool_t             fRemoveBadChannels;     //  Check the channel status provided and remove clusters with bad channels
 329   TObjArray        * fPHOSBadChannelMap;     //  Array of histograms with map of bad channels, PHOS
 330   Int_t              fNCellsFromPHOSBorder;  //  Number of cells from PHOS  border the cell with maximum amplitude has to be.
 331   Int_t              fNMaskCellColumns;      //  Number of masked columns
 332   Int_t*             fMaskCellColumns;       //[fNMaskCellColumns] list of masked cell collumn
 333   Bool_t             fRecalibration;         //  Switch on or off the recalibration
 334   Bool_t             fRunDependentCorrection;//  Switch on or off the recalibration dependent on T
 335   TObjArray        * fPHOSRecalibrationFactors;  // Array of histograms with map of recalibration factors, PHOS
 336   AliEMCALRecoUtils* fEMCALRecoUtils;        //  EMCAL utils for cluster rereconstruction
 337   Bool_t             fRecalculatePosition;   //  Recalculate cluster position
 338   Bool_t             fCorrectELinearity  ;   //  Correct cluster energy linearity
 339   Bool_t             fRecalculateMatching;   //  Recalculate cluster position
 340   Float_t            fCutR;                  //  dR cut on matching (PHOS)
 341   Float_t            fCutZ;                  //  dZ cut on matching (EMCAL/PHOS)
 342   Float_t            fCutEta;                //  dEta cut on matching (EMCAL)
 343   Float_t            fCutPhi;                //  dPhi cut on matching (EMCAL)
 344   Float_t            fLocMaxCutE;            //  Local maxima cut must have more than this energy
 345   Float_t            fLocMaxCutEDiff;        //  Local maxima cut, when aggregating cells, next can be a bit higher
 346   Bool_t             fPlotCluster;           //  Plot cluster in splitting method
 347   Bool_t             fOADBSet ;              //  AODB parameters already set
 348   Bool_t             fOADBForEMCAL ;         //  Get calibration from OADB for EMCAL
 349   Bool_t             fOADBForPHOS ;          //  Get calibration from OADB for PHOS
 350   TString            fOADBFilePathEMCAL ;    //  Default path $ALICE_ROOT/OADB/EMCAL, if needed change
 351   TString            fOADBFilePathPHOS ;     //  Default path $ALICE_ROOT/OADB/PHOS, if needed change
 352   Bool_t             fImportGeometryFromFile;// Import geometry settings in geometry.root file
 353   TString            fImportGeometryFilePath;// path fo geometry.root file
 354
 355   Int_t              fNSuperModulesUsed;     // Number of supermodules to be used in analysis, can be different than the real geo,
 356                                              // to be used at initialization of histograms
 357
 358   Bool_t             fMCECellClusFracCorrOn; // Correct or not the weight of cells in cluster
 359   Float_t            fMCECellClusFracCorrParam[4]; // Parameters for the function correcting the weight of the cells in the cluster
 360
 361   AliCalorimeterUtils(              const AliCalorimeterUtils & cu) ; // cpy ctor
 362   AliCalorimeterUtils & operator = (const AliCalorimeterUtils & cu) ; // cpy assignment
 363
 364   ClassDef(AliCalorimeterUtils,17)
 365 } ;
 366
 367
 368 #endif //ALICALORIMETERUTILS_H
 369
 370
 371