]>
Commit | Line | Data |
---|---|---|
9f9631f3 | 1 | #include "TChain.h" |
2 | #include "TTree.h" | |
3 | #include "TH1F.h" | |
4 | #include "TH2F.h" | |
5 | #include "TCanvas.h" | |
6 | #include "TList.h" | |
7 | #include "TParticle.h" | |
8 | #include "TParticlePDG.h" | |
9 | #include "TProfile.h" | |
10 | #include "TNtuple.h" | |
11 | #include "TFile.h" | |
12 | ||
13 | #include "AliAnalysisTask.h" | |
14 | #include "AliAnalysisManager.h" | |
15 | ||
16 | #include "AliESDEvent.h" | |
e4ab7356 | 17 | #include "AliLog.h" |
9f9631f3 | 18 | #include "AliESDVertex.h" |
19 | #include "AliESDInputHandler.h" | |
20 | #include "AliESDtrackCuts.h" | |
21 | #include "AliMultiplicity.h" | |
22 | ||
23 | ||
24 | #include "AliAnalysisTaskQASym.h" | |
25 | #include "AliExternalTrackParam.h" | |
26 | #include "AliTrackReference.h" | |
27 | ||
28 | #include "AliHeader.h" | |
29 | #include "AliGenEventHeader.h" | |
30 | #include "AliGenDPMjetEventHeader.h" | |
31 | ||
32 | // Analysis Task for basic QA on the ESD | |
33 | ||
34 | // Authors: Jan Fiete Grosse-Oetringhaus, Christian Klein-Boesing, | |
35 | // Andreas Morsch, Eva Sicking | |
36 | ||
37 | ClassImp(AliAnalysisTaskQASym) | |
38 | ||
39 | //________________________________________________________________________ | |
40 | AliAnalysisTaskQASym::AliAnalysisTaskQASym(const char *name) | |
41 | : AliAnalysisTaskSE(name) | |
42 | ,fFieldOn(kTRUE) | |
43 | ,fHists(0) | |
44 | ,fHistRECpt(0) | |
45 | ,fEta(0) | |
e4ab7356 | 46 | ,fEtaPhi(0) |
9f9631f3 | 47 | ,fEtaPt(0) |
48 | ,fQPt(0) | |
49 | ,fDca(0) | |
50 | ,fqRec(0) | |
51 | ,fsigmaPt(0) | |
52 | ||
53 | ,fRecPtPos(0) | |
54 | ,fRecPtNeg(0) | |
55 | ,fRecPhiPos(0) | |
56 | ,fRecPhiNeg(0) | |
57 | ,fRecEtaPos(0) | |
58 | ,fRecEtaNeg(0) | |
59 | ,fRecEtaPtPos(0) | |
60 | ,fRecEtaPtNeg(0) | |
61 | ,fRecDcaPos(0) | |
62 | ,fRecDcaNeg(0) | |
63 | ,fRecDcaNegInv(0) | |
64 | ,fRecDPos(0) | |
65 | ,fRecDNeg(0) | |
66 | ||
e4ab7356 | 67 | |
9f9631f3 | 68 | ,fRecQPtPosEta(0) |
69 | ,fRecQPtNegEta(0) | |
70 | ,fRecPtPosEta(0) | |
71 | ,fRecPtNegEta(0) | |
72 | ,fRecPhiPosEta(0) | |
73 | ,fRecPhiNegEta(0) | |
74 | ,fRecDcaPosEta(0) | |
75 | ,fRecDcaNegEta(0) | |
76 | ,fRecDPosEta(0) | |
77 | ,fRecDNegEta(0) | |
78 | ||
79 | ,fRecPtPosVz(0) | |
80 | ,fRecPtNegVz(0) | |
81 | ,fRecEtaPosVz(0) | |
82 | ,fRecEtaNegVz(0) | |
83 | ,fRecPhiPosVz(0) | |
84 | ,fRecPhiNegVz(0) | |
85 | ,fSignedDcaPosVz(0) | |
86 | ,fSignedDcaNegVz(0) | |
87 | ,fRecQPtPosEtaVz(0) | |
88 | ,fRecQPtNegEtaVz(0) | |
89 | ,fRecEtaPtPosVz(0) | |
90 | ,fRecEtaPtNegVz(0) | |
91 | ||
92 | ||
93 | ,fDeltaPhiAll(0) | |
94 | ,fDeltaPhiLeading(0) | |
95 | ,fDiffDcaD(0) | |
96 | ,fPhiRec(0) | |
97 | ,fThetaRec(0) | |
98 | ,fNumber(0) | |
99 | ,fVx(0) | |
100 | ,fVy(0) | |
101 | ,fVz(0) | |
102 | ,test(0) | |
103 | ||
104 | ||
105 | ,fCuts(0) | |
106 | ||
107 | ||
108 | ||
109 | { | |
110 | // Constructor | |
111 | for(Int_t i = 0;i<18;++i){ | |
112 | fRecPtTpcSector[i] = 0; | |
113 | fRecEtaTpcSector[i] = 0; | |
114 | fSignedDcaTpcSector[i] = 0; | |
115 | fRecQPtTpcSector[i] = 0; | |
116 | fRecEtaPtTpcSector[i] = 0; | |
117 | } | |
118 | ||
119 | for(Int_t i = 0;i< 7;++i){ | |
120 | fRecPtPosLadder[i] = 0; | |
121 | fRecPtNegLadder[i] = 0; | |
122 | fRecPhiPosLadder[i] = 0; | |
123 | fRecPhiNegLadder[i] = 0; | |
124 | fRecEtaPosLadder[i] = 0; | |
125 | fRecEtaNegLadder[i] = 0; | |
126 | fSignDcaPos[i] = 0; | |
127 | fSignDcaNeg[i] = 0; | |
128 | fSignDcaNegInv[i] = 0; | |
129 | fPtSigmaPos[i] =0; | |
130 | fPtSigmaNeg[i] =0; | |
131 | fqPtRec[i] =0; | |
132 | fDcaSigmaPos[i] =0; | |
133 | fDcaSigmaNeg[i] =0; | |
134 | } | |
135 | ||
136 | DefineOutput(1, TList::Class()); | |
137 | ||
138 | ||
139 | ||
140 | } | |
141 | ||
142 | ||
143 | //________________________________________________________________________ | |
144 | void AliAnalysisTaskQASym::UserCreateOutputObjects() | |
145 | { | |
146 | // Create histograms | |
147 | // Called once | |
148 | ||
e4ab7356 | 149 | Double_t range = 1.; |
9f9631f3 | 150 | Double_t pt = 20.; |
151 | ||
152 | fHists = new TList(); | |
e4ab7356 | 153 | // test = new TNtuple("test","test", |
154 | // "pt:phi:theta:x:y:z:charge"); | |
9f9631f3 | 155 | fHistRECpt = new TH1F("fHistRECpt", |
156 | " p_{T}", | |
157 | 100, 0., pt); | |
158 | fEta = new TH1F("fEta", | |
159 | " #eta", | |
160 | 200, -2., 2.); | |
e4ab7356 | 161 | fEtaPhi = new TH2F("fEtaPhi", |
162 | " #eta - #phi", | |
163 | 200, -2., 2., 128, 0., 2. * TMath::Pi()); | |
164 | ||
9f9631f3 | 165 | fThetaRec = new TH1F("fThetaRec", |
166 | " #theta", | |
167 | 180, 0., TMath::Pi()); | |
168 | fPhiRec = new TH1F("fPhiRec", | |
169 | " #phi", | |
170 | 180, 0., 2*TMath::Pi()); | |
171 | fNumber = new TH1F("fNumber", | |
172 | "number of tracks per event", | |
173 | 50, 0.5, 49.5); | |
174 | fVx = new TH1F("fVx", | |
175 | "X of vertex", | |
e4ab7356 | 176 | 100, -5., 5.); |
9f9631f3 | 177 | fVy = new TH1F("fVy", |
178 | "Y of vertex", | |
e4ab7356 | 179 | 100, -5., 5.); |
9f9631f3 | 180 | fVz = new TH1F("fVz", |
181 | "Z of vertex", | |
e4ab7356 | 182 | 500, -50., 50.); |
9f9631f3 | 183 | |
184 | fEtaPt = new TH1F("fEtaPt", | |
185 | " #eta/p_{T} ", | |
186 | 100, -1., 1.); | |
187 | ||
188 | fQPt = new TH1F("fQPt", | |
189 | " charge/p_{T} ", | |
190 | 100, -1., 1.); | |
191 | ||
192 | fDca = new TH1F("fDca", | |
193 | " dca ", | |
194 | 200, -range, range); | |
195 | ||
196 | ||
197 | fqRec = new TH1F("fqRec", | |
198 | " charge all reconstructed particle", | |
199 | 21, -9.5, 10.5); | |
200 | ||
201 | fsigmaPt = new TH1F("fsigmaPt", | |
202 | "Log_{10}(#sigma_{p_{T}})", | |
203 | 200, -2., 8.); | |
204 | ||
205 | ||
206 | ||
207 | ||
208 | //------------ | |
209 | for(Int_t ITSlayer_case=0;ITSlayer_case<7;ITSlayer_case++){ | |
210 | ||
211 | fSignDcaPos[ITSlayer_case] = new TH1F(Form("fSignDcaPos%d", ITSlayer_case), | |
212 | " Signed dca", | |
213 | 200, -range, range); | |
214 | fSignDcaPos[ITSlayer_case]->GetXaxis()->SetTitle("dca"); | |
215 | fSignDcaPos[ITSlayer_case]->GetYaxis()->SetTitle(""); | |
216 | ||
217 | ||
218 | fSignDcaNeg[ITSlayer_case] = new TH1F(Form("fSignDcaNeg%d", ITSlayer_case), | |
219 | " Signed dcas", | |
220 | 200, -range, range); | |
221 | fSignDcaNeg[ITSlayer_case]->GetXaxis()->SetTitle("dca"); | |
222 | fSignDcaNeg[ITSlayer_case]->GetYaxis()->SetTitle(""); | |
223 | ||
224 | fSignDcaNegInv[ITSlayer_case] = new TH1F(Form("fSignDcaNegInv%d", ITSlayer_case), | |
225 | " inverse Signed dca ", | |
226 | 200, -range, range); | |
227 | fSignDcaNegInv[ITSlayer_case]->GetXaxis()->SetTitle("-dca"); | |
228 | fSignDcaNegInv[ITSlayer_case]->GetYaxis()->SetTitle(""); | |
229 | ||
230 | ||
231 | ||
232 | ||
233 | fPtSigmaPos[ITSlayer_case] = new TH1F(Form("fPtSigmaPos%d", ITSlayer_case), | |
234 | " #sigma_{pT} ", | |
235 | 208, -2., 8.); | |
236 | fPtSigmaPos[ITSlayer_case]->GetXaxis()->SetTitle("Log_{10}(#sigma_{pT})"); | |
237 | fPtSigmaPos[ITSlayer_case]->GetYaxis()->SetTitle(""); | |
238 | ||
239 | ||
240 | fPtSigmaNeg[ITSlayer_case] = new TH1F(Form("fPtSigmaNeg%d",ITSlayer_case), | |
241 | " #sigma_{pT}", | |
242 | 208, -2., 8.); | |
243 | fPtSigmaNeg[ITSlayer_case]->GetXaxis()->SetTitle("Log_{10}(#sigma_{pT})"); | |
244 | fPtSigmaNeg[ITSlayer_case]->GetYaxis()->SetTitle(""); | |
245 | ||
246 | ||
247 | ||
248 | ||
249 | ||
250 | fqPtRec[ITSlayer_case] = new TH1F(Form("fqPtRec%d",ITSlayer_case), | |
251 | "q/ p_{T}", | |
252 | 200, -100., 100.); | |
253 | fqPtRec[ITSlayer_case]->GetXaxis()->SetTitle("q_{tr}/p_{T, tr} (GeV/c)"); | |
254 | fqPtRec[ITSlayer_case]->GetYaxis()->SetTitle(""); | |
255 | ||
256 | ||
257 | ||
258 | ||
259 | ||
260 | fDcaSigmaPos[ITSlayer_case] = new TH2F(Form("fDcaSigmaPos%d", ITSlayer_case), | |
261 | " p_{T} shift vs #sigma_{pT} ", | |
262 | 200, -range, range,200, -4., 4. ); | |
263 | fDcaSigmaPos[ITSlayer_case]->GetXaxis()->SetTitle("signed DCA)"); | |
264 | fDcaSigmaPos[ITSlayer_case]->GetYaxis()->SetTitle("log_{10}(#sigma_{pT})"); | |
265 | ||
266 | ||
267 | fDcaSigmaNeg[ITSlayer_case] = new TH2F(Form("fDcaSigmaNeg%d", ITSlayer_case), | |
268 | " p_{T} shift vs #sigma_{pT} ", | |
269 | 200, -range, range,200, -4., 4. ); | |
270 | fDcaSigmaNeg[ITSlayer_case]->GetXaxis()->SetTitle("signed DCA"); | |
271 | fDcaSigmaNeg[ITSlayer_case]->GetYaxis()->SetTitle("log_{10}(#sigma_{pT})"); | |
272 | ||
273 | ||
274 | ||
275 | ||
276 | ||
277 | ||
278 | // YIELDs---------- positive and negative particles | |
279 | ||
280 | fRecPtPos = new TH1F("fRecPtPos", | |
281 | " p_{T}", | |
282 | 100, 0.,pt); | |
283 | fRecPtPos->GetXaxis()->SetTitle("p_{T} (GeV/c)"); | |
284 | fRecPtNeg = new TH1F("fRecPtNeg", | |
285 | " p_{T} ", | |
286 | 100, 0., pt); | |
287 | fRecPtNeg->GetXaxis()->SetTitle("p_{T} (GeV/c)"); | |
288 | ||
289 | ||
290 | fRecPhiPos = new TH1F("fRecPhiPos", | |
291 | "#phi", | |
292 | 361, 0., 360.); | |
293 | fRecPhiPos->GetXaxis()->SetTitle("#phi (deg)"); | |
294 | ||
295 | fRecPhiNeg = new TH1F("fRecPhiNeg", | |
296 | "#phi ", | |
297 | 361, 0., 360.); | |
298 | fRecPhiNeg->GetXaxis()->SetTitle("#phi (deg)"); | |
299 | ||
300 | fRecEtaPos = new TH1F("fRecEtaPos", | |
301 | "#eta", | |
302 | 200, -2., 2.); | |
303 | fRecEtaPos->GetXaxis()->SetTitle("#eta"); | |
304 | ||
305 | fRecEtaNeg = new TH1F("fRecEtaNeg", | |
306 | "#eta", | |
307 | 200, -2., 2.); | |
308 | fRecEtaNeg->GetXaxis()->SetTitle("#eta"); | |
309 | ||
310 | fRecEtaPtPos = new TH1F("fRecEtaPtPos", | |
311 | "#eta/p_{T}", | |
312 | 200, -0.1, .1); | |
313 | fRecEtaPtPos->GetXaxis()->SetTitle("#eta/p_{T}"); | |
314 | ||
315 | fRecEtaPtNeg = new TH1F("fRecEtaPtNeg", | |
316 | "#eta/p_{T}", | |
317 | 200, -.1, .1); | |
318 | fRecEtaPtNeg->GetXaxis()->SetTitle("#eta/p_{T}"); | |
319 | ||
320 | fRecDcaPos = new TH1F("fRecDcaPos", | |
321 | " dca", | |
322 | 100, -range, range); | |
323 | fRecDcaPos->GetXaxis()->SetTitle("dca (cm)"); | |
324 | fRecDcaNeg = new TH1F("fRecDcaNeg", | |
325 | " dca", | |
326 | 100, -range, range); | |
327 | fRecDcaNeg->GetXaxis()->SetTitle("dca (cm)"); | |
328 | ||
329 | fRecDcaNegInv = new TH1F("fRecDcaNegInv", | |
330 | " dca", | |
331 | 100, -range, range); | |
332 | fRecDcaNegInv->GetXaxis()->SetTitle("dca (cm)"); | |
333 | ||
334 | ||
335 | fRecDPos = new TH1F("fRecDPos", | |
336 | " d", | |
337 | 100, -range, range); | |
338 | fRecDPos->GetXaxis()->SetTitle("d (cm)"); | |
339 | fRecDNeg = new TH1F("fRecDNeg", | |
340 | "d", | |
341 | 100, -range, range); | |
342 | fRecDNeg->GetXaxis()->SetTitle("d (cm)"); | |
343 | ||
344 | ||
345 | // YIELDs ---------------- positive and negative eta | |
346 | ||
347 | ||
348 | fRecQPtPosEta = new TH1F("fRecQPtPosEta", | |
349 | "q/p_{T}", | |
350 | 200, -0.5, 0.5); | |
351 | fRecQPtPosEta->GetXaxis()->SetTitle("q/p_{T} "); | |
352 | ||
353 | fRecQPtNegEta = new TH1F("fRecQPtNegEta", | |
354 | "q/p_{T}", | |
355 | 200, -0.5, 0.5); | |
356 | fRecQPtNegEta->GetXaxis()->SetTitle("q/p_{T}"); | |
357 | ||
358 | fRecPtPosEta = new TH1F("fRecPtPosEta", | |
359 | " p_{T} ", | |
360 | 100, 0., pt); | |
361 | fRecPtPosEta->GetXaxis()->SetTitle("p_{T} (GeV/c)"); | |
362 | ||
363 | fRecPtNegEta = new TH1F("fRecPtNegEta", | |
364 | " p_{T}", | |
365 | 100, 0., pt); | |
366 | fRecPtNegEta->GetXaxis()->SetTitle("p_{T} (GeV/c)"); | |
367 | ||
368 | fRecPhiPosEta = new TH1F("fRecPhiPosEta", | |
369 | "#phi", | |
370 | 361, 0., 360); | |
371 | fRecPhiPosEta->GetXaxis()->SetTitle("#phi (deg)"); | |
372 | ||
373 | fRecPhiNegEta = new TH1F("fRecPhiNegEta", | |
374 | "#phi ", | |
375 | 361, 0, 360); | |
376 | fRecPhiNegEta->GetXaxis()->SetTitle("#phi (deg)"); | |
377 | ||
378 | fRecDcaPosEta = new TH1F("fRecDcaPosEta", | |
379 | " dca ", | |
380 | 100, -range, range); | |
381 | fRecDcaPosEta->GetXaxis()->SetTitle("dca (cm)"); | |
382 | fRecDcaNegEta = new TH1F("fRecDcaNegEta", | |
383 | " dca", | |
384 | 100, -range, range); | |
385 | fRecDcaNegEta->GetXaxis()->SetTitle("dca (cm)"); | |
386 | ||
387 | fRecDPosEta = new TH1F("fRecDPosEta", | |
388 | " d", | |
389 | 100, -range, range); | |
390 | fRecDPosEta->GetXaxis()->SetTitle("d (cm)"); | |
391 | fRecDNegEta = new TH1F("fRecDNegEta", | |
392 | "d", | |
393 | 100, -5., 5.); | |
394 | fRecDNegEta->GetXaxis()->SetTitle("d (cm)"); | |
395 | ||
396 | ||
397 | ||
398 | // YIELDs ---------------- for TPC sectors | |
399 | for(Int_t sector=0; sector<18;sector++){ | |
400 | ||
401 | ||
402 | fRecPtTpcSector[sector] = new TH1F(Form("fRecPtTpcSector%02d",sector), | |
403 | Form("p_{T} distribution: TPC sector %d", | |
404 | sector),100, 0., pt); | |
405 | fRecPtTpcSector[sector]->GetXaxis()->SetTitle("p_{T} (GeV/c)"); | |
406 | ||
407 | fRecEtaTpcSector[sector] = new TH1F(Form("fRecEtaTpcSector%02d",sector), | |
408 | Form("#eta distribution: TPC sector %d", | |
409 | sector),200, -2., 2.); | |
410 | fRecEtaTpcSector[sector]->GetXaxis()->SetTitle("p_{T} (GeV/c)"); | |
411 | ||
412 | ||
413 | fSignedDcaTpcSector[sector] = new TH1F(Form("fSignedDcaTpcSector%02d",sector), | |
414 | Form("dca distribution: TPC sector %d", | |
415 | sector),200, -range, range ); | |
416 | fSignedDcaTpcSector[sector]->GetXaxis()->SetTitle("dca"); | |
417 | ||
418 | fRecQPtTpcSector[sector] = new TH1F(Form("fRecQPtTpcSector%02d",sector), | |
419 | Form("Q/ p_{T} distribution: TPC sector %d", | |
420 | sector),100, -1., 1.); | |
421 | fRecQPtTpcSector[sector]->GetXaxis()->SetTitle("Q/p_{T} (GeV/c)"); | |
422 | ||
423 | fRecEtaPtTpcSector[sector] = new TH1F(Form("fRecEtaPtTpcSector%02d",sector), | |
424 | Form("#eta/ p_{T} distribution: TPC sector %d", | |
425 | sector),100, -1., 1.); | |
426 | fRecEtaPtTpcSector[sector]->GetXaxis()->SetTitle("#eta/p_{T} (GeV/c)"); | |
427 | ||
428 | } | |
429 | // YIELDS ITS ladder | |
430 | for(Int_t i=0;i<7;i++){ | |
431 | fRecPtPosLadder[i] = new TH1F(Form("fRecPtPosLadder%d", i), | |
432 | " p_{T} distribution", | |
433 | 100, 0., pt); | |
434 | fRecPtPosLadder[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)"); | |
435 | fRecPtNegLadder[i] = new TH1F(Form("fRecPtNegLadder%d",i), | |
436 | " p_{T} distribution ", | |
437 | 100, 0., pt); | |
438 | fRecPtNegLadder[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)"); | |
439 | ||
440 | ||
441 | fRecPhiPosLadder[i] = new TH1F(Form("fRecPhiPosLadder%d",i), | |
442 | "#phi distribution: all pos eta", | |
443 | 361, 0., 360); | |
444 | fRecPhiPosLadder[i]->GetXaxis()->SetTitle("#phi (deg)"); | |
445 | ||
446 | fRecPhiNegLadder[i] = new TH1F(Form("fRecPhiNegLadder%d", i), | |
447 | "#phi distribution: all neg eta", | |
448 | 361, 0, 360); | |
449 | fRecPhiNegLadder[i]->GetXaxis()->SetTitle("#phi (deg)"); | |
450 | ||
451 | ||
452 | ||
453 | fRecEtaPosLadder[i] = new TH1F(Form("fRecEtaPosLadder%d",i), | |
454 | "#eta distribution", | |
455 | 200, -2., 2.); | |
456 | fRecEtaPosLadder[i]->GetXaxis()->SetTitle("#eta)"); | |
457 | ||
458 | fRecEtaNegLadder[i] = new TH1F(Form("fRecEtaNegLadder%d", i), | |
459 | "#eta distribution", | |
460 | 200, -2., 2.); | |
461 | fRecEtaNegLadder[i]->GetXaxis()->SetTitle("#eta"); | |
462 | } | |
463 | ||
464 | Double_t vzmax = 30; | |
465 | ||
466 | fRecPtPosVz = new TH2F("fRecPtPosVz", | |
467 | "p_{T} distribution vs Vz()", | |
468 | 100, -1., 2., 200,-vzmax,vzmax); | |
469 | fRecPtPosVz->GetXaxis()->SetTitle("log_{10}(p_{T})"); | |
470 | ||
471 | fRecPtNegVz = new TH2F("fRecPtNegVz", | |
472 | "p_{T} distribution vs Vz()", | |
473 | 100, -1., 2.,200,-vzmax,vzmax); | |
474 | fRecPtNegVz->GetXaxis()->SetTitle("Log_{10}(p_{T})"); | |
475 | ||
476 | ||
477 | fRecEtaPosVz= new TH2F("fRecEtaPosVz", | |
478 | "#eta distribution vs Vz()", | |
479 | 100, -2., 2., 200,-vzmax,vzmax); | |
480 | fRecEtaPosVz->GetXaxis()->SetTitle("#eta"); | |
481 | fRecEtaNegVz = new TH2F("fRecEtaNegVz", | |
482 | "#eta distribution vs Vz()", | |
483 | 100, -2., 2.,200,-vzmax,vzmax); | |
484 | fRecEtaNegVz->GetXaxis()->SetTitle("#eta"); | |
485 | ||
486 | fRecPhiPosVz= new TH2F("fRecPhiPosVz", | |
487 | "#eta distribution vs Vz()", | |
488 | 361, 0., 360., 200,-vzmax,vzmax); | |
489 | fRecPhiPosVz->GetXaxis()->SetTitle("#phi (deg)"); | |
490 | fRecPhiNegVz = new TH2F("fRecPhiNegVz", | |
491 | "dca vs Vz()", | |
492 | 361, 0., 360.,200,-vzmax,vzmax); | |
493 | fRecPhiNegVz->GetXaxis()->SetTitle("#phi (deg)"); | |
494 | ||
495 | fSignedDcaPosVz= new TH2F("fSignedDcaPosVz", | |
496 | "#eta distribution vs Vz()", | |
497 | 200, -range, range, 200,-vzmax,vzmax); | |
498 | fSignedDcaPosVz->GetXaxis()->SetTitle("dca (cm)"); | |
499 | fSignedDcaNegVz = new TH2F("fSignedDcaNegVz", | |
500 | "dca vs Vz()", | |
501 | 200, -range, range,200,-vzmax,vzmax); | |
502 | fSignedDcaNegVz->GetXaxis()->SetTitle("dca (cm)"); | |
503 | ||
504 | fRecQPtPosEtaVz= new TH2F("fRecQPtPosEtaVz", | |
505 | " Q/p_{T} distribution vs Vz()", | |
506 | 100, -1., 1., 200,-vzmax,vzmax); | |
507 | fRecQPtPosEtaVz->GetXaxis()->SetTitle("Q/p_{T}"); | |
508 | fRecQPtNegEtaVz = new TH2F("fRecQPtNegEtaVz", | |
509 | " Q/p_{T} distribution vs Vz()", | |
510 | 100, -1., 1.,200,-vzmax,vzmax); | |
511 | fRecQPtNegEtaVz->GetXaxis()->SetTitle("Q/p_{T}"); | |
512 | ||
513 | ||
514 | fRecEtaPtPosVz= new TH2F("fRecEtaPtPosVz", | |
515 | " #eta/p_{T} distribution vs Vz()", | |
516 | 100, -1., 1., 200,-vzmax,vzmax); | |
517 | fRecEtaPtPosVz->GetXaxis()->SetTitle("#eta/p_{T"); | |
518 | fRecEtaPtNegVz = new TH2F("fRecEtaPtNegVz", | |
519 | " #eta/p_{T} distribution vs Vz()", | |
520 | 100, -1., 1.,200,-vzmax,vzmax); | |
521 | fRecEtaPtNegVz->GetXaxis()->SetTitle("#eta/p_{T}"); | |
522 | ||
523 | //new | |
524 | fDeltaPhiAll = new TH1F("fDeltaPhiAll", | |
525 | " #Delta #phi",200,-360,360); | |
526 | fDeltaPhiAll->GetXaxis()->SetTitle("#Delta #phi"); | |
527 | ||
528 | ||
529 | fDeltaPhiLeading = new TH2F("fDeltaPhiLeading", | |
530 | " #Delta #phi",361,-360,360, 361,0, 360); | |
531 | fDeltaPhiLeading->GetXaxis()->SetTitle("#Delta #phi (deg.)"); | |
532 | fDeltaPhiLeading->GetYaxis()->SetTitle("#phi_{leading particle} (deg.)"); | |
533 | ||
534 | fDiffDcaD = new TH1F("fDiffDcaD", | |
535 | "dca-d", | |
536 | 200, -5., 5.); | |
537 | ||
538 | } | |
539 | ||
540 | fHists->SetOwner(); | |
541 | ||
9f9631f3 | 542 | fHists->Add(fHistRECpt); |
543 | fHists->Add(fEta); | |
e4ab7356 | 544 | fHists->Add(fEtaPhi); |
9f9631f3 | 545 | fHists->Add(fThetaRec); |
546 | fHists->Add(fPhiRec); | |
547 | fHists->Add(fNumber); | |
548 | fHists->Add(fVx); | |
549 | fHists->Add(fVy); | |
550 | fHists->Add(fVz); | |
551 | ||
552 | fHists->Add(fEtaPt); | |
553 | fHists->Add(fQPt); | |
554 | fHists->Add(fDca); | |
555 | ||
556 | fHists->Add(fDeltaPhiAll); | |
557 | fHists->Add(fDeltaPhiLeading); | |
558 | fHists->Add(fDiffDcaD); | |
559 | ||
560 | fHists->Add(fqRec); | |
561 | fHists->Add(fsigmaPt); | |
562 | ||
563 | fHists->Add(fRecPtPos); | |
564 | fHists->Add(fRecPtNeg); | |
565 | fHists->Add(fRecPhiPos); | |
566 | fHists->Add(fRecPhiNeg); | |
567 | fHists->Add(fRecEtaPos); | |
568 | fHists->Add(fRecEtaNeg); | |
569 | fHists->Add(fRecEtaPtPos); | |
570 | fHists->Add(fRecEtaPtNeg); | |
571 | fHists->Add(fRecDcaPos); | |
572 | fHists->Add(fRecDcaNeg); | |
573 | fHists->Add(fRecDcaNegInv); | |
574 | fHists->Add(fRecDPos); | |
575 | fHists->Add(fRecDNeg); | |
576 | ||
577 | ||
578 | fHists->Add(fRecQPtPosEta); | |
579 | fHists->Add(fRecQPtNegEta); | |
580 | fHists->Add(fRecPtPosEta); | |
581 | fHists->Add(fRecPtNegEta); | |
582 | fHists->Add(fRecPhiPosEta); | |
583 | fHists->Add(fRecPhiNegEta); | |
584 | fHists->Add(fRecDcaPosEta); | |
585 | fHists->Add(fRecDcaNegEta); | |
586 | fHists->Add(fRecDPosEta); | |
587 | fHists->Add(fRecDNegEta); | |
588 | ||
589 | ||
590 | for(Int_t i=0;i<18;i++){ | |
591 | fHists->Add(fRecPtTpcSector[i]); | |
592 | fHists->Add(fRecEtaTpcSector[i]); | |
593 | fHists->Add(fSignedDcaTpcSector[i]); | |
594 | fHists->Add(fRecQPtTpcSector[i]); | |
595 | fHists->Add(fRecEtaPtTpcSector[i]); | |
596 | } | |
597 | ||
598 | for(Int_t i=0;i<7;i++){ | |
599 | fHists->Add(fRecPtPosLadder[i]); | |
600 | fHists->Add(fRecPtNegLadder[i]); | |
601 | fHists->Add(fRecPhiPosLadder[i]); | |
602 | fHists->Add(fRecPhiNegLadder[i]); | |
603 | fHists->Add(fRecEtaPosLadder[i]); | |
604 | fHists->Add(fRecEtaNegLadder[i]); | |
605 | } | |
606 | ||
607 | fHists->Add(fRecPtPosVz); | |
608 | fHists->Add(fRecPtNegVz); | |
609 | fHists->Add(fRecEtaPosVz); | |
610 | fHists->Add(fRecEtaNegVz); | |
611 | fHists->Add(fRecPhiPosVz); | |
612 | fHists->Add(fRecPhiNegVz); | |
613 | fHists->Add(fSignedDcaPosVz); | |
614 | fHists->Add(fSignedDcaNegVz); | |
615 | fHists->Add(fRecQPtPosEtaVz); | |
616 | fHists->Add(fRecQPtNegEtaVz); | |
617 | fHists->Add(fRecEtaPtPosVz); | |
618 | fHists->Add(fRecEtaPtNegVz); | |
619 | ||
620 | ||
621 | for(Int_t i=0;i<7;i++){ | |
622 | fHists->Add(fSignDcaPos[i]); | |
623 | fHists->Add(fSignDcaNeg[i]); | |
624 | fHists->Add(fSignDcaNegInv[i]); | |
625 | ||
626 | fHists->Add(fPtSigmaPos[i]); | |
627 | fHists->Add(fPtSigmaNeg[i]); | |
628 | fHists->Add(fqPtRec[i]); | |
629 | ||
630 | fHists->Add(fDcaSigmaPos[i]); | |
631 | fHists->Add(fDcaSigmaNeg[i]); | |
632 | ||
633 | ||
634 | } | |
635 | ||
636 | ||
637 | ||
638 | for (Int_t i=0; i<fHists->GetEntries(); ++i) { | |
639 | TH1 *h1 = dynamic_cast<TH1*>(fHists->At(i)); | |
640 | if (h1){ | |
641 | // Printf("%s ",h1->GetName()); | |
642 | h1->Sumw2(); | |
643 | } | |
644 | } | |
645 | // BKC | |
646 | ||
647 | ||
648 | } | |
649 | ||
650 | //__________________________________________________________ | |
651 | ||
652 | void AliAnalysisTaskQASym::UserExec(Option_t *) | |
653 | { | |
e4ab7356 | 654 | printf("I'm here \n"); |
9f9631f3 | 655 | AliVEvent *event = InputEvent(); |
656 | if (!event) { | |
657 | Printf("ERROR: Could not retrieve event"); | |
658 | return; | |
659 | } | |
660 | ||
661 | ||
662 | if(Entry()==0){ | |
663 | AliESDEvent* esd = dynamic_cast<AliESDEvent*>(event); | |
664 | if(esd){ | |
665 | Printf("We are reading from ESD"); | |
666 | } | |
667 | ||
668 | } | |
669 | ||
670 | Printf("There are %d tracks in this event", event->GetNumberOfTracks()); | |
671 | ||
672 | ||
673 | Int_t LeadingTrack = 0; | |
674 | Float_t LeadingEnergy = -20.; | |
675 | Float_t LeadingPhi = 0;//TMath::Pi(); | |
676 | ||
677 | ||
678 | if(event->GetNumberOfTracks()!=0) fNumber->Fill(event->GetNumberOfTracks()); | |
679 | ||
e4ab7356 | 680 | const AliVVertex* vertex = event->GetPrimaryVertex(); |
681 | Float_t vz = vertex->GetZ(); | |
682 | if (TMath::Abs(vz) > 10.) return; | |
683 | ||
9f9631f3 | 684 | for (Int_t iTrack = 0; iTrack < event->GetNumberOfTracks(); iTrack++) { |
685 | ||
686 | ||
687 | AliVParticle *track = event->GetTrack(iTrack); | |
688 | AliESDtrack *esdtrack = dynamic_cast<AliESDtrack*>(track); | |
689 | if (!track) { | |
690 | Printf("ERROR: Could not receive track %d", iTrack); | |
691 | continue; | |
692 | } | |
693 | ||
e4ab7356 | 694 | //if (!fCuts->AcceptTrack(esdtrack)) continue; |
695 | const AliExternalTrackParam * tpcPSO = esdtrack->GetTPCInnerParam(); | |
696 | const AliExternalTrackParam * tpcP = esdtrack; | |
9f9631f3 | 697 | if (!tpcP) continue; |
698 | ||
e4ab7356 | 699 | |
700 | if (tpcP->Pt() > 50. && tpcPSO) { | |
701 | printf("High Pt %5d %5d %13.3f %13.3f \n", event->GetPeriodNumber(), event->GetOrbitNumber(), | |
702 | tpcPSO->Pt(), esdtrack->Pt()); | |
703 | // AliFatal("Jet"); | |
704 | } | |
9f9631f3 | 705 | |
e4ab7356 | 706 | // if (tpcPSO) fRecPt12->Fill(tpcPSO->Pt(), esdtrack->Pt()); |
707 | ||
9f9631f3 | 708 | if(tpcP->E()>LeadingEnergy){ |
709 | LeadingTrack=iTrack; | |
710 | LeadingEnergy=tpcP->E(); | |
711 | LeadingPhi=tpcP->Phi(); | |
712 | } | |
713 | ||
714 | ||
715 | ||
716 | ||
717 | //propagate to dca | |
718 | esdtrack->PropagateToDCA(event->GetPrimaryVertex(), | |
719 | event->GetMagneticField(), 10000.); | |
720 | ||
721 | ||
722 | // if(tpcP->Pt()<2.)continue; | |
723 | ||
724 | ||
725 | fqRec->Fill(tpcP->Charge()); | |
726 | ||
727 | ||
728 | Double_t sigmapt = tpcP->GetSigma1Pt2(); | |
729 | sigmapt= sqrt(sigmapt); | |
730 | sigmapt= sigmapt *(tpcP->Pt()*tpcP->Pt()); | |
731 | ||
732 | if(sigmapt == 0.)continue; | |
733 | fsigmaPt->Fill(TMath::Log10(sigmapt)); | |
734 | ||
735 | ||
736 | ||
737 | ||
738 | ||
739 | ||
740 | ||
741 | // hits in ITS layer | |
742 | Int_t cas=-1; | |
743 | if(esdtrack->HasPointOnITSLayer(0)) | |
744 | cas=0; | |
745 | else if(!esdtrack->HasPointOnITSLayer(0) | |
746 | && esdtrack->HasPointOnITSLayer(1)) | |
747 | cas=1; | |
748 | else if(!esdtrack->HasPointOnITSLayer(0) | |
749 | && !esdtrack->HasPointOnITSLayer(1) | |
750 | && esdtrack->HasPointOnITSLayer(2)) | |
751 | cas=2; | |
752 | else if(!esdtrack->HasPointOnITSLayer(0) | |
753 | && !esdtrack->HasPointOnITSLayer(1) | |
754 | && !esdtrack->HasPointOnITSLayer(2) | |
755 | && esdtrack->HasPointOnITSLayer(3)) | |
756 | cas=3; | |
757 | else if(!esdtrack->HasPointOnITSLayer(0) | |
758 | && !esdtrack->HasPointOnITSLayer(1) | |
759 | && !esdtrack->HasPointOnITSLayer(2) | |
760 | && !esdtrack->HasPointOnITSLayer(3) | |
761 | && esdtrack->HasPointOnITSLayer(4)) | |
762 | cas=4; | |
763 | else if( !esdtrack->HasPointOnITSLayer(0) | |
764 | && !esdtrack->HasPointOnITSLayer(1) | |
765 | && !esdtrack->HasPointOnITSLayer(2) | |
766 | && !esdtrack->HasPointOnITSLayer(3) | |
767 | && !esdtrack->HasPointOnITSLayer(4) | |
768 | && esdtrack->HasPointOnITSLayer(5)) | |
769 | cas=5; | |
770 | else | |
771 | cas=6; | |
772 | ||
773 | ||
774 | ||
775 | //------------------- | |
776 | ||
777 | sdca_tr = (tpcP->Py()*tpcP->Xv() | |
778 | - tpcP->Px()*tpcP->Yv())/tpcP->Pt(); | |
779 | ||
780 | ||
781 | ||
782 | fqPtRec[cas]->Fill(tpcP->Charge()/tpcP->Pt()); | |
783 | ||
784 | ||
e4ab7356 | 785 | // test->Fill(tpcP->Pt(),tpcP->Phi(), tpcP->Theta(), |
786 | // tpcP->Xv(),tpcP->Yv(), tpcP->Zv(), tpcP->Charge()); | |
9f9631f3 | 787 | fHistRECpt->Fill(tpcP->Pt()); |
788 | fEta->Fill(tpcP->Eta()); | |
789 | fThetaRec->Fill(tpcP->Theta()); | |
790 | fPhiRec->Fill(tpcP->Phi()); | |
791 | fVx->Fill(tpcP->Xv()); | |
792 | fVy->Fill(tpcP->Yv()); | |
793 | fVz->Fill(tpcP->Zv()); | |
794 | ||
795 | ||
796 | fEtaPt->Fill(tpcP->Eta()/tpcP->Pt()); | |
797 | fQPt->Fill(tpcP->Charge()/tpcP->Pt()); | |
798 | fDca->Fill(sdca_tr); | |
799 | ||
800 | ||
801 | ||
802 | ||
803 | esdtrack->GetImpactParameters(xy,z); | |
804 | fDiffDcaD->Fill(sdca_tr+xy); | |
805 | ||
806 | ||
807 | //for positive particles | |
e4ab7356 | 808 | |
9f9631f3 | 809 | if(tpcP->Charge()>0){ |
810 | fRecPtPos->Fill(tpcP->Pt()); | |
811 | fRecPtPosLadder[cas]->Fill(tpcP->Pt()); | |
812 | fRecPtPosVz->Fill(TMath::Log10(tpcP->Pt()),tpcP->Zv()); | |
813 | fRecPhiPos->Fill(TMath::RadToDeg()*tpcP->Phi()); | |
814 | ||
815 | ||
816 | fRecPhiPosLadder[cas]->Fill(TMath::RadToDeg()*tpcP->Phi()); | |
817 | fRecPhiPosVz->Fill(TMath::RadToDeg()*tpcP->Phi(),tpcP->Zv()); | |
818 | fSignedDcaPosVz->Fill(sdca_tr,tpcP->Zv()); | |
819 | ||
820 | fRecEtaPos->Fill(tpcP->Eta()); | |
821 | fRecEtaPosLadder[cas]->Fill(tpcP->Eta()); | |
822 | fRecEtaPtPos->Fill(tpcP->Eta()/tpcP->Pt()); | |
823 | fRecEtaPosVz->Fill(tpcP->Eta(),tpcP->Zv()); | |
824 | fRecEtaPtPosVz->Fill(tpcP->Eta()/tpcP->Pt(),tpcP->Zv()); | |
825 | ||
826 | fRecDcaPos->Fill(sdca_tr); | |
827 | fRecDPos->Fill(xy); | |
828 | fSignDcaPos[cas]->Fill(sdca_tr); | |
829 | ||
830 | ||
831 | fDcaSigmaPos[cas]->Fill(sdca_tr, TMath::Log10(sigmapt)); | |
832 | ||
833 | fPtSigmaPos[cas]->Fill(TMath::Log10(sigmapt)); | |
834 | } | |
835 | //and negative particles | |
836 | else { | |
837 | fRecPtNeg->Fill(tpcP->Pt()); | |
838 | fRecPtNegLadder[cas]->Fill(tpcP->Pt()); | |
839 | fRecPtNegVz->Fill(TMath::Log10(tpcP->Pt()),tpcP->Zv()); | |
840 | ||
841 | fRecPhiNeg->Fill(TMath::RadToDeg()*tpcP->Phi()); | |
842 | fRecPhiNegLadder[cas]->Fill(TMath::RadToDeg()*tpcP->Phi()); | |
843 | fRecPhiNegVz->Fill(TMath::RadToDeg()*tpcP->Phi(),tpcP->Zv()); | |
844 | fSignedDcaNegVz->Fill(sdca_tr,tpcP->Zv()); | |
845 | fRecEtaPtNegVz->Fill(tpcP->Eta()/tpcP->Pt(),tpcP->Zv()); | |
846 | ||
847 | fRecEtaNeg->Fill(tpcP->Eta()); | |
848 | fRecEtaNegLadder[cas]->Fill(tpcP->Eta()); | |
849 | fRecEtaPtNeg->Fill(tpcP->Eta()/tpcP->Pt()); | |
850 | fRecEtaNegVz->Fill(tpcP->Eta(),tpcP->Zv()); | |
851 | ||
852 | fRecDcaNeg->Fill(sdca_tr); | |
853 | fRecDcaNegInv->Fill(-sdca_tr); | |
854 | fRecDNeg->Fill(xy); | |
855 | fSignDcaNeg[cas]->Fill(sdca_tr); | |
856 | fSignDcaNegInv[cas]->Fill(-sdca_tr); | |
857 | ||
858 | ||
859 | fDcaSigmaNeg[cas]->Fill(sdca_tr,TMath::Log10(sigmapt)); | |
860 | ||
861 | fPtSigmaNeg[cas]->Fill(TMath::Log10(sigmapt)); | |
862 | } | |
863 | ||
864 | ||
865 | ||
866 | //all particles with positive eta | |
867 | if(tpcP->Eta()>0){ | |
868 | fRecQPtPosEta->Fill(tpcP->Charge()/tpcP->Pt()); | |
869 | fRecPtPosEta->Fill(tpcP->Pt()); | |
870 | fRecPhiPosEta->Fill(TMath::RadToDeg()*tpcP->Phi()); | |
871 | fRecQPtPosEtaVz->Fill(tpcP->Charge()/tpcP->Pt(),tpcP->Zv()); | |
872 | fRecDcaPosEta->Fill(sdca_tr); | |
873 | fRecDPosEta->Fill(xy); | |
874 | } | |
875 | //all particles with negative eta (and eta==0) | |
876 | else{ | |
877 | fRecQPtNegEta->Fill(tpcP->Charge()/tpcP->Pt()); | |
878 | fRecPtNegEta->Fill(tpcP->Pt()); | |
879 | fRecPhiNegEta->Fill(TMath::RadToDeg()*tpcP->Phi()); | |
880 | fRecQPtNegEtaVz->Fill(tpcP->Charge()/tpcP->Pt(),tpcP->Zv()); | |
881 | fRecDcaNegEta->Fill(sdca_tr); | |
882 | fRecDNegEta->Fill(xy); | |
883 | ||
884 | } | |
885 | ||
886 | ||
887 | //spectren detected by TPC sectors | |
888 | //pt cut on 1 GeV/c ?! | |
889 | // if(tpcP->Pt()<1.) continue; | |
890 | fRecPtTpcSector[Int_t(tpcP->Phi()* | |
891 | TMath::RadToDeg()/20)]->Fill(tpcP->Pt()); | |
892 | fRecEtaTpcSector[Int_t(tpcP->Phi()* | |
893 | TMath::RadToDeg()/20)]->Fill(tpcP->Eta()); | |
894 | fSignedDcaTpcSector[Int_t(tpcP->Phi()* | |
895 | TMath::RadToDeg()/20)]->Fill(sdca_tr); | |
896 | fRecQPtTpcSector[Int_t(tpcP->Phi()* | |
897 | TMath::RadToDeg()/20)]->Fill(tpcP->Charge()/tpcP->Pt()); | |
898 | fRecEtaPtTpcSector[Int_t(tpcP->Phi()* | |
899 | TMath::RadToDeg()/20)]->Fill(tpcP->Eta()/tpcP->Pt()); | |
900 | ||
901 | ||
902 | ||
903 | ||
904 | ||
905 | ||
906 | // another track loop | |
907 | for (Int_t iTrack2 = 0; iTrack2 < event->GetNumberOfTracks(); iTrack2++) { | |
908 | ||
909 | if(LeadingTrack==iTrack2) continue; | |
910 | ||
911 | AliVParticle *track2 = event->GetTrack(iTrack2); | |
912 | AliESDtrack* esdtrack2 = dynamic_cast<AliESDtrack*>(track2); | |
913 | if (!track2) { | |
914 | Printf("ERROR: Could not receive track %d", iTrack); | |
915 | continue; | |
916 | } | |
917 | if (!fCuts->AcceptTrack(esdtrack2)) continue; | |
918 | //propagate to dca | |
919 | esdtrack2->PropagateToDCA(event->GetPrimaryVertex(), | |
920 | event->GetMagneticField(), 10000.); | |
921 | ||
922 | fDeltaPhiLeading->Fill((LeadingPhi-esdtrack2->Phi())*TMath::RadToDeg(), | |
923 | LeadingPhi*TMath::RadToDeg() ); | |
924 | ||
925 | ||
926 | ||
927 | }//second track loop | |
928 | }//first track loop | |
929 | ||
930 | ||
931 | ||
932 | ||
933 | // Post output data. | |
934 | // PostData(1, fHistPt); | |
935 | PostData(1, fHists); | |
936 | } | |
937 | ||
938 | ||
939 | ||
940 | ||
941 | ||
942 | //________________________________________________________________________ | |
943 | void AliAnalysisTaskQASym::Terminate(Option_t *) | |
944 | { | |
945 | ||
946 | ||
947 | } | |
948 | ||
949 | ||
950 | ||
951 | ||
952 |