[u/mrichter/AliRoot.git] / PWGJE / EMCALJetTasks / UserTasks / AliAnalysisTaskEmcalJetHadEPpid.h

#ifndef AliAnalysisTaskEmcalJetHadEPpid_h
#define AliAnalysisTaskEmcalJetHadEPpid_h

// root classes
class TClonesArray;
class TH1F;
class TH2F;
class TH3F;
class THnSparse;
class TList;
class TLorentzVector;
class TGraph;

// AliROOT classes
class AliEventPoolManager;
class AliLocalRhoParameter;
// added 12/9
class AliEMCALTrack;
class AliMagF;
class AliESDEvent;
class AliAODEvent;
class AliEMCALGeometry;
class AliEMCALRecoUtils;
class AliESDtrack;

// this whole section of includes added 
#include <AliAnalysisTaskEmcalJet.h>
#include <AliEmcalJet.h>
#include <AliVEvent.h>
#include <AliVTrack.h>
#include <AliVCluster.h>
#include <TClonesArray.h>
#include <TMath.h>
#include <TRandom3.h>
#include <AliLog.h>

#include "AliAnalysisTaskLocalRho.h"
#include "AliLocalRhoParameter.h"

// PID stuff
#include "AliPIDResponse.h"

#include "AliAnalysisFilter.h"

class AliAnalysisTaskEmcalJetHadEPpid : public AliAnalysisTaskEmcalJet {
 public:
  AliAnalysisTaskEmcalJetHadEPpid();
  AliAnalysisTaskEmcalJetHadEPpid(const char *name);
  //virtual ~AliAnalysisTaskEmcalJetHadEPpid() {}
  virtual ~AliAnalysisTaskEmcalJetHadEPpid();

  virtual void            UserCreateOutputObjects();
  virtual THnSparse*      NewTHnSparseF(const char* name, UInt_t entries);
  virtual void            GetDimParams(Int_t iEntry,TString &label, Int_t &nbins, Double_t &xmin, Double_t &xmax);
  virtual THnSparse*      NewTHnSparseFPID(const char* name, UInt_t entries);
  virtual void            GetDimParamsPID(Int_t iEntry,TString &label, Int_t &nbins, Double_t &xmin, Double_t &xmax);
  void                    SetPlotGlobalRho(Bool_t g)            { doPlotGlobalRho = g; } // plot global rho switch
  void                    SetVariableBinning(Bool_t v)          { doVariableBinning = v; } // do variable binning switch
  void                    SetdoPID(Bool_t p)                    { doPID = p; }   // do PID switch
  void		          SetvarbinTHnSparse(Bool_t vb)         { dovarbinTHnSparse = vb; }
  void		          SetDataType(Bool_t data)		{ useAOD = data; }

  // getters
  TString		  GetLocalRhoName() const		{return fLocalRhoName; }

  // set names of some objects
  virtual void            SetLocalRhoName(const char *ln)          {fLocalRhoName = ln; }
  virtual void            SetTracksName(const char *tn)            {fTracksName = tn; }
  virtual void            SetJetsName(const char *jn)              {fJetsName = jn; }

  // bias and cuts
  virtual void            SetAreaCut(Double_t a)                { fAreacut    = a; }
  virtual void            SetTrkBias(Double_t b)                { fTrkBias    = b; }  //require a track with pt > b in jet
  virtual void            SetClusBias(Double_t b)               { fClusBias   = b; }  //require a cluster with pt > b in jet
  virtual void            SetTrkEta(Double_t e)                 { fTrkEta   = e; }  //eta range of the associated tracks
  virtual void            SetJetPtcut(Double_t jpt)             { fJetPtcut = jpt; } // jet pt cut
 
  // eta and phi limits of jets
  virtual void            SetJetEta(Double_t emin, Double_t emax)  { fEtamin = emin; fEtamax = emax; }
  virtual void            SetJetPhi(Double_t pmin, Double_t pmax)  { fPhimin = pmin; fPhimax = pmax; }

  // event mixing setters
  virtual void            SetEventMixing(Int_t yesno)		   { fDoEventMixing=yesno; }
  virtual void	          SetMixingTracks(Int_t tracks)		   { fMixingTracks = tracks; }

protected:
  // functions 
  void			 ExecOnce();
  Bool_t		 Run();
  virtual void           Terminate(Option_t *); 
  virtual Int_t          GetCentBin(Double_t cent) const; // centrality bin of event
  Float_t                RelativePhi(Double_t mphi,Double_t vphi) const; // relative jet track angle
  Float_t                RelativeEPJET(Double_t jetAng, Double_t EPAng) const;  // relative jet event plane angle
  virtual Int_t          GetEtaBin(Double_t eta) const;      // eta bins
  virtual Int_t          GetpTjetBin(Double_t pt) const;     // jet pt bins
  virtual Int_t          GetpTtrackBin(Double_t pt) const;   // track pt bins
  virtual Int_t          GetzVertexBin(Double_t zVtx) const; // zVertex bin
  void                   SetfHistPIDcounterLabels(TH1* fHistPID) const;  // PID counter

