[u/mrichter/AliRoot.git] / PWGLF / SPECTRA / IdentifiedHighPt / train / AliAnalysisTaskHighPtDeDx.h

#ifndef ALIANALYSISTASKHIGHPTDEDX_H
#define ALIANALYSISTASKHIGHPTDEDX_H

// ROOT includes
#include <TList.h>
#include <TH1.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>
#include "DebugClassesMultESA2013.h"


class AliAnalysisTaskHighPtDeDx : public AliAnalysisTaskSE {
 public:
  enum AnalysisMode { kInvalid = -1, kGlobalTrk = 0x1, kTPCTrk = 0x2 }; 
  AliAnalysisTaskHighPtDeDx();
  AliAnalysisTaskHighPtDeDx(const char *name);

  virtual ~AliAnalysisTaskHighPtDeDx();

  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 GetEtaCutStack() { return fEtaCutStack; }   
  Double_t GetMinPt() { return fMinPt; }   
  Double_t GetMinPtV0() { return fMinPtV0; }
  Int_t    GetTreeOption() { return fTreeOption; }

  virtual void  SetTrigger1(UInt_t ktriggerInt1) {ftrigBit1 = ktriggerInt1;}
  virtual void  SetTrigger2(UInt_t ktriggerInt2) {ftrigBit2 = ktriggerInt2;}
  virtual void  SetTrackFilter(AliAnalysisFilter* trackF) {fTrackFilter = trackF;}
  virtual void  SetTrackFilterGolden(AliAnalysisFilter* trackF) {fTrackFilterGolden = trackF;}
  virtual void  SetTrackFilterTPC(AliAnalysisFilter* trackF) {fTrackFilterTPC = trackF;}
  virtual void  SetProduceVZEROBranch(Bool_t prodvzerob) {fVZEROBranch = prodvzerob;}
  virtual void  SetProduceTPCBranch(Bool_t prodtpcb) {fTPCBranch = prodtpcb;}
  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  SetEtaCutStack(Double_t etaCutStack){fEtaCutStack = etaCutStack;}
  virtual void  SetMinPt(Double_t value) {fMinPt = value;}   
  virtual void  SetMinPtV0(Double_t value) {fMinPtV0 = value;}
  virtual void  SetMinCent(Float_t minvalc) {fMinCent = minvalc;}
  virtual void  SetMaxCent(Float_t maxvalc) {fMaxCent = maxvalc;}
  virtual void  SetLowPtFraction(Double_t value) {fLowPtFraction = value;}   
  virtual void  SetMassCut(Double_t massCut){fMassCut = massCut;}
  virtual void  SetTreeOption(Int_t value) {fTreeOption = value;}    
  virtual void  SetRequireRecV0(Bool_t value) {fRequireRecV0 = value;}
  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, AnalysisMode anamode );
  virtual void ProduceArrayV0ESD(AliESDEvent* event, AnalysisMode anamode );
  virtual void ProduceArrayTrksAOD(AliAODEvent* event, AnalysisMode anamode );
  virtual void ProduceArrayV0AOD(AliAODEvent* event, AnalysisMode anamode );
  Short_t   GetPidCode(Int_t pdgCode) const;
  Float_t   GetSpherocity(AliESDEvent* event, AliAnalysisFilter* cuts, Float_t etacut, Float_t ptcut, Bool_t useTPCtrack);
  Float_t   GetSphericity(AliESDEvent* event, AliAnalysisFilter* cuts, Float_t etacut, Float_t ptcut, Bool_t useTPCtrack);
  Float_t   GetSpherocityTrue(AliStack *Stack, Float_t etacut, Float_t ptcut);
  Float_t   GetSphericityTrue(AliStack *Stack, Float_t etacut, Float_t ptcut);

  void      ProcessMCTruthESD();
  void      ProcessMCTruthAOD(); 
  void      Sort(TClonesArray* array, Bool_t isMC);
  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);

  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* fTrackFilter;    //  Track Filter, old cuts 2010
  AliAnalysisFilter* fTrackFilterGolden;    //  Track Filter, set 2010 with golden cuts
  AliAnalysisFilter* fTrackFilterTPC; // track filter for TPC only tracks
  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
  Bool_t        fVZEROBranch;         //true if you want to store VZERO cells information
  Bool_t        fTPCBranch;           //tru if you want to produce the TPC branch
  TRandom*      fRandom;              //! random number generator
  DeDxEvent*    fEvent;               //! event pointer
  TClonesArray* fTrackArrayGlobalPar;          //! track array pointer, global tracks
  TClonesArray* fTrackArrayTPCPar;          //! track array pointer, tpc track parameters
  TClonesArray* fV0ArrayGlobalPar;             //! V0 array pointer, global tracks
  TClonesArray* fV0ArrayTPCPar;             //! V0 array pointer, tpc tracks
  TClonesArray* fTrackArrayMC;        //! MC track array pointer
  TClonesArray* fVZEROArray;          //! array of the v0 cells.


  //
  // Cuts and options
  //
  UInt_t       ftrigBit1;
  UInt_t       ftrigBit2;
  Double_t     fVtxCut;             // Vtx cut on z position in cm
  Double_t     fEtaCut;             // Eta cut used to select particles
  Double_t     fEtaCutStack;        // Eta cut used to select particles - reduce saved stack size
  Double_t     fMinPt;              // Min pt - for histogram limits
  Double_t     fMinPtV0;            // Min pt - for histogram limits - V0s / strangeness part
  Double_t     fLowPtFraction;      // Fraction of tracks below min pt to keep
  Double_t     fMassCut;            // Reject all v0 with all dmass > masscut!
  Int_t        fTreeOption;         // 0: no tree, >0: enable debug tree
  Float_t      fMinCent; //minimum centrality
  Float_t      fMaxCent; //maximum centrality
  Bool_t       fRequireRecV0;       // Require a v0 before updating tree
                                    // For a spectra analysis we will need to
                                    // keep track also of the empty events
  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
  TH1I*         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* fn2;
  TH1F* fcent;
  TTree*        fTree;              //! Debug tree 

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

