ROOT logo
AliRoot » TPC » REC » AliTPCtracker

class AliTPCtracker: public AliTracker

          Implementation of the TPC tracker

   Origin: Marian Ivanov   Marian.Ivanov@cern.ch

  AliTPC parallel tracker

  The track fitting is based on Kalman filtering approach
  The track finding steps:
      1. Seeding - with and without vertex constraint
                 - seeding with vertex constain done at first n^2 proble
                 - seeding without vertex constraint n^3 problem
      2. Tracking - follow prolongation road - find cluster - update kalman track
  The seeding and tracking is repeated several times, in different seeding region.
  This approach enables to find the track which cannot be seeded in some region of TPC
  This can happen because of low momenta (track do not reach outer radius), or track is currently in the ded region between sectors, or the track is for the moment overlapped with other track (seed quality is poor) ...

Function Members (Methods)

 
    This is an abstract class, constructors will not be documented.
    Look at the header to check for available constructors.

public:
virtual~AliTPCtracker()
voidTObject::AbstractMethod(const char* method) const
Int_tAcceptCluster(AliTPCseed* seed, AliTPCclusterMI* cluster)
virtual voidTObject::AppendPad(Option_t* option = "")
voidApplyTailCancellation()
voidApplyXtalkCorrection()
virtual voidTObject::Browse(TBrowser* b)
voidCalculateXtalkCorrection()
Int_tCheckKinkPoint(AliTPCseed* seed, AliTPCseed& mother, AliTPCseed& daughter, const AliESDkink& kink)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
Int_tClusters2Tracks()
virtual Int_tClusters2Tracks(AliESDEvent *const esd)
virtual Int_tClusters2TracksHLT(AliESDEvent *const esd, const AliESDEvent* hltEvent)
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidCookLabel(AliKalmanTrack* tk, Float_t wrong) const
virtual Int_tCookLabel(AliTPCseed *const t, Float_t wrong, Int_t first, Int_t last) const
virtual voidTObject::Copy(TObject& object) const
virtual voidTObject::Delete(Option_t* option = "")MENU
voidDeleteSeeds()
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual Double_tErrY2(AliTPCseed* seed, const AliTPCclusterMI* cl = 0)
virtual Double_tErrZ2(AliTPCseed* seed, const AliTPCclusterMI* cl = 0)
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
Double_tF1(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3) const
Double_tF1old(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3) const
Double_tF2(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3) const
Double_tF2old(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3) const
Double_tF3(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t z1, Double_t z2) const
Double_tF3n(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t z1, Double_t z2, Double_t c) const
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual voidFillClusterArray(TObjArray* array) const
voidFillESD(const TObjArray* arr)
static voidAliTracker::FillResiduals(const AliExternalTrackParam* t, const AliCluster* c, Bool_t updated = kTRUE)
static voidAliTracker::FillResiduals(const AliExternalTrackParam* t, Double_t* p, Double_t* cov, UShort_t id, Bool_t updated = kTRUE)
voidFilterOutlierClusters()
voidFindCurling(const TObjArray* array, AliESDEvent* esd, Int_t iter)
voidFindKinks(TObjArray* array, AliESDEvent* esd)
voidFindMultiMC(const TObjArray* array, AliESDEvent* esd, Int_t iter)
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
voidFindSplitted(TObjArray* array, AliESDEvent* esd, Int_t iter)
static Double_tAliTrackerBase::FitTrack(AliExternalTrackParam* trackParam, AliTrackPointArray* pointArray, Double_t mass, Double_t maxStep)
Int_tFollowBackProlongation(AliTPCseed& t, Int_t rf, Bool_t fromSeeds = 0)
Int_tFollowProlongation(AliTPCseed& t, Int_t rf = 0, Int_t step = 1, Bool_t fromSeeds = 0)
Int_tFollowToNext(AliTPCseed& t, Int_t nr)
Int_tFollowToNextCluster(AliTPCseed& t, Int_t nr)
static voidAliTrackerBase::GetBxByBz(const Double_t* r, Double_t* b)
static Double_tAliTrackerBase::GetBz()
static Double_tAliTrackerBase::GetBz(const Double_t* r)
virtual AliCluster*GetCluster(Int_t index) const
AliTPCclusterMI*GetClusterMI(Int_t index) const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
const AliEventInfo*AliTracker::GetEventInfo() const
virtual const char*TObject::GetIconName() const
virtual const char*TObject::GetName() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
virtual AliPlaneEff*AliTracker::GetPlaneEff()
Bool_tGetProlongation(Double_t x1, Double_t x2, Double_t* x, Double_t& y, Double_t& z) const
static TObjArray**AliTracker::GetResidualsArray()
TObjArray*GetSeeds() const
Double_tAliTrackerBase::GetSigmaX() const
Double_tAliTrackerBase::GetSigmaY() const
Double_tAliTrackerBase::GetSigmaZ() const
voidGetTailValue(Float_t ampfactor, Double_t& ionTailMax, Double_t& ionTailTotal, TGraphErrors** graphRes, Float_t* indexAmpGraphs, AliTPCclusterMI* cl0, AliTPCclusterMI* cl1)
virtual const char*TObject::GetTitle() const
virtual Bool_tGetTrackPoint(Int_t index, AliTrackPoint& p) const
virtual Bool_tAliTracker::GetTrackPointTrackingError(Int_t, AliTrackPoint&, const AliESDtrack*)
static Double_tAliTrackerBase::GetTrackPredictedChi2(AliExternalTrackParam* track, Double_t mass, Double_t step, const AliExternalTrackParam* backup)
virtual UInt_tTObject::GetUniqueID() const
Double_tAliTrackerBase::GetX() const
Double_tAliTrackerBase::GetY() const
Double_tAliTrackerBase::GetZ() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTObject::IsSortable() const
Bool_tIsTPCHVDipEvent(AliESDEvent *const esdEvent)
Bool_tTObject::IsZombie() const
Int_tLoadClusters()
virtual Int_tLoadClusters(TTree *const tree)
virtual Int_tLoadClusters(const TObjArray* arr)
virtual Int_tLoadClusters(const TClonesArray* arr)
Int_tLoadInnerSectors()
Int_tLoadOuterSectors()
virtual voidTObject::ls(Option_t* option = "") const
static Double_tAliTrackerBase::MakeC(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3)
voidMakeSeeds2(TObjArray* arr, Int_t sec, Int_t i1, Int_t i2, Float_t* cuts, Float_t deltay = -1, Bool_t bconstrain = kTRUE)
voidMakeSeeds3(TObjArray* arr, Int_t sec, Int_t i1, Int_t i2, Float_t* cuts, Float_t deltay = -1, Int_t ddsec = 0)
static Double_tAliTrackerBase::MakeSnp(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3)
static Double_tAliTrackerBase::MakeTgl(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t z1, Double_t z2)
static Double_tAliTrackerBase::MakeTgl(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t z1, Double_t z2, Double_t c)
voidMarkSeedFree(TObject* seed)
voidTObject::MayNotUse(const char* method) const
static Double_tAliTrackerBase::MeanMaterialBudget(const Double_t* start, const Double_t* end, Double_t* mparam)
TObject*&NextFreeSeed()
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
Float_tOverlapFactor(AliTPCseed* s1, AliTPCseed* s2, Int_t& sum1, Int_t& sum2)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual Int_tPostProcess(AliESDEvent* esd)
virtual voidTObject::Print(Option_t* option = "") const
Int_tPropagateBack(const TObjArray *const arr)
virtual Int_tPropagateBack(AliESDEvent* event)
Int_tPropagateBack(AliTPCseed *const pt, Int_t row0, Int_t row1)
Int_tPropagateForward()
Int_tPropagateForward2(const TObjArray *const arr)
static Bool_tAliTrackerBase::PropagateTrackTo(AliExternalTrackParam* track, Double_t x, Double_t m, Double_t maxStep, Bool_t rotateTo = kTRUE, Double_t maxSnp = 0.8, Int_t sign = 0, Bool_t addTimeStep = kFALSE, Bool_t correctMaterialBudget = kTRUE)
static Int_tAliTrackerBase::PropagateTrackTo2(AliExternalTrackParam* track, Double_t x, Double_t m, Double_t maxStep, Bool_t rotateTo = kTRUE, Double_t maxSnp = 0.8, Int_t sign = 0, Bool_t addTimeStep = kFALSE, Bool_t correctMaterialBudget = kTRUE)
static Bool_tAliTrackerBase::PropagateTrackToBxByBz(AliExternalTrackParam* track, Double_t x, Double_t m, Double_t maxStep, Bool_t rotateTo = kTRUE, Double_t maxSnp = 0.8, Int_t sign = 0, Bool_t addTimeStep = kFALSE)
virtual Int_tTObject::Read(const char* name)
Int_tReadSeeds(const TFile* in)
virtual voidTObject::RecursiveRemove(TObject* obj)
virtual Int_tRefitInward(AliESDEvent* esd)
Int_tRefitKink(AliTPCseed& mother, AliTPCseed& daughter, const AliESDkink& kink)
voidRemoveUsed2(TObjArray* arr, Float_t factor1, Float_t factor2, Int_t minimal)
voidTObject::ResetBit(UInt_t f)
voidResetSeedsPool()
voidRotateToLocal(AliTPCseed* seed)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidSetDebug(Int_t debug)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidAliTracker::SetEventInfo(AliEventInfo* evInfo)
static voidAliTracker::SetFillResiduals(AliRecoParam::EventSpecie_t es, Bool_t flag = kTRUE)
voidSetIteration(Int_t iteration)
static voidTObject::SetObjectStat(Bool_t stat)
static voidAliTracker::SetResidualsArray(TObjArray** arr)
voidSetSeeds(TObjArray* seeds)
voidSetTPCtrackerSectors(AliTPCtrackerSector* innerSec, AliTPCtrackerSector* outerSec)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidSetUseHLTClusters(Int_t useHLTClusters)
voidAliTrackerBase::SetVertex(const Double_t* xyz, const Double_t* ers = 0)
virtual voidShowMembers(TMemberInspector&)
voidSignClusters(const TObjArray* arr, Float_t fnumber = 3., Float_t fdensity = 2.)
voidSignShared(TObjArray* arr)
voidSignShared(AliTPCseed* s1, AliTPCseed* s2)
voidSortTracks(TObjArray* arr, Int_t mode) const
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
voidSumTracks(TObjArray* arr1, TObjArray*& arr2)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
voidTransform(AliTPCclusterMI* cluster)
static Bool_tAliTrackerBase::UniformField()
virtual voidUnloadClusters()
Int_tUpdateClusters(AliTPCseed& t, Int_t nr)
voidUpdateKinkQualityD(AliTPCseed* seed)
voidUpdateKinkQualityM(AliTPCseed* seed)
virtual voidAliTracker::UseClusters(const AliKalmanTrack* t, Int_t from = 0) const
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTObject::MakeZombie()
private:
voidAddCovariance(AliTPCseed* seed)
voidAddCovarianceAdd(AliTPCseed* seed)
voidDumpClusters(Int_t iter, TObjArray* trackArray)
voidFillClusterOccupancyInfo()
Double_tGetMaxY(Int_t row) const
Double_tGetPadPitchLength(Double_t x) const
Double_tGetPadPitchLength(Int_t row) const
AliTPCtrackerRow&GetRow(Int_t sec, Int_t row)
Int_tGetRowNumber(Double_t x) const
Int_tGetRowNumber(Double_t* x) const
voidGetShape(AliTPCseed* seed, Int_t row)
Double_tGetXrow(Int_t row) const
Bool_tIsActive(Int_t sec, Int_t row)
Bool_tIsFindable(AliTPCseed& t)
voidMakeESDBitmaps(AliTPCseed* t, AliESDtrack* esd)
AliTPCseed*MakeSeed(AliTPCseed *const track, Float_t r0, Float_t r1, Float_t r2)
voidMakeSeeds5(TObjArray* arr, Int_t sec, Int_t i1, Int_t i2, Float_t* cuts, Float_t deltay = -1)
TObjArray*MakeSeedsHLT(const AliESDEvent* hltEvent)
AliTPCtracker&operator=(const AliTPCtracker& r)
voidParallelTracking(TObjArray *const arr, Int_t rfirst, Int_t rlast)
voidPrepareForBackProlongation(const TObjArray *const arr, Float_t fac) const
voidPrepareForProlongation(TObjArray *const arr, Float_t fac) const
Int_tPropagateToRowHLT(AliTPCseed* pt, int nrow)
voidReadSeeds(const AliESDEvent *const event, Int_t direction)
AliTPCseed*ReSeed(AliTPCseed* t)
AliTPCseed*ReSeed(AliTPCseed* t, Int_t r0, Bool_t forward)
AliTPCseed*ReSeed(const AliTPCseed* t, Float_t r0, Float_t r1, Float_t r2)
voidTrackFollowingHLT(TObjArray *const arr)
TObjArray*Tracking()
voidTracking(TObjArray* arr)
TObjArray*Tracking(Int_t seedtype, Int_t i1, Int_t i2, Float_t* cuts, Float_t dy = -1, Int_t dsec = 0)
TObjArray*TrackingSpecial()
voidUnsignClusters()
Int_tUpdateTrack(AliTPCseed* t, Int_t accept)