  // parameters of detector to cut on for event
  Double_t               fPhimin;                  // phi min
  Double_t               fPhimax;                  // phi max
  Double_t               fEtamin;                  // eta min
  Double_t               fEtamax;                  // eta max
  Double_t               fAreacut;                 // area cut
  Double_t               fTrkBias;                 // track bias
  Double_t               fClusBias;                // cluster bias
  Double_t               fTrkEta;                  // eta min/max of tracks
  Double_t	         fJetPtcut;		   // jet pt to cut on for correlations

  // event mixing
  Int_t			 fDoEventMixing;
  Int_t			 fMixingTracks;

  // switches for plots
  Bool_t		 doPlotGlobalRho;
  Bool_t		 doVariableBinning;
  Bool_t                 dovarbinTHnSparse;
 
  // data type switch
  Bool_t	         useAOD;

  // switches for PID
  Bool_t		 doPID;

  // local rho value
  Double_t		 fLocalRhoVal;

  // object names
  TString		 fTracksName;
  TString		 fJetsName;

  // event counter
  Int_t			 event;

  // boolean functions for PID
  Bool_t		 isPItpc, isKtpc, isPtpc;
  Double_t			 nPIDtpc;

  Bool_t		 isPIits, isKits, isPits;
  Double_t			 nPIDits;  

  Bool_t		 isPItof, isKtof, isPtof;
  Double_t			 nPIDtof;

  // event pool
  TObjArray*		 CloneAndReduceTrackList(TObjArray* tracks);
  AliEventPoolManager   *fPoolMgr;  // event pool Manager object

  // PID
  AliPIDResponse	*fPIDResponse;   // PID response object
  AliTPCPIDResponse	*fTPCResponse;   // TPC pid response object

 private:
  // needed for PID
  AliESDEvent     *fESD;                  //ESD object
  AliAODEvent	  *fAOD;		  //AOD object

  TH2F                  *fHistTPCdEdX;
  TH2F	                *fHistITSsignal;
//  TH2F		    *fHistTOFsignal;

  TH2F                  *fHistRhovsCent; //!
  TH2F                  *fHistNjetvsCent;//! number of jets versus Centrality
  TH2F                  *fHistJetPtvsTrackPt[6];//!
  TH2F                  *fHistRawJetPtvsTrackPt[6];//!
  TH1F                  *fHistTrackPt[6];//!
  TH1F                  *fHistEP0[6];//!
  TH1F                  *fHistEP0A[6];//!
  TH1F                  *fHistEP0C[6];//!
  TH2F                  *fHistEPAvsC[6];//!
  TH2F                  *fHistJetPtvsdEP[6];//!
  TH2F                  *fHistJetPtvsdEPBias[6];//!
  TH2F                  *fHistRhovsdEP[6]; //!
  TH3F                  *fHistJetEtaPhiPt[6];//!
  TH3F                  *fHistJetEtaPhiPtBias[6];//!
  TH2F                  *fHistJetPtArea[6];//!
  TH2F                  *fHistJetPtAreaBias[6];//!
  TH2F                  *fHistJetPtNcon[6]; //!
  TH2F                  *fHistJetPtNconBias[6]; //!
  TH2F                  *fHistJetPtNconCh[6]; //!
  TH2F                  *fHistJetPtNconBiasCh[6]; //!
  TH2F                  *fHistJetPtNconEm[6]; //!
  TH2F                  *fHistJetPtNconBiasEm[6]; //!
  TH1F		        *fHistJetHaddPhiINcent[6];
  TH1F			*fHistJetHaddPhiOUTcent[6];
  TH1F			*fHistJetHaddPhiMIDcent[6];
// ***********************
  TH1                   *fHistCentrality;
  TH1                   *fHistZvtx;
  TH1                   *fHistMult;
  TH1			*fHistJetPhi;
  TH1		        *fHistTrackPhi;
  TH1		        *fHistJetHaddPhiIN;
  TH1			*fHistJetHaddPhiOUT;
  TH1			*fHistJetHaddPhiMID;
  TH1			*fHistJetHaddPhiBias;
  TH1			*fHistJetHaddPhiINBias;
  TH1			*fHistJetHaddPhiOUTBias;
  TH1			*fHistJetHaddPhiMIDBias;

