[u/mrichter/AliRoot.git] / PWG3 / vertexingHF / AliAODPidHF.cxx

/**************************************************************************
 * Copyright(c) 1998-2006, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 * *************************************************************************/

//***********************************************************
// Class AliAODPidHF
// class for PID with AliAODRecoDecayHF
// 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
//***********************************************************
#include "AliAODPidHF.h"
#include "AliAODPid.h"
#include "AliPID.h"
#include "AliTPCPIDResponse.h"
#include "AliITSPIDResponse.h"
#include "AliTOFPIDResponse.h"
#include "AliAODpidUtil.h"
#include "AliESDtrack.h"


ClassImp(AliAODPidHF)

//------------------------------
AliAODPidHF::AliAODPidHF():
  AliAODPid(),
  fnNSigma(5),
  fnSigma(),
  fTOFSigma(160.),
  fnPriors(5),
  fPriors(),
  fnPLimit(2),
  fPLimit(),
  fAsym(kFALSE),
  fTPC(kFALSE),
  fTOF(kFALSE),
  fITS(kFALSE),
  fTRD(kFALSE),
  fMatch(0),
  fCompat(kFALSE)
{
 //
 // Default constructor
 //
 fPLimit=new Double_t[fnPLimit];
 fnSigma=new Double_t[fnNSigma];
 fPriors=new Double_t[fnPriors];

 for(Int_t i=0;i<fnNSigma;i++){
  fnSigma[i]=0.;
 }
 for(Int_t i=0;i<fnPriors;i++){
  fPriors[i]=0.;
 }
 for(Int_t i=0;i<fnPLimit;i++){
  fPLimit[i]=0.;
 }

}
//----------------------
AliAODPidHF::~AliAODPidHF()
{
      // destructor
 //   if(fPLimit) delete fPLimit;
 //   if(fnSigma)  delete fnSigma;
 //   if(fPriors)  delete fPriors;
}
//------------------------
AliAODPidHF::AliAODPidHF(const AliAODPidHF& pid) :
  AliAODPid(pid),
  fnNSigma(pid.fnNSigma),
  fnSigma(pid.fnSigma),
  fTOFSigma(pid.fTOFSigma),
  fnPriors(pid.fnPriors),
  fPriors(pid.fPriors),
  fnPLimit(pid.fnPLimit),
  fPLimit(pid.fPLimit),
  fAsym(pid.fAsym),
  fTPC(pid.fTPC),
  fTOF(pid.fTOF),
  fITS(pid.fITS),
  fTRD(pid.fTRD),
  fMatch(pid.fMatch),
  fCompat(pid.fCompat)
  {
  
  for(Int_t i=0;i<5;i++){
    fPriors[i]=pid.fPriors[i];
  }
  
  }