Data Members

public:
enum EStreamFlags { kStreamTransform
kStreamErrParam
kStreamFilterClusterInfo
kStreamClDump
kStreamRemoveUsed
kStreamRemoveShort
kStreamSplitted2
kStreamFillESD
kStreamCPropagateBack
kStreamRecoverBack
kStreamRefitInward
kStreamRecoverIn
kStreamUpdateTrack
kStreamCrosstalkMatrix
kStreamXtalk
kStreamIonTail
kStreamFindMultiMC
kStreamFindCurling
kStreamFindKinks
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
private:
TObjArray*fCrossTalkSignalArrayfor 36 sectors
Int_tfDebugdebug option
TTreeSRedirector*fDebugStreamer!debug streamer
AliESDEvent*fEventoutput with esd tracks
const AliESDEvent*fEventHLTinput with HLT tracks
TArrayIfFreeSeedsID! array of ID's of freed seeds
AliTPCtrackerSector*fInnerSecarray of inner sectors;
TTree*fInputinput tree with clusters
Int_tfIterationindicate iteration - 0 - froward -1 back - 2forward - back->forward
Int_tfLastSeedID! id of the pool seed on which is returned by the NextFreeSeed method
Int_tfNnumber of loaded sectors
Int_tfNFreeSeeds! number of seeds freed in the pool
Bool_tfNewIOindicated if we have data using New IO
Int_tfNtrackscurrent number of tracks
AliTPCtrackerSector*fOuterSecarray of outer sectors;
TTree*fOutputoutput tree with tracks
Double_tfPadLength[200]max y for given pad row
AliTPCtrackerSector*fSectorspointer to loaded sectors;
TTree*fSeedTreeoutput tree with seeds - filled in debug mode 1
TObjArray*fSeedsarray of track seeds
TClonesArray*fSeedsPool! pool of seeds
TTree*fTreeDebugoutput with a debug information about track
Int_tfUseHLTClustersuse HLT clusters instead of offline clusters
Double_tfXRow[200]radius of the pad row
Double_tfYMax[200]max y for given pad row
const Int_tfkNISnumber of inner sectors
const Int_tfkNOSnumber of outer sectors
const AliTPCParam*fkParampointer to the parameters

Class Charts

Inheritance Chart:
TObject
AliTrackerBase
AliTracker
AliTPCtracker

Function documentation

Int_t UpdateTrack(AliTPCseed* t, Int_t accept)
update track information using current cluster - track->fCurrentCluster
Int_t AcceptCluster(AliTPCseed* seed, AliTPCclusterMI* cluster)
 decide according desired precision to accept given
 cluster for tracking
AliTPCtracker & operator=(const AliTPCtracker& r)
 dummy

~AliTPCtracker()
 TPC tracker destructor

void FillESD(const TObjArray* arr)

fill esds using updated tracks
Double_t ErrY2(AliTPCseed* seed, const AliTPCclusterMI* cl = 0)

