Fix (Chiara)
[u/mrichter/AliRoot.git] / PWG3 / vertexingHF / AliAODPidHF.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-2006, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  *                                                                        *
5  * Author: The ALICE Off-line Project.                                    *
6  * Contributors are mentioned in the code where appropriate.              *
7  *
8  * Permission to use, copy, modify and distribute this software and its   *
9  * documentation strictly for non-commercial purposes is hereby granted   *
10  * without fee, provided that the above copyright notice appears in all   *
11  * copies and that both the copyright notice and this permission notice   *
12  * appear in the supporting documentation. The authors make no claims     *
13  * about the suitability of this software for any purpose. It is          *
14  * provided "as is" without express or implied warranty.                  *
15  * *************************************************************************/
16
17 /* $Id$ */
18
19 //***********************************************************
20 // Class AliAODPidHF
21 // class for PID with AliAODRecoDecayHF
22 // Authors: D. Caffarri caffarri@pd.infn.it, A.Dainese andrea.dainese@pd.infn.it, S. Dash dash@to.infn.it, F. Prino prino@to.infn.it, R. Romita r.romita@gsi.de, Y. Wang yifei@pi0.physi.uni-heidelberg.de P. Antonioli pietro.antonioli@bo.infn.it
23 //***********************************************************
24 #include "AliAODPidHF.h"
25 #include "AliAODPid.h"
26 #include "AliPID.h"
27 #include "AliTPCPIDResponse.h"
28 #include "AliITSPIDResponse.h"
29 #include "AliTOFPIDResponse.h"
30 #include "AliAODpidUtil.h"
31 #include "AliESDtrack.h"
32
33
34 ClassImp(AliAODPidHF)
35
36 //------------------------------
37 AliAODPidHF::AliAODPidHF():
38   AliAODPid(),
39   fnNSigma(5),
40   fnSigma(),
41   fTOFSigma(160.),
42   fnPriors(5),
43   fPriors(),
44   fnPLimit(2),
45   fPLimit(),
46   fAsym(kFALSE),
47   fTPC(kFALSE),
48   fTOF(kFALSE),
49   fITS(kFALSE),
50   fTRD(kFALSE),
51   fMatch(0),
52   fCompat(kFALSE),
53   fPCompatTOF(1.5),
54   fnNSigmaCompat(2),
55   fnSigmaCompat(),
56   fMC(kFALSE),
57   fOnePad(kFALSE),
58   fPbPb(kFALSE)
59 {
60  //
61  // Default constructor
62  //
63  fPLimit=new Double_t[fnPLimit];
64  fnSigma=new Double_t[fnNSigma];
65  fPriors=new Double_t[fnPriors];
66  fnSigmaCompat=new Double_t[fnNSigmaCompat];
67
68  for(Int_t i=0;i<fnNSigma;i++){
69   fnSigma[i]=0.;
70  }
71  for(Int_t i=0;i<fnPriors;i++){
72   fPriors[i]=0.;
73  }
74  for(Int_t i=0;i<fnPLimit;i++){
75   fPLimit[i]=0.;
76  }
77  for(Int_t i=0;i<fnNSigmaCompat;i++){
78   fnSigmaCompat[i]=3.;
79  }
80
81 }
82 //----------------------
83 AliAODPidHF::~AliAODPidHF()
84 {
85       // destructor
86  //   if(fPLimit) delete fPLimit;
87  //   if(fnSigma)  delete fnSigma;
88  //   if(fPriors)  delete fPriors;
89 }
90 //------------------------
91 AliAODPidHF::AliAODPidHF(const AliAODPidHF& pid) :
92   AliAODPid(pid),
93   fnNSigma(pid.fnNSigma),
94   fnSigma(pid.fnSigma),
95   fTOFSigma(pid.fTOFSigma),
96   fnPriors(pid.fnPriors),
97   fPriors(pid.fPriors),
98   fnPLimit(pid.fnPLimit),
99   fPLimit(pid.fPLimit),
100   fAsym(pid.fAsym),
101   fTPC(pid.fTPC),
102   fTOF(pid.fTOF),
103   fITS(pid.fITS),
104   fTRD(pid.fTRD),
105   fMatch(pid.fMatch),
106   fCompat(pid.fCompat),
107   fPCompatTOF(pid.fPCompatTOF),
108   fnNSigmaCompat(pid.fnNSigmaCompat),
109   fnSigmaCompat(pid.fnSigmaCompat),
110   fMC(pid.fMC),
111   fOnePad(pid.fOnePad),
112   fPbPb(pid.fPbPb)
113   {
114   
115   for(Int_t i=0;i<5;i++){
116     fPriors[i]=pid.fPriors[i];
117   }
118   
119   }
120
121 //----------------------
122 Int_t AliAODPidHF::RawSignalPID(AliAODTrack *track, TString detector) const{
123 // raw PID for single detectors, returns the particle type with smaller sigma
124    Int_t specie=-1;
125    if(detector.Contains("ITS")) return ApplyPidITSRaw(track,specie);
126    if(detector.Contains("TPC")) return ApplyPidTPCRaw(track,specie);
127    if(detector.Contains("TOF")) return ApplyPidTOFRaw(track,specie);
128
129   return specie;
130
131 }
132 //---------------------------
133 Bool_t AliAODPidHF::IsKaonRaw(AliAODTrack *track, TString detector) const{
134 // checks if the track can be a kaon, raw PID applied for single detectors
135  Int_t specie=0;
136
137  if(detector.Contains("ITS")) specie=ApplyPidITSRaw(track,3);
138  if(detector.Contains("TPC")) specie=ApplyPidTPCRaw(track,3);
139  if(detector.Contains("TOF")) specie=ApplyPidTOFRaw(track,3);
140
141  if(specie==3) return kTRUE;
142  return kFALSE;
143 }
144 //---------------------------
145 Bool_t AliAODPidHF::IsPionRaw (AliAODTrack *track, TString detector) const{
146 // checks if the track can be a pion, raw PID applied for single detectors
147
148  Int_t specie=0;
149
150  if(detector.Contains("ITS")) specie=ApplyPidITSRaw(track,2);
151  if(detector.Contains("TPC")) specie=ApplyPidTPCRaw(track,2);
152  if(detector.Contains("TOF")) specie=ApplyPidTOFRaw(track,2);
153
154  if(specie==2) return kTRUE;
155  return kFALSE;
156 }
157 //---------------------------
158 Bool_t AliAODPidHF::IsProtonRaw (AliAODTrack *track, TString detector) const{
159 // checks if the track can be a proton raw PID applied for single detectors
160
161  Int_t specie=0;
162  if(detector.Contains("ITS")) specie=ApplyPidITSRaw(track,4);
163  if(detector.Contains("TPC")) specie=ApplyPidTPCRaw(track,4); 
164  if(detector.Contains("TOF")) specie=ApplyPidTOFRaw(track,4);
165
166  if(specie==4) return kTRUE;
167
168  return kFALSE;
169 }
170 //--------------------------
171 Bool_t AliAODPidHF::IsElectronRaw(AliAODTrack *track, TString detector) const{
172 // checks if the track can be an electron raw PID applied for single detectors
173
174  Int_t specie=-1;
175  if(detector.Contains("ITS")) specie=ApplyPidITSRaw(track,0);
176  if(detector.Contains("TPC")) specie=ApplyPidTPCRaw(track,0);
177  if(detector.Contains("TOF")) specie=ApplyPidTOFRaw(track,0);
178
179  if(specie==0) return kTRUE;
180
181  return kFALSE;
182 }
183 //--------------------------
184 Int_t AliAODPidHF::ApplyPidTPCRaw(AliAODTrack *track,Int_t specie) const{
185 // n-sigma cut, TPC PID
186
187   if(!CheckStatus(track,"TPC")) return 0;
188   AliAODPid *pidObj = track->GetDetPid();
189   
190   Double_t dedx=pidObj->GetTPCsignal();
191   Double_t mom = pidObj->GetTPCmomentum();
192   AliTPCPIDResponse tpcResponse;
193   SetBetheBloch(tpcResponse); 
194   UShort_t nTPCClus=pidObj->GetTPCsignalN();
195   if(nTPCClus==0) {nTPCClus=track->GetTPCNcls();}
196
197   Int_t pid=-1;
198   if(specie<0){  // from RawSignalPID : should return the particle specie to wich the de/dx is closer to the bethe-block curve -> performance to be checked
199    Double_t nsigmaMax=fnSigma[0];
200    for(Int_t ipart=0;ipart<5;ipart++){
201     AliPID::EParticleType type=AliPID::EParticleType(ipart);
202     Double_t nsigma = TMath::Abs(tpcResponse.GetNumberOfSigmas(mom,dedx,nTPCClus,type));
203     if((nsigma<nsigmaMax) && (nsigma<fnSigma[0])) {
204      pid=ipart;
205      nsigmaMax=nsigma;
206     }
207    }
208   }else{ // asks only for one particle specie
209    AliPID::EParticleType type=AliPID::EParticleType(specie);
210     Double_t nsigma = TMath::Abs(tpcResponse.GetNumberOfSigmas(mom,dedx,nTPCClus,type));
211    if (nsigma>fnSigma[0]) {
212     pid=-1; 
213    }else{
214     pid=specie;
215    }
216   }
217
218  return pid;
219
220 }
221 //----------------------------
222 Int_t AliAODPidHF::ApplyPidITSRaw(AliAODTrack *track,Int_t specie) const{
223 // truncated mean, ITS PID
224
225   if(!CheckStatus(track,"ITS")) return 0;
226
227   Double_t mom=track->P();
228   AliAODPid *pidObj = track->GetDetPid();
229
230   Double_t dedx=pidObj->GetITSsignal();
231   UChar_t clumap=track->GetITSClusterMap();
232   Int_t nPointsForPid=0;
233   for(Int_t i=2; i<6; i++){
234    if(clumap&(1<<i)) ++nPointsForPid;
235   }
236
237   Bool_t isSA=kTRUE;
238   if(track->GetStatus() & AliESDtrack::kTPCin) isSA = kFALSE;
239
240   AliITSPIDResponse itsResponse;
241   Int_t pid=-1;
242   if(specie<0){  // from RawSignalPID : should return the particle specie to wich the de/dx is closer to the bethe-block curve -> performance to be checked
243    Double_t nsigmaMax=fnSigma[4];
244    for(Int_t ipart=0;ipart<5;ipart++){
245     AliPID::EParticleType type=AliPID::EParticleType(ipart);
246     Double_t nsigma = TMath::Abs(itsResponse.GetNumberOfSigmas(mom,dedx,type,nPointsForPid,isSA));
247     if((nsigma<nsigmaMax) && (nsigma<fnSigma[4])) {
248      pid=ipart;
249      nsigmaMax=nsigma;
250     }
251    }
252   }else{ // asks only for one particle specie
253    AliPID::EParticleType type=AliPID::EParticleType(specie);
254     Double_t nsigma = TMath::Abs(itsResponse.GetNumberOfSigmas(mom,dedx,type));
255    if (nsigma>fnSigma[4]) {
256     pid=-1; 
257    }else{
258     pid=specie;
259    }
260   }
261  return pid; 
262 }
263 //----------------------------
264 Int_t AliAODPidHF::ApplyPidTOFRaw(AliAODTrack *track,Int_t specie) const{
265 // n-sigma cut, TOF PID
266
267  if(!CheckStatus(track,"TOF")) return 0;
268
269  Double_t time[AliPID::kSPECIESN];
270  Double_t sigmaTOFPid[AliPID::kSPECIES];
271  AliAODPid *pidObj = track->GetDetPid();
272  pidObj->GetIntegratedTimes(time);
273  Double_t sigTOF=pidObj->GetTOFsignal();
274  pidObj->GetTOFpidResolution(sigmaTOFPid);
275
276  Int_t pid=-1;
277
278   if(specie<0){  
279    Double_t sigmaTOFtrack;
280    if (sigmaTOFPid[4]>0) sigmaTOFtrack=sigmaTOFPid[4];
281    else sigmaTOFtrack=fTOFSigma;
282    Double_t nsigmaMax=sigmaTOFtrack*fnSigma[3];
283    for(Int_t ipart=0;ipart<5;ipart++){
284     Double_t nsigma=TMath::Abs(sigTOF-time[ipart]);
285     if (sigmaTOFPid[ipart]>0) sigmaTOFtrack=sigmaTOFPid[ipart]; 
286     else sigmaTOFtrack=fTOFSigma;  // backward compatibility for old AODs
287     if((nsigma<nsigmaMax) && (nsigma<fnSigma[3]*sigmaTOFtrack)) {
288      pid=ipart;
289      nsigmaMax=nsigma;
290     }
291    }
292   }else{ // asks only for one particle specie
293     Double_t nsigma=TMath::Abs(sigTOF-time[specie]);
294     Double_t sigmaTOFtrack;
295     if (sigmaTOFPid[specie]>0) sigmaTOFtrack=sigmaTOFPid[specie]; 
296     else sigmaTOFtrack=fTOFSigma;  // backward compatibility for old AODs
297     if (nsigma>fnSigma[3]*sigmaTOFtrack) {
298       pid=-1; 
299     }else{
300       pid=specie;
301     }
302   }
303  return pid; 
304
305 }
306 //------------------------------
307 void AliAODPidHF::CombinedProbability(AliAODTrack *track,Bool_t *type) const{
308 // combined PID stored inside the AOD track
309
310  const Double_t *pid=track->PID();
311  Float_t max=0.;
312  Int_t k=-1;
313  for (Int_t i=0; i<10; i++) {
314    if (pid[i]>max) {k=i; max=pid[i];}  
315  }
316
317  if(k==2) type[0]=kTRUE;
318  if(k==3) type[1]=kTRUE;
319  if(k==4) type[2]=kTRUE;
320
321  return;
322 }
323 //--------------------
324 void AliAODPidHF::BayesianProbability(AliAODTrack *track,Double_t *pid) const{
325 // bayesian PID for single detectors or combined
326
327   if(fITS && !fTPC && !fTOF) {BayesianProbabilityITS(track,pid);return;}
328   if(fTPC && !fITS && !fTOF) {BayesianProbabilityTPC(track,pid);return;}
329   if(fTOF && !fITS && !fTPC) {BayesianProbabilityTOF(track,pid);return;}
330
331     Double_t probITS[5]={1.,1.,1.,1.,1.};
332     Double_t probTPC[5]={1.,1.,1.,1.,1.};
333     Double_t probTOF[5]={1.,1.,1.,1.,1.};
334     if(fITS) BayesianProbabilityITS(track,probITS);
335     if(fTPC) BayesianProbabilityTPC(track,probTPC);
336     if(fTOF) BayesianProbabilityTOF(track,probTOF);
337     Double_t probTot[5]={0.,0.,0.,0.,0.};
338     for(Int_t i=0;i<5;i++){
339      probTot[i]=probITS[i]*probTPC[i]*probTOF[i];
340     }
341     for(Int_t i2=0;i2<5;i2++){
342      pid[i2]=probTot[i2]*fPriors[i2]/(probTot[0]*fPriors[0]+probTot[1]*fPriors[1]+probTot[2]*fPriors[2]+probTot[3]*fPriors[3]+probTot[4]*fPriors[4]);
343     }
344
345  return;
346
347 }
348 //------------------------------------
349 void AliAODPidHF::BayesianProbabilityITS(AliAODTrack *track,Double_t *prob) const{
350
351 // bayesian PID for ITS
352  AliAODpidUtil pid;
353  Double_t itspid[AliPID::kSPECIES];
354  pid.MakeITSPID(track,itspid);
355  for(Int_t ind=0;ind<AliPID::kSPECIES;ind++){
356   if(fTOF || fTPC || fTRD){
357    prob[ind]=itspid[ind];
358   }else{
359    prob[ind]=itspid[ind]*fPriors[ind]/(itspid[0]*fPriors[0]+itspid[1]*fPriors[1]+itspid[2]*fPriors[2]+itspid[3]*fPriors[3]+itspid[4]*fPriors[4]);
360   }
361  }
362  return;
363
364 }
365 //------------------------------------
366 void AliAODPidHF::BayesianProbabilityTPC(AliAODTrack *track,Double_t *prob) const{
367 // bayesian PID for TPC
368
369  AliAODpidUtil pid;
370  Double_t tpcpid[AliPID::kSPECIES];
371  pid.MakeTPCPID(track,tpcpid);
372  for(Int_t ind=0;ind<AliPID::kSPECIES;ind++){
373   if(fTOF || fITS || fTRD){
374    prob[ind]=tpcpid[ind];
375   }else{
376    prob[ind]=tpcpid[ind]*fPriors[ind]/(tpcpid[0]*fPriors[0]+tpcpid[1]*fPriors[1]+tpcpid[2]*fPriors[2]+tpcpid[3]*fPriors[3]+tpcpid[4]*fPriors[4]);
377  }
378 }
379  return;
380
381 }
382 //------------------------------------
383 void AliAODPidHF::BayesianProbabilityTOF(AliAODTrack *track,Double_t *prob) const{
384 // bayesian PID for TOF
385
386  AliAODpidUtil pid;
387  Double_t tofpid[AliPID::kSPECIES];
388  pid.MakeTOFPID(track,tofpid);
389  for(Int_t ind=0;ind<AliPID::kSPECIES;ind++){
390   if(fTPC || fITS || fTRD){
391    prob[ind]=tofpid[ind];
392   }else{
393   prob[ind]=tofpid[ind]*fPriors[ind]/(tofpid[0]*fPriors[0]+tofpid[1]*fPriors[1]+tofpid[2]*fPriors[2]+tofpid[3]*fPriors[3]+tofpid[4]*fPriors[4]);
394  }
395 }
396  return;
397
398 }
399 //---------------------------------
400 void AliAODPidHF::BayesianProbabilityTRD(AliAODTrack *track,Double_t *prob) const{
401 // bayesian PID for TRD
402
403  AliAODpidUtil pid;
404  Double_t trdpid[AliPID::kSPECIES];
405  pid.MakeTRDPID(track,trdpid);
406  for(Int_t ind=0;ind<AliPID::kSPECIES;ind++){
407   if(fTPC || fITS || fTOF){
408    prob[ind]=trdpid[ind];
409   }else{
410    prob[ind]=trdpid[ind]*fPriors[ind]/(trdpid[0]*fPriors[0]+trdpid[1]*fPriors[1]+trdpid[2]*fPriors[2]+trdpid[3]*fPriors[3]+trdpid[4]*fPriors[4]);
411  }
412 }
413   return;
414
415  }
416 //--------------------------------
417 Bool_t AliAODPidHF::CheckStatus(AliAODTrack *track,TString detectors) const{
418
419 // Quality cuts on the tracks, detector by detector
420
421  if(detectors.Contains("ITS")){
422   if ((track->GetStatus()&AliESDtrack::kITSin)==0) return kFALSE;
423   UChar_t clumap=track->GetITSClusterMap();
424   Int_t nPointsForPid=0;
425   for(Int_t i=2; i<6; i++){
426    if(clumap&(1<<i)) ++nPointsForPid;
427   }
428   if(nPointsForPid<3) return kFALSE;
429  }
430
431  if(detectors.Contains("TPC")){
432    if ((track->GetStatus()&AliESDtrack::kTPCin )==0) return kFALSE;
433    UShort_t nTPCClus=track->GetTPCClusterMap().CountBits();
434    if (nTPCClus<70) return kFALSE;
435  }
436
437  if(detectors.Contains("TOF")){
438    if ((track->GetStatus()&AliESDtrack::kTOFout )==0)    return kFALSE;
439    if ((track->GetStatus()&AliESDtrack::kTIME )==0)     return kFALSE;
440    if ((track->GetStatus()&AliESDtrack::kTOFpid )==0)   return kFALSE;
441    if (!(track->GetStatus()&AliESDtrack::kTOFmismatch)==0)    return kFALSE;
442  }
443
444
445  if(detectors.Contains("TRD")){
446   if ((track->GetStatus()&AliESDtrack::kTRDout )==0)   return kFALSE;
447   AliAODPid *pidObj = track->GetDetPid();
448   Float_t *mom=pidObj->GetTRDmomentum();
449   Int_t ntracklets=0;
450   for(Int_t iPl=0;iPl<6;iPl++){
451    if(mom[iPl]>0.) ntracklets++;
452   }
453    if(ntracklets<4) return kFALSE;
454  }
455
456  return kTRUE;
457 }
458 //--------------------------------------------
459 Bool_t AliAODPidHF::TPCRawAsym(AliAODTrack* track,Int_t specie) const{
460 // TPC nsigma cut PID, different sigmas in different p bins
461
462   if(!CheckStatus(track,"TPC")) return kFALSE;
463   AliAODPid *pidObj = track->GetDetPid();
464   Double_t mom = pidObj->GetTPCmomentum();
465   Double_t dedx=pidObj->GetTPCsignal();
466   UShort_t nTPCClus=pidObj->GetTPCsignalN();
467   if(nTPCClus==0) {nTPCClus=track->GetTPCNcls();}
468   
469   AliTPCPIDResponse tpcResponse;
470   SetBetheBloch(tpcResponse); 
471   AliPID::EParticleType type=AliPID::EParticleType(specie);
472   Double_t nsigma = TMath::Abs(tpcResponse.GetNumberOfSigmas(mom,dedx,nTPCClus,type)); 
473
474   if(mom<fPLimit[0] && nsigma<fnSigma[0]) return kTRUE;
475   if(mom<fPLimit[1] && mom>fPLimit[0] && nsigma<fnSigma[1]) return kTRUE;
476   if(mom>fPLimit[1] && nsigma<fnSigma[2]) return kTRUE;
477
478  return kFALSE;
479 }
480 //------------------
481 Int_t AliAODPidHF::MatchTPCTOF(AliAODTrack *track,Int_t mode,Int_t specie,Bool_t compat){
482 // combination of the PID info coming from TPC and TOF
483  if(mode==1){
484   //TOF || TPC (a la' Andrea R.)
485  // convention: 
486  // for the single detectors: -1 = kFALSE, 1 = kTRUE, 0 = compatible
487  // the method returns the sum of the response of the 2 detectors
488   if(fTPC && fTOF) {if(!CheckStatus(track,"TPC") && !CheckStatus(track,"TOF")) return 0;}
489
490   
491   Int_t tTPCinfo=0;
492   if(fTPC){
493   if(CheckStatus(track,"TPC")) {
494    if(fAsym) {
495     if(TPCRawAsym(track,specie)) {
496       tTPCinfo=1;
497      }else{
498       tTPCinfo=-1;
499      }
500    }else{
501     if(specie==2 && IsPionRaw(track,"TPC")) {
502      tTPCinfo=1;
503     }else{
504      tTPCinfo=-1;
505     }
506     if(specie==3 && IsKaonRaw(track,"TPC")) {
507      tTPCinfo=1;
508     }else{
509      tTPCinfo=-1;
510     }
511     if(specie==4 && IsProtonRaw(track,"TPC")) {
512      tTPCinfo=1;
513     }else{
514      tTPCinfo=-1;
515     }
516
517    }
518
519
520    if(compat && tTPCinfo<0){
521     Double_t sig0tmp=fnSigma[0];
522     SetSigma(0,fnSigmaCompat[0]);
523     if(specie==2 && IsPionRaw(track,"TPC")) tTPCinfo=0;
524     if(specie==3 && IsKaonRaw(track,"TPC")) tTPCinfo=0;
525     if(specie==4 && IsProtonRaw(track,"TPC")) tTPCinfo=0;
526     SetSigma(0,sig0tmp);
527    }
528
529   }
530  }
531
532  Int_t tTOFinfo=0;
533  if(fTOF){
534   if(!CheckStatus(track,"TOF") && fTPC) return tTPCinfo;
535
536   tTOFinfo=-1;
537  
538   if(specie==2 && IsPionRaw(track,"TOF")) tTOFinfo=1;
539   if(specie==3 && IsKaonRaw(track,"TOF")) tTOFinfo=1;
540   if(specie==4 && IsProtonRaw(track,"TOF")) tTOFinfo=1;
541
542   if(compat && tTOFinfo>0){
543    Double_t ptrack=track->P();
544    if(ptrack>fPCompatTOF) {
545     Double_t sig0tmp=fnSigma[3];
546     SetSigma(3,fnSigmaCompat[1]);
547     if(specie==2 && IsPionRaw(track,"TOF")) tTOFinfo=0;
548     if(specie==3 && IsKaonRaw(track,"TOF")) tTOFinfo=0;
549     if(specie==4 && IsProtonRaw(track,"TOF")) tTOFinfo=0;
550     SetSigma(3,sig0tmp);
551    }
552   }
553  }
554
555  if(tTPCinfo+tTOFinfo==0 && fITS){
556   if(!CheckStatus(track,"ITS")) return tTPCinfo+tTOFinfo;
557   Int_t tITSinfo = -1;
558   if(specie==2 && IsPionRaw(track,"ITS")) tITSinfo=1;
559   if(specie==3 && IsKaonRaw(track,"ITS")) tITSinfo=1;
560   if(specie==4 && IsProtonRaw(track,"ITS")) tITSinfo=1;
561   return tITSinfo;
562  }
563
564  return tTPCinfo+tTOFinfo;
565 }
566  if(mode==2){
567   //TPC & TOF (a la' Yifei)
568  // convention: -1 = kFALSE, 1 = kTRUE, 0 = not identified
569   Int_t tTPCinfo=0; 
570   
571   if(fTPC && CheckStatus(track,"TPC")) {
572    tTPCinfo=1;
573    if(fAsym){
574     if(!TPCRawAsym(track,specie)) tTPCinfo=-1;
575    }else{
576     if(specie==2 && !IsPionRaw(track,"TPC")) tTPCinfo=-1;
577     if(specie==3 && !IsKaonRaw(track,"TPC")) tTPCinfo=-1;
578     if(specie==4 && !IsProtonRaw(track,"TPC")) tTPCinfo=-1;
579    }
580   }
581
582   Int_t tTOFinfo=1;
583   if(fTOF){
584    if(fTPC && !CheckStatus(track,"TOF")) return tTPCinfo;
585
586    if(specie==2 && !IsPionRaw(track,"TOF")) tTOFinfo=-1;
587    if(specie==3 && !IsKaonRaw(track,"TOF")) tTOFinfo=-1;
588    if(specie==4 && !IsProtonRaw(track,"TOF")) tTOFinfo=-1;
589   }
590
591  if(tTOFinfo==1 && tTPCinfo==1) return 1;
592
593  if(tTPCinfo+tTOFinfo==0 && fITS){
594   if(!CheckStatus(track,"ITS")) return tTPCinfo+tTOFinfo;
595   Int_t tITSinfo = -1;
596   if(specie==2 && IsPionRaw(track,"ITS")) tITSinfo=1;
597   if(specie==3 && IsKaonRaw(track,"ITS")) tITSinfo=1;
598   if(specie==4 && IsProtonRaw(track,"ITS")) tITSinfo=1;
599   return tITSinfo;
600  }
601
602    return -1;
603
604 }
605
606  if(mode==3){
607  //TPC for p<fPLimit[0], TOF for p>=fPLimit[0] (a la' Andrea A.)
608  // convention (temporary): -1 = kFALSE, 1 = kTRUE, 0 = not identified
609   
610   if(fTPC && fTOF) if(!CheckStatus(track,"TPC") && !CheckStatus(track,"TOF")) return 0;
611
612   Double_t ptrack=track->P();
613   
614
615   Int_t tTPCinfo=-1;
616
617    if(ptrack>=fPLimit[0] && ptrack<fPLimit[1] && fTPC) {  
618     if(!CheckStatus(track,"TPC")) return 0;
619     if(fAsym) {
620      if(TPCRawAsym(track,specie)) tTPCinfo=1;
621     }else{
622      if(specie==2 && IsPionRaw(track,"TPC")) tTPCinfo=1;
623      if(specie==3 && IsKaonRaw(track,"TPC")) tTPCinfo=1;
624      if(specie==4 && IsProtonRaw(track,"TPC")) tTPCinfo=1;
625     } 
626     return tTPCinfo;
627    }
628
629    Int_t tTOFinfo=-1;
630    if(ptrack>=fPLimit[1] && fTOF){
631     if(!CheckStatus(track,"TOF")) return 0;
632     if(specie==2 && IsPionRaw(track,"TOF")) tTOFinfo=1;
633     if(specie==3 && IsKaonRaw(track,"TOF")) tTOFinfo=1;
634     if(specie==4 && IsProtonRaw(track,"TOF")) tTOFinfo=1;
635     return tTOFinfo;
636    }
637
638    Int_t tITSinfo=-1;
639    if(ptrack<fPLimit[0] && fITS){
640     if(!CheckStatus(track,"ITS")) return 0;
641     if(specie==2 && IsPionRaw(track,"ITS")) tITSinfo=1;
642     if(specie==3 && IsKaonRaw(track,"ITS")) tITSinfo=1;
643     if(specie==4 && IsProtonRaw(track,"ITS")) tITSinfo=1;
644     return tITSinfo;
645    }
646
647  }
648
649  return -1;
650
651 }
652 //----------------------------------   
653 Int_t AliAODPidHF::MakeRawPid(AliAODTrack *track, Int_t specie){
654 // general method to compute PID
655  if(fMatch>0){
656   return MatchTPCTOF(track,fMatch,specie,fCompat); 
657  }else{
658   if(fTPC && !fTOF && !fITS) {
659    Int_t tTPCres=0;
660    if(!fAsym){
661    tTPCres=ApplyPidTPCRaw(track,specie);
662    }else{
663     if(TPCRawAsym(track,specie)) {
664      tTPCres=1;
665     }else{
666      tTPCres=-1;
667     }
668    }
669    if(tTPCres==specie){return 1;}else{return tTPCres;};
670   }else{
671    AliError("You should enable just one detector if you don't want to match");
672    return 0;
673   }
674   if(fTOF && !fTPC && !fITS) {
675    Int_t tTOFres=ApplyPidTOFRaw(track,specie); 
676    if(tTOFres==specie){return 1;}else{return tTOFres;};
677   }else{
678    AliError("You should enable just one detector if you don't want to match");
679    return 0;
680   }
681
682   if(fITS && !fTPC && !fTOF) {
683    Int_t tITSres=ApplyPidITSRaw(track,specie);
684    if(tITSres==specie){return 1;}else{return tITSres;};
685   }else{
686    AliError("You should enable just one detector if you don't want to match");
687    return 0;
688   }
689  } 
690   
691 }
692 //--------------------------------------------
693 void AliAODPidHF::SetBetheBloch(AliTPCPIDResponse &tpcResp) const{
694
695  Double_t alephParameters[5];
696
697  // MC
698  if(fMC){
699   alephParameters[0] = 2.15898e+00/50.;
700   alephParameters[1] = 1.75295e+01;
701   alephParameters[2] = 3.40030e-09;
702   alephParameters[3] = 1.96178e+00;
703   alephParameters[4] = 3.91720e+00;
704
705  }else{
706
707    // Read Data
708
709   if(fOnePad) {
710
711     alephParameters[0] =1.34490e+00/50; 
712     alephParameters[1] = 2.69455e+01; 
713     alephParameters[2] = TMath::Exp(-2.97552+01); 
714     alephParameters[3] = 2.35339e+00; 
715     alephParameters[4] = 5.98079e+00;
716     
717   } else if(fPbPb) {
718     
719     // alephParameters[0] = 1.25202/50.; 
720     // alephParameters[1] = 2.74992e+01; 
721     // alephParameters[2] = TMath::Exp(-3.31517e+01); 
722     // alephParameters[3] = 2.46246; 
723     // alephParameters[4] = 6.78938;
724     
725     alephParameters[0] = 5.10207e+00/50.; 
726     alephParameters[1] = 7.94982e+00; 
727     alephParameters[2] = TMath::Exp(-9.07942e+00); 
728     alephParameters[3] = 2.38808e+00; 
729     alephParameters[4] = 1.68165e+00;
730     
731   } else {
732     alephParameters[0] = 0.0283086/0.97;
733     alephParameters[1] = 2.63394e+01;
734     alephParameters[2] = 5.04114e-11;
735     alephParameters[3] = 2.12543e+00;
736     alephParameters[4] = 4.88663e+00;
737     
738   }
739   
740  }
741
742  tpcResp.SetBetheBlochParameters(alephParameters[0],alephParameters[1],alephParameters[2],alephParameters[3],alephParameters[4]);
743
744
745  return;
746
747 }
748 //-----------------------
749 Bool_t AliAODPidHF::IsTOFPiKexcluded(AliAODTrack *track,Double_t nsigmaK){
750
751
752  if(!CheckStatus(track,"TOF")) return 0;
753
754   Double_t time[AliPID::kSPECIESN];
755   Double_t sigmaTOFPid[AliPID::kSPECIES];
756   AliAODPid *pidObj = track->GetDetPid();
757   pidObj->GetIntegratedTimes(time);
758   Double_t sigTOF=pidObj->GetTOFsignal();
759   pidObj->GetTOFpidResolution(sigmaTOFPid);
760   Double_t sigmaTOFtrack;
761   if (sigmaTOFPid[3]>0) sigmaTOFtrack=sigmaTOFPid[3];
762   else sigmaTOFtrack=fTOFSigma;  // backward compatibility for old AODs
763   
764   if((sigTOF-time[3])>nsigmaK*sigmaTOFtrack)return kTRUE;// K, Pi excluded (->LIKELY A PROTON)
765   
766   return kFALSE;
767
768 }
769