//----------------------
Int_t AliAODPidHF::RawSignalPID(AliAODTrack *track, TString detector) const{
// raw PID for single detectors, returns the particle type with smaller sigma
   Int_t specie=-1;
   if(detector.Contains("ITS")) return ApplyPidITSRaw(track,specie);
   if(detector.Contains("TPC")) return ApplyPidTPCRaw(track,specie);
   if(detector.Contains("TOF")) return ApplyPidTOFRaw(track,specie);

  return specie;

}
//---------------------------
Bool_t AliAODPidHF::IsKaonRaw(AliAODTrack *track, TString detector) const{
// checks if the track can be a kaon, raw PID applied for single detectors
 Int_t specie=0;

 if(detector.Contains("ITS")) specie=ApplyPidITSRaw(track,3);
 if(detector.Contains("TPC")) specie=ApplyPidTPCRaw(track,3);
 if(detector.Contains("TOF")) specie=ApplyPidTOFRaw(track,3);

 if(specie==3) return kTRUE;
 return kFALSE;
}
//---------------------------
Bool_t AliAODPidHF::IsPionRaw (AliAODTrack *track, TString detector) const{
// checks if the track can be a pion, raw PID applied for single detectors

 Int_t specie=0;

 if(detector.Contains("ITS")) specie=ApplyPidITSRaw(track,2);
 if(detector.Contains("TPC")) specie=ApplyPidTPCRaw(track,2);
 if(detector.Contains("TOF")) specie=ApplyPidTOFRaw(track,2);

 if(specie==2) return kTRUE;
 return kFALSE;
}
//---------------------------
Bool_t AliAODPidHF::IsProtonRaw (AliAODTrack *track, TString detector) const{
// checks if the track can be a proton raw PID applied for single detectors

 Int_t specie=0;
 if(detector.Contains("ITS")) specie=ApplyPidITSRaw(track,4);
 if(detector.Contains("TPC")) specie=ApplyPidTPCRaw(track,4); 
 if(detector.Contains("TOF")) specie=ApplyPidTOFRaw(track,4);

 if(specie==4) return kTRUE;

 return kFALSE;
}
//--------------------------
Bool_t AliAODPidHF::IsElectronRaw(AliAODTrack *track, TString detector) const{
// checks if the track can be an electron raw PID applied for single detectors

 Int_t specie=-1;
 if(detector.Contains("ITS")) specie=ApplyPidITSRaw(track,0);
 if(detector.Contains("TPC")) specie=ApplyPidTPCRaw(track,0);
 if(detector.Contains("TOF")) specie=ApplyPidTOFRaw(track,0);

 if(specie==0) return kTRUE;

 return kFALSE;
}
//--------------------------
Int_t AliAODPidHF::ApplyPidTPCRaw(AliAODTrack *track,Int_t specie) const{
// n-sigma cut, TPC PID

  if(!CheckStatus(track,"TPC")) return 0;
  AliAODPid *pidObj = track->GetDetPid();
  
  Double_t dedx=pidObj->GetTPCsignal();
  Double_t mom = pidObj->GetTPCmomentum();
  AliTPCPIDResponse tpcResponse;
  Int_t pid=-1;
  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
   Double_t nsigmaMax=fnSigma[0];
   for(Int_t ipart=0;ipart<5;ipart++){
    AliPID::EParticleType type=AliPID::EParticleType(ipart);
    Double_t nsigma = TMath::Abs(tpcResponse.GetNumberOfSigmas(mom,dedx,track->GetTPCNcls(),type));
    if((nsigma<nsigmaMax) && (nsigma<fnSigma[0])) {
     pid=ipart;
     nsigmaMax=nsigma;
    }
   }
  }else{ // asks only for one particle specie
   AliPID::EParticleType type=AliPID::EParticleType(specie);
    Double_t nsigma = TMath::Abs(tpcResponse.GetNumberOfSigmas(mom,dedx,track->GetTPCNcls(),type));
   if (nsigma>fnSigma[0]) {
    pid=-1; 
   }else{
    pid=specie;
   }
  }

 return pid;

}
//----------------------------
Int_t AliAODPidHF::ApplyPidITSRaw(AliAODTrack *track,Int_t specie) const{
// truncated mean, ITS PID

  if(!CheckStatus(track,"ITS")) return 0;

  Double_t mom=track->P();
  AliAODPid *pidObj = track->GetDetPid();

  Double_t dedx=pidObj->GetITSsignal();
  AliITSPIDResponse itsResponse;
  Int_t pid=-1;
  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
   Double_t nsigmaMax=fnSigma[4];
   for(Int_t ipart=0;ipart<5;ipart++){
    AliPID::EParticleType type=AliPID::EParticleType(ipart);
    Double_t nsigma = TMath::Abs(itsResponse.GetNumberOfSigmas(mom,dedx,type));
    if((nsigma<nsigmaMax) && (nsigma<fnSigma[4])) {
     pid=ipart;
     nsigmaMax=nsigma;
    }
   }
  }else{ // asks only for one particle specie
   AliPID::EParticleType type=AliPID::EParticleType(specie);
    Double_t nsigma = TMath::Abs(itsResponse.GetNumberOfSigmas(mom,dedx,type));
   if (nsigma>fnSigma[4]) {
    pid=-1; 
   }else{
    pid=specie;
   }
  }
 return pid; 
}
//----------------------------
Int_t AliAODPidHF::ApplyPidTOFRaw(AliAODTrack *track,Int_t specie) const{
// n-sigma cut, TOF PID

 if(!CheckStatus(track,"TOF")) return 0;

 Double_t time[AliPID::kSPECIESN];
 AliAODPid *pidObj = track->GetDetPid();
 pidObj->GetIntegratedTimes(time);
 Double_t sigTOF=pidObj->GetTOFsignal();
// AliTOFPIDResponse tofResponse;
 Int_t pid=-1;

  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
   Double_t nsigmaMax=fTOFSigma*fnSigma[3];
   for(Int_t ipart=0;ipart<5;ipart++){
    //AliPID::EParticleType type=AliPID::EParticleType(ipart);
    //Double_t nsigma = tofResponse.GetExpectedSigma(track->P(),time[type],AliPID::ParticleMass(type));
    Double_t nsigma=TMath::Abs(sigTOF-time[ipart]);
    if((nsigma<nsigmaMax) && (nsigma<fnSigma[3]*fTOFSigma)) {
     pid=ipart;
     nsigmaMax=nsigma;
    }
   }
  }else{ // asks only for one particle specie
   //AliPID::EParticleType type=AliPID::EParticleType(specie);
   //Double_t nsigma = TMath::Abs(tofResponse.GetExpectedSigma(track->P(),time[type],AliPID::ParticleMass(type)));
    Double_t nsigma=TMath::Abs(sigTOF-time[specie]);
   if (nsigma>fnSigma[3]*fTOFSigma) {
    pid=-1; 
   }else{
    pid=specie;
   }
  }
 return pid; 

}
//------------------------------
void AliAODPidHF::CombinedProbability(AliAODTrack *track,Bool_t *type) const{
// combined PID stored inside the AOD track

 const Double_t *pid=track->PID();
 Float_t max=0.;
 Int_t k=-1;
 for (Int_t i=0; i<10; i++) {
   if (pid[i]>max) {k=i; max=pid[i];}  
 }

 if(k==2) type[0]=kTRUE;
 if(k==3) type[1]=kTRUE;
 if(k==4) type[2]=kTRUE;

 return;
}
//--------------------
void AliAODPidHF::BayesianProbability(AliAODTrack *track,Double_t *pid) const{
// bayesian PID for single detectors or combined

  if(fITS && !fTPC && !fTOF) {BayesianProbabilityITS(track,pid);return;}
  if(fTPC && !fITS && !fTOF) {BayesianProbabilityTPC(track,pid);return;}
  if(fTOF && !fITS && !fTPC) {BayesianProbabilityTOF(track,pid);return;}

    Double_t probITS[5]={1.,1.,1.,1.,1.};
    Double_t probTPC[5]={1.,1.,1.,1.,1.};
    Double_t probTOF[5]={1.,1.,1.,1.,1.};
    if(fITS) BayesianProbabilityITS(track,probITS);
    if(fTPC) BayesianProbabilityTPC(track,probTPC);
    if(fTOF) BayesianProbabilityTOF(track,probTOF);
    Double_t probTot[5]={0.,0.,0.,0.,0.};
    for(Int_t i=0;i<5;i++){
     probTot[i]=probITS[i]*probTPC[i]*probTOF[i];
    }
    for(Int_t i2=0;i2<5;i2++){
     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]);
    }

 return;

}
//------------------------------------
void AliAODPidHF::BayesianProbabilityITS(AliAODTrack *track,Double_t *prob) const{

// bayesian PID for ITS
 AliAODpidUtil pid;
 Double_t itspid[AliPID::kSPECIES];
 pid.MakeITSPID(track,itspid);
 for(Int_t ind=0;ind<AliPID::kSPECIES;ind++){
  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]);
 }
 return;

}
//------------------------------------
void AliAODPidHF::BayesianProbabilityTPC(AliAODTrack *track,Double_t *prob) const{
// bayesian PID for TPC

 AliAODpidUtil pid;
 Double_t tpcpid[AliPID::kSPECIES];
 pid.MakeTPCPID(track,tpcpid);
 for(Int_t ind=0;ind<AliPID::kSPECIES;ind++){
  if(tpcpid[ind]>0.) {
   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]);
  }else{
   prob[ind]=0.;
  }
 }
 return;

}
//------------------------------------
void AliAODPidHF::BayesianProbabilityTOF(AliAODTrack *track,Double_t *prob) const{
// bayesian PID for TOF

 AliAODpidUtil pid;
 Double_t tofpid[AliPID::kSPECIES];
 pid.MakeTOFPID(track,tofpid);
 for(Int_t ind=0;ind<AliPID::kSPECIES;ind++){
  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]);
 }
 return;

}
//---------------------------------
void AliAODPidHF::BayesianProbabilityTRD(AliAODTrack *track,Double_t *prob) const{
// bayesian PID for TRD

 AliAODpidUtil pid;
 Double_t trdpid[AliPID::kSPECIES];
 pid.MakeTRDPID(track,trdpid);
 for(Int_t ind=0;ind<AliPID::kSPECIES;ind++){
  if(trdpid[ind]>0.) {
   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]);
  }else{
   prob[ind]=0.;
  }
 }
  return;

 }
