First implementation of ESD classes (Yu.Belikov)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 22 May 2003 13:48:21 +0000 (13:48 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 22 May 2003 13:48:21 +0000 (13:48 +0000)
ITS/AliITSclusterV2.h
ITS/AliITStrackV2.cxx
ITS/AliITStrackV2.h
ITS/AliITStrackerV2.cxx
ITS/AliITStrackerV2.h
TPC/AliTPCcluster.h
TPC/AliTPCtrack.cxx
TPC/AliTPCtrack.h
TPC/AliTPCtracker.cxx
TPC/AliTPCtracker.h

index 219ef14..26c354a 100644 (file)
@@ -9,6 +9,7 @@
 //      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch 
 //-------------------------------------------------------------------------
 
+#include "TMath.h"
 #include "AliCluster.h"
 #include "AliITSrecoV2.h"
 
@@ -20,12 +21,12 @@ public:
     fIndex=lab[3];
     fQ=hit[4];
   }
-  void Use() {fSigmaY2=-fSigmaY2;}
+  void Use() {fQ=-fQ;}
   void SetQ(Float_t q) {fQ=q;}
   void SetDetectorIndex(Int_t i) { fIndex=i; }
 
-  Int_t IsUsed() const {return (fSigmaY2<0) ? 1 : 0;}
-  Float_t GetQ() const {return fQ;}
+  Int_t IsUsed() const {return (fQ<0) ? 1 : 0;}
+  Float_t GetQ() const {return TMath::Abs(fQ);}
   Int_t GetDetectorIndex() const { return 0x3FF&fIndex; }
 
   Int_t GetPindex() const { return 0xFFF00000&fIndex; }  //SSD clusters only
index d592f47..05df21e 100644 (file)
@@ -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,6 +83,43 @@ 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];
+  fP2=p[2];
+  fP3=p[3];
+  fP4=p[4]/x;
+
+  //Conversion of the covariance matrix
+  Double_t c[15]; t.GetExternalCovariance(c);
+
+  fC00=c[0 ];
+  fC10=c[1 ];   fC11=c[2 ];
+  fC20=c[3 ];   fC21=c[4 ];   fC22=c[5 ];
+  fC30=c[6 ];   fC31=c[7 ];   fC32=c[8 ];   fC33=c[9 ];
+  fC40=c[10]/x; fC41=c[11]/x; fC42=c[12]/x; fC43=c[13]/x; fC44=c[14]/x/x;
+
+  if (!Invariant()) throw "AliITStrackV2: conversion failed !\n";
+
+}
+
+//____________________________________________________________________________
+AliITStrackV2::AliITStrackV2(AliESDtrack& t) throw (const Char_t *) :
+AliKalmanTrack() {
+  //------------------------------------------------------------------
+  //Conversion ESD track -> ITS track
+  //------------------------------------------------------------------
+  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]; t.GetExternalParameters(x,p);
+  fX=x;    x=GetConvConst();
   fP0=p[0]; 
   fP1=p[1]; 
   fP2=p[2];
@@ -95,10 +135,21 @@ AliKalmanTrack(t) {
   fC30=c[6 ];   fC31=c[7 ];   fC32=c[8 ];   fC33=c[9 ];
   fC40=c[10]/x; fC41=c[11]/x; fC42=c[12]/x; fC43=c[13]/x; fC44=c[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);
+}
+
 //____________________________________________________________________________
 AliITStrackV2::AliITStrackV2(const AliITStrackV2& t) : AliKalmanTrack(t) {
   //------------------------------------------------------------------
@@ -121,6 +172,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 +291,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);
   }
 
index fbf4054..e69aec1 100644 (file)
@@ -29,6 +29,7 @@
 
 #include "AliITSrecoV2.h"
 
+class AliESDtrack;
 class AliTPCtrack;
 
 //_____________________________________________________________________________
