[u/mrichter/AliRoot.git] / PWG4 / JetTasks / AliAnalysisTaskHardSoft.h

#ifndef AliAnalysisTaskHardSoft_cxx
#define AliAnalysisTaskHardSoft_cxx
 

class TH1F;
class TH2F;
class TH3F;
class TList;
class TNtuple;

class AliESDEvent;
class AliESDtrack;
class AliESDtrackCuts;


#include "AliAnalysisTaskSE.h"
#include "TFile.h"
#include "TNtuple.h"

class AliAnalysisTaskHardSoft : public AliAnalysisTaskSE {
 public:
  AliAnalysisTaskHardSoft(const char *name = "AliAnalysisTaskHardSoft");
  virtual ~AliAnalysisTaskHardSoft() {}
  
  virtual void   UserCreateOutputObjects();
  virtual void   UserExec(Option_t *option);
  virtual void   Terminate(Option_t *);
  
  virtual void   SetUseMc(Bool_t useMc)                    {fUseMc = useMc;}  
  virtual void   SetUseNeutralMC(Bool_t  useNeutral)       {fUseNeutral = useNeutral;}    

  virtual void   SetRadiusCut(Float_t radiusCut)           {fRadiusCut = radiusCut;}  
  virtual void   SetTriggerPtCut(Float_t triggerPtCut)     {fTriggerPtCut = triggerPtCut;}  
  virtual void   SetAssociatePtCut(Float_t associatePtCut) {fAssociatePtCut = associatePtCut;}  

  virtual void   SetMap(TH2F* map)                         {fMap = map;}  
  virtual void   SetMapLeading(TH2F* mapLeading)           {fMapLeading = mapLeading;}  
  
  
  virtual void   SetCuts(AliESDtrackCuts* cuts)
  {fCuts = cuts;}

  virtual void   SetFieldOn(Bool_t b = kTRUE){fFieldOn = b;} 

  
 private:

  Bool_t       fUseMc;                     // for simulated data: calculate the same for MCpartciles aswell
  Bool_t       fUseNeutral;                // use also neutral particle in MC case
  Float_t      fRadiusCut;                 // radius cut for hard/soft event determination (CDF approach)
  Float_t      fTriggerPtCut;              // first pt cut for hard/soft event determination (CDF approach)
  Float_t      fAssociatePtCut;            // first pt cut for hard/soft event determination (CDF approach)
  
  TH2F       * fMap;                       // map for eta-phi acceptance (used for random particles)
  TH2F       * fMapLeading;                // map for eta-phi acceptance (used for random particles)

  AliESDtrackCuts* fCuts;                  // List of cuts for ESDs
  Bool_t      fFieldOn;


  TList       * fHists;                    // List of histos

  //properties of particles(0)/esdtracks(1)
  TH1F       * fPt[2];                     // pt 
  TH1F       * fEta[2];                    // eta
  TH1F       * fPhi[2];                    // phi
  TH2F       * fEtaPhi[2];                 // eta-phi (needed as input for random position -> will be fMap)
  TH2F       * fEtaPhiLeading[2];          // eta-phi (needed as input for random position -> will be fMapLeading)
  TH1F       * fNch[2];                    // all accepted tracks/particles
  TH1F       * fPtLeading[2];              // pt of leading track/particle

  TProfile   * fPtLeadingNch[2];           // pt of leading track/particle vs Nch
  TProfile   * fPtSumNch[2];               // pt sum track/particle vs Nch
  TProfile   * fPtAvNch[2];                // average pt track/particle vs Nch

  TH1F       * fDPhiLeading[2];            // delta phi of associate tracks to leading track
  TH1F       * fRadiusLeading[2];          // radius of associate tracks to leading track

  TH1F       * fDPhiLeadingR[2];           // delta phi of associate tracks to leading track for random pos.
  TH1F       * fRadiusLeadingR[2];         // radius of associate tracks to leading track for random pos.

  TH1F       * fDPhiLeadingRS[2];          // delta phi of associate tracks to leading track for random seed pos.
  TH1F       * fRadiusLeadingRS[2];        // radius of associate tracks to leading track for random seed pos

  TProfile   * fNchAssInR[2];              // number of tracks within R around leading track vs Nch
  TH1F       * fTrigger[2];                // number of triggers with at accepted-track number

  //per Nch bin of all accepted tracks
  TH1F       * fDPhiLeadingNchBin[2][100]; // delta phi of associate tracks to leading track per Nch bin

  TH1F       * fNchHardSoft[2][2];         // Nch for hard and soft events (classified with CDF algorithm)
  TH1F       * fPtHardSoft[2][2];          // Pt for hard and soft events (classified with CDF algorithm)
  TProfile   * fPtAvHardSoftNch[2][2];     // <Pt> for hard and soft events (classified with CDF algorithm)


  AliAnalysisTaskHardSoft(const AliAnalysisTaskHardSoft&); // not implemented
  AliAnalysisTaskHardSoft& operator=(const AliAnalysisTaskHardSoft&); // not implemented
  
  ClassDef(AliAnalysisTaskHardSoft, 1);    // Hard and Soft event characteristics
};

