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