[u/mrichter/AliRoot.git] / PWG / CaloTrackCorrBase / AliCalorimeterUtils.h

#ifndef ALICALORIMETERUTILS_H
#define ALICALORIMETERUTILS_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice     */

//_________________________________________________________________________
// Class utility for Calorimeter specific selection methods                ///
//
//
//
//-- Author: Gustavo Conesa (LPSC-Grenoble) 
//////////////////////////////////////////////////////////////////////////////

// --- ROOT system ---
#include <TObject.h> 
#include <TString.h>
#include <TObjArray.h>
class TArrayF;  
#include <TH2I.h>
#include <TGeoMatrix.h>

//--- ANALYSIS system ---
class AliVEvent;
class AliVTrack;
class AliAODPWG4Particle;
class AliAODCaloCluster;
class AliVCaloCells;
class AliPHOSGeoUtils;
class AliEMCALGeometry;
#include "AliEMCALRecoUtils.h"

class AliCalorimeterUtils : public TObject {

 public:   
  AliCalorimeterUtils() ; // ctor
  virtual ~AliCalorimeterUtils() ;//virtual dtor
  
  virtual void  InitParameters();
  virtual void  Print(const Option_t * opt)          const ;

  virtual Int_t GetDebug()                           const { return fDebug                ; }
  virtual void  SetDebug(Int_t d)                          { fDebug = d                   ; }
	
  //virtual void Init();
	
  // Cluster contents
  
  Bool_t        AreNeighbours(TString calo, Int_t absId1, Int_t absId2) const ;

  Int_t         GetNumberOfLocalMaxima(AliVCluster* cluster, AliVCaloCells* cells)  ;
  
  Int_t         GetNumberOfLocalMaxima(AliVCluster* cluster, AliVCaloCells* cells,
                                       Int_t *absIdList,     Float_t *maxEList)  ;
  
  Float_t       GetLocalMaximaCutE()                 const { return fLocMaxCutE           ; }
  void          SetLocalMaximaCutE(Float_t cut)            { fLocMaxCutE     = cut        ; }
  
  Float_t       GetLocalMaximaCutEDiff()             const { return fLocMaxCutEDiff       ; }
  void          SetLocalMaximaCutEDiff(Float_t c)          { fLocMaxCutEDiff = c          ; }
  
  Int_t         GetMaxEnergyCell(AliVCaloCells* cells, const AliVCluster* clu, Float_t & fraction) const ;
  
  void          SplitEnergy(Int_t absId1, Int_t absId2, AliVCluster *cluster, AliVCaloCells* cells,
                            //Float_t & e1, Float_t & e2,
                            AliAODCaloCluster *cluster1, AliAODCaloCluster *cluster2,
                            Int_t nMax, Int_t eventNumber = 0);//, Int_t *absIdList, Float_t *maxEList,
  
  void          SwitchOnClusterPlot()                      { fPlotCluster = kTRUE         ; }
  void          SwitchOffClusterPlot()                     { fPlotCluster = kFALSE        ; }

  //Calorimeters Geometry Methods
  AliEMCALGeometry * GetEMCALGeometry()              const { return fEMCALGeo             ; }
  TString       EMCALGeometryName()                  const { return fEMCALGeoName         ; }  
  void          SetEMCALGeometryName(TString name)         { fEMCALGeoName = name         ; }
  void          InitEMCALGeometry(Int_t runnumber = 180000) ; 
  Bool_t        IsEMCALGeoMatrixSet()                const { return fEMCALGeoMatrixSet    ; }
	
  AliPHOSGeoUtils * GetPHOSGeometry()                const { return fPHOSGeo              ; }	
  TString       PHOSGeometryName()                   const { return fPHOSGeoName          ; }  
  void          SetPHOSGeometryName(TString name)          { fPHOSGeoName = name          ; }
  void          InitPHOSGeometry(Int_t runnumber = 180000) ; 
  Bool_t        IsPHOSGeoMatrixSet()                 const { return fPHOSGeoMatrixSet     ; }

