]>
Commit | Line | Data |
---|---|---|
f98ea3f1 | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial pures is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any pure. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | /* $Id$ */ | |
17 | ||
18 | // AliAnalysisTaskPIDflowQA: | |
19 | // QA for pid | |
20 | // | |
21 | //origin: Marek Chojnacki, Marek.Chojnacki@cern.ch | |
22 | //modified: Mikolaj Krzewicki, Mikolaj.Krzewicki@cern.ch | |
23 | ||
2b1eaa10 | 24 | #include <stdio.h> |
25 | ||
f98ea3f1 | 26 | #include "AliAnalysisTaskPIDflowQA.h" |
27 | #include "AliAnalysisManager.h" | |
28 | #include "AliESDEvent.h" | |
f98ea3f1 | 29 | #include "AliStack.h" |
30 | #include "AliMCEvent.h" | |
1a80f9f6 | 31 | #include "TH1F.h" |
f98ea3f1 | 32 | #include "TH2F.h" |
5104aa35 | 33 | #include "TProfile.h" |
f98ea3f1 | 34 | #include "TMath.h" |
f98ea3f1 | 35 | #include "AliVEvent.h" |
f98ea3f1 | 36 | #include "AliPID.h" |
37 | #include "AliCDBManager.h" | |
38 | #include "AliFlowEventCuts.h" | |
cdc20344 | 39 | #include "AliFlowTrackCuts.h" |
2b1eaa10 | 40 | #include "AliVEventHandler.h" |
41 | #include "AliInputEventHandler.h" | |
42 | #include "TTree.h" | |
43 | #include "TFile.h" | |
f98ea3f1 | 44 | |
45 | ClassImp( AliAnalysisTaskPIDflowQA) | |
46 | ||
47 | //________________________________________________________________________ | |
48 | AliAnalysisTaskPIDflowQA:: AliAnalysisTaskPIDflowQA(): | |
49 | AliAnalysisTaskSE("AliAnalysisTaskPIDflowQA"), | |
50 | fESD(NULL), | |
51 | fCuts(NULL), | |
52 | fEventCuts(NULL), | |
53 | fESDpid(NULL), | |
2b1eaa10 | 54 | fUseDebugFile(kFALSE), |
55 | fFile(NULL), | |
f98ea3f1 | 56 | fTPCsignal(NULL), |
1a80f9f6 | 57 | fTPCsignalPi(NULL), |
58 | fTPCsignalK(NULL), | |
59 | fTPCsignalP(NULL), | |
60 | fTPCsignalPimc(NULL), | |
61 | fTPCsignalKmc(NULL), | |
62 | fTPCsignalPmc(NULL), | |
7288f660 | 63 | fTOFtime(NULL), |
64 | fTOFtimeE(NULL), | |
65 | fTOFtimePi(NULL), | |
66 | fTOFtimeK(NULL), | |
67 | fTOFtimeP(NULL), | |
1a80f9f6 | 68 | fTOFbeta(NULL), |
69 | fTOFbetaE(NULL), | |
70 | fTOFbetaPi(NULL), | |
71 | fTOFbetaK(NULL), | |
72 | fTOFbetaP(NULL), | |
73 | fTOFinvbeta(NULL), | |
74 | fTOFinvbetaE(NULL), | |
75 | fTOFinvbetaPi(NULL), | |
76 | fTOFinvbetaK(NULL), | |
77 | fTOFinvbetaP(NULL), | |
9b692328 | 78 | fTOFrawtime(NULL), |
79 | fTOFrawtimeE(NULL), | |
80 | fTOFrawtimePi(NULL), | |
81 | fTOFrawtimeK(NULL), | |
82 | fTOFrawtimeP(NULL), | |
83 | fTOFrawbeta(NULL), | |
84 | fTOFrawbetaE(NULL), | |
85 | fTOFrawbetaPi(NULL), | |
86 | fTOFrawbetaK(NULL), | |
87 | fTOFrawbetaP(NULL), | |
88 | fTOFrawinvbeta(NULL), | |
89 | fTOFrawinvbetaE(NULL), | |
90 | fTOFrawinvbetaPi(NULL), | |
91 | fTOFrawinvbetaK(NULL), | |
92 | fTOFrawinvbetaP(NULL), | |
f98ea3f1 | 93 | fPvsPt(NULL), |
5104aa35 | 94 | fMeanPvsP(NULL), |
cdc20344 | 95 | fTPCvsGlobalMult(NULL), |
96 | fStandardGlobalCuts(NULL), | |
97 | fStandardTPCCuts(NULL), | |
9b692328 | 98 | fCutsTOFbetaElectrons(NULL), |
99 | fCutsTOFbetaPions(NULL), | |
100 | fCutsTOFbetaKaons(NULL), | |
101 | fCutsTOFbetaProtons(NULL), | |
102 | fCutsTOFbetaSimpleElectrons(NULL), | |
103 | fCutsTOFbetaSimplePions(NULL), | |
104 | fCutsTOFbetaSimpleKaons(NULL), | |
105 | fCutsTOFbetaSimpleProtons(NULL), | |
b9cf8f8e | 106 | fCutsTOFbayesianElectrons(NULL), |
107 | fCutsTOFbayesianPions(NULL), | |
108 | fCutsTOFbayesianKaons(NULL), | |
109 | fCutsTOFbayesianProtons(NULL), | |
9b692328 | 110 | fCutsTPCdedxElectrons(NULL), |
111 | fCutsTPCdedxPions(NULL), | |
112 | fCutsTPCdedxKaons(NULL), | |
113 | fCutsTPCdedxProtons(NULL), | |
114 | fCutsTPCpidElectrons(NULL), | |
115 | fCutsTPCpidPions(NULL), | |
116 | fCutsTPCpidKaons(NULL), | |
117 | fCutsTPCpidProtons(NULL), | |
b9cf8f8e | 118 | fCutsTPCbayesianElectrons(NULL), |
119 | fCutsTPCbayesianPions(NULL), | |
120 | fCutsTPCbayesianKaons(NULL), | |
121 | fCutsTPCbayesianProtons(NULL), | |
122 | fCutsMCelectrons(NULL), | |
123 | fCutsMCpions(NULL), | |
124 | fCutsMCkaons(NULL), | |
125 | fCutsMCprotons(NULL), | |
126 | fCutsMCprimaryelectrons(NULL), | |
127 | fCutsMCprimarypions(NULL), | |
128 | fCutsMCprimarykaons(NULL), | |
129 | fCutsMCprimaryprotons(NULL), | |
5104aa35 | 130 | fOutputList(NULL) |
f98ea3f1 | 131 | { |
132 | //def ctor | |
133 | } | |
134 | ||
135 | //________________________________________________________________________ | |
136 | AliAnalysisTaskPIDflowQA:: AliAnalysisTaskPIDflowQA(const char *name): | |
137 | AliAnalysisTaskSE(name), | |
138 | fESD(NULL), | |
139 | fCuts(NULL), | |
140 | fEventCuts(NULL), | |
141 | fESDpid(NULL), | |
2b1eaa10 | 142 | fUseDebugFile(kFALSE), |
143 | fFile(NULL), | |
f98ea3f1 | 144 | fTPCsignal(NULL), |
1a80f9f6 | 145 | fTPCsignalPi(NULL), |
146 | fTPCsignalK(NULL), | |
147 | fTPCsignalP(NULL), | |
148 | fTPCsignalPimc(NULL), | |
149 | fTPCsignalKmc(NULL), | |
150 | fTPCsignalPmc(NULL), | |
7288f660 | 151 | fTOFtime(NULL), |
152 | fTOFtimeE(NULL), | |
153 | fTOFtimePi(NULL), | |
154 | fTOFtimeK(NULL), | |
155 | fTOFtimeP(NULL), | |
1a80f9f6 | 156 | fTOFbeta(NULL), |
157 | fTOFbetaE(NULL), | |
158 | fTOFbetaPi(NULL), | |
159 | fTOFbetaK(NULL), | |
160 | fTOFbetaP(NULL), | |
161 | fTOFinvbeta(NULL), | |
162 | fTOFinvbetaE(NULL), | |
163 | fTOFinvbetaPi(NULL), | |
164 | fTOFinvbetaK(NULL), | |
165 | fTOFinvbetaP(NULL), | |
9b692328 | 166 | fTOFrawtime(NULL), |
167 | fTOFrawtimeE(NULL), | |
168 | fTOFrawtimePi(NULL), | |
169 | fTOFrawtimeK(NULL), | |
170 | fTOFrawtimeP(NULL), | |
171 | fTOFrawbeta(NULL), | |
172 | fTOFrawbetaE(NULL), | |
173 | fTOFrawbetaPi(NULL), | |
174 | fTOFrawbetaK(NULL), | |
175 | fTOFrawbetaP(NULL), | |
176 | fTOFrawinvbeta(NULL), | |
177 | fTOFrawinvbetaE(NULL), | |
178 | fTOFrawinvbetaPi(NULL), | |
179 | fTOFrawinvbetaK(NULL), | |
180 | fTOFrawinvbetaP(NULL), | |
f98ea3f1 | 181 | fPvsPt(NULL), |
5104aa35 | 182 | fMeanPvsP(NULL), |
cdc20344 | 183 | fTPCvsGlobalMult(NULL), |
184 | fStandardGlobalCuts(NULL), | |
185 | fStandardTPCCuts(NULL), | |
9b692328 | 186 | fCutsTOFbetaElectrons(NULL), |
187 | fCutsTOFbetaPions(NULL), | |
188 | fCutsTOFbetaKaons(NULL), | |
189 | fCutsTOFbetaProtons(NULL), | |
190 | fCutsTOFbetaSimpleElectrons(NULL), | |
191 | fCutsTOFbetaSimplePions(NULL), | |
192 | fCutsTOFbetaSimpleKaons(NULL), | |
193 | fCutsTOFbetaSimpleProtons(NULL), | |
b9cf8f8e | 194 | fCutsTOFbayesianElectrons(NULL), |
195 | fCutsTOFbayesianPions(NULL), | |
196 | fCutsTOFbayesianKaons(NULL), | |
197 | fCutsTOFbayesianProtons(NULL), | |
9b692328 | 198 | fCutsTPCdedxElectrons(NULL), |
199 | fCutsTPCdedxPions(NULL), | |
200 | fCutsTPCdedxKaons(NULL), | |
201 | fCutsTPCdedxProtons(NULL), | |
202 | fCutsTPCpidElectrons(NULL), | |
203 | fCutsTPCpidPions(NULL), | |
204 | fCutsTPCpidKaons(NULL), | |
205 | fCutsTPCpidProtons(NULL), | |
b9cf8f8e | 206 | fCutsTPCbayesianElectrons(NULL), |
207 | fCutsTPCbayesianPions(NULL), | |
208 | fCutsTPCbayesianKaons(NULL), | |
209 | fCutsTPCbayesianProtons(NULL), | |
210 | fCutsMCelectrons(NULL), | |
211 | fCutsMCpions(NULL), | |
212 | fCutsMCkaons(NULL), | |
213 | fCutsMCprotons(NULL), | |
214 | fCutsMCprimaryelectrons(NULL), | |
215 | fCutsMCprimarypions(NULL), | |
216 | fCutsMCprimarykaons(NULL), | |
217 | fCutsMCprimaryprotons(NULL), | |
5104aa35 | 218 | fOutputList(NULL) |
f98ea3f1 | 219 | { |
220 | //Constructor | |
221 | fESDpid=new AliESDpid(); | |
222 | ||
223 | //old | |
224 | fESDpid->GetTPCResponse().SetBetheBlochParameters(0.0283086, | |
225 | 2.63394e+01, | |
226 | 5.04114e-11, | |
227 | 2.12543e+00, | |
228 | 4.88663e+00 ); | |
229 | //new | |
230 | //fESDpid->GetTPCResponse().SetBetheBlochParameters(1.28949/50., | |
231 | // 2.74095e+01, | |
232 | // TMath::Exp(-3.21763e+01), | |
233 | // 2.44026, | |
234 | // 6.58800); | |
235 | ||
236 | DefineOutput(1, TList::Class()); | |
237 | } | |
238 | ||
239 | //________________________________________________________________________ | |
240 | void AliAnalysisTaskPIDflowQA::UserCreateOutputObjects() | |
241 | { | |
242 | //UserCreateOutputObject | |
5104aa35 | 243 | if (fOutputList) fOutputList->Delete(); |
244 | delete fOutputList; | |
245 | fOutputList=new TList(); | |
ef7cafb6 | 246 | fOutputList->SetOwner(kTRUE); |
f98ea3f1 | 247 | |
248 | const Int_t ndec=2; | |
249 | Int_t startvalue=-1; | |
250 | const Int_t npredec=50; | |
251 | Double_t tabx[ndec*npredec+1]; | |
252 | for (Int_t i=0; i<ndec; i++) | |
253 | { | |
254 | for (Int_t j=0; j<npredec; j++) | |
255 | { | |
256 | tabx[npredec*i+j]=TMath::Power(10,((Double_t)i)+((Double_t)startvalue)+((Double_t)j)/((Double_t)npredec)); | |
257 | } | |
258 | } | |
259 | tabx[ndec*npredec]=TMath::Power(10,ndec+startvalue); | |
260 | ||
f98ea3f1 | 261 | Int_t kPtBins=60; |
262 | Double_t binsPtDummy[kPtBins+1]; | |
263 | binsPtDummy[0]=0.0; | |
264 | for(int i=1; i<=kPtBins+1; i++) | |
265 | { | |
266 | if(binsPtDummy[i-1]+0.05<1.01) | |
267 | binsPtDummy[i]=binsPtDummy[i-1]+0.05; | |
268 | else | |
269 | binsPtDummy[i]=binsPtDummy[i-1]+0.1; | |
270 | } | |
271 | ||
272 | Int_t kPBins=60; | |
273 | Double_t binsPDummy[kPBins+1]; | |
274 | binsPDummy[0]=0.0; | |
275 | for(int i=1; i<=kPBins+1; i++) | |
276 | { | |
277 | if(binsPDummy[i-1]+0.05<1.01) | |
278 | binsPDummy[i]=binsPDummy[i-1]+0.05; | |
279 | else | |
280 | binsPDummy[i]=binsPDummy[i-1]+0.1; | |
281 | } | |
282 | ||
1a80f9f6 | 283 | fTPCsignal=new TH2F("fTPCsignal",";p [GeV/c];dEdx",kPBins,binsPDummy,500,0,500); |
284 | fOutputList->Add(fTPCsignal); | |
1a80f9f6 | 285 | fTPCsignalPi=new TH2F("fTPCsignalPi",";p [GeV/c];signal",kPBins,binsPDummy,300,-2,2);//TPC PID signal as function of p for pi+ |
286 | fTPCsignalK=new TH2F("fTPCsignalK",";p [GeV/c];signal",kPBins,binsPDummy,300,-2,2);//TPC PID signal as function of p for K+ | |
287 | fTPCsignalP=new TH2F("fTPCsignalP",";p [GeV/c];signal",kPBins,binsPDummy,300,-2,2);//TPC PID signal as function of p for p | |
288 | fOutputList->Add(fTPCsignalPi); | |
289 | fOutputList->Add(fTPCsignalK); | |
290 | fOutputList->Add(fTPCsignalP); | |
1a80f9f6 | 291 | |
f21bdf48 | 292 | fTOFtime=new TH2F("fTOFtime",";p[GeV/c];#time",kPBins,binsPDummy,1000, 12000, 80000);// |
293 | fOutputList->Add(fTOFtime); | |
294 | fTOFtimeE=new TH2F("fTOFtimeE",";p [GeV/c];#time-#time_{#pi}",kPBins,binsPDummy,500, -8000, 8000);// | |
295 | fTOFtimePi=new TH2F("fTOFtimePi",";p [GeV/c];#time-#time_{#pi}",kPBins,binsPDummy,500, -8000, 8000);// | |
296 | fTOFtimeK=new TH2F("fTOFtimeK",";p [GeV/c];#time-#time_{K}",kPBins,binsPDummy,500, -8000, 8000);// | |
297 | fTOFtimeP=new TH2F("fTOFtimeP",";p [GeV/c];#time-#time_{p}",kPBins,binsPDummy,500, -8000, 8000);// | |
9b692328 | 298 | fOutputList->Add(fTOFtimeE); |
299 | fOutputList->Add(fTOFtimePi); | |
300 | fOutputList->Add(fTOFtimeK); | |
301 | fOutputList->Add(fTOFtimeP); | |
7288f660 | 302 | |
1a80f9f6 | 303 | fTOFbeta=new TH2F("fTOFbeta",";p[GeV/c];#beta",kPBins,binsPDummy,1000, 0.4, 1.1);// |
304 | fOutputList->Add(fTOFbeta); | |
305 | fTOFbetaE=new TH2F("fTOFbetaE",";p [GeV/c];#beta-#beta_{#pi}",kPBins,binsPDummy,500, -0.25, 0.25);// | |
306 | fTOFbetaPi=new TH2F("fTOFbetaPi",";p [GeV/c];#beta-#beta_{#pi}",kPBins,binsPDummy,500, -0.25, 0.25);// | |
307 | fTOFbetaK=new TH2F("fTOFbetaK",";p [GeV/c];#beta-#beta_{K}",kPBins,binsPDummy,500, -0.25, 0.25);// | |
308 | fTOFbetaP=new TH2F("fTOFbetaP",";p [GeV/c];#beta-#beta_{p}",kPBins,binsPDummy,500, -0.25, 0.25);// | |
309 | fOutputList->Add(fTOFbetaE); | |
310 | fOutputList->Add(fTOFbetaPi); | |
311 | fOutputList->Add(fTOFbetaK); | |
312 | fOutputList->Add(fTOFbetaP); | |
313 | ||
314 | fTOFinvbeta=new TH2F("fTOFinvbeta",";p[GeV/c];1/#beta",kPBins,binsPDummy,1000, 0.90, 2.5);// | |
315 | fOutputList->Add(fTOFinvbeta); | |
316 | fTOFinvbetaE=new TH2F("fTOFinvbetaE",";p [GeV/c];1/#beta-1/#beta_{#pi}",kPBins,binsPDummy,600, -0.3, 0.3);// | |
317 | fTOFinvbetaPi=new TH2F("fTOFinvbetaPi",";p [GeV/c];1/#beta-1/#beta_{#pi}",kPBins,binsPDummy,600, -0.3, 0.3);// | |
318 | fTOFinvbetaK=new TH2F("fTOFinvbetaK",";p [GeV/c];1/#beta-1/#beta_{K}",kPBins,binsPDummy,600, -0.3, 0.3);// | |
319 | fTOFinvbetaP=new TH2F("fTOFinvbetaP",";p [GeV/c];1/#beta-1/#beta_{p}",kPBins,binsPDummy,600, -0.3, 0.3);// | |
320 | fOutputList->Add(fTOFinvbetaE); | |
321 | fOutputList->Add(fTOFinvbetaPi); | |
322 | fOutputList->Add(fTOFinvbetaK); | |
323 | fOutputList->Add(fTOFinvbetaP); | |
324 | ||
9b692328 | 325 | fTOFrawtime=new TH2F("fTOFrawtime",";p[GeV/c];#time",kPBins,binsPDummy,1000, 12000, 80000);// |
326 | fOutputList->Add(fTOFrawtime); | |
327 | fTOFrawtimeE=new TH2F("fTOFrawtimeE",";p [GeV/c];#time-#time_{#pi}",kPBins,binsPDummy,500, -8000, 8000);// | |
328 | fTOFrawtimePi=new TH2F("fTOFrawtimePi",";p [GeV/c];#time-#time_{#pi}",kPBins,binsPDummy,500, -8000, 8000);// | |
329 | fTOFrawtimeK=new TH2F("fTOFrawtimeK",";p [GeV/c];#time-#time_{K}",kPBins,binsPDummy,500, -8000, 8000);// | |
330 | fTOFrawtimeP=new TH2F("fTOFrawtimeP",";p [GeV/c];#time-#time_{p}",kPBins,binsPDummy,500, -8000, 8000);// | |
331 | fOutputList->Add(fTOFrawtimeE); | |
332 | fOutputList->Add(fTOFrawtimePi); | |
333 | fOutputList->Add(fTOFrawtimeK); | |
334 | fOutputList->Add(fTOFrawtimeP); | |
335 | ||
336 | fTOFrawbeta=new TH2F("fTOFrawbeta",";p[GeV/c];#beta",kPBins,binsPDummy,1000, 0.4, 1.1);// | |
337 | fOutputList->Add(fTOFrawbeta); | |
338 | fTOFrawbetaE=new TH2F("fTOFrawbetaE",";p [GeV/c];#beta-#beta_{#pi}",kPBins,binsPDummy,500, -0.25, 0.25);// | |
339 | fTOFrawbetaPi=new TH2F("fTOFrawbetaPi",";p [GeV/c];#beta-#beta_{#pi}",kPBins,binsPDummy,500, -0.25, 0.25);// | |
340 | fTOFrawbetaK=new TH2F("fTOFrawbetaK",";p [GeV/c];#beta-#beta_{K}",kPBins,binsPDummy,500, -0.25, 0.25);// | |
341 | fTOFrawbetaP=new TH2F("fTOFrawbetaP",";p [GeV/c];#beta-#beta_{p}",kPBins,binsPDummy,500, -0.25, 0.25);// | |
342 | fOutputList->Add(fTOFrawbetaE); | |
343 | fOutputList->Add(fTOFrawbetaPi); | |
344 | fOutputList->Add(fTOFrawbetaK); | |
345 | fOutputList->Add(fTOFrawbetaP); | |
346 | ||
347 | fTOFrawinvbeta=new TH2F("fTOFrawinvbeta",";p[GeV/c];1/#beta",kPBins,binsPDummy,1000, 0.90, 2.5);// | |
348 | fOutputList->Add(fTOFrawinvbeta); | |
349 | fTOFrawinvbetaE=new TH2F("fTOFrawinvbetaE",";p [GeV/c];1/#beta-1/#beta_{#pi}",kPBins,binsPDummy,600, -0.3, 0.3);// | |
350 | fTOFrawinvbetaPi=new TH2F("fTOFrawinvbetaPi",";p [GeV/c];1/#beta-1/#beta_{#pi}",kPBins,binsPDummy,600, -0.3, 0.3);// | |
351 | fTOFrawinvbetaK=new TH2F("fTOFrawinvbetaK",";p [GeV/c];1/#beta-1/#beta_{K}",kPBins,binsPDummy,600, -0.3, 0.3);// | |
352 | fTOFrawinvbetaP=new TH2F("fTOFrawinvbetaP",";p [GeV/c];1/#beta-1/#beta_{p}",kPBins,binsPDummy,600, -0.3, 0.3);// | |
353 | fOutputList->Add(fTOFrawinvbetaE); | |
354 | fOutputList->Add(fTOFrawinvbetaPi); | |
355 | fOutputList->Add(fTOFrawinvbetaK); | |
356 | fOutputList->Add(fTOFrawinvbetaP); | |
f98ea3f1 | 357 | |
a0241c3a | 358 | fPvsPt=new TH2F("fPvsPt","p vs p_{t};p [GeV/c];p_{t} [GeV/c]",kPBins,binsPDummy,kPtBins,binsPtDummy); |
5104aa35 | 359 | fOutputList->Add(fPvsPt); |
f98ea3f1 | 360 | |
a0241c3a | 361 | fMeanPvsP = new TProfile("fMeanPvsP","Mean P vs P;p [Gev/c];<p> [GeV/c]",kPBins,binsPDummy); |
5104aa35 | 362 | fOutputList->Add(fMeanPvsP); |
a0241c3a | 363 | |
cdc20344 | 364 | fTPCvsGlobalMult = new TH2F("fTPCvsGlobalMult","TPC only vs Global track multiplicity;global;TPC only",500,0,2500,500,0,3500); |
365 | fOutputList->Add(fTPCvsGlobalMult); | |
366 | ||
367 | fStandardGlobalCuts = AliFlowTrackCuts::GetStandardGlobalTrackCuts2010(); | |
1a80f9f6 | 368 | fStandardTPCCuts = AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts2010(); |
369 | ||
9b692328 | 370 | fCutsTOFbetaElectrons = new AliFlowTrackCuts("TOFbeta e"); |
371 | fCutsTOFbetaElectrons->SetPID(AliPID::kElectron, AliFlowTrackCuts::kTOFbeta); | |
372 | fCutsTOFbetaElectrons->SetRequireStrictTOFTPCagreement(); | |
373 | fCutsTOFbetaElectrons->SetQA(); | |
374 | fCutsTOFbetaPions = new AliFlowTrackCuts("TOFbeta pi"); | |
375 | fCutsTOFbetaPions->SetPID(AliPID::kPion, AliFlowTrackCuts::kTOFbeta); | |
376 | fCutsTOFbetaPions->SetRequireStrictTOFTPCagreement(); | |
377 | fCutsTOFbetaPions->SetQA(); | |
378 | fCutsTOFbetaKaons = new AliFlowTrackCuts("TOFbeta K"); | |
379 | fCutsTOFbetaKaons->SetPID(AliPID::kKaon, AliFlowTrackCuts::kTOFbeta); | |
380 | fCutsTOFbetaKaons->SetRequireStrictTOFTPCagreement(); | |
381 | fCutsTOFbetaKaons->SetQA(); | |
382 | fCutsTOFbetaProtons = new AliFlowTrackCuts("TOFbeta p"); | |
383 | fCutsTOFbetaProtons->SetPID(AliPID::kProton, AliFlowTrackCuts::kTOFbeta); | |
384 | fCutsTOFbetaProtons->SetRequireStrictTOFTPCagreement(); | |
385 | fCutsTOFbetaProtons->SetQA(); | |
386 | ||
387 | fCutsTOFbetaSimpleElectrons = new AliFlowTrackCuts("TOFbetaSimple e"); | |
388 | fCutsTOFbetaSimpleElectrons->SetPID(AliPID::kElectron, AliFlowTrackCuts::kTOFbetaSimple); | |
389 | fCutsTOFbetaSimpleElectrons->SetRequireStrictTOFTPCagreement(); | |
390 | fCutsTOFbetaSimpleElectrons->SetQA(); | |
391 | fCutsTOFbetaSimplePions = new AliFlowTrackCuts("TOFbetaSimple pi"); | |
392 | fCutsTOFbetaSimplePions->SetPID(AliPID::kPion, AliFlowTrackCuts::kTOFbetaSimple); | |
393 | fCutsTOFbetaSimplePions->SetRequireStrictTOFTPCagreement(); | |
394 | fCutsTOFbetaSimplePions->SetQA(); | |
395 | fCutsTOFbetaSimpleKaons = new AliFlowTrackCuts("TOFbetaSimple K"); | |
396 | fCutsTOFbetaSimpleKaons->SetPID(AliPID::kKaon, AliFlowTrackCuts::kTOFbetaSimple); | |
397 | fCutsTOFbetaSimpleKaons->SetRequireStrictTOFTPCagreement(); | |
398 | fCutsTOFbetaSimpleKaons->SetQA(); | |
399 | fCutsTOFbetaSimpleProtons = new AliFlowTrackCuts("TOFbetaSimple p"); | |
400 | fCutsTOFbetaSimpleProtons->SetPID(AliPID::kProton, AliFlowTrackCuts::kTOFbetaSimple); | |
401 | fCutsTOFbetaSimpleProtons->SetRequireStrictTOFTPCagreement(); | |
402 | fCutsTOFbetaSimpleProtons->SetQA(); | |
403 | ||
b9cf8f8e | 404 | fCutsTOFbayesianElectrons = new AliFlowTrackCuts("TOFbayesian e"); |
405 | fCutsTOFbayesianElectrons->SetPID(AliPID::kElectron, AliFlowTrackCuts::kTOFbayesian); | |
406 | fCutsTOFbayesianElectrons->SetRequireStrictTOFTPCagreement(); | |
407 | fCutsTOFbayesianElectrons->SetQA(); | |
408 | fCutsTOFbayesianPions = new AliFlowTrackCuts("TOFbayesian pi"); | |
409 | fCutsTOFbayesianPions->SetPID(AliPID::kPion, AliFlowTrackCuts::kTOFbayesian); | |
410 | fCutsTOFbayesianPions->SetRequireStrictTOFTPCagreement(); | |
411 | fCutsTOFbayesianPions->SetQA(); | |
412 | fCutsTOFbayesianKaons = new AliFlowTrackCuts("TOFbayesian K"); | |
413 | fCutsTOFbayesianKaons->SetPID(AliPID::kKaon, AliFlowTrackCuts::kTOFbayesian); | |
414 | fCutsTOFbayesianKaons->SetRequireStrictTOFTPCagreement(); | |
415 | fCutsTOFbayesianKaons->SetQA(); | |
416 | fCutsTOFbayesianProtons = new AliFlowTrackCuts("TOFbayesian p"); | |
417 | fCutsTOFbayesianProtons->SetPID(AliPID::kProton, AliFlowTrackCuts::kTOFbayesian); | |
418 | fCutsTOFbayesianProtons->SetRequireStrictTOFTPCagreement(); | |
419 | fCutsTOFbayesianProtons->SetQA(); | |
420 | ||
9b692328 | 421 | fCutsTPCdedxElectrons = new AliFlowTrackCuts("TPCdedx e"); |
422 | fCutsTPCdedxElectrons->SetPID(AliPID::kElectron, AliFlowTrackCuts::kTPCdedx); | |
423 | fCutsTPCdedxElectrons->SetQA(); | |
b9cf8f8e | 424 | fCutsTPCdedxPions = new AliFlowTrackCuts("TPCdedx pi"); |
9b692328 | 425 | fCutsTPCdedxPions->SetPID(AliPID::kPion, AliFlowTrackCuts::kTPCdedx); |
426 | fCutsTPCdedxPions->SetQA(); | |
427 | fCutsTPCdedxKaons = new AliFlowTrackCuts("TPCdedx K"); | |
428 | fCutsTPCdedxKaons->SetPID(AliPID::kKaon, AliFlowTrackCuts::kTPCdedx); | |
429 | fCutsTPCdedxKaons->SetQA(); | |
430 | fCutsTPCdedxProtons = new AliFlowTrackCuts("TPCdedx p"); | |
431 | fCutsTPCdedxProtons->SetPID(AliPID::kProton, AliFlowTrackCuts::kTPCdedx); | |
432 | fCutsTPCdedxProtons->SetQA(); | |
433 | ||
434 | fCutsTPCpidElectrons = new AliFlowTrackCuts("TPCpid e"); | |
435 | fCutsTPCpidElectrons->SetPID(AliPID::kElectron, AliFlowTrackCuts::kTPCpid); | |
436 | fCutsTPCpidElectrons->SetQA(); | |
b9cf8f8e | 437 | fCutsTPCpidPions = new AliFlowTrackCuts("TPCpid pi"); |
9b692328 | 438 | fCutsTPCpidPions->SetPID(AliPID::kPion, AliFlowTrackCuts::kTPCpid); |
439 | fCutsTPCpidPions->SetQA(); | |
440 | fCutsTPCpidKaons = new AliFlowTrackCuts("TPCpid K"); | |
441 | fCutsTPCpidKaons->SetPID(AliPID::kKaon, AliFlowTrackCuts::kTPCpid); | |
442 | fCutsTPCpidKaons->SetQA(); | |
443 | fCutsTPCpidProtons = new AliFlowTrackCuts("TPCpid p"); | |
444 | fCutsTPCpidProtons->SetPID(AliPID::kProton, AliFlowTrackCuts::kTPCpid); | |
445 | fCutsTPCpidProtons->SetQA(); | |
cdc20344 | 446 | |
b9cf8f8e | 447 | fCutsTPCbayesianElectrons = new AliFlowTrackCuts("TPCbayesian e"); |
448 | fCutsTPCbayesianElectrons->SetPID(AliPID::kElectron, AliFlowTrackCuts::kTPCbayesian); | |
449 | fCutsTPCbayesianElectrons->SetQA(); | |
450 | fCutsTPCbayesianPions = new AliFlowTrackCuts("TPCbayesian pi"); | |
451 | fCutsTPCbayesianPions->SetPID(AliPID::kPion, AliFlowTrackCuts::kTPCbayesian); | |
452 | fCutsTPCbayesianPions->SetQA(); | |
453 | fCutsTPCbayesianKaons = new AliFlowTrackCuts("TPCbayesian K"); | |
454 | fCutsTPCbayesianKaons->SetPID(AliPID::kKaon, AliFlowTrackCuts::kTPCbayesian); | |
455 | fCutsTPCbayesianKaons->SetQA(); | |
456 | fCutsTPCbayesianProtons = new AliFlowTrackCuts("TPCbayesian p"); | |
457 | fCutsTPCbayesianProtons->SetPID(AliPID::kProton, AliFlowTrackCuts::kTPCbayesian); | |
458 | fCutsTPCbayesianProtons->SetQA(); | |
459 | ||
460 | fCutsMCelectrons=new AliFlowTrackCuts("MC e"); | |
461 | fCutsMCelectrons->SetMCPID(11); | |
462 | fCutsMCelectrons->SetIgnoreSignInMCPID(); | |
463 | fCutsMCelectrons->SetQA(); | |
464 | fCutsMCpions=new AliFlowTrackCuts("MC pi"); | |
465 | fCutsMCpions->SetMCPID(211); | |
466 | fCutsMCpions->SetIgnoreSignInMCPID(); | |
467 | fCutsMCpions->SetQA(); | |
468 | fCutsMCkaons=new AliFlowTrackCuts("MC K"); | |
469 | fCutsMCpions->SetMCPID(321); | |
470 | fCutsMCpions->SetIgnoreSignInMCPID(); | |
471 | fCutsMCpions->SetQA(); | |
472 | fCutsMCprotons=new AliFlowTrackCuts("MC p"); | |
473 | fCutsMCpions->SetMCPID(2212); | |
474 | fCutsMCpions->SetIgnoreSignInMCPID(); | |
475 | fCutsMCpions->SetQA(); | |
476 | ||
477 | fCutsMCprimaryelectrons=new AliFlowTrackCuts("MCprimary e"); | |
478 | fCutsMCprimaryelectrons->SetMCPID(11); | |
479 | fCutsMCprimaryelectrons->SetIgnoreSignInMCPID(); | |
480 | fCutsMCprimaryelectrons->SetMCisPrimary(); | |
481 | fCutsMCprimaryelectrons->SetQA(); | |
482 | fCutsMCprimarypions=new AliFlowTrackCuts("MCprimary pi"); | |
483 | fCutsMCprimarypions->SetMCPID(211); | |
484 | fCutsMCprimarypions->SetIgnoreSignInMCPID(); | |
485 | fCutsMCprimarypions->SetMCisPrimary(); | |
486 | fCutsMCprimarypions->SetQA(); | |
487 | fCutsMCprimarykaons=new AliFlowTrackCuts("MCprimary K"); | |
488 | fCutsMCprimarypions->SetMCPID(321); | |
489 | fCutsMCprimarypions->SetIgnoreSignInMCPID(); | |
490 | fCutsMCprimarypions->SetMCisPrimary(); | |
491 | fCutsMCprimarypions->SetQA(); | |
492 | fCutsMCprimaryprotons=new AliFlowTrackCuts("MCprimary p"); | |
493 | fCutsMCprimarypions->SetMCPID(2212); | |
494 | fCutsMCprimarypions->SetIgnoreSignInMCPID(); | |
495 | fCutsMCprimarypions->SetMCisPrimary(); | |
496 | fCutsMCprimarypions->SetQA(); | |
497 | ||
a0241c3a | 498 | //fOutputList->Add(fESDpid); |
5104aa35 | 499 | |
9b692328 | 500 | fOutputList->Add(fCutsTPCdedxElectrons->GetQA()); |
501 | fOutputList->Add(fCutsTPCdedxPions->GetQA()); | |
502 | fOutputList->Add(fCutsTPCdedxKaons->GetQA()); | |
503 | fOutputList->Add(fCutsTPCdedxProtons->GetQA()); | |
504 | fOutputList->Add(fCutsTPCpidElectrons->GetQA()); | |
505 | fOutputList->Add(fCutsTPCpidPions->GetQA()); | |
506 | fOutputList->Add(fCutsTPCpidKaons->GetQA()); | |
507 | fOutputList->Add(fCutsTPCpidProtons->GetQA()); | |
b9cf8f8e | 508 | fOutputList->Add(fCutsTPCbayesianElectrons->GetQA()); |
509 | fOutputList->Add(fCutsTPCbayesianPions->GetQA()); | |
510 | fOutputList->Add(fCutsTPCbayesianKaons->GetQA()); | |
511 | fOutputList->Add(fCutsTPCbayesianProtons->GetQA()); | |
9b692328 | 512 | fOutputList->Add(fCutsTOFbetaElectrons->GetQA()); |
513 | fOutputList->Add(fCutsTOFbetaPions->GetQA()); | |
514 | fOutputList->Add(fCutsTOFbetaKaons->GetQA()); | |
515 | fOutputList->Add(fCutsTOFbetaProtons->GetQA()); | |
516 | fOutputList->Add(fCutsTOFbetaSimpleElectrons->GetQA()); | |
517 | fOutputList->Add(fCutsTOFbetaSimplePions->GetQA()); | |
518 | fOutputList->Add(fCutsTOFbetaSimpleKaons->GetQA()); | |
519 | fOutputList->Add(fCutsTOFbetaSimpleProtons->GetQA()); | |
b9cf8f8e | 520 | fOutputList->Add(fCutsTOFbayesianElectrons->GetQA()); |
521 | fOutputList->Add(fCutsTOFbayesianPions->GetQA()); | |
522 | fOutputList->Add(fCutsTOFbayesianKaons->GetQA()); | |
523 | fOutputList->Add(fCutsTOFbayesianProtons->GetQA()); | |
524 | fOutputList->Add(fCutsMCelectrons->GetQA()); | |
525 | fOutputList->Add(fCutsMCpions->GetQA()); | |
526 | fOutputList->Add(fCutsMCkaons->GetQA()); | |
527 | fOutputList->Add(fCutsMCprotons->GetQA()); | |
528 | fOutputList->Add(fCutsMCprimaryelectrons->GetQA()); | |
529 | fOutputList->Add(fCutsMCprimarypions->GetQA()); | |
530 | fOutputList->Add(fCutsMCprimarykaons->GetQA()); | |
531 | fOutputList->Add(fCutsMCprimaryprotons->GetQA()); | |
1a80f9f6 | 532 | |
2b1eaa10 | 533 | if (fUseDebugFile) fFile = fopen("debug.txt","w"); |
534 | ||
5104aa35 | 535 | PostData(1, fOutputList); |
f98ea3f1 | 536 | } |
537 | ||
538 | //________________________________________________________________________ | |
539 | void AliAnalysisTaskPIDflowQA::UserExec(Option_t *) | |
540 | { | |
541 | fESD = dynamic_cast<AliESDEvent*> (InputEvent()); | |
542 | if (!fESD) return; | |
543 | ||
cb070a12 | 544 | //do the calibration bit |
545 | fESDpid->SetTOFResponse(fESD,AliESDpid::kTOF_T0); // to use T0-TOF | |
546 | fESDpid->MakePID(fESD,kFALSE); | |
547 | ||
f98ea3f1 | 548 | if(!fCuts || !fEventCuts) |
549 | { | |
550 | Printf("No CUTS Defined.........\n"); | |
5104aa35 | 551 | PostData(1, fOutputList); |
f98ea3f1 | 552 | return; |
553 | } | |
554 | ||
555 | if (!(fEventCuts->IsSelected(fESD))) | |
556 | { | |
557 | return; | |
558 | } | |
559 | ||
9b692328 | 560 | AliStack* stack=NULL; |
561 | AliMCEvent* mcEvent = MCEvent(); | |
562 | if (mcEvent) stack = mcEvent->Stack(); | |
563 | if (mcEvent) Printf("MC particles: %d", mcEvent->GetNumberOfTracks()); | |
f98ea3f1 | 564 | |
565 | Printf("There are %d tracks in this event", fESD->GetNumberOfTracks()); | |
566 | Int_t nTracks=fESD->GetNumberOfTracks(); | |
567 | ||
568 | AliESDtrack *trackESD=0; | |
569 | ||
9b692328 | 570 | fCuts->SetEvent(fESD,mcEvent); |
571 | fCutsTPCdedxElectrons->SetEvent(fESD,mcEvent); | |
572 | fCutsTPCdedxPions->SetEvent(fESD,mcEvent); | |
573 | fCutsTPCdedxKaons->SetEvent(fESD,mcEvent); | |
574 | fCutsTPCdedxProtons->SetEvent(fESD,mcEvent); | |
575 | fCutsTPCpidElectrons->SetEvent(fESD,mcEvent); | |
576 | fCutsTPCpidPions->SetEvent(fESD,mcEvent); | |
577 | fCutsTPCpidKaons->SetEvent(fESD,mcEvent); | |
578 | fCutsTPCpidProtons->SetEvent(fESD,mcEvent); | |
b9cf8f8e | 579 | fCutsTPCbayesianElectrons->SetEvent(fESD,mcEvent); |
580 | fCutsTPCbayesianPions->SetEvent(fESD,mcEvent); | |
581 | fCutsTPCbayesianKaons->SetEvent(fESD,mcEvent); | |
582 | fCutsTPCbayesianProtons->SetEvent(fESD,mcEvent); | |
9b692328 | 583 | fCutsTOFbetaElectrons->SetEvent(fESD,mcEvent); |
584 | fCutsTOFbetaPions->SetEvent(fESD,mcEvent); | |
585 | fCutsTOFbetaKaons->SetEvent(fESD,mcEvent); | |
586 | fCutsTOFbetaProtons->SetEvent(fESD,mcEvent); | |
587 | fCutsTOFbetaSimpleElectrons->SetEvent(fESD,mcEvent); | |
588 | fCutsTOFbetaSimplePions->SetEvent(fESD,mcEvent); | |
589 | fCutsTOFbetaSimpleKaons->SetEvent(fESD,mcEvent); | |
590 | fCutsTOFbetaSimpleProtons->SetEvent(fESD,mcEvent); | |
b9cf8f8e | 591 | fCutsTOFbayesianElectrons->SetEvent(fESD,mcEvent); |
592 | fCutsTOFbayesianPions->SetEvent(fESD,mcEvent); | |
593 | fCutsTOFbayesianKaons->SetEvent(fESD,mcEvent); | |
594 | fCutsTOFbayesianProtons->SetEvent(fESD,mcEvent); | |
595 | fCutsMCelectrons->SetEvent(fESD,mcEvent); | |
596 | fCutsMCpions->SetEvent(fESD,mcEvent); | |
597 | fCutsMCkaons->SetEvent(fESD,mcEvent); | |
598 | fCutsMCprotons->SetEvent(fESD,mcEvent); | |
599 | fCutsMCprimaryelectrons->SetEvent(fESD,mcEvent); | |
600 | fCutsMCprimarypions->SetEvent(fESD,mcEvent); | |
601 | fCutsMCprimarykaons->SetEvent(fESD,mcEvent); | |
602 | fCutsMCprimaryprotons->SetEvent(fESD,mcEvent); | |
499fe731 | 603 | |
f98ea3f1 | 604 | for(int tr1=0; tr1<nTracks; tr1++) |
605 | { | |
606 | trackESD=fESD->GetTrack(tr1); | |
607 | if (!trackESD) continue; | |
608 | ||
1a80f9f6 | 609 | Double_t p=trackESD->GetP(); |
610 | Double_t pt=trackESD->Pt(); | |
611 | ||
2b1eaa10 | 612 | if(!(fCuts->IsSelected(trackESD))) continue; |
f98ea3f1 | 613 | |
614 | Int_t label=-1; | |
9b692328 | 615 | if(mcEvent) label=trackESD->GetLabel(); |
f98ea3f1 | 616 | |
617 | Int_t pdgcode=0; | |
9b692328 | 618 | if(stack) |
f98ea3f1 | 619 | { |
620 | TParticle* particle2 = stack->Particle(TMath::Abs(label)); | |
621 | pdgcode=particle2->GetPdgCode(); | |
622 | } | |
623 | ||
f98ea3f1 | 624 | fPvsPt->Fill(p,pt); |
5104aa35 | 625 | fMeanPvsP->Fill(p,p); |
f98ea3f1 | 626 | |
f98ea3f1 | 627 | pidTPC(trackESD,pdgcode); |
628 | pidTOF(trackESD,pdgcode); | |
629 | } | |
630 | ||
b9cf8f8e | 631 | for (Int_t imc=0; imc<(mcEvent!=NULL)?mcEvent->GetNumberOfTracks():0;imc++) |
632 | { | |
633 | fCutsMCelectrons->IsSelected(mcEvent->GetTrack(imc)); | |
634 | fCutsMCpions->IsSelected(mcEvent->GetTrack(imc)); | |
635 | fCutsMCkaons->IsSelected(mcEvent->GetTrack(imc)); | |
636 | fCutsMCprotons->IsSelected(mcEvent->GetTrack(imc)); | |
637 | fCutsMCprimaryelectrons->IsSelected(mcEvent->GetTrack(imc)); | |
638 | fCutsMCprimarypions->IsSelected(mcEvent->GetTrack(imc)); | |
639 | fCutsMCprimarykaons->IsSelected(mcEvent->GetTrack(imc)); | |
640 | fCutsMCprimaryprotons->IsSelected(mcEvent->GetTrack(imc)); | |
641 | } | |
642 | ||
cdc20344 | 643 | //check the correlation between the global and TPConly number of tracks |
644 | fStandardGlobalCuts->SetEvent(fESD); | |
645 | fStandardTPCCuts->SetEvent(fESD); | |
2b1eaa10 | 646 | Int_t multGlobal = fStandardGlobalCuts->Count(); |
647 | Int_t multTPC = fStandardTPCCuts->Count(); | |
648 | fTPCvsGlobalMult->Fill(multGlobal,multTPC); | |
cdc20344 | 649 | |
2b1eaa10 | 650 | if (fFile) |
651 | { | |
652 | const AliESDVertex* pvtx = fESD->GetPrimaryVertex(); | |
653 | const AliESDVertex* tpcvtx = fESD->GetPrimaryVertexTPC(); | |
654 | const AliESDVertex* spdvtx = fESD->GetPrimaryVertexSPD(); | |
655 | AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); | |
656 | AliVEventHandler* handler = mgr->GetInputEventHandler(); | |
657 | TTree* tree = handler->GetTree(); | |
658 | TFile* file = tree->GetCurrentFile(); | |
659 | if (multTPC>(23+1.216*multGlobal) || multTPC<(-20+1.087*multGlobal)) | |
660 | { | |
661 | fprintf(fFile, "%i %i %s %i\n",multTPC,multGlobal,file->GetName(),fESD->GetEventNumberInFile()); | |
662 | fprintf(fFile, " primary vertex: x: %.2f, y: %.2f, z: %.2f, n: %i\n", pvtx->GetX(), pvtx->GetY(), pvtx->GetZ(), pvtx->GetNContributors()); | |
663 | fprintf(fFile, " SPD vertex: x: %.2f, y: %.2f, z: %.2f, n: %i\n", spdvtx->GetX(), spdvtx->GetY(), spdvtx->GetZ(), spdvtx->GetNContributors()); | |
664 | fprintf(fFile, " TPC vertex: x: %.2f, y: %.2f, z: %.2f, n: %i\n", tpcvtx->GetX(), tpcvtx->GetY(), tpcvtx->GetZ(), tpcvtx->GetNContributors()); | |
665 | } | |
666 | } | |
f98ea3f1 | 667 | } |
668 | ||
669 | //________________________________________________________________________ | |
670 | void AliAnalysisTaskPIDflowQA::Terminate(Option_t *) | |
671 | { | |
672 | //Terminate | |
673 | if(fCuts) | |
674 | fCuts->Dump(); | |
f98ea3f1 | 675 | |
676 | Printf("AliAnalysisTaskPIDflowQA: end of Terminate"); | |
677 | } | |
678 | ||
f98ea3f1 | 679 | |
680 | //________________________________________________________________________ | |
9b692328 | 681 | void AliAnalysisTaskPIDflowQA::pidTPC(AliESDtrack* t, Int_t) |
f98ea3f1 | 682 | { |
1a80f9f6 | 683 | //do TPC pid |
4ea2bb6b | 684 | const AliExternalTrackParam* innerParam = t->GetInnerParam(); |
685 | if (!innerParam) return; | |
686 | Double_t pinTPCglobal=innerParam->GetP(); | |
499fe731 | 687 | Double_t tpcSignal =t->GetTPCsignal(); |
1a80f9f6 | 688 | Float_t p=innerParam->P(); |
f98ea3f1 | 689 | Float_t sigPion = fESDpid->GetTPCResponse().GetExpectedSignal(pinTPCglobal, AliPID::kPion); |
690 | Float_t sigKaon = fESDpid->GetTPCResponse().GetExpectedSignal(pinTPCglobal, AliPID::kKaon); | |
691 | Float_t sigProton = fESDpid->GetTPCResponse().GetExpectedSignal(pinTPCglobal, AliPID::kProton); | |
f98ea3f1 | 692 | if(!(sigPion>0.0&&sigKaon>0.0&&sigProton>0.0)) |
693 | return; | |
694 | ||
695 | fTPCsignal->Fill(pinTPCglobal,tpcSignal); | |
696 | ||
1a80f9f6 | 697 | fTPCsignalPi->Fill(p,(tpcSignal-sigPion)/sigPion); |
698 | fTPCsignalK->Fill(p,(tpcSignal-sigKaon)/sigKaon); | |
699 | fTPCsignalP->Fill(p,(tpcSignal-sigProton)/sigProton); | |
700 | ||
9b692328 | 701 | fCutsTPCdedxElectrons->IsSelected(t); |
702 | fCutsTPCdedxPions->IsSelected(t); | |
703 | fCutsTPCdedxKaons->IsSelected(t); | |
704 | fCutsTPCdedxProtons->IsSelected(t); | |
705 | fCutsTPCpidElectrons->IsSelected(t); | |
706 | fCutsTPCpidPions->IsSelected(t); | |
707 | fCutsTPCpidKaons->IsSelected(t); | |
708 | fCutsTPCpidProtons->IsSelected(t); | |
b9cf8f8e | 709 | fCutsTPCbayesianElectrons->IsSelected(t); |
710 | fCutsTPCbayesianPions->IsSelected(t); | |
711 | fCutsTPCbayesianKaons->IsSelected(t); | |
712 | fCutsTPCbayesianProtons->IsSelected(t); | |
f98ea3f1 | 713 | } |
714 | ||
1a80f9f6 | 715 | //______________________________________________________________________________ |
9b692328 | 716 | void AliAnalysisTaskPIDflowQA::pidTOF(AliESDtrack* track, Int_t) |
f98ea3f1 | 717 | { |
1a80f9f6 | 718 | //do TOF pid |
719 | Bool_t goodtrack = (track) && | |
720 | (track->GetStatus() & AliESDtrack::kTOFpid) && | |
721 | (track->GetTOFsignal() > 12000) && | |
722 | (track->GetTOFsignal() < 100000) && | |
f21bdf48 | 723 | (track->GetIntegratedLength() > 365); |
724 | ||
f98ea3f1 | 725 | if (!goodtrack) return; |
726 | ||
1a80f9f6 | 727 | const Float_t c = 2.99792457999999984e-02; |
728 | Float_t p = track->GetP(); | |
1a80f9f6 | 729 | Float_t l = track->GetIntegratedLength(); |
730 | Float_t trackT0 = fESDpid->GetTOFResponse().GetStartTime(p); | |
9b692328 | 731 | //time |
1a80f9f6 | 732 | Float_t timeTOF = track->GetTOFsignal()- trackT0; |
733 | Double_t integratedTimes[5] = {-1.0,-1.0,-1.0,-1.0,-1.0}; | |
734 | track->GetIntegratedTimes(integratedTimes); | |
1a80f9f6 | 735 | //beta |
736 | Float_t beta = l/timeTOF/c; | |
5104aa35 | 737 | Float_t betaHypothesis[5] = {0.0,0.0,0.0,0.0,0.0}; |
1a80f9f6 | 738 | Float_t betadiff[5] = {0.0,0.0,0.0,0.0,0.0}; |
5104aa35 | 739 | for (Int_t i=0;i<5;i++) |
740 | { | |
1a80f9f6 | 741 | betaHypothesis[i] = l/integratedTimes[i]/c; |
742 | betadiff[i] = beta-betaHypothesis[i]; | |
5104aa35 | 743 | } |
1a80f9f6 | 744 | //inverse beta |
745 | Float_t invbeta = 1/beta; | |
746 | Float_t invbetaHypothesis[5] = {0.0,0.0,0.0,0.0,0.0}; | |
747 | Float_t invbetadiff[5] = {0.0,0.0,0.0,0.0,0.0}; | |
748 | for (Int_t i=0;i<5;i++) | |
749 | { | |
750 | invbetaHypothesis[i] = 1/betaHypothesis[i]; | |
751 | invbetadiff[i] = invbeta-invbetaHypothesis[i]; | |
752 | } | |
f98ea3f1 | 753 | |
9b692328 | 754 | Double_t tpcpid[AliPID::kSPECIES]; |
755 | track->GetTPCpid(tpcpid); | |
756 | ||
757 | //base hists | |
758 | fTOFrawtime->Fill(p,timeTOF); | |
759 | fTOFrawtimeE->Fill(p,timeTOF-integratedTimes[0]); | |
644f1368 | 760 | fTOFrawtimePi->Fill(p,timeTOF-integratedTimes[2]); |
761 | fTOFrawtimeK->Fill(p,timeTOF-integratedTimes[3]); | |
762 | fTOFrawtimeP->Fill(p,timeTOF-integratedTimes[4]); | |
9b692328 | 763 | |
764 | fTOFrawbeta->Fill(p,beta); | |
765 | fTOFrawbetaE->Fill(p,betadiff[0]); | |
766 | fTOFrawbetaPi->Fill(p,betadiff[2]); | |
767 | fTOFrawbetaK->Fill(p,betadiff[3]); | |
768 | fTOFrawbetaP->Fill(p,betadiff[4]); | |
769 | ||
770 | fTOFrawinvbeta->Fill(p,invbeta); | |
771 | fTOFrawinvbetaE->Fill(p,invbetadiff[0]); | |
772 | fTOFrawinvbetaPi->Fill(p,invbetadiff[2]); | |
773 | fTOFrawinvbetaK->Fill(p,invbetadiff[3]); | |
774 | fTOFrawinvbetaP->Fill(p,invbetadiff[4]); | |
775 | ||
776 | //cleanup with TPC | |
777 | if (track->GetStatus() & AliESDtrack::kTOFmismatch) return; | |
778 | if (!TPCTOFagree(track)) return; | |
779 | ||
1a80f9f6 | 780 | //responses |
f21bdf48 | 781 | fTOFtime->Fill(p,timeTOF); |
9b692328 | 782 | fTOFtimeE->Fill(p,timeTOF-integratedTimes[0]); |
644f1368 | 783 | fTOFtimePi->Fill(p,timeTOF-integratedTimes[2]); |
784 | fTOFtimeK->Fill(p,timeTOF-integratedTimes[3]); | |
785 | fTOFtimeP->Fill(p,timeTOF-integratedTimes[4]); | |
f21bdf48 | 786 | |
1a80f9f6 | 787 | fTOFbeta->Fill(p,beta); |
788 | fTOFbetaE->Fill(p,betadiff[0]); | |
789 | fTOFbetaPi->Fill(p,betadiff[2]); | |
790 | fTOFbetaK->Fill(p,betadiff[3]); | |
791 | fTOFbetaP->Fill(p,betadiff[4]); | |
792 | ||
793 | fTOFinvbeta->Fill(p,invbeta); | |
794 | fTOFinvbetaE->Fill(p,invbetadiff[0]); | |
795 | fTOFinvbetaPi->Fill(p,invbetadiff[2]); | |
796 | fTOFinvbetaK->Fill(p,invbetadiff[3]); | |
797 | fTOFinvbetaP->Fill(p,invbetadiff[4]); | |
798 | ||
9b692328 | 799 | fCutsTOFbetaElectrons->IsSelected(track); |
800 | fCutsTOFbetaPions->IsSelected(track); | |
801 | fCutsTOFbetaKaons->IsSelected(track); | |
802 | fCutsTOFbetaProtons->IsSelected(track); | |
803 | fCutsTOFbetaSimpleElectrons->IsSelected(track); | |
804 | fCutsTOFbetaSimplePions->IsSelected(track); | |
805 | fCutsTOFbetaSimpleKaons->IsSelected(track); | |
806 | fCutsTOFbetaSimpleProtons->IsSelected(track); | |
b9cf8f8e | 807 | fCutsTOFbayesianElectrons->IsSelected(track); |
808 | fCutsTOFbayesianPions->IsSelected(track); | |
809 | fCutsTOFbayesianKaons->IsSelected(track); | |
810 | fCutsTOFbayesianProtons->IsSelected(track); | |
f98ea3f1 | 811 | } |
812 | ||
1a80f9f6 | 813 | //______________________________________________________________________________ |
5104aa35 | 814 | Float_t AliAnalysisTaskPIDflowQA::Beta(Float_t m, Float_t p) |
815 | { | |
816 | //get theoretical beta | |
817 | return TMath::Sqrt(1. / (1. + m * m / (p * p))); | |
818 | } | |
9b692328 | 819 | |
820 | //---------------------------------------------------------------// | |
821 | Bool_t AliAnalysisTaskPIDflowQA::TPCTOFagree(const AliESDtrack *track) | |
822 | { | |
823 | Bool_t status = kFALSE; | |
824 | ||
825 | Float_t mass[5] = {5.10998909999999971e-04,1.05658000000000002e-01,1.39570000000000000e-01,4.93676999999999977e-01,9.38271999999999995e-01}; | |
826 | ||
827 | ||
828 | Double_t exptimes[5]; | |
829 | track->GetIntegratedTimes(exptimes); | |
830 | ||
831 | Float_t dedx = track->GetTPCsignal(); | |
832 | ||
833 | Float_t p = track->P(); | |
834 | Float_t time = track->GetTOFsignal()- fESDpid->GetTOFResponse().GetStartTime(p); | |
835 | Float_t tl = track->GetIntegratedLength(); | |
836 | ||
837 | Float_t betagammares = fESDpid->GetTOFResponse().GetExpectedSigma(p, exptimes[4], mass[4]); | |
838 | ||
839 | Float_t betagamma1 = tl/(time-5 *betagammares) * 33.3564095198152043; | |
840 | ||
841 | // printf("betagamma1 = %f\n",betagamma1); | |
842 | ||
843 | if(betagamma1 < 0.1) betagamma1 = 0.1; | |
844 | ||
845 | if(betagamma1 < 0.99999) betagamma1 /= TMath::Sqrt(1-betagamma1*betagamma1); | |
846 | else betagamma1 = 100; | |
847 | ||
848 | Float_t betagamma2 = tl/(time+5 *betagammares) * 33.3564095198152043; | |
849 | // printf("betagamma2 = %f\n",betagamma2); | |
850 | ||
851 | if(betagamma2 < 0.1) betagamma2 = 0.1; | |
852 | ||
853 | if(betagamma2 < 0.99999) betagamma2 /= TMath::Sqrt(1-betagamma2*betagamma2); | |
854 | else betagamma2 = 100; | |
855 | ||
856 | ||
857 | Double_t ptpc[3]; | |
858 | track->GetInnerPxPyPz(ptpc); | |
859 | Float_t momtpc=TMath::Sqrt(ptpc[0]*ptpc[0] + ptpc[1]*ptpc[1] + ptpc[2]*ptpc[2]); | |
860 | ||
861 | for(Int_t i=0;i < 5;i++){ | |
862 | Float_t resolutionTOF = fESDpid->GetTOFResponse().GetExpectedSigma(p, exptimes[i], mass[i]); | |
863 | if(TMath::Abs(exptimes[i] - time) < 5 * resolutionTOF){ | |
864 | Float_t dedxExp = 0; | |
865 | if(i==0) dedxExp = fESDpid->GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kElectron); | |
866 | else if(i==1) dedxExp = fESDpid->GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kMuon); | |
867 | else if(i==2) dedxExp = fESDpid->GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kPion); | |
868 | else if(i==3) dedxExp = fESDpid->GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kKaon); | |
869 | else if(i==4) dedxExp = fESDpid->GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kProton); | |
870 | ||
871 | Float_t resolutionTPC = 2; | |
872 | if(i==0) resolutionTPC = fESDpid->GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kElectron); | |
873 | else if(i==1) resolutionTPC = fESDpid->GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kMuon); | |
874 | else if(i==2) resolutionTPC = fESDpid->GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kPion); | |
875 | else if(i==3) resolutionTPC = fESDpid->GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kKaon); | |
876 | else if(i==4) resolutionTPC = fESDpid->GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kProton); | |
877 | ||
878 | if(TMath::Abs(dedx - dedxExp) < 3 * resolutionTPC){ | |
879 | status = kTRUE; | |
880 | } | |
881 | } | |
882 | } | |
883 | ||
884 | Float_t bb1 = fESDpid->GetTPCResponse().Bethe(betagamma1); | |
885 | Float_t bb2 = fESDpid->GetTPCResponse().Bethe(betagamma2); | |
886 | Float_t bbM = fESDpid->GetTPCResponse().Bethe((betagamma1+betagamma2)*0.5); | |
887 | ||
888 | ||
889 | // status = kFALSE; | |
890 | // for nuclei | |
891 | Float_t resolutionTOFpr = fESDpid->GetTOFResponse().GetExpectedSigma(p, exptimes[4], mass[4]); | |
892 | Float_t resolutionTPCpr = fESDpid->GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kProton); | |
893 | if(TMath::Abs(dedx-bb1) < resolutionTPCpr*3 && exptimes[4] < time-7*resolutionTOFpr){ | |
894 | status = kTRUE; | |
895 | } | |
896 | else if(TMath::Abs(dedx-bb2) < resolutionTPCpr*3 && exptimes[4] < time-7*resolutionTOFpr){ | |
897 | status = kTRUE; | |
898 | } | |
899 | else if(TMath::Abs(dedx-bbM) < resolutionTPCpr*3 && exptimes[4] < time-7*resolutionTOFpr){ | |
900 | status = kTRUE; | |
901 | } | |
902 | ||
903 | return status; | |
904 | } | |
5104aa35 | 905 |