//***********************************************************
#include "AliAODPidHF.h"
#include "AliAODPid.h"
-#include "AliAODTrack.h"
#include "AliPID.h"
#include "AliTPCPIDResponse.h"
#include "AliITSPIDResponse.h"
fPriors(),
fnPLimit(2),
fPLimit(),
- fAsym(kFALSE)
+ fAsym(kFALSE),
+ fTPC(kFALSE),
+ fTOF(kFALSE),
+ fITS(kFALSE),
+ fTRD(kFALSE),
+ fMatch(0),
+ fCompat(kFALSE),
+ fMC(kFALSE)
{
//
// Default constructor
fPriors(pid.fPriors),
fnPLimit(pid.fnPLimit),
fPLimit(pid.fPLimit),
- fAsym(pid.fAsym)
+ fAsym(pid.fAsym),
+ fTPC(pid.fTPC),
+ fTOF(pid.fTOF),
+ fITS(pid.fITS),
+ fTRD(pid.fTRD),
+ fMatch(pid.fMatch),
+ fCompat(pid.fCompat),
+ fMC(kFALSE)
{
for(Int_t i=0;i<5;i++){
Int_t AliAODPidHF::ApplyPidTPCRaw(AliAODTrack *track,Int_t specie) const{
// n-sigma cut, TPC PID
- if(!CheckStatus(track,"TPC")) return -1;
+ if(!CheckStatus(track,"TPC")) return 0;
AliAODPid *pidObj = track->GetDetPid();
Double_t dedx=pidObj->GetTPCsignal();
Int_t AliAODPidHF::ApplyPidITSRaw(AliAODTrack *track,Int_t specie) const{
// truncated mean, ITS PID
- if(!CheckStatus(track,"ITS")) return -1;
+ if(!CheckStatus(track,"ITS")) return 0;
Double_t mom=track->P();
AliAODPid *pidObj = track->GetDetPid();
Double_t dedx=pidObj->GetITSsignal();
+ UChar_t clumap=track->GetITSClusterMap();
+ Int_t nPointsForPid=0;
+ for(Int_t i=2; i<6; i++){
+ if(clumap&(1<<i)) ++nPointsForPid;
+ }
+
+ Bool_t isSA=kTRUE;
+ if(track->GetStatus() & AliESDtrack::kTPCin) isSA = kFALSE;
+
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));
+ Double_t nsigma = TMath::Abs(itsResponse.GetNumberOfSigmas(mom,dedx,type,nPointsForPid,isSA));
if((nsigma<nsigmaMax) && (nsigma<fnSigma[4])) {
pid=ipart;
nsigmaMax=nsigma;
Int_t AliAODPidHF::ApplyPidTOFRaw(AliAODTrack *track,Int_t specie) const{
// n-sigma cut, TOF PID
- if(!CheckStatus(track,"TOF")) return -1;
+ if(!CheckStatus(track,"TOF")) return 0;
Double_t time[AliPID::kSPECIESN];
AliAODPid *pidObj = track->GetDetPid();
return;
}
//--------------------
-void AliAODPidHF::BayesianProbability(AliAODTrack *track,TString detectors,Double_t *pid) const{
+void AliAODPidHF::BayesianProbability(AliAODTrack *track,Double_t *pid) const{
// bayesian PID for single detectors or combined
- if(detectors.Contains("ITS")) {BayesianProbabilityITS(track,pid);return;}
- if(detectors.Contains("TPC")) {BayesianProbabilityTPC(track,pid);return;}
- if(detectors.Contains("TOF")) {BayesianProbabilityTOF(track,pid);return;}
-
- if(detectors.Contains("All")) {
- Double_t probITS[5]={0.,0.,0.,0.,0.};
- Double_t probTPC[5]={0.,0.,0.,0.,0.};
- Double_t probTOF[5]={0.,0.,0.,0.,0.};
- BayesianProbabilityITS(track,probITS);
- BayesianProbabilityTPC(track,probTPC);
- BayesianProbabilityTOF(track,probTOF);
+ 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;
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]);
+ if(fTOF || fTPC || fTRD){
+ prob[ind]=itspid[ind];
+ }else{
+ 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;
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]);
+ if(fTOF || fITS || fTRD){
+ prob[ind]=tpcpid[ind];
}else{
- prob[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]);
}
+}
return;
}
Double_t tofpid[AliPID::kSPECIES];
pid.MakeTOFPID(track,tofpid);
for(Int_t ind=0;ind<AliPID::kSPECIES;ind++){
+ if(fTPC || fITS || fTRD){
+ prob[ind]=tofpid[ind];
+ }else{
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;
}
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]);
+ if(fTPC || fITS || fTOF){
+ prob[ind]=trdpid[ind];
}else{
- prob[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]);
}
+}
return;
}
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(nPointsForPid<3) return kFALSE;
}
if(detectors.Contains("TPC")){
// combination of the PID info coming from TPC and TOF
if(mode==1){
//TOF || TPC (a la' Andrea R.)
- // convention (temporary):
+ // convention:
// for the single detectors: -1 = kFALSE, 1 = kTRUE, 0 = compatible
// the method returns the sum of the response of the 2 detectors
- if(!CheckStatus(track,"TPC") && !CheckStatus(track,"TOF")) return 0;
+ if(fTPC && fTOF) {if(!CheckStatus(track,"TPC") && !CheckStatus(track,"TOF")) return 0;}
- Int_t TPCinfo=0;
+
+ Int_t tTPCinfo=0;
+ if(fTPC){
if(CheckStatus(track,"TPC")) {
if(fAsym) {
- if(TPCRawAsym(track,specie)) TPCinfo=1;
+ if(TPCRawAsym(track,specie)) {
+ tTPCinfo=1;
+ }else{
+ tTPCinfo=-1;
+ }
}else{
- if(specie==2 && IsPionRaw(track,"TPC")) TPCinfo=1;
- if(specie==3 && IsKaonRaw(track,"TPC")) TPCinfo=1;
- if(specie==4 && IsProtonRaw(track,"TPC")) TPCinfo=1;
+ 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 && TPCinfo<0){
- Double_t sig0tmp=fnSigma[0];
- SetSigma(0,3.);
- if(specie==2 && IsPionRaw(track,"TPC")) TPCinfo=0;
- if(specie==3 && IsKaonRaw(track,"TPC")) TPCinfo=0;
- if(specie==4 && IsProtonRaw(track,"TPC")) TPCinfo=0;
- SetSigma(0,sig0tmp);
- }
+ 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);
+ }
+ }
}
- if(!CheckStatus(track,"TOF")) return TPCinfo;
+ Int_t tTOFinfo=0;
+ if(fTOF){
+ if(!CheckStatus(track,"TOF") && fTPC) return tTPCinfo;
- Int_t TOFinfo=-1;
+ tTOFinfo=-1;
- if(specie==2 && IsPionRaw(track,"TOF")) TOFinfo=1;
- if(specie==3 && IsKaonRaw(track,"TOF")) TOFinfo=1;
- if(specie==4 && IsProtonRaw(track,"TOF")) TOFinfo=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 && TOFinfo>0){
- Double_t ptrack=track->P();
- if(ptrack>1.5) TOFinfo=0;
+ if(compat && tTOFinfo>0){
+ Double_t ptrack=track->P();
+ if(ptrack>1.5) tTOFinfo=0;
+ }
}
- return TPCinfo+TOFinfo;
+ if(tTPCinfo+tTOFinfo==0 && fITS){
+ if(!CheckStatus(track,"ITS")) return tTPCinfo+tTOFinfo;
+ Int_t tITSinfo = -1;
+ if(specie==2 && IsPionRaw(track,"TOF")) tITSinfo=1;
+ if(specie==3 && IsKaonRaw(track,"TOF")) tITSinfo=1;
+ if(specie==4 && IsProtonRaw(track,"TOF")) tITSinfo=1;
+ return tITSinfo;
}
+
+ return tTPCinfo+tTOFinfo;
+}
if(mode==2){
//TPC & TOF (a la' Yifei)
- // convention (temporary): -1 = kFALSE, 1 = kTRUE, 0 = not identified
- Int_t TPCinfo=1;
- if(CheckStatus(track,"TPC")) {
+ // 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)) TPCinfo=-1;
+ if(!TPCRawAsym(track,specie)) tTPCinfo=-1;
}else{
- if(specie==2 && !IsPionRaw(track,"TPC")) TPCinfo=-1;
- if(specie==3 && !IsKaonRaw(track,"TPC")) TPCinfo=-1;
- if(specie==4 && !IsProtonRaw(track,"TPC")) TPCinfo=-1;
+ 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 TOFinfo=1;
- if(!CheckStatus(track,"TOF")) return TPCinfo;
+ Int_t tTOFinfo=1;
+ if(fTOF){
+ if(fTPC && !CheckStatus(track,"TOF")) return tTPCinfo;
- if(specie==2 && !IsPionRaw(track,"TOF")) TOFinfo=-1;
- if(specie==3 && !IsKaonRaw(track,"TOF")) TOFinfo=-1;
- if(specie==4 && !IsProtonRaw(track,"TOF")) TOFinfo=-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(TOFinfo==1 && TPCinfo==1) return 1;
- return -1;
+ if(tTOFinfo==1 && tTPCinfo==1) return 1;
+ if(tTPCinfo+tTOFinfo==0 && fITS){
+ if(!CheckStatus(track,"ITS")) return tTPCinfo+tTOFinfo;
+ Int_t tITSinfo = -1;
+ if(specie==2 && IsPionRaw(track,"TOF")) tITSinfo=1;
+ if(specie==3 && IsKaonRaw(track,"TOF")) tITSinfo=1;
+ if(specie==4 && IsProtonRaw(track,"TOF")) tITSinfo=1;
+ return tITSinfo;
}
+ 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(!CheckStatus(track,"TPC") && !CheckStatus(track,"TOF")) return 0;
+ if(fTPC && fTOF) if(!CheckStatus(track,"TPC") && !CheckStatus(track,"TOF")) return 0;
Double_t ptrack=track->P();
- Int_t TPCinfo=-1;
+ Int_t tTPCinfo=-1;
- if(ptrack<fPLimit[0]) {
+ if(ptrack>=fPLimit[0] && ptrack<fPLimit[1] && fTPC) {
if(!CheckStatus(track,"TPC")) return 0;
if(fAsym) {
- if(TPCRawAsym(track,specie)) TPCinfo=1;
+ if(TPCRawAsym(track,specie)) tTPCinfo=1;
}else{
- if(specie==2 && IsPionRaw(track,"TPC")) TPCinfo=1;
- if(specie==3 && IsKaonRaw(track,"TPC")) TPCinfo=1;
- if(specie==4 && IsProtonRaw(track,"TPC")) TPCinfo=1;
+ 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 TPCinfo;
+ return tTPCinfo;
}
- Int_t TOFinfo=-1;
- if(ptrack>=fPLimit[0]){
+ Int_t tTOFinfo=-1;
+ if(ptrack>=fPLimit[1] && fTOF){
if(!CheckStatus(track,"TOF")) return 0;
- if(specie==2 && IsPionRaw(track,"TOF")) TOFinfo=1;
- if(specie==3 && IsKaonRaw(track,"TOF")) TOFinfo=1;
- if(specie==4 && IsProtonRaw(track,"TOF")) TOFinfo=1;
- return TOFinfo;
+ 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;
+ }
+
+ Int_t tITSinfo=-1;
+ if(ptrack<fPLimit[0] && fITS){
+ if(!CheckStatus(track,"ITS")) return 0;
+ if(specie==2 && IsPionRaw(track,"ITS")) tITSinfo=1;
+ if(specie==3 && IsKaonRaw(track,"ITS")) tITSinfo=1;
+ if(specie==4 && IsProtonRaw(track,"ITS")) tITSinfo=1;
+ return tITSinfo;
}
}
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;
+ }
+ }
+
}
-
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff