[u/mrichter/AliRoot.git] / EMCAL / AliEMCALRecoUtils.h

#ifndef ALIEMCALRECOUTILS_H
#define ALIEMCALRECOUTILS_H

/* $Id: AliEMCALRecoUtils.h 33808 2009-07-15 09:48:08Z gconesab $ */

///////////////////////////////////////////////////////////////////////////////
//
// Class AliEMCALRecoUtils
// Some utilities to recalculate the cluster position or energy linearity
//
//
// Author:  Gustavo Conesa (LPSC- Grenoble) 
///////////////////////////////////////////////////////////////////////////////

//Root includes
#include "TNamed.h"
#include "TMath.h"
#include "TObjArray.h"
#include "TH2F.h"

//AliRoot includes
class AliVCluster;
class AliVCaloCells;
#include "AliLog.h"
class AliEMCALGeometry;
class AliEMCALPIDUtils;

class AliEMCALRecoUtils : public TNamed {
  
public:
  
  AliEMCALRecoUtils();
  AliEMCALRecoUtils(const AliEMCALRecoUtils&); 
  AliEMCALRecoUtils& operator=(const AliEMCALRecoUtils&); 
  virtual ~AliEMCALRecoUtils() ;
  
  enum NonlinearityFunctions{kPi0MC=0,kPi0GammaGamma=1,kPi0GammaConversion=2,kNoCorrection=3};
  enum PositionAlgorithms{kUnchanged=-1,kPosTowerIndex=0, kPosTowerGlobal=1};
  enum ParticleType{kPhoton=0, kElectron=1,kHadron =2, kUnknown=-1};
  
  //Position recalculation
  void     RecalculateClusterPosition(AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu); 
  void     RecalculateClusterPositionFromTowerIndex (AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu); 
  void     RecalculateClusterPositionFromTowerGlobal(AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu); 
  
  Float_t  GetCellWeight(const Float_t eCell, const Float_t eCluster) const { return TMath::Max( 0., fW0 + TMath::Log( eCell / eCluster ));}
  
  Float_t  GetDepth(const Float_t eCluster, const Int_t iParticle, const Int_t iSM) const ; 
  
  void     GetMaxEnergyCell(AliEMCALGeometry *geom, AliVCaloCells* cells, AliVCluster* clu, 
                            Int_t & absId,  Int_t& iSupMod, Int_t& ieta, Int_t& iphi);
  
  Float_t  GetMisalTransShift(const Int_t i) const {
    if(i < 15 ){return fMisalTransShift[i]; }
    else { AliInfo(Form("Index %d larger than 15, do nothing\n",i)); return 0.;}
  }
  Float_t* GetMisalTransShiftArray() {return fMisalTransShift; }

  void     SetMisalTransShift(const Int_t i, const Float_t shift) {
    if(i < 15 ){fMisalTransShift[i] = shift; }
    else { AliInfo(Form("Index %d larger than 15, do nothing\n",i));}
  }
  void     SetMisalTransShiftArray(Float_t * misal) 
  { for(Int_t i = 0; i < 15; i++)fMisalTransShift[i] = misal[i]; }

  Float_t  GetMisalRotShift(const Int_t i) const {
    if(i < 15 ){return fMisalRotShift[i]; }
    else { AliInfo(Form("Index %d larger than 15, do nothing\n",i)); return 0.;}
  }
  Float_t* GetMisalRotShiftArray() {return fMisalRotShift; }
  
  void     SetMisalRotShift(const Int_t i, const Float_t shift) {
    if(i < 15 ){fMisalRotShift[i] = shift; }
    else { AliInfo(Form("Index %d larger than 15, do nothing\n",i));}
  }
  void     SetMisalRotShiftArray(Float_t * misal) 
  { for(Int_t i = 0; i < 15; i++)fMisalRotShift[i] = misal[i]; }
  
  Int_t    GetParticleType() const         {return  fParticleType    ;}
  void     SetParticleType(Int_t particle) {fParticleType = particle ;}
  
  Int_t    GetPositionAlgorithm() const    {return fPosAlgo;}
  void     SetPositionAlgorithm(Int_t alg) {fPosAlgo = alg ;}
  
  Float_t  GetW0() const     {return fW0;}
  void     SetW0(Float_t w0) {fW0  = w0 ;}

  //Non Linearity
  
  Float_t CorrectClusterEnergyLinearity(AliVCluster* clu);
  
