[u/mrichter/AliRoot.git] / PWG4 / CaloCalib / AliAnalysisTaskEMCALPi0CalibSelection.h

#ifndef ALIANALYSISTASKEMCALPI0CALIBSELECTION_H
#define ALIANALYSISTASKEMCALPI0CALIBSELECTION_H

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

//---------------------------------------------------------------------------// 
// Fill histograms with two-cluster invariant mass                           //
// using calibration coefficients of the previous iteration.                 //
//---------------------------------------------------------------------------//

// Root includes
class TH1F;
#include "TH2I.h"
#include "TObjArray.h"

// AliRoot includes
#include "AliAnalysisTaskSE.h"
class AliEMCALGeometry;
//class AliEMCALCalibData ;
#include "AliEMCALGeoParams.h"
class AliEMCALRecoUtils;

class AliAnalysisTaskEMCALPi0CalibSelection : public AliAnalysisTaskSE
{
public:

  AliAnalysisTaskEMCALPi0CalibSelection(const char* name);
  virtual ~AliAnalysisTaskEMCALPi0CalibSelection();

private:
  
  AliAnalysisTaskEMCALPi0CalibSelection(const AliAnalysisTaskEMCALPi0CalibSelection&); 
  AliAnalysisTaskEMCALPi0CalibSelection& operator=(const AliAnalysisTaskEMCALPi0CalibSelection&); 
  
public:
  
  // Implementation of interface methods
  virtual void UserCreateOutputObjects();
  virtual void UserExec(Option_t * opt);
  virtual void LocalInit() ;
  
  void    SetAsymmetryCut(Float_t asy)      {fAsyCut      = asy ;}
  void    SetClusterMinEnergy(Float_t emin) {fEmin        = emin;}
  void    SetClusterMaxEnergy(Float_t emax) {fEmax        = emax;}
  void    SetClusterMinNCells(Int_t n)      {fMinNCells   = n   ;}
  void    SetNCellsGroup(Int_t n)           {fGroupNCells = n   ;}
  void    SetLogWeight(Float_t w)           {fLogWeight   = w   ;}
  	
  void    SwitchOnSameSM()                  {fSameSM = kTRUE  ; }
  void    SwitchOffSameSM()                 {fSameSM = kFALSE ; }
  
  //Geometry setters
  void    SetGeometryName(TString name)                  { fEMCALGeoName = name   ; }
  TString GeometryName() const                           { return fEMCALGeoName   ; }
  void    SwitchOnLoadOwnGeometryMatrices()              { fLoadMatrices = kTRUE  ; }
  void    SwitchOffLoadOwnGeometryMatrices()             { fLoadMatrices = kFALSE ; }
  void    SetGeometryMatrixInSM(TGeoHMatrix* m, Int_t i) { fMatrix[i]    = m      ; }

  // Cluster recalculation
  void    SwitchOnClusterCorrection()               {fCorrectClusters = kTRUE  ; }
  void    SwitchOffClusterCorrection()              {fCorrectClusters = kFALSE ; }
  void    SetEMCALRecoUtils(AliEMCALRecoUtils * ru) {fRecoUtils = ru           ; }
  AliEMCALRecoUtils* GetEMCALRecoUtils()    const   {return fRecoUtils         ; }
  
  void    SetInvariantMassHistoBinRange(Int_t nBins, Float_t minbin, Float_t maxbin){
                                        fNbins = nBins; fMinBin = minbin; fMaxBin = maxbin; }
	  
  void    GetMaxEnergyCellPosAndClusterPos(AliVCaloCells* cells, AliVCluster* clu, Int_t& iSM, Int_t& ieta, Int_t& iphi);

  // Mask clusters
  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;
  
  void    UseFilteredEventAsInput() {fFilteredInput = kTRUE ;}
  void    UseNormalEventAsInput()   {fFilteredInput = kFALSE;}

  void    PrintInfo();
  
private:

  AliEMCALGeometry * fEMCALGeo;  //! EMCAL geometry
	
  Float_t fEmin;           // min. cluster energy
  Float_t fEmax;           // max. cluster energy
  Float_t fAsyCut;         // Asymmetry cut
  Int_t   fMinNCells;      // min. ncells in cluster
  Int_t   fGroupNCells;    // group n cells
  Float_t fLogWeight;      // log weight used in cluster recalibration
  Bool_t  fSameSM;         // Combine clusters in channels on same SM
  Bool_t  fFilteredInput;  // Read input produced with filter.
  Bool_t  fCorrectClusters;// Correct clusters energy, position etc.
  TString fEMCALGeoName;   // Name of geometry to use.