#endif
Commit	Line	Data
d803655a	1	#ifndef ALIANALYSISTASKHIGHPTDEDX_H
	2	#define ALIANALYSISTASKHIGHPTDEDX_H
	3
	4	// ROOT includes
	5	#include <TList.h>
	6	#include <TH1.h>
	7	#include <TTreeStream.h>
	8	#include <TRandom.h>
	9	#include <TObject.h>
	10
	11	// AliRoot includes
	12	#include <AliAnalysisTaskSE.h>
	13	#include <AliESDEvent.h>
	14	#include <AliAODEvent.h>
	15	#include <AliMCEvent.h>
	16	#include <AliAnalysisFilter.h>
	17	#include <AliStack.h>
	18	#include <AliGenEventHeader.h>
	19	#include <AliVHeader.h>
	20	#include <AliAODMCParticle.h>
	21	#include <AliESDtrackCuts.h>
	22	#include "DebugClassesMultESA2013.h"
	23
	24
	25
	26	class AliAnalysisTaskHighPtDeDx : public AliAnalysisTaskSE {
	27	public:
	28	enum AnalysisMode { kInvalid = -1, kGlobalTrk = 0x1, kTPCTrk = 0x2 };
	29	AliAnalysisTaskHighPtDeDx();
	30	AliAnalysisTaskHighPtDeDx(const char *name);
	31
	32	virtual ~AliAnalysisTaskHighPtDeDx();
	33
	34	virtual void UserCreateOutputObjects();
	35	virtual void UserExec(Option_t *option);
	36
	37	Bool_t GetAnalysisMC() { return fAnalysisMC; }
	38	Double_t GetVtxCut() { return fVtxCut; }
	39	Double_t GetEtaCut() { return fEtaCut; }
e069b94c	40	Double_t GetEtaCutStack() { return fEtaCutStack; }
d803655a	41	Double_t GetMinPt() { return fMinPt; }
	42	Double_t GetMinPtV0() { return fMinPtV0; }
	43	Int_t GetTreeOption() { return fTreeOption; }
	44
	45	virtual void SetTrigger1(UInt_t ktriggerInt1) {ftrigBit1 = ktriggerInt1;}
	46	virtual void SetTrigger2(UInt_t ktriggerInt2) {ftrigBit2 = ktriggerInt2;}
	47	virtual void SetTrackFilter(AliAnalysisFilter* trackF) {fTrackFilter = trackF;}
	48	virtual void SetTrackFilterGolden(AliAnalysisFilter* trackF) {fTrackFilterGolden = trackF;}
	49	virtual void SetTrackFilterTPC(AliAnalysisFilter* trackF) {fTrackFilterTPC = trackF;}
	50	virtual void SetProduceVZEROBranch(Bool_t prodvzerob) {fVZEROBranch = prodvzerob;}
	51	virtual void SetProduceTPCBranch(Bool_t prodtpcb) {fTPCBranch = prodtpcb;}
	52	virtual void SetAnalysisType(const char* analysisType) {fAnalysisType = analysisType;}
	53	virtual void SetAnalysisMC(Bool_t isMC) {fAnalysisMC = isMC;}
	54	virtual void SetVtxCut(Double_t vtxCut){fVtxCut = vtxCut;}
	55	virtual void SetEtaCut(Double_t etaCut){fEtaCut = etaCut;}
e069b94c	56	virtual void SetEtaCutStack(Double_t etaCutStack){fEtaCutStack = etaCutStack;}
d803655a	57	virtual void SetMinPt(Double_t value) {fMinPt = value;}
	58	virtual void SetMinPtV0(Double_t value) {fMinPtV0 = value;}
	59	virtual void SetMinCent(Float_t minvalc) {fMinCent = minvalc;}
	60	virtual void SetMaxCent(Float_t maxvalc) {fMaxCent = maxvalc;}
	61	virtual void SetLowPtFraction(Double_t value) {fLowPtFraction = value;}
	62	virtual void SetMassCut(Double_t massCut){fMassCut = massCut;}
	63	virtual void SetTreeOption(Int_t value) {fTreeOption = value;}
	64	virtual void SetRequireRecV0(Bool_t value) {fRequireRecV0 = value;}
	65	virtual void SetStoreMcIn(Bool_t value) {fStoreMcIn = value;}
	66	virtual void SetAnalysisPbPb(Bool_t isanaPbPb) {fAnalysisPbPb = isanaPbPb;}
	67
	68	private:
	69	virtual Float_t GetVertex(const AliVEvent* event) const;
	70	virtual void AnalyzeESD(AliESDEvent* esd);
	71	virtual void AnalyzeAOD(AliAODEvent* aod);
	72	virtual void ProduceArrayTrksESD(AliESDEvent* event, AnalysisMode anamode );
	73	virtual void ProduceArrayV0ESD(AliESDEvent* event, AnalysisMode anamode );
	74	virtual void ProduceArrayTrksAOD(AliAODEvent* event, AnalysisMode anamode );
	75	virtual void ProduceArrayV0AOD(AliAODEvent* event, AnalysisMode anamode );
	76	Short_t GetPidCode(Int_t pdgCode) const;
	77	Float_t GetSpherocity(AliESDEvent* event, AliAnalysisFilter* cuts, Float_t etacut, Float_t ptcut, Bool_t useTPCtrack);
	78	Float_t GetSphericity(AliESDEvent* event, AliAnalysisFilter* cuts, Float_t etacut, Float_t ptcut, Bool_t useTPCtrack);
	79	Float_t GetSpherocityTrue(AliStack *Stack, Float_t etacut, Float_t ptcut);
	80	Float_t GetSphericityTrue(AliStack *Stack, Float_t etacut, Float_t ptcut);
	81
	82	void ProcessMCTruthESD();
	83	void ProcessMCTruthAOD();
	84	void Sort(TClonesArray* array, Bool_t isMC);
	85	Short_t GetPythiaEventProcessType(Int_t pythiaType);
	86	Short_t GetDPMjetEventProcessType(Int_t dpmJetType);
	87	ULong64_t GetEventIdAsLong(AliVHeader* header) const;
	88
	89	TParticle* FindPrimaryMother(AliStack* stack, Int_t label);
	90	Int_t FindPrimaryMotherLabel(AliStack* stack, Int_t label);
	91
	92	AliAODMCParticle* FindPrimaryMotherAOD(AliAODMCParticle* startParticle);
	93
	94	TParticle* FindPrimaryMotherV0(AliStack* stack, Int_t label);
	95	Int_t FindPrimaryMotherLabelV0(AliStack* stack, Int_t label, Int_t& nSteps);
	96
	97	AliAODMCParticle* FindPrimaryMotherAODV0(AliAODMCParticle* startParticle, Int_t& nSteps);
	98
	99
	100
	101	static const Double_t fgkClight; // Speed of light (cm/ps)
	102
	103	AliESDEvent* fESD; //! ESD object
	104	AliAODEvent* fAOD; //! AOD object
	105	AliMCEvent* fMC; //! MC object
	106	AliStack* fMCStack; //! MC ESD stack
	107	TClonesArray* fMCArray; //! MC array for AOD
	108	AliAnalysisFilter* fTrackFilter; // Track Filter, old cuts 2010
	109	AliAnalysisFilter* fTrackFilterGolden; // Track Filter, set 2010 with golden cuts
	110	AliAnalysisFilter* fTrackFilterTPC; // track filter for TPC only tracks
	111	TString fAnalysisType; // "ESD" or "AOD"
	112	Bool_t fAnalysisMC; // Real(kFALSE) or MC(kTRUE) flag
	113	Bool_t fAnalysisPbPb; // true you want to analyze PbPb data, false for pp
	114	Bool_t fVZEROBranch; //true if you want to store VZERO cells information
	115	Bool_t fTPCBranch; //tru if you want to produce the TPC branch
	116	TRandom* fRandom; //! random number generator
	117	DeDxEvent* fEvent; //! event pointer
	118	TClonesArray* fTrackArrayGlobalPar; //! track array pointer, global tracks
	119	TClonesArray* fTrackArrayTPCPar; //! track array pointer, tpc track parameters
	120	TClonesArray* fV0ArrayGlobalPar; //! V0 array pointer, global tracks
121	TClonesArray* fV0ArrayTPCPar; //! V0 array pointer, tpc tracks
122	TClonesArray* fTrackArrayMC; //! MC track array pointer
123	TClonesArray* fVZEROArray; //! array of the v0 cells.
124
125
126	//
127	// Cuts and options
128	//
129	UInt_t ftrigBit1;
130	UInt_t ftrigBit2;
131	Double_t fVtxCut; // Vtx cut on z position in cm
132	Double_t fEtaCut; // Eta cut used to select particles
e069b94c	133	Double_t fEtaCutStack; // Eta cut used to select particles - reduce saved stack size
d803655a	134	Double_t fMinPt; // Min pt - for histogram limits
e069b94c	135	Double_t fMinPtV0; // Min pt - for histogram limits - V0s / strangeness part
d803655a	136	Double_t fLowPtFraction; // Fraction of tracks below min pt to keep
	137	Double_t fMassCut; // Reject all v0 with all dmass > masscut!
	138	Int_t fTreeOption; // 0: no tree, >0: enable debug tree
	139	Float_t fMinCent; //minimum centrality
	140	Float_t fMaxCent; //maximum centrality
	141	Bool_t fRequireRecV0; // Require a v0 before updating tree
	142	// For a spectra analysis we will need to
	143	// keep track also of the empty events
	144	Bool_t fStoreMcIn; // Store MC input tracks
	145	//
	146	// Help variables
	147	//
	148	Short_t fMcProcessType; // -1=invalid, 0=data, 1=ND, 2=SD, 3=DD
	149	Short_t fTriggeredEventMB; // 1 = triggered, 0 = not trigged (MC only)
	150	Short_t fVtxStatus; // -1 = no vtx, 0 = outside cut, 1 = inside cut
	151	Float_t fZvtx; // z vertex
	152	Float_t fZvtxMC; // z vertex MC (truth)
	153	Int_t fRun; // run no
	154	ULong64_t fEventId; // unique event id
	155
	156	//
	157	// Output objects
	158	//
	159	TList* fListOfObjects; //! Output list of objects
	160	TH1I* fEvents; //! No of accepted events
	161	TH1I* fVtx; //! Event vertex info
	162	TH1I* fVtxMC; //! Event vertex info for ALL MC events
	163	TH1F* fVtxBeforeCuts; //! Vertex z dist before cuts
	164	TH1F* fVtxAfterCuts; //! Vertex z dist after cuts
	165	TH1F* fn1;
	166	TH1F* fn2;
	167	TH1F* fcent;
	168	TTree* fTree; //! Debug tree
	169
	170	ClassDef(AliAnalysisTaskHighPtDeDx, 1); //Analysis task for high pt analysis
	171	};
	172
	173	#endif