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