#endif
Commit	Line	Data
7f092c14	1	#ifndef AliAnalysisTaskHardSoft_cxx
	2	#define AliAnalysisTaskHardSoft_cxx
	3
	4
	5	class TH1F;
	6	class TH2F;
	7	class TH3F;
	8	class TList;
	9	class TNtuple;
	10
	11	class AliESDEvent;
	12	class AliESDtrack;
	13	class AliESDtrackCuts;
	14
	15
	16	#include "AliAnalysisTaskSE.h"
	17	#include "TFile.h"
	18	#include "TNtuple.h"
	19
	20	class AliAnalysisTaskHardSoft : public AliAnalysisTaskSE {
	21	public:
	22	AliAnalysisTaskHardSoft(const char *name = "AliAnalysisTaskHardSoft");
	23	virtual ~AliAnalysisTaskHardSoft() {}
	24
	25	virtual void UserCreateOutputObjects();
	26	virtual void UserExec(Option_t *option);
	27	virtual void Terminate(Option_t *);
	28
	29	virtual void SetUseMc(Bool_t useMc) {fUseMc = useMc;}
	30	virtual void SetUseNeutralMC(Bool_t useNeutral) {fUseNeutral = useNeutral;}
	31
	32	virtual void SetRadiusCut(Float_t radiusCut) {fRadiusCut = radiusCut;}
	33	virtual void SetTriggerPtCut(Float_t triggerPtCut) {fTriggerPtCut = triggerPtCut;}
	34	virtual void SetAssociatePtCut(Float_t associatePtCut) {fAssociatePtCut = associatePtCut;}
	35
	36	virtual void SetMap(TH2F* map) {fMap = map;}
	37	virtual void SetMapLeading(TH2F* mapLeading) {fMapLeading = mapLeading;}
	38
	39
	40	virtual void SetCuts(AliESDtrackCuts* cuts)
	41	{fCuts = cuts;}
	42
	43	virtual void SetFieldOn(Bool_t b = kTRUE){fFieldOn = b;}
	44
	45
	46	private:
	47
	48	Bool_t fUseMc; // for simulated data: calculate the same for MCpartciles aswell
	49	Bool_t fUseNeutral; // use also neutral particle in MC case
	50	Float_t fRadiusCut; // radius cut for hard/soft event determination (CDF approach)
	51	Float_t fTriggerPtCut; // first pt cut for hard/soft event determination (CDF approach)
	52	Float_t fAssociatePtCut; // first pt cut for hard/soft event determination (CDF approach)
	53
	54	TH2F * fMap; // map for eta-phi acceptance (used for random particles)
	55	TH2F * fMapLeading; // map for eta-phi acceptance (used for random particles)
	56
	57	AliESDtrackCuts* fCuts; // List of cuts for ESDs
	58	Bool_t fFieldOn;
	59
	60
	61	TList * fHists; // List of histos
	62
	63	//properties of particles(0)/esdtracks(1)
	64	TH1F * fPt[2]; // pt
65	TH1F * fEta[2]; // eta
66	TH1F * fPhi[2]; // phi
67	TH2F * fEtaPhi[2]; // eta-phi (needed as input for random position -> will be fMap)
68	TH2F * fEtaPhiLeading[2]; // eta-phi (needed as input for random position -> will be fMapLeading)
69	TH1F * fNch[2]; // all accepted tracks/particles
70	TH1F * fPtLeading[2]; // pt of leading track/particle
71
72	TProfile * fPtLeadingNch[2]; // pt of leading track/particle vs Nch
73	TProfile * fPtSumNch[2]; // pt sum track/particle vs Nch
74	TProfile * fPtAvNch[2]; // average pt track/particle vs Nch
75
76	TH1F * fDPhiLeading[2]; // delta phi of associate tracks to leading track
77	TH1F * fRadiusLeading[2]; // radius of associate tracks to leading track
78
79	TH1F * fDPhiLeadingR[2]; // delta phi of associate tracks to leading track for random pos.
80	TH1F * fRadiusLeadingR[2]; // radius of associate tracks to leading track for random pos.
81
82	TH1F * fDPhiLeadingRS[2]; // delta phi of associate tracks to leading track for random seed pos.
83	TH1F * fRadiusLeadingRS[2]; // radius of associate tracks to leading track for random seed pos
84
85	TProfile * fNchAssInR[2]; // number of tracks within R around leading track vs Nch
86	TH1F * fTrigger[2]; // number of triggers with at accepted-track number
87
88	//per Nch bin of all accepted tracks
89	TH1F * fDPhiLeadingNchBin[2][100]; // delta phi of associate tracks to leading track per Nch bin
90
a2b9ced6	91	TH1F * fNchHardSoft[2][2]; // Nch for hard and soft events (classified with CDF algorithm)
	92	TH1F * fPtHardSoft[2][2]; // Pt for hard and soft events (classified with CDF algorithm)
	93	TProfile * fPtAvHardSoftNch[2][2]; // <Pt> for hard and soft events (classified with CDF algorithm)
7f092c14	94
	95
	96	AliAnalysisTaskHardSoft(const AliAnalysisTaskHardSoft&); // not implemented
	97	AliAnalysisTaskHardSoft& operator=(const AliAnalysisTaskHardSoft&); // not implemented
	98
	99	ClassDef(AliAnalysisTaskHardSoft, 1); // Hard and Soft event characteristics
	100	};
	101
	102	#endif