[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(const TString calo, const Int_t absId1, const 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(const Int_t absId1, const Int_t absId2, 
                            AliVCluster *cluster, 
                            AliVCaloCells* cells,
                            //Float_t & e1, Float_t & e2,
                            AliAODCaloCluster *cluster1, 
                            AliAODCaloCluster *cluster2, 
                            const Int_t nMax, const 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          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(const Int_t iSM, const Int_t ieta) const ;
  
  
  //Calorimeter indexes information
  Int_t         GetModuleNumber(AliAODPWG4Particle * particle, AliVEvent* inputEvent) const;
  Int_t         GetModuleNumber(AliVCluster * cluster) const;
  Int_t         GetModuleNumberCellIndexes(const Int_t absId, const 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, const TString calo, const Int_t absId, const Int_t bunchCrossNumber) const ;
  void          RecalibrateCellAmplitude(Float_t  & amp,  const TString calo, const 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(const Int_t bc, const Int_t absID) const 
  { return fEMCALRecoUtils->GetEMCALChannelTimeRecalibrationFactor(bc, absID) ; } 
	
  void         SetEMCALChannelTimeRecalibrationFactor(const Int_t bc, const Int_t absID, Double_t c = 0) 
  { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactor(bc, absID, c) ; }  
  
  TH1F *       GetEMCALChannelTimeRecalibrationFactors(const Int_t bc)const       { return fEMCALRecoUtils-> GetEMCALChannelTimeRecalibrationFactors(bc) ; }	
  void         SetEMCALChannelTimeRecalibrationFactors(TObjArray *map)            { fEMCALRecoUtils->SetEMCALChannelTimeRecalibrationFactors(map)        ; }
  void         SetEMCALChannelTimeRecalibrationFactors(const 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(const AliVCluster * cluster, const AliVEvent * event, const 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    ; }

  
 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
  
  AliCalorimeterUtils(              const AliCalorimeterUtils & cu) ; // cpy ctor
  AliCalorimeterUtils & operator = (const AliCalorimeterUtils & cu) ; // cpy assignment
  
  ClassDef(AliCalorimeterUtils,14)
} ;


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