// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-------------------------------------------------------------------------
+#include "TMath.h"
#include "AliCluster.h"
#include "AliITSrecoV2.h"
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
#include "AliCluster.h"
#include "AliTPCtrack.h"
+#include "AliESDtrack.h"
#include "AliITStrackV2.h"
ClassImp(AliITStrackV2)
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) {
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];
+ 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();
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) {
//------------------------------------------------------------------
fIndex[i]=t.fIndex[i];
if (i<4) fdEdxSample[i]=t.fdEdxSample[i];
}
+ fESDtrack=t.fESDtrack;
}
//_____________________________________________________________________________
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);
}
#include "AliITSrecoV2.h"
+class AliESDtrack;
class AliTPCtrack;
//_____________________________________________________________________________
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);
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); }
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;}
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();
#include "AliITSgeom.h"
#include "AliITSRecPoint.h"
#include "AliTPCtrack.h"
+#include "AliESD.h"
#include "AliITSclusterV2.h"
#include "AliITStrackerV2.h"
}
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;
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
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
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
delete tpcTree;
delete itrack;
+ UnloadClusters();
itsTracks.Delete();
savedir->cd();
#include "AliITStrackV2.h"
class AliITSclusterV2;
+class AliESD;
class AliITSgeom;
class TFile;
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);
// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-------------------------------------------------------
+#include "TMath.h"
#include "AliCluster.h"
//_____________________________________________________________________________
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)
/*
$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)
#include "AliTPCtrack.h"
#include "AliCluster.h"
#include "AliBarrelTrack.h"
+#include "AliESDtrack.h"
ClassImp(AliTPCtrack)
}
+//_____________________________________________________________________________
+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) {
//-----------------------------------------------------------------
#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 {
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);
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;}
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;
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]
//---------------------------------------------------------------------
// 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
-
/*
$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)
#include <TTree.h>
#include <Riostream.h>
+#include "AliESD.h"
+
#include "AliTPCtracker.h"
#include "AliTPCcluster.h"
#include "AliTPCParam.h"
#include "TVector2.h"
#include <stdlib.h>
+
+ClassImp(AliTPCtracker)
+
//_____________________________________________________________________________
AliTPCtracker::AliTPCtracker(const AliTPCParam *par):
AliTracker(), fkNIS(par->GetNInnerSector()/2), fkNOS(par->GetNOuterSector()/2)
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;
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";
"can't get the segment branch !\n";
return 3;
}
-// AliClusters carray, *addr=&carray;
+
AliClusters carray, *addr=&carray;
carray.SetClass("AliTPCcluster");
carray.SetArray(0);
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;
while (ncl--) {
AliTPCcluster *c=(AliTPCcluster*)carray[ncl];
padrow.InsertCluster(c,sec,row);
- }
+ }
} else {
id -= outindex;
Int_t sec = id/nor;
padrow.InsertCluster(c,sec+fkNIS,row);
}
}
-
carray.GetArray()->Clear();
}
delete cTree;
class TFile;
class AliTPCParam;
class TObjArray;
+class AliESD;
class AliTPCtracker : public AliTracker {
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);
TClonesArray *fBarrelArray;
AliBarrelTrack *fBarrelTrack;
+ ClassDef(AliTPCtracker,1) // Time Projection Chamber tracker
};
#endif