  Float_t  GetNonLinearityParam(const Int_t i) const {
    if(i < 6 ){return fNonLinearityParams[i]; }
    else { AliInfo(Form("Index %d larger than 6, do nothing\n",i)); return 0.;}
  }
  void     SetNonLinearityParam(const Int_t i, const Float_t param) {
    if(i < 6 ){fNonLinearityParams[i] = param; }
    else { AliInfo(Form("Index %d larger than 6, do nothing\n",i));}
  }
  
  Int_t GetNonLinearityFunction() const    {return fNonLinearityFunction;}
  void  SetNonLinearityFunction(Int_t fun) {fNonLinearityFunction = fun ;}
  
  void Print(const Option_t*) const;
  
  //Recalibration
  void RecalibrateClusterEnergy(AliEMCALGeometry* geom, AliVCluster* cluster, AliVCaloCells * cells);

  Bool_t IsRecalibrationOn()  const { return fRecalibration ; }
  void SwitchOnRecalibration()    {fRecalibration = kTRUE ; InitEMCALRecalibrationFactors();}
  void SwitchOffRecalibration()   {fRecalibration = kFALSE ; }
  
  void InitEMCALRecalibrationFactors() ;
  
  Float_t GetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow) const { 
    if(fEMCALRecalibrationFactors) return (Float_t) ((TH2F*)fEMCALRecalibrationFactors->At(iSM))->GetBinContent(iCol,iRow); 
    else return 1;}
	
  void SetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) { 
    if(!fEMCALRecalibrationFactors) InitEMCALRecalibrationFactors();
    ((TH2F*)fEMCALRecalibrationFactors->At(iSM))->SetBinContent(iCol,iRow,c);}  
  
  TH2F * GetEMCALChannelRecalibrationFactors(Int_t iSM) const {return (TH2F*)fEMCALRecalibrationFactors->At(iSM);}	
  void SetEMCALChannelRecalibrationFactors(TObjArray *map)      {fEMCALRecalibrationFactors = map;}
  void SetEMCALChannelRecalibrationFactors(Int_t iSM , TH2F* h) {fEMCALRecalibrationFactors->AddAt(h,iSM);}

  //Modules fiducial region, remove clusters in borders
  Bool_t CheckCellFiducialRegion(AliEMCALGeometry* geom, AliVCluster* cluster, AliVCaloCells* cells) ;
  void   SetNumberOfCellsFromEMCALBorder(Int_t n) {fNCellsFromEMCALBorder = n; }
  Int_t  GetNumberOfCellsFromEMCALBorder() const  {return fNCellsFromEMCALBorder; }
    
  void   SwitchOnNoFiducialBorderInEMCALEta0()  {fNoEMCALBorderAtEta0 = kTRUE; }
  void   SwitchOffNoFiducialBorderInEMCALEta0() {fNoEMCALBorderAtEta0 = kFALSE; }
  Bool_t IsEMCALNoBorderAtEta0()                {return fNoEMCALBorderAtEta0;}
  
  // Bad channels
  Bool_t IsBadChannelsRemovalSwitchedOn()  const { return fRemoveBadChannels ; }
  void SwitchOnBadChannelsRemoval ()  {fRemoveBadChannels = kTRUE  ; InitEMCALBadChannelStatusMap();}
  void SwitchOffBadChannelsRemoval()  {fRemoveBadChannels = kFALSE ; }
	
  void InitEMCALBadChannelStatusMap() ;
	
  Int_t GetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow) const { 
    if(fEMCALBadChannelMap) return (Int_t) ((TH2I*)fEMCALBadChannelMap->At(iSM))->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) { 
    if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap() ;
    ((TH2I*)fEMCALBadChannelMap->At(iSM))->SetBinContent(iCol,iRow,c);}
	
  TH2I * GetEMCALChannelStatusMap(Int_t iSM) const {return (TH2I*)fEMCALBadChannelMap->At(iSM);}
  void   SetEMCALChannelStatusMap(TObjArray *map)  {fEMCALBadChannelMap = map;}
	
  Bool_t ClusterContainsBadChannel(AliEMCALGeometry* geom, UShort_t* cellList, Int_t nCells);
 
  //Recalculate other cluster parameters
  void RecalculateClusterPID(AliVCluster * cluster);
  AliEMCALPIDUtils * GetPIDUtils() { return fPIDUtils;}

  void RecalculateClusterShowerShapeParameters(AliEMCALGeometry * geom, AliVCaloCells* cells, AliVCluster * cluster);