  TH1                   *fHistMEdPHI; // phi distrubtion of mixed events
  TH1			*fHistTrackPtallcent;

  TH2                   *fHistJetEtaPhi;  
  TH2                   *fHistTrackEtaPhi[4][7];
  TH1		        *fHistJetHadbindPhi[9]; 
  TH1			*fHistJetHadbindPhiIN[9]; 
  TH1			*fHistJetHadbindPhiMID[9]; 
  TH1		        *fHistJetHadbindPhiOUT[9]; 
  TH2                   *fHistJetHEtaPhi;

  TH1                   *fHistJetPt[2];
  TH1                   *fHistJetPtBias[2];
  TH1                   *fHistJetPtTT[2];
  TH2                   *fHistAreavsRawPt[2];
  TH2                   *fHistJetH[2][5][3];
  TH2                   *fHistJetHBias[2][5][3];
  TH2                   *fHistJetHTT[2][5][3];
  TH1F			*fHistJetHdPHI[11];
  TH2F			*fHistJetHdETAdPHI[11];
  TH2F                  *fHistSEphieta; // single events phi-eta distributions
  TH2F                  *fHistMEphieta; // mixed events phi-eta distributions
  TH1F			*fHistJetHaddPHI;

  // PID status histo's
  TH1			*fHistPID;

  // THn Sparse's
  THnSparse             *fhnPID;          // PID sparse
  THnSparse             *fhnMixedEvents;  // mixed events matrix
  THnSparse             *fhnJH;           // jet hadron events matrix

// ***********************************************************
   
  //Declare it private to avoid compilation warning
  AliAnalysisTaskEmcalJetHadEPpid(const AliAnalysisTaskEmcalJetHadEPpid & g) ; // cpy ctor

