[u/mrichter/AliRoot.git] / PWGGA / PHOSTasks / PHOS_PbPb / AliAnalysisTaskPi0Flow.h

#ifndef AliAnalysisTaskPi0Flow_cxx
#define AliAnalysisTaskPi0Flow_cxx

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

// Analysis task to fill histograms with PHOS ESD or AOD clusters and cells
// Authors : Dmitri Peressounko
// Date    : 28.05.2011
// Modified: 03.08.2012 Henrik Qvigstad
/* $Id$ */

class TObjArray;
class TH1F;
class TH2I;
class TH2F;
class TH3F;
class TF1 ;
class AliStack ;
class AliESDtrackCuts;
class AliPHOSGeometry;
class AliESDEvent ;
class AliPHOSCalibData;
class AliESDtrack ;
class AliESDCaloCluster ;
class AliEPFlattener;

#include "TArrayD.h"

#include "AliAnalysisTaskSE.h"

class AliAnalysisTaskPi0Flow : public AliAnalysisTaskSE {
public:
    enum Period { kUndefinedPeriod, kLHC10h, kLHC11h, kLHC13 };

public:
    AliAnalysisTaskPi0Flow(const char *name = "AliAnalysisTaskPi0Flow", Period period = kUndefinedPeriod);
    virtual ~AliAnalysisTaskPi0Flow();

    virtual void   UserCreateOutputObjects();
    virtual void   UserExec(Option_t *option);
    /* virtual void   Terminate(Option_t *); */

    void SetPeriod(Period period) { fPeriod = period;}
    
    void SetCentralityBinning(const TArrayD& edges, const TArrayI& nMixed);
    void SetEventMixingRPBinning(UInt_t nBins) { fNEMRPBins = nBins; }
    void SetMaxAbsVertexZ(Float_t z) { fMaxAbsVertexZ = z; }
    void SetManualV0EPCalc(Bool_t manCalc = true) {fManualV0EPCalc = manCalc;}
    void SetEnablePHOSModule(int module, Bool_t enable = true);
    
    void SetPHOSBadMap(Int_t mod,TH2I * badMapHist);
    //Where to read AODB object with EP calibration if not default
    void SetEPcalibFileName(const TString filename) {fEPcalibFileName = filename; }   


protected:
    AliAnalysisTaskPi0Flow(const AliAnalysisTaskPi0Flow&); // not implemented
    AliAnalysisTaskPi0Flow& operator=(const AliAnalysisTaskPi0Flow&); // not implemented

    virtual void MakeMCHistograms();

    // Step 0:
    AliVEvent* GetEvent();

    // Step 1:
    void SetGeometry();
    void SetMisalignment();
    void SetV0Calibration(); //V0 calibration
    void SetESDTrackCuts(); // AliESDtrack cuts ( for esd data )
    void SetPHOSCalibData(); // phos re-calibration ( for esd data)
    void SetFlatteningData(); // phos flattening

    // Step 2:
    void SetVertex();
    Bool_t RejectEventVertex();

    // Step 4:
    void SetCentrality();
    Bool_t RejectCentrality();

    // Step 5:
    void EvalReactionPlane();
    void EvalV0ReactionPlane();

    // Step 7: QA PHOS cells
    void FillPHOSCellQAHists();

    // Step 8: Event Photons (PHOS Clusters) selection
    void SelectPhotonClusters();
    void FillSelectedClusterHistograms();

    // Step 9: Consider pi0 (photon/cluster) pairs.
    void ConsiderPi0s();

    // Step 10; Mixing
    void ConsiderPi0sMix();

    // Step 11: MC
    virtual void DoMC();

    // Step 12: Update lists
    void UpdateLists();

    Bool_t AreNeibors(Int_t id1,Int_t id2) ;
    Double_t ApplyFlattening(Double_t phi, Double_t c) ; //Apply centrality-dependent flattening
    Double_t ApplyFlatteningV0A(Double_t phi, Double_t c) ; //Apply centrality-dependent flattening
    Double_t ApplyFlatteningV0C(Double_t phi, Double_t c) ; //Apply centrality-dependent flattening
    Int_t ConvertToInternalRunNumber(Int_t run) ;
    Double_t CoreEnergy(AliVCluster * clu, AliVCaloCells * cells);
    void EvalCoreLambdas(AliVCluster * clu, AliVCaloCells * cells, Double_t &m02, Double_t &m20) ; 
    Bool_t TestCoreLambda(Double_t pt,Double_t l1,Double_t l2) ;