 Use calibrated cluster error from OCDB

Double_t ErrZ2(AliTPCseed* seed, const AliTPCclusterMI* cl = 0)

 Use calibrated cluster error from OCDB

void RotateToLocal(AliTPCseed* seed)
rotate to track "local coordinata
Double_t F1old(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3) const
 Initial approximation of the track curvature

Double_t F1(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3) const
 Initial approximation of the track curvature

Double_t F2(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3) const
 Initial approximation of the track curvature

Double_t F2old(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3) const
 Initial approximation of the track curvature times center of curvature

Double_t F3(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t z1, Double_t z2) const
 Initial approximation of the tangent of the track dip angle

Double_t F3n(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t z1, Double_t z2, Double_t c) const
 Initial approximation of the tangent of the track dip angle

Bool_t GetProlongation(Double_t x1, Double_t x2, Double_t* x, Double_t& y, Double_t& z) const
 This function find proloncation of a track to a reference plane x=x2.

Int_t LoadClusters(TTree *const tree)
 load clusters

Int_t LoadClusters(const TObjArray* arr)
 load clusters to the memory
Int_t LoadClusters(const TClonesArray* arr)
 load clusters to the memory from one
 TClonesArray

Int_t LoadClusters()
 load clusters to the memory
void CalculateXtalkCorrection()
 Calculate crosstalk estimate

void FilterOutlierClusters()
 filter outlier clusters