  AliAnalysisTaskEmcalJetHadEPpid& operator=(const AliAnalysisTaskEmcalJetHadEPpid&); // not implemented
  ClassDef(AliAnalysisTaskEmcalJetHadEPpid, 4); // Emcal jet hadron PID - Event plane dependence
};
#endif
Commit	Line	Data
fc392675	1	#ifndef AliAnalysisTaskEmcalJetHadEPpid_h
	2	#define AliAnalysisTaskEmcalJetHadEPpid_h
	3
	4	// root classes
	5	class TClonesArray;
	6	class TH1F;
	7	class TH2F;
	8	class TH3F;
	9	class THnSparse;
	10	class TList;
	11	class TLorentzVector;
	12	class TGraph;
	13
	14	// AliROOT classes
	15	class AliEventPoolManager;
	16	class AliLocalRhoParameter;
	17	// added 12/9
	18	class AliEMCALTrack;
	19	class AliMagF;
	20	class AliESDEvent;
	21	class AliAODEvent;
	22	class AliEMCALGeometry;
	23	class AliEMCALRecoUtils;
	24	class AliESDtrack;
	25
	26	// this whole section of includes added
	27	#include <AliAnalysisTaskEmcalJet.h>
	28	#include <AliEmcalJet.h>
	29	#include <AliVEvent.h>
	30	#include <AliVTrack.h>
	31	#include <AliVCluster.h>
	32	#include <TClonesArray.h>
	33	#include <TMath.h>
	34	#include <TRandom3.h>
	35	#include <AliLog.h>
	36
	37	#include "AliAnalysisTaskLocalRho.h"
	38	#include "AliLocalRhoParameter.h"
	39
	40	// PID stuff
	41	#include "AliPIDResponse.h"
	42
	43	#include "AliAnalysisFilter.h"
	44
	45	class AliAnalysisTaskEmcalJetHadEPpid : public AliAnalysisTaskEmcalJet {
	46	public:
	47	AliAnalysisTaskEmcalJetHadEPpid();
	48	AliAnalysisTaskEmcalJetHadEPpid(const char *name);
	49	//virtual ~AliAnalysisTaskEmcalJetHadEPpid() {}
	50	virtual ~AliAnalysisTaskEmcalJetHadEPpid();
	51
	52	virtual void UserCreateOutputObjects();
	53	virtual THnSparse* NewTHnSparseF(const char* name, UInt_t entries);
	54	virtual void GetDimParams(Int_t iEntry,TString &label, Int_t &nbins, Double_t &xmin, Double_t &xmax);
	55	virtual THnSparse* NewTHnSparseFPID(const char* name, UInt_t entries);
	56	virtual void GetDimParamsPID(Int_t iEntry,TString &label, Int_t &nbins, Double_t &xmin, Double_t &xmax);
	57	void SetPlotGlobalRho(Bool_t g) { doPlotGlobalRho = g; } // plot global rho switch
	58	void SetVariableBinning(Bool_t v) { doVariableBinning = v; } // do variable binning switch
	59	void SetdoPID(Bool_t p) { doPID = p; } // do PID switch
	60	void SetvarbinTHnSparse(Bool_t vb) { dovarbinTHnSparse = vb; }
	61	void SetDataType(Bool_t data) { useAOD = data; }
	62
	63	// getters
	64	TString GetLocalRhoName() const {return fLocalRhoName; }
65
66	// set names of some objects
67	virtual void SetLocalRhoName(const char *ln) {fLocalRhoName = ln; }
68	virtual void SetTracksName(const char *tn) {fTracksName = tn; }
69	virtual void SetJetsName(const char *jn) {fJetsName = jn; }
70
71	// bias and cuts
72	virtual void SetAreaCut(Double_t a) { fAreacut = a; }
73	virtual void SetTrkBias(Double_t b) { fTrkBias = b; } //require a track with pt > b in jet
74	virtual void SetClusBias(Double_t b) { fClusBias = b; } //require a cluster with pt > b in jet
75	virtual void SetTrkEta(Double_t e) { fTrkEta = e; } //eta range of the associated tracks
76	virtual void SetJetPtcut(Double_t jpt) { fJetPtcut = jpt; } // jet pt cut
77
78	// eta and phi limits of jets
79	virtual void SetJetEta(Double_t emin, Double_t emax) { fEtamin = emin; fEtamax = emax; }
80	virtual void SetJetPhi(Double_t pmin, Double_t pmax) { fPhimin = pmin; fPhimax = pmax; }
81
82	// event mixing setters
83	virtual void SetEventMixing(Int_t yesno) { fDoEventMixing=yesno; }
84	virtual void SetMixingTracks(Int_t tracks) { fMixingTracks = tracks; }
85
86	protected:
87	// functions
88	void ExecOnce();
89	Bool_t Run();
90	virtual void Terminate(Option_t *);
91	virtual Int_t GetCentBin(Double_t cent) const; // centrality bin of event
92	Float_t RelativePhi(Double_t mphi,Double_t vphi) const; // relative jet track angle
93	Float_t RelativeEPJET(Double_t jetAng, Double_t EPAng) const; // relative jet event plane angle
94	virtual Int_t GetEtaBin(Double_t eta) const; // eta bins
95	virtual Int_t GetpTjetBin(Double_t pt) const; // jet pt bins
96	virtual Int_t GetpTtrackBin(Double_t pt) const; // track pt bins
97	virtual Int_t GetzVertexBin(Double_t zVtx) const; // zVertex bin
98	void SetfHistPIDcounterLabels(TH1* fHistPID) const; // PID counter
99
100	// parameters of detector to cut on for event
101	Double_t fPhimin; // phi min
102	Double_t fPhimax; // phi max
103	Double_t fEtamin; // eta min
104	Double_t fEtamax; // eta max
105	Double_t fAreacut; // area cut
106	Double_t fTrkBias; // track bias
107	Double_t fClusBias; // cluster bias
108	Double_t fTrkEta; // eta min/max of tracks
109	Double_t fJetPtcut; // jet pt to cut on for correlations
110
111	// event mixing
112	Int_t fDoEventMixing;
113	Int_t fMixingTracks;
114
115	// switches for plots
116	Bool_t doPlotGlobalRho;
117	Bool_t doVariableBinning;
118	Bool_t dovarbinTHnSparse;
119
120	// data type switch
121	Bool_t useAOD;
122
123	// switches for PID
124	Bool_t doPID;
125
126	// local rho value
127	Double_t fLocalRhoVal;
128
129	// object names
130	TString fTracksName;
131	TString fJetsName;
132
133	// event counter
134	Int_t event;
135
136	// boolean functions for PID
137	Bool_t isPItpc, isKtpc, isPtpc;
138	Double_t nPIDtpc;
139
140	Bool_t isPIits, isKits, isPits;
141	Double_t nPIDits;
142
143	Bool_t isPItof, isKtof, isPtof;
144	Double_t nPIDtof;
145
146	// event pool
147	TObjArray* CloneAndReduceTrackList(TObjArray* tracks);
148	AliEventPoolManager *fPoolMgr; // event pool Manager object
149
150	// PID
151	AliPIDResponse *fPIDResponse; // PID response object
152	AliTPCPIDResponse *fTPCResponse; // TPC pid response object
153
154	private:
155	// needed for PID
156	AliESDEvent *fESD; //ESD object
157	AliAODEvent *fAOD; //AOD object
158
159	TH2F *fHistTPCdEdX;
160	TH2F *fHistITSsignal;
161	// TH2F *fHistTOFsignal;
162
163	TH2F *fHistRhovsCent; //!
164	TH2F *fHistNjetvsCent;//! number of jets versus Centrality
165	TH2F *fHistJetPtvsTrackPt[6];//!
166	TH2F *fHistRawJetPtvsTrackPt[6];//!
167	TH1F *fHistTrackPt[6];//!
168	TH1F *fHistEP0[6];//!
169	TH1F *fHistEP0A[6];//!
170	TH1F *fHistEP0C[6];//!
171	TH2F *fHistEPAvsC[6];//!
172	TH2F *fHistJetPtvsdEP[6];//!
173	TH2F *fHistJetPtvsdEPBias[6];//!
174	TH2F *fHistRhovsdEP[6]; //!
175	TH3F *fHistJetEtaPhiPt[6];//!
176	TH3F *fHistJetEtaPhiPtBias[6];//!
177	TH2F *fHistJetPtArea[6];//!
178	TH2F *fHistJetPtAreaBias[6];//!
179	TH2F *fHistJetPtNcon[6]; //!
180	TH2F *fHistJetPtNconBias[6]; //!
181	TH2F *fHistJetPtNconCh[6]; //!
182	TH2F *fHistJetPtNconBiasCh[6]; //!
183	TH2F *fHistJetPtNconEm[6]; //!
184	TH2F *fHistJetPtNconBiasEm[6]; //!
185	TH1F *fHistJetHaddPhiINcent[6];
186	TH1F *fHistJetHaddPhiOUTcent[6];
187	TH1F *fHistJetHaddPhiMIDcent[6];
188	// ***********************
189	TH1 *fHistCentrality;
190	TH1 *fHistZvtx;
191	TH1 *fHistMult;
192	TH1 *fHistJetPhi;
193	TH1 *fHistTrackPhi;
194	TH1 *fHistJetHaddPhiIN;
195	TH1 *fHistJetHaddPhiOUT;
196	TH1 *fHistJetHaddPhiMID;
197	TH1 *fHistJetHaddPhiBias;
198	TH1 *fHistJetHaddPhiINBias;
199	TH1 *fHistJetHaddPhiOUTBias;
200	TH1 *fHistJetHaddPhiMIDBias;
201
202	TH1 *fHistMEdPHI; // phi distrubtion of mixed events
203	TH1 *fHistTrackPtallcent;
204
205	TH2 *fHistJetEtaPhi;
206	TH2 *fHistTrackEtaPhi[4][7];
207	TH1 *fHistJetHadbindPhi[9];
208	TH1 *fHistJetHadbindPhiIN[9];
209	TH1 *fHistJetHadbindPhiMID[9];
210	TH1 *fHistJetHadbindPhiOUT[9];
211	TH2 *fHistJetHEtaPhi;
212
213	TH1 *fHistJetPt[2];
214	TH1 *fHistJetPtBias[2];
215	TH1 *fHistJetPtTT[2];
216	TH2 *fHistAreavsRawPt[2];
217	TH2 *fHistJetH[2][5][3];
218	TH2 *fHistJetHBias[2][5][3];
219	TH2 *fHistJetHTT[2][5][3];
220	TH1F *fHistJetHdPHI[11];
221	TH2F *fHistJetHdETAdPHI[11];
222	TH2F *fHistSEphieta; // single events phi-eta distributions
223	TH2F *fHistMEphieta; // mixed events phi-eta distributions
224	TH1F *fHistJetHaddPHI;
225
226	// PID status histo's
227	TH1 *fHistPID;
228
229	// THn Sparse's
230	THnSparse *fhnPID; // PID sparse
231	THnSparse *fhnMixedEvents; // mixed events matrix
232	THnSparse *fhnJH; // jet hadron events matrix
233
234	// ***********************************************************
235
236	//Declare it private to avoid compilation warning
237	AliAnalysisTaskEmcalJetHadEPpid(const AliAnalysisTaskEmcalJetHadEPpid & g) ; // cpy ctor
238
239	AliAnalysisTaskEmcalJetHadEPpid& operator=(const AliAnalysisTaskEmcalJetHadEPpid&); // not implemented
240	ClassDef(AliAnalysisTaskEmcalJetHadEPpid, 4); // Emcal jet hadron PID - Event plane dependence
241	};
242	#endif