//--------------------------------
Bool_t AliAODPidHF::CheckStatus(AliAODTrack *track,TString detectors) const{

// Quality cuts on the tracks, detector by detector

 if(detectors.Contains("ITS")){
  if ((track->GetStatus()&AliESDtrack::kITSin)==0) return kFALSE;
  UChar_t clumap=track->GetITSClusterMap();
  Int_t nPointsForPid=0;
  for(Int_t i=2; i<6; i++){
   if(clumap&(1<<i)) ++nPointsForPid;
  }
  if(nPointsForPid<3) return kFALSE;// track not to be used for PID purposes
 }

 if(detectors.Contains("TPC")){
   if ((track->GetStatus()&AliESDtrack::kTPCin )==0) return kFALSE;
   UShort_t nTPCClus=track->GetTPCClusterMap().CountBits();
   if (nTPCClus<70) return kFALSE;
 }

 if(detectors.Contains("TOF")){
   if ((track->GetStatus()&AliESDtrack::kTOFout )==0)    return kFALSE;
   if ((track->GetStatus()&AliESDtrack::kTIME )==0)     return kFALSE;
   if ((track->GetStatus()&AliESDtrack::kTOFpid )==0)   return kFALSE;
 }


 if(detectors.Contains("TRD")){
  if ((track->GetStatus()&AliESDtrack::kTRDout )==0)   return kFALSE;
  AliAODPid *pidObj = track->GetDetPid();
  Float_t *mom=pidObj->GetTRDmomentum();
  Int_t ntracklets=0;
  for(Int_t iPl=0;iPl<6;iPl++){
   if(mom[iPl]>0.) ntracklets++;
  }
   if(ntracklets<4) return kFALSE;
 }

 return kTRUE;
}
//--------------------------------------------
Bool_t AliAODPidHF::TPCRawAsym(AliAODTrack* track,Int_t specie) const{
// TPC nsigma cut PID, different sigmas in different p bins

  if(!CheckStatus(track,"TPC")) return kFALSE;
  AliAODPid *pidObj = track->GetDetPid();
  Double_t mom = pidObj->GetTPCmomentum();
  Double_t dedx=pidObj->GetTPCsignal();
  
  AliTPCPIDResponse tpcResponse;
  AliPID::EParticleType type=AliPID::EParticleType(specie);
  Double_t nsigma = TMath::Abs(tpcResponse.GetNumberOfSigmas(mom,dedx,track->GetTPCNcls(),type)); 

  if(mom<fPLimit[0] && nsigma<fnSigma[0]) return kTRUE;
  if(mom<fPLimit[1] && mom>fPLimit[0] && nsigma<fnSigma[1]) return kTRUE;
  if(mom>fPLimit[1] && nsigma<fnSigma[2]) return kTRUE;

 return kFALSE;
}
//------------------
Int_t AliAODPidHF::MatchTPCTOF(AliAODTrack *track,Int_t mode,Int_t specie,Bool_t compat){
// combination of the PID info coming from TPC and TOF
 if(mode==1){
  //TOF || TPC (a la' Andrea R.)
 // convention: 
 // for the single detectors: -1 = kFALSE, 1 = kTRUE, 0 = compatible
 // the method returns the sum of the response of the 2 detectors
  if(fTPC && fTOF) {if(!CheckStatus(track,"TPC") && !CheckStatus(track,"TOF")) return 0;}

  
  Int_t tTPCinfo=0;
  if(fTPC){
  if(CheckStatus(track,"TPC")) {
   if(fAsym) {
    if(TPCRawAsym(track,specie)) {
      tTPCinfo=1;
     }else{
      tTPCinfo=-1;
     }
   }else{
    if(specie==2 && IsPionRaw(track,"TPC")) {
     tTPCinfo=1;
    }else{
     tTPCinfo=-1;
    }
    if(specie==3 && IsKaonRaw(track,"TPC")) {
     tTPCinfo=1;
    }else{
     tTPCinfo=-1;
    }
    if(specie==4 && IsProtonRaw(track,"TPC")) {
     tTPCinfo=1;
    }else{
     tTPCinfo=-1;
    }

   }


   if(compat && tTPCinfo<0){
    Double_t sig0tmp=fnSigma[0];
    SetSigma(0,3.);
    if(specie==2 && IsPionRaw(track,"TPC")) tTPCinfo=0;
    if(specie==3 && IsKaonRaw(track,"TPC")) tTPCinfo=0;
    if(specie==4 && IsProtonRaw(track,"TPC")) tTPCinfo=0;
    SetSigma(0,sig0tmp);
   }

  }
 }

 Int_t tTOFinfo=0;
 if(fTOF){
  if(!CheckStatus(track,"TOF") && fTPC) return tTPCinfo;

  tTOFinfo=-1;
 
  if(specie==2 && IsPionRaw(track,"TOF")) tTOFinfo=1;
  if(specie==3 && IsKaonRaw(track,"TOF")) tTOFinfo=1;
  if(specie==4 && IsProtonRaw(track,"TOF")) tTOFinfo=1;

  if(compat && tTOFinfo>0){
   Double_t ptrack=track->P();
   if(ptrack>1.5) tTOFinfo=0;
  }
 }
 return tTPCinfo+tTOFinfo;
}
 if(mode==2){
  //TPC & TOF (a la' Yifei)
 // convention: -1 = kFALSE, 1 = kTRUE, 0 = not identified
  Int_t tTPCinfo=0; 
  
  if(fTPC && CheckStatus(track,"TPC")) {
   tTPCinfo=1;
   if(fAsym){
    if(!TPCRawAsym(track,specie)) tTPCinfo=-1;
   }else{
    if(specie==2 && !IsPionRaw(track,"TPC")) tTPCinfo=-1;
    if(specie==3 && !IsKaonRaw(track,"TPC")) tTPCinfo=-1;
    if(specie==4 && !IsProtonRaw(track,"TPC")) tTPCinfo=-1;
   }
  }

  Int_t tTOFinfo=1;
  if(fTOF){
   if(fTPC && !CheckStatus(track,"TOF")) return tTPCinfo;

   if(specie==2 && !IsPionRaw(track,"TOF")) tTOFinfo=-1;
   if(specie==3 && !IsKaonRaw(track,"TOF")) tTOFinfo=-1;
   if(specie==4 && !IsProtonRaw(track,"TOF")) tTOFinfo=-1;
  }
  if(tTOFinfo==1 && tTPCinfo==1) return 1;

   return -1;

}

 if(mode==3){
 //TPC for p<fPLimit[0], TOF for p>=fPLimit[0] (a la' Andrea A.)
 // convention (temporary): -1 = kFALSE, 1 = kTRUE, 0 = not identified
  
  if(fTPC && fTOF) if(!CheckStatus(track,"TPC") && !CheckStatus(track,"TOF")) return 0;

  Double_t ptrack=track->P();
  

  Int_t tTPCinfo=-1;

   if(ptrack<fPLimit[0] && fTPC) {  
    if(!CheckStatus(track,"TPC")) return 0;
    if(fAsym) {
     if(TPCRawAsym(track,specie)) tTPCinfo=1;
    }else{
     if(specie==2 && IsPionRaw(track,"TPC")) tTPCinfo=1;
     if(specie==3 && IsKaonRaw(track,"TPC")) tTPCinfo=1;
     if(specie==4 && IsProtonRaw(track,"TPC")) tTPCinfo=1;
    } 
    return tTPCinfo;
   }

   Int_t tTOFinfo=-1;
   if(ptrack>=fPLimit[0] && fTOF){
    if(!CheckStatus(track,"TOF")) return 0;
    if(specie==2 && IsPionRaw(track,"TOF")) tTOFinfo=1;
    if(specie==3 && IsKaonRaw(track,"TOF")) tTOFinfo=1;
    if(specie==4 && IsProtonRaw(track,"TOF")) tTOFinfo=1;
    return tTOFinfo;
   }

 }

 return -1;

}
//----------------------------------   
Int_t AliAODPidHF::MakeRawPid(AliAODTrack *track, Int_t specie){
// general method to compute PID
 if(fMatch>0){
  return MatchTPCTOF(track,fMatch,specie,fCompat); 
 }else{
  if(fTPC && !fTOF && !fITS) {
   Int_t tTPCres=ApplyPidTPCRaw(track,specie);
   if(tTPCres==specie){return 1;}else{return tTPCres;};
  }else{
   AliError("You should enable just one detector if you don't want to match");
   return 0;
  }
  if(fTOF && !fTPC && !fITS) {
   Int_t tTOFres=ApplyPidTOFRaw(track,specie); 
   if(tTOFres==specie){return 1;}else{return tTOFres;};
  }else{
   AliError("You should enable just one detector if you don't want to match");
   return 0;
  }

  if(fITS && !fTPC && !fTOF) {
   Int_t tITSres=ApplyPidITSRaw(track,specie);
   if(tITSres==specie){return 1;}else{return tITSres;};
  }else{
   AliError("You should enable just one detector if you don't want to match");
   return 0;
  }
 } 
  
}
Commit	Line	Data
7ce8802c	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
228f3aba	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
7ce8802c	21	//***********************************************************
	22	#include "AliAODPidHF.h"
	23	#include "AliAODPid.h"
