[u/mrichter/AliRoot.git] / PWGGA / GammaConv / AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero.h

#ifndef ALIANALYSISTASKNEUTRALMESONTOPIPLPIMIPIZERO_H
#define ALIANALYSISTASKNEUTRALMESONTOPIPLPIMIPIZERO_H

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


#include "AliAnalysisTaskSE.h"
#include "AliV0ReaderV1.h"
#include "AliKFConversionPhoton.h"
#include "AliPrimaryPionSelector.h"
#include "AliConversionMesonCuts.h"
#include "AliConvEventCuts.h"
#include "AliGammaConversionAODBGHandler.h"
#include "TProfile2D.h"

class AliESDInputHandler;
class AliMCEventHandler;
class AliESDEvent;
class AliESDtrack;
class AliESDtrackCuts;
class AliESDpidCuts;
class AliV0Reader;
class AliTriggerAnalysis;

class AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero: public AliAnalysisTaskSE
{
	public:

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

		virtual void UserExec(Option_t *);
		virtual void UserCreateOutputObjects();
		virtual Bool_t Notify();
		virtual void Terminate(const Option_t *);

			
		void SetMoveParticleAccordingToVertex(Bool_t flag){fMoveParticleAccordingToVertex = flag;}
			
		void SetIsHeavyIon(Int_t flag){
			if (flag == 1 || flag ==2 ){
				fIsHeavyIon = 1;    
			} else {
				fIsHeavyIon = 0;    
			}
		}
		
		void SetIsMC(Bool_t isMC){fIsMC=isMC;}
		void SetConversionCutList(Int_t nCuts, TList *CutArray){
			fnCuts= nCuts;
			fGammaCutArray = CutArray;
		}
		void SetEventCutList(Int_t nCuts, TList *CutArray){
			fnCuts= nCuts;
			fEventCutArray = CutArray;
		}

		void SetPionCutList(TList *CutArray){
			fPionCutArray = CutArray;
		}
		void SetNeutralPionCutList(TList *CutArray){
			fNeutralPionMesonCutArray = CutArray;
		}
		void SetMesonCutList(TList *CutArray){
			fMesonCutArray = CutArray;
		}
		void SetDoMesonQA(Bool_t flag){ fDoMesonQA = flag; }
	

	private:

		void InitBack();
		void ProcessPhotonCandidates();
		void ProcessTruePhotonCandidates(AliAODConversionPhoton*);
		void ProcessTrueMesonCandidates(AliAODConversionMother *Pi0Candidate, AliAODConversionMother *TrueNeutralPionCandidate, AliAODConversionPhoton *TrueVirtualGammaCandidate);
		void MoveParticleAccordingToVertex(AliAODConversionMother* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex);
    	void ProcessNeutralPionCandidatesPureConversions();	
		void ProcessTrueNeutralPionCandidatesPureConversions(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1);
		void ProcessTrueNeutralPionCandidatesPureConversionsAOD(AliAODConversionMother *Pi0Candidate, AliAODConversionPhoton *TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1);
		void ProcessPionCandidates();
		void ProcessMCParticles();
		void CalculateMesonCandidates();
        void CalculateBackground();
		void UpdateEventByEventData();
        
		Bool_t IsPiPlPiMiPiZeroDecay(TParticle *fMCMother) const;
		Bool_t IsEtaPiPlPiMiPiZeroDaughter( Int_t label ) const;
		Bool_t IsOmegaPiPlPiMiPiZeroDaughter( Int_t label ) const;
		Bool_t GammaIsNeutralMesonPiPlPiMiPiZeroDaughter( Int_t label ) const;

