]>
Commit | Line | Data |
---|---|---|
d7238ca3 | 1 | /************************************************************************* |
2 | * Task for Fragmentation Function Analysis in PWG4 Jet Task Force Train * | |
3 | *************************************************************************/ | |
4 | ||
6bec8236 | 5 | #ifndef ALIANALYSISTASKFRAGMENTATIONFUNCTION_H |
6 | #define ALIANALYSISTASKFRAGMENTATIONFUNCTION_H | |
d7238ca3 | 7 | |
6bec8236 | 8 | /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * |
9 | * See cxx source for full Copyright notice */ | |
f32b5a77 | 10 | |
d7238ca3 | 11 | /* $Id$ */ |
6bec8236 | 12 | |
d7238ca3 | 13 | class AliESDEvent; |
14 | class AliAODEvent; | |
15 | class TList; | |
6bec8236 | 16 | class TH1F; |
d7238ca3 | 17 | class TH2F; |
ac017ff3 | 18 | class TProfile; |
d7238ca3 | 19 | |
656dc810 | 20 | #include "THnSparse.h" |
d7238ca3 | 21 | #include "AliAnalysisTaskSE.h" |
22 | ||
23 | class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE { | |
6bec8236 | 24 | |
6bec8236 | 25 | public: |
656dc810 | 26 | |
27 | //---------------------------------------- | |
d7238ca3 | 28 | class AliFragFuncHistos : public TObject |
29 | { | |
656dc810 | 30 | |
31 | public: | |
d7238ca3 | 32 | |
33 | AliFragFuncHistos(const char* name = "FFhistos", | |
34 | Int_t nJetPt = 0, Float_t jetPtMin = 0, Float_t jetPtMax = 0, | |
35 | Int_t nPt = 0, Float_t ptMin = 0, Float_t ptMax = 0, | |
36 | Int_t nXi = 0, Float_t xiMin = 0, Float_t xiMax = 0, | |
37 | Int_t nZ = 0, Float_t zMin = 0, Float_t zMax = 0); | |
38 | AliFragFuncHistos(const AliFragFuncHistos& copy); | |
39 | AliFragFuncHistos& operator=(const AliFragFuncHistos &o); | |
40 | virtual ~AliFragFuncHistos(); | |
41 | ||
42 | virtual void DefineHistos(); | |
43 | virtual void FillFF(Float_t trackPt, Float_t jetPt,Bool_t incrementJetPt); | |
44 | virtual void AddToOutput(TList* list) const; | |
45 | ||
46 | private: | |
47 | ||
48 | Int_t fNBinsJetPt; // FF histos bins | |
49 | Float_t fJetPtMin; // FF histos limits | |
50 | Float_t fJetPtMax; // FF histos limits | |
51 | Int_t fNBinsPt; // FF histos bins | |
52 | Float_t fPtMin; // FF histos limits | |
53 | Float_t fPtMax; // FF histos limits | |
54 | Int_t fNBinsXi; // FF histos bins | |
55 | Float_t fXiMin; // FF histos limits | |
56 | Float_t fXiMax; // FF histos limits | |
57 | Int_t fNBinsZ; // FF histos bins | |
58 | Float_t fZMin; // FF histos limits | |
59 | Float_t fZMax; // FF histos limits | |
6bec8236 | 60 | |
656dc810 | 61 | TH2F* fh2TrackPt; //! FF: track transverse momentum |
62 | TH2F* fh2Xi; //! FF: xi | |
63 | TH2F* fh2Z; //! FF: z | |
64 | TH1F* fh1JetPt; //! jet pt | |
d7238ca3 | 65 | |
66 | TString fName; // histo names prefix | |
67 | ||
68 | ClassDef(AliFragFuncHistos, 1); | |
69 | }; | |
70 | ||
656dc810 | 71 | //---------------------------------------- |
d7238ca3 | 72 | class AliFragFuncQAJetHistos : public TObject |
73 | { | |
74 | ||
75 | public: | |
6bec8236 | 76 | |
d7238ca3 | 77 | AliFragFuncQAJetHistos(const char* name = "QAJethistos", |
78 | Int_t nPt = 0, Float_t ptMin = 0, Float_t ptMax = 0, | |
79 | Int_t nEta = 0, Float_t etaMin = 0, Float_t etaMax = 0, | |
80 | Int_t nPhi = 0, Float_t phiMin = 0, Float_t phiMax = 0); | |
81 | ||
82 | AliFragFuncQAJetHistos(const AliFragFuncQAJetHistos& copy); | |
83 | AliFragFuncQAJetHistos& operator=(const AliFragFuncQAJetHistos &o); | |
84 | virtual ~AliFragFuncQAJetHistos(); | |
85 | virtual void DefineHistos(); | |
86 | virtual void FillJetQA(Float_t eta, Float_t phi, Float_t pt); | |
87 | virtual void AddToOutput(TList* list) const; | |
88 | ||
89 | private: | |
90 | ||
91 | Int_t fNBinsPt; // jet QA histos bins | |
92 | Float_t fPtMin; // jet QA histos limits | |
93 | Float_t fPtMax; // jet QA histos limits | |
94 | Int_t fNBinsEta; // jet QA histos bins | |
95 | Float_t fEtaMin; // jet QA histos limits | |
96 | Float_t fEtaMax; // jet QA histos limits | |
97 | Int_t fNBinsPhi; // jet QA histos bins | |
98 | Float_t fPhiMin; // jet QA histos limits | |
99 | Float_t fPhiMax; // jet QA histos limits | |
100 | ||
101 | TH2F* fh2EtaPhi; //! jet phi vs eta | |
102 | TH1F* fh1Pt; //! jet transverse momentum | |
103 | TString fName; // histo names prefix | |
104 | ||
105 | ClassDef(AliFragFuncQAJetHistos, 1); | |
106 | }; | |
107 | ||
656dc810 | 108 | //---------------------------------------- |
d7238ca3 | 109 | class AliFragFuncQATrackHistos : public TObject |
110 | { | |
111 | ||
112 | public: | |
113 | ||
114 | AliFragFuncQATrackHistos(const char* name = "QATrackhistos", | |
115 | Int_t nPt = 0, Float_t ptMin = 0, Float_t ptMax = 0, | |
116 | Int_t nEta = 0, Float_t etaMin = 0, Float_t etaMax = 0, | |
117 | Int_t nPhi = 0, Float_t phiMin = 0, Float_t phiMax = 0, | |
118 | Float_t ptThresh = 0); | |
119 | ||
120 | AliFragFuncQATrackHistos(const AliFragFuncQATrackHistos& copy); | |
121 | AliFragFuncQATrackHistos& operator=(const AliFragFuncQATrackHistos &o); | |
122 | virtual ~AliFragFuncQATrackHistos(); | |
123 | virtual void DefineHistos(); | |
124 | virtual void FillTrackQA(Float_t eta, Float_t phi, Float_t pt); | |
125 | virtual void AddToOutput(TList* list) const; | |
126 | ||
127 | private: | |
128 | ||
656dc810 | 129 | Int_t fNBinsPt; // track QA histos bins in pt |
130 | Float_t fPtMin; // track QA histos limits in pt | |
131 | Float_t fPtMax; // track QA histos limits in pt | |
132 | Int_t fNBinsEta; // track QA histos bins in eta | |
133 | Float_t fEtaMin; // track QA histos limits in eta | |
134 | Float_t fEtaMax; // track QA histos limits in eta | |
135 | Int_t fNBinsPhi; // track QA histos bins in phi | |
136 | Float_t fPhiMin; // track QA histos limits in phi | |
137 | Float_t fPhiMax; // track QA histos limits in phi | |
d7238ca3 | 138 | |
139 | Float_t fHighPtThreshold; // high pt track phi vs eta distribution | |
140 | ||
656dc810 | 141 | TH2F* fh2EtaPhi; //! track phi vs eta |
142 | TH1F* fh1Pt; //! track transverse momentum | |
143 | TH2F* fh2HighPtEtaPhi; //! phi vs eta for high pt (>fgHighPtThreshold) tracks | |
d7238ca3 | 144 | |
656dc810 | 145 | TString fName; // histo names prefix |
d7238ca3 | 146 | |
147 | ClassDef(AliFragFuncQATrackHistos, 1); | |
148 | }; | |
149 | ||
656dc810 | 150 | //---------------------------------------- |
151 | class AliFragFuncIntraJetHistos : public TObject | |
152 | { | |
153 | ||
154 | public: | |
155 | ||
156 | AliFragFuncIntraJetHistos(const char* name = "IntraJethistos", | |
157 | Int_t nJetPt = 0, Float_t jetPtMin = 0, Float_t jetPtMax = 0, | |
158 | Int_t nPt = 0, Float_t ptMin = 0, Float_t ptMax = 0, | |
159 | Int_t nZ = 0, Float_t zMin = 0, Float_t zMax = 0, | |
160 | Int_t nCosTheta = 0, Float_t costhetaMin = 0, Float_t costhetaMax = 0, | |
161 | Int_t nTheta = 0, Float_t thetaMin = 0, Float_t thetaMax = 0, | |
162 | Int_t nJt = 0, Float_t jtMin = 0, Float_t jtMax = 0); | |
163 | AliFragFuncIntraJetHistos(const AliFragFuncIntraJetHistos& copy); | |
164 | AliFragFuncIntraJetHistos& operator=(const AliFragFuncIntraJetHistos &o); | |
165 | virtual ~AliFragFuncIntraJetHistos(); | |
166 | ||
167 | virtual void DefineHistos(); | |
168 | virtual void FillIntraJet(TLorentzVector* trackV, TLorentzVector* jetV); | |
169 | virtual void AddToOutput(TList* list) const; | |
170 | ||
171 | private: | |
172 | ||
173 | Int_t fNBinsJetPt; // IntraJet histos bins in jet pt | |
174 | Float_t fJetPtMin; // IntraJet histos limits in jet pt | |
175 | Float_t fJetPtMax; // IntraJet histos limits in jet pt | |
176 | Int_t fNBinsPt; // IntraJet histos bins in pt | |
177 | Float_t fPtMin; // IntraJet histos limits in pt | |
178 | Float_t fPtMax; // IntraJet histos limits in pt | |
179 | Int_t fNBinsZ; // IntraJet histos bins in z | |
180 | Float_t fZMin; // IntraJet histos limits in z | |
181 | Float_t fZMax; // IntraJet histos limits in z | |
182 | Int_t fNBinsJt; // IntraJet histos bins in jt | |
183 | Float_t fJtMin; // IntraJet histos limits in jt | |
184 | Float_t fJtMax; // IntraJet histos limits in jt | |
185 | Int_t fNBinsTheta; // IntraJet histos bins in theta | |
186 | Float_t fThetaMin; // IntraJet histos limits in theta | |
187 | Float_t fThetaMax; // IntraJet histos limits in theta | |
188 | Int_t fNBinsCosTheta; // IntraJet histos bins in cos(theta) | |
189 | Float_t fCosThetaMin; // IntraJet histos limits in cos(theta) | |
190 | Float_t fCosThetaMax; // IntraJet histos limits in cos(theta) | |
191 | ||
192 | TH2F* fh2Theta; //! IntraJet: theta distribution | |
193 | TH2F* fh2CosTheta; //! IntraJet: cos(theta) distribution | |
194 | TH2F* fh2Jt; //! IntraJet: jt distribution | |
195 | TH2F* fh2PtvsZ; //! IntraJet: pt vs z distribution | |
196 | ||
197 | THnSparseF* fhnIntraJet; //! IntraJet | |
198 | Int_t fnDim; // HnSparseF dimensions | |
199 | ||
200 | TString fName; // histo names prefix | |
201 | ||
202 | ClassDef(AliFragFuncIntraJetHistos, 1); | |
203 | }; | |
204 | ||
205 | //---------------------------------------- | |
206 | class AliFragFuncDiJetHistos : public TObject | |
207 | { | |
208 | ||
209 | public: | |
210 | ||
211 | AliFragFuncDiJetHistos(const char* name = "DiJetHistos", Int_t kindSlices = 0, | |
212 | Int_t nJetinvMass = 0, Float_t jetInvMassMin = 0, Float_t jetInvMassMax = 0, | |
213 | Int_t nJetPt = 0, Float_t jetPtMin = 0, Float_t jetPtMax = 0, | |
214 | Int_t nPt = 0, Float_t ptMin = 0, Float_t ptMax = 0, | |
215 | Int_t nXi = 0, Float_t xiMin = 0, Float_t xiMax = 0, | |
216 | Int_t nZ = 0, Float_t zMin = 0, Float_t zMax = 0); | |
217 | AliFragFuncDiJetHistos(const AliFragFuncDiJetHistos& copy); | |
218 | AliFragFuncDiJetHistos& operator=(const AliFragFuncDiJetHistos &o); | |
219 | virtual ~AliFragFuncDiJetHistos(); | |
220 | ||
221 | virtual void DefineDiJetHistos(); | |
222 | virtual void FillDiJetFF(Int_t jetType, Float_t trackPt, Float_t jetPt, Double_t jetBin, Bool_t incrementJetPt); | |
223 | virtual void AddToOutput(TList* list) const; | |
224 | ||
225 | private: | |
226 | ||
227 | Int_t fKindSlices; | |
228 | Int_t fNBinsJetInvMass; // FF histos bins | |
229 | Float_t fJetInvMassMin; // FF histos limits | |
230 | Float_t fJetInvMassMax; // FF histos limits | |
231 | Int_t fNBinsJetPt; // FF histos bins | |
232 | Float_t fJetPtMin; // FF histos limits | |
233 | Float_t fJetPtMax; // FF histos limits | |
234 | Int_t fNBinsPt; // FF histos bins | |
235 | Float_t fPtMin; // FF histos limits | |
236 | Float_t fPtMax; // FF histos limits | |
237 | Int_t fNBinsXi; // FF histos bins | |
238 | Float_t fXiMin; // FF histos limits | |
239 | Float_t fXiMax; // FF histos limits | |
240 | Int_t fNBinsZ; // FF histos bins | |
241 | Float_t fZMin; // FF histos limits | |
242 | Float_t fZMax; // FF histos limits | |
243 | ||
244 | TH2F* fh2TrackPtJet1; //! FF dijet : track transverse momentum of jet 1 | |
245 | TH2F* fh2TrackPtJet2; //! FF dijet : track transverse momentum of jet 2 | |
246 | TH2F* fh2TrackPtJet; //! FF dijet : track transverse momentum of jets 1 and 2 | |
247 | TH1F* fh1Jet1Pt; //! jet 1 pt | |
248 | TH1F* fh1Jet2Pt; //! jet 2 pt | |
249 | TH1F* fh1JetPt; //! jet 1 and 2 pt | |
250 | TH2F* fh2Xi1; //! FF dijet : xi of jet 1 | |
251 | TH2F* fh2Xi2; //! FF dijet : xi of jet 2 | |
252 | TH2F* fh2Xi; //! FF dijet : xi of jet 1 and 2 | |
253 | TH2F* fh2Z1; //! FF dijet : z of jet 1 | |
254 | TH2F* fh2Z2; //! FF dijet : z of jet 2 | |
255 | TH2F* fh2Z; //! FF dijet : z of jet 1 and 2 | |
256 | TH2F* fh2Pt1; //! FF dijet : z of jet 1 | |
257 | TH2F* fh2Pt2; //! FF dijet : z of jet 2 | |
258 | TH2F* fh2Pt; //! FF dijet : z of jet 1 and 2 | |
259 | ||
260 | TString fName; // histo names prefix | |
261 | ||
262 | ClassDef(AliFragFuncDiJetHistos, 1); | |
263 | }; | |
264 | ||
265 | //---------------------------------------- | |
266 | class AliFragFuncQADiJetHistos : public TObject | |
267 | { | |
268 | public: | |
269 | AliFragFuncQADiJetHistos(const char* name = "QADiJetHistos", Int_t kindSlices = 0, | |
270 | Int_t nInvMass = 0, Float_t invMassMin = 0, Float_t invMassMax = 0, | |
271 | Int_t nJetPt = 0, Float_t jetPtMin = 0, Float_t jetPtMax = 0, | |
272 | Int_t nDeltaPhi = 0, Float_t deltaPhiMin = 0, Float_t deltaPhiMax = 0, | |
273 | Int_t nDeltaEta = 0, Float_t deltaEtaMin = 0, Float_t deltaEtaMax = 0, | |
274 | Int_t nDeltaPt = 0, Float_t deltaPtMin = 0, Float_t deltaPtMax = 0); | |
275 | AliFragFuncQADiJetHistos(const AliFragFuncQADiJetHistos& copy); | |
276 | AliFragFuncQADiJetHistos& operator=(const AliFragFuncQADiJetHistos &o); | |
277 | virtual ~AliFragFuncQADiJetHistos(); | |
278 | ||
279 | virtual void DefineQADiJetHistos(); | |
280 | virtual void FillDiJetQA(Double_t invMass, Double_t deltaPhi, Double_t deltaEta, Double_t deltaPt, Double_t jetBin); | |
281 | virtual void AddToOutput(TList* list) const; | |
282 | ||
283 | private: | |
284 | ||
285 | Int_t fKindSlices; | |
286 | Int_t fNBinsJetInvMass; // FF histos bins in jet invariant mass | |
287 | Float_t fJetInvMassMin; // FF histos limits in jet invariant mass | |
288 | Float_t fJetInvMassMax; // FF histos limits in jet invariant mass | |
289 | Int_t fNBinsJetPt; // FF histos bins in jet pt | |
290 | Float_t fJetPtMin; // FF histos limits in jet pt | |
291 | Float_t fJetPtMax; // FF histos limits in jet pt | |
292 | Int_t fNBinsDeltaPhi; // FF histos bins in jet delta phi | |
293 | Float_t fDeltaPhiMin; // FF histos limits in jet delta phi | |
294 | Float_t fDeltaPhiMax; // FF histos limits in jet delta phi | |
295 | Int_t fNBinsDeltaEta; // FF histos bins in jet delta eta | |
296 | Float_t fDeltaEtaMin; // FF histos limits in jet delta eta | |
297 | Float_t fDeltaEtaMax; // FF histos limits in jet delta eta | |
298 | Int_t fNBinsDeltaPt; // FF histos bins in jet delta pt | |
299 | Float_t fDeltaPtMin; // FF histos limits in jet delta pt | |
300 | Float_t fDeltaPtMax; // FF histos limits in jet delta pt | |
301 | ||
302 | TH2F* fh2InvMass; // FF dijet invariant mass histos | |
303 | TH2F* fh2DeltaPhi; // FF dijet delta phi histos | |
304 | TH2F* fh2DeltaEta; // FF dijet delta eta histos | |
305 | TH2F* fh2DeltaPt; // FF dijet delta pt histos | |
306 | ||
307 | TString fName; // histo names prefix | |
308 | ||
309 | ClassDef(AliFragFuncQADiJetHistos, 1); | |
310 | }; | |
d7238ca3 | 311 | |
312 | AliAnalysisTaskFragmentationFunction(); | |
313 | AliAnalysisTaskFragmentationFunction(const char *name); | |
314 | AliAnalysisTaskFragmentationFunction(const AliAnalysisTaskFragmentationFunction ©); | |
315 | AliAnalysisTaskFragmentationFunction& operator=(const AliAnalysisTaskFragmentationFunction &o); | |
316 | virtual ~AliAnalysisTaskFragmentationFunction(); | |
317 | ||
318 | virtual void UserCreateOutputObjects(); | |
319 | virtual void Init(); | |
320 | virtual void LocalInit() {Init();} | |
321 | virtual void UserExec(Option_t *option); | |
322 | virtual void Terminate(Option_t* ); | |
ac017ff3 | 323 | virtual Bool_t Notify(); |
d7238ca3 | 324 | |
325 | virtual void SetTrackTypeGen(Int_t i){fTrackTypeGen = i;} | |
326 | virtual void SetJetTypeGen(Int_t i){fJetTypeGen = i;} | |
7d9e8b32 | 327 | virtual void SetJetTypeRecEff(Int_t i){fJetTypeRecEff = i;} |
d7238ca3 | 328 | |
329 | virtual void SetBranchGenJets(const char* c){fBranchGenJets = c;} | |
330 | virtual void SetBranchRecJets(const char* c){fBranchRecJets = c;} | |
331 | ||
656dc810 | 332 | virtual void SetTrackCuts(Float_t trackPt = 0.15, Float_t trackEtaMin = -0.9, Float_t trackEtaMax = 0.9, |
333 | Float_t trackPhiMin = 0., Float_t trackPhiMax = 2*TMath::Pi()) | |
334 | {fTrackPtCut = trackPt; fTrackEtaMin = trackEtaMin; fTrackEtaMax = trackEtaMax; | |
335 | fTrackPhiMin = trackPhiMin; fTrackPhiMax = trackPhiMax;} | |
d7238ca3 | 336 | virtual void SetFilterMask(UInt_t i) {fFilterMask = i;} |
ac017ff3 | 337 | virtual void UsePhysicsSelection(Bool_t b) {fUsePhysicsSelection = b;} |
656dc810 | 338 | virtual void SetJetCuts(Float_t jetPt = 5., Float_t jetEtaMin = -0.5, Float_t jetEtaMax = 0.5, |
339 | Float_t jetPhiMin = 0., Float_t jetPhiMax = 2*TMath::Pi()) | |
340 | {fJetPtCut = jetPt; fJetEtaMin = jetEtaMin; fJetEtaMax = jetEtaMax; | |
341 | fJetPhiMin = jetPhiMin; fJetPhiMax = jetPhiMax;} | |
342 | virtual void SetDiJetCuts(Int_t cutType = 1, Float_t deltaPhiCut = 0., | |
343 | Float_t cdfCut = 0.5, Float_t ptFractionCut = 0.6) | |
344 | {fDiJetCut = cutType; fDiJetDeltaPhiCut = deltaPhiCut; | |
345 | fDiJetCDFCut = cdfCut; fDiJetPtFractionCut = ptFractionCut;} | |
f3564520 | 346 | virtual void SetKindSlices(Int_t slice = 1) {fDiJetKindBins = slice;} |
656dc810 | 347 | |
d7238ca3 | 348 | virtual void SetFFRadius(Float_t r = 0.4) { fFFRadius = r; } |
349 | ||
350 | static void SetProperties(TH1* h,const char* x, const char* y); | |
351 | static void SetProperties(TH2* h,const char* x, const char* y,const char* z); | |
7d9e8b32 | 352 | static void SetProperties(THnSparse* h,const Int_t dim, const char** labels); |
d7238ca3 | 353 | |
354 | void SetHighPtThreshold(Float_t pt = 5.) { fQATrackHighPtThreshold = pt; } | |
355 | ||
356 | ||
ac017ff3 | 357 | void SetFFHistoBins(Int_t nJetPt = 245, Float_t jetPtMin = 5, Float_t jetPtMax = 250, |
358 | Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 200., | |
d7238ca3 | 359 | Int_t nXi = 70, Float_t xiMin = 0., Float_t xiMax = 7., |
360 | Int_t nZ = 22, Float_t zMin = 0., Float_t zMax = 1.1) | |
361 | { fFFNBinsJetPt = nJetPt; fFFJetPtMin = jetPtMin; fFFJetPtMax = jetPtMax; | |
362 | fFFNBinsPt = nPt; fFFPtMin = ptMin; fFFPtMax = ptMax; | |
363 | fFFNBinsXi = nXi; fFFXiMin = xiMin; fFFXiMax = xiMax; | |
364 | fFFNBinsZ = nZ; fFFZMin = zMin; fFFZMax = zMax; } | |
365 | ||
ac017ff3 | 366 | void SetQAJetHistoBins(Int_t nPt = 300, Float_t ptMin = 0., Float_t ptMax = 300., |
d7238ca3 | 367 | Int_t nEta = 20, Float_t etaMin = -1.0, Float_t etaMax = 1.0, |
368 | Int_t nPhi = 60, Float_t phiMin = 0., Float_t phiMax = 2*TMath::Pi()) | |
369 | { fQAJetNBinsPt = nPt; fQAJetPtMin = ptMin; fQAJetPtMax = ptMax; | |
370 | fQAJetNBinsEta = nEta; fQAJetEtaMin = etaMin; fQAJetEtaMax = etaMax; | |
371 | fQAJetNBinsPhi = nPhi; fQAJetPhiMin = phiMin; fQAJetPhiMax = phiMax; } | |
372 | ||
ac017ff3 | 373 | void SetQATrackHistoBins(Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 200., |
d7238ca3 | 374 | Int_t nEta = 20, Float_t etaMin = -1.0, Float_t etaMax = 1.0, |
375 | Int_t nPhi = 60, Float_t phiMin = 0., Float_t phiMax = 2*TMath::Pi()) | |
376 | { fQATrackNBinsPt = nPt; fQATrackPtMin = ptMin; fQATrackPtMax = ptMax; | |
377 | fQATrackNBinsEta = nEta; fQATrackEtaMin = etaMin; fQATrackEtaMax = etaMax; | |
378 | fQATrackNBinsPhi = nPhi; fQATrackPhiMin = phiMin; fQATrackPhiMax = phiMax; } | |
379 | ||
ac017ff3 | 380 | void SetIJHistoBins(Int_t nJetPt = 245, Float_t jetPtMin = 5, Float_t jetPtMax = 250, |
381 | Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 200., | |
656dc810 | 382 | Int_t nZ = 22, Float_t zMin = 0., Float_t zMax = 1.1, |
383 | Int_t nCosTheta = 100, Float_t costhetaMin = 0., Float_t costhetaMax = 1., | |
384 | Int_t nTheta = 200, Float_t thetaMin = -0.5, Float_t thetaMax = 1.5, | |
385 | Int_t nJt = 25, Float_t jtMin = 0., Float_t jtMax = 5.) | |
386 | { fIJNBinsJetPt = nJetPt; fIJJetPtMin = jetPtMin; fIJJetPtMax = jetPtMax; | |
387 | fIJNBinsPt = nPt; fIJPtMin = ptMin; fIJPtMax = ptMax; | |
388 | fIJNBinsZ = nZ; fIJZMin = zMin; fIJZMax = zMax; | |
389 | fIJNBinsCosTheta = nCosTheta; fIJCosThetaMin = costhetaMin; fIJCosThetaMax = costhetaMax; | |
390 | fIJNBinsTheta = nTheta; fIJThetaMin = thetaMin; fIJThetaMax = thetaMax; | |
391 | fIJNBinsJt = nJt; fIJJtMin = jtMin; fIJJtMax = jtMax; } | |
392 | ||
ac017ff3 | 393 | void SetDiJetHistoBins(Int_t nJetInvMass = 245, Float_t jetInvMassMin = 5, Float_t jetInvMassMax = 250, |
394 | Int_t nJetPt = 245, Float_t jetPtMin = 5, Float_t jetPtMax = 250, | |
395 | Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 200., | |
656dc810 | 396 | Int_t nXi = 70, Float_t xiMin = 0., Float_t xiMax = 7., |
397 | Int_t nZ = 22, Float_t zMin = 0., Float_t zMax = 1.1) | |
398 | { | |
399 | fDiJetNBinsJetInvMass = nJetInvMass; fDiJetJetInvMassMin = jetInvMassMin; fDiJetJetInvMassMax = jetInvMassMax; | |
400 | fDiJetNBinsJetPt = nJetPt; fDiJetJetPtMin = jetPtMin; fDiJetJetPtMax = jetPtMax; | |
401 | fDiJetNBinsPt = nPt; fDiJetPtMin = ptMin; fDiJetPtMax = ptMax; | |
402 | fDiJetNBinsXi = nXi; fDiJetXiMin = xiMin; fDiJetXiMax = xiMax; | |
403 | fDiJetNBinsZ = nZ; fDiJetZMin = zMin; fDiJetZMax = zMax; | |
404 | } | |
405 | ||
ac017ff3 | 406 | void SetQADiJetHistoBins(Int_t nInvMass = 245, Float_t invMassMin = 5., Float_t invMassMax = 250., |
407 | Int_t nJetPt = 245, Float_t jetPtMin = 5, Float_t jetPtMax = 250, | |
656dc810 | 408 | Int_t nDeltaPhi = 100, Float_t deltaPhiMin = 0., Float_t deltaPhiMax = TMath::Pi(), |
409 | Int_t nDeltaEta = 22, Float_t deltaEtaMin = 0., Float_t deltaEtaMax = 1.1, | |
410 | Int_t nDeltaPt = 100, Float_t deltaPtMin = 0., Float_t deltaPtMax = 100.) | |
411 | { | |
412 | fQADiJetNBinsInvMass = nInvMass; fQADiJetInvMassMin = invMassMin; fQADiJetInvMassMax = invMassMax; | |
413 | fQADiJetNBinsJetPt = nJetPt; fQADiJetJetPtMin = jetPtMin; fQADiJetJetPtMax = jetPtMax; | |
414 | fQADiJetNBinsDeltaPhi = nDeltaPhi; fQADiJetDeltaPhiMin = deltaPhiMin; fQADiJetDeltaPhiMax = deltaPhiMax; | |
415 | fQADiJetNBinsDeltaEta = nDeltaEta; fQADiJetDeltaEtaMin = deltaEtaMin; fQADiJetDeltaEtaMax = deltaEtaMax; | |
416 | fQADiJetNBinsDeltaPt = nDeltaPt; fQADiJetDeltaPtMin = deltaPtMin; fQADiJetDeltaPtMax = deltaPtMax; | |
417 | ||
418 | } | |
419 | ||
420 | Float_t GetFFRadius() const { return fFFRadius; } | |
421 | void GetJetTracksTrackrefs(TList* l, AliAODJet* j); | |
422 | void GetJetTracksPointing(TList* in, TList* out, AliAODJet* j, const Double_t r, Double_t& pt); | |
423 | Double_t GetDiJetBin(Double_t invMass, Double_t leadingJetPt, Double_t eMean, Int_t kindSlices); // function to find which bin fill | |
424 | Double_t InvMass(AliAODJet* jet1, AliAODJet* jet2); | |
7d9e8b32 | 425 | void AssociateGenRec(TList* tracksAODMCCharged,TList* tracksRec, TArrayI& indexAODTr,TArrayI& indexMCTr,TArrayS& isGenPrim); |
426 | void FillSingleTrackRecEffHisto(THnSparse* histo, TList* tracksGen, TList* tracksRec, TArrayI& indexAODTr, TArrayS& isGenPrim); | |
427 | void FillJetTrackRecEffHisto(THnSparse* histo,Double_t jetPhi,Double_t jetEta,Double_t jetPt,TList* jetTrackList, TList* tracksGen, | |
428 | TArrayI& indexAODTr,TArrayS& isGenPrim); | |
429 | ||
d7238ca3 | 430 | |
431 | // Consts | |
432 | ||
7d9e8b32 | 433 | enum {kTrackUndef=0, kTrackAOD, kTrackAODQualityCuts, kTrackAODCuts, kTrackKineAll, kTrackKineCharged, kTrackKineChargedAcceptance, |
434 | kTrackAODMCAll, kTrackAODMCCharged, kTrackAODMCChargedAcceptance}; | |
d7238ca3 | 435 | enum {kJetsUndef=0, kJetsRec, kJetsRecAcceptance, kJetsGen, kJetsGenAcceptance, kJetsKine, kJetsKineAcceptance}; |
ac017ff3 | 436 | |
437 | ||
438 | private: | |
d7238ca3 | 439 | |
440 | Int_t GetListOfTracks(TList* list, Int_t type); | |
441 | Int_t GetListOfJets(TList* list, Int_t type); | |
442 | ||
443 | AliESDEvent* fESD; // ESD event | |
444 | AliAODEvent* fAOD; // AOD event | |
445 | AliMCEvent* fMCEvent; // MC event | |
446 | ||
447 | TString fBranchRecJets; // branch name for reconstructed jets | |
448 | TString fBranchGenJets; // branch name for generated jets | |
449 | ||
656dc810 | 450 | Int_t fTrackTypeGen; // type of generated tracks |
451 | Int_t fJetTypeGen; // type of generated jets | |
d7238ca3 | 452 | |
7d9e8b32 | 453 | Int_t fJetTypeRecEff; // type of jets used for filling reconstruction efficiency histos |
454 | ||
656dc810 | 455 | UInt_t fFilterMask; // filter bit for selected tracks |
ac017ff3 | 456 | Bool_t fUsePhysicsSelection; // switch for event selection |
d7238ca3 | 457 | |
458 | // track cuts | |
656dc810 | 459 | Float_t fTrackPtCut; // track transverse momentum cut |
460 | Float_t fTrackEtaMin; // track eta cut | |
461 | Float_t fTrackEtaMax; // track eta cut | |
462 | Float_t fTrackPhiMin; // track phi cut | |
463 | Float_t fTrackPhiMax; // track phi cut | |
d7238ca3 | 464 | |
465 | // jet cuts | |
656dc810 | 466 | Float_t fJetPtCut; // jet transverse momentum cut |
467 | Float_t fJetEtaMin; // jet eta cut | |
468 | Float_t fJetEtaMax; // jet eta cut | |
469 | Float_t fJetPhiMin; // jet phi cut | |
470 | Float_t fJetPhiMax; // jet phi cut | |
471 | ||
472 | // di-jet cuts | |
473 | Int_t fDiJetCut; // dijet cut selection | |
474 | Float_t fDiJetDeltaPhiCut; // delta phi cut value | |
475 | Float_t fDiJetPtFractionCut; // fraction of pt cut value | |
476 | Float_t fDiJetCDFCut; // cdf cut value | |
477 | ||
478 | Int_t fDiJetKindBins; // type of bins: invmass, etleading, emean | |
479 | static TArrayD* fDiJetBins; // bining in invmass, etleading, emean | |
d7238ca3 | 480 | |
d7238ca3 | 481 | Float_t fFFRadius; // if radius > 0 construct FF from tracks within cone around jet axis, otherwise use trackRefs |
c2658535 | 482 | |
483 | Float_t fAvgTrials; // average number of trials per event | |
d7238ca3 | 484 | |
7d9e8b32 | 485 | TList* fTracksRec; //! reconstructed tracks |
486 | TList* fTracksRecCuts; //! reconstructed tracks after cuts | |
487 | TList* fTracksGen; //! generated tracks | |
488 | TList* fTracksAODMCCharged; //! AOD MC tracks | |
489 | TList* fTracksRecQualityCuts; //! reconstructed tracks after quality cuts, no acceptance/pt cut | |
490 | ||
d7238ca3 | 491 | |
492 | TList* fJetsRec; //! jets from reconstructed tracks | |
493 | TList* fJetsRecCuts; //! jets from reonstructed tracks after jet cuts | |
494 | TList* fJetsGen; //! jets from generated tracks | |
7d9e8b32 | 495 | TList* fJetsRecEff; //! jets used for reconstruction efficiency histos |
d7238ca3 | 496 | |
497 | ||
498 | AliFragFuncQATrackHistos* fQATrackHistosRec; //! track QA: reconstructed tracks | |
499 | AliFragFuncQATrackHistos* fQATrackHistosRecCuts; //! track QA: reconstructed tracks after cuts | |
500 | AliFragFuncQATrackHistos* fQATrackHistosGen; //! track QA: generated tracks | |
501 | ||
502 | AliFragFuncQAJetHistos* fQAJetHistosRec; //! jet QA: jets from reconstructed tracks | |
503 | AliFragFuncQAJetHistos* fQAJetHistosRecCuts; //! jet QA: jets from reconstructed tracks after jet cuts | |
504 | AliFragFuncQAJetHistos* fQAJetHistosRecCutsLeading; //! jet QA: leading jet from reconstructed tracks after jet cuts | |
505 | AliFragFuncQAJetHistos* fQAJetHistosGen; //! jet QA: jets from generated tracks | |
506 | AliFragFuncQAJetHistos* fQAJetHistosGenLeading; //! jet QA: leading jet from generated tracks | |
7d9e8b32 | 507 | AliFragFuncQAJetHistos* fQAJetHistosRecEffLeading; //! jet QA: leading jet used for reconstruction efficiency histos |
d7238ca3 | 508 | |
7d9e8b32 | 509 | |
d7238ca3 | 510 | AliFragFuncHistos* fFFHistosRecCuts; //! FF reconstructed tracks after cuts |
511 | AliFragFuncHistos* fFFHistosRecLeading; //! FF reconstructed tracks after cuts: all reconstructed tracks pt / leading track pt | |
512 | AliFragFuncHistos* fFFHistosRecLeadingTrack; //! FF reconstructed tracks after cuts: leading track pt / jet pt | |
513 | AliFragFuncHistos* fFFHistosGen; //! FF generated tracks after cuts | |
514 | AliFragFuncHistos* fFFHistosGenLeading; //! FF generated tracks after cuts: all generated tracks pt / leading track pt | |
515 | AliFragFuncHistos* fFFHistosGenLeadingTrack; //! FF generated tracks after cuts: leading track pt / jet pt | |
516 | ||
656dc810 | 517 | |
518 | AliFragFuncIntraJetHistos* fIJHistosRecCuts; //! IJ reconstructed tracks after cuts | |
519 | AliFragFuncIntraJetHistos* fIJHistosRecLeading; //! IJ reconstructed tracks after cuts: all reconstructed tracks pt / leading track pt | |
520 | AliFragFuncIntraJetHistos* fIJHistosRecLeadingTrack; //! IJ reconstructed tracks after cuts: leading track pt / jet pt | |
521 | AliFragFuncIntraJetHistos* fIJHistosGen; //! IJ generated tracks after cuts | |
522 | AliFragFuncIntraJetHistos* fIJHistosGenLeading; //! IJ generated tracks after cuts: all generated tracks pt / leading track pt | |
523 | AliFragFuncIntraJetHistos* fIJHistosGenLeadingTrack; //! IJ generated tracks after cuts: leading track pt / jet pt | |
524 | ||
525 | AliFragFuncDiJetHistos* fFFDiJetHistosRecCuts; //! DiJet FF reconstructed tracks after cuts | |
526 | AliFragFuncDiJetHistos* fFFDiJetHistosRecLeading; //! DiJet FF reconstructed tracks after cuts: all reconstructed tracks pt / leading track pt | |
527 | AliFragFuncDiJetHistos* fFFDiJetHistosRecLeadingTrack; //! DiJet FF reconstructed tracks after cuts: leading track pt / jet pt | |
528 | ||
529 | AliFragFuncDiJetHistos* fFFDiJetHistosGen; //! DiJet FF generated tracks after cuts | |
530 | AliFragFuncDiJetHistos* fFFDiJetHistosGenLeading; //! DiJet FF generated tracks after cuts: all generated tracks pt / leading track pt | |
531 | AliFragFuncDiJetHistos* fFFDiJetHistosGenLeadingTrack; //! DiJet FF generated tracks after cuts: leading track pt / jet pt | |
532 | ||
533 | AliFragFuncQADiJetHistos* fQADiJetHistosRecCuts; //! Dijet QA : reconstructed tracks after cuts | |
534 | AliFragFuncQADiJetHistos* fQADiJetHistosGen; //! DiJet QA: jets from generated tracks | |
535 | ||
536 | ||
d7238ca3 | 537 | Float_t fQATrackHighPtThreshold; // track QA high transverse momentum threshold |
538 | ||
539 | // histogram bins | |
540 | ||
541 | Int_t fFFNBinsJetPt; // FF histos bins | |
542 | Float_t fFFJetPtMin; // FF histos limits | |
543 | Float_t fFFJetPtMax; // FF histos limits | |
544 | ||
545 | Int_t fFFNBinsPt; // FF histos bins | |
546 | Float_t fFFPtMin; // FF histos limits | |
547 | Float_t fFFPtMax; // FF histos limits | |
548 | ||
549 | Int_t fFFNBinsXi; // FF histos bins | |
550 | Float_t fFFXiMin; // FF histos limits | |
551 | Float_t fFFXiMax; // FF histos limits | |
552 | ||
553 | Int_t fFFNBinsZ; // FF histos bins | |
554 | Float_t fFFZMin; // FF histos limits | |
555 | Float_t fFFZMax; // FF histos limits | |
556 | ||
557 | Int_t fQAJetNBinsPt; // jet QA histos bins | |
558 | Float_t fQAJetPtMin; // jet QA histos limits | |
559 | Float_t fQAJetPtMax; // jet QA histos limits | |
560 | ||
561 | Int_t fQAJetNBinsEta; // jet QA histos bins | |
562 | Float_t fQAJetEtaMin; // jet QA histos limits | |
563 | Float_t fQAJetEtaMax; // jet QA histos limits | |
564 | ||
565 | Int_t fQAJetNBinsPhi; // jet QA histos bins | |
566 | Float_t fQAJetPhiMin; // jet QA histos limits | |
567 | Float_t fQAJetPhiMax; // jet QA histos limits | |
568 | ||
569 | Int_t fQATrackNBinsPt; // track QA histos bins | |
570 | Float_t fQATrackPtMin; // track QA histos limits | |
571 | Float_t fQATrackPtMax; // track QA histos limits | |
572 | ||
573 | Int_t fQATrackNBinsEta; // track QA histos bins | |
574 | Float_t fQATrackEtaMin; // track QA histos limits | |
575 | Float_t fQATrackEtaMax; // track QA histos limits | |
576 | ||
577 | Int_t fQATrackNBinsPhi; // track QA histos bins | |
578 | Float_t fQATrackPhiMin; // track QA histos limits | |
579 | Float_t fQATrackPhiMax; // track QA histos limits | |
580 | ||
656dc810 | 581 | Int_t fIJNBinsJetPt; // IJ histos bins |
582 | Float_t fIJJetPtMin; // IJ histos limits | |
583 | Float_t fIJJetPtMax; // IJ histos limits | |
584 | ||
585 | Int_t fIJNBinsPt; // IJ histos bins | |
586 | Float_t fIJPtMin; // IJ histos limits | |
587 | Float_t fIJPtMax; // IJ histos limits | |
588 | ||
589 | Int_t fIJNBinsZ; // IJ histos bins | |
590 | Float_t fIJZMin; // IJ histos limits | |
591 | Float_t fIJZMax; // IJ histos limits | |
592 | ||
593 | Int_t fIJNBinsCosTheta; // IJ histos bins | |
594 | Float_t fIJCosThetaMin; // IJ histos limits | |
595 | Float_t fIJCosThetaMax; // IJ histos limits | |
596 | ||
597 | Int_t fIJNBinsTheta; // IJ histos bins | |
598 | Float_t fIJThetaMin; // IJ histos limits | |
599 | Float_t fIJThetaMax; // IJ histos limits | |
600 | ||
601 | Int_t fIJNBinsJt; // IJ histos bins | |
602 | Float_t fIJJtMin; // IJ histos limits | |
603 | Float_t fIJJtMax; // IJ histos limits | |
604 | ||
605 | Int_t fDiJetNBinsJetInvMass; // FF dijet histos bins | |
606 | Float_t fDiJetJetInvMassMin; // FF dijet histos limits | |
607 | Float_t fDiJetJetInvMassMax; // FF dijet histos limits | |
608 | Int_t fDiJetNBinsJetPt; // FF dijet histos bins | |
609 | Float_t fDiJetJetPtMin; // FF dijet histos limits | |
610 | Float_t fDiJetJetPtMax; // FF dijet histos limits | |
611 | Int_t fDiJetNBinsPt; // FF dijet histos bins | |
612 | Float_t fDiJetPtMin; // FF dijet histos limits | |
613 | Float_t fDiJetPtMax; // FF dijet histos limits | |
614 | Int_t fDiJetNBinsXi; // FF dijet histos bins | |
615 | Float_t fDiJetXiMin; // FF dijet histos limits | |
616 | Float_t fDiJetXiMax; // FF dijet histos limits | |
617 | Int_t fDiJetNBinsZ; // FF dijet histos bins | |
618 | Float_t fDiJetZMin; // FF dijet histos limits | |
619 | Float_t fDiJetZMax; // FF dijet histos limits | |
620 | ||
621 | Int_t fQADiJetNBinsInvMass; // dijet QA histos bins | |
622 | Float_t fQADiJetInvMassMin; // dijet QA histos limits | |
623 | Float_t fQADiJetInvMassMax; // dijet QA histos limits | |
624 | ||
625 | Int_t fQADiJetNBinsJetPt; // dijet QA histos bins | |
626 | Float_t fQADiJetJetPtMin; // dijet QA histos limits | |
627 | Float_t fQADiJetJetPtMax; // dijet QA histos limits | |
628 | ||
629 | Int_t fQADiJetNBinsDeltaPhi; // dijet QA histos bins | |
630 | Float_t fQADiJetDeltaPhiMin; // dijet QA histos limits | |
631 | Float_t fQADiJetDeltaPhiMax; // dijet QA histos limits | |
632 | ||
633 | Int_t fQADiJetNBinsDeltaEta; // dijet QA histos bins | |
634 | Float_t fQADiJetDeltaEtaMin; // dijet QA histos limits | |
635 | Float_t fQADiJetDeltaEtaMax; // dijet QA histos limits | |
636 | ||
637 | Int_t fQADiJetNBinsDeltaPt; // dijet QA histos bins | |
638 | Float_t fQADiJetDeltaPtMin; // dijet QA histos limits | |
639 | Float_t fQADiJetDeltaPtMax; // dijet QA histos limits | |
640 | ||
d7238ca3 | 641 | // Histograms |
642 | TList *fCommonHistList; // List of common histos | |
643 | ||
644 | TH1F *fh1EvtSelection; //! event cuts | |
645 | TH1F *fh1VertexNContributors; //! NContributors to prim vertex | |
646 | TH1F *fh1VertexZ; //! prim vertex z distribution | |
647 | TH1F *fh1EvtMult; //! number of reconstructed tracks after cuts | |
ac017ff3 | 648 | |
649 | TProfile* fh1Xsec; //! pythia cross section and trials | |
650 | TH1F* fh1Trials; //! sum of trials | |
651 | TH1F* fh1PtHard; //! pt hard of the event | |
652 | TH1F* fh1PtHardTrials; //! pt hard of the event | |
653 | ||
d7238ca3 | 654 | TH1F *fh1nRecJetsCuts; //! number of jets from reconstructed tracks per event |
655 | TH1F *fh1nGenJets; //! number of jets from generated tracks per event | |
7d9e8b32 | 656 | TH1F *fh1nRecEffJets; //! number of jets for reconstruction eff per event |
657 | ||
658 | // tracking efficiency | |
659 | ||
660 | THnSparseF *fhnSingleTrackRecEffHisto; //! track reconstruction efficiency | |
661 | THnSparseF *fhnJetTrackRecEffHisto; //! reconstruction efficiency jet tracks | |
d7238ca3 | 662 | |
ac017ff3 | 663 | ClassDef(AliAnalysisTaskFragmentationFunction, 5); |
6bec8236 | 664 | }; |
d7238ca3 | 665 | |
6bec8236 | 666 | #endif |