  void          AccessGeometry(AliVEvent* inputEvent) ;
	
  void          SetImportGeometryFromFile(Bool_t import,
                                          TString path = ""){
                                                             fImportGeometryFromFile = import    ;
                                                             fImportGeometryFilePath = path      ; } // EMCAL
  
  void          SwitchOnLoadOwnEMCALGeometryMatrices()     { fLoadEMCALMatrices = kTRUE   ; }
  void          SwitchOffLoadOwnEMCALGeometryMatrices()    { fLoadEMCALMatrices = kFALSE  ; }
  void          SetEMCALGeometryMatrixInSM(TGeoHMatrix* m, Int_t i) { fEMCALMatrix[i] = m ; }
  
  void          SwitchOnLoadOwnPHOSGeometryMatrices()      { fLoadPHOSMatrices = kTRUE    ; }
  void          SwitchOffLoadOwnPHOSGeometryMatrices()     { fLoadPHOSMatrices = kFALSE   ; }
  void          SetPHOSGeometryMatrixInSM(TGeoHMatrix* m, Int_t i) { fPHOSMatrix[i] = m   ; }
  
  // Bad channels
  Bool_t        IsBadChannelsRemovalSwitchedOn()     const { return fRemoveBadChannels                                ; }
  void          SwitchOnBadChannelsRemoval ()              { fRemoveBadChannels = kTRUE   ; 
                                                             fEMCALRecoUtils->SwitchOnBadChannelsRemoval(); 
                                                             if(!fPHOSBadChannelMap) InitPHOSBadChannelStatusMap()    ; }
  void          SwitchOffBadChannelsRemoval()              { fRemoveBadChannels = kFALSE ; 
                                                             fEMCALRecoUtils->SwitchOffBadChannelsRemoval()           ; }
  
  Bool_t        IsDistanceToBadChannelRecalculated() const { return  IsDistanceToBadChannelRecalculated()             ; }
  void          SwitchOnDistToBadChannelRecalculation ()   { fEMCALRecoUtils->SwitchOnDistToBadChannelRecalculation() ; }
  void          SwitchOffDistToBadChannelRecalculation()   { fEMCALRecoUtils->SwitchOffDistToBadChannelRecalculation(); }
  
  void          InitPHOSBadChannelStatusMap () ;