private:
  
  Float_t fMisalTransShift[15];   // Shift parameters
  Float_t fMisalRotShift[15];     // Shift parameters
  Int_t   fNonLinearityFunction;  // Non linearity function choice
  Float_t fNonLinearityParams[6]; // Parameters for the non linearity function
  Int_t   fParticleType;          // Particle type for depth calculation
  Int_t   fPosAlgo;               // Position recalculation algorithm
  Float_t fW0;                    // Weight0
  
  Bool_t     fRecalibration;             // Switch on or off the recalibration
  TObjArray* fEMCALRecalibrationFactors; // Array of histograms with map of recalibration factors, EMCAL
  Bool_t     fRemoveBadChannels;         // Check the channel status provided and remove clusters with bad channels
  TObjArray* fEMCALBadChannelMap;        // Array of histograms with map of bad channels, EMCAL
  Int_t      fNCellsFromEMCALBorder;     // Number of cells from EMCAL border the cell with maximum amplitude has to be.
  Bool_t     fNoEMCALBorderAtEta0;       // Do fiducial cut in EMCAL region eta = 0?

  AliEMCALPIDUtils * fPIDUtils;               // Recalculate PID parameters
  
  ClassDef(AliEMCALRecoUtils, 5)
  
};

#endif // ALIEMCALRECOUTILS_H
Commit	Line	Data
d9b3567c	1	#ifndef ALIEMCALRECOUTILS_H
	2	#define ALIEMCALRECOUTILS_H
	3
	4	/* $Id: AliEMCALRecoUtils.h 33808 2009-07-15 09:48:08Z gconesab $ */
	5
	6	///////////////////////////////////////////////////////////////////////////////
	7	//
	8	// Class AliEMCALRecoUtils
	9	// Some utilities to recalculate the cluster position or energy linearity
	10	//
	11	//
	12	// Author: Gustavo Conesa (LPSC- Grenoble)
	13	///////////////////////////////////////////////////////////////////////////////
	14
	15	//Root includes
	16	#include "TNamed.h"
094786cc	17	#include "TMath.h"
094786cc	18	#include "TObjArray.h"
17688f67	19	#include "TH2F.h"
d9b3567c	20
	21	//AliRoot includes
	22	class AliVCluster;
	23	class AliVCaloCells;
	24	#include "AliLog.h"