    1.)..... booking part
    nSectors=72;
    nTimeBins=fParam->Get....
    TH2F hisTime("","", sector,0,sector, nTimeBins,0,nTimeBins);
    TH2F hisPadRow("","", sector,0,sector, nPadRows,0,nPadRows);
    2.) .... filling part
    .... cluster loop { hisTime.Fill(cluster->GetDetector(),cluster->GetTimeBin()); }

    3.) ...filtering part
    sector loop { calculate median,mean80 and rms80 of the nclusters per time bin; calculate median,mean80 and rms80 of the nclusters per par row; .... export values to the debug streamers - to decide which threshold to be used... }

    sector loop
    { disable clusters in time bins > mean+ n rms80+ offsetTime disable clusters in padRow > mean+ n rms80+ offsetPadRow // how to dislable clusters? - new bit to introduce }
    //
    4. Disabling clusters


void UnloadClusters()
 unload clusters from the memory

void FillClusterArray(TObjArray* array) const
 Filling cluster to the array - For visualization purposes

void Transform(AliTPCclusterMI* cluster)
 transformation

void ApplyXtalkCorrection()
 ApplyXtalk correction
 Loop over all clusters
      add to each cluster signal corresponding to common Xtalk mode for given time bin at given wire segment
 cluster loop
void ApplyTailCancellation()
 Correct the cluster charge for the ion tail effect
 The TimeResponse function accessed via  AliTPCcalibDB (TPC/Calib/IonTail)

void GetTailValue(Float_t ampfactor, Double_t& ionTailMax, Double_t& ionTailTotal, TGraphErrors** graphRes, Float_t* indexAmpGraphs, AliTPCclusterMI* cl0, AliTPCclusterMI* cl1)
Int_t LoadOuterSectors()
 This function fills outer TPC sectors with clusters.

Int_t LoadInnerSectors()
 This function fills inner TPC sectors with clusters.

AliTPCclusterMI * GetClusterMI(Int_t index) const
       Return pointer to a given cluster

Int_t FollowToNext(AliTPCseed& t, Int_t nr)
 This function tries to find a track prolongation to next pad row


Bool_t GetTrackPoint(Int_t index, AliTrackPoint& p) const
 Get track space point by index
 return false in case the cluster doesn't exist
Int_t UpdateClusters(AliTPCseed& t, Int_t nr)
 This function tries to find a track prolongation to next pad row

Int_t FollowToNextCluster(AliTPCseed& t, Int_t nr)
 This function tries to find a track prolongation to next pad row

Int_t FollowProlongation(AliTPCseed& t, Int_t rf = 0, Int_t step = 1, Bool_t fromSeeds = 0)
 This function tries to find a track prolongation.

Int_t FollowBackProlongation(AliTPCseed& t, Int_t rf, Bool_t fromSeeds = 0)
 This function tries to find a track prolongation.


Float_t OverlapFactor(AliTPCseed* s1, AliTPCseed* s2, Int_t& sum1, Int_t& sum2)
 overlapping factor

void SignShared(AliTPCseed* s1, AliTPCseed* s2)
 shared clusters

void SignShared(TObjArray* arr)
sort trackss according sectors

void SortTracks(TObjArray* arr, Int_t mode) const
sort tracks in array according mode criteria
void RemoveUsed2(TObjArray* arr, Float_t factor1, Float_t factor2, Int_t minimal)
 Loop over all tracks and remove overlaped tracks (with lower quality)
 Algorithm:
    1. Unsign clusters
    2. Sort tracks according quality
       Quality is defined by the number of cluster between first and last points

    3. Loop over tracks - decreasing quality order
       a.) remove - If the fraction of shared cluster less than factor (1- n or 2)
       b.) remove - If the minimal number of clusters less than minimal and not ITS
       c.) if track accepted - sign clusters

