https://savannah.cern.ch/bugs/index.php?96630
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 18 Aug 2012 20:55:49 +0000 (20:55 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 18 Aug 2012 20:55:49 +0000 (20:55 +0000)
Pietro Antonioli

STEER/STEERBase/AliITSPIDResponse.cxx
STEER/STEERBase/AliITSPidParams.cxx
STEER/STEERBase/AliITSPidParams.h

index acab4d7..bcbe2d2 100644 (file)
@@ -175,14 +175,14 @@ void AliITSPIDResponse::GetITSProbabilities(Float_t mom, Double_t qclu[4], Doubl
   // using the likelihood method
   //
   const Int_t nLay = 4;
-  const Int_t nPart = 3;
+  const Int_t nPart= 4;
 
   static AliITSPidParams pars(isMC);  // Pid parametrisation parameters
   
-  Double_t itsProb[nPart] = {1,1,1}; // p, K, pi
+  Double_t itsProb[nPart] = {1,1,1,1}; // e, p, K, pi
 
   for (Int_t iLay = 0; iLay < nLay; iLay++) {
-    if (qclu[iLay] <= 0)
+    if (qclu[iLay] <= 50.)
       continue;
 
     Float_t dedx = qclu[iLay];
@@ -190,11 +190,13 @@ void AliITSPIDResponse::GetITSProbabilities(Float_t mom, Double_t qclu[4], Doubl
     itsProb[0] *= layProb;
     
     layProb = pars.GetLandauGausNorm(dedx,AliPID::kKaon,mom,iLay+3);
-    if (mom < 0.16) layProb=0.00001;
     itsProb[1] *= layProb;
     
     layProb = pars.GetLandauGausNorm(dedx,AliPID::kPion,mom,iLay+3);
     itsProb[2] *= layProb;
+   
+    layProb = pars.GetLandauGausNorm(dedx,AliPID::kElectron,mom,iLay+3);
+    itsProb[3] *= layProb;
   }
 
   // Normalise probabilities
@@ -202,13 +204,12 @@ void AliITSPIDResponse::GetITSProbabilities(Float_t mom, Double_t qclu[4], Doubl
   for (Int_t iPart = 0; iPart < nPart; iPart++) {
     sumProb += itsProb[iPart];
   }
-  sumProb += 2*itsProb[2]; // muon and electron cannot be distinguished from pions
+  sumProb += itsProb[2]; // muon cannot be distinguished from pions
 
   for (Int_t iPart = 0; iPart < nPart; iPart++) {
     itsProb[iPart]/=sumProb;
   }
-  
-  condprobfun[AliPID::kElectron] = itsProb[2];
+  condprobfun[AliPID::kElectron] = itsProb[3];
   condprobfun[AliPID::kMuon] = itsProb[2];
   condprobfun[AliPID::kPion] = itsProb[2];
   condprobfun[AliPID::kKaon] = itsProb[1];
index 5d3e74e..3ebfd51 100644 (file)
 #include <TNamed.h>
 #include <TMath.h>
 #include "AliITSPidParams.h"
-#include "AliPID.h"
 
 ClassImp(AliITSPidParams)
 
 //______________________________________________________________________
 AliITSPidParams::AliITSPidParams(Bool_t isMC):
 TNamed("default",""),
-  fSDDPionMPV(0),
+  fSDDElecLandauWidth(0),
+  fSDDElecGaussWidth(0),
+  fSSDElecLandauWidth(0),
+  fSSDElecGaussWidth(0),
   fSDDPionLandauWidth(0),
   fSDDPionGaussWidth(0),
-  fSSDPionMPV(0),
   fSSDPionLandauWidth(0),
   fSSDPionGaussWidth(0),
-  fSDDKaonMPV(0),
   fSDDKaonLandauWidth(0),
   fSDDKaonGaussWidth(0),
-  fSSDKaonMPV(0),
   fSSDKaonLandauWidth(0),
   fSSDKaonGaussWidth(0),
-  fSDDProtMPV(0),
   fSDDProtLandauWidth(0),
   fSDDProtGaussWidth(0),
-  fSSDProtMPV(0),
   fSSDProtLandauWidth(0),
   fSSDProtGaussWidth(0)
 {
@@ -60,22 +57,18 @@ TNamed("default",""),
 //______________________________________________________________________
 AliITSPidParams::AliITSPidParams(Char_t * name, Bool_t isMC):
   TNamed(name,""),
-  fSDDPionMPV(0),
-  fSDDPionLandauWidth(0),
-  fSDDPionGaussWidth(0),
-  fSSDPionMPV(0),
+  fSDDElecLandauWidth(0),
+  fSDDElecGaussWidth(0),
+  fSSDElecLandauWidth(0),
+  fSSDElecGaussWidth(0),
   fSSDPionLandauWidth(0),
   fSSDPionGaussWidth(0),
-  fSDDKaonMPV(0),
   fSDDKaonLandauWidth(0),
   fSDDKaonGaussWidth(0),
-  fSSDKaonMPV(0),
   fSSDKaonLandauWidth(0),
   fSSDKaonGaussWidth(0),
-  fSDDProtMPV(0),
   fSDDProtLandauWidth(0),
   fSDDProtGaussWidth(0),
-  fSSDProtMPV(0),
   fSSDProtLandauWidth(0), 
   fSSDProtGaussWidth(0)
 {
@@ -85,198 +78,263 @@ AliITSPidParams::AliITSPidParams(Char_t * name, Bool_t isMC):
 }
 //______________________________________________________________________
 AliITSPidParams::~AliITSPidParams(){
-  // 
-  if(fSDDPionMPV) delete fSDDPionMPV;
+  //
+  if(fSDDElecLandauWidth) delete fSDDElecLandauWidth;
+  if(fSDDElecGaussWidth) delete fSDDElecGaussWidth;
+  
+  if(fSSDElecLandauWidth) delete fSSDElecLandauWidth;
+  if(fSSDElecGaussWidth) delete fSSDElecGaussWidth;
+
   if(fSDDPionLandauWidth) delete fSDDPionLandauWidth;
   if(fSDDPionGaussWidth) delete fSDDPionGaussWidth;
 
-  if(fSSDPionMPV) delete fSSDPionMPV;
   if(fSSDPionLandauWidth) delete fSSDPionLandauWidth;
   if(fSSDPionGaussWidth) delete fSSDPionGaussWidth;
   
-  if(fSDDKaonMPV) delete fSDDKaonMPV;
   if(fSDDKaonLandauWidth) delete fSDDKaonLandauWidth;
   if(fSDDKaonGaussWidth) delete fSDDKaonGaussWidth;
   
-  if(fSSDKaonMPV) delete fSSDKaonMPV;
   if(fSSDKaonLandauWidth) delete fSSDKaonLandauWidth;
   if(fSSDKaonGaussWidth) delete fSSDKaonGaussWidth;
 
-  if(fSDDProtMPV) delete fSDDProtMPV;
   if(fSDDProtLandauWidth) delete fSDDProtLandauWidth;
   if(fSDDProtGaussWidth) delete fSDDProtGaussWidth;
 
-  if(fSSDProtMPV) delete fSSDProtMPV;
   if(fSSDProtLandauWidth) delete fSSDProtLandauWidth;
   if(fSSDProtGaussWidth) delete fSSDProtGaussWidth;
 }
-
 //______________________________________________________________________
+Double_t AliITSPidParams::BetheBloch(Double_t mom, Double_t mass, const Double_t *p) const{
+ //
+  // This is the empirical parameterization of the Bethe-Bloch formula.
+  // It is normalized to 1 at the minimum.
+  //
+  // bg - beta*gamma
+  // 
+  Double_t bg = mom/mass;
+  Double_t beta = bg/TMath::Sqrt(1.+ bg*bg);
+  Double_t aa = TMath::Power(beta,p[3]);
+  Double_t bb = TMath::Power(1./bg,p[4]);
+  bb=TMath::Log(p[2]+bb);
+  return (p[0]-aa-bb)*p[1]/aa;
+}
+//______________________________________________________________________
+Double_t AliITSPidParams::ExtrapolateWidth(Double_t mom, Double_t x1, Double_t y1,Double_t x2, Double_t y2) const{
+  //
+  // This is a linear extrapolation of Landau width and Gaussian width 
+  // for low momentum.
+  
+ Double_t slope = (y2-y1)/(x2-x1);
+ return slope*mom+(y1-slope*x1);
+}//______________________________________________________________________
 void AliITSPidParams::InitMC(){
   // initialize TFormulas to Monte Carlo values (=p-p simulations PYTHIA+GEANT)
   // parameter values from LHC10d1 
-
-  // pions
-  if(fSDDPionMPV) delete fSDDPionMPV;
-  fSDDPionMPV=new TFormula("fSDDPionMPV","[0]/(x*x)*TMath::Log(x)+[1]/(x*x*x*x)*TMath::Log(x)+[2]*TMath::Log(x)+[3]");
-  fSDDPionMPV->SetParameters(-0.892291, 0.003630, 1.866484, 78.378179);
-
+  // MPV BetheBloch parameters;
+  
+  //sdd MC electrons parameters
+  fSDDElecMPVBetheParams[0] = -0.0931934;
+  fSDDElecMPVBetheParams[1] = 77.8422;
+  fSDDElecMPVBetheParams[2] = -0.889085;
+  fSDDElecMPVBetheParams[3] = -154.455;
+  fSDDElecMPVBetheParams[4] = -0.000256076;
+  
+  //ssd MC electrons parameters
+  fSSDElecMPVBetheParams[0] = -0.0989358;
+  fSSDElecMPVBetheParams[1] = 77.8271;
+  fSSDElecMPVBetheParams[2] = -0.900887;
+  fSSDElecMPVBetheParams[3] =-1241.14;
+  fSSDElecMPVBetheParams[4] = -0.0014204;
+  
+   // electrons 
+  if(fSDDElecLandauWidth) delete fSDDElecLandauWidth;
+  fSDDElecLandauWidth=new TFormula("fSDDElecLandauWidth","[0]/(x*x)+[1]");
+  fSDDElecLandauWidth->SetParameters(-0.002702, 6.224960);
+
+  if(fSDDElecGaussWidth) delete fSDDElecGaussWidth;
+  fSDDElecGaussWidth=new TFormula("fSDDElecGaussWidth","[0]/(x*x)+[1]");
+  fSDDElecGaussWidth->SetParameters(0.012402, 7.993106);
+
+  if(fSSDElecLandauWidth) delete fSSDElecLandauWidth;
+  fSSDElecLandauWidth=new TFormula("fSSDElecLandauWidth","[0]/(x*x)+[1]");
+  fSSDElecLandauWidth->SetParameters(-0.002144, 6.231089);
+
+  if(fSSDElecGaussWidth) delete fSSDElecGaussWidth;
+  fSSDElecGaussWidth=new TFormula("fSSDElecGaussWidth","[0]/(x*x)+[1]");
+  fSSDElecGaussWidth->SetParameters(0.014530, 6.217153);
+  
+  //sdd MC hadrons parameters
+  fSDDHadronMPVBetheParams[0] = 1.13531;
+  fSDDHadronMPVBetheParams[1] = -156.651;
+  fSDDHadronMPVBetheParams[2] = 1.87562;
+  fSDDHadronMPVBetheParams[3] = 0.45819;
+  fSDDHadronMPVBetheParams[4] = 2.26506;
+  
+  //ssd MC hadrons parameters
+  fSSDHadronMPVBetheParams[0] = -0.451908;
+  fSSDHadronMPVBetheParams[1] = -55.4368;
+  fSSDHadronMPVBetheParams[2] = 0.984636;
+  fSSDHadronMPVBetheParams[3] = 0.97078;
+  fSSDHadronMPVBetheParams[4] = 2.50883;
+
+  // pions 
   if(fSDDPionLandauWidth) delete fSDDPionLandauWidth;
   fSDDPionLandauWidth=new TFormula("fSDDPionLandauWidth","[0]/(x*x)+[1]");
-  fSDDPionLandauWidth->SetParameters(0.080999, 5.917715);
+  fSDDPionLandauWidth->SetParameters(0.08026, 5.87922);
 
   if(fSDDPionGaussWidth) delete fSDDPionGaussWidth;
   fSDDPionGaussWidth=new TFormula("fSDDPionGaussWidth","[0]/(x*x)*TMath::Log(x)+[1]");
-  fSDDPionGaussWidth->SetParameters(-0.092822, 7.839729);
-
-  if(fSSDPionMPV) delete fSSDPionMPV;
-  fSSDPionMPV=new TFormula("fSSDPionMPV","[0]/(x*x)*TMath::Log(x)+[1]/(x*x*x*x)*TMath::Log(x)+[2]*TMath::Log(x)+[3]");
-  fSSDPionMPV->SetParameters(-0.896507, 0.003173, 2.017155, 80.682567);
+  fSDDPionGaussWidth->SetParameters(-0.090495, 7.705286);
 
   if(fSSDPionLandauWidth) delete fSSDPionLandauWidth;
   fSSDPionLandauWidth=new TFormula("fSSDPionLandauWidth","[0]/(x*x)+[1]");
-  fSSDPionLandauWidth->SetParameters(0.087182, 5.843610);
+  fSSDPionLandauWidth->SetParameters(0.083882, 5.823419);
 
   if(fSSDPionGaussWidth) delete fSSDPionGaussWidth;
   fSSDPionGaussWidth=new TFormula("fSSDPionGaussWidth","[0]/(x*x)*TMath::Log(x)+[1]");
-  fSSDPionGaussWidth->SetParameters(-0.110444, 5.837737);
+  fSSDPionGaussWidth->SetParameters(-0.105218, 5.650956);
 
   // kaons
-  if(fSDDKaonMPV) delete fSDDKaonMPV;
-  fSDDKaonMPV=new TFormula("fSDDKaonMPV","[0]/(x*x)+[1]/(x*x*x*x)+[2]");
-  fSDDKaonMPV->SetParameters(17.581590, -0.120134, 72.550701);
-
   if(fSDDKaonLandauWidth) delete fSDDKaonLandauWidth;
   fSDDKaonLandauWidth=new TFormula("fSDDKaonLandauWidth","[0]/(x*x)+[1]");
-  fSDDKaonLandauWidth->SetParameters(1.271756, 5.778888);
+  fSDDKaonLandauWidth->SetParameters(1.430692, 5.581389);
 
   if(fSDDKaonGaussWidth) delete fSDDKaonGaussWidth;
   fSDDKaonGaussWidth=new TFormula("fSDDKaonGaussWidth","[0]/(x*x)*TMath::Log(x)+[1]");
-  fSDDKaonGaussWidth->SetParameters(-1.650298, 8.322084);
-
-  if(fSSDKaonMPV) delete fSSDKaonMPV;
-  fSSDKaonMPV=new TFormula("fSSDKaonMPV","[0]/(x*x)+[1]/(x*x*x*x)+[2]");
-  fSSDKaonMPV->SetParameters(16.238778, 0.039318, 75.863719);
+  fSDDKaonGaussWidth->SetParameters(-1.6537, 8.071832);
 
   if(fSSDKaonLandauWidth) delete fSSDKaonLandauWidth;
   fSSDKaonLandauWidth=new TFormula("fSSDKaonLandauWidth","[0]/(x*x)+[1]");
-  fSSDKaonLandauWidth->SetParameters(1.179541, 5.961353);
+  fSSDKaonLandauWidth->SetParameters(1.368824, 5.639291);
 
   if(fSSDKaonGaussWidth) delete fSSDKaonGaussWidth;
   fSSDKaonGaussWidth=new TFormula("fSSDKaonGaussWidth","[0]/(x*x)*TMath::Log(x)+[1]");
-  fSSDKaonGaussWidth->SetParameters(-2.019126, 6.155977);
+  fSSDKaonGaussWidth->SetParameters(-1.901858, 6.0932281);
 
   // protons
-  if(fSDDProtMPV) delete fSDDProtMPV;
-  fSDDProtMPV=new TFormula("fSDDProtMPV","[0]/(x*x)+[1]/(x*x*x*x)+[2]");
-  fSDDProtMPV->SetParameters(64.482762, -1.667823, 71.850731);
-
   if(fSDDProtLandauWidth) delete fSDDProtLandauWidth;
   fSDDProtLandauWidth=new TFormula("fSDDProtLandauWidth","[0]/(x*x)+[1]");
-  fSDDProtLandauWidth->SetParameters(6.948997, 3.928018);
+  fSDDProtLandauWidth->SetParameters(6.529418, 5.049098);
 
   if(fSDDProtGaussWidth) delete fSDDProtGaussWidth;
   fSDDProtGaussWidth=new TFormula("fSDDProtGaussWidth","[0]/(x*x)*TMath::Log(x)+[1]");
-  fSDDProtGaussWidth->SetParameters(-6.522760, 12.673959);
-
-  if(fSSDProtMPV) delete fSSDProtMPV;
-  fSSDProtMPV=new TFormula("fSSDProtMPV","[0]/(x*x)+[1]/(x*x*x*x)+[2]");
-  fSSDProtMPV->SetParameters(63.817375, -1.221779, 73.233644);
+  fSDDProtGaussWidth->SetParameters(-9.360599, 11.318026);
 
   if(fSSDProtLandauWidth) delete fSSDProtLandauWidth;
   fSSDProtLandauWidth=new TFormula("fSSDProtLandauWidth","[0]/(x*x)+[1]");
-  fSSDProtLandauWidth->SetParameters(7.286942, 3.581451);
+  fSSDProtLandauWidth->SetParameters(6.419493, 4.925070);
 
   if(fSSDProtGaussWidth) delete fSSDProtGaussWidth;
   fSSDProtGaussWidth=new TFormula("fSSDProtGaussWidth","[0]/(x*x)*TMath::Log(x)+[1]");
-  fSSDProtGaussWidth->SetParameters(-8.327867, 9.723422);
-
+  fSSDProtGaussWidth->SetParameters(-9.599064, 9.358656);
 }
 //______________________________________________________________________
 void AliITSPidParams::InitData(){
-  // initialize TFormulas to Real Data values (=p-p simulations PYTHIA+GEANT)
+  // initialize TFormulas to Real Data values (=p-p ALICE Experiment)
   // parameter values from LHC10b 
+  // MPV BetheBloch parameters;
+ //sdd data electrons parameters
+  fSDDElecMPVBetheParams[0] = -0.130204;
+  fSDDElecMPVBetheParams[1] = 75.1267;
+  fSDDElecMPVBetheParams[2] = -0.889337;
+  fSDDElecMPVBetheParams[3] = 388.372;
+  fSDDElecMPVBetheParams[4] = 0.00134649;
+  
+  //ssd data electrons parameters
+  fSSDElecMPVBetheParams[0] = -0.162773;
+  fSSDElecMPVBetheParams[1] = 72.9393;
+  fSSDElecMPVBetheParams[2] = -0.896944;
+  fSSDElecMPVBetheParams[3] = 3233.02;
+  fSSDElecMPVBetheParams[4] = 0.00146896;
+  
+   // electrons 
+  if(fSDDElecLandauWidth) delete fSDDElecLandauWidth;
+  fSDDElecLandauWidth=new TFormula("fSDDElecLandauWidth","[0]/(x*x)+[1]");
+  fSDDElecLandauWidth->SetParameters(-0.002702, 6.224960);
+
+  if(fSDDElecGaussWidth) delete fSDDElecGaussWidth;
+  fSDDElecGaussWidth=new TFormula("fSDDElecGaussWidth","[0]/(x*x)+[1]");
+  fSDDElecGaussWidth->SetParameters(0.012402, 7.993106);
+
+  if(fSSDElecLandauWidth) delete fSSDElecLandauWidth;
+  fSSDElecLandauWidth=new TFormula("fSSDElecLandauWidth","[0]/(x*x)+[1]");
+  fSSDElecLandauWidth->SetParameters(-0.002144, 6.231089);
+
+  if(fSSDElecGaussWidth) delete fSSDElecGaussWidth;
+  fSSDElecGaussWidth=new TFormula("fSSDElecGaussWidth","[0]/(x*x)+[1]");
+  fSSDElecGaussWidth->SetParameters(0.014530, 6.217153);
+  
+  //sdd data hadrons parameters
+  fSDDHadronMPVBetheParams[0] = -18.1867;
+  fSDDHadronMPVBetheParams[1] = -3.45806;
+  fSDDHadronMPVBetheParams[2] =  2.23635;
+  fSDDHadronMPVBetheParams[3] =  2.08328;
+  fSDDHadronMPVBetheParams[4] = -1.92331;
+  //ssd data hadrons parameters
+  fSSDHadronMPVBetheParams[0] = -12.6459;
+  fSSDHadronMPVBetheParams[1] = -4.84598;
+  fSSDHadronMPVBetheParams[2] =  1.50253;
+  fSSDHadronMPVBetheParams[3] =  2.08328;
+  fSSDHadronMPVBetheParams[4] = -1.3719;
   
   // pions
-  if(fSDDPionMPV) delete fSDDPionMPV;
-  fSDDPionMPV=new TFormula("fSDDPionMPV","[0]/(x*x)*TMath::Log(x)+[1]/(x*x*x*x)*TMath::Log(x)+[2]*TMath::Log(x)+[3]");
-  fSDDPionMPV->SetParameters(-0.907609, 0.006521, 3.340347, 81.297942);
-
   if(fSDDPionLandauWidth) delete fSDDPionLandauWidth;
   fSDDPionLandauWidth=new TFormula("fSDDPionLandauWidth","[0]/(x*x)+[1]");
-  fSDDPionLandauWidth->SetParameters(0.077272, 5.478557);
+  fSDDPionLandauWidth->SetParameters(0.07694, 5.468728);
 
   if(fSDDPionGaussWidth) delete fSDDPionGaussWidth;
   fSDDPionGaussWidth=new TFormula("fSDDPionGaussWidth","[0]/(x*x)*TMath::Log(x)+[1]");
-  fSDDPionGaussWidth->SetParameters(-0.098529, 10.265711);
-
-  if(fSSDPionMPV) delete fSSDPionMPV;
-  fSSDPionMPV=new TFormula("fSSDPionMPV","[0]/(x*x)*TMath::Log(x)+[1]/(x*x*x*x)*TMath::Log(x)+[2]*TMath::Log(x)+[3]");
-  fSSDPionMPV->SetParameters(-0.920046, 0.006061, 3.428578, 81.401816);
+  fSDDPionGaussWidth->SetParameters(-0.098209, 10.409441);
 
   if(fSSDPionLandauWidth) delete fSSDPionLandauWidth;
   fSSDPionLandauWidth=new TFormula("fSSDPionLandauWidth","[0]/(x*x)+[1]");
-  fSSDPionLandauWidth->SetParameters(0.071243, 5.388830);
+  fSSDPionLandauWidth->SetParameters(0.071602, 5.365442);
 
   if(fSSDPionGaussWidth) delete fSSDPionGaussWidth;
   fSSDPionGaussWidth=new TFormula("fSSDPionGaussWidth","[0]/(x*x)*TMath::Log(x)+[1]");
-  fSSDPionGaussWidth->SetParameters(-0.099189, 7.412309);
+  fSSDPionGaussWidth->SetParameters(-0.098045, 7.617583);
 
   // kaons
-  if(fSDDKaonMPV) delete fSDDKaonMPV;
-  fSDDKaonMPV=new TFormula("fSDDKaonMPV","[0]/(x*x)+[1]/(x*x*x*x)+[2]");
-  fSDDKaonMPV->SetParameters(15.429146, 0.178251, 74.640293);
-
   if(fSDDKaonLandauWidth) delete fSDDKaonLandauWidth;
   fSDDKaonLandauWidth=new TFormula("fSDDKaonLandauWidth","[0]/(x*x)+[1]");
-  fSDDKaonLandauWidth->SetParameters(0.975202, 5.699311);
+  fSDDKaonLandauWidth->SetParameters(0.998191, 5.461668);
 
   if(fSDDKaonGaussWidth) delete fSDDKaonGaussWidth;
   fSDDKaonGaussWidth=new TFormula("fSDDKaonGaussWidth","[0]/(x*x)+[1]");
-  fSDDKaonGaussWidth->SetParameters(1.660840, 9.389192);
-
-  if(fSSDKaonMPV) delete fSSDKaonMPV;
-  fSSDKaonMPV=new TFormula("fSSDKaonMPV","[0]/(x*x)+[1]/(x*x*x*x)+[2]");
-  fSSDKaonMPV->SetParameters(15.170715, 0.181379, 74.951884);
+  fSDDKaonGaussWidth->SetParameters(1.629308, 9.851873);
 
   if(fSSDKaonLandauWidth) delete fSSDKaonLandauWidth;
   fSSDKaonLandauWidth=new TFormula("fSSDKaonLandauWidth","[0]/(x*x)+[1]");
-  fSSDKaonLandauWidth->SetParameters(0.756466, 5.818274);
+  fSSDKaonLandauWidth->SetParameters(0.773113, 5.618683);
 
   if(fSSDKaonGaussWidth) delete fSSDKaonGaussWidth;
   fSSDKaonGaussWidth=new TFormula("fSSDKaonGaussWidth","[0]/(x*x)+[1]");
-  fSSDKaonGaussWidth->SetParameters(1.546693, 6.389872);
+  fSSDKaonGaussWidth->SetParameters(1.510713, 6.862774);
 
   // protons
-  if(fSDDProtMPV) delete fSDDProtMPV;
-  fSDDProtMPV=new TFormula("fSDDProtMPV","[0]/(x*x)+[1]/(x*x*x*x)+[2]");
-  fSDDProtMPV->SetParameters(61.452534, 0.372908, 71.668352);
-
   if(fSDDProtLandauWidth) delete fSDDProtLandauWidth;
   fSDDProtLandauWidth=new TFormula("fSDDProtLandauWidth","[0]/(x*x)+[1]");
-  fSDDProtLandauWidth->SetParameters(3.667023, 5.430721);
+  fSDDProtLandauWidth->SetParameters(3.561429, 5.372105);
 
   if(fSDDProtGaussWidth) delete fSDDProtGaussWidth;
   fSDDProtGaussWidth=new TFormula("fSDDProtGaussWidth","[0]/(x*x)+[1]");
-  fSDDProtGaussWidth->SetParameters(5.503814, 9.657439);
-
-  if(fSSDProtMPV) delete fSSDProtMPV;
-  fSSDProtMPV=new TFormula("fSSDProtMPV","[0]/(x*x)+[1]/(x*x*x*x)+[2]");
-  fSSDProtMPV->SetParameters(60.246538, 0.000323, 71.992031);
+  fSDDProtGaussWidth->SetParameters(5.395926, 10.044613);
 
   if(fSSDProtLandauWidth) delete fSSDProtLandauWidth;
   fSSDProtLandauWidth=new TFormula("fSSDProtLandauWidth","[0]/(x*x)+[1]");
-  fSSDProtLandauWidth->SetParameters(2.568323, 5.939774);
+  fSSDProtLandauWidth->SetParameters(2.647428, 5.678460);
 
   if(fSSDProtGaussWidth) delete fSSDProtGaussWidth;
   fSSDProtGaussWidth=new TFormula("fSSDProtGaussWidth","[0]/(x*x)+[1]");
-  fSSDProtGaussWidth->SetParameters(5.050541, 6.290964);
-
+  fSSDProtGaussWidth->SetParameters(4.91025, 6.779763);
 }
 //_______________________________________________________________________
 Double_t AliITSPidParams::GetLandauGausNormPdgCode(Double_t dedx, Int_t pdgCode, Double_t mom, Int_t lay) const {
   // Computes Landau Gauss convolution for given particle specie and given momentum in a given ITS layer
-  if(TMath::Abs(pdgCode)==211) return GetLandauGausNorm(dedx,AliPID::kPion,mom,lay);
+  if(TMath::Abs(pdgCode)==11) return GetLandauGausNorm(dedx,AliPID::kElectron,mom,lay);
+  else if(TMath::Abs(pdgCode)==211) return GetLandauGausNorm(dedx,AliPID::kPion,mom,lay);
   else if(TMath::Abs(pdgCode)==321) return GetLandauGausNorm(dedx,AliPID::kKaon,mom,lay);
   else if(TMath::Abs(pdgCode)==2212) return GetLandauGausNorm(dedx,AliPID::kProton,mom,lay);
   else return 0.;
@@ -285,9 +343,22 @@ Double_t AliITSPidParams::GetLandauGausNormPdgCode(Double_t dedx, Int_t pdgCode,
 Double_t AliITSPidParams::GetLandauGausNorm(Double_t dedx, Int_t partType, Double_t mom, Int_t lay) const{
   // Computes Landau Gauss convolution for given particle specie and given momentum in a given ITS layer
   
-  Double_t par[3];
+  Double_t par[4];
   Bool_t isSet=kFALSE;
-  if(partType==AliPID::kPion){
+  if(partType==AliPID::kElectron){
+    if(lay==3 || lay==4){
+      par[0]=GetSDDElecLandauWidth(mom);
+      par[1]=GetSDDElecMPV(mom);
+      par[2]=GetSDDElecGaussWidth(mom);
+      isSet=kTRUE;
+    }
+    else if(lay==5 || lay==6){
+      par[0]=GetSSDElecLandauWidth(mom);
+      par[1]=GetSSDElecMPV(mom);
+      par[2]=GetSSDElecGaussWidth(mom);
+      isSet=kTRUE;
+    }
+  }else if(partType==AliPID::kPion){
     if(lay==3 || lay==4){
       par[0]=GetSDDPionLandauWidth(mom);
       par[1]=GetSDDPionMPV(mom);
@@ -340,7 +411,7 @@ Double_t AliITSPidParams::GetLandauGausNorm(Double_t dedx, Int_t partType, Doubl
   Double_t fland;
   Double_t sum = 0.0;
   Double_t xlow,xupp;
-  Double_t step = 0.;
+  Double_t step;
   Double_t i;
   
   // MP shift correction
index a9a58b8..2ba1a9b 100644 (file)
@@ -7,13 +7,14 @@
 
 ///////////////////////////////////////////////////////////////////
 //                                                               //
-// Class to store parameters of ITS response funcions            //
+// Class to store parameters of ITS response functions           //
 // Origin: F.Prino, Torino, prino@to.infn.it                     //
 //                                                               //
 ///////////////////////////////////////////////////////////////////
 
 #include <TFormula.h>
 #include <TNamed.h>
+#include "AliPID.h"
 
 class AliITSPidParams : public TNamed {
 
@@ -27,11 +28,39 @@ class AliITSPidParams : public TNamed {
   Double_t GetLandauGausNormPdgCode(Double_t dedx, Int_t pdgCode, Double_t mom, Int_t lay) const;
   Double_t GetLandauGausNorm(Double_t dedx, Int_t partType, Double_t mom, Int_t lay) const;
   
-  // pion setters
-  void SetSDDPionMPV(const TFormula* form){
-    if(fSDDPionMPV) delete fSDDPionMPV;
-    fSDDPionMPV=new TFormula(*form);
+  // electron setters
+  void SetSDDElecMPVparams(const Double_t* params){
+    for(Int_t ipar=0; ipar<5; ipar++) fSDDElecMPVBetheParams[ipar]=params[ipar];
+  }  
+  void SetSSDElecMPVparams(const Double_t* params){
+    for(Int_t ipar=0; ipar<5; ipar++) fSSDElecMPVBetheParams[ipar]=params[ipar];
+  }
+  void SetSDDElecLandauWidth(const TFormula* form){
+    if(fSDDElecLandauWidth) delete fSDDElecLandauWidth;
+    fSDDElecLandauWidth=new TFormula(*form);
+  }
+  void SetSDDElecGaussWidth(const TFormula* form){
+    if(fSDDElecGaussWidth) delete fSDDElecGaussWidth;
+    fSDDElecGaussWidth=new TFormula(*form);
+  } 
+  void SetSSDElecLandauWidth(const TFormula* form){
+    if(fSSDElecLandauWidth) delete fSSDElecLandauWidth;
+    fSSDElecLandauWidth=new TFormula(*form);
+  }
+  void SetSSDElecGaussWidth(const TFormula* form){
+    if(fSSDElecGaussWidth) delete fSSDElecGaussWidth;
+    fSSDElecGaussWidth=new TFormula(*form);
   }
+
+  //Hadron setters
+  void SetSDDHadronMPVparams(const Double_t* params){
+    for(Int_t ipar=0; ipar<5; ipar++) fSDDHadronMPVBetheParams[ipar]=params[ipar];
+  }  
+  void SetSSDHadronMPVparams(const Double_t* params){
+    for(Int_t ipar=0; ipar<5; ipar++) fSSDHadronMPVBetheParams[ipar]=params[ipar];
+  }
+  
+  //Pion setters
   void SetSDDPionLandauWidth(const TFormula* form){
     if(fSDDPionLandauWidth) delete fSDDPionLandauWidth;
     fSDDPionLandauWidth=new TFormula(*form);
@@ -39,11 +68,7 @@ class AliITSPidParams : public TNamed {
   void SetSDDPionGaussWidth(const TFormula* form){
     if(fSDDPionGaussWidth) delete fSDDPionGaussWidth;
     fSDDPionGaussWidth=new TFormula(*form);
-  }
-  void SetSSDPionMPV(const TFormula* form){
-    if(fSSDPionMPV) delete fSSDPionMPV;
-    fSSDPionMPV=new TFormula(*form);
-  }
+  } 
   void SetSSDPionLandauWidth(const TFormula* form){
     if(fSSDPionLandauWidth) delete fSSDPionLandauWidth;
     fSSDPionLandauWidth=new TFormula(*form);
@@ -54,10 +79,6 @@ class AliITSPidParams : public TNamed {
   }
 
   // kaon setters
-  void SetSDDKaonMPV(const TFormula* form){
-    if(fSDDKaonMPV) delete fSDDKaonMPV;
-    fSDDKaonMPV=new TFormula(*form);
-  }
   void SetSDDKaonLandauWidth(const TFormula* form){
     if(fSDDKaonLandauWidth) delete fSDDKaonLandauWidth;
     fSDDKaonLandauWidth=new TFormula(*form);
@@ -66,10 +87,6 @@ class AliITSPidParams : public TNamed {
     if(fSDDKaonGaussWidth) delete fSDDKaonGaussWidth;
     fSDDKaonGaussWidth=new TFormula(*form);
   }
-  void SetSSDKaonMPV(const TFormula* form){
-    if(fSSDKaonMPV) delete fSSDKaonMPV;
-    fSSDKaonMPV=new TFormula(*form);
-  }
   void SetSSDKaonLandauWidth(const TFormula* form){
     if(fSSDKaonLandauWidth) delete fSSDKaonLandauWidth;
     fSSDKaonLandauWidth=new TFormula(*form);
@@ -79,12 +96,7 @@ class AliITSPidParams : public TNamed {
     fSSDKaonGaussWidth=new TFormula(*form);
   }
 
-
   // proton setters
-  void SetSDDProtMPV(const TFormula* form){
-    if(fSDDProtMPV) delete fSDDProtMPV;
-    fSDDProtMPV=new TFormula(*form);
-  }
   void SetSDDProtLandauWidth(const TFormula* form){
     if(fSDDProtLandauWidth) delete fSDDProtLandauWidth;
     fSDDProtLandauWidth=new TFormula(*form);
@@ -93,10 +105,6 @@ class AliITSPidParams : public TNamed {
     if(fSDDProtGaussWidth) delete fSDDProtGaussWidth;
     fSDDProtGaussWidth=new TFormula(*form);
   }
-  void SetSSDProtMPV(const TFormula* form){
-    if(fSSDProtMPV) delete fSSDProtMPV;
-    fSSDProtMPV=new TFormula(*form);
-  }
   void SetSSDProtLandauWidth(const TFormula* form){
     if(fSSDProtLandauWidth) delete fSSDProtLandauWidth;
     fSSDProtLandauWidth=new TFormula(*form);
@@ -106,10 +114,32 @@ class AliITSPidParams : public TNamed {
     fSSDProtGaussWidth=new TFormula(*form);
   }
 
+  // electron getters
+  Double_t GetSDDElecMPV(Double_t mom) const {
+    Double_t mass = AliPID::ParticleMass(AliPID::kElectron);
+    return BetheBloch(mom,mass,fSDDElecMPVBetheParams);
+  }
+  Double_t GetSDDElecLandauWidth(Double_t mom) const {
+    return fSDDElecLandauWidth->Eval(mom);
+  }
+  Double_t GetSDDElecGaussWidth(Double_t mom) const {
+    return fSDDElecGaussWidth->Eval(mom);
+  }
+  Double_t GetSSDElecMPV(Double_t mom) const {
+    Double_t mass = AliPID::ParticleMass(AliPID::kElectron);
+    return BetheBloch(mom,mass,fSSDElecMPVBetheParams);
+  }
+  Double_t GetSSDElecLandauWidth(Double_t mom) const {
+    return fSSDElecLandauWidth->Eval(mom);
+  }
+  Double_t GetSSDElecGaussWidth(Double_t mom) const {
+    return fSSDElecGaussWidth->Eval(mom);
+  }
 
   // pion getters
   Double_t GetSDDPionMPV(Double_t mom) const {
-    return fSDDPionMPV->Eval(mom);
+    Double_t mass = AliPID::ParticleMass(AliPID::kPion);
+    return BetheBloch(mom,mass,fSDDHadronMPVBetheParams);
   }
   Double_t GetSDDPionLandauWidth(Double_t mom) const {
     return fSDDPionLandauWidth->Eval(mom);
@@ -118,7 +148,8 @@ class AliITSPidParams : public TNamed {
     return fSDDPionGaussWidth->Eval(mom);
   }
   Double_t GetSSDPionMPV(Double_t mom) const {
-    return fSSDPionMPV->Eval(mom);
+    Double_t mass = AliPID::ParticleMass(AliPID::kPion);
+    return BetheBloch(mom,mass,fSSDHadronMPVBetheParams);
   }
   Double_t GetSSDPionLandauWidth(Double_t mom) const {
     return fSSDPionLandauWidth->Eval(mom);
@@ -129,42 +160,102 @@ class AliITSPidParams : public TNamed {
 
   // kaon getters
   Double_t GetSDDKaonMPV(Double_t mom) const {
-    return fSDDKaonMPV->Eval(mom);
+    Double_t mass = AliPID::ParticleMass(AliPID::kKaon);
+    return BetheBloch(mom,mass,fSDDHadronMPVBetheParams);
   }
   Double_t GetSDDKaonLandauWidth(Double_t mom) const {
-    return fSDDKaonLandauWidth->Eval(mom);
+    Double_t xlw = 0.3;
+    Double_t xup = 0.4;
+    if (mom > xlw) return fSDDKaonLandauWidth->Eval(mom);
+    else {
+      Double_t ylw =fSDDKaonLandauWidth->Eval(xlw);
+      Double_t yup =fSDDKaonLandauWidth->Eval(xup);
+      return ExtrapolateWidth(mom,xlw,ylw,xup,yup);
+   }
   }
   Double_t GetSDDKaonGaussWidth(Double_t mom) const {
-    return fSDDKaonGaussWidth->Eval(mom);
+    Double_t xlw = 0.3;
+    Double_t xup = 0.4;
+    if (mom > xlw) return fSDDKaonGaussWidth->Eval(mom);
+    else {
+      Double_t ylw =fSDDKaonGaussWidth->Eval(xlw);
+      Double_t yup =fSDDKaonGaussWidth->Eval(xup);
+      return ExtrapolateWidth(mom,xlw,ylw,xup,yup);
+    }
   }
   Double_t GetSSDKaonMPV(Double_t mom) const {
-    return fSSDKaonMPV->Eval(mom);
+    Double_t mass = AliPID::ParticleMass(AliPID::kKaon);
+    return BetheBloch(mom,mass,fSSDHadronMPVBetheParams);
   }
   Double_t GetSSDKaonLandauWidth(Double_t mom) const {
-    return fSSDKaonLandauWidth->Eval(mom);
+    Double_t xlw = 0.3;
+    Double_t xup = 0.4;
+    if (mom > xlw) return fSSDKaonLandauWidth->Eval(mom);
+    else {
+      Double_t ylw =fSSDKaonLandauWidth->Eval(xlw);
+      Double_t yup =fSSDKaonLandauWidth->Eval(xup);
+      return ExtrapolateWidth(mom,xlw,ylw,xup,yup);
+    }
   }
   Double_t GetSSDKaonGaussWidth(Double_t mom) const {
-    return fSSDKaonGaussWidth->Eval(mom);
+    Double_t xlw = 0.3;
+    Double_t xup = 0.4;
+    if (mom > xlw) return fSSDKaonGaussWidth->Eval(mom);
+    else {
+      Double_t ylw =fSSDKaonGaussWidth->Eval(xlw);
+      Double_t yup =fSSDKaonGaussWidth->Eval(xup);
+      return ExtrapolateWidth(mom,xlw,ylw,xup,yup);
+    }
   }
 
   // proton getters
   Double_t GetSDDProtMPV(Double_t mom) const {
-    return fSDDProtMPV->Eval(mom);
+    Double_t mass = AliPID::ParticleMass(AliPID::kProton);
+    return BetheBloch(mom,mass,fSDDHadronMPVBetheParams);
   }
   Double_t GetSDDProtLandauWidth(Double_t mom) const {
-    return fSDDProtLandauWidth->Eval(mom);
+    Double_t xlw = 0.35;
+    Double_t xup = 0.45;
+    if (mom > xlw) return fSDDProtLandauWidth->Eval(mom);
+    else {
+      Double_t ylw =fSDDProtLandauWidth->Eval(xlw);
+      Double_t yup =fSDDProtLandauWidth->Eval(xup);
+      return ExtrapolateWidth(mom,xlw,ylw,xup,yup);
+   }
   }
   Double_t GetSDDProtGaussWidth(Double_t mom) const {
-    return fSDDProtGaussWidth->Eval(mom);
+    Double_t xlw = 0.35;
+    Double_t xup = 0.45;
+    if (mom > xlw) return fSDDProtGaussWidth->Eval(mom);
+    else {
+      Double_t ylw =fSDDProtGaussWidth->Eval(xlw);
+      Double_t yup =fSDDProtGaussWidth->Eval(xup);
+      return ExtrapolateWidth(mom,xlw,ylw,xup,yup);
+   }
   }
   Double_t GetSSDProtMPV(Double_t mom) const {
-    return fSSDProtMPV->Eval(mom);
+    Double_t mass = AliPID::ParticleMass(AliPID::kProton);
+    return BetheBloch(mom,mass,fSSDHadronMPVBetheParams);
   }
   Double_t GetSSDProtLandauWidth(Double_t mom) const {
-    return fSSDProtLandauWidth->Eval(mom);
+    Double_t xlw = 0.35;
+    Double_t xup = 0.45;
+    if (mom > xlw) return fSSDProtLandauWidth->Eval(mom);
+    else {
+      Double_t ylw =fSSDProtLandauWidth->Eval(xlw);
+      Double_t yup =fSSDProtLandauWidth->Eval(xup);
+      return ExtrapolateWidth(mom,xlw,ylw,xup,yup);
+   }
   }
   Double_t GetSSDProtGaussWidth(Double_t mom) const {
-    return fSSDProtGaussWidth->Eval(mom);
+    Double_t xlw = 0.35;
+    Double_t xup = 0.45;
+    if (mom > xlw) return fSSDProtGaussWidth->Eval(mom);
+    else {
+      Double_t ylw =fSSDProtGaussWidth->Eval(xlw);
+      Double_t yup =fSSDProtGaussWidth->Eval(xup);
+      return ExtrapolateWidth(mom,xlw,ylw,xup,yup);
+   }
   }
 
  private:
@@ -172,30 +263,43 @@ class AliITSPidParams : public TNamed {
   AliITSPidParams(const AliITSPidParams& rec);
   AliITSPidParams& operator=(const AliITSPidParams &source);
 
-  TFormula* fSDDPionMPV;         // pion dE/dx MPV vs. p in SDD
+  Double_t BetheBloch(Double_t mom, Double_t mass, const Double_t* p) const;
+  Double_t ExtrapolateWidth(Double_t mom, Double_t x1, Double_t y1, Double_t x2, Double_t y2) const;
+  
+  // Electron parameterizations
+  Double_t fSDDElecMPVBetheParams[5];         // Electron bethe block parameters in SDD
+  Double_t fSSDElecMPVBetheParams[5];         // Electron bethe block parameters in SSD
+  TFormula* fSDDElecLandauWidth; // Electron dE/dx Landau width vs. p in SDD
+  TFormula* fSDDElecGaussWidth;  // Electron dE/dx Gaussian width vs. p in SDD
+
+  TFormula* fSSDElecLandauWidth; // Electron dE/dx Landau width vs. p in SSD
+  TFormula* fSSDElecGaussWidth;  // Electron dE/dx Gaussian width vs. p in SSD
+  
+  // Hadron parameterizations
+  Double_t fSDDHadronMPVBetheParams[5];         // hadrons bethe block parameters in SDD
+  Double_t fSSDHadronMPVBetheParams[5];         // hadrons bethe block parameters in SSD
   TFormula* fSDDPionLandauWidth; // pion dE/dx Landau width vs. p in SDD
   TFormula* fSDDPionGaussWidth;  // pion dE/dx Gaussian width vs. p in SDD
 
-  TFormula* fSSDPionMPV;         // pion dE/dx MPV vs. p in SSD
   TFormula* fSSDPionLandauWidth; // pion dE/dx Landau width vs. p in SSD
   TFormula* fSSDPionGaussWidth;  // pion dE/dx Gaussian width vs. p in SSD
 
-  TFormula* fSDDKaonMPV;         // kaon dE/dx MPV vs. p in SDD
   TFormula* fSDDKaonLandauWidth; // kaon dE/dx Landau width vs. p in SDD
   TFormula* fSDDKaonGaussWidth;  // kaon dE/dx Gaussian width vs. p in SDD
 
-  TFormula* fSSDKaonMPV;         // kaon dE/dx MPV vs. p in SSD
   TFormula* fSSDKaonLandauWidth; // kaon dE/dx Landau width vs. p in SSD
   TFormula* fSSDKaonGaussWidth;  // kaon dE/dx Gaussian width vs. p in SSD
 
-  TFormula* fSDDProtMPV;         // kaon dE/dx MPV vs. p in SDD
-  TFormula* fSDDProtLandauWidth; // kaon dE/dx Landau width vs. p in SDD
-  TFormula* fSDDProtGaussWidth;  // kaon dE/dx Gaussian width vs. p in SDD
+  TFormula* fSDDProtLandauWidth; // Proton dE/dx Landau width vs. p in SDD
+  TFormula* fSDDProtGaussWidth;  // Proton dE/dx Gaussian width vs. p in SDD
 
-  TFormula* fSSDProtMPV;         // kaon dE/dx MPV vs. p in SSD
-  TFormula* fSSDProtLandauWidth; // kaon dE/dx Landau width vs. p in SSD
-  TFormula* fSSDProtGaussWidth;  // kaon dE/dx Gaussian width vs. p in SSD
+  TFormula* fSSDProtLandauWidth; // Proton dE/dx Landau width vs. p in SSD
+  TFormula* fSSDProtGaussWidth;  // Proton dE/dx Gaussian width vs. p in SSD
 
-  ClassDef(AliITSPidParams,1);
+
+  
+  ClassDef(AliITSPidParams,2);
 };
 #endif