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