[u/mrichter/AliRoot.git] / PWGLF / QATasks / AliAnalysisTaskQAHighPtDeDx.h

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


// ROOT includes
#include <TList.h>
#include <TH1.h>
#include <TProfile.h>
#include <TTreeStream.h>
#include <TRandom.h>
#include <TObject.h>

// AliRoot includes
#include <AliAnalysisTaskSE.h>
#include <AliESDEvent.h>
#include <AliAODEvent.h>
#include <AliMCEvent.h>
#include <AliAnalysisFilter.h>
#include <AliStack.h>
#include <AliGenEventHeader.h>
#include <AliVHeader.h>
#include <AliAODMCParticle.h> 
#include <AliESDtrackCuts.h>


class AliAnalysisTaskQAHighPtDeDx : public AliAnalysisTaskSE {
 public:
 

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


  //AliAnalysisTaskQAHighPtDeDx(const char *name="<default name>");
  //virtual ~AliAnalysisTaskQAHighPtDeDx() { /*if (fOutputList) delete fOutputList;*/}//;

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

  Bool_t   GetAnalysisMC() { return fAnalysisMC; }   
  Double_t GetVtxCut() { return fVtxCut; }   
  Double_t GetEtaCut() { return fEtaCut; }     
  //Double_t GetMinPt() { return fMinPt; }   
  //Int_t    GetTreeOption() { return fTreeOption; }  

  virtual void  SetTrigger(UInt_t ktriggerInt) {ftrigBit = ktriggerInt;}
  virtual void  SetTrackFilterGolden(AliAnalysisFilter* trackF) {fTrackFilterGolden = trackF;}
  virtual void  SetTrackFilterTPC(AliAnalysisFilter* trackF) {fTrackFilterTPC = trackF;}
  virtual void  SetCentralityEstimator(const char * centEst) {fCentEst = centEst;}
  virtual void  SetAnalysisType(const char* analysisType) {fAnalysisType = analysisType;}
  virtual void  SetAnalysisMC(Bool_t isMC) {fAnalysisMC = isMC;}
  virtual void  SetVtxCut(Double_t vtxCut){fVtxCut = vtxCut;}
  virtual void  SetEtaCut(Double_t etaCut){fEtaCut = etaCut;}
  virtual void  SetPileUpRej(Bool_t isrej) {fPileUpRej = isrej;}   
  virtual void  SetMinCent(Float_t minvalc) {fMinCent = minvalc;}
  virtual void  SetMaxCent(Float_t maxvalc) {fMaxCent = maxvalc;}
  virtual void  SetStoreMcIn(Bool_t value) {fStoreMcIn = value;}
  virtual void  SetAnalysisPbPb(Bool_t isanaPbPb) {fAnalysisPbPb = isanaPbPb;}

 private:
  virtual Float_t GetVertex(const AliVEvent* event) const;
  virtual void AnalyzeESD(AliESDEvent* esd); 
  virtual void AnalyzeAOD(AliAODEvent* aod); 
  virtual void ProduceArrayTrksESD(AliESDEvent* event);
  virtual void ProduceArrayV0ESD(AliESDEvent* event);
  virtual void ProduceArrayTrksAOD(AliAODEvent* event);
  virtual void ProduceArrayV0AOD(AliAODEvent* event);
  Short_t   GetPidCode(Int_t pdgCode) const;
  void      ProcessMCTruthESD();
  void      ProcessMCTruthAOD(); 

  Short_t   GetPythiaEventProcessType(Int_t pythiaType);
  Short_t   GetDPMjetEventProcessType(Int_t dpmJetType);
  ULong64_t GetEventIdAsLong(AliVHeader* header) const;

  TParticle* FindPrimaryMother(AliStack* stack, Int_t label);
  Int_t      FindPrimaryMotherLabel(AliStack* stack, Int_t label);

  AliAODMCParticle* FindPrimaryMotherAOD(AliAODMCParticle* startParticle);

  TParticle* FindPrimaryMotherV0(AliStack* stack, Int_t label);
  Int_t      FindPrimaryMotherLabelV0(AliStack* stack, Int_t label, Int_t& nSteps);
  Bool_t PhiCut(Double_t pt, Double_t phi, Double_t q, Float_t   mag, TF1* phiCutLow, TF1* phiCutHigh);


  AliAODMCParticle* FindPrimaryMotherAODV0(AliAODMCParticle* startParticle, Int_t& nSteps);


  static const Double_t fgkClight;   // Speed of light (cm/ps)