		AliV0ReaderV1 					*fV0Reader;									//
		AliPrimaryPionSelector			*fPionSelector;								//
		AliGammaConversionAODBGHandler 	**fBGHandler;								//
		AliESDEvent 					*fESDEvent;									//
		AliMCEvent 						*fMCEvent;									//
		AliStack 						*fMCStack;									//
		TList 							**fCutFolder;								//
		TList 							**fESDList;									//
		TList 							**fBackList;								//
		TList 							**fMotherList;								//
		TList 							**fTrueList;								//
		TList 							**fMCList;									//
		TList 							*fOutputContainer;							//
		TClonesArray 					*fReaderGammas;								//
		vector<Int_t> 					fSelectorNegPionIndex;						//
		vector<Int_t> 					fSelectorPosPionIndex;						//
		TList 							*fGoodGammas;								//
		TList 							*fNeutralPionCandidates;					//
		TList 							*fGoodVirtualParticles;						//
		TList 							*fEventCutArray;							//
		TList 							*fGammaCutArray;							//
		TList 							*fPionCutArray;								//
		TList 							*fNeutralPionMesonCutArray;					//
		TList 							*fMesonCutArray;							//
		AliConvEventCuts 				*fEventCuts;								//
		AliConversionPhotonCuts 		*fConversionCuts;							//
		
		// reconstructed particles
		TH1F 							**fHistoConvGammaPt;						//
		TH1F 							**fHistoConvGammaEta;						//
		TH1F 							**fHistoNegPionPt;							//
		TH1F 							**fHistoPosPionPt;							//
		TH1F 							**fHistoNegPionPhi;							//
		TH1F 							**fHistoPosPionPhi;							//
		TH1F 							**fHistoNegPionEta;							//
		TH1F 							**fHistoPosPionEta;							//
		TH2F 							**fHistoNegPionClsTPC;						//
		TH2F 							**fHistoPosPionClsTPC;						//
		TH2F 							**fHistoPionDCAxy;							//
		TH2F 							**fHistoPionDCAz;							//
		TH2F 							**fHistoPionTPCdEdxNSigma;					//
		TH2F 							**fHistoPionTPCdEdx;						//
		TH2F 							**fHistoPionPionInvMassPt;					//
		TH2F	 						**fHistoGammaGammaInvMassPt;				//
		TH2F	 						**fHistoMotherInvMassPt;					//
		THnSparseF 						**fTHnSparseMotherInvMassPtZM;				//
		TH2F 							**fHistoMotherBackInvMassPt;				//
		THnSparseF				 		**fTHnSparseMotherBackInvMassPtZM;			//
		
		// pure MC properties
		TH1F 							**fHistoMCAllGammaPt;						//
		TH1F 							**fHistoMCConvGammaPt;						//
		TH1F 							**fHistoMCAllPosPionsPt;					//
		TH1F 							**fHistoMCAllNegPionsPt;					//
		TH1F 							**fHistoMCGammaFromNeutralMesonPt;			//
		TH1F 							**fHistoMCPosPionsFromNeutralMesonPt;		//
		TH1F 							**fHistoMCNegPionsFromNeutralMesonPt;		//
		TH1F 							**fHistoMCEtaPiPlPiMiPiZeroPt;				//
		TH1F 							**fHistoMCEtaPiPlPiMiPiZeroInAccPt;			//
		TH1F 							**fHistoMCOmegaPiPlPiMiPiZeroPt;			//
		TH1F 							**fHistoMCOmegaPiPlPiMiPiZeroInAccPt;		//

		// reconstructed particles MC validated
		TH2F 							**fHistoTrueMotherPiPlPiMiPiZeroInvMassPt;	// histos with reconstructed validated eta or omega, inv mass, pT
		TH2F 							**fHistoTrueMotherGammaGammaInvMassPt;		// histos with reconstructed validated pi0, inv mass, pT
		TH1F 							**fHistoTrueConvGammaPt;					// histos with reconstructed validated gamma, pT
		TH1F 							**fHistoTrueConvGammaFromNeutralMesonPt;	// histos with reconstructed validated gamma from eta or omega via pi0, pT
		TH1F				 			**fHistoTruePosPionPt;						// histos with reconstructed validated positive pion, pT
		TH1F 							**fHistoTruePosPionFromNeutralMesonPt;		// histos with reconstructed validated positive pion from eta or omega, pT
		TH1F 							**fHistoTrueNegPionPt;						// histos with reconstructed validated negative pion, pT
		TH1F 							**fHistoTrueNegPionFromNeutralMesonPt;		// histos with reconstructed validated negative pion from eta or omega, pT
		TH2F 							**fHistoTruePionPionInvMassPt;				// histos with reconstructed validated two pion, invariant mass, pT
		TH2F 							**fHistoTruePionPionFromSameMotherInvMassPt;// histos with reconstructed validated two pion from same mother, invariant mass, pT
		TH2F 							**fHistoTruePionPionFromNeutralMesonInvMassPt;// histos with reconstructed validated two pion from eta or omega, invariant mass, pT
		// Event properties
		TH1I 							**fHistoNEvents;							// histo for event counting
		TH1I 							**fHistoNGoodESDTracks;						// histo number of reconstructed primary tracks
		TProfile 						**fProfileEtaShift;							// profile for eta shift bookkeeping
			
