ALIROOT-5633 o Increase ClassDef o Speed up code

diff --git a/STEER/STEERBase/AliITSPIDResponse.cxx b/STEER/STEERBase/AliITSPIDResponse.cxx
index 1eb304b271c764ec9db6ba51129e53b978aed3be..3292029b6d0d0a41cc72227602afa92380bb4958 100644 (file)
--- a/STEER/STEERBase/AliITSPIDResponse.cxx
+++ b/STEER/STEERBase/AliITSPIDResponse.cxx
@@ -158,6 +158,32 @@ Double_t AliITSPIDResponse::BetheAleph(Double_t p, Double_t mass) const {
   return bb;
 }
 
+//_________________________________________________________________________
+Double_t AliITSPIDResponse::Bethe(Double_t bg, const Double_t * const par, Bool_t isNuclei) const
+{
+
+  const Double_t beta = bg/TMath::Sqrt(1.+ bg*bg);
+  const Double_t gamma=bg/beta;
+  Double_t bb=1.;
+
+  Double_t eff=1.0;
+  if(bg<par[2])
+    eff=(bg-par[3])*(bg-par[3])+par[4];
+  else
+    eff=(par[2]-par[3])*(par[2]-par[3])+par[4];
+  
+  if(gamma>=0. && beta>0.){
+    if(isNuclei){
+      //Parameterization for deuteron between 0.4 - 1.5 GeV/c; triton between 0.58 - 1.65 GeV/c
+      bb=par[0] + par[1]/bg + par[2]/(bg*bg) + par[3]/(bg*bg*bg) + par[4]/(bg*bg*bg*bg);
+    }else{ //Parameterization for pion, kaon, proton, electron
+      bb=(par[1]+2.0*TMath::Log(gamma)-beta*beta)*(par[0]/(beta*beta))*eff;
+    }
+  }
+  
+  return bb;
+}
+
 //_________________________________________________________________________
 Double_t AliITSPIDResponse::Bethe(Double_t p, Double_t mass, Bool_t isSA, Bool_t isNuclei) const {
 
@@ -171,46 +197,66 @@ Double_t AliITSPIDResponse::Bethe(Double_t p, Double_t mass, Bool_t isSA, Bool_t
   // fBBtri --> parameters for triton
 
 
-  Double_t bg=p/mass;
-  Double_t beta = bg/TMath::Sqrt(1.+ bg*bg);
-  Double_t gamma=bg/beta;
-  Double_t bb=1.;
-  
-  Double_t par[5];
+  const Double_t bg=p/mass;
+
+  //NOTE
+  //NOTE: if changes are made here, please also check the alternative function below
+  //NOTE
+  const Double_t *par=fBBtpcits;
   if(isSA){
     if(TMath::AreEqualAbs(mass,AliPID::ParticleMass(0),0.00001)){
       //if is an electron use a specific BB parameterization
       //To be used only between 100 and 160 MeV/c
-      for(Int_t ip=0; ip<5;ip++) par[ip]=fBBsaElectron[ip];
+      par=fBBsaElectron;
     }else{
-      for(Int_t ip=0; ip<5;ip++) par[ip]=fBBsa[ip];
+      par=fBBsa;
     }
   }else{
     if(isNuclei){
-      if(TMath::AreEqualAbs(mass,AliPID::ParticleMass(5),0.002)) for(Int_t ip=0; ip<5;ip++) par[ip]=fBBdeu[ip];
-      if(TMath::AreEqualAbs(mass,AliPID::ParticleMass(6),0.001)) for(Int_t ip=0; ip<5;ip++) par[ip]=fBBtri[ip];
-    }
-    else{
-      for(Int_t ip=0; ip<5;ip++) par[ip]=fBBtpcits[ip];
+      if(TMath::AreEqualAbs(mass,AliPID::ParticleMass(5),0.002)) par=fBBdeu;
+      if(TMath::AreEqualAbs(mass,AliPID::ParticleMass(6),0.001)) par=fBBtri;
     }
   }
 
-  Double_t eff=1.0;
-  if(bg<par[2])
-    eff=(bg-par[3])*(bg-par[3])+par[4];
-  else
-    eff=(par[2]-par[3])*(par[2]-par[3])+par[4];
+  return Bethe(bg, par, isNuclei);
+}
+
+//_________________________________________________________________________
+Double_t AliITSPIDResponse::Bethe(Double_t p, AliPID::EParticleType species, Bool_t isSA) const
+{
+  //
+  // Aliternative bethe function assuming a particle type not a mass
+  // should be slightly faster
+  //
+
+  const Double_t m=AliPID::ParticleMassZ(species);
+  const Double_t bg=p/m;
+  Bool_t isNuclei=kFALSE;
   
-  if(gamma>=0. && beta>0.){
-    if(isNuclei){
-      //Parameterization for deuteron between 0.4 - 1.5 GeV/c; triton between 0.58 - 1.65 GeV/c
-      bb=par[0] + par[1]/bg + par[2]/(bg*bg) + par[3]/(bg*bg*bg) + par[4]/(bg*bg*bg*bg);
-    }else{ //Parameterization for pion, kaon, proton, electron
-      bb=(par[1]+2.0*TMath::Log(gamma)-beta*beta)*(par[0]/(beta*beta))*eff;
+  //NOTE
+  //NOTE: if changes are made here, please also check the alternative function above
+  //NOTE
+  const Double_t *par=fBBtpcits;
+  if(isSA){
+    if(species == AliPID::kElectron){
+      //if is an electron use a specific BB parameterization
+      //To be used only between 100 and 160 MeV/c
+      par=fBBsaElectron;
+    }else{
+      par=fBBsa;
+    }
+  }else{
+    if(species == AliPID::kDeuteron) {
+      par=fBBdeu;
+      isNuclei=kTRUE;
+    }
+    if(species == AliPID::kTriton  ) {
+      par=fBBtri;
+      isNuclei=kTRUE;
     }
   }
 
-  return bb;
+  return Bethe(bg, par, isNuclei);
 }
 
 //_________________________________________________________________________
@@ -264,27 +310,25 @@ Double_t AliITSPIDResponse::GetResolution(Double_t bethe,
   // Double_t p is used for the resolution of deuteron and triton, because they are function of the momentum
   // default -> Double_t p=0.
 
-  Float_t r;
-  Float_t c=1.; //this is a correction factor used for the nuclei resolution, while for pion/kaon/proton/electron is 1.
-  Double_t par[3];
+  Float_t r=0.f;
+  Double_t c=1.; //this is a correction factor used for the nuclei resolution, while for pion/kaon/proton/electron is 1.
 
   if(isSA) r=fResolSA[nPtsForPid];
   else{
-    if(AliPID::ParticleMass(type)>=AliPID::ParticleMass(5)){ //if mass >= mass_deu -->resolution for nuclei is selected
-      if(type==AliPID::kDeuteron){
-       if(nPtsForPid==3) for(Int_t j=0; j<3; j++) par[j] = fResolTPCITSDeu3[j];
-       if(nPtsForPid==4) for(Int_t j=0; j<3; j++) par[j] = fResolTPCITSDeu4[j];
-       c=par[2];
-      }
-      if(type==AliPID::kTriton){
-       if(nPtsForPid==3) for(Int_t j=0; j<3; j++) par[j] = fResolTPCITSTri3[j];
-       if(nPtsForPid==4) for(Int_t j=0; j<3; j++) par[j] = fResolTPCITSTri4[j];
-       c=par[2];
-      }
-
+    const Double_t *par=0x0;
+    if(type==AliPID::kDeuteron){
+      if(nPtsForPid==3) par = fResolTPCITSDeu3;
+      if(nPtsForPid==4) par = fResolTPCITSDeu4;
+      c=par[2];
+      r=par[0]+par[1]*p;
+    } else if(type==AliPID::kTriton){
+      if(nPtsForPid==3) par = fResolTPCITSTri3;
+      if(nPtsForPid==4) par = fResolTPCITSTri4;
+      c=par[2];
       r=par[0]+par[1]*p;
+    } else{
+      r=fResolTPCITS[nPtsForPid];
     }
-    else r=fResolTPCITS[nPtsForPid];
   }
 
   return r*bethe*c;

diff --git a/STEER/STEERBase/AliITSPIDResponse.h b/STEER/STEERBase/AliITSPIDResponse.h
index f9b76bed5c81ecbcb3131ba24bce30ddc6521884..c18a3840300a95b682436c4d679c890d7e92b838 100644 (file)
--- a/STEER/STEERBase/AliITSPIDResponse.h
+++ b/STEER/STEERBase/AliITSPIDResponse.h
@@ -44,6 +44,7 @@ public:
 
  Double_t BetheAleph(Double_t p,Double_t mass) const;
  Double_t Bethe(Double_t p, Double_t mass, Bool_t isSA=kFALSE,Bool_t isNuclei=kFALSE) const;
+ Double_t Bethe(Double_t p, AliPID::EParticleType species, Bool_t isSA=kFALSE) const;
  Double_t BetheITSsaHybrid(Double_t p, Double_t mass) const;
  Double_t GetResolution(Double_t bethe, Int_t nPtsForPid=4, Bool_t isSA=kFALSE,Double_t p=0., AliPID::EParticleType type=AliPID::kPion) const;
  void GetITSProbabilities(Float_t mom, Double_t qclu[4], Double_t condprobfun[AliPID::kSPECIES],Bool_t isMC=kFALSE) const;
@@ -54,7 +55,7 @@ public:
  
  Float_t GetNumberOfSigmas(Float_t mom, Float_t signal, AliPID::EParticleType type, Int_t nPtsForPid=4, Bool_t isSA=kFALSE) const {
    const Double_t chargeFactor = TMath::Power(AliPID::ParticleCharge(type),2.);
-   Float_t bethe = Bethe(mom,AliPID::ParticleMassZ(type),isSA)*chargeFactor;
+   Float_t bethe = Bethe(mom,type,isSA)*chargeFactor;
    return (signal - bethe)/GetResolution(bethe,nPtsForPid,isSA,mom,type);
  }
  Int_t GetParticleIdFromdEdxVsP(Float_t mom, Float_t signal, Bool_t isSA=kFALSE) const;
@@ -82,7 +83,8 @@ private:
   Double_t fResolTPCITSTri3[3]; // triton resolutions vs. p for tracks with 3 SDD/SSD points
   Double_t fResolTPCITSTri4[3]; // triton resolutions vs. p for tracks with 4 SDD/SSD points
 
-  ClassDef(AliITSPIDResponse,4)   // ITS PID class
+  Double_t Bethe(Double_t bg, const Double_t * const par, Bool_t isNuclei) const;
+  ClassDef(AliITSPIDResponse,5)   // ITS PID class
 };
 
 #endif