Changes related to PID mode and parameters configuration (Rossella, Francesco)
[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 //***********************************************************
18 // Class AliAODPidHF
19 // class for PID with AliAODRecoDecayHF
20 // 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
21 //***********************************************************
22 #include "AliAODPidHF.h"
23 #include "AliAODPid.h"
24 #include "AliAODTrack.h"
25 #include "AliPID.h"
26 #include "AliTPCPIDResponse.h"
27 #include "AliITSPIDResponse.h"
28 #include "AliTOFPIDResponse.h"
29 #include "AliAODpidUtil.h"
30 #include "AliESDtrack.h"
31
32
33 ClassImp(AliAODPidHF)
34
35 //------------------------------
36 AliAODPidHF::AliAODPidHF():
37   AliAODPid(),
38   fnNSigma(5),
39   fnSigma(),
40   fTOFSigma(160.),
41   fnPriors(5),
42   fPriors(),
43   fnPLimit(2),
44   fPLimit(),
45   fAsym(kFALSE),
46   fTPC(kFALSE),
47   fTOF(kFALSE),
48   fITS(kFALSE),
49   fTRD(kFALSE),
50   fMatch(kFALSE),
51   fCompat(kFALSE)
52 {
53  //
54  // Default constructor
55  //
56  fPLimit=new Double_t[fnPLimit];
57  fnSigma=new Double_t[fnNSigma];
58  fPriors=new Double_t[fnPriors];
59
60  for(Int_t i=0;i<fnNSigma;i++){
61   fnSigma[i]=0.;
62  }
63  for(Int_t i=0;i<fnPriors;i++){
64   fPriors[i]=0.;
65  }
66  for(Int_t i=0;i<fnPLimit;i++){
67   fPLimit[i]=0.;
68  }
69
70 }
71 //----------------------
72 AliAODPidHF::~AliAODPidHF()
73 {
74       // destructor
75  //   if(fPLimit) delete fPLimit;
76  //   if(fnSigma)  delete fnSigma;
77  //   if(fPriors)  delete fPriors;
78 }
79 //------------------------
80 AliAODPidHF::AliAODPidHF(const AliAODPidHF& pid) :
81   AliAODPid(pid),
82   fnNSigma(pid.fnNSigma),
83   fnSigma(pid.fnSigma),
84   fTOFSigma(pid.fTOFSigma),
85   fnPriors(pid.fnPriors),
86   fPriors(pid.fPriors),
87   fnPLimit(pid.fnPLimit),
88   fPLimit(pid.fPLimit),
89   fAsym(pid.fAsym),
90   fTPC(pid.fTPC),
91   fTOF(pid.fTOF),
92   fITS(pid.fITS),
93   fTRD(pid.fTRD),
94   fMatch(pid.fMatch),
95   fCompat(pid.fCompat)
96   {
97   
98   for(Int_t i=0;i<5;i++){
99     fPriors[i]=pid.fPriors[i];
100   }
101   
102   }
103
104 //----------------------
105 Int_t AliAODPidHF::RawSignalPID(AliAODTrack *track, TString detector) const{
106 // raw PID for single detectors, returns the particle type with smaller sigma
107    Int_t specie=-1;
108    if(detector.Contains("ITS")) return ApplyPidITSRaw(track,specie);
109    if(detector.Contains("TPC")) return ApplyPidTPCRaw(track,specie);
110    if(detector.Contains("TOF")) return ApplyPidTOFRaw(track,specie);
111
112   return specie;
113
114 }
115 //---------------------------
116 Bool_t AliAODPidHF::IsKaonRaw(AliAODTrack *track, TString detector) const{
117 // checks if the track can be a kaon, raw PID applied for single detectors
118  Int_t specie=0;
119
120  if(detector.Contains("ITS")) specie=ApplyPidITSRaw(track,3);
121  if(detector.Contains("TPC")) specie=ApplyPidTPCRaw(track,3);
122  if(detector.Contains("TOF")) specie=ApplyPidTOFRaw(track,3);
123
124  if(specie==3) return kTRUE;
125  return kFALSE;
126 }
127 //---------------------------
128 Bool_t AliAODPidHF::IsPionRaw (AliAODTrack *track, TString detector) const{
129 // checks if the track can be a pion, raw PID applied for single detectors
130
131  Int_t specie=0;
132
133  if(detector.Contains("ITS")) specie=ApplyPidITSRaw(track,2);
134  if(detector.Contains("TPC")) specie=ApplyPidTPCRaw(track,2);
135  if(detector.Contains("TOF")) specie=ApplyPidTOFRaw(track,2);
136
137  if(specie==2) return kTRUE;
138  return kFALSE;
139 }
140 //---------------------------
141 Bool_t AliAODPidHF::IsProtonRaw (AliAODTrack *track, TString detector) const{
142 // checks if the track can be a proton raw PID applied for single detectors
143
144  Int_t specie=0;
145  if(detector.Contains("ITS")) specie=ApplyPidITSRaw(track,4);
146  if(detector.Contains("TPC")) specie=ApplyPidTPCRaw(track,4); 
147  if(detector.Contains("TOF")) specie=ApplyPidTOFRaw(track,4);
148
149  if(specie==4) return kTRUE;
150
151  return kFALSE;
152 }
153 //--------------------------
154 Bool_t AliAODPidHF::IsElectronRaw(AliAODTrack *track, TString detector) const{
155 // checks if the track can be an electron raw PID applied for single detectors
156
157  Int_t specie=-1;
158  if(detector.Contains("ITS")) specie=ApplyPidITSRaw(track,0);
159  if(detector.Contains("TPC")) specie=ApplyPidTPCRaw(track,0);
160  if(detector.Contains("TOF")) specie=ApplyPidTOFRaw(track,0);
161
162  if(specie==0) return kTRUE;
163
164  return kFALSE;
165 }
166 //--------------------------
167 Int_t AliAODPidHF::ApplyPidTPCRaw(AliAODTrack *track,Int_t specie) const{
168 // n-sigma cut, TPC PID
169
170   if(!CheckStatus(track,"TPC")) return 0;
171   AliAODPid *pidObj = track->GetDetPid();
172   
173   Double_t dedx=pidObj->GetTPCsignal();
174   Double_t mom = pidObj->GetTPCmomentum();
175   AliTPCPIDResponse tpcResponse;
176   Int_t pid=-1;
177   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
178    Double_t nsigmaMax=fnSigma[0];
179    for(Int_t ipart=0;ipart<5;ipart++){
180     AliPID::EParticleType type=AliPID::EParticleType(ipart);
181     Double_t nsigma = TMath::Abs(tpcResponse.GetNumberOfSigmas(mom,dedx,track->GetTPCNcls(),type));
182     if((nsigma<nsigmaMax) && (nsigma<fnSigma[0])) {
183      pid=ipart;
184      nsigmaMax=nsigma;
185     }
186    }
187   }else{ // asks only for one particle specie
188    AliPID::EParticleType type=AliPID::EParticleType(specie);
189     Double_t nsigma = TMath::Abs(tpcResponse.GetNumberOfSigmas(mom,dedx,track->GetTPCNcls(),type));
190    if (nsigma>fnSigma[0]) {
191     pid=-1; 
192    }else{
193     pid=1;
194    }
195   }
196
197  return pid;
198
199 }
200 //----------------------------
201 Int_t AliAODPidHF::ApplyPidITSRaw(AliAODTrack *track,Int_t specie) const{
202 // truncated mean, ITS PID
203
204   if(!CheckStatus(track,"ITS")) return 0;
205
206   Double_t mom=track->P();
207   AliAODPid *pidObj = track->GetDetPid();
208
209   Double_t dedx=pidObj->GetITSsignal();
210   AliITSPIDResponse itsResponse;
211   Int_t pid=-1;
212   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
213    Double_t nsigmaMax=fnSigma[4];
214    for(Int_t ipart=0;ipart<5;ipart++){
215     AliPID::EParticleType type=AliPID::EParticleType(ipart);
216     Double_t nsigma = TMath::Abs(itsResponse.GetNumberOfSigmas(mom,dedx,type));
217     if((nsigma<nsigmaMax) && (nsigma<fnSigma[4])) {
218      pid=ipart;
219      nsigmaMax=nsigma;
220     }
221    }
222   }else{ // asks only for one particle specie
223    AliPID::EParticleType type=AliPID::EParticleType(specie);
224     Double_t nsigma = TMath::Abs(itsResponse.GetNumberOfSigmas(mom,dedx,type));
225    if (nsigma>fnSigma[4]) {
226     pid=-1; 
227    }else{
228     pid=1;
229    }
230   }
231  return pid; 
232 }
233 //----------------------------
234 Int_t AliAODPidHF::ApplyPidTOFRaw(AliAODTrack *track,Int_t specie) const{
235 // n-sigma cut, TOF PID
236
237  if(!CheckStatus(track,"TOF")) return 0;
238
239  Double_t time[AliPID::kSPECIESN];
240  AliAODPid *pidObj = track->GetDetPid();
241  pidObj->GetIntegratedTimes(time);
242  Double_t sigTOF=pidObj->GetTOFsignal();
243 // AliTOFPIDResponse tofResponse;
244  Int_t pid=-1;
245
246   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
247    Double_t nsigmaMax=fTOFSigma*fnSigma[3];
248    for(Int_t ipart=0;ipart<5;ipart++){
249     //AliPID::EParticleType type=AliPID::EParticleType(ipart);
250     //Double_t nsigma = tofResponse.GetExpectedSigma(track->P(),time[type],AliPID::ParticleMass(type));
251     Double_t nsigma=TMath::Abs(sigTOF-time[ipart]);
252     if((nsigma<nsigmaMax) && (nsigma<fnSigma[3]*fTOFSigma)) {
253      pid=ipart;
254      nsigmaMax=nsigma;
255     }
256    }
257   }else{ // asks only for one particle specie
258    //AliPID::EParticleType type=AliPID::EParticleType(specie);
259    //Double_t nsigma = TMath::Abs(tofResponse.GetExpectedSigma(track->P(),time[type],AliPID::ParticleMass(type)));
260     Double_t nsigma=TMath::Abs(sigTOF-time[specie]);
261    if (nsigma>fnSigma[3]*fTOFSigma) {
262     pid=-1; 
263    }else{
264     pid=1;
265    }
266   }
267  return pid; 
268
269 }
270 //------------------------------
271 void AliAODPidHF::CombinedProbability(AliAODTrack *track,Bool_t *type) const{
272 // combined PID stored inside the AOD track
273
274  const Double_t *pid=track->PID();
275  Float_t max=0.;
276  Int_t k=-1;
277  for (Int_t i=0; i<10; i++) {
278    if (pid[i]>max) {k=i; max=pid[i];}  
279  }
280
281  if(k==2) type[0]=kTRUE;
282  if(k==3) type[1]=kTRUE;
283  if(k==4) type[2]=kTRUE;
284
285  return;
286 }
287 //--------------------
288 void AliAODPidHF::BayesianProbability(AliAODTrack *track,Double_t *pid) const{
289 // bayesian PID for single detectors or combined
290
291   if(fITS && !fTPC && !fTOF) {BayesianProbabilityITS(track,pid);return;}
292   if(fTPC && !fITS && !fTOF) {BayesianProbabilityTPC(track,pid);return;}
293   if(fTOF && !fITS && !fTPC) {BayesianProbabilityTOF(track,pid);return;}
294
295     Double_t probITS[5]={1.,1.,1.,1.,1.};
296     Double_t probTPC[5]={1.,1.,1.,1.,1.};
297     Double_t probTOF[5]={1.,1.,1.,1.,1.};
298     if(fITS) BayesianProbabilityITS(track,probITS);
299     if(fTPC) BayesianProbabilityTPC(track,probTPC);
300     if(fTOF) BayesianProbabilityTOF(track,probTOF);
301     Double_t probTot[5]={0.,0.,0.,0.,0.};
302     for(Int_t i=0;i<5;i++){
303      probTot[i]=probITS[i]*probTPC[i]*probTOF[i];
304     }
305     for(Int_t i2=0;i2<5;i2++){
306      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]);
307     }
308
309  return;
310
311 }
312 //------------------------------------
313 void AliAODPidHF::BayesianProbabilityITS(AliAODTrack *track,Double_t *prob) const{
314
315 // bayesian PID for ITS
316  AliAODpidUtil pid;
317  Double_t itspid[AliPID::kSPECIES];
318  pid.MakeITSPID(track,itspid);
319  for(Int_t ind=0;ind<AliPID::kSPECIES;ind++){
320   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]);
321  }
322  return;
323
324 }
325 //------------------------------------
326 void AliAODPidHF::BayesianProbabilityTPC(AliAODTrack *track,Double_t *prob) const{
327 // bayesian PID for TPC
328
329  AliAODpidUtil pid;
330  Double_t tpcpid[AliPID::kSPECIES];
331  pid.MakeTPCPID(track,tpcpid);
332  for(Int_t ind=0;ind<AliPID::kSPECIES;ind++){
333   if(tpcpid[ind]>0.) {
334    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]);
335   }else{
336    prob[ind]=0.;
337   }
338  }
339  return;
340
341 }
342 //------------------------------------
343 void AliAODPidHF::BayesianProbabilityTOF(AliAODTrack *track,Double_t *prob) const{
344 // bayesian PID for TOF
345
346  AliAODpidUtil pid;
347  Double_t tofpid[AliPID::kSPECIES];
348  pid.MakeTOFPID(track,tofpid);
349  for(Int_t ind=0;ind<AliPID::kSPECIES;ind++){
350   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]);
351  }
352  return;
353
354 }
355 //---------------------------------
356 void AliAODPidHF::BayesianProbabilityTRD(AliAODTrack *track,Double_t *prob) const{
357 // bayesian PID for TRD
358
359  AliAODpidUtil pid;
360  Double_t trdpid[AliPID::kSPECIES];
361  pid.MakeTRDPID(track,trdpid);
362  for(Int_t ind=0;ind<AliPID::kSPECIES;ind++){
363   if(trdpid[ind]>0.) {
364    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]);
365   }else{
366    prob[ind]=0.;
367   }
368  }
369   return;
370
371  }
372 //--------------------------------
373 Bool_t AliAODPidHF::CheckStatus(AliAODTrack *track,TString detectors) const{
374
375 // Quality cuts on the tracks, detector by detector
376
377  if(detectors.Contains("ITS")){
378   if ((track->GetStatus()&AliESDtrack::kITSin)==0) return kFALSE;
379   UChar_t clumap=track->GetITSClusterMap();
380   Int_t nPointsForPid=0;
381   for(Int_t i=2; i<6; i++){
382    if(clumap&(1<<i)) ++nPointsForPid;
383   }
384   if(nPointsForPid<3) return kFALSE;// track not to be used for PID purposes
385  }
386
387  if(detectors.Contains("TPC")){
388    if ((track->GetStatus()&AliESDtrack::kTPCin )==0) return kFALSE;
389    UShort_t nTPCClus=track->GetTPCClusterMap().CountBits();
390    if (nTPCClus<70) return kFALSE;
391  }
392
393  if(detectors.Contains("TOF")){
394    if ((track->GetStatus()&AliESDtrack::kTOFout )==0)    return kFALSE;
395    if ((track->GetStatus()&AliESDtrack::kTIME )==0)     return kFALSE;
396    if ((track->GetStatus()&AliESDtrack::kTOFpid )==0)   return kFALSE;
397  }
398
399
400  if(detectors.Contains("TRD")){
401   if ((track->GetStatus()&AliESDtrack::kTRDout )==0)   return kFALSE;
402   AliAODPid *pidObj = track->GetDetPid();
403   Float_t *mom=pidObj->GetTRDmomentum();
404   Int_t ntracklets=0;
405   for(Int_t iPl=0;iPl<6;iPl++){
406    if(mom[iPl]>0.) ntracklets++;
407   }
408    if(ntracklets<4) return kFALSE;
409  }
410
411  return kTRUE;
412 }
413 //--------------------------------------------
414 Bool_t AliAODPidHF::TPCRawAsym(AliAODTrack* track,Int_t specie) const{
415 // TPC nsigma cut PID, different sigmas in different p bins
416
417   if(!CheckStatus(track,"TPC")) return kFALSE;
418   AliAODPid *pidObj = track->GetDetPid();
419   Double_t mom = pidObj->GetTPCmomentum();
420   Double_t dedx=pidObj->GetTPCsignal();
421   
422   AliTPCPIDResponse tpcResponse;
423   AliPID::EParticleType type=AliPID::EParticleType(specie);
424   Double_t nsigma = TMath::Abs(tpcResponse.GetNumberOfSigmas(mom,dedx,track->GetTPCNcls(),type)); 
425
426   if(mom<fPLimit[0] && nsigma<fnSigma[0]) return kTRUE;
427   if(mom<fPLimit[1] && mom>fPLimit[0] && nsigma<fnSigma[1]) return kTRUE;
428   if(mom>fPLimit[1] && nsigma<fnSigma[2]) return kTRUE;
429
430  return kFALSE;
431 }
432 //------------------
433 Int_t AliAODPidHF::MatchTPCTOF(AliAODTrack *track,Int_t mode,Int_t specie,Bool_t compat){
434 // combination of the PID info coming from TPC and TOF
435  if(mode==1){
436   //TOF || TPC (a la' Andrea R.)
437  // convention: 
438  // for the single detectors: -1 = kFALSE, 1 = kTRUE, 0 = compatible
439  // the method returns the sum of the response of the 2 detectors
440   if(fTPC && fTOF)  if(!CheckStatus(track,"TPC") && !CheckStatus(track,"TOF")) return 0;
441
442   
443   Int_t TPCinfo=0;
444   if(fTPC){
445   if(CheckStatus(track,"TPC")) {
446    if(fAsym) {
447     if(TPCRawAsym(track,specie)) {
448       TPCinfo=1;
449      }else{
450       TPCinfo=-1;
451      }
452    }else{
453     if(specie==2 && IsPionRaw(track,"TPC")) {
454      TPCinfo=1;
455     }else{
456      TPCinfo=-1;
457     }
458     if(specie==3 && IsKaonRaw(track,"TPC")) {
459      TPCinfo=1;
460     }else{
461      TPCinfo=-1;
462     }
463     if(specie==4 && IsProtonRaw(track,"TPC")) {
464      TPCinfo=1;
465     }else{
466      TPCinfo=-1;
467     }
468
469    }
470
471
472    if(compat && TPCinfo<0){
473     Double_t sig0tmp=fnSigma[0];
474     SetSigma(0,3.);
475     if(specie==2 && IsPionRaw(track,"TPC")) TPCinfo=0;
476     if(specie==3 && IsKaonRaw(track,"TPC")) TPCinfo=0;
477     if(specie==4 && IsProtonRaw(track,"TPC")) TPCinfo=0;
478     SetSigma(0,sig0tmp);
479    }
480
481   }
482  }
483
484  Int_t TOFinfo=0;
485  if(fTOF){
486   if(!CheckStatus(track,"TOF") && fTPC) return TPCinfo;
487
488   TOFinfo=-1;
489  
490   if(specie==2 && IsPionRaw(track,"TOF")) TOFinfo=1;
491   if(specie==3 && IsKaonRaw(track,"TOF")) TOFinfo=1;
492   if(specie==4 && IsProtonRaw(track,"TOF")) TOFinfo=1;
493
494   if(compat && TOFinfo>0){
495    Double_t ptrack=track->P();
496    if(ptrack>1.5) TOFinfo=0;
497   }
498 }
499  return TPCinfo+TOFinfo;
500 }
501  if(mode==2){
502   //TPC & TOF (a la' Yifei)
503  // convention: -1 = kFALSE, 1 = kTRUE, 0 = not identified
504   Int_t TPCinfo=0; 
505   
506   if(fTPC && CheckStatus(track,"TPC")) {
507    TPCinfo=1;
508    if(fAsym){
509     if(!TPCRawAsym(track,specie)) TPCinfo=-1;
510    }else{
511     if(specie==2 && !IsPionRaw(track,"TPC")) TPCinfo=-1;
512     if(specie==3 && !IsKaonRaw(track,"TPC")) TPCinfo=-1;
513     if(specie==4 && !IsProtonRaw(track,"TPC")) TPCinfo=-1;
514    }
515   }
516
517   Int_t TOFinfo=0;
518   if(fTOF){
519    if(fTPC && !CheckStatus(track,"TOF")) return TPCinfo;
520    TOFinfo=1;
521
522    if(specie==2 && !IsPionRaw(track,"TOF")) TOFinfo=-1;
523    if(specie==3 && !IsKaonRaw(track,"TOF")) TOFinfo=-1;
524    if(specie==4 && !IsProtonRaw(track,"TOF")) TOFinfo=-1;
525   }
526    if(TOFinfo+TPCinfo>=2) return 1;
527
528    return -1;
529
530 }
531
532  if(mode==3){
533  //TPC for p<fPLimit[0], TOF for p>=fPLimit[0] (a la' Andrea A.)
534  // convention (temporary): -1 = kFALSE, 1 = kTRUE, 0 = not identified
535   
536   if(fTPC && fTOF) if(!CheckStatus(track,"TPC") && !CheckStatus(track,"TOF")) return 0;
537
538   Double_t ptrack=track->P();
539   
540
541   Int_t TPCinfo=-1;
542
543    if(ptrack<fPLimit[0] && fTPC) {  
544     if(!CheckStatus(track,"TPC")) return 0;
545     if(fAsym) {
546      if(TPCRawAsym(track,specie)) TPCinfo=1;
547     }else{
548      if(specie==2 && IsPionRaw(track,"TPC")) TPCinfo=1;
549      if(specie==3 && IsKaonRaw(track,"TPC")) TPCinfo=1;
550      if(specie==4 && IsProtonRaw(track,"TPC")) TPCinfo=1;
551     } 
552     return TPCinfo;
553    }
554
555    Int_t TOFinfo=-1;
556    if(ptrack>=fPLimit[0] && fTOF){
557     if(!CheckStatus(track,"TOF")) return 0;
558     if(specie==2 && IsPionRaw(track,"TOF")) TOFinfo=1;
559     if(specie==3 && IsKaonRaw(track,"TOF")) TOFinfo=1;
560     if(specie==4 && IsProtonRaw(track,"TOF")) TOFinfo=1;
561     return TOFinfo;
562    }
563
564  }
565
566  return -1;
567
568 }
569 //----------------------------------   
570 Int_t AliAODPidHF::MakeRawPid(AliAODTrack *track, Int_t specie){
571  if(fMatch>0){
572   return MatchTPCTOF(track,fMatch,specie,fCompat); //clarify
573  }else{
574   if(fTPC && !fTOF && !fITS) {
575    return ApplyPidTPCRaw(track,specie);
576   }else{
577    AliError("You should enable just one detector if you don't want to match");
578    return 0;
579   }
580   if(fTOF && !fTPC && !fITS) {
581    return ApplyPidTOFRaw(track,specie);
582   }else{
583    AliError("You should enable just one detector if you don't want to match");
584    return 0;
585   }
586
587   if(fITS && !fTPC && !fTOF) {
588    return ApplyPidITSRaw(track,specie);
589   }else{
590    AliError("You should enable just one detector if you don't want to match");
591    return 0;
592   }
593  } 
594   
595 }