[u/mrichter/AliRoot.git] / PWGJE / AliAnalysisTaskJetProperties.h

// *************************************************************************************
// * Task for Jetproperties and jet shape analysis in PWG4 Jet Task Force Train for pp *
// *************************************************************************************

#ifndef ALIANALYSISTASKJETPROPERTIES_H
#define ALIANALYSISTASKJETPROPERTIES_H

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

/* $Id$ */

class AliESDEvent;
class AliAODEvent;
class AliAODExtension;
class TList;
class TH1F;
class TH2F;
class TH3F;
class TProfile;
class THnSparse; 
class TRandom3;
class TArrayS;

#include "AliAnalysisTaskSE.h"

class AliAnalysisTaskJetProperties : public AliAnalysisTaskSE {
  
 public:
  AliAnalysisTaskJetProperties(); 
  AliAnalysisTaskJetProperties(const char *name);
  virtual ~AliAnalysisTaskJetProperties();
  
  virtual Bool_t Notify();
  virtual void   UserCreateOutputObjects();
  virtual void   Init();
  virtual void   UserExec(Option_t *option);
  virtual void   Terminate(Option_t* );
  
  virtual void   SetJetBranch(const char* c){fBranchJets = c;}
  virtual void   SetNonStdFile(char* c){fNonStdFile = c;}
  virtual void   SetTrackType(Int_t i){fTrackType = i;}
  virtual void   SetEventCuts(Float_t VtxZ=10.,Int_t nContributors=2)
  {fMaxVertexZ = VtxZ; fNContributors = nContributors;}
  virtual void   SetTrackCuts(Float_t trackPt = 0.15, Float_t trackEtaMin = -0.9, Float_t trackEtaMax = 0.9)
  {fTrackPtCut = trackPt; fTrackEtaMin = trackEtaMin; fTrackEtaMax = trackEtaMax;}
  virtual void   SetPileupRejection(Bool_t IsPileupReject){fRejectPileup = IsPileupReject;}
  virtual void   SetJetCuts(Float_t jetPt = 5., Float_t jetEtaMin = -0.5, Float_t jetEtaMax = 0.5) 
  {fJetPtCut = jetPt; fJetEtaMin = jetEtaMin; fJetEtaMax = jetEtaMax;}
  virtual void   SetJetRejectType(Int_t i){fJetRejectType = i;}
  virtual void   SetFilterMask(UInt_t i) {fFilterMask = i;}
  virtual void   UsePhysicsSelection(Bool_t b) {fUsePhysicsSelection = b;}
  virtual void   SetJetRadius(Float_t r){fJetRadius = r;}
  
  enum {kTrackUndef=0, kTrackAOD, kTrackKine,kTrackAODMC};//for track selection
  enum {kNoReject=0, kReject1Track};//for jet rejection
  enum {kRejectPileup=1};//for pileup rejection
 protected:
  Int_t	   GetListOfJetTracks(TList* l, const AliAODJet* j);
  Int_t	   GetListOfJets(TList* list);
  void     FillJetProperties(TList *jetlist);
  void     FillJetShape(TList *jetlist);
  void     FillJetShapeUE(TList *jetlist);
  void     FillFFCorr(TList *jetlist);

  void     GetTracksTiltedwrpJetAxis(Float_t alpha, TList* inputlist, TList* outputlist, const AliAODJet* jet, Double_t radius,Double_t& sumPt);
  Int_t    GetListOfTracks(TList *list, Int_t type);
  
  AliESDEvent*     fESD;          // ESD event
  AliAODEvent*     fAOD;          // AOD event
  AliAODEvent*     fAODJets;      // AOD event with jet branch (case we have AOD both in input and output)
  AliAODExtension* fAODExtension; //! where we take the jets from can be input or output AOD
  //AliMCEvent*  fMCEvent;  // MC event
  
  TString fNonStdFile;          // name of delta aod file to catch the extension
  TString fBranchJets;          // branch name for reconstructed jets
  Int_t   fTrackType;           // type of generated tracks
  Int_t   fJetRejectType;       // type of jets rejected
  Bool_t  fRejectPileup;        // pileup rejection
  Bool_t  fUseAODInputJets;     // take jets from in/output - only relevant if AOD event both in input AND output and we want to use output
  UInt_t  fFilterMask;	        // filter bit for selected tracks
  Bool_t  fUsePhysicsSelection; // switch for event selection
  Float_t fMaxVertexZ;          // maximum abs(z) position of primiary vertex [cm]
  Int_t   fNContributors;       // contributors to primary vertex
  // track cuts
  Float_t fTrackPtCut;          // track transverse momentum cut
  Float_t fTrackEtaMin;         // track eta cut
  Float_t fTrackEtaMax;         // track eta cut
  // jet cuts
  Float_t fJetPtCut;            // jet transverse momentum cut
  Float_t fJetEtaMin;           // jet eta cut
  Float_t fJetEtaMax;           // jet eta cut
  Float_t fAvgTrials;           // average number of trials per event
  Float_t fJetRadius;
  
