X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=PWG3%2FvertexingHF%2FAliAODPidHF.cxx;h=27ce078c23dba4ab22f3e829b80bc687cf902183;hb=40bce8523a7d8eef78bc9186bbbdf209d0fc0907;hp=9012c7a754fde452a6b9c0324c31965d6eeb71bc;hpb=53c434400b247310144a33be85c49f6f2e6e22b2;p=u%2Fmrichter%2FAliRoot.git

diff --git a/PWG3/vertexingHF/AliAODPidHF.cxx b/PWG3/vertexingHF/AliAODPidHF.cxx
index 9012c7a754f..27ce078c23d 100644
--- a/PWG3/vertexingHF/AliAODPidHF.cxx
+++ b/PWG3/vertexingHF/AliAODPidHF.cxx
@@ -21,7 +21,6 @@
 //***********************************************************
 #include "AliAODPidHF.h"
 #include "AliAODPid.h"
-#include "AliAODTrack.h"
 #include "AliPID.h"
 #include "AliTPCPIDResponse.h"
 #include "AliITSPIDResponse.h"
@@ -42,7 +41,14 @@ AliAODPidHF::AliAODPidHF():
   fPriors(),
   fnPLimit(2),
   fPLimit(),
-  fAsym(kFALSE)
+  fAsym(kFALSE),
+  fTPC(kFALSE),
+  fTOF(kFALSE),
+  fITS(kFALSE),
+  fTRD(kFALSE),
+  fMatch(0),
+  fCompat(kFALSE),
+  fMC(kFALSE)
 {
  //
  // Default constructor
@@ -80,7 +86,14 @@ AliAODPidHF::AliAODPidHF(const AliAODPidHF& pid) :
   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++){
@@ -155,7 +168,7 @@ Bool_t AliAODPidHF::IsElectronRaw(AliAODTrack *track, TString detector) const{
 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();
@@ -189,19 +202,28 @@ Int_t AliAODPidHF::ApplyPidTPCRaw(AliAODTrack *track,Int_t specie) const{
 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;
@@ -222,7 +244,7 @@ Int_t AliAODPidHF::ApplyPidITSRaw(AliAODTrack *track,Int_t specie) const{
 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();
@@ -273,20 +295,19 @@ void AliAODPidHF::CombinedProbability(AliAODTrack *track,Bool_t *type) const{
  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];
@@ -294,7 +315,6 @@ void AliAODPidHF::BayesianProbability(AliAODTrack *track,TString detectors,Doubl
     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;
 
@@ -307,7 +327,11 @@ void AliAODPidHF::BayesianProbabilityITS(AliAODTrack *track,Double_t *prob) cons
  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;
 
@@ -320,12 +344,12 @@ void AliAODPidHF::BayesianProbabilityTPC(AliAODTrack *track,Double_t *prob) cons
  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;
 
 }
@@ -337,8 +361,12 @@ void AliAODPidHF::BayesianProbabilityTOF(AliAODTrack *track,Double_t *prob) cons
  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;
 
 }
@@ -350,12 +378,12 @@ void AliAODPidHF::BayesianProbabilityTRD(AliAODTrack *track,Double_t *prob) cons
  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;
 
  }
@@ -371,7 +399,7 @@ Bool_t AliAODPidHF::CheckStatus(AliAODTrack *track,TString detectors) const{
   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")){
@@ -424,108 +452,194 @@ Int_t AliAODPidHF::MatchTPCTOF(AliAODTrack *track,Int_t mode,Int_t specie,Bool_t
 // 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;
+  }
+ } 
+  
 }
-