Updated class to store dE/dx samples

diff --git a/ITS/AliITSdEdxSamples.cxx b/ITS/AliITSdEdxSamples.cxx
index 0881785..fb57c47 100644 (file)
--- a/ITS/AliITSdEdxSamples.cxx
+++ b/ITS/AliITSdEdxSamples.cxx
@@ -38,44 +38,75 @@ AliITSdEdxSamples::AliITSdEdxSamples():TObject(),
   fParticleSpecie(0)
 {
   // Default constructor
-
-  for(Int_t i=0; i<fgkMaxSamples; i++) {
-    fdEdxSamples[i]=0.;
+  for(Int_t i=0; i<kMaxSamples; i++){
+    fdESamples[i]=0.;
+    fdxSamples[i]=0.;
     fPAtSample[i]=0.;
   }
 }
 
 //______________________________________________________________________
-AliITSdEdxSamples::AliITSdEdxSamples(Int_t nSamples,Double_t* samples, Double_t mom, Int_t specie) :
+AliITSdEdxSamples::AliITSdEdxSamples(Int_t nSamples, Double_t* esamples, Double_t* xsamples, Double_t mom, Int_t specie) :
   TObject(),
   fNSamples(nSamples),
   fP(mom),
   fParticleSpecie(specie)
 {
   // Standard constructor
-  for(Int_t i=0; i<fgkMaxSamples; i++)fPAtSample[i]=0.;
-  SetSamples(nSamples,samples);
+  SetdESamples(nSamples,esamples);
+  SetdxSamples(nSamples,xsamples);
+}
+
+//______________________________________________________________________
+AliITSdEdxSamples::AliITSdEdxSamples(const AliITSdEdxSamples& source) :
+  TObject(),
+  fNSamples(source.fNSamples),
+  fP(source.fP),
+  fParticleSpecie(source.fParticleSpecie)
+{
+  // Copy constructor
+  for(Int_t i=0; i<fNSamples; i++){
+    fdESamples[i]=source.GetdESample(i);
+    fdxSamples[i]=source.GetdxSample(i);
+    fPAtSample[i]=source.GetMomentumAtSample(i);
+  }
 }
 //______________________________________________________________________
-void AliITSdEdxSamples::SetSamples(Int_t nSamples, Double_t* samples){
+void AliITSdEdxSamples::SetdESamples(Int_t nSamples, Double_t* samples){
   // Set the samples
 
-  if(nSamples>fgkMaxSamples){
-    AliWarning(Form("Too many dE/dx samples,only first %d will be used",fgkMaxSamples));
-    fNSamples=fgkMaxSamples;
+  if(nSamples>kMaxSamples){
+    AliWarning(Form("Too many dE samples,only first %d will be used",kMaxSamples));    
+    fNSamples=kMaxSamples;
   }else{
     fNSamples=nSamples;
   }
-  for(Int_t i=0; i<fNSamples; i++) fdEdxSamples[i]=samples[i];
-  for(Int_t i=fNSamples; i<fgkMaxSamples; i++) fdEdxSamples[i]=0.;
+  for(Int_t i=0; i<fNSamples; i++) fdESamples[i]=samples[i];
+  for(Int_t i=fNSamples; i<kMaxSamples; i++) fdESamples[i]=0.;
   return;
 }
 //______________________________________________________________________
-void AliITSdEdxSamples::SetSamplesAndMomenta(Int_t nSamples, Double_t* samples, Double_t* mom){
+void AliITSdEdxSamples::SetdxSamples(Int_t nSamples, Double_t* samples){
   // Set the samples
-  SetSamples(nSamples,samples);
+
+  if(nSamples>kMaxSamples){
+    AliWarning(Form("Too many dx samples,only first %d will be used",kMaxSamples))
+    fNSamples=kMaxSamples;
+  }else{
+    fNSamples=nSamples;
+  }
+  for(Int_t i=0; i<fNSamples; i++) fdxSamples[i]=samples[i];
+  for(Int_t i=fNSamples; i<kMaxSamples; i++) fdxSamples[i]=0.;
+  return;
+}
+
+//______________________________________________________________________
+void AliITSdEdxSamples::SetSamplesAndMomenta(Int_t nSamples, Double_t* esamples, Double_t* xsamples, Double_t* mom){
+  // Set the samples
+  SetdESamples(nSamples,esamples);
+  SetdxSamples(nSamples,xsamples);
   for(Int_t i=0; i<fNSamples; i++) fPAtSample[i]=mom[i];
-  for(Int_t i=fNSamples; i<fgkMaxSamples; i++) fPAtSample[i]=0.;
+  for(Int_t i=fNSamples; i<kMaxSamples; i++) fPAtSample[i]=0.;
   return;
 }
 //______________________________________________________________________
@@ -83,12 +114,13 @@ Double_t AliITSdEdxSamples::GetTruncatedMean(Double_t frac, Double_t mindedx) co
   // compute truncated mean 
 
   Int_t nc=0;
-  Double_t dedx[fgkMaxSamples];
+  Double_t dedx[kMaxSamples];
   for (Int_t il=0; il<fNSamples; il++) { // count good (>0) dE/dx values
-    if(fdEdxSamples[il]>mindedx){
-      dedx[nc]= fdEdxSamples[il];
+    Double_t dedxsamp=GetdEdxSample(il);
+    if(dedxsamp>mindedx){
+      dedx[nc]= dedxsamp;
       nc++;
-    }
+    }    
   }
   if(nc<1) return 0.;
   
@@ -105,15 +137,15 @@ Double_t AliITSdEdxSamples::GetTruncatedMean(Double_t frac, Double_t mindedx) co
   } while (swap);
 
   Double_t sumamp=0,sumweight=0;
-  Double_t weight[fgkMaxSamples];
-  for(Int_t iw=0; iw<fgkMaxSamples; iw++) weight[iw]=0.;
+  Double_t weight[kMaxSamples];
+  for(Int_t iw=0; iw<kMaxSamples; iw++) weight[iw]=0.;
   Int_t lastUsed=(Int_t)(frac*nc+0.00001);
   if(lastUsed==0) lastUsed=1;
-  if(lastUsed>fgkMaxSamples) lastUsed=fgkMaxSamples;
+  if(lastUsed>kMaxSamples) lastUsed=kMaxSamples;
   for(Int_t iw=0; iw<lastUsed; iw++) weight[iw]=1.;
-  if((frac*nc-lastUsed)>0.4 && lastUsed<fgkMaxSamples) weight[lastUsed]=0.5;
+  if((frac*nc-lastUsed)>0.4 && lastUsed<kMaxSamples) weight[lastUsed]=0.5;
   for (Int_t i=0; i<nc; i++) {
-    AliDebug(5,Form("dE/dx %f   weight %f",dedx[i],weight[i]));
+    // AliDebug(5,Form("dE/dx %f   weight %f",dedx[i],weight[i]));
     sumamp+= dedx[i]*weight[i];
     sumweight+=weight[i];
   }
@@ -124,13 +156,13 @@ Double_t AliITSdEdxSamples::GetTruncatedMean(Double_t frac, Double_t mindedx) co
 //______________________________________________________________________
 Double_t AliITSdEdxSamples::GetWeightedMean(Double_t mindedx) const {
   // compute generalized mean with k=-2 (used by CMS)
-
   Int_t nc=0;
-  Double_t dedx[fgkMaxSamples];
+  Double_t dedx[kMaxSamples];
   for (Int_t il=0; il<fNSamples; il++) { // count good (>0) dE/dx values
-    if(fdEdxSamples[il]>mindedx){
-      dedx[nc]= fdEdxSamples[il];
-      nc++;
+    Double_t dedxsamp=GetdEdxSample(il);
+    if(dedxsamp>mindedx){
+      dedx[nc]= dedxsamp;
+      nc++;      
     }
   }
   if(nc<1) return 0.;
@@ -153,8 +185,8 @@ void  AliITSdEdxSamples::GetConditionalProbabilities(AliITSPidParams* pars, Doub
   for(Int_t iS=0; iS<fNSamples; iS++){
     Int_t iLayer=iS+3; // to match with present ITS
     if(iLayer>6) iLayer=6; // all extra points are treated as SSD
-    if(fdEdxSamples[iS]<mindedx) continue;
-    Float_t dedx = fdEdxSamples[iS];
+    Float_t dedx = GetdEdxSample(iS);
+    if(dedx<mindedx) continue;
     Float_t layProb = pars->GetLandauGausNorm(dedx,AliPID::kProton,fP,iLayer);
     itsProb[0] *= layProb;
 

diff --git a/ITS/AliITSdEdxSamples.h b/ITS/AliITSdEdxSamples.h
index 62c60db..21a17f2 100644 (file)
--- a/ITS/AliITSdEdxSamples.h
+++ b/ITS/AliITSdEdxSamples.h
@@ -3,8 +3,6 @@
 /* Copyright(c) 2009-2012, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id$ */
-
 ///////////////////////////////////////////////////////////////////
 //                                                               //
 // Class to store information for PID with ITS                   //
@@ -22,11 +20,13 @@ class AliITSdEdxSamples : public TObject {
 
  public:
   AliITSdEdxSamples();
-  AliITSdEdxSamples(Int_t nSamples, Double_t* samples, Double_t mom, Int_t specie=0);
+  AliITSdEdxSamples(Int_t nSamples, Double_t* esamples, Double_t* xsamples, Double_t mom, Int_t specie=0);
+  AliITSdEdxSamples(const AliITSdEdxSamples& source);
   virtual ~AliITSdEdxSamples(){};
 
-  void SetSamples(Int_t nSamples, Double_t* samples);
-  void SetSamplesAndMomenta(Int_t nSamples, Double_t* samples, Double_t* mom);
+  void SetdESamples(Int_t nSamples, Double_t* samples);
+  void SetdxSamples(Int_t nSamples, Double_t* samples);
+  void SetSamplesAndMomenta(Int_t nSamples, Double_t* esamples, Double_t* xsamples, Double_t* mom);
   void SetMomentum(Double_t mom){
     fP=mom;
   }
@@ -37,10 +37,27 @@ class AliITSdEdxSamples : public TObject {
   Int_t GetNumberOfSamples() const {
     return fNSamples;
   }
-  Double_t GetdEdxSample(Int_t i) const {
-    if(i<fNSamples) return fdEdxSamples[i];
+  Double_t GetdESample(Int_t i) const {
+    if(i<fNSamples) return fdESamples[i];
+    else return 0.;
+  }
+  Double_t GetNehPairs(Int_t i) const {
+    if(i<fNSamples) return fdESamples[i]*1000./3.63;
+    else return 0.;
+  }
+  Double_t GetQfC(Int_t i) const{
+    return GetNehPairs(i)*1.6E-4;
+  }
+  Double_t GetdxSample(Int_t i) const {
+    if(i<fNSamples) return fdxSamples[i];
     else return 0.;
   }
+  Double_t GetdEdxSample(Int_t i) const { // keV/100um
+    if(i<fNSamples && fdxSamples[i]>0.) 
+      return fdESamples[i]/(fdxSamples[i]*100.);
+    else return 0.;
+  }
+
   Double_t GetMomentum() const {
     return fP;
   }
@@ -56,16 +73,18 @@ class AliITSdEdxSamples : public TObject {
   Double_t GetWeightedMean(Double_t mindedx=0.) const;
   void     GetConditionalProbabilities(AliITSPidParams* pars, Double_t condprob[AliPID::kSPECIES], Double_t mindedx=0.) const;
 
+
  protected:
-  static const UShort_t fgkMaxSamples=10;  // max. n. of layers with dE/dx info
-  
+  enum{kMaxSamples=10}; // max. n. of layers with dE/dx info
+
   Int_t    fNSamples;                   // number of samples
-  Double_t fdEdxSamples[fgkMaxSamples]; // dE/dx samples
+  Double_t fdESamples[kMaxSamples];     // dE samples (keV)
+  Double_t fdxSamples[kMaxSamples];     // dx samples (cm)
   Double_t fP;                          // track momentum
   Int_t    fParticleSpecie;             // MC generated particle
-  Double_t fPAtSample[fgkMaxSamples];   // track momentum at specific samples
+  Double_t fPAtSample[kMaxSamples];     // track momentum at specific samples
   
-  ClassDef(AliITSdEdxSamples,1);
+  ClassDef(AliITSdEdxSamples,2);
 
 };
 #endif