  TList	    *fJetList;                //! List of jets
  TList	    *fTrackList;              //! List of selected tracks
  TList	    *fTrackListUE;            //! List of tracks in jet cone UE
  TList	    *fTrackListJet;           //! List of tracks in a jet
  TList	    *fCommonHistList;         //! List of common histos
  TH1F      *fh1EvtSelection;         //! event cuts 
  TH1F	    *fh1VertexNContributors;  //! NContributors to prim vertex
  TH1F	    *fh1VertexZ;              //! prim vertex z distribution
  TProfile  *fh1Xsec;                 //! pythia cross section and trials
  TH1F*     fh1Trials;                //! sum of trials
  TH1F*     fh1PtHard;                //! pt hard of the event
  TH1F*     fh1PtHardTrials;          //! pt hard of the event
 
  TH2F*     fh2EtaJet;                //!jet eta distribution
  TH2F*     fh2PhiJet;                //!jet phi distribution
  TH2F*     fh2PtJet;                 //!jet pt distribution
  TH1F*     fh1PtJet;                 //!jet pt distribution 1D
  TH2F*     fh2NtracksJet;            //!number of tracks in jet
  TProfile* fProNtracksJet;           //!number of tracks in jet
  TH2F*     fh2EtaTrack;              //!track eta distribution
  TH2F*     fh2PhiTrack;              //!track phi distribution
  TH2F*     fh2PtTrack;               //!track pt distribution
  TH2F*     fh2FF;                    //!fragmentation function (z)
  TH2F*     fh2Ksi;                   //!fragmentation function (Ksi)
  TH2F*     fh2DelEta;                //!delta eta distribution
  TH2F*     fh2DelPhi;                //!delta phi distribution
  TH2F*     fh2DelR;                  //!delta R distribution
  
  TH1F*     fh1PtLeadingJet;          //!highest jet pt
  TH2F*     fh2NtracksLeadingJet;     //!number of tracks in jet
  TProfile* fProNtracksLeadingJet;    //!number of tracks in jet
  TH2F*     fh2DelR80pcNch;           //!R containing 80% of Nch vs jet pt
  TProfile* fProDelR80pcNch;          //!R containing 80% of Nch vs jet pt
  TH2F*     fh2DelR80pcPt;            //!R containing 80% of pT vs jet pt
  TProfile* fProDelR80pcPt;           //!R containing 80% of pT vs jet pt
  TH2F*     fh2AreaCh;                //!charged jet area vs jet pT
  TProfile* fProAreaCh;               //!charged jet area vs jet pT
  TH3F*     fh3PtDelRNchSum;          //!Nch sum vs R
  TH3F*     fh3PtDelRPtSum;           //!Pt sum vs R
  TProfile* fProDiffJetShape;         //!Diff jet shape pT=20-100
  TProfile* fProIntJetShape;          //!Int jet shape pT=20-100
  TProfile* fProDelRNchSum[13];        //!Nch sum vs R
  TProfile* fProDelRPtSum[13];         //!Pt sum vs R
  TProfile* fProDiffJetShapeA[13];     //!Diff jet shape pT
  TProfile* fProIntJetShapeA[13];      //!Int jet shape pT

  TH1F*     fh1PtSumInJetConeUE;        //!pt sum of UE in cone R
  TH2F*     fh2NtracksLeadingJetUE;     //!number of tracks in jet (UE)
  TProfile* fProNtracksLeadingJetUE;    //!number of tracks in jet (UE)
  TH2F*     fh2DelR80pcNchUE;           //!R containing 80% of Nch vs jet pt (UE)
  TProfile* fProDelR80pcNchUE;          //!R containing 80% of Nch vs jet pt (UE)
  TH2F*     fh2DelR80pcPtUE;            //!R containing 80% of pT vs jet pt (UE)
  TProfile* fProDelR80pcPtUE;           //!R containing 80% of pT vs jet pt (UE)
  TH2F*     fh2AreaChUE;                //!charged jet area vs jet pT (UE)
  TProfile* fProAreaChUE;               //!charged jet area vs jet pT (UE)
  TH3F*     fh3PtDelRNchSumUE;          //!Nch sum vs R (UE)
  TH3F*     fh3PtDelRPtSumUE;           //!Pt sum vs R (UE)
  TProfile* fProDiffJetShapeUE;         //!Diff jet shape pT=20-100 (UE)
  TProfile* fProIntJetShapeUE;          //!Int jet shape pT=20-100 (UE)
  TProfile* fProDelRNchSumUE[13];        //!Nch sum vs R (UE)
  TProfile* fProDelRPtSumUE[13];         //!Pt sum vs R (UE)
  TProfile* fProDiffJetShapeAUE[13];     //!Diff jet shape pT (UE)
  TProfile* fProIntJetShapeAUE[13];      //!Int jet shape pT (UE)

  TH1F* fh1CorrJetPt;                    //!jet pt in FillCorr
  TH2F* fh2CorrPtTrack1;                 //!trk pt in FillCorr
  TH2F* fh2CorrFF1;                      //!FF in FillCorr
  TH2F* fh2CorrKsi1;                     //!Ksi in FillCorr
  TH2F* fh2CorrjT1;                      //!jT in FillCorr
  TH1F* fh1JetPtvsTrkSum;                //!QA plots to check jetPt-trkPtsum
  TH2F* fh2CorrPt1Pt2[6];                //!pt1-pt2 in FillCorr
  TH2F* fh2CorrZ1Z2[6];                  //!z1-z2 in FillCorr
  TH2F* fh2CorrKsi1Ksi2[6];              //!ksi1-ksi2 in FillCorr
  TH2F* fh2CorrjT1jT2[6];                //!jt1-jt2 in FillCorr
  
  AliAnalysisTaskJetProperties(const AliAnalysisTaskJetProperties&);// not implemented
  AliAnalysisTaskJetProperties& operator=(const AliAnalysisTaskJetProperties&);// not implemented
  ClassDef(AliAnalysisTaskJetProperties, 2);
};

#endif
Commit	Line	Data
59a5935a	1	// *************************************************************************************
	2	// * Task for Jetproperties and jet shape analysis in PWG4 Jet Task Force Train for pp *
	3	// *************************************************************************************
	4
	5	#ifndef ALIANALYSISTASKJETPROPERTIES_H
	6	#define ALIANALYSISTASKJETPROPERTIES_H
	7
	8	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	9	* See cxx source for full Copyright notice */
	10
	11	/* $Id$ */
	12
	13	class AliESDEvent;
	14	class AliAODEvent;
	15	class AliAODExtension;
	16	class TList;
	17	class TH1F;
	18	class TH2F;
	19	class TH3F;
	20	class TProfile;
	21	class THnSparse;
	22	class TRandom3;
	23	class TArrayS;
	24
	25	#include "AliAnalysisTaskSE.h"
	26
	27	class AliAnalysisTaskJetProperties : public AliAnalysisTaskSE {
	28
	29	public:
	30	AliAnalysisTaskJetProperties();
	31	AliAnalysisTaskJetProperties(const char *name);
	32	virtual ~AliAnalysisTaskJetProperties();
	33
	34	virtual Bool_t Notify();
	35	virtual void UserCreateOutputObjects();
	36	virtual void Init();
	37	virtual void UserExec(Option_t *option);
	38	virtual void Terminate(Option_t* );
	39
	40	virtual void SetJetBranch(const char* c){fBranchJets = c;}
bd8f39b7	41	virtual void SetNonStdFile(char* c){fNonStdFile = c;}
59a5935a	42	virtual void SetTrackType(Int_t i){fTrackType = i;}
	43	virtual void SetEventCuts(Float_t VtxZ=10.,Int_t nContributors=2)
	44	{fMaxVertexZ = VtxZ; fNContributors = nContributors;}
	45	virtual void SetTrackCuts(Float_t trackPt = 0.15, Float_t trackEtaMin = -0.9, Float_t trackEtaMax = 0.9)
	46	{fTrackPtCut = trackPt; fTrackEtaMin = trackEtaMin; fTrackEtaMax = trackEtaMax;}
e84e0b8d	47	virtual void SetPileupRejection(Bool_t IsPileupReject){fRejectPileup = IsPileupReject;}
59a5935a	48	virtual void SetJetCuts(Float_t jetPt = 5., Float_t jetEtaMin = -0.5, Float_t jetEtaMax = 0.5)
	49	{fJetPtCut = jetPt; fJetEtaMin = jetEtaMin; fJetEtaMax = jetEtaMax;}
	50	virtual void SetJetRejectType(Int_t i){fJetRejectType = i;}
	51	virtual void SetFilterMask(UInt_t i) {fFilterMask = i;}
	52	virtual void UsePhysicsSelection(Bool_t b) {fUsePhysicsSelection = b;}
597a0905	53	virtual void SetJetRadius(Float_t r){fJetRadius = r;}
59a5935a	54
	55	enum {kTrackUndef=0, kTrackAOD, kTrackKine,kTrackAODMC};//for track selection
	56	enum {kNoReject=0, kReject1Track};//for jet rejection
e84e0b8d	57	enum {kRejectPileup=1};//for pileup rejection
59a5935a	58	protected:
	59	Int_t GetListOfJetTracks(TList* l, const AliAODJet* j);
	60	Int_t GetListOfJets(TList* list);
	61	void FillJetProperties(TList *jetlist);
	62	void FillJetShape(TList *jetlist);
597a0905	63	void FillJetShapeUE(TList *jetlist);
8c37dfbf	64	void FillFFCorr(TList *jetlist);
8c37dfbf	65
597a0905	66	void GetTracksTiltedwrpJetAxis(Float_t alpha, TList* inputlist, TList* outputlist, const AliAODJet* jet, Double_t radius,Double_t& sumPt);
597a0905	67	Int_t GetListOfTracks(TList *list, Int_t type);
59a5935a	68
	69	AliESDEvent* fESD; // ESD event
	70	AliAODEvent* fAOD; // AOD event
	71	AliAODEvent* fAODJets; // AOD event with jet branch (case we have AOD both in input and output)
	72	AliAODExtension* fAODExtension; //! where we take the jets from can be input or output AOD
	73	//AliMCEvent* fMCEvent; // MC event
	74
	75	TString fNonStdFile; // name of delta aod file to catch the extension
	76	TString fBranchJets; // branch name for reconstructed jets
	77	Int_t fTrackType; // type of generated tracks
	78	Int_t fJetRejectType; // type of jets rejected
e84e0b8d	79	Bool_t fRejectPileup; // pileup rejection
59a5935a	80	Bool_t fUseAODInputJets; // take jets from in/output - only relevant if AOD event both in input AND output and we want to use output
	81	UInt_t fFilterMask; // filter bit for selected tracks
	82	Bool_t fUsePhysicsSelection; // switch for event selection
	83	Float_t fMaxVertexZ; // maximum abs(z) position of primiary vertex [cm]
	84	Int_t fNContributors; // contributors to primary vertex
	85	// track cuts
	86	Float_t fTrackPtCut; // track transverse momentum cut
	87	Float_t fTrackEtaMin; // track eta cut
	88	Float_t fTrackEtaMax; // track eta cut
	89	// jet cuts
	90	Float_t fJetPtCut; // jet transverse momentum cut
	91	Float_t fJetEtaMin; // jet eta cut
	92	Float_t fJetEtaMax; // jet eta cut
	93	Float_t fAvgTrials; // average number of trials per event
597a0905	94	Float_t fJetRadius;
59a5935a	95
59a5935a	96	TList *fJetList; //! List of jets
597a0905	97	TList *fTrackList; //! List of selected tracks
	98	TList *fTrackListUE; //! List of tracks in jet cone UE
	99	TList *fTrackListJet; //! List of tracks in a jet
59a5935a	100	TList *fCommonHistList; //! List of common histos
	101	TH1F *fh1EvtSelection; //! event cuts
	102	TH1F *fh1VertexNContributors; //! NContributors to prim vertex
	103	TH1F *fh1VertexZ; //! prim vertex z distribution
	104	TProfile *fh1Xsec; //! pythia cross section and trials
	105	TH1F* fh1Trials; //! sum of trials
	106	TH1F* fh1PtHard; //! pt hard of the event
	107	TH1F* fh1PtHardTrials; //! pt hard of the event
	108
	109	TH2F* fh2EtaJet; //!jet eta distribution
	110	TH2F* fh2PhiJet; //!jet phi distribution
	111	TH2F* fh2PtJet; //!jet pt distribution
	112	TH1F* fh1PtJet; //!jet pt distribution 1D
	113	TH2F* fh2NtracksJet; //!number of tracks in jet
	114	TProfile* fProNtracksJet; //!number of tracks in jet
	115	TH2F* fh2EtaTrack; //!track eta distribution
	116	TH2F* fh2PhiTrack; //!track phi distribution
	117	TH2F* fh2PtTrack; //!track pt distribution
8c37dfbf	118	TH2F* fh2FF; //!fragmentation function (z)
8c37dfbf	119	TH2F* fh2Ksi; //!fragmentation function (Ksi)
59a5935a	120	TH2F* fh2DelEta; //!delta eta distribution
	121	TH2F* fh2DelPhi; //!delta phi distribution
	122	TH2F* fh2DelR; //!delta R distribution
	123
	124	TH1F* fh1PtLeadingJet; //!highest jet pt
	125	TH2F* fh2NtracksLeadingJet; //!number of tracks in jet
	126	TProfile* fProNtracksLeadingJet; //!number of tracks in jet
	127	TH2F* fh2DelR80pcNch; //!R containing 80% of Nch vs jet pt
	128	TProfile* fProDelR80pcNch; //!R containing 80% of Nch vs jet pt
	129	TH2F* fh2DelR80pcPt; //!R containing 80% of pT vs jet pt
	130	TProfile* fProDelR80pcPt; //!R containing 80% of pT vs jet pt
	131	TH2F* fh2AreaCh; //!charged jet area vs jet pT
	132	TProfile* fProAreaCh; //!charged jet area vs jet pT
	133	TH3F* fh3PtDelRNchSum; //!Nch sum vs R
	134	TH3F* fh3PtDelRPtSum; //!Pt sum vs R
efabdd32	135	TProfile* fProDiffJetShape; //!Diff jet shape pT=20-100
efabdd32	136	TProfile* fProIntJetShape; //!Int jet shape pT=20-100
597a0905	137	TProfile* fProDelRNchSum[13]; //!Nch sum vs R
	138	TProfile* fProDelRPtSum[13]; //!Pt sum vs R
	139	TProfile* fProDiffJetShapeA[13]; //!Diff jet shape pT
	140	TProfile* fProIntJetShapeA[13]; //!Int jet shape pT
efabdd32	141
597a0905	142	TH1F* fh1PtSumInJetConeUE; //!pt sum of UE in cone R
	143	TH2F* fh2NtracksLeadingJetUE; //!number of tracks in jet (UE)
	144	TProfile* fProNtracksLeadingJetUE; //!number of tracks in jet (UE)
	145	TH2F* fh2DelR80pcNchUE; //!R containing 80% of Nch vs jet pt (UE)
	146	TProfile* fProDelR80pcNchUE; //!R containing 80% of Nch vs jet pt (UE)
	147	TH2F* fh2DelR80pcPtUE; //!R containing 80% of pT vs jet pt (UE)
	148	TProfile* fProDelR80pcPtUE; //!R containing 80% of pT vs jet pt (UE)
	149	TH2F* fh2AreaChUE; //!charged jet area vs jet pT (UE)
	150	TProfile* fProAreaChUE; //!charged jet area vs jet pT (UE)
	151	TH3F* fh3PtDelRNchSumUE; //!Nch sum vs R (UE)
	152	TH3F* fh3PtDelRPtSumUE; //!Pt sum vs R (UE)
	153	TProfile* fProDiffJetShapeUE; //!Diff jet shape pT=20-100 (UE)
	154	TProfile* fProIntJetShapeUE; //!Int jet shape pT=20-100 (UE)
	155	TProfile* fProDelRNchSumUE[13]; //!Nch sum vs R (UE)
	156	TProfile* fProDelRPtSumUE[13]; //!Pt sum vs R (UE)
	157	TProfile* fProDiffJetShapeAUE[13]; //!Diff jet shape pT (UE)
	158	TProfile* fProIntJetShapeAUE[13]; //!Int jet shape pT (UE)
59a5935a	159
8c37dfbf	160	TH1F* fh1CorrJetPt; //!jet pt in FillCorr
	161	TH2F* fh2CorrPtTrack1; //!trk pt in FillCorr
	162	TH2F* fh2CorrFF1; //!FF in FillCorr
	163	TH2F* fh2CorrKsi1; //!Ksi in FillCorr
	164	TH2F* fh2CorrjT1; //!jT in FillCorr
	165	TH1F* fh1JetPtvsTrkSum; //!QA plots to check jetPt-trkPtsum
	166	TH2F* fh2CorrPt1Pt2[6]; //!pt1-pt2 in FillCorr
	167	TH2F* fh2CorrZ1Z2[6]; //!z1-z2 in FillCorr
	168	TH2F* fh2CorrKsi1Ksi2[6]; //!ksi1-ksi2 in FillCorr
	169	TH2F* fh2CorrjT1jT2[6]; //!jt1-jt2 in FillCorr
	170
59a5935a	171	AliAnalysisTaskJetProperties(const AliAnalysisTaskJetProperties&);// not implemented
59a5935a	172	AliAnalysisTaskJetProperties& operator=(const AliAnalysisTaskJetProperties&);// not implemented
efabdd32	173	ClassDef(AliAnalysisTaskJetProperties, 2);
59a5935a	174	};
	175
	176	#endif