094786cc	25	class AliEMCALGeometry;
83bfd77a	26	class AliEMCALPIDUtils;
d9b3567c	27
	28	class AliEMCALRecoUtils : public TNamed {
	29
	30	public:
	31
	32	AliEMCALRecoUtils();
	33	AliEMCALRecoUtils(const AliEMCALRecoUtils&);
	34	AliEMCALRecoUtils& operator=(const AliEMCALRecoUtils&);
094786cc	35	virtual ~AliEMCALRecoUtils() ;
d9b3567c	36
d9b3567c	37	enum NonlinearityFunctions{kPi0MC=0,kPi0GammaGamma=1,kPi0GammaConversion=2,kNoCorrection=3};
fd6df01c	38	enum PositionAlgorithms{kUnchanged=-1,kPosTowerIndex=0, kPosTowerGlobal=1};
094786cc	39	enum ParticleType{kPhoton=0, kElectron=1,kHadron =2, kUnknown=-1};
d9b3567c	40
d9b3567c	41	//Position recalculation
094786cc	42	void RecalculateClusterPosition(AliEMCALGeometry geom, AliVCaloCells cells, AliVCluster* clu);
	43	void RecalculateClusterPositionFromTowerIndex (AliEMCALGeometry geom, AliVCaloCells cells, AliVCluster* clu);
	44	void RecalculateClusterPositionFromTowerGlobal(AliEMCALGeometry geom, AliVCaloCells cells, AliVCluster* clu);
	45
	46	Float_t GetCellWeight(const Float_t eCell, const Float_t eCluster) const { return TMath::Max( 0., fW0 + TMath::Log( eCell / eCluster ));}
	47
	48	Float_t GetDepth(const Float_t eCluster, const Int_t iParticle, const Int_t iSM) const ;
	49
	50	void GetMaxEnergyCell(AliEMCALGeometry geom, AliVCaloCells cells, AliVCluster* clu,
d9b3567c	51	Int_t & absId, Int_t& iSupMod, Int_t& ieta, Int_t& iphi);
d9b3567c	52
2a71e873	53	Float_t GetMisalTransShift(const Int_t i) const {
2a71e873	54	if(i < 15 ){return fMisalTransShift[i]; }
d9b3567c	55	else { AliInfo(Form("Index %d larger than 15, do nothing\n",i)); return 0.;}
d9b3567c	56	}
094786cc	57	Float_t* GetMisalTransShiftArray() {return fMisalTransShift; }
d9b3567c	58
2a71e873	59	void SetMisalTransShift(const Int_t i, const Float_t shift) {
2a71e873	60	if(i < 15 ){fMisalTransShift[i] = shift; }
d9b3567c	61	else { AliInfo(Form("Index %d larger than 15, do nothing\n",i));}
d9b3567c	62	}
2a71e873	63	void SetMisalTransShiftArray(Float_t * misal)
2a71e873	64	{ for(Int_t i = 0; i < 15; i++)fMisalTransShift[i] = misal[i]; }
d9b3567c	65
2a71e873	66	Float_t GetMisalRotShift(const Int_t i) const {
	67	if(i < 15 ){return fMisalRotShift[i]; }
	68	else { AliInfo(Form("Index %d larger than 15, do nothing\n",i)); return 0.;}
	69	}
094786cc	70	Float_t* GetMisalRotShiftArray() {return fMisalRotShift; }
2a71e873	71
	72	void SetMisalRotShift(const Int_t i, const Float_t shift) {
	73	if(i < 15 ){fMisalRotShift[i] = shift; }
	74	else { AliInfo(Form("Index %d larger than 15, do nothing\n",i));}
	75	}
	76	void SetMisalRotShiftArray(Float_t * misal)
	77	{ for(Int_t i = 0; i < 15; i++)fMisalRotShift[i] = misal[i]; }
	78
094786cc	79	Int_t GetParticleType() const {return fParticleType ;}
094786cc	80	void SetParticleType(Int_t particle) {fParticleType = particle ;}
2a71e873	81
094786cc	82	Int_t GetPositionAlgorithm() const {return fPosAlgo;}
094786cc	83	void SetPositionAlgorithm(Int_t alg) {fPosAlgo = alg ;}
2a71e873	84
094786cc	85	Float_t GetW0() const {return fW0;}
	86	void SetW0(Float_t w0) {fW0 = w0 ;}
	87
d9b3567c	88	//Non Linearity
	89
	90	Float_t CorrectClusterEnergyLinearity(AliVCluster* clu);
	91
	92	Float_t GetNonLinearityParam(const Int_t i) const {
	93	if(i < 6 ){return fNonLinearityParams[i]; }
	94	else { AliInfo(Form("Index %d larger than 6, do nothing\n",i)); return 0.;}
	95	}
	96	void SetNonLinearityParam(const Int_t i, const Float_t param) {
	97	if(i < 6 ){fNonLinearityParams[i] = param; }
	98	else { AliInfo(Form("Index %d larger than 6, do nothing\n",i));}
	99	}
	100
094786cc	101	Int_t GetNonLinearityFunction() const {return fNonLinearityFunction;}
d9b3567c	102	void SetNonLinearityFunction(Int_t fun) {fNonLinearityFunction = fun ;}
	103
	104	void Print(const Option_t*) const;
	105
094786cc	106	//Recalibration
	107	void RecalibrateClusterEnergy(AliEMCALGeometry* geom, AliVCluster* cluster, AliVCaloCells * cells);
	108
	109	Bool_t IsRecalibrationOn() const { return fRecalibration ; }
	110	void SwitchOnRecalibration() {fRecalibration = kTRUE ; InitEMCALRecalibrationFactors();}
	111	void SwitchOffRecalibration() {fRecalibration = kFALSE ; }
	112
	113	void InitEMCALRecalibrationFactors() ;
	114
	115	Float_t GetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow) const {
	116	if(fEMCALRecalibrationFactors) return (Float_t) ((TH2F*)fEMCALRecalibrationFactors->At(iSM))->GetBinContent(iCol,iRow);
	117	else return 1;}
	118
	119	void SetEMCALChannelRecalibrationFactor(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) {
	120	if(!fEMCALRecalibrationFactors) InitEMCALRecalibrationFactors();
	121	((TH2F*)fEMCALRecalibrationFactors->At(iSM))->SetBinContent(iCol,iRow,c);}
	122
	123	TH2F * GetEMCALChannelRecalibrationFactors(Int_t iSM) const {return (TH2F*)fEMCALRecalibrationFactors->At(iSM);}
	124	void SetEMCALChannelRecalibrationFactors(TObjArray *map) {fEMCALRecalibrationFactors = map;}
	125	void SetEMCALChannelRecalibrationFactors(Int_t iSM , TH2F* h) {fEMCALRecalibrationFactors->AddAt(h,iSM);}
	126