  AliEMCALRecoUtils * fRecoUtils;  // Access to reconstruction utilities
  
  //Output histograms	
  Int_t   fNbins;  // N       mass bins of invariant mass histograms
  Float_t fMinBin; // Minimum mass bins of invariant mass histograms
  Float_t fMaxBin; // Maximum mass bins of invariant mass histograms

  TList*  fOutputContainer; //!histogram container
  TH1F*   fHmpi0[AliEMCALGeoParams::fgkEMCALModules][AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows];//! two-cluster inv. mass assigned to each cell.

  TH2F*   fHmgg;                                                           //! two-cluster inv.mass vs pt of pair
  TH2F*   fHmggDifferentSM;                                                //! two-cluster inv.mass vs pt of pair, each cluster in different SM
  TH2F*   fHmggSM[AliEMCALGeoParams::fgkEMCALModules];                     //! two-cluster inv.mass per SM
  TH2F*   fHmggPairSameSectorSM[AliEMCALGeoParams::fgkEMCALModules/2];     //! two-cluster inv.mass per Pair
  TH2F*   fHmggPairSameSideSM  [AliEMCALGeoParams::fgkEMCALModules-2];     //! two-cluster inv.mass per Pair
  
  TH2F*   fHmggMaskFrame;                                                  //! two-cluster inv.mass vs pt of pair, mask clusters facing frames
  TH2F*   fHmggDifferentSMMaskFrame;                                       //! two-cluster inv.mass vs pt of pair, each cluster in different SM,mask clusters facing frames
  TH2F*   fHmggSMMaskFrame[AliEMCALGeoParams::fgkEMCALModules];            //! two-cluster inv.mass per SM, mask clusters facing frames
  TH2F*   fHmggPairSameSectorSMMaskFrame[AliEMCALGeoParams::fgkEMCALModules/2]; //! two-cluster inv.mass per Pair, mask clusters facing frames
  TH2F*   fHmggPairSameSideSMMaskFrame  [AliEMCALGeoParams::fgkEMCALModules-2]; //! two-cluster inv.mass per Pair, mask clusters facing frames

  TH2F*   fHOpeningAngle;                                                  //! two-cluster opening angle vs pt of pair, with mass close to pi0
  TH2F*   fHOpeningAngleDifferentSM;                                       //! two-cluster opening angle vs pt of pair, each cluster in different SM, with mass close to pi0
  TH2F*   fHOpeningAngleSM[AliEMCALGeoParams::fgkEMCALModules];            //! two-cluster opening angle vs pt per SM,with mass close to pi0
  TH2F*   fHOpeningAnglePairSM[AliEMCALGeoParams::fgkEMCALModules];        //! two-cluster opening angle vs pt per Pair,with mass close to pi0

  TH2F*   fHIncidentAngle;                                                 //! cluster incident angle vs pt of pair, with mass close to pi0
  TH2F*   fHIncidentAngleDifferentSM;                                      //! cluster incident angle vs pt of pair, each cluster in different SM, with mass close to pi0
  TH2F*   fHIncidentAngleSM[AliEMCALGeoParams::fgkEMCALModules];           //! cluster incident angle vs pt per SM,with mass close to pi0
  TH2F*   fHIncidentAnglePairSM[AliEMCALGeoParams::fgkEMCALModules];       //! cluster incident angle vs pt per Pair,with mass close to pi0
  
  TH2F*   fHAsymmetry;                                                     //! two-cluster asymmetry vs pt of pair, with mass close to pi0
  TH2F*   fHAsymmetryDifferentSM;                                          //! two-cluster asymmetry vs pt of pair, each cluster in different SM, with mass close to pi0
  TH2F*   fHAsymmetrySM[AliEMCALGeoParams::fgkEMCALModules];               //! two-cluster asymmetry vs pt per SM,with mass close to pi0
  TH2F*   fHAsymmetryPairSM[AliEMCALGeoParams::fgkEMCALModules];           //! two-cluster asymmetry vs pt per Pair,with mass close to pi0
  