Called in - AliTPCtracker::Clusters2Tracks()
          - AliTPCtracker::PropagateBack()
          - AliTPCtracker::RefitInward()

 Arguments:
   factor1 - factor for constrained
   factor2 -        for non constrained tracks
            if (Float_t(shared+1)/Float_t(found+1)>factor) - DELETE

void DumpClusters(Int_t iter, TObjArray* trackArray)
 Dump clusters after reco
 signed and unsigned cluster can be visualized
 1. Unsign all cluster
 2. Sign all used clusters
 3. Dump clusters
void UnsignClusters()
 loop over all clusters and unsign them

void SignClusters(const TObjArray* arr, Float_t fnumber = 3., Float_t fdensity = 2.)
sign clusters to be "used"

 snumber and sdensity sign number of sigmas - bellow mean value to be accepted
 loop over "primaries"
Int_t RefitInward(AliESDEvent* esd)
 back propagation of ESD tracks

return 0;
Int_t PropagateBack(AliESDEvent* event)
 back propagation of ESD tracks

Int_t PostProcess(AliESDEvent* esd)
 Post process events

void DeleteSeeds()
void ReadSeeds(const AliESDEvent *const event, Int_t direction)
read seeds from the event
void MakeSeeds3(TObjArray* arr, Int_t sec, Int_t i1, Int_t i2, Float_t* cuts, Float_t deltay = -1, Int_t ddsec = 0)
 This function creates track seeds.
 SEEDING WITH VERTEX CONSTRAIN

 cuts[0]   - fP4 cut
 cuts[1]   - tan(phi)  cut
 cuts[2]   - zvertex cut
 cuts[3]   - fP3 cut