@@ -36,6 +37,7 @@ class AliITStrackV2 : public AliKalmanTrack {
 public:
   AliITStrackV2();
   AliITStrackV2(const AliTPCtrack& t) throw (const Char_t *);
+  AliITStrackV2(AliESDtrack& t) throw (const Char_t *);
   AliITStrackV2(const AliITStrackV2& t);
   Int_t PropagateToVertex(Double_t d=0., Double_t x0=0.);
   Int_t Propagate(Double_t alpha, Double_t xr);
@@ -49,6 +51,7 @@ public:
   void SetDetectorIndex(Int_t i) {SetLabel(i);}
   void ResetCovariance();
   void ResetClusters() { SetChi2(0.); SetNumberOfClusters(0); }
+  void UpdateESDtrack(ULong_t flags);
   
   void *operator new(size_t s,void *p) { return p; }
   void *operator new(size_t s) { return ::operator new(s); }
@@ -57,6 +60,7 @@ public:
   Double_t GetX()    const {return fX;}
   Double_t GetAlpha()const {return fAlpha;}
   Double_t GetdEdx() const {return fdEdx;}
+  Double_t GetPIDsignal() const {return GetdEdx();}
   Double_t GetY()    const {return fP0;}
   Double_t GetZ()    const {return fP1;}
   Double_t GetSnp()  const {return fP2;}
@@ -96,13 +100,15 @@ private:
 
   Float_t fdEdxSample[4];   // array of dE/dx samples b.b.
 
+  AliESDtrack *fESDtrack;   //! pointer to the connected ESD track
+
   ClassDef(AliITStrackV2,2)   //ITS reconstructed track
 };
 
 inline 
 void AliITStrackV2::GetExternalParameters(Double_t& xr, Double_t x[5]) const {
   //---------------------------------------------------------------------
-  // This function return external TPC track representation
+  // This function return external ITS track representation
   //---------------------------------------------------------------------
      xr=fX;          
      x[0]=GetY(); x[1]=GetZ(); x[2]=GetSnp(); x[3]=GetTgl(); x[4]=Get1Pt();
index b20e726..7bb30ec 100644 (file)
@@ -27,6 +27,7 @@
 #include "AliITSgeom.h"
 #include "AliITSRecPoint.h"
 #include "AliTPCtrack.h"
+#include "AliESD.h"
 #include "AliITSclusterV2.h"
 #include "AliITStrackerV2.h"
 
@@ -98,12 +99,21 @@ void AliITStrackerV2::SetLayersNotToSkip(Int_t *l) {
 }
 
 Int_t AliITStrackerV2::LoadClusters() {
+  return LoadClusters(gFile);
+}
+
+Int_t AliITStrackerV2::LoadClusters(const TFile *cf) {
   //--------------------------------------------------------------------
   //This function loads ITS clusters
   //--------------------------------------------------------------------
+  if (!((TFile *)cf)->IsOpen()) {
+    Error("LoadClusters","file with ITS clusters has not been open !\n");
+    return 1;
+  }
+
   char   cname[100]; 
   sprintf(cname,"TreeC_ITS_%d",GetEventNumber());
-  TTree *cTree=(TTree*)gDirectory->Get(cname);
+  TTree *cTree=(TTree*)((TFile *)cf)->Get(cname);
   if (!cTree) { 
     Error("LoadClusters"," can't get cTree !\n");
     return 1;
@@ -178,6 +188,84 @@ static Int_t CorrectForDeadZoneMaterial(AliITStrackV2 *t) {
   return 0;
 }
 
+Int_t AliITStrackerV2::Clusters2Tracks(AliESD *event) {
+  //--------------------------------------------------------------------
+  // This functions reconstructs ITS tracks
+  // The clusters must be already loaded !
+  //--------------------------------------------------------------------
+  TObjArray itsTracks(15000);
+
+  {/* Read ESD tracks */
+    Int_t nentr=event->GetNumberOfTracks();
+    Info("Clusters2Tracks", "Number of ESD tracks: %d\n", nentr);
+    while (nentr--) {
+      AliESDtrack *esd=event->GetTrack(nentr);
+
+      if (esd->GetStatus() != AliESDtrack::kTPCin) continue;
+
+      AliITStrackV2 *t=0;
+      try {
+        t=new AliITStrackV2(*esd);
+      } catch (const Char_t *msg) {
+        Warning("Clusters2Tracks",msg);
+        delete t;
+        continue;
+      }
+      if (TMath::Abs(t->GetD())>4) continue;
+
+      if (CorrectForDeadZoneMaterial(t)!=0) {
+         Warning("Clusters2Tracks",
+                 "failed to correct for the material in the dead zone !\n");
+         delete t;
+         continue;
+      }
+      itsTracks.AddLast(t);
+    }
+  } /* End Read ESD tracks */
+
+  itsTracks.Sort();
+  Int_t nentr=itsTracks.GetEntriesFast();
+
+  Int_t ntrk=0;
+  for (fPass=0; fPass<2; fPass++) {
+     Int_t &constraint=fConstraint[fPass]; if (constraint<0) continue;
+     for (Int_t i=0; i<nentr; i++) {
+       AliITStrackV2 *t=(AliITStrackV2*)itsTracks.UncheckedAt(i);
+       if (t==0) continue;           //this track has been already tracked
+       Int_t tpcLabel=t->GetLabel(); //save the TPC track label
+
+       ResetTrackToFollow(*t);
+       ResetBestTrack();
+
+       for (FollowProlongation(); fI<kMaxLayer; fI++) {
+          while (TakeNextProlongation()) FollowProlongation();
+       }
+
+       if (fBestTrack.GetNumberOfClusters() == 0) continue;
+
+       if (fConstraint[fPass]) {
+          ResetTrackToFollow(*t);
+          if (!RefitAt(3.7, &fTrackToFollow, &fBestTrack)) continue;
+          ResetBestTrack();
+       }
+
+       fBestTrack.SetLabel(tpcLabel);
+       fBestTrack.CookdEdx();
+       CookLabel(&fBestTrack,0.); //For comparison only
+       fBestTrack.UpdateESDtrack(AliESDtrack::kITSin);
+       UseClusters(&fBestTrack);
+       delete itsTracks.RemoveAt(i);
+       ntrk++;
+     }
+  }
+
+  itsTracks.Delete();
+
+  Info("Clusters2Tracks","Number of prolonged tracks: %d\n",ntrk);
+
+  return 0;
+}
+
 Int_t AliITStrackerV2::Clusters2Tracks(const TFile *inp, TFile *out) {
   //--------------------------------------------------------------------
   //This functions reconstructs ITS tracks
@@ -292,6 +380,62 @@ Int_t AliITStrackerV2::Clusters2Tracks(const TFile *inp, TFile *out) {
   return 0;
 }
 
+Int_t AliITStrackerV2::PropagateBack(AliESD *event) {
+  //--------------------------------------------------------------------
+  // This functions propagates reconstructed ITS tracks back
+  // The clusters must be loaded !
+  //--------------------------------------------------------------------
+  Int_t nentr=event->GetNumberOfTracks();
+  Info("PropagateBack", "Number of ESD tracks: %d\n", nentr);
+
+  Int_t ntrk=0;
+  for (Int_t i=0; i<nentr; i++) {
+     AliESDtrack *esd=event->GetTrack(i);
+
+     if (esd->GetStatus()!=(AliESDtrack::kTPCin|AliESDtrack::kITSin)) continue;
+
+     AliITStrackV2 *t=0;
+     try {
+        t=new AliITStrackV2(*esd);
+     } catch (const Char_t *msg) {
+        Warning("PropagateBack",msg);
+        delete t;
+        continue;
+     }
+
+     ResetTrackToFollow(*t);
+
+     // propagete to vertex [SR, GSI 17.02.2003]
+     fTrackToFollow.PropagateTo(3.,0.0028,65.19);
+     fTrackToFollow.PropagateToVertex();
+
+     // Start Time measurement [SR, GSI 17.02.2003]
+     fTrackToFollow.StartTimeIntegral();
+     fTrackToFollow.PropagateTo(3.,-0.0028,65.19);
+
+     fTrackToFollow.ResetCovariance(); fTrackToFollow.ResetClusters();
+     if (RefitAt(49.,&fTrackToFollow,t)) {
+        if (CorrectForDeadZoneMaterial(&fTrackToFollow)!=0) {
+          Warning("PropagateBack",
+                  "failed to correct for the material in the dead zone !\n");
+          delete t;
+          continue;
+        }
+        fTrackToFollow.SetLabel(t->GetLabel());
+        fTrackToFollow.CookdEdx();
+        CookLabel(&fTrackToFollow,0.); //For comparison only
+        fTrackToFollow.UpdateESDtrack(AliESDtrack::kITSout);
+        UseClusters(&fTrackToFollow);
+        ntrk++;
+     }
+     delete t;
+  }
+
+  Info("PropagateBack","Number of back propagated ITS tracks: %d\n",ntrk);
+
+  return 0;
+}
+
 Int_t AliITStrackerV2::PropagateBack(const TFile *inp, TFile *out) {
   //--------------------------------------------------------------------
   //This functions propagates reconstructed ITS tracks back
@@ -376,6 +520,59 @@ Int_t AliITStrackerV2::PropagateBack(const TFile *inp, TFile *out) {
   return 0;
 }
 
+Int_t AliITStrackerV2::RefitInward(AliESD *event) {
+  //--------------------------------------------------------------------
+  // This functions refits ITS tracks using the 
+  // "inward propagated" TPC tracks
+  // The clusters must be loaded !
+  //--------------------------------------------------------------------
+  Int_t nentr=event->GetNumberOfTracks();
+  Info("RefitInward", "Number of ESD tracks: %d\n", nentr);
+
+  Int_t ntrk=0;
+  for (Int_t i=0; i<nentr; i++) {
+    AliESDtrack *esd=event->GetTrack(i);
+
+    ULong_t flags = AliESDtrack::kITSin | AliESDtrack::kTPCrefit;
+
+    if ( (esd->GetStatus() & flags) != flags ) continue;
+    if ( esd->GetStatus() & AliESDtrack::kITSrefit) continue;
+
+    AliITStrackV2 *t=0;
+    try {
+        t=new AliITStrackV2(*esd);
+    } catch (const Char_t *msg) {
+        Warning("RefitInward",msg);
+        delete t;
+        continue;
+    }
+
+    if (CorrectForDeadZoneMaterial(t)!=0) {
+       Warning("RefitInward",
+               "failed to correct for the material in the dead zone !\n");
+       delete t;
+       continue;
+    }
+
+    ResetTrackToFollow(*t);
+
+    //Refitting...
+    if (RefitAt(3.7, &fTrackToFollow, t)) {
+       fTrackToFollow.SetLabel(t->GetLabel());
+       fTrackToFollow.CookdEdx();
+       CookLabel(&fTrackToFollow,0.); //For comparison only
+       fTrackToFollow.UpdateESDtrack(AliESDtrack::kITSrefit);
+       UseClusters(&fTrackToFollow);
+       ntrk++;
+    }
+    delete t;
+  }
+
+  Info("RefitInward","Number of refitted tracks: %d\n",ntrk);
+
+  return 0;
+}
+
 Int_t AliITStrackerV2::RefitInward(const TFile *inp, TFile *out) {
   //--------------------------------------------------------------------
   // This functions refits ITS tracks using the 
@@ -497,6 +694,7 @@ Int_t AliITStrackerV2::RefitInward(const TFile *inp, TFile *out) {
 
   delete tpcTree;
   delete itrack;
+  UnloadClusters();
   itsTracks.Delete();
 
   savedir->cd();
index 9cfbe40..5ccbf03 100644 (file)
@@ -13,6 +13,7 @@
 #include "AliITStrackV2.h"
 
 class AliITSclusterV2;
+class AliESD;
 class AliITSgeom;
 class TFile;
 
@@ -24,10 +25,14 @@ public:
   AliITStrackerV2(const AliITSgeom *geom);
   AliCluster *GetCluster(Int_t index) const;
   Int_t LoadClusters();
+  Int_t LoadClusters(const TFile *cf);
   void UnloadClusters();
   Int_t Clusters2Tracks(const TFile *in, TFile *out);
+  Int_t Clusters2Tracks(AliESD *event);
   Int_t PropagateBack(const TFile *in, TFile *out);
+  Int_t PropagateBack(AliESD *event);
   Int_t RefitInward(const TFile *in, TFile *out);
+  Int_t RefitInward(AliESD *event);
   Bool_t RefitAt(Double_t x, AliITStrackV2 *seed, const AliITStrackV2 *t);
   void SetupFirstPass(Int_t *flags, Double_t *cuts=0);
   void SetupSecondPass(Int_t *flags, Double_t *cuts=0);
index c6da09b..3b84475 100644 (file)
@@ -11,6 +11,7 @@
 //   Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch 
 //-------------------------------------------------------
 
+#include "TMath.h"
 #include "AliCluster.h"
 
 //_____________________________________________________________________________
@@ -22,7 +23,7 @@ public:
   void SetQ(Float_t q) {fQ=q;}
 
   Int_t IsUsed() const {return (fQ<0) ? 1 : 0;}
-  Float_t GetQ() const {return fQ;}
+  Float_t GetQ() const {return TMath::Abs(fQ);}
 
 private:
   Float_t   fQ ;       //Q of cluster (in ADC counts)
index 3cf5b5d..c5970e4 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.21  2003/05/22 10:46:46  hristov
+Using access methods instead of data members
+
 Revision 1.20  2003/04/10 10:36:54  hristov
 Code for unified TPC/TRD tracking (S.Radomski)
 
@@ -62,6 +65,7 @@ Logs added
 #include "AliTPCtrack.h"
 #include "AliCluster.h"
 #include "AliBarrelTrack.h"
+#include "AliESDtrack.h"
 
 ClassImp(AliTPCtrack)
 
@@ -138,6 +142,49 @@ AliKalmanTrack(t) {
 }
 
 //_____________________________________________________________________________
+AliTPCtrack::AliTPCtrack(const AliESDtrack& t) : AliKalmanTrack() {
+  //-----------------------------------------------------------------
+  // Conversion AliESDtrack -> AliTPCtrack.
+  //-----------------------------------------------------------------
+  SetNumberOfClusters(t.GetTPCclusters(fIndex));
+  SetLabel(t.GetLabel());
+  SetMass(t.GetMass());
+
+  fdEdx  = t.GetTPCsignal();
+  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]; t.GetExternalParameters(x,p);
+  fX=x;    x=GetConvConst();
+  fP0=p[0];
+  fP1=p[1];
+  fP3=p[3];
+  fP4=p[4]/x;
+  fP2=fP4*fX - p[2];
+
+  //Conversion of the covariance matrix
+  Double_t c[15]; t.GetExternalCovariance(c);
+  c[10]/=x; c[11]/=x; c[12]/=x; c[13]/=x; c[14]/=x*x;
+
+  Double_t c22=fX*fX*c[14] - 2*fX*c[12] + c[5];
+  Double_t c32=fX*c[13] - c[8];
+  Double_t c20=fX*c[10] - c[3], c21=fX*c[11] - c[4], c42=fX*c[14] - c[12];
+
+  fC00=c[0 ];
+  fC10=c[1 ];   fC11=c[2 ];
+  fC20=c20;     fC21=c21;     fC22=c22;
+  fC30=c[6 ];   fC31=c[7 ];   fC32=c32;   fC33=c[9 ];
+  fC40=c[10];   fC41=c[11];   fC42=c42;   fC43=c[13]; fC44=c[14];
+
+  if (t.GetStatus()&AliESDtrack::kTIME == 0) return;
+  StartTimeIntegral();
+  Double_t times[10]; t.GetIntegratedTimes(times); SetIntegratedTimes(times);
+  SetIntegratedLength(t.GetIntegratedLength());
+}
+
+//_____________________________________________________________________________
 AliTPCtrack::AliTPCtrack(const AliTPCtrack& t) : AliKalmanTrack(t) {
   //-----------------------------------------------------------------
   // This is a track copy constructor.
index 203dd37..5764a47 100644 (file)
@@ -2,11 +2,8 @@
 #define ALITPCTRACK_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
-
 /* $Id$ */
 
-
-
 //-------------------------------------------------------
 //                    TPC Track Class
 //
  *      external param3:   tangent of the track momentum dip angle           *
  *      external param4:   1/pt (1/(GeV/c))                                  *
  *****************************************************************************/
-
 #include <AliKalmanTrack.h>
 #include <TMath.h>
 
 #include "AliTPCreco.h"
 
 class AliBarrelTrack;
+class AliESDtrack;
 
 //_____________________________________________________________________________
 class AliTPCtrack : public AliKalmanTrack {
@@ -41,6 +38,7 @@ public:
   AliTPCtrack(UInt_t index, const Double_t xx[5], 
               const Double_t cc[15], Double_t xr, Double_t alpha); 
   AliTPCtrack(const AliKalmanTrack& t, Double_t alpha);
+  AliTPCtrack(const AliESDtrack& t);
   AliTPCtrack(const AliTPCtrack& t);
   virtual ~AliTPCtrack() {}
   Int_t PropagateToVertex(Double_t x0=36.66,Double_t rho=1.2e-3);
@@ -50,10 +48,11 @@ public:
   Double_t GetX()     const {return fX;}
   Double_t GetAlpha() const {return fAlpha;}
   Double_t GetdEdx()  const {return fdEdx;}
+  Double_t GetPIDsignal()  const {return GetdEdx();}
 
   Double_t GetY()   const {return fP0;}
   Double_t GetZ()   const {return fP1;}
-  Double_t GetSnp() const {return fX*fP4 - fP2;}             
+  Double_t GetSnp() const {return fX*fP4 - fP2;}
   Double_t 
     Get1Pt() const { return (1e-9*TMath::Abs(fP4)/fP4 + fP4)*GetConvConst(); }
   Double_t GetTgl() const {return fP3;}
@@ -101,7 +100,7 @@ public:
     cc[3 ]=fC20;  cc[4 ]=fC21;  cc[5 ]=fC22;
     cc[6 ]=fC40;  cc[7 ]=fC41;  cc[8 ]=fC42;  cc[9 ]=fC44;
     cc[10]=fC30;  cc[11]=fC31;  cc[12]=fC32;  cc[13]=fC43;  cc[14]=fC33;
-  }  
+  }
 //****************************************************** 
 
   virtual Double_t GetPredictedChi2(const AliCluster *cluster) const;
@@ -127,7 +126,7 @@ protected:
   Double_t fC20, fC21, fC22;             // of the
   Double_t fC30, fC31, fC32, fC33;       // track
   Double_t fC40, fC41, fC42, fC43, fC44; // parameters
+
   UInt_t fIndex[kMaxRow];       // indices of associated clusters 
 
   //[SR, 01.04.2003]
@@ -143,10 +142,9 @@ void AliTPCtrack::GetExternalParameters(Double_t& xr, Double_t x[5]) const {
   //---------------------------------------------------------------------
   // This function return external TPC track representation
   //---------------------------------------------------------------------
-     xr=fX;          
+     xr=fX;
      x[0]=GetY(); x[1]=GetZ(); x[2]=GetSnp(); x[3]=GetTgl(); x[4]=Get1Pt();
 }
 
 #endif
 
-
index 2bbf4f2..91022c8 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.32  2003/04/10 10:36:54  hristov
+Code for unified TPC/TRD tracking (S.Radomski)
+
 Revision 1.31  2003/03/19 17:14:11  hristov
 Load/UnloadClusters added to the base class and the derived classes changed correspondingly. Possibility to give 2 input files for ITS and TPC tracks in PropagateBack. TRD tracker uses fEventN from the base class (T.Kuhr)
 
@@ -104,6 +107,8 @@ Splitted from AliTPCtracking
 #include <TTree.h>
 #include <Riostream.h>
 
+#include "AliESD.h"
+
 #include "AliTPCtracker.h"
 #include "AliTPCcluster.h"
 #include "AliTPCParam.h"
@@ -112,6 +117,9 @@ Splitted from AliTPCtracking
 #include "TVector2.h"
 
 #include <stdlib.h>
+
+ClassImp(AliTPCtracker)
+
 //_____________________________________________________________________________
 AliTPCtracker::AliTPCtracker(const AliTPCParam *par): 
 AliTracker(), fkNIS(par->GetNInnerSector()/2), fkNOS(par->GetNOuterSector()/2)
@@ -333,12 +341,16 @@ Double_t f3(Double_t x1,Double_t y1,
   return (z1 - z2)/sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
 }
 
-//_____________________________________________________________________________
 Int_t AliTPCtracker::LoadClusters() {
+  return LoadClusters(gFile);
+}
+
+//_____________________________________________________________________________
+Int_t AliTPCtracker::LoadClusters(const TFile *cf) {
   //-----------------------------------------------------------------
   // This function loads TPC clusters.
   //-----------------------------------------------------------------
-  if (!gFile->IsOpen()) {
+  if (!((TFile*)cf)->IsOpen()) {
     cerr<<"AliTPCtracker::LoadClusters : "<<
       "file with clusters has not been open !\n";
     return 1;
@@ -346,7 +358,7 @@ Int_t AliTPCtracker::LoadClusters() {
 
   Char_t name[100];
   sprintf(name,"TreeC_TPC_%d",GetEventNumber());
-  TTree *cTree=(TTree*)gFile->Get(name);
+  TTree *cTree=(TTree*)((TFile*)cf)->Get(name);
   if (!cTree) {
     cerr<<"AliTPCtracker::LoadClusters : "<<
       "can't get the tree with TPC clusters !\n";
@@ -359,7 +371,7 @@ Int_t AliTPCtracker::LoadClusters() {
       "can't get the segment branch !\n";
     return 3;
   }
-//  AliClusters carray, *addr=&carray;
+
   AliClusters carray, *addr=&carray;
   carray.SetClass("AliTPCcluster");
   carray.SetArray(0);
@@ -376,9 +388,9 @@ Int_t AliTPCtracker::LoadClusters() {
       Int_t id=carray.GetID();
       if ((id<0) || (id>2*(fkNIS*nir + fkNOS*nor))) {
          cerr<<"AliTPCtracker::LoadClusters : "<<
-              "wrong index !\n";
+               "wrong index !\n";
          exit(1);
-      }        
+      }
       Int_t outindex = 2*fkNIS*nir;
       if (id<outindex) {
          Int_t sec = id/nir;
@@ -388,7 +400,7 @@ Int_t AliTPCtracker::LoadClusters() {
          while (ncl--) {
            AliTPCcluster *c=(AliTPCcluster*)carray[ncl];
            padrow.InsertCluster(c,sec,row);
-         }           
+         }
       } else {
          id -= outindex;
          Int_t sec = id/nor;
@@ -400,7 +412,6 @@ Int_t AliTPCtracker::LoadClusters() {
            padrow.InsertCluster(c,sec+fkNIS,row);
          }
       }
-
       carray.GetArray()->Clear();
   }
   delete cTree;
index 36df374..37237b0 100644 (file)
@@ -19,6 +19,7 @@
 class TFile;
 class AliTPCParam;
 class TObjArray;
+class AliESD;
 
 class AliTPCtracker : public AliTracker {
 public:
@@ -32,11 +33,14 @@ public:
    Int_t ReadSeeds(const TFile *in);
 
    Int_t LoadClusters();
+   Int_t LoadClusters(const TFile *cf);
    void UnloadClusters();
 
    AliCluster *GetCluster(Int_t index) const;
    Int_t Clusters2Tracks(const TFile *in, TFile *out);
+   Int_t Clusters2Tracks(AliESD *event);
    Int_t PropagateBack(const TFile *in, TFile *out);
+   Int_t PropagateBack(AliESD *event);
    Int_t PropagateBack(const TFile *in, const TFile *in2, TFile *out);
    Int_t RefitInward(TFile *outTracks, TFile *inTracks);
 
@@ -179,6 +183,7 @@ private:
    TClonesArray *fBarrelArray;
    AliBarrelTrack *fBarrelTrack;
 
+  ClassDef(AliTPCtracker,1)   // Time Projection Chamber tracker
 };
 
 #endif