  TH2F*   fhTowerDecayPhotonHit[AliEMCALGeoParams::fgkEMCALModules] ;      //! Cells ordered in column/row for different module, number of times a decay photon hits
  TH2F*   fhTowerDecayPhotonEnergy[AliEMCALGeoParams::fgkEMCALModules] ;   //! Cells ordered in column/row for different module, accumulated energy in the tower by decay photons.
  TH2F*   fhTowerDecayPhotonAsymmetry[AliEMCALGeoParams::fgkEMCALModules] ;//! Cells ordered in column/row for different module, accumulated asymmetry in the tower by decay photons.
  TH2F*   fhTowerDecayPhotonHitMaskFrame[AliEMCALGeoParams::fgkEMCALModules] ;//! Cells ordered in column/row for different module, number of times a decay photon hits

  TH1I*   fhNEvents;     //! Number of events counter histogram
  TList * fCuts ;        //! List with analysis cuts
  Bool_t  fLoadMatrices; //  Matrices set from configuration, not get from geometry.root or from ESDs/AODs
  TGeoHMatrix * fMatrix[AliEMCALGeoParams::fgkEMCALModules];    // Geometry matrices with alignments
  
  Int_t   fNMaskCellColumns;  // Number of masked columns
  Int_t*  fMaskCellColumns;   //[fNMaskCellColumns] list of masked cell collumn
   
  ClassDef(AliAnalysisTaskEMCALPi0CalibSelection,13);

};

#endif //ALIANALYSISTASKEMCALPI0CALIBSELECTION_H
Commit	Line	Data
375cec9b	1	#ifndef ALIANALYSISTASKEMCALPI0CALIBSELECTION_H
	2	#define ALIANALYSISTASKEMCALPI0CALIBSELECTION_H
	3
	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
	7	//---------------------------------------------------------------------------//
	8	// Fill histograms with two-cluster invariant mass //
	9	// using calibration coefficients of the previous iteration. //
	10	//---------------------------------------------------------------------------//
	11
	12	// Root includes
	13	class TH1F;
6eb2a715	14	#include "TH2I.h"
6eb2a715	15	#include "TObjArray.h"
375cec9b	16
	17	// AliRoot includes
	18	#include "AliAnalysisTaskSE.h"
	19	class AliEMCALGeometry;