void MakeSeeds5(TObjArray* arr, Int_t sec, Int_t i1, Int_t i2, Float_t* cuts, Float_t deltay = -1)
 This function creates track seeds.

 cuts[0]   - fP4 cut
 cuts[1]   - tan(phi)  cut
 cuts[2]   - zvertex cut
 cuts[3]   - fP3 cut
void MakeSeeds2(TObjArray* arr, Int_t sec, Int_t i1, Int_t i2, Float_t* cuts, Float_t deltay = -1, Bool_t bconstrain = kTRUE)
 This function creates track seeds - without vertex constraint

 cuts[0]   - fP4 cut        - not applied
 cuts[1]   - tan(phi)  cut
 cuts[2]   - zvertex cut    - not applied
 cuts[3]   - fP3 cut
AliTPCseed * MakeSeed(AliTPCseed *const track, Float_t r0, Float_t r1, Float_t r2)

reseed using track points
AliTPCseed * ReSeed(const AliTPCseed* t, Float_t r0, Float_t r1, Float_t r2)

reseed using founded clusters

 Find the number of clusters
AliTPCseed * ReSeed(AliTPCseed* t, Int_t r0, Bool_t forward)

reseed using founded clusters

void FindMultiMC(const TObjArray* array, AliESDEvent* esd, Int_t iter)
  find multi tracks - THIS FUNCTION IS ONLY FOR DEBUG PURPOSES
                      USES MC LABELS
  Use AliTPCReconstructor::StreamLevel()& kStreamFindMultiMC if you want to tune parameters - cuts

  Two reasons to have multiple find tracks
  1. Curling tracks can be find more than once
  2. Splitted tracks
     a.) Multiple seeding to increase tracking efficiency - (~ 100% reached)
     b.) Edge effect on the sector boundaries


  Algorithm done in 2 phases - because of CPU consumption
  it is n^2 algorithm - for lead-lead 20000x20000 combination are investigated

  Algorihm for curling tracks sign:
    1 phase -makes a very rough fast cuts to minimize combinatorics
                 a.) opposite sign
                 b.) one of the tracks - not pointing to the primary vertex -
                 c.) delta tan(theta)
                 d.) delta phi
    2 phase - calculates DCA between tracks  - time consument