7ce8802c	24	#include "AliPID.h"
	25	#include "AliTPCPIDResponse.h"
	26	#include "AliITSPIDResponse.h"
	27	#include "AliTOFPIDResponse.h"
	28	#include "AliAODpidUtil.h"
f9e3cf8e	29	#include "AliESDtrack.h"
7ce8802c	30
	31
	32	ClassImp(AliAODPidHF)
	33
	34	//------------------------------
	35	AliAODPidHF::AliAODPidHF():
228f3aba	36	AliAODPid(),
	37	fnNSigma(5),
	38	fnSigma(),
	39	fTOFSigma(160.),
	40	fnPriors(5),
	41	fPriors(),
	42	fnPLimit(2),
	43	fPLimit(),
cdac45d3	44	fAsym(kFALSE),
	45	fTPC(kFALSE),
	46	fTOF(kFALSE),
	47	fITS(kFALSE),
	48	fTRD(kFALSE),
79f3c225	49	fMatch(0),
cdac45d3	50	fCompat(kFALSE)
7ce8802c	51	{
	52	//
	53	// Default constructor
	54	//
228f3aba	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	}
7ce8802c	68
	69	}
	70	//----------------------
	71	AliAODPidHF::~AliAODPidHF()
	72	{
	73	// destructor
228f3aba	74	// if(fPLimit) delete fPLimit;
	75	// if(fnSigma) delete fnSigma;
	76	// if(fPriors) delete fPriors;
7ce8802c	77	}
	78	//------------------------
	79	AliAODPidHF::AliAODPidHF(const AliAODPidHF& pid) :
	80	AliAODPid(pid),