    void FillHistogram(const char * key,Double_t x) const ; //Fill 1D histogram witn name key
    void FillHistogram(const char * key,Double_t x, Double_t y) const ; //Fill 2D histogram witn name key
    void FillHistogram(const char * key,Double_t x, Double_t y, Double_t z) const ; //Fill 3D histogram witn name key
    void FillHistogram(const char * key,Double_t x, Double_t y, Double_t z, Double_t w) const ; //Fill 3D histogram witn name key

    TVector3 GetVertexVector(const AliVVertex* vertex);
    Int_t GetCentralityBin(Float_t centralityV0M);
    Int_t GetRPBin();

    void LogProgress(int step);
    void LogSelection(int step, int internalRunNumber);

    Bool_t IsGoodChannel(const char * det, Int_t mod,Int_t ix, Int_t iz); //Use addisional bad map for PHOS


    void Reclusterize(AliVCluster * clu) ;
    Double_t TestCPV(Double_t dx, Double_t dz, Double_t pt, Int_t charge);
    Bool_t TestLambda(Double_t pt,Double_t l1,Double_t l2) ;  //Evaluate Dispersion cuts for photons
    Bool_t TestLambda2(Double_t pt,Double_t l1,Double_t l2) ;  //Evaluate Dispersion cuts for photons
    
    UInt_t GetNumberOfCentralityBins() { return fCentEdges.GetSize()-1; }
    TList* GetCaloPhotonsPHOSList(UInt_t vtxBin, UInt_t centBin, UInt_t rpBin);
    

protected:
    // transiant constants
    static const Int_t kNMod = 5;

    // constants:
    static const Double_t kLogWeight= 4.5 ; // log weight for recalibration.
    static const Double_t kAlphaCut=0.7 ;
    static const Bool_t doESDReCalibration = kTRUE;
    static const Int_t kNCenBins = 9; // see EvalV0ReactionPlane()

    // cluster cut variables:
    static const Double_t kMinClusterEnergy = 0.3;
    static const Double_t kMinBCDistance = 2.5;  //distance to nearest bad channel
    static const Int_t kMinNCells = 3;
    static const Double_t kMinM02 = 0.2;

    // Binning, [vtx, centrality, reaction-plane]
    static const Int_t kNVtxZBins = 1;
    static const Double_t kCentCutoff = 90.; // Ignore Centrality over 90%
    TArrayD fCentEdges;  // Centrality Bin Lower edges
    TArrayI fCentNMixed; // Number of mixed events for each centrality bin
    UInt_t fNEMRPBins;
    

    // Behavior / cuts
    Period fPeriod;
    Float_t fMaxAbsVertexZ; // in cm
    Bool_t fManualV0EPCalc;
    Bool_t fModuleEnabled[kNMod]; //[kNMod]


    TList * fOutputContainer;        //final histogram container

    TF1 *fNonLinCorr;          // Non-linearity correction
//TF1 * fRecent[5][12] ;//Recentering corrections
    TH2I *fPHOSBadMap[6] ;    //Container for PHOS bad channels map

    // Run variables

    // Step 0: Event Objects
    // fEvent, fMCStack
    AliVEvent* fEvent; //! Current event
    AliESDEvent* fEventESD; //! Current event, if ESD.
    AliAODEvent* fEventAOD; //! Current event, if AOD.

    // Step 1: Run Number, Misalignment Matrix, and Calibration
    Int_t fRunNumber; // run number
    Int_t fInternalRunNumber ;    //Current internal run number
    AliPHOSGeometry  *fPHOSGeo;  //! PHOS geometry
    TProfile *fMultV0;                  // object containing VZERO calibration information
    Float_t fV0Cpol,fV0Apol;            // loaded by OADB
    Float_t fMeanQ[kNCenBins][2][2];    // and recentering
    Float_t fWidthQ[kNCenBins][2][2];   // ...
    AliESDtrackCuts *fESDtrackCuts; // Track cut
    AliPHOSCalibData *fPHOSCalibData; // PHOS calibration object
    TString fEPcalibFileName; 
    AliEPFlattener * fTPCFlat ; //Object for flattening of TPC
    AliEPFlattener * fV0AFlat ; //Object for flattening of V0A
    AliEPFlattener * fV0CFlat ; //Object for flattening of V0C
    
    
    // Step 2: Vertex
    Double_t fVertex[3];
    TVector3 fVertexVector;
    Int_t fVtxBin;