void FindSplitted(TObjArray* array, AliESDEvent* esd, Int_t iter)
 Find Splitted tracks and remove the one with worst quality
 Corresponding debug streamer to tune selections - "Splitted2"
 Algorithm:
 0. Sort tracks according quality
 1. Propagate the tracks to the reference radius
 2. Double_t loop to select close tracks (only to speed up process)
 3. Calculate cluster overlap ratio - and remove the track if bigger than a threshold
 4. Delete temporary parameters

void FindCurling(const TObjArray* array, AliESDEvent* esd, Int_t iter)
  find Curling tracks
  Use AliTPCReconstructor::StreamLevel()&kStreamFindCurling if you want to tune parameters - cuts


  Algorithm done in 2 phases - because of CPU consumption
  it is n^2 algorithm - for lead-lead 20000x20000 combination are investigated
  see detal in MC part what can be used to cut



void FindKinks(TObjArray* array, AliESDEvent* esd)
  find kinks


 RS something is wrong in this routine: not all seeds are assigned to daughters and mothers array, but they all are queried
 to check later
Int_t RefitKink(AliTPCseed& mother, AliTPCseed& daughter, const AliESDkink& kink)
 refit kink towards to the vertex


void UpdateKinkQualityM(AliTPCseed* seed)
 update Kink quality information for mother after back propagation

void UpdateKinkQualityD(AliTPCseed* seed)
 update Kink quality information for daughter after refit

Int_t CheckKinkPoint(AliTPCseed* seed, AliTPCseed& mother, AliTPCseed& daughter, const AliESDkink& kink)
 check kink point for given track
 if return value=0 kink point not found
 otherwise seed0 correspond to mother particle
           seed1 correspond to daughter particle
           kink  parameter of kink point
AliTPCseed* ReSeed(AliTPCseed* t)
 reseed - refit -  track

Int_t ReadSeeds(const TFile* in)
 This function reades track seeds.

Int_t Clusters2TracksHLT(AliESDEvent *const esd, const AliESDEvent* hltEvent)
 clusters to tracks
Int_t Clusters2Tracks(AliESDEvent *const esd)
 clusters to tracks
Int_t Clusters2Tracks()
 This is a track finder.

void Tracking(TObjArray* arr)
 tracking of the seeds

TObjArray * Tracking(Int_t seedtype, Int_t i1, Int_t i2, Float_t* cuts, Float_t dy = -1, Int_t dsec = 0)

tracking routine
TObjArray * Tracking()
 tracking

TObjArray * TrackingSpecial()
 seeding adjusted for laser and cosmic tests - short tracks with big inclination angle
 no primary vertex seeding tried