  AliESDEvent* fESD;                  //! ESD object
  AliAODEvent* fAOD;                  //! AOD object
  AliMCEvent*  fMC;                   //! MC object
  AliStack*    fMCStack;              //! MC ESD stack
  TClonesArray* fMCArray;             //! MC array for AOD
  AliAnalysisFilter* fTrackFilterGolden;    //  Track Filter, set 2010 with golden cuts
  AliAnalysisFilter* fTrackFilterTPC; // track filter for TPC only tracks
  TString       fCentEst;             // V0A , V0M, 
  TString       fAnalysisType;        //  "ESD" or "AOD"
  Bool_t        fAnalysisMC;          //  Real(kFALSE) or MC(kTRUE) flag
  Bool_t        fAnalysisPbPb;        //  true you want to analyze PbPb data, false for pp
  UInt_t       ftrigBit;
  TRandom*      fRandom;              //! random number generator
  Bool_t        fPileUpRej;           // kTRUE is pile-up is rejected
 

  //
  // Cuts and options
  //

  Double_t     fVtxCut;             // Vtx cut on z position in cm
  Double_t     fEtaCut;             // Eta cut used to select particles
  Float_t      fMinCent; //minimum centrality
  Float_t      fMaxCent; //maximum centrality
  Bool_t       fStoreMcIn;          // Store MC input tracks
  //
  // Help variables
  //
  Short_t      fMcProcessType;      // -1=invalid, 0=data, 1=ND, 2=SD, 3=DD
  Short_t      fTriggeredEventMB;   // 1 = triggered, 0 = not trigged (MC only)
  Short_t      fVtxStatus;          // -1 = no vtx, 0 = outside cut, 1 = inside cut
  Float_t      fZvtx;               // z vertex
  Float_t      fZvtxMC;             // z vertex MC (truth)
  Int_t        fRun;                // run no
  ULong64_t    fEventId;            // unique event id
              
  //
  // Output objects
  //
  TList*        fListOfObjects;     //! Output list of objects
  TH1I*         fEvents;            //! No of accepted events
  TH1I*         fVtx;               //! Event vertex info
  TH1F*         fVtxMC;             //! Event vertex info for ALL MC events
  TH1F*         fVtxBeforeCuts;     //! Vertex z dist before cuts
  TH1F*         fVtxAfterCuts;      //! Vertex z dist after cuts
  TH1F* fn1;
  TH1F* fcent;

  TH2D *hMIPVsEta;
  TProfile *pMIPVsEta;
  TH2D *hMIPVsEtaV0s;
  TProfile *pMIPVsEtaV0s;
  TH2D *hPlateauVsEta;
  TProfile *pPlateauVsEta;
  TH2D *hPhi;

  TH2D     *hMIPVsNch[9];
  TProfile *pMIPVsNch[9];

  TH2D     *hMIPVsPhi[9];
  TProfile *pMIPVsPhi[9];
  TH2D     *hPlateauVsPhi[9];
  TProfile *pPlateauVsPhi[9];

  TH2D* histPiV0[9];
  TH1D* histpPiV0[9];

  TH2D* histPV0[9];
  TH1D* histpPV0[9];

  TH2D* histAllCh[9];

  TH2D* histPiTof[9];
  TH1D* histpPiTof[9];

  TH2D* histEV0[9];

  TH1D* hMcIn[7][9];
  TH1D* hMcOut[7][9];

  AliAnalysisTaskQAHighPtDeDx(const AliAnalysisTaskQAHighPtDeDx&);            // not implemented
  AliAnalysisTaskQAHighPtDeDx& operator=(const AliAnalysisTaskQAHighPtDeDx&); // not implemented

  //TTree*        fTree;              //! Debug tree 

  ClassDef(AliAnalysisTaskQAHighPtDeDx, 1);    //Analysis task for high pt analysis 
};