    // Step 4: Centrality
    Float_t fCentralityV0M ; //!Centrality of the currecnt event
    Int_t fCentBin ;       //! Current centrality bin

    // Step 5: Reaction Plane
    Bool_t fHaveTPCRP ; //! Is TPC RP defined?
    Float_t fRP ;       //!Reaction plane calculated with full TPC
    Float_t fRPV0A ;    //!Reaction plain calculated with A-side TPC: eta>0.15
    Float_t fRPV0C ;    //!Reaction plain calculated with C-side TPC: eta<-0.15
    Int_t fEMRPBin;       //! Event Mixing Reaction Plane Bin

    // Step 8: Event Photons (PHOS Clusters) selection
    TObjArray * fCaloPhotonsPHOS ;      //PHOS photons in current event

    // Step 12: Update lists for mixing.
    TObjArray* fCaloPhotonsPHOSLists; //! array of TList, Containers for events with PHOS photons


    ClassDef(AliAnalysisTaskPi0Flow, 2); // PHOS analysis task
};

#endif
Commit	Line	Data
ada6b882	1	#ifndef AliAnalysisTaskPi0Flow_cxx
	2	#define AliAnalysisTaskPi0Flow_cxx
	3
b8bea077	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
ada6b882	7	// Analysis task to fill histograms with PHOS ESD or AOD clusters and cells
	8	// Authors : Dmitri Peressounko
	9	// Date : 28.05.2011
	10	// Modified: 03.08.2012 Henrik Qvigstad
91b112bd	11	/* $Id$ */
ada6b882	12
	13	class TObjArray;
	14	class TH1F;
	15	class TH2I;
	16	class TH2F;
	17	class TH3F;
	18	class TF1 ;
	19	class AliStack ;
	20	class AliESDtrackCuts;
	21	class AliPHOSGeometry;
	22	class AliESDEvent ;
	23	class AliPHOSCalibData;
	24	class AliESDtrack ;
	25	class AliESDCaloCluster ;