  Int_t         GetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow) const { 
                  return fEMCALRecoUtils->GetEMCALChannelStatus(iSM,iCol,iRow); }//Channel is ok by default

  Int_t         GetPHOSChannelStatus (Int_t imod, Int_t iCol, Int_t iRow) const { 
                  if(fPHOSBadChannelMap) return (Int_t) ((TH2I*)fPHOSBadChannelMap->At(imod))->GetBinContent(iCol,iRow); 
                  else return 0 ; }//Channel is ok by default
  
  void          SetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) { 
                  fEMCALRecoUtils->SetEMCALChannelStatus(iSM,iCol,iRow,c) ; }
  
  void          SetPHOSChannelStatus (Int_t imod, Int_t iCol, Int_t iRow, Double_t c = 1) {
                  if(!fPHOSBadChannelMap) InitPHOSBadChannelStatusMap() ; 
                  ((TH2I*)fPHOSBadChannelMap->At(imod))->SetBinContent(iCol,iRow,c) ; }
    
  void          SetEMCALChannelStatusMap(Int_t iSM , TH2I* h) { fEMCALRecoUtils->SetEMCALChannelStatusMap(iSM,h)      ; }
  void          SetPHOSChannelStatusMap(Int_t imod , TH2I* h) { fPHOSBadChannelMap ->AddAt(h,imod)                    ; }
  
  TH2I *        GetEMCALChannelStatusMap(Int_t iSM)  const { return fEMCALRecoUtils->GetEMCALChannelStatusMap(iSM)    ; }
  TH2I *        GetPHOSChannelStatusMap(Int_t imod)  const { return (TH2I*)fPHOSBadChannelMap->At(imod)               ; }

  void          SetEMCALChannelStatusMap(TObjArray *map)   { fEMCALRecoUtils->SetEMCALChannelStatusMap(map)           ; }
  void          SetPHOSChannelStatusMap (TObjArray *map)   { fPHOSBadChannelMap  = map                                ; }
	
  Bool_t        ClusterContainsBadChannel(TString calorimeter,UShort_t* cellList, Int_t nCells);
	
  // Mask clusters in front of frame, EMCAL only
  Int_t         GetNMaskCellColumns()                const { return fNMaskCellColumns;}
  void          SetNMaskCellColumns(Int_t n) {
                  if(n > fNMaskCellColumns) { delete [] fMaskCellColumns ; fMaskCellColumns = new Int_t[n] ; }
                  fNMaskCellColumns = n                                                                               ; }
  void          SetMaskCellColumn(Int_t ipos, Int_t icol) { 
                  if(ipos < fNMaskCellColumns) fMaskCellColumns[ipos] = icol;
                  else printf("Not set, position larger than allocated set size first")                               ; }
  Bool_t        MaskFrameCluster(Int_t iSM, Int_t ieta) const ;
  
  
  //Calorimeter indexes information
  Int_t         GetModuleNumber(AliAODPWG4Particle * particle, AliVEvent* inputEvent) const;
  Int_t         GetModuleNumber(AliVCluster * cluster) const;
  Int_t         GetModuleNumberCellIndexes(Int_t absId, TString calo, Int_t & icol, Int_t & irow, Int_t &iRCU) const ;
	
  //Modules fiducial region
  Bool_t        CheckCellFiducialRegion(AliVCluster* cluster, AliVCaloCells* cells, AliVEvent * event, Int_t iev=0) const ;
  void          SetNumberOfCellsFromPHOSBorder(Int_t n)    { fNCellsFromPHOSBorder = n                                ; }
  Int_t         GetNumberOfCellsFromPHOSBorder()     const { return fNCellsFromPHOSBorder                             ; }
  void          SetNumberOfCellsFromEMCALBorder(Int_t n)   { fEMCALRecoUtils->SetNumberOfCellsFromEMCALBorder(n)      ; }
  Int_t         GetNumberOfCellsFromEMCALBorder()    const { return fEMCALRecoUtils->GetNumberOfCellsFromEMCALBorder(); }
  void          SwitchOnNoFiducialBorderInEMCALEta0()      { fEMCALRecoUtils->SwitchOnNoFiducialBorderInEMCALEta0()   ; }
  void          SwitchOffNoFiducialBorderInEMCALEta0()     { fEMCALRecoUtils->SwitchOffNoFiducialBorderInEMCALEta0()  ; }
  Bool_t        IsEMCALNoBorderAtEta0()              const { return fEMCALRecoUtils->IsEMCALNoBorderAtEta0()          ; }
  
  // Recalibration
  Bool_t        IsRecalibrationOn()                  const { return fRecalibration                                    ; }
  void          SwitchOnRecalibration()                    { fRecalibration = kTRUE ; 
                  InitPHOSRecalibrationFactors(); fEMCALRecoUtils->SwitchOnRecalibration()                            ; }
  void          SwitchOffRecalibration()                   { fRecalibration = kFALSE;
                  fEMCALRecoUtils->SwitchOffRecalibration()                                                           ; }
	
  void          InitPHOSRecalibrationFactors () ;
	
  Float_t       GetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow) const { 
                  return fEMCALRecoUtils->GetEMCALChannelRecalibrationFactor(iSM , iCol, iRow)                        ; }
  
  Float_t       GetPHOSChannelRecalibrationFactor (Int_t imod, Int_t iCol, Int_t iRow) const { 
                  if(fPHOSRecalibrationFactors)
                    return (Float_t) ((TH2F*)fPHOSRecalibrationFactors->At(imod))->GetBinContent(iCol,iRow); 
                  else return 1                                                                                       ; }
  
  void          SetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) { 
                  fEMCALRecoUtils->SetEMCALChannelRecalibrationFactor(iSM,iCol,iRow,c)                                ; }
	
  void          SetPHOSChannelRecalibrationFactor (Int_t imod, Int_t iCol, Int_t iRow, Double_t c = 1) {
                  if(!fPHOSRecalibrationFactors)  InitPHOSRecalibrationFactors();
                  ((TH2F*)fPHOSRecalibrationFactors->At(imod))->SetBinContent(iCol,iRow,c)                            ; }
    
  void          SetEMCALChannelRecalibrationFactors(Int_t iSM , TH2F* h) { fEMCALRecoUtils->SetEMCALChannelRecalibrationFactors(iSM,h)      ; }
  void          SetPHOSChannelRecalibrationFactors(Int_t imod , TH2F* h) { fPHOSRecalibrationFactors ->AddAt(h,imod)                        ; }
	
  TH2F *        GetEMCALChannelRecalibrationFactors(Int_t iSM)     const { return fEMCALRecoUtils->GetEMCALChannelRecalibrationFactors(iSM) ; }
  TH2F *        GetPHOSChannelRecalibrationFactors(Int_t imod)     const { return (TH2F*)fPHOSRecalibrationFactors->At(imod)                ; }
	
  void          SetEMCALChannelRecalibrationFactors(TObjArray *map)      { fEMCALRecoUtils->SetEMCALChannelRecalibrationFactors(map)        ; }
  void          SetPHOSChannelRecalibrationFactors (TObjArray *map)      { fPHOSRecalibrationFactors  = map;}

  void          RecalibrateCellTime     (Double_t & time, TString calo, Int_t absId, Int_t bunchCrossNumber) const ;
  void          RecalibrateCellAmplitude(Float_t  & amp,  TString calo, Int_t absId) const ;
  Float_t       RecalibrateClusterEnergy(AliVCluster* cluster, AliVCaloCells * cells);

  // Run dependent energy calibrations (EMCAL)
  
  void          SwitchOffRunDepCorrection()                              {  fRunDependentCorrection = kFALSE  ; }
  void          SwitchOnRunDepCorrection()                               {  fRunDependentCorrection = kTRUE   ; }
  
  // Time Recalibration (EMCAL)
  
  Bool_t       IsTimeRecalibrationOn()                             const { return fEMCALRecoUtils->IsTimeRecalibrationOn() ; }
  void         SwitchOffTimeRecalibration()                              { fEMCALRecoUtils->SwitchOffTimeRecalibration()   ; }
  void         SwitchOnTimeRecalibration()                               { fEMCALRecoUtils->SwitchOnTimeRecalibration()    ; }
  
  Float_t      GetEMCALChannelTimeRecalibrationFactor(Int_t bc, Int_t absID) const
  { return fEMCALRecoUtils->GetEMCALChannelTimeRecalibrationFactor(bc, absID) ; } 
	
  void         SetEMCALChannelTimeRecalibrationFactor(Int_t bc, Int_t absID, Double_t c = 0)
  { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactor(bc, absID, c) ; }  
  
  TH1F *       GetEMCALChannelTimeRecalibrationFactors(Int_t bc) const     { return fEMCALRecoUtils-> GetEMCALChannelTimeRecalibrationFactors(bc) ; }
  void         SetEMCALChannelTimeRecalibrationFactors(TObjArray *map)     { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactors(map)        ; }
  void         SetEMCALChannelTimeRecalibrationFactors(Int_t bc , TH1F* h) { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactors(bc , h)     ; }
  
  //EMCAL specific utils for the moment
  void          SetEMCALRecoUtils(AliEMCALRecoUtils * ru)  { fEMCALRecoUtils = ru          ; }
  AliEMCALRecoUtils* GetEMCALRecoUtils()             const { return fEMCALRecoUtils        ; }
  
  Bool_t        IsCorrectionOfClusterEnergyOn()      const { return fCorrectELinearity     ; }
  void          SwitchOnCorrectClusterLinearity()          { fCorrectELinearity = kTRUE    ; } 
  void          SwitchOffCorrectClusterLinearity()         { fCorrectELinearity = kFALSE   ; } 
  void          CorrectClusterEnergy(AliVCluster *cl);
  
  Bool_t        IsRecalculationOfClusterPositionOn() const { return fRecalculatePosition   ; }
  void          SwitchOnRecalculateClusterPosition()       { fRecalculatePosition = kTRUE  ; } 
  void          SwitchOffRecalculateClusterPosition()      { fRecalculatePosition = kFALSE ; } 
  void          RecalculateClusterPosition(AliVCaloCells* cells, AliVCluster* clu);
  void          RecalculateClusterShowerShapeParameters(AliVCaloCells* cells, AliVCluster* clu){
                  fEMCALRecoUtils->RecalculateClusterShowerShapeParameters((AliEMCALGeometry*)fEMCALGeo, cells, clu)  ; }
  
  void          RecalculateClusterDistanceToBadChannel(AliVCaloCells* cells, AliVCluster* clu){
                  fEMCALRecoUtils->RecalculateClusterDistanceToBadChannel((AliEMCALGeometry*)fEMCALGeo, cells, clu)   ; }
  
  void          RecalculateClusterPID(AliVCluster* clu)    { fEMCALRecoUtils->RecalculateClusterPID(clu)              ; }

  // *** Track Matching ***
  
  AliVTrack *   GetMatchedTrack(AliVCluster * cluster, AliVEvent * event, Int_t index = 0) const ;
  
  // Recalculation
  void          RecalculateClusterTrackMatching(AliVEvent * event, TObjArray* clusterArray = 0x0) ;
    
  void          GetMatchedResiduals(Int_t index, Float_t &dR, Float_t &dZ) {
                  if (fRecalculateMatching) fEMCALRecoUtils->GetMatchedResiduals(index,dR,dZ)   ; }
  
  //This could be used for PHOS ...
  void          SwitchOnRecalculateClusterTrackMatching()       { fRecalculateMatching = kTRUE  ; } 
  void          SwitchOffRecalculateClusterTrackMatching()      { fRecalculateMatching = kFALSE ; } 
  Bool_t        IsRecalculationOfClusterTrackMatchingOn() const { return fRecalculateMatching   ; }
  
  Float_t       GetCutZ()                                 const { return fCutZ                  ; } // PHOS only
  void          SetCutZ(Float_t z)                              { fCutZ = z                     ; } // PHOS only

  
  Float_t       GetCutR()                                 const { return fCutR                  ; } // PHOS and EMCAL
  void          SetCutR(Float_t r)                              { fCutR = r                     ;   // PHOS and EMCA
                                                                  fEMCALRecoUtils->SetCutR(r)   ; }
  
  Float_t       GetCutEta()                               const { return fCutEta                ; } // EMCAL only
  void          SetCutEta(Float_t e)                            { fCutEta = e                   ;   // EMCAL only
                                                                  fEMCALRecoUtils->SetCutEta(e) ; }

  Float_t       GetCutPhi()                               const { return fCutPhi                ; } // EMCAL only
  void          SetCutPhi(Float_t p)                            { fCutPhi = p                   ;   // EMCAL only
                                                                  fEMCALRecoUtils->SetCutPhi(p) ; }
  // OADB options settings
  
  void          AccessOADB(AliVEvent * event) ;
  
  TString       GetPass() ;
  
  void          SwitchOnEMCALOADB()                             { fOADBForEMCAL = kTRUE         ; }
  void          SwitchOffEMCALOADB()                            { fOADBForEMCAL = kFALSE        ; }

  void          SwitchOnPHOSOADB()                              { fOADBForPHOS  = kTRUE         ; }
  void          SwitchOffPHOSOADB()                             { fOADBForPHOS  = kFALSE        ; }

  void          SetEMCALOADBFilePath(TString path)              { fOADBFilePathEMCAL  = path    ; }
  void          SetPHOSOADBFilePath (TString path)              { fOADBFilePathPHOS   = path    ; }

  void          SetNumberOfSuperModulesUsed(Int_t nSM)          { fNSuperModulesUsed  = nSM     ; }
  Int_t         GetNumberOfSuperModulesUsed()             const { return fNSuperModulesUsed     ; }
  
 private:

  Int_t              fDebug;                 //  Debugging level
  TString            fEMCALGeoName;          //  Name of geometry to use for EMCAL.
  TString            fPHOSGeoName;           //  Name of geometry to use for PHOS.	
  AliEMCALGeometry * fEMCALGeo ;             //! EMCAL geometry pointer
  AliPHOSGeoUtils  * fPHOSGeo  ;             //! PHOS  geometry pointer  
  Bool_t             fEMCALGeoMatrixSet;     //  Check if the transformation matrix is set for EMCAL
  Bool_t             fPHOSGeoMatrixSet ;     //  Check if the transformation matrix is set for PHOS
  Bool_t             fLoadEMCALMatrices;     //  Matrices set from configuration, not get from geometry.root or from ESDs/AODs
  TGeoHMatrix *      fEMCALMatrix[12];       //  Geometry matrices with alignments
  Bool_t             fLoadPHOSMatrices;      //  Matrices set from configuration, not get from geometry.root or from ESDs/AODs
  TGeoHMatrix *      fPHOSMatrix[5];         //  Geometry matrices with alignments
  Bool_t             fRemoveBadChannels;     //  Check the channel status provided and remove clusters with bad channels
  TObjArray        * fPHOSBadChannelMap;     //  Array of histograms with map of bad channels, PHOS
  Int_t              fNCellsFromPHOSBorder;  //  Number of cells from PHOS  border the cell with maximum amplitude has to be.
  Int_t              fNMaskCellColumns;      //  Number of masked columns
  Int_t*             fMaskCellColumns;       //[fNMaskCellColumns] list of masked cell collumn
  Bool_t             fRecalibration;         //  Switch on or off the recalibration
  Bool_t             fRunDependentCorrection;//  Switch on or off the recalibration dependent on T
  TObjArray        * fPHOSRecalibrationFactors;  // Array of histograms with map of recalibration factors, PHOS
  AliEMCALRecoUtils* fEMCALRecoUtils;        //  EMCAL utils for cluster rereconstruction
  Bool_t             fRecalculatePosition;   //  Recalculate cluster position
  Bool_t             fCorrectELinearity  ;   //  Correct cluster energy linearity
  Bool_t             fRecalculateMatching;   //  Recalculate cluster position
  Float_t            fCutR;                  //  dR cut on matching (PHOS)
  Float_t            fCutZ;                  //  dZ cut on matching (EMCAL/PHOS)
  Float_t            fCutEta;                //  dEta cut on matching (EMCAL)
  Float_t            fCutPhi;                //  dPhi cut on matching (EMCAL)
  Float_t            fLocMaxCutE;            //  Local maxima cut must have more than this energy
  Float_t            fLocMaxCutEDiff;        //  Local maxima cut, when aggregating cells, next can be a bit higher
  Bool_t             fPlotCluster;           //  Plot cluster in splitting method
  Bool_t             fOADBSet ;              //  AODB parameters already set
  Bool_t             fOADBForEMCAL ;         //  Get calibration from OADB for EMCAL
  Bool_t             fOADBForPHOS ;          //  Get calibration from OADB for PHOS
  TString            fOADBFilePathEMCAL ;    //  Default path $ALICE_ROOT/OADB/EMCAL, if needed change
  TString            fOADBFilePathPHOS ;     //  Default path $ALICE_ROOT/OADB/PHOS, if needed change
  Bool_t             fImportGeometryFromFile;// Import geometry settings in geometry.root file
  TString            fImportGeometryFilePath;// path fo geometry.root file

  Int_t              fNSuperModulesUsed;     // Number of supermodules to be used in analysis, can be different than the real geo,
                                             // to be used at initialization of histograms

  
  AliCalorimeterUtils(              const AliCalorimeterUtils & cu) ; // cpy ctor
  AliCalorimeterUtils & operator = (const AliCalorimeterUtils & cu) ; // cpy assignment
  
  ClassDef(AliCalorimeterUtils,16)
} ;


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