		TRandom3 						fRandom;									// random number
		Int_t 							fnCuts;										// number of cuts to be run in parallel
		Int_t 							fiCut;										// current cut
		Int_t 							fNumberOfESDTracks;							// integer with number of primary tracks in this event
		Bool_t 							fMoveParticleAccordingToVertex;				// Flag to move parice to the vertex
		Int_t 							fIsHeavyIon;								// Flag for collision system 0: pp, 1: PbPb, 2: pPb
		Bool_t 							fDoMesonAnalysis;							// Flag for switching on meson analysis
		Bool_t 							fDoMesonQA;									// Flag for switching on small meson QA
		Bool_t 							fIsFromMBHeader;							// Flag for particle whether it belongs to accepted header
		Bool_t 							fIsMC;										// Flag for MC  

	private:
		AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero( const AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero& ); // Not implemented
		AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero& operator=( const AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero& ); // Not implemented

		ClassDef( AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero, 1 );
};

#endif // ALIANALYSISTASKNEUTRALMESONTOPIPLPIMIPIZERO_H
Commit	Line	Data
cb287740	1	#ifndef ALIANALYSISTASKNEUTRALMESONTOPIPLPIMIPIZERO_H
	2	#define ALIANALYSISTASKNEUTRALMESONTOPIPLPIMIPIZERO_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	#include "AliAnalysisTaskSE.h"
	9	#include "AliV0ReaderV1.h"
	10	#include "AliKFConversionPhoton.h"
	11	#include "AliPrimaryPionSelector.h"
	12	#include "AliConversionMesonCuts.h"
	13	#include "AliConvEventCuts.h"
	14	#include "AliGammaConversionAODBGHandler.h"
	15	#include "TProfile2D.h"
	16
	17	class AliESDInputHandler;
	18	class AliMCEventHandler;
	19	class AliESDEvent;
	20	class AliESDtrack;
	21	class AliESDtrackCuts;
	22	class AliESDpidCuts;
	23	class AliV0Reader;
	24	class AliTriggerAnalysis;
	25
	26	class AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero: public AliAnalysisTaskSE
	27	{
	28	public:
	29
	30	AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero();
	31	AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero( const char* name );
	32	virtual ~AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero();
	33
	34	virtual void UserExec(Option_t *);
	35	virtual void UserCreateOutputObjects();
	36	virtual Bool_t Notify();
	37	virtual void Terminate(const Option_t *);
	38
	39
	40	void SetMoveParticleAccordingToVertex(Bool_t flag){fMoveParticleAccordingToVertex = flag;}
	41
	42	void SetIsHeavyIon(Int_t flag){
	43	if (flag == 1 \|\| flag ==2 ){
	44	fIsHeavyIon = 1;
	45	} else {
	46	fIsHeavyIon = 0;
	47	}
	48	}
	49
	50	void SetIsMC(Bool_t isMC){fIsMC=isMC;}
	51	void SetConversionCutList(Int_t nCuts, TList *CutArray){
	52	fnCuts= nCuts;
	53	fGammaCutArray = CutArray;
	54	}
	55	void SetEventCutList(Int_t nCuts, TList *CutArray){
	56	fnCuts= nCuts;
	57	fEventCutArray = CutArray;
	58	}
	59
	60	void SetPionCutList(TList *CutArray){
	61	fPionCutArray = CutArray;
	62	}
	63	void SetNeutralPionCutList(TList *CutArray){
	64	fNeutralPionMesonCutArray = CutArray;
65	}
66	void SetMesonCutList(TList *CutArray){
67	fMesonCutArray = CutArray;
68	}
69	void SetDoMesonQA(Bool_t flag){ fDoMesonQA = flag; }
70
71
72	private:
73
74	void InitBack();
75	void ProcessPhotonCandidates();
76	void ProcessTruePhotonCandidates(AliAODConversionPhoton*);
77	void ProcessTrueMesonCandidates(AliAODConversionMother Pi0Candidate, AliAODConversionMother TrueNeutralPionCandidate, AliAODConversionPhoton *TrueVirtualGammaCandidate);
f61c548e	78	void MoveParticleAccordingToVertex(AliAODConversionMother* particle,const AliGammaConversionAODBGHandler::GammaConversionVertex *vertex);
cb287740	79	void ProcessNeutralPionCandidatesPureConversions();
	80	void ProcessTrueNeutralPionCandidatesPureConversions(AliAODConversionMother Pi0Candidate, AliAODConversionPhoton TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1);
	81	void ProcessTrueNeutralPionCandidatesPureConversionsAOD(AliAODConversionMother Pi0Candidate, AliAODConversionPhoton TrueGammaCandidate0, AliAODConversionPhoton *TrueGammaCandidate1);
	82	void ProcessPionCandidates();
	83	void ProcessMCParticles();
	84	void CalculateMesonCandidates();
	85	void CalculateBackground();
	86	void UpdateEventByEventData();
	87
	88	Bool_t IsPiPlPiMiPiZeroDecay(TParticle *fMCMother) const;
	89	Bool_t IsEtaPiPlPiMiPiZeroDaughter( Int_t label ) const;
	90	Bool_t IsOmegaPiPlPiMiPiZeroDaughter( Int_t label ) const;
6671ffac	91	Bool_t GammaIsNeutralMesonPiPlPiMiPiZeroDaughter( Int_t label ) const;
cb287740	92
	93	AliV0ReaderV1 *fV0Reader; //
	94	AliPrimaryPionSelector *fPionSelector; //
	95	AliGammaConversionAODBGHandler **fBGHandler; //
	96	AliESDEvent *fESDEvent; //
	97	AliMCEvent *fMCEvent; //
	98	AliStack *fMCStack; //
	99	TList **fCutFolder; //
	100	TList **fESDList; //
	101	TList **fBackList; //
	102	TList **fMotherList; //
	103	TList **fTrueList; //
	104	TList **fMCList; //
	105	TList *fOutputContainer; //
	106	TClonesArray *fReaderGammas; //
	107	vector<Int_t> fSelectorNegPionIndex; //
	108	vector<Int_t> fSelectorPosPionIndex; //
	109	TList *fGoodGammas; //
	110	TList *fNeutralPionCandidates; //
	111	TList *fGoodVirtualParticles; //
	112	TList *fEventCutArray; //
	113	TList *fGammaCutArray; //
	114	TList *fPionCutArray; //
	115	TList *fNeutralPionMesonCutArray; //
	116	TList *fMesonCutArray; //
	117	AliConvEventCuts *fEventCuts; //
	118	AliConversionPhotonCuts *fConversionCuts; //
	119
	120	// reconstructed particles
	121	TH1F **fHistoConvGammaPt; //
	122	TH1F **fHistoConvGammaEta; //
	123	TH1F **fHistoNegPionPt; //
	124	TH1F **fHistoPosPionPt; //
	125	TH1F **fHistoNegPionPhi; //
	126	TH1F **fHistoPosPionPhi; //
	127	TH1F **fHistoNegPionEta; //
	128	TH1F **fHistoPosPionEta; //
	129	TH2F **fHistoNegPionClsTPC; //
	130	TH2F **fHistoPosPionClsTPC; //
	131	TH2F **fHistoPionDCAxy; //
	132	TH2F **fHistoPionDCAz; //
	133	TH2F **fHistoPionTPCdEdxNSigma; //
	134	TH2F **fHistoPionTPCdEdx; //
	135	TH2F **fHistoPionPionInvMassPt; //
	136	TH2F **fHistoGammaGammaInvMassPt; //
	137	TH2F **fHistoMotherInvMassPt; //
	138	THnSparseF **fTHnSparseMotherInvMassPtZM; //
	139	TH2F **fHistoMotherBackInvMassPt; //
	140	THnSparseF **fTHnSparseMotherBackInvMassPtZM; //
	141
	142	// pure MC properties
	143	TH1F **fHistoMCAllGammaPt; //
	144	TH1F **fHistoMCConvGammaPt; //
	145	TH1F **fHistoMCAllPosPionsPt; //
	146	TH1F **fHistoMCAllNegPionsPt; //
	147	TH1F **fHistoMCGammaFromNeutralMesonPt; //
	148	TH1F **fHistoMCPosPionsFromNeutralMesonPt; //
	149	TH1F **fHistoMCNegPionsFromNeutralMesonPt; //
	150	TH1F **fHistoMCEtaPiPlPiMiPiZeroPt; //
	151	TH1F **fHistoMCEtaPiPlPiMiPiZeroInAccPt; //
	152	TH1F **fHistoMCOmegaPiPlPiMiPiZeroPt; //
	153	TH1F **fHistoMCOmegaPiPlPiMiPiZeroInAccPt; //
	154
	155	// reconstructed particles MC validated
156	TH2F **fHistoTrueMotherPiPlPiMiPiZeroInvMassPt; // histos with reconstructed validated eta or omega, inv mass, pT
157	TH2F **fHistoTrueMotherGammaGammaInvMassPt; // histos with reconstructed validated pi0, inv mass, pT
158	TH1F **fHistoTrueConvGammaPt; // histos with reconstructed validated gamma, pT
159	TH1F **fHistoTrueConvGammaFromNeutralMesonPt; // histos with reconstructed validated gamma from eta or omega via pi0, pT
160	TH1F **fHistoTruePosPionPt; // histos with reconstructed validated positive pion, pT
161	TH1F **fHistoTruePosPionFromNeutralMesonPt; // histos with reconstructed validated positive pion from eta or omega, pT
162	TH1F **fHistoTrueNegPionPt; // histos with reconstructed validated negative pion, pT
163	TH1F **fHistoTrueNegPionFromNeutralMesonPt; // histos with reconstructed validated negative pion from eta or omega, pT
164	TH2F **fHistoTruePionPionInvMassPt; // histos with reconstructed validated two pion, invariant mass, pT
95bd6d60	165	TH2F **fHistoTruePionPionFromSameMotherInvMassPt;// histos with reconstructed validated two pion from same mother, invariant mass, pT
cb287740	166	TH2F **fHistoTruePionPionFromNeutralMesonInvMassPt;// histos with reconstructed validated two pion from eta or omega, invariant mass, pT
	167	// Event properties
	168	TH1I **fHistoNEvents; // histo for event counting
	169	TH1I **fHistoNGoodESDTracks; // histo number of reconstructed primary tracks
	170	TProfile **fProfileEtaShift; // profile for eta shift bookkeeping
	171
	172	TRandom3 fRandom; // random number
	173	Int_t fnCuts; // number of cuts to be run in parallel
	174	Int_t fiCut; // current cut
	175	Int_t fNumberOfESDTracks; // integer with number of primary tracks in this event
	176	Bool_t fMoveParticleAccordingToVertex; // Flag to move parice to the vertex
	177	Int_t fIsHeavyIon; // Flag for collision system 0: pp, 1: PbPb, 2: pPb
	178	Bool_t fDoMesonAnalysis; // Flag for switching on meson analysis
	179	Bool_t fDoMesonQA; // Flag for switching on small meson QA
	180	Bool_t fIsFromMBHeader; // Flag for particle whether it belongs to accepted header
	181	Bool_t fIsMC; // Flag for MC
	182
	183	private:
	184	AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero( const AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero& ); // Not implemented
	185	AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero& operator=( const AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero& ); // Not implemented
	186
	187	ClassDef( AliAnalysisTaskNeutralMesonToPiPlPiMiPiZero, 1 );
	188	};
	189
	190	#endif // ALIANALYSISTASKNEUTRALMESONTOPIPLPIMIPIZERO_H
	191