228f3aba	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),
cdac45d3	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)
7ce8802c	95	{
	96
	97	for(Int_t i=0;i<5;i++){
	98	fPriors[i]=pid.fPriors[i];
	99	}
	100
	101	}
	102
	103	//----------------------
228f3aba	104	Int_t AliAODPidHF::RawSignalPID(AliAODTrack *track, TString detector) const{
228f3aba	105	// raw PID for single detectors, returns the particle type with smaller sigma
f9e3cf8e	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);
7ce8802c	110
f9e3cf8e	111	return specie;
7ce8802c	112
	113	}
	114	//---------------------------
228f3aba	115	Bool_t AliAODPidHF::IsKaonRaw(AliAODTrack *track, TString detector) const{
228f3aba	116	// checks if the track can be a kaon, raw PID applied for single detectors
7ce8802c	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	//---------------------------
228f3aba	127	Bool_t AliAODPidHF::IsPionRaw (AliAODTrack *track, TString detector) const{
228f3aba	128	// checks if the track can be a pion, raw PID applied for single detectors
7ce8802c	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	//---------------------------
228f3aba	140	Bool_t AliAODPidHF::IsProtonRaw (AliAODTrack *track, TString detector) const{
228f3aba	141	// checks if the track can be a proton raw PID applied for single detectors
7ce8802c	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	}
f9e3cf8e	152	//--------------------------
228f3aba	153	Bool_t AliAODPidHF::IsElectronRaw(AliAODTrack *track, TString detector) const{
228f3aba	154	// checks if the track can be an electron raw PID applied for single detectors
f9e3cf8e	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	//--------------------------
228f3aba	166	Int_t AliAODPidHF::ApplyPidTPCRaw(AliAODTrack *track,Int_t specie) const{
228f3aba	167	// n-sigma cut, TPC PID
7ce8802c	168
cdac45d3	169	if(!CheckStatus(track,"TPC")) return 0;
7ce8802c	170	AliAODPid *pidObj = track->GetDetPid();
	171
	172	Double_t dedx=pidObj->GetTPCsignal();
	173	Double_t mom = pidObj->GetTPCmomentum();
	174	AliTPCPIDResponse tpcResponse;
f9e3cf8e	175	Int_t pid=-1;
f9e3cf8e	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
228f3aba	177	Double_t nsigmaMax=fnSigma[0];
f9e3cf8e	178	for(Int_t ipart=0;ipart<5;ipart++){
7ce8802c	179	AliPID::EParticleType type=AliPID::EParticleType(ipart);
f9e3cf8e	180	Double_t nsigma = TMath::Abs(tpcResponse.GetNumberOfSigmas(mom,dedx,track->GetTPCNcls(),type));
228f3aba	181	if((nsigma<nsigmaMax) && (nsigma<fnSigma[0])) {
7ce8802c	182	pid=ipart;
	183	nsigmaMax=nsigma;
	184	}
	185	}
	186	}else{ // asks only for one particle specie
	187	AliPID::EParticleType type=AliPID::EParticleType(specie);
f9e3cf8e	188	Double_t nsigma = TMath::Abs(tpcResponse.GetNumberOfSigmas(mom,dedx,track->GetTPCNcls(),type));
228f3aba	189	if (nsigma>fnSigma[0]) {
f9e3cf8e	190	pid=-1;
7ce8802c	191	}else{
79f3c225	192	pid=specie;
7ce8802c	193	}
	194	}
	195
	196	return pid;
	197
	198	}
	199	//----------------------------
228f3aba	200	Int_t AliAODPidHF::ApplyPidITSRaw(AliAODTrack *track,Int_t specie) const{
228f3aba	201	// truncated mean, ITS PID
f9e3cf8e	202
cdac45d3	203	if(!CheckStatus(track,"ITS")) return 0;
f9e3cf8e	204
7ce8802c	205	Double_t mom=track->P();
	206	AliAODPid *pidObj = track->GetDetPid();
	207
	208	Double_t dedx=pidObj->GetITSsignal();
	209	AliITSPIDResponse itsResponse;
f9e3cf8e	210	Int_t pid=-1;
f9e3cf8e	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
228f3aba	212	Double_t nsigmaMax=fnSigma[4];
f9e3cf8e	213	for(Int_t ipart=0;ipart<5;ipart++){
7ce8802c	214	AliPID::EParticleType type=AliPID::EParticleType(ipart);
7ce8802c	215	Double_t nsigma = TMath::Abs(itsResponse.GetNumberOfSigmas(mom,dedx,type));
228f3aba	216	if((nsigma<nsigmaMax) && (nsigma<fnSigma[4])) {
7ce8802c	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));
228f3aba	224	if (nsigma>fnSigma[4]) {
f9e3cf8e	225	pid=-1;
7ce8802c	226	}else{
79f3c225	227	pid=specie;
7ce8802c	228	}
	229	}
	230	return pid;
	231	}
	232	//----------------------------
228f3aba	233	Int_t AliAODPidHF::ApplyPidTOFRaw(AliAODTrack *track,Int_t specie) const{
228f3aba	234	// n-sigma cut, TOF PID
f9e3cf8e	235
cdac45d3	236	if(!CheckStatus(track,"TOF")) return 0;
f9e3cf8e	237
7ce8802c	238	Double_t time[AliPID::kSPECIESN];
	239	AliAODPid *pidObj = track->GetDetPid();
	240	pidObj->GetIntegratedTimes(time);
228f3aba	241	Double_t sigTOF=pidObj->GetTOFsignal();
228f3aba	242	// AliTOFPIDResponse tofResponse;
f9e3cf8e	243	Int_t pid=-1;
7ce8802c	244
f9e3cf8e	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
228f3aba	246	Double_t nsigmaMax=fTOFSigma*fnSigma[3];
f9e3cf8e	247	for(Int_t ipart=0;ipart<5;ipart++){
228f3aba	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)) {
7ce8802c	252	pid=ipart;
	253	nsigmaMax=nsigma;
	254	}
	255	}
	256	}else{ // asks only for one particle specie
228f3aba	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) {
f9e3cf8e	261	pid=-1;
7ce8802c	262	}else{
79f3c225	263	pid=specie;
7ce8802c	264	}
	265	}
	266	return pid;
	267
	268	}
	269	//------------------------------