9d29cbcb	26	class AliEPFlattener;
ada6b882	27
	28	#include "TArrayD.h"
	29
	30	#include "AliAnalysisTaskSE.h"
	31
	32	class AliAnalysisTaskPi0Flow : public AliAnalysisTaskSE {
	33	public:
90d2ba9f	34	enum Period { kUndefinedPeriod, kLHC10h, kLHC11h, kLHC13 };
ada6b882	35
	36	public:
	37	AliAnalysisTaskPi0Flow(const char *name = "AliAnalysisTaskPi0Flow", Period period = kUndefinedPeriod);
	38	virtual ~AliAnalysisTaskPi0Flow();
	39
	40	virtual void UserCreateOutputObjects();
	41	virtual void UserExec(Option_t *option);
4c5399e6	42	/* virtual void Terminate(Option_t ); /
ada6b882	43
	44	void SetPeriod(Period period) { fPeriod = period;}
	45
85394e40	46	void SetCentralityBinning(const TArrayD& edges, const TArrayI& nMixed);
ada6b882	47	void SetEventMixingRPBinning(UInt_t nBins) { fNEMRPBins = nBins; }
10a684bf	48	void SetMaxAbsVertexZ(Float_t z) { fMaxAbsVertexZ = z; }
6a1a4e92	49	void SetManualV0EPCalc(Bool_t manCalc = true) {fManualV0EPCalc = manCalc;}
88014928	50	void SetEnablePHOSModule(int module, Bool_t enable = true);
ada6b882	51
ada6b882	52	void SetPHOSBadMap(Int_t mod,TH2I * badMapHist);
b509e3a5	53	//Where to read AODB object with EP calibration if not default
b509e3a5	54	void SetEPcalibFileName(const TString filename) {fEPcalibFileName = filename; }
ada6b882	55
393743be	56
393743be	57	protected:
ada6b882	58	AliAnalysisTaskPi0Flow(const AliAnalysisTaskPi0Flow&); // not implemented
	59	AliAnalysisTaskPi0Flow& operator=(const AliAnalysisTaskPi0Flow&); // not implemented
	60
393743be	61	virtual void MakeMCHistograms();
393743be	62
ada6b882	63	// Step 0:
ada6b882	64	AliVEvent* GetEvent();
ada6b882	65
	66	// Step 1:
	67	void SetGeometry();
	68	void SetMisalignment();
	69	void SetV0Calibration(); //V0 calibration
	70	void SetESDTrackCuts(); // AliESDtrack cuts ( for esd data )
	71	void SetPHOSCalibData(); // phos re-calibration ( for esd data)
b509e3a5	72	void SetFlatteningData(); // phos flattening
ada6b882	73
	74	// Step 2:
	75	void SetVertex();
	76	Bool_t RejectEventVertex();
	77
	78	// Step 4:
	79	void SetCentrality();
	80	Bool_t RejectCentrality();
	81
	82	// Step 5:
	83	void EvalReactionPlane();
	84	void EvalV0ReactionPlane();
	85
	86	// Step 7: QA PHOS cells
	87	void FillPHOSCellQAHists();
	88
	89	// Step 8: Event Photons (PHOS Clusters) selection
	90	void SelectPhotonClusters();
	91	void FillSelectedClusterHistograms();
	92
	93	// Step 9: Consider pi0 (photon/cluster) pairs.
	94	void ConsiderPi0s();
	95
	96	// Step 10; Mixing
	97	void ConsiderPi0sMix();
	98
393743be	99	// Step 11: MC
	100	virtual void DoMC();
	101
	102	// Step 12: Update lists
ada6b882	103	void UpdateLists();
	104
	105	Bool_t AreNeibors(Int_t id1,Int_t id2) ;
	106	Double_t ApplyFlattening(Double_t phi, Double_t c) ; //Apply centrality-dependent flattening
	107	Double_t ApplyFlatteningV0A(Double_t phi, Double_t c) ; //Apply centrality-dependent flattening
	108	Double_t ApplyFlatteningV0C(Double_t phi, Double_t c) ; //Apply centrality-dependent flattening
	109	Int_t ConvertToInternalRunNumber(Int_t run) ;
91b112bd	110	Double_t CoreEnergy(AliVCluster * clu, AliVCaloCells * cells);
6ca8b4a1	111	void EvalCoreLambdas(AliVCluster * clu, AliVCaloCells * cells, Double_t &m02, Double_t &m20) ;
6ca8b4a1	112	Bool_t TestCoreLambda(Double_t pt,Double_t l1,Double_t l2) ;
ada6b882	113
	114
	115
	116
	117	void FillHistogram(const char * key,Double_t x) const ; //Fill 1D histogram witn name key
	118	void FillHistogram(const char * key,Double_t x, Double_t y) const ; //Fill 2D histogram witn name key
	119	void FillHistogram(const char * key,Double_t x, Double_t y, Double_t z) const ; //Fill 3D histogram witn name key
45c6dc2d	120	void FillHistogram(const char * key,Double_t x, Double_t y, Double_t z, Double_t w) const ; //Fill 3D histogram witn name key
ada6b882	121
	122	TVector3 GetVertexVector(const AliVVertex* vertex);
	123	Int_t GetCentralityBin(Float_t centralityV0M);
	124	Int_t GetRPBin();
	125
c9fb2807	126	void LogProgress(int step);
c9fb2807	127	void LogSelection(int step, int internalRunNumber);
ada6b882	128
	129	Bool_t IsGoodChannel(const char * det, Int_t mod,Int_t ix, Int_t iz); //Use addisional bad map for PHOS
	130
	131
	132	void Reclusterize(AliVCluster * clu) ;
	133	Double_t TestCPV(Double_t dx, Double_t dz, Double_t pt, Int_t charge);
	134	Bool_t TestLambda(Double_t pt,Double_t l1,Double_t l2) ; //Evaluate Dispersion cuts for photons
	135	Bool_t TestLambda2(Double_t pt,Double_t l1,Double_t l2) ; //Evaluate Dispersion cuts for photons
	136
	137	UInt_t GetNumberOfCentralityBins() { return fCentEdges.GetSize()-1; }
	138	TList* GetCaloPhotonsPHOSList(UInt_t vtxBin, UInt_t centBin, UInt_t rpBin);
	139
	140
	141
	142
393743be	143	protected:
052d1b8e	144	// transiant constants
	145	static const Int_t kNMod = 5;
	146
ada6b882	147	// constants:
	148	static const Double_t kLogWeight= 4.5 ; // log weight for recalibration.
	149	static const Double_t kAlphaCut=0.7 ;
	150	static const Bool_t doESDReCalibration = kTRUE;
	151	static const Int_t kNCenBins = 9; // see EvalV0ReactionPlane()
	152
	153	// cluster cut variables:
	154	static const Double_t kMinClusterEnergy = 0.3;
f9dbbc02	155	static const Double_t kMinBCDistance = 2.5; //distance to nearest bad channel
ada6b882	156	static const Int_t kMinNCells = 3;
	157	static const Double_t kMinM02 = 0.2;
	158
	159	// Binning, [vtx, centrality, reaction-plane]
	160	static const Int_t kNVtxZBins = 1;
	161	static const Double_t kCentCutoff = 90.; // Ignore Centrality over 90%
107849ac	162	TArrayD fCentEdges; // Centrality Bin Lower edges
107849ac	163	TArrayI fCentNMixed; // Number of mixed events for each centrality bin
ada6b882	164	UInt_t fNEMRPBins;
ada6b882	165
ada6b882	166
10a684bf	167	// Behavior / cuts
ada6b882	168	Period fPeriod;
10a684bf	169	Float_t fMaxAbsVertexZ; // in cm
6a1a4e92	170	Bool_t fManualV0EPCalc;
052d1b8e	171	Bool_t fModuleEnabled[kNMod]; //[kNMod]
ada6b882	172
10a684bf	173
ada6b882	174	TList * fOutputContainer; //final histogram container
	175
	176	TF1 *fNonLinCorr; // Non-linearity correction
	177	//TF1 * fRecent[5][12] ;//Recentering corrections
	178	TH2I *fPHOSBadMap[6] ; //Container for PHOS bad channels map
	179
	180	// Run variables
	181
	182	// Step 0: Event Objects
	183	// fEvent, fMCStack
	184	AliVEvent* fEvent; //! Current event
	185	AliESDEvent* fEventESD; //! Current event, if ESD.
	186	AliAODEvent* fEventAOD; //! Current event, if AOD.
ada6b882	187
	188	// Step 1: Run Number, Misalignment Matrix, and Calibration
	189	Int_t fRunNumber; // run number
	190	Int_t fInternalRunNumber ; //Current internal run number
	191	AliPHOSGeometry *fPHOSGeo; //! PHOS geometry
	192	TProfile *fMultV0; // object containing VZERO calibration information
	193	Float_t fV0Cpol,fV0Apol; // loaded by OADB
	194	Float_t fMeanQ[kNCenBins][2][2]; // and recentering
	195	Float_t fWidthQ[kNCenBins][2][2]; // ...
	196	AliESDtrackCuts *fESDtrackCuts; // Track cut
	197	AliPHOSCalibData *fPHOSCalibData; // PHOS calibration object
b509e3a5	198	TString fEPcalibFileName;
9d29cbcb	199	AliEPFlattener * fTPCFlat ; //Object for flattening of TPC
	200	AliEPFlattener * fV0AFlat ; //Object for flattening of V0A
	201	AliEPFlattener * fV0CFlat ; //Object for flattening of V0C
b509e3a5	202
b509e3a5	203
ada6b882	204	// Step 2: Vertex
	205	Double_t fVertex[3];
	206	TVector3 fVertexVector;
	207	Int_t fVtxBin;
	208
	209	// Step 4: Centrality
	210	Float_t fCentralityV0M ; //!Centrality of the currecnt event
	211	Int_t fCentBin ; //! Current centrality bin
	212
	213	// Step 5: Reaction Plane
	214	Bool_t fHaveTPCRP ; //! Is TPC RP defined?
	215	Float_t fRP ; //!Reaction plane calculated with full TPC
	216	Float_t fRPV0A ; //!Reaction plain calculated with A-side TPC: eta>0.15
	217	Float_t fRPV0C ; //!Reaction plain calculated with C-side TPC: eta<-0.15
	218	Int_t fEMRPBin; //! Event Mixing Reaction Plane Bin
	219
	220	// Step 8: Event Photons (PHOS Clusters) selection
	221	TObjArray * fCaloPhotonsPHOS ; //PHOS photons in current event
	222
393743be	223	// Step 12: Update lists for mixing.
ada6b882	224	TObjArray* fCaloPhotonsPHOSLists; //! array of TList, Containers for events with PHOS photons
	225
	226
393743be	227	ClassDef(AliAnalysisTaskPi0Flow, 2); // PHOS analysis task
ada6b882	228	};
	229
	230	#endif