+++ /dev/null
-/**************************************************************************
- * Copyright(c) 1998-1999, 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. *
- **************************************************************************/
-
-/* $Id$ */
-
-/////////////////////////////////////////////////////////
-//Class for PID in the ITS //
-// //
-// //
-/////////////////////////////////////////////////////////
-
-#include <Riostream.h>
-#include <TF1.h>
-#include <TMath.h>
-
-#include "AliITSPidParItem.h"
-
-ClassImp(AliITSPidParItem)
-//____________________________________________________________________
-AliITSPidParItem::AliITSPidParItem():
-fPCenter(0),
-fPWidth(0)
-{
- // default constructor
- for(Int_t i=0;i<39;i++){
- fBuff[i]=0;
- }
-}//____________________________________________________________________
-AliITSPidParItem::AliITSPidParItem(Float_t center,Float_t width,Double_t *buff):
-fPCenter(center),
-fPWidth(width)
-{
- // standard constructor
- for (Int_t i=0;i<39;i++) fBuff[i]=buff[i];
-
-}
-
-//____________________________________________________________________
-void AliITSPidParItem::GetParameters(Double_t *buff) const{
- //get all the parameters
- for (Int_t i=0;i<39;i++) buff[i]=fBuff[i];
-
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetProtonPar(Double_t *buffp) const{
- //get the protons' parameters (Width Landau, Most Probable, Area, Width Gaussian, Chi2 fit, NDF fit, Integral fit)
- buffp[0]=fBuff[0];
- buffp[1]=fBuff[1];
- buffp[2]=fBuff[2];
- buffp[3]=fBuff[3];
- buffp[4]=fBuff[8];
- buffp[5]=fBuff[9];
- buffp[6]=fBuff[10];
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetKaonPar(Double_t *buffk) const{
- //get the kaons' parameters (Width Landau, Most Probable, Area, Width Gaussian, Chi2 fit, NDF fit, Integral fit)
- buffk[0]=fBuff[13];
- buffk[1]=fBuff[14];
- buffk[2]=fBuff[15];
- buffk[3]=fBuff[16];
- buffk[4]=fBuff[21];
- buffk[5]=fBuff[22];
- buffk[6]=fBuff[23];
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetPionPar(Double_t *buffpi) const{
- //get the pions' parameters (Width Landau, Most Probable, Area, Width Gaussian, Chi2 fit, NDF fit, Integral fit)
- buffpi[0]=fBuff[26];
- buffpi[1]=fBuff[27];
- buffpi[2]=fBuff[28];
- buffpi[3]=fBuff[29];
- buffpi[4]=fBuff[34];
- buffpi[5]=fBuff[35];
- buffpi[6]=fBuff[36];
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetPar0(Double_t *buff0) const{
- //Width Landau for protons, kaons, pions.
- buff0[0]=fBuff[0];
- buff0[1]=fBuff[13];
- buff0[2]=fBuff[26];
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetPar1(Double_t *buff1) const{
- //Most Probable for protons, kaons, pions.
- buff1[0]=fBuff[1];
- buff1[1]=fBuff[14];
- buff1[2]=fBuff[27];
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetPar2(Double_t *buff2) const{
- //Area for protons, kaons, pions.
- buff2[0]=fBuff[2];
- buff2[1]=fBuff[15];
- buff2[2]=fBuff[28];
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetPar3(Double_t *buff3) const{
- //Width Gaussian for protons, kaons, pions.
- buff3[0]=fBuff[3];
- buff3[1]=fBuff[16];
- buff3[2]=fBuff[29];
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetChisquare(Double_t *buffchi) const{
- //Chi2 of the fit for protons, kaons, pions.
- buffchi[0]=fBuff[8];
- buffchi[1]=fBuff[21];
- buffchi[2]=fBuff[34];
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetNDF(Double_t *buffndf) const{
- //NDF of the fit for protons, kaons, pions.
- buffndf[0]=fBuff[9];
- buffndf[1]=fBuff[22];
- buffndf[2]=fBuff[35];
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetProParFun(Double_t *pfun) const{
- //some Protons parameters: Width Landau, Most Probable, Area, Width Gaussian, Integral fit
- pfun[0]=fBuff[0];
- pfun[1]=fBuff[1];
- pfun[2]=fBuff[2];
- pfun[3]=fBuff[3];
- pfun[4]=fBuff[10];
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetKaoParFun(Double_t *kfun) const{
- //some Kaons parameters: Width Landau, Most Probable, Area, Width Gaussian, Integral fit
- kfun[0]=fBuff[13];
- kfun[1]=fBuff[14];
- kfun[2]=fBuff[15];
- kfun[3]=fBuff[16];
- kfun[4]=fBuff[23];
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetPiParFun(Double_t *pifun) const{
- //some Pions parameters: Width Landau, Most Probable, Area, Width Gaussian, Integral fit
- pifun[0]=fBuff[26];
- pifun[1]=fBuff[27];
- pifun[2]=fBuff[28];
- pifun[3]=fBuff[29];
- pifun[4]=fBuff[36];
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetRangeLim(Double_t *range) const{
- //Range limits for the response functions
- range[0]=fBuff[11];//proton low
- range[1]=fBuff[12];//proton high
- range[2]=fBuff[24];//kaon low
- range[3]=fBuff[25];//kaon high
- range[4]=fBuff[37];//pion low
- range[5]=fBuff[38];//pion high
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetProtonParErr(Double_t *bufferp)const{
- //errors on the protons' parameters
- bufferp[0]=fBuff[4];
- bufferp[1]=fBuff[5];
- bufferp[2]=fBuff[6];
- bufferp[3]=fBuff[7];
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetKaonParErr(Double_t *bufferk)const{
- //errors on the kaons' parameters
- bufferk[0]=fBuff[17];
- bufferk[1]=fBuff[18];
- bufferk[2]=fBuff[19];
- bufferk[3]=fBuff[20];
-}
-//____________________________________________________________________
-void AliITSPidParItem::GetPionParErr(Double_t *bufferpi)const{
- //errors on the pions' parameters
- bufferpi[0]=fBuff[30];
- bufferpi[1]=fBuff[31];
- bufferpi[2]=fBuff[32];
- bufferpi[3]=fBuff[33];
-}
-//____________________________________________________________________
-void AliITSPidParItem::PrintParameters() const {
- // Prints the data members of this class
-cout<<"==============================***************"<<endl;
-cout<<"Momentum (GeV/c) - center of the bin - "<<fPCenter<<endl;
-cout<<" Width of momentum bin (GeV/c) "<<fPWidth<<endl;
-for (Int_t i=0;i<39;i++) cout<<"Parameter"<<i<<" = "<<fBuff[i]<<endl;
-
-}
-
-//_______________________________________________________________________
-TF1* AliITSPidParItem::CookFunIts(TString namefun,Double_t *par,Double_t rangei,Double_t rangef,TString comment){
- //
- TF1 *fun;
- if (par[4]!=0) {
- fun=new TF1(comment,Langaufun2,rangei,rangef,5);
- fun->SetParameters(par);
-
- }
- else {fun=new TF1(namefun,"0");}
- return fun;
-}
-
-//_________________________________________________________________________
-Double_t AliITSPidParItem::Langaufun(Double_t *x, Double_t *par) {
-
- //Fit parameters:
- //par[0]=Width (scale) parameter of Landau density
- //par[1]=Most Probable (MP, location) parameter of Landau density
- //par[2]=Total area (integral -inf to inf, normalization constant)
- //par[3]=Width (sigma) of convoluted Gaussian function
- //
- //In the Landau distribution (represented by the CERNLIB approximation),
- //the maximum is located at x=-0.22278298 with the location parameter=0.
- //This shift is corrected within this function, so that the actual
- //maximum is identical to the MP parameter.
-
- // Numeric constants
- Double_t invsq2pi = 0.3989422804014; // (2 pi)^(-1/2)
- Double_t mpshift = -0.22278298; // Landau maximum location
-
- // Control constants
- Double_t np = 100.0; // number of convolution steps
- Double_t sc = 5.0; // convolution extends to +-sc Gaussian sigmas
-
- // Variables
- Double_t xx;
- Double_t mpc;
- Double_t fland;
- Double_t sum = 0.0;
- Double_t xlow,xupp;
- Double_t step;
- Double_t i;
-
-
- // MP shift correction
- mpc = par[1] - mpshift * par[0];
-
- // Range of convolution integral
- xlow = x[0] - sc * par[3];
- xupp = x[0] + sc * par[3];
-
- step = (xupp-xlow) / np;
-
- // Convolution integral of Landau and Gaussian by sum
- for(i=1.0; i<=np/2; i++) {
- xx = xlow + (i-.5) * step;
- fland = TMath::Landau(xx,mpc,par[0]) / par[0];
- sum += fland * TMath::Gaus(x[0],xx,par[3]);
-
- xx = xupp - (i-.5) * step;
- fland = TMath::Landau(xx,mpc,par[0]) / par[0];
- sum += fland * TMath::Gaus(x[0],xx,par[3]);
- }
-
- return (par[2] * step * sum * invsq2pi / par[3]);
-}
-//_______________________________________________________________________
-Double_t AliITSPidParItem::Langaufun2(Double_t *x, Double_t *par){
- //
- return 1/par[4]*Langaufun(x,par);
-}
+++ /dev/null
-#ifndef AliITSPIDPARITEM_H
-#define AliITSPIDPARITEM_H
-//////////////////////////////////////////////////////////
-//Class for PID in the ITS //
-//Origin: Elena Bruna bruna@to.infn.it //
-//////////////////////////////////////////////////////////
-
-class AliITSPidParItem : public TObject{
-
- public:
- AliITSPidParItem();
- AliITSPidParItem(Float_t center,Float_t width,Double_t *buff);
- virtual ~AliITSPidParItem(){;}
- Float_t GetMomentumCenter() const {return fPCenter;}
- Float_t GetWidthMom() const {return fPWidth;}
- void GetParameters(Double_t *buff) const;
- void PrintParameters() const;
- void GetProtonPar(Double_t *buffp) const;
- void GetKaonPar(Double_t *buffk) const;
- void GetPionPar(Double_t *buffpi) const;
- void GetPar0(Double_t *buff0) const;
- void GetPar1(Double_t *buff1) const;
- void GetPar2(Double_t *buff2) const;
- void GetPar3(Double_t *buff3) const;
- void GetChisquare(Double_t *buffchi) const;
- void GetNDF(Double_t *buffndf) const;
- void GetProParFun(Double_t *pfun) const;
- void GetKaoParFun(Double_t *kfun) const;
- void GetPiParFun(Double_t *pifun) const;
- void GetRangeLim(Double_t *range) const;
- void GetProtonParErr(Double_t *bufferp)const;
- void GetKaonParErr(Double_t *bufferk)const;
- void GetPionParErr(Double_t *bufferpi) const;
- static TF1* CookFunIts(TString namefun,Double_t *par,Double_t rangei,Double_t rangef,TString comment);
- static Double_t Langaufun(Double_t *x, Double_t *par);
- static Double_t Langaufun2(Double_t *x, Double_t *par);
-
- private:
- Float_t fPCenter; //value for center
- Float_t fPWidth; //value for width
- Double_t fBuff[39]; //array for PID parameters
-
- ClassDef(AliITSPidParItem,1);
-};
-#endif
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 2007-2009, 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. *
+ **************************************************************************/
+
+/* $Id: */
+
+///////////////////////////////////////////////////////////////////
+// //
+// Implementation of the class to store parameters of ITS //
+// response funcions for dE/dx based PID //
+// Origin: F.Prino, Torino, prino@to.infn.it //
+// //
+///////////////////////////////////////////////////////////////////
+
+#include <TFormula.h>
+#include <TNamed.h>
+#include <TMath.h>
+#include "AliITSPidParams.h"
+#include "AliPID.h"
+
+ClassImp(AliITSPidParams)
+
+//______________________________________________________________________
+AliITSPidParams::AliITSPidParams():
+ TNamed("default",""),
+ fSDDPionMPV(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)
+{
+ // default constructor
+ InitDefaults();
+}
+//______________________________________________________________________
+AliITSPidParams::AliITSPidParams(Char_t * name):
+ TNamed(name,""),
+ fSDDPionMPV(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)
+{
+ // standard constructor
+ InitDefaults();
+}
+//______________________________________________________________________
+AliITSPidParams::~AliITSPidParams(){
+ //
+ if(fSDDPionMPV) delete fSDDPionMPV;
+ 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;
+}
+
+//______________________________________________________________________
+void AliITSPidParams::InitDefaults(){
+ // initialize TFormulas to default values (=p-p simulations PYTHIA+GEANT)
+ // parameter values from Emanuele Biolcati
+
+ // pions
+ if(fSDDPionMPV) delete fSDDPionMPV;
+ fSDDPionMPV=new TFormula("fSDDPionMPV","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]*TMath::Log(x*x)+[3]");
+ fSDDPionMPV->SetParameters(1.4831933,-0.000403,3.9722756,92.710680);
+
+ if(fSDDPionLandauWidth) delete fSDDPionLandauWidth;
+ fSDDPionLandauWidth=new TFormula("fSDDPionLandauWidth","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSDDPionLandauWidth->SetParameters(-0.091098,-0.001355,8.3019280);
+
+ if(fSDDPionGaussWidth) delete fSDDPionGaussWidth;
+ fSDDPionGaussWidth=new TFormula("fSDDPionGaussWidth","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSDDPionGaussWidth->SetParameters(-0.129570,-0.002686,15.287701);
+
+ if(fSSDPionMPV) delete fSSDPionMPV;
+ fSSDPionMPV=new TFormula("fSSDPionMPV","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]*TMath::Log(x*x)+[3]");
+ fSSDPionMPV->SetParameters(1.2455667,-0.000743,3.2260119,84.237030);
+
+ if(fSSDPionLandauWidth) delete fSSDPionLandauWidth;
+ fSSDPionLandauWidth=new TFormula("fSSDPionLandauWidth","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSSDPionLandauWidth->SetParameters(-0.083918,-0.001246,7.4750478);
+
+ if(fSSDPionGaussWidth) delete fSSDPionGaussWidth;
+ fSSDPionGaussWidth=new TFormula("fSSDPionGaussWidth","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSSDPionGaussWidth->SetParameters(-0.140441,-0.002984,10.936747);
+
+ // kaons
+ if(fSDDKaonMPV) delete fSDDKaonMPV;
+ fSDDKaonMPV=new TFormula("fSDDKaonMPV","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSDDKaonMPV->SetParameters(16.998674,-0.058006,89.660709);
+
+ if(fSDDKaonLandauWidth) delete fSDDKaonLandauWidth;
+ fSDDKaonLandauWidth=new TFormula("fSDDKaonLandauWidth","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSDDKaonLandauWidth->SetParameters(1.0014235,-5.61e-15,9.2672327);
+
+ if(fSDDKaonGaussWidth) delete fSDDKaonGaussWidth;
+ fSDDKaonGaussWidth=new TFormula("fSDDKaonGaussWidth","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSDDKaonGaussWidth->SetParameters(0.7919025,-0.103579,14.016803);
+
+ if(fSSDKaonMPV) delete fSSDKaonMPV;
+ fSSDKaonMPV=new TFormula("fSSDKaonMPV","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSSDKaonMPV->SetParameters(14.090845,-0.087253,81.782088);
+
+ if(fSSDKaonLandauWidth) delete fSSDKaonLandauWidth;
+ fSSDKaonLandauWidth=new TFormula("fSSDKaonLandauWidth","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSSDKaonLandauWidth->SetParameters(1.0769127,-9.06e-13,7.5221492);
+
+ if(fSSDKaonGaussWidth) delete fSSDKaonGaussWidth;
+ fSSDKaonGaussWidth=new TFormula("fSSDKaonGaussWidth","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSSDKaonGaussWidth->SetParameters(0.5155878,-0.098696,10.771975);
+
+ // protons
+ if(fSDDProtMPV) delete fSDDProtMPV;
+ fSDDProtMPV=new TFormula("fSDDProtMPV","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSDDProtMPV->SetParameters(70.325146,0.0386808,87.797052);
+
+ if(fSDDProtLandauWidth) delete fSDDProtLandauWidth;
+ fSDDProtLandauWidth=new TFormula("fSDDProtLandauWidth","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSDDProtLandauWidth->SetParameters(4.0476840,-3.77e-14,10.294707);
+
+ if(fSDDProtGaussWidth) delete fSDDProtGaussWidth;
+ fSDDProtGaussWidth=new TFormula("fSDDProtGaussWidth","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSDDProtGaussWidth->SetParameters(5.9780498,-2.16e-11,13.357744);
+
+ if(fSSDProtMPV) delete fSSDProtMPV;
+ fSSDProtMPV=new TFormula("fSSDProtMPV","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSSDProtMPV->SetParameters(58.918831,-0.303855,80.341765);
+
+ if(fSSDProtLandauWidth) delete fSSDProtLandauWidth;
+ fSSDProtLandauWidth=new TFormula("fSSDProtLandauWidth","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSSDProtLandauWidth->SetParameters(3.0814273,-1.26e-13,8.8353833);
+
+ if(fSSDProtGaussWidth) delete fSSDProtGaussWidth;
+ fSSDProtGaussWidth=new TFormula("fSSDProtGaussWidth","[0]/(x*x)+[1]/(x*x*x*x)*TMath::Log(x*x)+[2]");
+ fSSDProtGaussWidth->SetParameters(5.6177229,-1.67e-13,10.538921);
+
+}
+//_______________________________________________________________________
+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);
+ 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.;
+}
+//_______________________________________________________________________
+ 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];
+ Bool_t isSet=kFALSE;
+ if(partType==AliPID::kPion){
+ if(lay==3 || lay==4){
+ par[0]=GetSDDPionLandauWidth(mom);
+ par[1]=GetSDDPionMPV(mom);
+ par[2]=GetSDDPionGaussWidth(mom);
+ isSet=kTRUE;
+ }
+ else if(lay==5 || lay==6){
+ par[0]=GetSSDPionLandauWidth(mom);
+ par[1]=GetSSDPionMPV(mom);
+ par[2]=GetSSDPionGaussWidth(mom);
+ isSet=kTRUE;
+ }
+ }else if(partType==AliPID::kKaon){
+ if(lay==3 || lay==4){
+ par[0]=GetSDDKaonLandauWidth(mom);
+ par[1]=GetSDDKaonMPV(mom);
+ par[2]=GetSDDKaonGaussWidth(mom);
+ isSet=kTRUE;
+ }
+ else if(lay==5 || lay==6){
+ par[0]=GetSSDKaonLandauWidth(mom);
+ par[1]=GetSSDKaonMPV(mom);
+ par[2]=GetSSDKaonGaussWidth(mom);
+ isSet=kTRUE;
+ }
+ }else if(partType==AliPID::kProton){
+ if(lay==3 || lay==4){
+ par[0]=GetSDDProtLandauWidth(mom);
+ par[1]=GetSDDProtMPV(mom);
+ par[2]=GetSDDProtGaussWidth(mom);
+ isSet=kTRUE;
+ }
+ else if(lay==5 || lay==6){
+ par[0]=GetSSDProtLandauWidth(mom);
+ par[1]=GetSSDProtMPV(mom);
+ par[2]=GetSSDProtGaussWidth(mom);
+ isSet=kTRUE;
+ }
+ }
+ if(!isSet) return 0.;
+ // Numeric constants
+ Double_t invsq2pi = 0.3989422804014; // (2 pi)^(-1/2)
+ Double_t mpshift = -0.22278298; // Landau maximum location
+ // Control constants
+ Double_t np = 100.0; // number of convolution steps
+ Double_t sc = 5.0; // convolution extends to +-sc Gaussian sigmas
+ // Variables
+ Double_t xx;
+ Double_t mpc;
+ Double_t fland;
+ Double_t sum = 0.0;
+ Double_t xlow,xupp;
+ Double_t step;
+ Double_t i;
+
+ // MP shift correction
+ mpc = par[1] - mpshift * par[0];
+ // Range of convolution integral
+ xlow = dedx - sc * par[2];
+ xupp = dedx + sc * par[2];
+ if(np!=0) step = (xupp-xlow) / np;
+
+ // Convolution integral of Landau and Gaussian by sum
+ for(i=1.0; i<=np/2; i++) {
+ xx = xlow + (i-.5) * step;
+
+ fland = TMath::Landau(xx,mpc,par[0]) / par[0];
+ sum += fland * TMath::Gaus(dedx,xx,par[2]);
+
+ xx = xupp - (i-.5) * step;
+ fland = TMath::Landau(xx,mpc,par[0]) / par[0];
+ sum += fland * TMath::Gaus(dedx,xx,par[2]);
+ }
+
+ return (step * sum * invsq2pi / par[2]);
+}
+
--- /dev/null
+#ifndef ALIITSPIDPARAMS_H
+#define ALIITSPIDPARAMS_H
+/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id: $ */
+
+///////////////////////////////////////////////////////////////////
+// //
+// Class to store parameters of ITS response funcions //
+// Origin: F.Prino, Torino, prino@to.infn.it //
+// //
+///////////////////////////////////////////////////////////////////
+
+#include <TFormula.h>
+#include <TNamed.h>
+
+class AliITSPidParams : public TNamed {
+
+ public:
+ AliITSPidParams();
+ AliITSPidParams(Char_t * name);
+ ~AliITSPidParams();
+
+ void InitDefaults();
+ 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(TFormula* form){
+ if(fSDDPionMPV) delete fSDDPionMPV;
+ fSDDPionMPV=new TFormula(*form);
+ }
+ void SetSDDPionLandauWidth(TFormula* form){
+ if(fSDDPionLandauWidth) delete fSDDPionLandauWidth;
+ fSDDPionLandauWidth=new TFormula(*form);
+ }
+ void SetSDDPionGaussWidth(TFormula* form){
+ if(fSDDPionGaussWidth) delete fSDDPionGaussWidth;
+ fSDDPionGaussWidth=new TFormula(*form);
+ }
+ void SetSSDPionMPV(TFormula* form){
+ if(fSSDPionMPV) delete fSSDPionMPV;
+ fSSDPionMPV=new TFormula(*form);
+ }
+ void SetSSDPionLandauWidth(TFormula* form){
+ if(fSSDPionLandauWidth) delete fSSDPionLandauWidth;
+ fSSDPionLandauWidth=new TFormula(*form);
+ }
+ void SetSSDPionGaussWidth(TFormula* form){
+ if(fSSDPionGaussWidth) delete fSSDPionGaussWidth;
+ fSSDPionGaussWidth=new TFormula(*form);
+ }
+
+ // kaon setters
+ void SetSDDKaonMPV(TFormula* form){
+ if(fSDDKaonMPV) delete fSDDKaonMPV;
+ fSDDKaonMPV=new TFormula(*form);
+ }
+ void SetSDDKaonLandauWidth(TFormula* form){
+ if(fSDDKaonLandauWidth) delete fSDDKaonLandauWidth;
+ fSDDKaonLandauWidth=new TFormula(*form);
+ }
+ void SetSDDKaonGaussWidth(TFormula* form){
+ if(fSDDKaonGaussWidth) delete fSDDKaonGaussWidth;
+ fSDDKaonGaussWidth=new TFormula(*form);
+ }
+ void SetSSDKaonMPV(TFormula* form){
+ if(fSSDKaonMPV) delete fSSDKaonMPV;
+ fSSDKaonMPV=new TFormula(*form);
+ }
+ void SetSSDKaonLandauWidth(TFormula* form){
+ if(fSSDKaonLandauWidth) delete fSSDKaonLandauWidth;
+ fSSDKaonLandauWidth=new TFormula(*form);
+ }
+ void SetSSDKaonGaussWidth(TFormula* form){
+ if(fSSDKaonGaussWidth) delete fSSDKaonGaussWidth;
+ fSSDKaonGaussWidth=new TFormula(*form);
+ }
+
+
+ // proton setters
+ void SetSDDProtMPV(TFormula* form){
+ if(fSDDProtMPV) delete fSDDProtMPV;
+ fSDDProtMPV=new TFormula(*form);
+ }
+ void SetSDDProtLandauWidth(TFormula* form){
+ if(fSDDProtLandauWidth) delete fSDDProtLandauWidth;
+ fSDDProtLandauWidth=new TFormula(*form);
+ }
+ void SetSDDProtGaussWidth(TFormula* form){
+ if(fSDDProtGaussWidth) delete fSDDProtGaussWidth;
+ fSDDProtGaussWidth=new TFormula(*form);
+ }
+ void SetSSDProtMPV(TFormula* form){
+ if(fSSDProtMPV) delete fSSDProtMPV;
+ fSSDProtMPV=new TFormula(*form);
+ }
+ void SetSSDProtLandauWidth(TFormula* form){
+ if(fSSDProtLandauWidth) delete fSSDProtLandauWidth;
+ fSSDProtLandauWidth=new TFormula(*form);
+ }
+ void SetSSDProtGaussWidth(TFormula* form){
+ if(fSSDProtGaussWidth) delete fSSDProtGaussWidth;
+ fSSDProtGaussWidth=new TFormula(*form);
+ }
+
+
+ // pion getters
+ Double_t GetSDDPionMPV(Double_t mom) const {
+ return fSDDPionMPV->Eval(mom);
+ }
+ Double_t GetSDDPionLandauWidth(Double_t mom) const {
+ return fSDDPionLandauWidth->Eval(mom);
+ }
+ Double_t GetSDDPionGaussWidth(Double_t mom) const {
+ return fSDDPionGaussWidth->Eval(mom);
+ }
+ Double_t GetSSDPionMPV(Double_t mom) const {
+ return fSSDPionMPV->Eval(mom);
+ }
+ Double_t GetSSDPionLandauWidth(Double_t mom) const {
+ return fSSDPionLandauWidth->Eval(mom);
+ }
+ Double_t GetSSDPionGaussWidth(Double_t mom) const {
+ return fSSDPionGaussWidth->Eval(mom);
+ }
+
+ // kaon getters
+ Double_t GetSDDKaonMPV(Double_t mom) const {
+ return fSDDKaonMPV->Eval(mom);
+ }
+ Double_t GetSDDKaonLandauWidth(Double_t mom) const {
+ return fSDDKaonLandauWidth->Eval(mom);
+ }
+ Double_t GetSDDKaonGaussWidth(Double_t mom) const {
+ return fSDDKaonGaussWidth->Eval(mom);
+ }
+ Double_t GetSSDKaonMPV(Double_t mom) const {
+ return fSSDKaonMPV->Eval(mom);
+ }
+ Double_t GetSSDKaonLandauWidth(Double_t mom) const {
+ return fSSDKaonLandauWidth->Eval(mom);
+ }
+ Double_t GetSSDKaonGaussWidth(Double_t mom) const {
+ return fSSDKaonGaussWidth->Eval(mom);
+ }
+
+ // proton getters
+ Double_t GetSDDProtMPV(Double_t mom) const {
+ return fSDDProtMPV->Eval(mom);
+ }
+ Double_t GetSDDProtLandauWidth(Double_t mom) const {
+ return fSDDProtLandauWidth->Eval(mom);
+ }
+ Double_t GetSDDProtGaussWidth(Double_t mom) const {
+ return fSDDProtGaussWidth->Eval(mom);
+ }
+ Double_t GetSSDProtMPV(Double_t mom) const {
+ return fSSDProtMPV->Eval(mom);
+ }
+ Double_t GetSSDProtLandauWidth(Double_t mom) const {
+ return fSSDProtLandauWidth->Eval(mom);
+ }
+ Double_t GetSSDProtGaussWidth(Double_t mom) const {
+ return fSSDProtGaussWidth->Eval(mom);
+ }
+
+ private:
+
+ AliITSPidParams(const AliITSPidParams& rec);
+ AliITSPidParams& operator=(const AliITSPidParams &source);
+
+ TFormula* fSDDPionMPV; // pion dE/dx MPV vs. p in SDD
+ 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* 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
+
+ ClassDef(AliITSPidParams,1);
+};
+#endif
// Origin: Elena Bruna bruna@to.infn.it,, Massimo Masera masera@to.infn.it//
//////////////////////////////////////////////////////////////////////////
#include "AliESDtrack.h"
+#include "AliITSPidParams.h"
+#include "AliPID.h"
#include "AliITSPident.h"
-#include "AliITSSteerPid.h"
-#include <Riostream.h>
ClassImp(AliITSPident)
//_______________________________________________________________________
AliITSPident::AliITSPident():
-fMom(0),
fPBayesp(0),
fPBayesk(0),
fPBayespi(0),
fCondFunKLay[i]=0;
fCondFunPiLay[i]=0;
}
- for (Int_t i=0;i<4;i++)fNcls[i]=0;
}
//_______________________________________________________________________
AliITSPident::~AliITSPident(){
// destructor
}
-//______________________________________________________________________
-AliITSPident::AliITSPident(const AliITSPident &ob) :TObject(ob),
-fMom(ob.fMom),
-fPBayesp(ob.fPBayesp),
-fPBayesk(ob.fPBayesk),
-fPBayespi(ob.fPBayespi),
-fPPriorip(ob.fPPriorip),
-fPPriorik(ob.fPPriorik),
-fPPrioripi(ob.fPPrioripi),
-fPPriorie(ob.fPPriorie)
-{
- // Copy constructor
-}
-
-//______________________________________________________________________
-AliITSPident& AliITSPident::operator=(const AliITSPident& ob){
- // Assignment operator
- this->~AliITSPident();
- new(this) AliITSPident(ob);
- return *this;
-}
-
-
//_______________________________________________________________________
-AliITSPident::AliITSPident(Double_t mom,AliITSSteerPid *sp,Float_t *Qlay,Float_t *nlay,Float_t priorip,Float_t priorik,Float_t prioripi,Float_t priorie):
-fMom(mom),
+AliITSPident::AliITSPident(Double_t mom,AliITSPidParams *pars, Double_t *Qlay,Double_t priorip,Double_t priorik,Double_t prioripi,Double_t priorie):
fPBayesp(0),
fPBayesk(0),
fPBayespi(0),
fPPriorie(priorie)
{
//
- for (Int_t i=0;i<8;i++){
- fCondFunProLay[i]=-1;
- fCondFunKLay[i]=-1;
- fCondFunPiLay[i]=-1;
- }
- for(Int_t la=0;la<4;la++){//loop on layers
- Double_t parp[3];Double_t park[3];Double_t parpi[3];
- fNcls[la]=0;
- Double_t range[6];
- range[0]=0.3*parp[1];
- range[1]=2.*parp[1];
-
- range[2]=0.3*park[1];
- range[3]=2.*park[1];
-
- range[4]=0.3*parpi[1];
- range[5]=2.*parpi[1];
- Int_t layer=la+2;
- for(Int_t ii=0;ii<8;ii++){
- if(nlay[ii]==layer){
- fNcls[la]++;
- if(Qlay[ii]>0){
- sp->GetParFitLayer(la,fMom,parp,park,parpi);
- CookFunItsLay(ii,0,parp,Qlay[ii],fMom,range[0],range[1],"fPro");
- CookFunItsLay(ii,1,park,Qlay[ii],fMom,range[2],range[3],"fKao");
- CookFunItsLay(ii,2,parpi,Qlay[ii],fMom,range[4],range[5],"fPi");
- }
- }
- }
-
- }
-
- Float_t prior[4];Double_t condFun[8][3];
-
- prior[0]=fPPriorip;
- prior[1]=fPPriorik;
- prior[2]=fPPrioripi;
- prior[3]=fPPriorie;
- for(Int_t la=0;la<8;la++){
- condFun[la][0]= fCondFunProLay[la];
- condFun[la][1]= fCondFunKLay[la];
- condFun[la][2]= fCondFunPiLay[la];
-
- }
-
- fPBayesp=CookCombinedBayes(condFun,prior,0);
- fPBayesk=CookCombinedBayes(condFun,prior,1);
- fPBayespi=CookCombinedBayes(condFun,prior,2);
+ CalculateResponses(mom,pars,Qlay);
}
-
//__________________________________________________________________________________________
-AliITSPident::AliITSPident(AliESDtrack *track,AliITSSteerPid *sp,Float_t *Qlay,Float_t *nlay,Float_t priorip,Float_t priorik,Float_t prioripi,Float_t priorie):
-fMom(0),
+AliITSPident::AliITSPident(AliESDtrack *track,AliITSPidParams *pars,Double_t priorip,Double_t priorik,Double_t prioripi,Double_t priorie):
fPBayesp(0),
fPBayesk(0),
fPBayespi(0),
fPPriorie(priorie)
{
//
+ Double_t mom=track->GetP();
+ Double_t Qlay[4]={0.,0.,0.,0.};
+ track->GetITSdEdxSamples(Qlay);
+ CalculateResponses(mom,pars,Qlay);
+}
+//_______________________________________________________________________
+void AliITSPident::CalculateResponses(Double_t mom,AliITSPidParams *pars, Double_t *Qlay){
+ // calculates conditional probabilities
+
for (Int_t i=0;i<8;i++){
fCondFunProLay[i]=-1;
fCondFunKLay[i]=-1;
fCondFunPiLay[i]=-1;
}
- Double_t xr;
- Double_t par[5];
- track->GetExternalParameters(xr,par);
- if (par[4]!=0) {
- Float_t lamb=TMath::ATan(par[3]);
- fMom=1/(TMath::Abs(par[4])*TMath::Cos(lamb));
- }
-
-
- for(Int_t la=0;la<4;la++){//loop on layers
- Double_t parp[3];Double_t park[3];Double_t parpi[3];
- fNcls[la]=0;
- Double_t range[8];
- range[0]=0.3*parp[1];
- range[1]=2.*parp[1];
- range[2]=0.3*park[1];
- range[3]=2.*park[1];
-
- range[4]=0.3*parpi[1];
- range[5]=2.*parpi[1];
-
- Int_t layer=la+2;
- for(Int_t ii=0;ii<8;ii++){
- if(nlay[ii]==layer){
- fNcls[la]++;
- if(Qlay[ii]>0){
- sp->GetParFitLayer(la,fMom,parp,park,parpi);
- CookFunItsLay(ii,0,parp,Qlay[ii],fMom,range[0],range[1],"fPro");
- CookFunItsLay(ii,1,park,Qlay[ii],fMom,range[2],range[3],"fKao");
- CookFunItsLay(ii,2,parpi,Qlay[ii],fMom,range[4],range[5],"fPi");
- }
- }
+ for(Int_t iLay=0; iLay<4; iLay++){//loop on layers (3=SDD inner 6=SSD outer)
+ Double_t dedx=Qlay[iLay];
+ if(dedx>0){
+ fCondFunProLay[iLay]=pars->GetLandauGausNorm(dedx,AliPID::kProton,mom,iLay+3);
+ if(mom<0.4 && dedx<100)fCondFunProLay[iLay]=0.00001;
+ if(mom<0.4 &&dedx<50)fCondFunProLay[iLay]=0.0000001;
+ fCondFunKLay[iLay]=pars->GetLandauGausNorm(dedx,AliPID::kKaon,mom,iLay+3);
+ if(mom<0.25 && dedx<100)fCondFunKLay[iLay]=0.00001;
+ if(mom<0.4 &&dedx<30)fCondFunKLay[iLay]=0.0000001;
+ fCondFunPiLay[iLay]=pars->GetLandauGausNorm(dedx,AliPID::kPion,mom,iLay+3);
+ if(mom<0.6 &&dedx<20)fCondFunPiLay[iLay]=0.001;
}
-
}
-
- Float_t prior[4];Double_t condFun[8][3];
+ Double_t prior[4];
+ Double_t condFun[8][3];
prior[0]=fPPriorip;
prior[1]=fPPriorik;
prior[2]=fPPrioripi;
prior[3]=fPPriorie;
- for(Int_t la=0;la<8;la++){
- condFun[la][0]= fCondFunProLay[la];
- condFun[la][1]= fCondFunKLay[la];
- condFun[la][2]= fCondFunPiLay[la];
-
+ for(Int_t iLay=0;iLay<8;iLay++){
+ condFun[iLay][0]= fCondFunProLay[iLay];
+ condFun[iLay][1]= fCondFunKLay[iLay];
+ condFun[iLay][2]= fCondFunPiLay[iLay];
}
fPBayesp=CookCombinedBayes(condFun,prior,0);
fPBayesk=CookCombinedBayes(condFun,prior,1);
fPBayespi=CookCombinedBayes(condFun,prior,2);
-
}
//_______________________________________________________________________
-void AliITSPident::GetNclsPerLayer(Int_t *ncls) const{
- //number of clusters for each layer (sdd1,sdd2,ssd1,ssd2)
- for(Int_t la=0;la<4;la++){
- ncls[la]=fNcls[la];
- }
-
-}//_______________________________________________________________________
Double_t AliITSPident::GetProdCondFunPro() const {
//Product of conditional probability functions for protons
Double_t rv=1.;
//_______________________________________________________________________
Double_t AliITSPident::GetProdCondFunPi() const {
//Product of conditional probability functions for pions
- Double_t rv=1.;
- for(Int_t i=0;i<8;i++){
- Double_t fun=GetCondFunPi(i);
- if(fun>=0)rv*=fun;
- }
- return rv;
-}
-//_______________________________________________________________________
-void AliITSPident::PrintParameters() const{
- //print parameters
- cout<<"___________________________\n";
- cout<<"Track Local Momentum = "<<" "<<fMom<<endl;
-}
-
-//_______________________________________________________________________
-Double_t AliITSPident::Langaufun(Double_t *x, Double_t *par) {
-
- //Fit parameters:
- //par[0]=Width (scale) parameter of Landau density
- //par[1]=Most Probable (MP, location) parameter of Landau density
- //par[2]=Total area (integral -inf to inf, normalization constant)
- //par[3]=Width (sigma) of convoluted Gaussian function
- //
- //In the Landau distribution (represented by the CERNLIB approximation),
- //the maximum is located at x=-0.22278298 with the location parameter=0.
- //This shift is corrected within this function, so that the actual
- //maximum is identical to the MP parameter.
-
- // Numeric constants
- Double_t invsq2pi = 0.3989422804014; // (2 pi)^(-1/2)
- Double_t mpshift = -0.22278298; // Landau maximum location
-
- // Control constants
- Double_t np = 100.0; // number of convolution steps
- Double_t sc = 5.0; // convolution extends to +-sc Gaussian sigmas
-
- // Variables
- Double_t xx;
- Double_t mpc;
- Double_t fland;
- Double_t sum = 0.0;
- Double_t xlow,xupp;
- Double_t step;
- Double_t i;
-
-
- // MP shift correction
- mpc = par[1] - mpshift * par[0];
-
- // Range of convolution integral
- xlow = x[0] - sc * par[3];
- xupp = x[0] + sc * par[3];
-
- step = (xupp-xlow) / np;
-
- // Convolution integral of Landau and Gaussian by sum
- for(i=1.0; i<=np/2; i++) {
- xx = xlow + (i-.5) * step;
- fland = TMath::Landau(xx,mpc,par[0]) / par[0];
- sum += fland * TMath::Gaus(x[0],xx,par[3]);
-
- xx = xupp - (i-.5) * step;
- fland = TMath::Landau(xx,mpc,par[0]) / par[0];
- sum += fland * TMath::Gaus(x[0],xx,par[3]);
- }
-
- return (par[2] * step * sum * invsq2pi / par[3]);
-}
-
-//_______________________________________________________________________
-Double_t AliITSPident::Langaufun2(Double_t *x, Double_t *par){
- //normalized langaufun
- return 1/par[4]*Langaufun(x,par);
-}
-//_______________________________________________________________________
-Double_t AliITSPident::Langaufunnorm(Double_t *x, Double_t *par){
- //Fit parameters:
- //par[0]=Width (scale) parameter of Landau density
- //par[1]=Most Probable (MP, location) parameter of Landau density
-
- //par[2]=Width (sigma) of convoluted Gaussian function
- //
- //In the Landau distribution (represented by the CERNLIB approximation),
- //the maximum is located at x=-0.22278298 with the location parameter=0.
- //This shift is corrected within this function, so that the actual
- //maximum is identical to the MP parameter.
-
- // Numeric constants
- Double_t invsq2pi = 0.3989422804014; // (2 pi)^(-1/2)
- Double_t mpshift = -0.22278298; // Landau maximum location
-
- // Control constants
- Double_t np = 100.0; // number of convolution steps
- Double_t sc = 5.0; // convolution extends to +-sc Gaussian sigmas
-
- // Variables
- Double_t xx;
- Double_t mpc;
- Double_t fland;
- Double_t sum = 0.0;
- Double_t xlow,xupp;
- Double_t step;
- Double_t i;
-
-
- // MP shift correction
- mpc = par[1] - mpshift * par[0];
-
- // Range of convolution integral
- xlow = x[0] - sc * par[2];
- xupp = x[0] + sc * par[2];
-
- step = (xupp-xlow) / np;
-
- // Convolution integral of Landau and Gaussian by sum
- for(i=1.0; i<=np/2; i++) {
- xx = xlow + (i-.5) * step;
- fland = TMath::Landau(xx,mpc,par[0]) / par[0];
- sum += fland * TMath::Gaus(x[0],xx,par[2]);
-
- xx = xupp - (i-.5) * step;
- fland = TMath::Landau(xx,mpc,par[0]) / par[0];
- sum += fland * TMath::Gaus(x[0],xx,par[2]);
+ Double_t rv=1.;
+ for(Int_t i=0;i<8;i++){
+ Double_t fun=GetCondFunPi(i);
+ if(fun>=0)rv*=fun;
}
-
- return (step * sum * invsq2pi / par[2]);
+ return rv;
}
//_______________________________________________________________________
-Double_t AliITSPident::Gaus2(Double_t *x, Double_t *par){
- //normalized gaussian function
- return 1/(sqrt(2*TMath::Pi())*par[1])*TMath::Gaus(x[0],par[0],par[1]);
-}
-//_______________________________________________________________________
-void AliITSPident::CookFunItsLay(Int_t lay,Int_t opt,Double_t *par,Double_t dedx,Double_t mom,Double_t rangei,Double_t rangef,TString comment){
- //it gives the response functions
- TF1 funLay(comment,Langaufunnorm,rangei,rangef,3);
- funLay.SetParameters(par);
- Double_t condFun=funLay.Eval(dedx);
- if(opt==0){
- fCondFunProLay[lay]=condFun;
- if(mom<0.4 && dedx<100)fCondFunProLay[lay]=0.00001;
- if(mom<0.4 &&dedx<50)fCondFunProLay[lay]=0.0000001;
- }
- if(opt==1){
- fCondFunKLay[lay]=condFun;
- if(mom<0.25 && dedx<100)fCondFunKLay[lay]=0.00001;
- if(mom<0.4 &&dedx<30)fCondFunKLay[lay]=0.0000001;
- }
- if(opt==2){
- fCondFunPiLay[lay]=condFun;
- if(mom<0.6 &&dedx<20)fCondFunPiLay[lay]=0.001;
- }
-
-}
-//_______________________________________________________________________
-Float_t AliITSPident::CookCombinedBayes(Double_t condfun[][3],Float_t *prior,Int_t part)const {
+Double_t AliITSPident::CookCombinedBayes(Double_t condfun[][3],Double_t *prior,Int_t part)const {
//Bayesian combined PID in the ITS
Int_t test=0;
- Float_t bayes;
- Float_t pprior[4]={0,0,0,0};
+ Double_t bayes;
+ Double_t pprior[4]={0,0,0,0};
for(Int_t j=0;j<4;j++)pprior[j]=prior[j];
pprior[2]+=pprior[3];//prior for electrons summed to priors for pions
for(Int_t i=0;i<8;i++){//layer
if (condfun[i][0]>0 || condfun[i][1]>0 ||condfun[i][2]>0) test++;
}
+
if(test>0){
- if ((pprior[0]!=0 || pprior[1]!=0 ||pprior[2]!=0)&&CookSum(condfun,pprior)!=0){
+ Double_t sum=CookSum(condfun,pprior);
+ if ((pprior[0]!=0 || pprior[1]!=0 ||pprior[2]!=0)&&sum!=0.){
- bayes=pprior[part]*CookProd(condfun,part)*1/CookSum(condfun,pprior);
+ bayes=pprior[part]*CookProd(condfun,part)*1/sum;
}
else bayes=-100;
return bayes;
}
//_______________________________________________________________________
-Float_t AliITSPident::CookProd(Double_t condfun[][3],Int_t part)const{
+Double_t AliITSPident::CookProd(Double_t condfun[][3],Int_t part)const{
//
- Float_t p=1;
+ Double_t p=1;
for(Int_t lay=0;lay<8;lay++){
- if(condfun[lay][part]>=0)p=p*condfun[lay][part];
+ if(condfun[lay][part]>0.) p=p*condfun[lay][part];
}
-
return p;
}
//_______________________________________________________________________
-Float_t AliITSPident::CookSum(Double_t condfun[][3],Float_t *prior)const{
+Double_t AliITSPident::CookSum(Double_t condfun[][3],Double_t *prior)const{
//
- Float_t sum=0;
- Float_t pprior[4]={0,0,0,0};
- for(Int_t j=0;j<4;j++)pprior[j]=prior[j];
+ Double_t sum=0.;
+ Double_t pprior[4]={0,0,0,0};
+ for(Int_t j=0;j<4;j++) pprior[j]=prior[j];
pprior[2]+=pprior[3];//prior for electrons summed to priors for pions
for(Int_t i=0;i<3;i++){//sum over the particles--electrons excluded
sum+=pprior[i]*CookProd(condfun,i);
#include <TObject.h>
class AliESDtrack;
-class AliITSSteerPid;
class TF1;
-class AliITSPidParItem;
+class AliITSPidParams;
+
class AliITSPident : public TObject{
public:
AliITSPident();
- AliITSPident(Double_t mom,AliITSSteerPid *sp,Float_t *Qlay,Float_t *nlay,Float_t priorip=0.066,Float_t priorik=0.103,Float_t prioripi=0.83,Float_t priorie=0.001);
+ AliITSPident(Double_t mom,AliITSPidParams *pars,Double_t *Qlay,Double_t priorip=0.066,Double_t priorik=0.103,Double_t prioripi=0.83,Double_t priorie=0.001);
- AliITSPident(AliESDtrack *track,AliITSSteerPid *sp,Float_t *Qlay,Float_t *nlay,Float_t priorip=0.066,Float_t priorik=0.103,Float_t prioripi=0.83,Float_t priorie=0.001);
+ AliITSPident(AliESDtrack *track,AliITSPidParams *pars,Double_t priorip=0.066,Double_t priorik=0.103,Double_t prioripi=0.83,Double_t priorie=0.001);
virtual ~AliITSPident();
- Float_t GetP() const {return fMom;}//local momentum (GeV/c)
Double_t GetCondFunPro(Int_t lay) const {
return fCondFunProLay[lay];
}
return fCondFunPiLay[lay];
}
Double_t GetProdCondFunPi() const;
- void PrintParameters() const;
- Float_t GetPBayesp()const {return fPBayesp;}
- Float_t GetPBayesk()const {return fPBayesk;}
- Float_t GetPBayespi()const {return fPBayespi;}
- Float_t GetPPriorip() const {return fPPriorip;}
- Float_t GetPPriorik() const {return fPPriorik;}
- Float_t GetPPrioripi() const {return fPPrioripi;}
- Float_t GetPPriorie() const {return fPPriorie;}
- void GetNclsPerLayer(Int_t *ncls) const;
- static Double_t Langaufun(Double_t *x, Double_t *par);
- static Double_t Langaufun2(Double_t *x, Double_t *par);
- static Double_t Langaufunnorm(Double_t *x, Double_t *par);
- static Double_t Gaus2(Double_t *x, Double_t *par);
+
+ Double_t GetPBayesp()const {return fPBayesp;}
+ Double_t GetPBayesk()const {return fPBayesk;}
+ Double_t GetPBayespi()const {return fPBayespi;}
+ Double_t GetPPriorip() const {return fPPriorip;}
+ Double_t GetPPriorik() const {return fPPriorik;}
+ Double_t GetPPrioripi() const {return fPPrioripi;}
+ Double_t GetPPriorie() const {return fPPriorie;}
private:
- void CookFunItsLay(Int_t lay,Int_t opt,Double_t *par,Double_t dedx,Double_t mom,Double_t rangei,Double_t rangef,TString comment);
- void CookBayes(Double_t *condfun,Float_t *prior);
- Float_t CookCombinedBayes(Double_t condfun[][3],Float_t *prior,Int_t part)const;
- Float_t CookProd(Double_t condfun[][3],Int_t part) const;
- Float_t CookSum(Double_t condfun[][3],Float_t *prior) const;
+ void CalculateResponses(Double_t mom,AliITSPidParams *pars, Double_t *Qlay);
+ Double_t CookCombinedBayes(Double_t condfun[][3],Double_t *prior,Int_t part)const;
+ Double_t CookProd(Double_t condfun[][3],Int_t part) const;
+ Double_t CookSum(Double_t condfun[][3],Double_t *prior) const;
+
AliITSPident(const AliITSPident &ob); // copy constructor
AliITSPident& operator=(const AliITSPident & ob); // ass. op.
- Float_t fMom; // Particle momentum
Double_t fCondFunProLay[8]; // one for each silicon layer
Double_t fCondFunKLay[8]; // cond. prob. function kaons per layer
Double_t fCondFunPiLay[8]; // cond. prob. function pions per layer
- Float_t fPBayesp; // Bayes prob.
- Float_t fPBayesk; // Bayes prob. for kaons
- Float_t fPBayespi; // Bayes prob. for pions
- Float_t fPPriorip; // Priori prob.
- Float_t fPPriorik; // Priori prob. for kaons
- Float_t fPPrioripi; // Priori prob. for pions
- Float_t fPPriorie; // Priori prob. for electrons
- Int_t fNcls[4]; // N. of clusters per layer (sdd1,sdd2,ssd1,ssd2)
- ClassDef(AliITSPident,3);
+ Double_t fPBayesp; // Bayes prob.
+ Double_t fPBayesk; // Bayes prob. for kaons
+ Double_t fPBayespi; // Bayes prob. for pions
+ Double_t fPPriorip; // Priori prob.
+ Double_t fPPriorik; // Priori prob. for kaons
+ Double_t fPPrioripi; // Priori prob. for pions
+ Double_t fPPriorie; // Priori prob. for electrons
+
+ ClassDef(AliITSPident,4);
};
#endif
+++ /dev/null
-/**************************************************************************
- * Copyright(c) 1998-1999, 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. *
- **************************************************************************/
-
-/* $Id$ */
-
-/////////////////////////////////////////////////////////////////////////
-//Steering Class for PID in the ITS //
-//The PID is based on the likelihood of all the four ITS' layers, //
-//without using the truncated mean for the dE/dx. The response //
-//functions for each layer are convoluted Landau-Gaussian functions. //
-// Origin: Elena Bruna bruna@to.infn.it, Massimo Masera masera@to.infn.it//
-/////////////////////////////////////////////////////////////////////////
-
-#include <TClonesArray.h>
-#include <TMath.h>
-
-#include "AliITSSteerPid.h"
-
-ClassImp(AliITSSteerPid)
-
- //______________________________________________________________
-AliITSSteerPid::AliITSSteerPid():
-fClonarr2(0),
-fVect2(0),
-fVect2lay1(0),
-fVect2lay2(0),
-fVect2lay3(0),
-fVect2lay4(0),
-fFitTree(0),
-fItem(0),
-fPCenter(0),
-fPWidth(0)
-{
- // default constructor
- }
-//______________________________________________________________
-AliITSSteerPid::~AliITSSteerPid(){
- // destructor
- delete fClonarr2;
- delete fFitTree;
-}
-
-//______________________________________________________________________
-AliITSSteerPid::AliITSSteerPid(const AliITSSteerPid &ob) :TObject(ob),
-fClonarr2(ob.fClonarr2),
-fVect2(ob.fVect2),
-fVect2lay1(ob.fVect2lay1),
-fVect2lay2(ob.fVect2lay2),
-fVect2lay3(ob.fVect2lay3),
-fVect2lay4(ob.fVect2lay4),
-fFitTree(ob.fFitTree),
-fItem(ob.fItem),
-fPCenter(ob.fPCenter),
-fPWidth(ob.fPWidth) {
- // Copy constructor
-}
-
-//______________________________________________________________________
-AliITSSteerPid& AliITSSteerPid::operator=(const AliITSSteerPid& ob){
- // Assignment operator
- this->~AliITSSteerPid();
- new(this) AliITSSteerPid(ob);
- return *this;
-}
-
-//______________________________________________________________
-void AliITSSteerPid::InitLayer(TString fileITS,TString fileFitPar){
- // it opens the files useful for the PID
- fClonarr2=new TFile (fileITS,"r");
- fVect2=(TClonesArray*)fClonarr2->Get("vectfitits_0");//truncated mean
- fVect2lay1=(TClonesArray*)fClonarr2->Get("vectfitits_1");//lay 1
- fVect2lay2=(TClonesArray*)fClonarr2->Get("vectfitits_2");//lay 2
- fVect2lay3=(TClonesArray*)fClonarr2->Get("vectfitits_3");//lay 3
- fVect2lay4=(TClonesArray*)fClonarr2->Get("vectfitits_4");//lay 4
-
- TFile *fFitPar=new TFile (fileFitPar);
- fFitTree=(TTree*)fFitPar->Get("tree");
-
-}
-
-//______________________________________________________________
-AliITSPidParItem* AliITSSteerPid::GetItemLayer(Int_t nolay,Float_t mom){
- // it gives an AliITSPidParItem object for a given momentum and ITS layer
- if(nolay==1) return Item(fVect2lay1,mom);
- if(nolay==2) return Item(fVect2lay2,mom);
- if(nolay==3) return Item(fVect2lay3,mom);
- if(nolay==4) return Item(fVect2lay4,mom);
- if(nolay!=1&&nolay!=2&&nolay!=3&&nolay!=4) {
- fItem=new AliITSPidParItem();
- return fItem;
-
- }
- return 0;
-}
-
-//______________________________________________________________
-void AliITSSteerPid::GetParFitLayer(Int_t nolay,Float_t mom,Double_t *parp,Double_t *park,Double_t *parpi){
- //it gives the parameters of the convoluted functions (WL, MP, WG) for
- //protons, kaons and pions for a given momentum and ITS layer
-
- Double_t parfit0pro[3]={0,0,0};
- Double_t parfit1pro[3]={0,0,0};
- Double_t parfit3pro[3]={0,0,0};
- Double_t parfit0kao[3]={0,0,0};
- Double_t parfit1kao[3]={0,0,0};
- Double_t parfit3kao[3]={0,0,0};
- Double_t parfit0pi[3]={0,0,0};
- Double_t parfit1pi[3]={0,0,0};
- Double_t parfit3pi[3]={0,0,0};
-
- fFitTree->SetBranchAddress("par0pro",parfit0pro);
- fFitTree->SetBranchAddress("par1pro",parfit1pro);
- fFitTree->SetBranchAddress("par3pro",parfit3pro);
-
- fFitTree->SetBranchAddress("par0kao",parfit0kao);
- fFitTree->SetBranchAddress("par1kao",parfit1kao);
- fFitTree->SetBranchAddress("par3kao",parfit3kao);
-
- fFitTree->SetBranchAddress("par0pi",parfit0pi);
- fFitTree->SetBranchAddress("par1pi",parfit1pi);
- fFitTree->SetBranchAddress("par3pi",parfit3pi);
- fFitTree->GetEvent(nolay);
-
- GetLangausProPars(mom,parfit0pro,parfit1pro,parfit3pro,parp);
- GetLangausKaoPars(mom,parfit0kao,parfit1kao,parfit3kao,park);
- GetLangausPiPars(mom,parfit0pi,parfit1pi,parfit3pi,parpi);
-
-
-}//______________________________________________________________
-void AliITSSteerPid::GetLangausProPars(Float_t mom,Double_t *parfit0,Double_t *parfit1,Double_t *parfit3,Double_t *par){
-
- //It finds the parameters of the convoluted Landau-Gaussian response
- //function for protons (Width Landau, Most Probable, Width Gaussian)
- par[0]=parfit0[0]+parfit0[1]/mom;
- par[1]=parfit1[0]/(mom*mom)+parfit1[1]/(mom*mom)*TMath::Log(mom*mom)+parfit1[2];
- par[2]=parfit3[0]/(mom*mom)+parfit3[1]/(mom*mom)*TMath::Log(mom*mom)+parfit3[2];
-}
-//______________________________________________________________
-void AliITSSteerPid::GetLangausKaoPars(Float_t mom,Double_t *parfit0,Double_t *parfit1,Double_t *parfit3,Double_t *par){
- // It finds the parameters of the convoluted Landau-Gaussian response
- //function for kaons (Width Landau, Most Probable, Width Gaussian)
-
- par[0]=parfit0[0]+parfit0[1]/(mom*mom);
- par[1]=parfit1[0]/(mom*mom)+parfit1[1]/(mom*mom)*TMath::Log(mom*mom)+parfit1[2];
- par[2]=parfit3[0]/(mom*mom)+parfit3[1]/(mom*mom)*TMath::Log(mom*mom)+parfit3[2];
-}
-
-//______________________________________________________________
-void AliITSSteerPid::GetLangausPiPars(Float_t mom,Double_t *parfit0,Double_t *parfit1,Double_t *parfit3,Double_t *par){
- //It finds the parameters of the convoluted Landau-Gaussian response
- //function for pions (Width Landau, Most Probable, Width Gaussian)
-
- par[0]=parfit0[0]/(mom*mom)+parfit0[1]/(mom*mom)*TMath::Log(mom*mom)+parfit0[2];
- par[1]=parfit1[0]/(mom)+parfit1[1]/(mom)*TMath::Log(mom*mom)+parfit1[2];
- par[2]=parfit3[0]/(mom*mom)+parfit3[1]/(mom*mom)*TMath::Log(mom*mom)+parfit3[2];
-}
-
-
-
-//______________________________________________________________
-AliITSPidParItem* AliITSSteerPid::Item(TClonesArray *Vect,Float_t mom){
-
- //it gives an AliITSPidParItem object taken from the TClonesArray.
- Int_t mybin=-1;
-
- AliITSPidParItem* punt;
-
- for (Int_t a=0;a<50;a++){
- punt=(AliITSPidParItem*)Vect->At(a);
- Float_t centerp=punt->GetMomentumCenter();
- Float_t widthp=punt->GetWidthMom();
- if (mom>(centerp-widthp/2) && mom<=(centerp+widthp/2)) mybin=a;
- }
- if (mybin!=-1) fItem=(AliITSPidParItem*)Vect->At(mybin);
- else {
- fPCenter=0;
- fPWidth=0;
- for (Int_t ii=0;ii<52;ii++) fBuff[ii]=0;
- fItem = new AliITSPidParItem(fPCenter,fPWidth,fBuff);
- }
-
- return fItem;
-
-
-
-}
+++ /dev/null
-#ifndef AliITSSTEERPID_H
-#define AliITSSTEERPID_H
-////////////////////////////////////////////////////////////////////////
-//Steering lass for PID in ITS //
-//The PID is based on the likelihood of all the four ITS' layers, //
-//without using the truncated mean for the dE/dx. The response //
-//functions for each layer are convoluted Landau-Gaussian functions. //
-//Origin: Elena Bruna bruna@to.infn.it, Massimo Masera masera@to.infn.it//
-////////////////////////////////////////////////////////////////////////
-
-/* $Id$ */
-
-#include <TObject.h>
-#include <Riostream.h>
-#include <TF1.h>
-#include <TTree.h>
-#include <TFile.h>
-#include "AliITSPidParItem.h"
-
-
-class AliITSSteerPid : public TObject{
-
- public:
- AliITSSteerPid();
- virtual ~AliITSSteerPid();
- void InitLayer(TString fileITS="$ALICE_ROOT/ITS/farrfitits.root",TString fileFitPar="$ALICE_ROOT/ITS/ffitparams.root");
-
- AliITSPidParItem* GetItemLayer(Int_t nolay,Float_t mom);
- void GetParFitLayer(Int_t nolay,Float_t mom,Double_t *parp,Double_t *park,Double_t *parpi);
- static void GetLangausProPars(Float_t mom,Double_t *parfit0,Double_t *parfit1,Double_t *parfit3,Double_t *par);
- static void GetLangausKaoPars(Float_t mom,Double_t *parfit0,Double_t *parfit1,Double_t *parfit3,Double_t *par);
- static void GetLangausPiPars(Float_t mom,Double_t *parfit0,Double_t *parfit1,Double_t *parfit3,Double_t *par);
-
-
- private:
-
- AliITSPidParItem* Item(TClonesArray *Vect,Float_t mom);
- AliITSSteerPid(const AliITSSteerPid &ob); // copy constructor
- AliITSSteerPid& operator=(const AliITSSteerPid & ob); // ass. op.
-
-
- TFile *fClonarr2; // file of TClones Array
- TClonesArray *fVect2; // TClonesArray fVect
- TClonesArray *fVect2lay1; // TClonesArray for layer 1 (SDD1)
- TClonesArray *fVect2lay2; // TClonesArray for layer 2 (SDD2)
- TClonesArray *fVect2lay3; // TClonesArray for layer 3 (SSD1)
- TClonesArray *fVect2lay4; // TClonesArray for layer 4 (SSD2)
- TTree* fFitTree; // tree
- AliITSPidParItem *fItem; //element of TClonesArray of interest
- Float_t fPCenter; //value for center
- Float_t fPWidth; //value for width
- Double_t fBuff[52]; //array for
-
-
- ClassDef(AliITSSteerPid,1);
-
-
-};
-#endif
#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliITSLoader.h"
+#include "AliITSPidParams.h"
#include "AliITSPident.h"
-#include "AliITSSteerPid.h"
#include "AliLog.h"
ClassImp(AliITSpidESD2)
//_________________________________________________________________________
AliITSpidESD2::AliITSpidESD2():
AliITSpidESD(),
- fSp(0)
+ fPidPars(0)
{
// The main constructor
- fSp=new AliITSSteerPid();
- fSp->InitLayer();
+ fPidPars=new AliITSPidParams("default");
}
AliITSpidESD2::~AliITSpidESD2(){
//destructor
- if(fSp)delete fSp;
+ if(fPidPars)delete fPidPars;
}
//______________________________________________________________________
AliITSpidESD2::AliITSpidESD2(const AliITSpidESD2 &ob) :AliITSpidESD(ob),
-fSp(ob.fSp)
+fPidPars(ob.fPidPars)
{
// Copy constructor
}
void AliITSpidESD2::GetITSpidSingleTrack(AliESDtrack* esdtr, Double_t condprobfun[]){
// Method to calculate PID probabilities for a single track
- Double_t momits=esdtr->GetP();
- Double_t qclu[4];
- esdtr->GetITSdEdxSamples(qclu);
-
- Float_t qclucorr[8],nlay[8];
- for(Int_t jj=0;jj<8;jj++){
- if(jj<4 && qclu[jj]>0){
- qclucorr[jj]=qclu[jj];
- nlay[jj]=jj+2; // layers numbered from 0 to 5
- }
- else{
- qclucorr[jj]=-1;
- nlay[jj]=0;
- }
- }
- Float_t prip=0.33;
- Float_t prik=0.33;
- Float_t pripi=0.33;
- Float_t prie=0.;
- AliITSPident mypid(momits,fSp,qclucorr,nlay,prip,prik,pripi,prie);
+ Double_t prip=0.33;
+ Double_t prik=0.33;
+ Double_t pripi=0.33;
+ Double_t prie=0.;
+ AliITSPident mypid(esdtr,fPidPars,prip,prik,pripi,prie);
condprobfun[0]=mypid.GetProdCondFunPi();//el --PID in the ITS does not distinguish among Pi,el,mu
condprobfun[1]=mypid.GetProdCondFunPi();//mu
condprobfun[2]=mypid.GetProdCondFunPi();//pi
#include "AliITSpidESD.h"
#include "AliESDtrack.h"
-class AliITSSteerPid;
+class AliITSPidParams;
class AliITSpidESD2 : public AliITSpidESD {
public:
virtual Int_t MakePID(AliESDEvent *event);
private:
- AliITSSteerPid* fSp; //!pointer to AliITSSteerPid
+ AliITSPidParams* fPidPars; //!pointer to AliITSSteerPid
- ClassDef(AliITSpidESD2,3) // ITS PID class
+ ClassDef(AliITSpidESD2,4) // ITS PID class
};
#endif
// Classes for PID
#pragma link C++ class AliITSPid+;
-#pragma link C++ class AliITSPidParItem+;
+#pragma link C++ class AliITSPidParams+;
#pragma link C++ class AliITSPident+;
-#pragma link C++ class AliITSSteerPid+;
#pragma link C++ class AliITSpidESD+;
#pragma link C++ class AliITSpidESD1+;
#pragma link C++ class AliITSpidESD2+;
AliITSpidESD2.cxx \
AliITSdEdxAnalyzer.cxx \
AliITSPident.cxx \
- AliITSSteerPid.cxx \
- AliITSPidParItem.cxx \
+ AliITSPidParams.cxx \
AliITSReconstructor.cxx \
AliITSRecoParam.cxx \
AliITSBeamTestDig.cxx \
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff