Possibility to propagate tracks to the DCA to the primary vertex at the AOD level...

[u/mrichter/AliRoot.git] / STEER / AliKalmanTrack.cxx

diff --git a/STEER/AliKalmanTrack.cxx b/STEER/AliKalmanTrack.cxx
index 64e55ec8ad1113c3a690b40c9b492f3e2bb7e9a3..92df4af77cfd24124241509e795ccc97cfd820f3 100644 (file)
--- a/STEER/AliKalmanTrack.cxx
+++ b/STEER/AliKalmanTrack.cxx
@@ -17,43 +17,164 @@
 
 //-------------------------------------------------------------------------
 //                Implementation of the AliKalmanTrack class
-//
+//   that is the base for AliTPCtrack, AliITStrackV2 and AliTRDtrack
 //        Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
 //-------------------------------------------------------------------------
+#include <TGeoManager.h>
 
 #include "AliKalmanTrack.h"
 
 ClassImp(AliKalmanTrack)
 
-Double_t AliKalmanTrack::fgConvConst;
-
 //_______________________________________________________________________
-AliKalmanTrack::AliKalmanTrack():
-  fLab(-3141593),
+  AliKalmanTrack::AliKalmanTrack():AliExternalTrackParam(),
+  fFakeRatio(0),
   fChi2(0),
-  fMass(0.13957),
-  fN(0)
+  fMass(AliPID::ParticleMass(AliPID::kPion)),
+  fLab(-3141593),
+  fN(0),
+  fStartTimeIntegral(kFALSE),
+  fIntegratedLength(0)
 {
   //
   // Default constructor
   //
-    if (fgConvConst==0) 
-      Fatal("AliKalmanTrack()","The magnetic field has not been set !\n"); 
+
+  for(Int_t i=0; i<AliPID::kSPECIES; i++) fIntegratedTime[i] = 0;
 }
 
-//_______________________________________________________________________
 AliKalmanTrack::AliKalmanTrack(const AliKalmanTrack &t):
-  TObject(t),
-  fLab(t.fLab),
+  AliExternalTrackParam(t),
+  fFakeRatio(t.fFakeRatio),
   fChi2(t.fChi2),
   fMass(t.fMass),
-  fN(t.fN)
+  fLab(t.fLab),
+  fN(t.fN),
+  fStartTimeIntegral(t.fStartTimeIntegral),
+  fIntegratedLength(t.fIntegratedLength)
 {
   //
   // Copy constructor
   //
-  if (fgConvConst==0) 
-    Fatal("AliKalmanTrack(const AliKalmanTrack&)",
-          "The magnetic field has not been set !\n"); 
+  
+  for (Int_t i=0; i<AliPID::kSPECIES; i++)
+      fIntegratedTime[i] = t.fIntegratedTime[i];
+}
+
+AliKalmanTrack& AliKalmanTrack::operator=(const AliKalmanTrack&o){
+  if(this!=&o){
+    AliExternalTrackParam::operator=(o);
+    fLab = o.fLab;
+    fFakeRatio = o.fFakeRatio;
+    fChi2 = o.fChi2;
+    fMass = o.fMass;
+    fN = o.fN;
+    fStartTimeIntegral = o.fStartTimeIntegral;
+    for(Int_t i = 0;i<AliPID::kSPECIES;++i)fIntegratedTime[i] = o.fIntegratedTime[i];
+    fIntegratedLength = o.fIntegratedLength;
+  }
+  return *this;
+}
+
+//_______________________________________________________________________
+void AliKalmanTrack::StartTimeIntegral() 
+{
+  // Sylwester Radomski, GSI
+  // S.Radomski@gsi.de
+  //
+  // Start time integration
+  // To be called at Vertex by ITS tracker
+  //
+  
+  //if (fStartTimeIntegral) 
+  //  AliWarning("Reseting Recorded Time.");
+
+  fStartTimeIntegral = kTRUE;
+  for(Int_t i=0; i<AliPID::kSPECIES; i++) fIntegratedTime[i] = 0;  
+  fIntegratedLength = 0;
+}
+
+//_______________________________________________________________________
+void AliKalmanTrack:: AddTimeStep(Double_t length) 
+{
+  // 
+  // Add step to integrated time
+  // this method should be called by a sublasses at the end
+  // of the PropagateTo function or by a tracker
+  // each time step is made.
+  //
+  // If integration not started function does nothing
+  //
+  // Formula
+  // dt = dl * sqrt(p^2 + m^2) / p
+  // p = pT * (1 + tg^2 (lambda) )
+  //
+  // pt = 1/external parameter [4]
+  // tg lambda = external parameter [3]
+  //
+  //
+  // Sylwester Radomski, GSI
+  // S.Radomski@gsi.de
+  // 
+  
+  static const Double_t kcc = 2.99792458e-2;
+
+  if (!fStartTimeIntegral) return;
+  
+  fIntegratedLength += length;
+
+  Double_t xr, param[5];
+  Double_t pt, tgl;
+  
+  GetExternalParameters(xr, param);
+  pt =  1/param[4] ;
+  tgl = param[3];
+
+  Double_t p = TMath::Abs(pt * TMath::Sqrt(1+tgl*tgl));
+
+  if (length > 100) return;
+
+  for (Int_t i=0; i<AliPID::kSPECIES; i++) {
+    
+    Double_t mass = AliPID::ParticleMass(i);
+    Double_t correction = TMath::Sqrt( pt*pt * (1 + tgl*tgl) + mass * mass ) / p;
+    Double_t time = length * correction / kcc;
+
+    fIntegratedTime[i] += time;
+  }
+}
+
+//_______________________________________________________________________
+Double_t AliKalmanTrack::GetIntegratedTime(Int_t pdg) const 
+{
+  // Sylwester Radomski, GSI
+  // S.Radomski@gsi.de
+  //
+  // Return integrated time hypothesis for a given particle
+  // type assumption.
+  //
+  // Input parameter:
+  // pdg - Pdg code of a particle type
+  //
+
+
+  if (!fStartTimeIntegral) {
+    AliWarning("Time integration not started");
+    return 0.;
+  }
+
+  for (Int_t i=0; i<AliPID::kSPECIES; i++)
+    if (AliPID::ParticleCode(i) == TMath::Abs(pdg)) return fIntegratedTime[i];
+
+  AliWarning(Form("Particle type [%d] not found", pdg));
+  return 0;
+}
+
+void AliKalmanTrack::GetIntegratedTimes(Double_t *times) const {
+  for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fIntegratedTime[i];
+}
+
+void AliKalmanTrack::SetIntegratedTimes(const Double_t *times) {
+  for (Int_t i=0; i<AliPID::kSPECIES; i++) fIntegratedTime[i]=times[i];
 }