Fixing memory leaks

[u/mrichter/AliRoot.git] / ITS / AliITStrackV2.cxx

diff --git a/ITS/AliITStrackV2.cxx b/ITS/AliITStrackV2.cxx
index d592f47ebbde160a68b4a2d65d7dd56a441dc433..6b1d2e137cc588a81a00d99a8c9e29db0ff4f7d1 100644 (file)
--- a/ITS/AliITStrackV2.cxx
+++ b/ITS/AliITStrackV2.cxx
@@ -26,6 +26,7 @@
 
 #include "AliCluster.h"
 #include "AliTPCtrack.h"
+#include "AliESDtrack.h"
 #include "AliITStrackV2.h"
 
 ClassImp(AliITStrackV2)
@@ -56,11 +57,13 @@ AliITStrackV2::AliITStrackV2():AliKalmanTrack(),
   fC41(0),
   fC42(0),
   fC43(0),
-  fC44(0)
+  fC44(0),
+  fESDtrack(0)
   {
   for(Int_t i=0; i<kMaxLayer; i++) fIndex[i]=0;
   for(Int_t i=0; i<4; i++) fdEdxSample[i]=0;
 }
+
 //____________________________________________________________________________
 AliITStrackV2::AliITStrackV2(const AliTPCtrack& t) throw (const Char_t *) :
 AliKalmanTrack(t) {
@@ -80,11 +83,11 @@ AliKalmanTrack(t) {
   //Conversion of the track parameters
   Double_t x,p[5]; t.GetExternalParameters(x,p);
   fX=x;    x=GetConvConst();
-  fP0=p[0]; 
-  fP1=p[1]; 
+  fP0=p[0];
+  fP1=p[1];
   fP2=p[2];
   fP3=p[3];
-  fP4=p[4]/x; 
+  fP4=p[4]/x;
 
   //Conversion of the covariance matrix
   Double_t c[15]; t.GetExternalCovariance(c);
@@ -99,6 +102,61 @@ AliKalmanTrack(t) {
 
 }
 
+//____________________________________________________________________________
+AliITStrackV2::AliITStrackV2(AliESDtrack& t,Bool_t c) throw (const Char_t *) :
+AliKalmanTrack() {
+  //------------------------------------------------------------------
+  // Conversion ESD track -> ITS track.
+  // If c==kTRUE, create the ITS track out of the constrained params.
+  //------------------------------------------------------------------
+  SetNumberOfClusters(t.GetITSclusters(fIndex));
+  SetLabel(t.GetLabel());
+  SetMass(t.GetMass());
+
+  fdEdx=t.GetITSsignal();
+  fAlpha = t.GetAlpha();
+  if      (fAlpha < -TMath::Pi()) fAlpha += 2*TMath::Pi();
+  else if (fAlpha >= TMath::Pi()) fAlpha -= 2*TMath::Pi();
+
+  //Conversion of the track parameters
+  Double_t x,p[5]; 
+  if (c) t.GetConstrainedExternalParameters(x,p);
+  else t.GetExternalParameters(x,p);
+  fX=x;    x=GetConvConst();
+  fP0=p[0]; 
+  fP1=p[1]; 
+  fP2=p[2];
+  fP3=p[3];
+  fP4=p[4]/x; 
+
+  //Conversion of the covariance matrix
+  Double_t cv[15]; 
+  if (c) t.GetConstrainedExternalCovariance(cv);
+  else t.GetExternalCovariance(cv);
+  fC00=cv[0 ];
+  fC10=cv[1 ];   fC11=cv[2 ];
+  fC20=cv[3 ];   fC21=cv[4 ];   fC22=cv[5 ];
+  fC30=cv[6 ];   fC31=cv[7 ];   fC32=cv[8 ];   fC33=cv[9 ];
+  fC40=cv[10]/x; fC41=cv[11]/x; fC42=cv[12]/x; fC43=cv[13]/x; fC44=cv[14]/x/x;
+
+  if (t.GetStatus()&AliESDtrack::kTIME) {
+    StartTimeIntegral();
+    Double_t times[10]; t.GetIntegratedTimes(times); SetIntegratedTimes(times);
+    SetIntegratedLength(t.GetIntegratedLength());
+  }
+  fESDtrack=&t;
+
+  if (!Invariant()) throw "AliITStrackV2: conversion failed !\n";
+
+}
+
+void AliITStrackV2::UpdateESDtrack(ULong_t flags) {
+  fESDtrack->UpdateTrackParams(this,flags);
+}
+void AliITStrackV2::SetConstrainedESDtrack(Double_t chi2) {
+  fESDtrack->SetConstrainedTrackParams(this,chi2);
+}
+
 //____________________________________________________________________________
 AliITStrackV2::AliITStrackV2(const AliITStrackV2& t) : AliKalmanTrack(t) {
   //------------------------------------------------------------------
@@ -121,6 +179,7 @@ AliITStrackV2::AliITStrackV2(const AliITStrackV2& t) : AliKalmanTrack(t) {
       fIndex[i]=t.fIndex[i];
       if (i<4) fdEdxSample[i]=t.fdEdxSample[i];
   }
+  fESDtrack=t.fESDtrack;
 }
 
 //_____________________________________________________________________________
@@ -239,6 +298,8 @@ Int_t AliITStrackV2::CorrectForMaterial(Double_t d, Double_t x0) {
   if (x0!=0.) {
      d*=x0;
      Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*d;
+     if (beta2/(1-beta2)>3.5*3.5)
+       dE=0.153e-3/beta2*(log(3.5*5940)+0.5*log(beta2/(1-beta2)) - beta2)*d;
      fP4*=(1.- sqrt(p2+GetMass()*GetMass())/p2*dE);
   }
 
@@ -387,6 +448,8 @@ Int_t AliITStrackV2::Update(const AliCluster* c, Double_t chi2, UInt_t index) {
      return 0;
   }
 
+  if (chi2<0) return 1;
+
   Int_t n=GetNumberOfClusters();
   fIndex[n]=index;
   SetNumberOfClusters(n+1);