void SumTracks(TObjArray* arr1, TObjArray*& arr2)
sum tracks to common container
remove suspicious tracks
 RS: Attention: supplied tracks come in the static array, don't delete them
void ParallelTracking(TObjArray *const arr, Int_t rfirst, Int_t rlast)
 try to track in parralel
void PrepareForBackProlongation(const TObjArray *const arr, Float_t fac) const

 if we use TPC track itself we have to "update" covariance

void PrepareForProlongation(TObjArray *const arr, Float_t fac) const

 if we use TPC track itself we have to "update" covariance

Int_t PropagateBack(const TObjArray *const arr)
 make back propagation

Int_t PropagateForward2(const TObjArray *const arr)
 make forward propagation

Int_t PropagateForward()
 propagate track forward
UnsignClusters();
Int_t PropagateBack(AliTPCseed *const pt, Int_t row0, Int_t row1)
 make back propagation, in between row0 and row1

void GetShape(AliTPCseed* seed, Int_t row)
 gets cluster shape

void CookLabel(AliKalmanTrack* tk, Float_t wrong) const
This function "cooks" a track label. If label<0, this track is fake.

Int_t CookLabel(AliTPCseed *const t, Float_t wrong, Int_t first, Int_t last) const
This function "cooks" a track label. If label<0, this track is fake.

Int_t GetRowNumber(Double_t x) const
return pad row number for given x vector
void MakeESDBitmaps(AliTPCseed* t, AliESDtrack* esd)
 Fill the cluster and sharing bitmaps of the track

Bool_t IsFindable(AliTPCseed& t)
 return flag if there is findable cluster at given position

void AddCovariance(AliTPCseed* seed)
 Adding systematic error estimate to the covariance matrix
                !!!! the systematic error for element 4 is in 1/GeV
 03.03.2012     MI changed in respect to the previous versions
void AddCovarianceAdd(AliTPCseed* seed)
 Adding systematic error - as additive factor without correlation

                !!!! the systematic error for element 4 is in 1/GeV
 03.03.2012     MI changed in respect to the previous versions
Bool_t IsTPCHVDipEvent(AliESDEvent *const esdEvent)
 check events affected by TPC HV dip

void MarkSeedFree(TObject* seed)
 account that this seed is "deleted"
TObject *& NextFreeSeed()
 return next free slot where the seed can be created
void ResetSeedsPool()
 mark all seeds in the pool as unused
Int_t PropagateToRowHLT(AliTPCseed* pt, int nrow)
void TrackFollowingHLT(TObjArray *const arr)
 try to track in parralel
TObjArray * MakeSeedsHLT(const AliESDEvent* hltEvent)
 tracking

void FillClusterOccupancyInfo()
fill the cluster occupancy info into the ESD friend
AliTPCtrackerRow & GetRow(Int_t sec, Int_t row)
Bool_t IsActive(Int_t sec, Int_t row)
 check if the given sector row is active

Double_t GetXrow(Int_t row) const
  return (row>=fInnerSec->GetNRows()) ? fOuterSec->GetX(row-fInnerSec->GetNRows()):fInnerSec->GetX(row);
Double_t GetMaxY(Int_t row) const
Int_t GetRowNumber(Double_t x) const
Double_t GetPadPitchLength(Double_t x) const
Double_t GetPadPitchLength(Int_t row) const
void SetTPCtrackerSectors(AliTPCtrackerSector* innerSec, AliTPCtrackerSector* outerSec)
void SetIteration(Int_t iteration)
{fIteration = iteration;}
void SetDebug(Int_t debug)
{ fDebug = debug;}
TObjArray * GetSeeds() const
{return fSeeds;}
void SetSeeds(TObjArray* seeds)
{ fSeeds = seeds;}
AliCluster * GetCluster(Int_t index) const
{return (AliCluster*)GetClusterMI(index);}
void SetUseHLTClusters(Int_t useHLTClusters)
{fUseHLTClusters = useHLTClusters;}