fd6df01c	127	//Modules fiducial region, remove clusters in borders
	128	Bool_t CheckCellFiducialRegion(AliEMCALGeometry* geom, AliVCluster* cluster, AliVCaloCells* cells) ;
	129	void SetNumberOfCellsFromEMCALBorder(Int_t n) {fNCellsFromEMCALBorder = n; }
	130	Int_t GetNumberOfCellsFromEMCALBorder() const {return fNCellsFromEMCALBorder; }
	131
	132	void SwitchOnNoFiducialBorderInEMCALEta0() {fNoEMCALBorderAtEta0 = kTRUE; }
	133	void SwitchOffNoFiducialBorderInEMCALEta0() {fNoEMCALBorderAtEta0 = kFALSE; }
	134	Bool_t IsEMCALNoBorderAtEta0() {return fNoEMCALBorderAtEta0;}
	135
	136	// Bad channels
	137	Bool_t IsBadChannelsRemovalSwitchedOn() const { return fRemoveBadChannels ; }
	138	void SwitchOnBadChannelsRemoval () {fRemoveBadChannels = kTRUE ; InitEMCALBadChannelStatusMap();}
	139	void SwitchOffBadChannelsRemoval() {fRemoveBadChannels = kFALSE ; }
	140
	141	void InitEMCALBadChannelStatusMap() ;
	142
	143	Int_t GetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow) const {
	144	if(fEMCALBadChannelMap) return (Int_t) ((TH2I*)fEMCALBadChannelMap->At(iSM))->GetBinContent(iCol,iRow);
	145	else return 0;}//Channel is ok by default
	146
	147	void SetEMCALChannelStatus(Int_t iSM , Int_t iCol, Int_t iRow, Double_t c = 1) {
	148	if(!fEMCALBadChannelMap)InitEMCALBadChannelStatusMap() ;
	149	((TH2I*)fEMCALBadChannelMap->At(iSM))->SetBinContent(iCol,iRow,c);}
	150
	151	TH2I * GetEMCALChannelStatusMap(Int_t iSM) const {return (TH2I*)fEMCALBadChannelMap->At(iSM);}
	152	void SetEMCALChannelStatusMap(TObjArray *map) {fEMCALBadChannelMap = map;}
	153
	154	Bool_t ClusterContainsBadChannel(AliEMCALGeometry* geom, UShort_t* cellList, Int_t nCells);
	155
83bfd77a	156	//Recalculate other cluster parameters
	157	void RecalculateClusterPID(AliVCluster * cluster);
	158	AliEMCALPIDUtils * GetPIDUtils() { return fPIDUtils;}
	159
	160	void RecalculateClusterShowerShapeParameters(AliEMCALGeometry * geom, AliVCaloCells* cells, AliVCluster * cluster);
	161
fd6df01c	162
d9b3567c	163	private:
d9b3567c	164
2a71e873	165	Float_t fMisalTransShift[15]; // Shift parameters
2a71e873	166	Float_t fMisalRotShift[15]; // Shift parameters
d9b3567c	167	Int_t fNonLinearityFunction; // Non linearity function choice
d9b3567c	168	Float_t fNonLinearityParams[6]; // Parameters for the non linearity function
094786cc	169	Int_t fParticleType; // Particle type for depth calculation
	170	Int_t fPosAlgo; // Position recalculation algorithm
	171	Float_t fW0; // Weight0
fd6df01c	172
	173	Bool_t fRecalibration; // Switch on or off the recalibration
	174	TObjArray* fEMCALRecalibrationFactors; // Array of histograms with map of recalibration factors, EMCAL
	175	Bool_t fRemoveBadChannels; // Check the channel status provided and remove clusters with bad channels
	176	TObjArray* fEMCALBadChannelMap; // Array of histograms with map of bad channels, EMCAL
	177	Int_t fNCellsFromEMCALBorder; // Number of cells from EMCAL border the cell with maximum amplitude has to be.
	178	Bool_t fNoEMCALBorderAtEta0; // Do fiducial cut in EMCAL region eta = 0?
d9b3567c	179
83bfd77a	180	AliEMCALPIDUtils * fPIDUtils; // Recalculate PID parameters
	181
	182	ClassDef(AliEMCALRecoUtils, 5)
d9b3567c	183
	184	};
	185
	186	#endif // ALIEMCALRECOUTILS_H
	187
	188