228f3aba	270	void AliAODPidHF::CombinedProbability(AliAODTrack track,Bool_t type) const{
228f3aba	271	// combined PID stored inside the AOD track
7ce8802c	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	//--------------------
cdac45d3	287	void AliAODPidHF::BayesianProbability(AliAODTrack track,Double_t pid) const{
228f3aba	288	// bayesian PID for single detectors or combined
7ce8802c	289
cdac45d3	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);
7ce8802c	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	}
7ce8802c	307
	308	return;
	309
	310	}
	311	//------------------------------------
228f3aba	312	void AliAODPidHF::BayesianProbabilityITS(AliAODTrack track,Double_t prob) const{
7ce8802c	313
228f3aba	314	// bayesian PID for ITS
7ce8802c	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	//------------------------------------
228f3aba	325	void AliAODPidHF::BayesianProbabilityTPC(AliAODTrack track,Double_t prob) const{
228f3aba	326	// bayesian PID for TPC
7ce8802c	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	//------------------------------------
228f3aba	342	void AliAODPidHF::BayesianProbabilityTOF(AliAODTrack track,Double_t prob) const{
228f3aba	343	// bayesian PID for TOF
7ce8802c	344
	345	AliAODpidUtil pid;
	346	Double_t tofpid[AliPID::kSPECIES];
228f3aba	347	pid.MakeTOFPID(track,tofpid);
7ce8802c	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	}
f9e3cf8e	354	//---------------------------------
228f3aba	355	void AliAODPidHF::BayesianProbabilityTRD(AliAODTrack track,Double_t prob) const{
228f3aba	356	// bayesian PID for TRD
f9e3cf8e	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	//--------------------------------
228f3aba	372	Bool_t AliAODPidHF::CheckStatus(AliAODTrack *track,TString detectors) const{
f9e3cf8e	373
228f3aba	374	// Quality cuts on the tracks, detector by detector
f9e3cf8e	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	}
228f3aba	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.)
cdac45d3	436	// convention:
228f3aba	437	// for the single detectors: -1 = kFALSE, 1 = kTRUE, 0 = compatible
228f3aba	438	// the method returns the sum of the response of the 2 detectors
79f3c225	439	if(fTPC && fTOF) {if(!CheckStatus(track,"TPC") && !CheckStatus(track,"TOF")) return 0;}
228f3aba	440
cdac45d3	441
1cb0f658	442	Int_t tTPCinfo=0;
cdac45d3	443	if(fTPC){
228f3aba	444	if(CheckStatus(track,"TPC")) {
228f3aba	445	if(fAsym) {
3779f50a	446	if(TPCRawAsym(track,specie)) {
1cb0f658	447	tTPCinfo=1;
3779f50a	448	}else{
1cb0f658	449	tTPCinfo=-1;
3779f50a	450	}
228f3aba	451	}else{
3779f50a	452	if(specie==2 && IsPionRaw(track,"TPC")) {
1cb0f658	453	tTPCinfo=1;
3779f50a	454	}else{
1cb0f658	455	tTPCinfo=-1;
3779f50a	456	}
3779f50a	457	if(specie==3 && IsKaonRaw(track,"TPC")) {
1cb0f658	458	tTPCinfo=1;
3779f50a	459	}else{
1cb0f658	460	tTPCinfo=-1;
3779f50a	461	}
3779f50a	462	if(specie==4 && IsProtonRaw(track,"TPC")) {
1cb0f658	463	tTPCinfo=1;
3779f50a	464	}else{
1cb0f658	465	tTPCinfo=-1;
3779f50a	466	}
3779f50a	467
228f3aba	468	}
	469
	470
1cb0f658	471	if(compat && tTPCinfo<0){
cdac45d3	472	Double_t sig0tmp=fnSigma[0];
cdac45d3	473	SetSigma(0,3.);
1cb0f658	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;
cdac45d3	477	SetSigma(0,sig0tmp);
cdac45d3	478	}
228f3aba	479
cdac45d3	480	}
228f3aba	481	}
228f3aba	482
1cb0f658	483	Int_t tTOFinfo=0;
cdac45d3	484	if(fTOF){
1cb0f658	485	if(!CheckStatus(track,"TOF") && fTPC) return tTPCinfo;
228f3aba	486
1cb0f658	487	tTOFinfo=-1;
228f3aba	488
1cb0f658	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;
228f3aba	492
1cb0f658	493	if(compat && tTOFinfo>0){
cdac45d3	494	Double_t ptrack=track->P();
1cb0f658	495	if(ptrack>1.5) tTOFinfo=0;
cdac45d3	496	}
79f3c225	497	}
1cb0f658	498	return tTPCinfo+tTOFinfo;
cdac45d3	499	}
228f3aba	500	if(mode==2){
228f3aba	501	//TPC & TOF (a la' Yifei)
cdac45d3	502	// convention: -1 = kFALSE, 1 = kTRUE, 0 = not identified
1cb0f658	503	Int_t tTPCinfo=0;
cdac45d3	504
cdac45d3	505	if(fTPC && CheckStatus(track,"TPC")) {
1cb0f658	506	tTPCinfo=1;
228f3aba	507	if(fAsym){
1cb0f658	508	if(!TPCRawAsym(track,specie)) tTPCinfo=-1;
228f3aba	509	}else{
1cb0f658	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;
228f3aba	513	}
	514	}
	515
1cb0f658	516	Int_t tTOFinfo=1;
cdac45d3	517	if(fTOF){
1cb0f658	518	if(fTPC && !CheckStatus(track,"TOF")) return tTPCinfo;
228f3aba	519
1cb0f658	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;
cdac45d3	523	}
1cb0f658	524	if(tTOFinfo==1 && tTPCinfo==1) return 1;
228f3aba	525
228f3aba	526	return -1;
228f3aba	527
cdac45d3	528	}
228f3aba	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
cdac45d3	534	if(fTPC && fTOF) if(!CheckStatus(track,"TPC") && !CheckStatus(track,"TOF")) return 0;
228f3aba	535
	536	Double_t ptrack=track->P();
	537
	538
1cb0f658	539	Int_t tTPCinfo=-1;
228f3aba	540
cdac45d3	541	if(ptrack<fPLimit[0] && fTPC) {
228f3aba	542	if(!CheckStatus(track,"TPC")) return 0;
228f3aba	543	if(fAsym) {
1cb0f658	544	if(TPCRawAsym(track,specie)) tTPCinfo=1;
228f3aba	545	}else{
1cb0f658	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;
228f3aba	549	}
1cb0f658	550	return tTPCinfo;
228f3aba	551	}
228f3aba	552
1cb0f658	553	Int_t tTOFinfo=-1;
cdac45d3	554	if(ptrack>=fPLimit[0] && fTOF){
228f3aba	555	if(!CheckStatus(track,"TOF")) return 0;
1cb0f658	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;
228f3aba	560	}
	561
	562	}
	563
	564	return -1;
cdac45d3	565
	566	}
	567	//----------------------------------
	568	Int_t AliAODPidHF::MakeRawPid(AliAODTrack *track, Int_t specie){
1cb0f658	569	// general method to compute PID
cdac45d3	570	if(fMatch>0){
1cb0f658	571	return MatchTPCTOF(track,fMatch,specie,fCompat);
cdac45d3	572	}else{
cdac45d3	573	if(fTPC && !fTOF && !fITS) {
1cb0f658	574	Int_t tTPCres=ApplyPidTPCRaw(track,specie);
1cb0f658	575	if(tTPCres==specie){return 1;}else{return tTPCres;};
cdac45d3	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) {
1cb0f658	581	Int_t tTOFres=ApplyPidTOFRaw(track,specie);
1cb0f658	582	if(tTOFres==specie){return 1;}else{return tTOFres;};
cdac45d3	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) {
1cb0f658	589	Int_t tITSres=ApplyPidITSRaw(track,specie);
1cb0f658	590	if(tITSres==specie){return 1;}else{return tITSres;};
cdac45d3	591	}else{
	592	AliError("You should enable just one detector if you don't want to match");
	593	return 0;
	594	}
	595	}
	596
228f3aba	597	}