#endif
Commit	Line	Data
bb6f433c	1	#ifndef ALIANALYSISTASKQAHIGHPTDEDX_H
	2	#define ALIANALYSISTASKQAHIGHPTDEDX_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5	/* $Id$ */
	6
	7
	8	// ROOT includes
	9	#include <TList.h>
	10	#include <TH1.h>
	11	#include <TProfile.h>
	12	#include <TTreeStream.h>
	13	#include <TRandom.h>
	14	#include <TObject.h>
	15
	16	// AliRoot includes
	17	#include <AliAnalysisTaskSE.h>
	18	#include <AliESDEvent.h>
	19	#include <AliAODEvent.h>
	20	#include <AliMCEvent.h>
	21	#include <AliAnalysisFilter.h>
	22	#include <AliStack.h>
	23	#include <AliGenEventHeader.h>
	24	#include <AliVHeader.h>
	25	#include <AliAODMCParticle.h>
	26	#include <AliESDtrackCuts.h>
	27
	28
	29
	30	class AliAnalysisTaskQAHighPtDeDx : public AliAnalysisTaskSE {
	31	public:
	32
b5c45a25	33
	34	AliAnalysisTaskQAHighPtDeDx();
	35	AliAnalysisTaskQAHighPtDeDx(const char *name);
	36	virtual ~AliAnalysisTaskQAHighPtDeDx();
	37
	38
	39
	40
	41
	42
	43	//AliAnalysisTaskQAHighPtDeDx(const char *name="<default name>");
	44	//virtual ~AliAnalysisTaskQAHighPtDeDx() { /if (fOutputList) delete fOutputList;/}//;
bb6f433c	45
	46	virtual void UserCreateOutputObjects();
	47	virtual void UserExec(Option_t *option);
	48
	49	Bool_t GetAnalysisMC() { return fAnalysisMC; }
	50	Double_t GetVtxCut() { return fVtxCut; }
	51	Double_t GetEtaCut() { return fEtaCut; }
	52	//Double_t GetMinPt() { return fMinPt; }
	53	//Int_t GetTreeOption() { return fTreeOption; }
	54
	55	virtual void SetTrigger(UInt_t ktriggerInt) {ftrigBit = ktriggerInt;}
	56	virtual void SetTrackFilterGolden(AliAnalysisFilter* trackF) {fTrackFilterGolden = trackF;}
	57	virtual void SetTrackFilterTPC(AliAnalysisFilter* trackF) {fTrackFilterTPC = trackF;}
	58	virtual void SetCentralityEstimator(const char * centEst) {fCentEst = centEst;}
	59	virtual void SetAnalysisType(const char* analysisType) {fAnalysisType = analysisType;}
	60	virtual void SetAnalysisMC(Bool_t isMC) {fAnalysisMC = isMC;}
	61	virtual void SetVtxCut(Double_t vtxCut){fVtxCut = vtxCut;}
	62	virtual void SetEtaCut(Double_t etaCut){fEtaCut = etaCut;}
	63	virtual void SetPileUpRej(Bool_t isrej) {fPileUpRej = isrej;}
	64	virtual void SetMinCent(Float_t minvalc) {fMinCent = minvalc;}
	65	virtual void SetMaxCent(Float_t maxvalc) {fMaxCent = maxvalc;}
	66	virtual void SetStoreMcIn(Bool_t value) {fStoreMcIn = value;}
	67	virtual void SetAnalysisPbPb(Bool_t isanaPbPb) {fAnalysisPbPb = isanaPbPb;}
	68
	69	private:
	70	virtual Float_t GetVertex(const AliVEvent* event) const;
	71	virtual void AnalyzeESD(AliESDEvent* esd);
	72	virtual void AnalyzeAOD(AliAODEvent* aod);
	73	virtual void ProduceArrayTrksESD(AliESDEvent* event);
	74	virtual void ProduceArrayV0ESD(AliESDEvent* event);
	75	virtual void ProduceArrayTrksAOD(AliAODEvent* event);
	76	virtual void ProduceArrayV0AOD(AliAODEvent* event);
	77	Short_t GetPidCode(Int_t pdgCode) const;
	78	void ProcessMCTruthESD();
	79	void ProcessMCTruthAOD();
	80
	81	Short_t GetPythiaEventProcessType(Int_t pythiaType);
	82	Short_t GetDPMjetEventProcessType(Int_t dpmJetType);
	83	ULong64_t GetEventIdAsLong(AliVHeader* header) const;
	84
	85	TParticle* FindPrimaryMother(AliStack* stack, Int_t label);
	86	Int_t FindPrimaryMotherLabel(AliStack* stack, Int_t label);
	87
	88	AliAODMCParticle* FindPrimaryMotherAOD(AliAODMCParticle* startParticle);
	89
	90	TParticle* FindPrimaryMotherV0(AliStack* stack, Int_t label);
	91	Int_t FindPrimaryMotherLabelV0(AliStack* stack, Int_t label, Int_t& nSteps);
	92	Bool_t PhiCut(Double_t pt, Double_t phi, Double_t q, Float_t mag, TF1* phiCutLow, TF1* phiCutHigh);
	93
	94
	95	AliAODMCParticle* FindPrimaryMotherAODV0(AliAODMCParticle* startParticle, Int_t& nSteps);
	96
	97
	98
	99	static const Double_t fgkClight; // Speed of light (cm/ps)
	100
	101	AliESDEvent* fESD; //! ESD object
	102	AliAODEvent* fAOD; //! AOD object
	103	AliMCEvent* fMC; //! MC object
	104	AliStack* fMCStack; //! MC ESD stack
	105	TClonesArray* fMCArray; //! MC array for AOD
	106	AliAnalysisFilter* fTrackFilterGolden; // Track Filter, set 2010 with golden cuts
	107	AliAnalysisFilter* fTrackFilterTPC; // track filter for TPC only tracks
	108	TString fCentEst; // V0A , V0M,
109	TString fAnalysisType; // "ESD" or "AOD"
110	Bool_t fAnalysisMC; // Real(kFALSE) or MC(kTRUE) flag
111	Bool_t fAnalysisPbPb; // true you want to analyze PbPb data, false for pp
112	UInt_t ftrigBit;
113	TRandom* fRandom; //! random number generator
114	Bool_t fPileUpRej; // kTRUE is pile-up is rejected
115
116
117
118	//
119	// Cuts and options
120	//
121
122	Double_t fVtxCut; // Vtx cut on z position in cm
123	Double_t fEtaCut; // Eta cut used to select particles
124	Float_t fMinCent; //minimum centrality
125	Float_t fMaxCent; //maximum centrality
126	Bool_t fStoreMcIn; // Store MC input tracks
127	//
128	// Help variables
129	//
130	Short_t fMcProcessType; // -1=invalid, 0=data, 1=ND, 2=SD, 3=DD
131	Short_t fTriggeredEventMB; // 1 = triggered, 0 = not trigged (MC only)
132	Short_t fVtxStatus; // -1 = no vtx, 0 = outside cut, 1 = inside cut
133	Float_t fZvtx; // z vertex
134	Float_t fZvtxMC; // z vertex MC (truth)
135	Int_t fRun; // run no
136	ULong64_t fEventId; // unique event id
137
138	//
139	// Output objects
140	//
141	TList* fListOfObjects; //! Output list of objects
142	TH1I* fEvents; //! No of accepted events
143	TH1I* fVtx; //! Event vertex info
144	TH1F* fVtxMC; //! Event vertex info for ALL MC events
145	TH1F* fVtxBeforeCuts; //! Vertex z dist before cuts
146	TH1F* fVtxAfterCuts; //! Vertex z dist after cuts
147	TH1F* fn1;
148	TH1F* fcent;
149
150	TH2D *hMIPVsEta;
151	TProfile *pMIPVsEta;
152	TH2D *hMIPVsEtaV0s;
153	TProfile *pMIPVsEtaV0s;
154	TH2D *hPlateauVsEta;
155	TProfile *pPlateauVsEta;
156	TH2D *hPhi;
157
158	TH2D *hMIPVsNch[9];
159	TProfile *pMIPVsNch[9];
160
161	TH2D *hMIPVsPhi[9];
162	TProfile *pMIPVsPhi[9];
163	TH2D *hPlateauVsPhi[9];
164	TProfile *pPlateauVsPhi[9];
165
166	TH2D* histPiV0[9];
b5c45a25	167	TH1D* histpPiV0[9];
b5c45a25	168
bb6f433c	169	TH2D* histPV0[9];
b5c45a25	170	TH1D* histpPV0[9];
bb6f433c	171
bb6f433c	172	TH2D* histAllCh[9];
b5c45a25	173
bb6f433c	174	TH2D* histPiTof[9];
b5c45a25	175	TH1D* histpPiTof[9];
b5c45a25	176
bb6f433c	177	TH2D* histEV0[9];
b5c45a25	178
bb6f433c	179	TH1D* hMcIn[7][9];
	180	TH1D* hMcOut[7][9];
	181
b5c45a25	182	AliAnalysisTaskQAHighPtDeDx(const AliAnalysisTaskQAHighPtDeDx&); // not implemented
b5c45a25	183	AliAnalysisTaskQAHighPtDeDx& operator=(const AliAnalysisTaskQAHighPtDeDx&); // not implemented
bb6f433c	184
	185	//TTree* fTree; //! Debug tree
	186
	187	ClassDef(AliAnalysisTaskQAHighPtDeDx, 1); //Analysis task for high pt analysis
	188	};
	189
	190	#endif