6eb2a715	20	//class AliEMCALCalibData ;
375cec9b	21	#include "AliEMCALGeoParams.h"
9584c261	22	class AliEMCALRecoUtils;
375cec9b	23
	24	class AliAnalysisTaskEMCALPi0CalibSelection : public AliAnalysisTaskSE
	25	{
	26	public:
	27
375cec9b	28	AliAnalysisTaskEMCALPi0CalibSelection(const char* name);
375cec9b	29	virtual ~AliAnalysisTaskEMCALPi0CalibSelection();
375cec9b	30
9584c261	31	private:
	32
	33	AliAnalysisTaskEMCALPi0CalibSelection(const AliAnalysisTaskEMCALPi0CalibSelection&);
	34	AliAnalysisTaskEMCALPi0CalibSelection& operator=(const AliAnalysisTaskEMCALPi0CalibSelection&);
	35
	36	public:
	37
375cec9b	38	// Implementation of interface methods
	39	virtual void UserCreateOutputObjects();
	40	virtual void UserExec(Option_t * opt);
6eb2a715	41	virtual void LocalInit() ;
9fdaff9a	42
42b19289	43	void SetAsymmetryCut(Float_t asy) {fAsyCut = asy ;}
	44	void SetClusterMinEnergy(Float_t emin) {fEmin = emin;}
	45	void SetClusterMaxEnergy(Float_t emax) {fEmax = emax;}
	46	void SetClusterMinNCells(Int_t n) {fMinNCells = n ;}
	47	void SetNCellsGroup(Int_t n) {fGroupNCells = n ;}
	48	void SetLogWeight(Float_t w) {fLogWeight = w ;}
	49
	50	void SwitchOnSameSM() {fSameSM = kTRUE ; }
	51	void SwitchOffSameSM() {fSameSM = kFALSE ; }
9fdaff9a	52
42b19289	53	//Geometry setters
	54	void SetGeometryName(TString name) { fEMCALGeoName = name ; }
	55	TString GeometryName() const { return fEMCALGeoName ; }
	56	void SwitchOnLoadOwnGeometryMatrices() { fLoadMatrices = kTRUE ; }
	57	void SwitchOffLoadOwnGeometryMatrices() { fLoadMatrices = kFALSE ; }
	58	void SetGeometryMatrixInSM(TGeoHMatrix* m, Int_t i) { fMatrix[i] = m ; }
	59
	60	// Cluster recalculation
	61	void SwitchOnClusterCorrection() {fCorrectClusters = kTRUE ; }
	62	void SwitchOffClusterCorrection() {fCorrectClusters = kFALSE ; }
	63	void SetEMCALRecoUtils(AliEMCALRecoUtils * ru) {fRecoUtils = ru ; }
	64	AliEMCALRecoUtils* GetEMCALRecoUtils() const {return fRecoUtils ; }
2dfb1428	65
42b19289	66	void SetInvariantMassHistoBinRange(Int_t nBins, Float_t minbin, Float_t maxbin){
42b19289	67	fNbins = nBins; fMinBin = minbin; fMaxBin = maxbin; }
9584c261	68
42b19289	69	void GetMaxEnergyCellPosAndClusterPos(AliVCaloCells* cells, AliVCluster* clu, Int_t& iSM, Int_t& ieta, Int_t& iphi);
	70
	71	// Mask clusters
	72	void SetNMaskCellColumns(Int_t n) {
	73	if(n > fNMaskCellColumns){ delete [] fMaskCellColumns ; fMaskCellColumns = new Int_t[n] ; }
	74	fNMaskCellColumns = n ; }
	75	void SetMaskCellColumn(Int_t ipos, Int_t icol) { if(ipos < fNMaskCellColumns) fMaskCellColumns[ipos] = icol ;
	76	else printf("Not set, position larger than allocated set size first") ; }
	77	Bool_t MaskFrameCluster(const Int_t iSM, const Int_t ieta) const;
3b13c34c	78
42b19289	79	void UseFilteredEventAsInput() {fFilteredInput = kTRUE ;}
	80	void UseNormalEventAsInput() {fFilteredInput = kFALSE;}
	81
	82	void PrintInfo();
5ef94e1b	83
375cec9b	84	private:
375cec9b	85
cf028690	86	AliEMCALGeometry * fEMCALGeo; //! EMCAL geometry
375cec9b	87
247abff4	88	Float_t fEmin; // min. cluster energy
	89	Float_t fEmax; // max. cluster energy
	90	Float_t fAsyCut; // Asymmetry cut
	91	Int_t fMinNCells; // min. ncells in cluster
	92	Int_t fGroupNCells; // group n cells
	93	Float_t fLogWeight; // log weight used in cluster recalibration
	94	Bool_t fSameSM; // Combine clusters in channels on same SM
247abff4	95	Bool_t fFilteredInput; // Read input produced with filter.
	96	Bool_t fCorrectClusters;// Correct clusters energy, position etc.
	97	TString fEMCALGeoName; // Name of geometry to use.
	98
9584c261	99	AliEMCALRecoUtils * fRecoUtils; // Access to reconstruction utilities
9584c261	100
375cec9b	101	//Output histograms
6eb2a715	102	Int_t fNbins; // N mass bins of invariant mass histograms
	103	Float_t fMinBin; // Minimum mass bins of invariant mass histograms
	104	Float_t fMaxBin; // Maximum mass bins of invariant mass histograms
	105
cf028690	106	TList* fOutputContainer; //!histogram container
cf028690	107	TH1F* fHmpi0[AliEMCALGeoParams::fgkEMCALModules][AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows];//! two-cluster inv. mass assigned to each cell.
9584c261	108
42b19289	109	TH2F* fHmgg; //! two-cluster inv.mass vs pt of pair
	110	TH2F* fHmggDifferentSM; //! two-cluster inv.mass vs pt of pair, each cluster in different SM
	111	TH2F* fHmggSM[AliEMCALGeoParams::fgkEMCALModules]; //! two-cluster inv.mass per SM
	112	TH2F* fHmggPairSameSectorSM[AliEMCALGeoParams::fgkEMCALModules/2]; //! two-cluster inv.mass per Pair
	113	TH2F* fHmggPairSameSideSM [AliEMCALGeoParams::fgkEMCALModules-2]; //! two-cluster inv.mass per Pair
44cf05d7	114
42b19289	115	TH2F* fHmggMaskFrame; //! two-cluster inv.mass vs pt of pair, mask clusters facing frames
	116	TH2F* fHmggDifferentSMMaskFrame; //! two-cluster inv.mass vs pt of pair, each cluster in different SM,mask clusters facing frames
	117	TH2F* fHmggSMMaskFrame[AliEMCALGeoParams::fgkEMCALModules]; //! two-cluster inv.mass per SM, mask clusters facing frames
	118	TH2F* fHmggPairSameSectorSMMaskFrame[AliEMCALGeoParams::fgkEMCALModules/2]; //! two-cluster inv.mass per Pair, mask clusters facing frames
	119	TH2F* fHmggPairSameSideSMMaskFrame [AliEMCALGeoParams::fgkEMCALModules-2]; //! two-cluster inv.mass per Pair, mask clusters facing frames
	120
	121	TH2F* fHOpeningAngle; //! two-cluster opening angle vs pt of pair, with mass close to pi0
	122	TH2F* fHOpeningAngleDifferentSM; //! two-cluster opening angle vs pt of pair, each cluster in different SM, with mass close to pi0
	123	TH2F* fHOpeningAngleSM[AliEMCALGeoParams::fgkEMCALModules]; //! two-cluster opening angle vs pt per SM,with mass close to pi0
	124	TH2F* fHOpeningAnglePairSM[AliEMCALGeoParams::fgkEMCALModules]; //! two-cluster opening angle vs pt per Pair,with mass close to pi0
	125
	126	TH2F* fHIncidentAngle; //! cluster incident angle vs pt of pair, with mass close to pi0
	127	TH2F* fHIncidentAngleDifferentSM; //! cluster incident angle vs pt of pair, each cluster in different SM, with mass close to pi0
	128	TH2F* fHIncidentAngleSM[AliEMCALGeoParams::fgkEMCALModules]; //! cluster incident angle vs pt per SM,with mass close to pi0
	129	TH2F* fHIncidentAnglePairSM[AliEMCALGeoParams::fgkEMCALModules]; //! cluster incident angle vs pt per Pair,with mass close to pi0
44cf05d7	130
42b19289	131	TH2F* fHAsymmetry; //! two-cluster asymmetry vs pt of pair, with mass close to pi0
	132	TH2F* fHAsymmetryDifferentSM; //! two-cluster asymmetry vs pt of pair, each cluster in different SM, with mass close to pi0
	133	TH2F* fHAsymmetrySM[AliEMCALGeoParams::fgkEMCALModules]; //! two-cluster asymmetry vs pt per SM,with mass close to pi0
	134	TH2F* fHAsymmetryPairSM[AliEMCALGeoParams::fgkEMCALModules]; //! two-cluster asymmetry vs pt per Pair,with mass close to pi0
	135
	136	TH2F* fhTowerDecayPhotonHit[AliEMCALGeoParams::fgkEMCALModules] ; //! Cells ordered in column/row for different module, number of times a decay photon hits
	137	TH2F* fhTowerDecayPhotonEnergy[AliEMCALGeoParams::fgkEMCALModules] ; //! Cells ordered in column/row for different module, accumulated energy in the tower by decay photons.
	138	TH2F* fhTowerDecayPhotonAsymmetry[AliEMCALGeoParams::fgkEMCALModules] ;//! Cells ordered in column/row for different module, accumulated asymmetry in the tower by decay photons.
	139	TH2F* fhTowerDecayPhotonHitMaskFrame[AliEMCALGeoParams::fgkEMCALModules] ;//! Cells ordered in column/row for different module, number of times a decay photon hits
	140
	141	TH1I* fhNEvents; //! Number of events counter histogram
	142	TList * fCuts ; //! List with analysis cuts
	143	Bool_t fLoadMatrices; // Matrices set from configuration, not get from geometry.root or from ESDs/AODs
44cf05d7	144	TGeoHMatrix * fMatrix[AliEMCALGeoParams::fgkEMCALModules]; // Geometry matrices with alignments
3b13c34c	145
42b19289	146	Int_t fNMaskCellColumns; // Number of masked columns
	147	Int_t* fMaskCellColumns; //[fNMaskCellColumns] list of masked cell collumn
	148
	149	ClassDef(AliAnalysisTaskEMCALPi0CalibSelection,13);
375cec9b	150
	151	};
	152
	153	#endif //ALIANALYSISTASKEMCALPI0CALIBSELECTION_H