PID implementation fixed. Calculation of mass, energy, and rapidity introduced.

diff --git a/STEER/AliAODTrack.cxx b/STEER/AliAODTrack.cxx
index ce0c44a447b3a74f8077d71c77166f0a1867f531..968a21853e38d6993edee6d72418a638a8dde162 100644 (file)
--- a/STEER/AliAODTrack.cxx
+++ b/STEER/AliAODTrack.cxx
@@ -171,6 +171,157 @@ AliAODTrack& AliAODTrack::operator=(const AliAODTrack& trk)
   return *this;
 }
 
+//______________________________________________________________________________
+Double_t AliAODTrack::M(AODTrkPID_t pid) const
+{
+  // Returns the mass.
+  // In the case of elementary particles the hard coded mass values were taken 
+  // from the PDG. In all cases the error on the values does not affect 
+  // the last digit.
+  
+
+  switch (pid) {
+
+  case kElectron :
+    return 0.000510999;
+    break;
+
+  case kMuon :
+    return 0.1056584;
+    break;
+
+  case kPion :
+    return 0.13957;
+    break;
+
+  case kKaon :
+    return 0.4937;
+    break;
+
+  case kProton :
+    return 0.9382720;
+    break;
+
+  case kDeuteron :
+    return 1.8756;
+    break;
+
+  case kTriton :
+    return 2.8089;
+    break;
+
+  case kHelium3 :
+    return 2.8084;
+    break;
+
+  case kAlpha :
+    return 3.7274;
+    break;
+
+  case kUnknown :
+    return -999.;
+    break;
+
+  default :
+    return -999.;
+  }
+}
+
+//______________________________________________________________________________
+Double_t AliAODTrack::E(AODTrkPID_t pid) const
+{
+  // Returns the energy of the particle of a given pid.
+  
+  if (pid != kUnknown) { // particle was identified
+    Double_t m = M(pid);
+    return TMath::Sqrt(P()*P() + m*m);
+  } else { // pid unknown
+    return -999.;
+  }
+}
+
+//______________________________________________________________________________
+Double_t AliAODTrack::Y(AODTrkPID_t pid) const
+{
+  // Returns the energy of the particle of a given pid.
+  
+  if (pid != kUnknown) { // particle was identified
+    Double_t e = E(pid);
+    Double_t pz = Pz();
+    if (e>=0 && e!=pz) { // energy was positive (e.g. not -999.) and not equal to pz
+      return 0.5*TMath::Log((e+pz)/(e-pz));
+    } else { // energy not known or equal to pz
+      return -999.;
+    }
+  } else { // pid unknown
+    return -999.;
+  }
+}
+
+//______________________________________________________________________________
+Double_t AliAODTrack::Y(Double_t m) const
+{
+  // Returns the energy of the particle of a given mass.
+  
+  if (m >= 0.) { // mass makes sense
+    Double_t e = E(m);
+    Double_t pz = Pz();
+    if (e>=0 && e!=pz) { // energy was positive (e.g. not -999.) and not equal to pz
+      return 0.5*TMath::Log((e+pz)/(e-pz));
+    } else { // energy not known or equal to pz
+      return -999.;
+    }
+  } else { // pid unknown
+    return -999.;
+  }
+}
+
+//______________________________________________________________________________
+AliAODTrack::AODTrkPID_t AliAODTrack::GetMostProbablePID() const 
+{
+  // Returns the most probable PID array element.
+  
+  Int_t nPID = 10;
+  if (fPID) {
+    AODTrkPID_t loc = kUnknown;
+    Double_t max = 0.;
+    Bool_t allTheSame = kTRUE;
+    
+    for (Int_t iPID = 0; iPID < nPID; iPID++) {
+      if (fPID[iPID] >= max) {
+       if (fPID[iPID] > max) {
+         allTheSame = kFALSE;
+         max = fPID[iPID];
+         loc = (AODTrkPID_t)iPID;
+       } else {
+         allTheSame = kTRUE;
+       }
+      }
+    }
+    
+    return allTheSame ? kUnknown : loc;
+  } else {
+    return kUnknown;
+  }
+}
+
+//______________________________________________________________________________
+void AliAODTrack::ConvertAliPIDtoAODPID()
+{
+  // Converts AliPID array.
+  // The numbering scheme is the same for electrons, muons, pions, kaons, and protons.
+  // Everything else has to be set to zero.
+
+  fPID[kDeuteron] = 0.;
+  fPID[kTriton] = 0.;
+  fPID[kHelium3] = 0.;
+  fPID[kAlpha] = 0.;
+  fPID[kUnknown] = 0.;
+  
+  return;
+}
+
+
 //______________________________________________________________________________
 template <class T> void AliAODTrack::SetP(const T *p, const Bool_t cartesian) 
 {

diff --git a/STEER/AliAODTrack.h b/STEER/AliAODTrack.h
index d06bca20ee9c0a38fe04d0b172a4cb26750acf43..8103b6732d4b63db64f3f78dff184459b2342b1c 100644 (file)
--- a/STEER/AliAODTrack.h
+++ b/STEER/AliAODTrack.h
@@ -11,6 +11,7 @@
 //-------------------------------------------------------------------------
 
 #include <TRef.h>
+#include <TParticle.h>
 
 #include "AliVirtualParticle.h"
 #include "AliAODVertex.h"
@@ -27,8 +28,19 @@ class AliAODTrack : public AliVirtualParticle {
     kUsedForPrimVtxFit=BIT(15) // set if this track was used to fit the primary vertex
   };
 
-  enum AODTrkPID_t { // not clear why this was introduced
-    kUnknown=0, kElectron, kMuon, kPion, kProton, kDeuteron, kTriton, kAlpha, kOther}; // Where is the Kaon, why the Triton? 
+  enum AODTrkPID_t {
+    kElectron     =  0, 
+    kMuon         =  1, 
+    kPion         =  2, 
+    kKaon         =  3, 
+    kProton       =  4, 
+    kDeuteron     =  5,
+    kTriton       =  6,
+    kHelium3      =  7,
+    kAlpha        =  8,
+    kUnknown      =  9,
+    kMostProbable = -1
+  };
 
   AliAODTrack();
   AliAODTrack(Int_t id,
@@ -73,28 +85,33 @@ class AliAODTrack : public AliVirtualParticle {
   virtual Double_t Pz() const { return fMomentum[0] / TMath::Tan(fMomentum[2]); }
   virtual Double_t Pt() const { return fMomentum[0]; }
   virtual Double_t P()  const { return TMath::Sqrt(Pt()*Pt()+Pz()*Pz()); }
-
-          Double_t Chi2() const { return fChi2; }
-
-  virtual Double_t E() const { return -999.; }
-  // make a connection to the PID object, here!!!
-  virtual Double_t M() const { return -999.; }
+  
+  Double_t Chi2() const { return fChi2; }
+  
+  virtual Double_t M() const { return M(GetMostProbablePID()); }
+  Double_t M(AODTrkPID_t pid) const;
+  virtual Double_t E() const { return E(GetMostProbablePID()); }
+  Double_t E(AODTrkPID_t pid) const;
+  Double_t E(Double_t m) const { return TMath::Sqrt(P()*P() + m*m); }
+  virtual Double_t Y() const { return Y(GetMostProbablePID()); }
+  Double_t Y(AODTrkPID_t pid) const;
+  Double_t Y(Double_t m) const;
   
   virtual Double_t Eta() const { return -TMath::Log(TMath::Tan(0.5 * fMomentum[2])); }
-  // make a connection to the PID object, here!!!
-  virtual Double_t Y() const { return -999.; }
 
   virtual Short_t  Charge() const {return fCharge; }
 
   // PID
   virtual const Double_t *PID() const { return fPID; }
+  AODTrkPID_t GetMostProbablePID() const;
+  void ConvertAliPIDtoAODPID();
 
   template <class T> void GetPID(T *pid) const {
     for(Int_t i=0; i<10; ++i) pid[i]=fPID[i];}
  
   template <class T> void SetPID(const T *pid) {
     if(pid) for(Int_t i=0; i<10; ++i) fPID[i]=pid[i];
-    else {for(Int_t i=1; i<10; fPID[i++]=0); fPID[0]=1.;}}
+    else {for(Int_t i=0; i<10; fPID[i++]=0.);}}
 
   Int_t GetID() const { return fID; }
   Int_t GetLabel() const { return fLabel; } 
@@ -165,7 +182,7 @@ class AliAODTrack : public AliVirtualParticle {
   Int_t         fID;             // unique track ID, points back to the ESD track
   Int_t         fLabel;          // track label, points back to MC track
   
-  AliAODRedCov<6> *fCovMatrix;      // covariance matrix (x, y, z, px, py, pz)
+  AliAODRedCov<6> *fCovMatrix;   // covariance matrix (x, y, z, px, py, pz)
   TRef          fProdVertex;     // vertex of origin
 
   Char_t        fCharge;         // particle charge