// The pattern recongintion based on the "cooked covariance" approach
//-------------------------------------------------------------------------
-#include "AliTracker.h"
+#include "AliITSUTrackerGlo.h"
class TTree;
class TClonesArray;
class AliESDEvent;
class AliCluster;
class AliITSUClusterPix;
+class AliITSUTrackCooked;
+class AliITSUReconstructor;
//-------------------------------------------------------------------------
-class AliITSUTrackerCooked : public AliTracker {
+class AliITSUTrackerCooked : public AliITSUTrackerGlo {
public:
- enum{kNLayers=7, kMaxClusterPerLayer=70000};
- AliITSUTrackerCooked();
+ enum {
+ kNLayers=7, kMaxClusterPerLayer=150000, kMaxSelected=kMaxClusterPerLayer/10
+ };
+ AliITSUTrackerCooked(AliITSUReconstructor *rec);
virtual ~AliITSUTrackerCooked();
// These functions must be implemented
Int_t RefitInward(AliESDEvent *event);
Int_t LoadClusters(TTree *ct);
void UnloadClusters();
+ Bool_t
+ RefitAt(Double_t x, AliITSUTrackCooked *seed, const AliITSUTrackCooked *t);
+
AliCluster *GetCluster(Int_t index) const;
+ void SetSAonly(Bool_t sa=kTRUE) {fSAonly=sa;}
+ Bool_t GetSAonly() const {return fSAonly;}
+
// internal helper classes
class AliITSUlayer;
protected:
AliITSUTrackerCooked(const AliITSUTrackerCooked&);
// Other protected functions
- Int_t MakeSeeds(Int_t layer1, Int_t layer2);
+ Int_t MakeSeeds();
Bool_t AddCookedSeed(const Float_t r1[3], Int_t l1, Int_t i1,
const Float_t r2[3], Int_t l2, Int_t i2,
const AliCluster *c3,Int_t l3, Int_t i3);
+ void FollowProlongation();
+ Int_t TakeNextProlongation();
+ void ResetTrackToFollow(const AliITSUTrackCooked &t);
+ void ResetBestTrack();
private:
AliITSUTrackerCooked &operator=(const AliITSUTrackerCooked &tr);
static AliITSUlayer fgLayers[kNLayers];// Layers
TObjArray *fSeeds; // Track seeds
+
+ Int_t fI; // index of the current layer
+ AliITSUTrackCooked *fBestTrack; // "best" track
+ AliITSUTrackCooked *fTrackToFollow; // followed track
- ClassDef(AliITSUTrackerCooked,1) //ITSU stand-alone tracker
+ Bool_t fSAonly; // kTRUE if the standalone tracking only
+
+ ClassDef(AliITSUTrackerCooked,2) //ITSU stand-alone tracker
};
class AliITSUTrackerCooked::AliITSUlayer {
public:
AliITSUlayer();
- ~AliITSUlayer(){DeleteClusters();}
+ ~AliITSUlayer();
- void InsertClusters(TClonesArray *clusters);
+ void InsertClusters(TClonesArray *clusters, Bool_t seedingLayer, Bool_t sa);
void SetR(Double_t r) {fR=r;}
void DeleteClusters();
-
+ void ResetSelectedClusters() {fI=0;}
+ void SelectClusters(Float_t phi, Float_t dy, Float_t z, Float_t dz);
+ const AliCluster *GetNextCluster(Int_t &i);
+ void ResetTrack(const AliITSUTrackCooked &t);
Int_t FindClusterIndex(Double_t z) const;
- Double_t GetR() const {return fR;}
+ Float_t GetR() const {return fR;}
AliCluster *GetCluster(Int_t i) const { return fClusters[i]; }
+ Float_t GetXRef(Int_t i) const { return fXRef[i]; }
+ Float_t GetAlphaRef(Int_t i) const { return fAlphaRef[i]; }
+ Float_t GetClusterPhi(Int_t i) const { return fPhi[i]; }
Int_t GetNumberOfClusters() const {return fN;}
+ const AliITSUTrackCooked *GetTrack() const {return fTrack;}
protected:
AliITSUlayer(const AliITSUlayer&);
AliITSUlayer &operator=(const AliITSUlayer &tr);
Int_t InsertCluster(AliCluster *c);
- Double_t fR; // mean radius of this layer
+ Float_t fR; // mean radius of this layer
+
+ AliCluster *fClusters[kMaxClusterPerLayer]; // All clusters
+ Float_t fXRef[kMaxClusterPerLayer]; // x of the reference plane
+ Float_t fAlphaRef[kMaxClusterPerLayer]; // alpha of the reference plane
+ Float_t fPhi[kMaxClusterPerLayer]; // cluster phi
+ Int_t fN; // Total number of clusters
- AliCluster *fClusters[kMaxClusterPerLayer]; // array of clusters
- Int_t fN; //number of clusters
+ Int_t fIndex[kMaxSelected];
+ Int_t fNsel; // Number of selected clusters
+ Int_t fI; // Running index for the selected clusters
- Int_t fIndex[kMaxClusterPerLayer]; // Indexes of selected clusters
- Int_t fNsel; // number of selected clusters
+ AliITSUTrackCooked *fTrack; // track estimation at this layer
};