ITS/UPGRADE/AliITSUTrackerGlo.h

   1 #ifndef ALIITSTRACKERU_H
   2 #define ALIITSTRACKERU_H
   3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 //-------------------------------------------------------------------------
   7 //                ITS upgrade tracker base class
   8 //-------------------------------------------------------------------------
   9 #include "AliTracker.h"
  10 #include "AliESDEvent.h"
  11 #include "AliITSUSeed.h"
  12 #include "AliITSUTrackCond.h"
  13 #include "AliITSUTrackHyp.h"
  14 #include "AliITSUAux.h"
  15 #include <TArrayI.h>
  16
  17 class AliITSUReconstructor;
  18 class AliITSURecoDet;
  19 class AliITSUClusterPix;
  20 class AliESDtrack;
  21 class AliITSURecoLayer;
  22 class TTree;
  23
  24
  25 //-------------------------------------------------------------------------
  26 class AliITSUTrackerGlo : public AliTracker {
  27
  28   public:
  29   enum {kClus2Tracks,kPropBack,kRefitInw,kNTrackingPhases};   // tracking phases
  30   enum { // info from track extrapolation to layer for cluster check
  31     kTrXIn ,kTrYIn ,kTrZIn ,kTrPhiIn , // entrance (outer) point on the layer from above
  32     kTrXOut,kTrYOut,kTrZOut,kTrPhiOut, // exit (inner) point on the layer
  33     kTrPhi0, kTrDPhi, kTrZ0, kTrDZ,     // mean phi,dPhi, mean z, dZ (don't change this order)
  34     kNTrImpData};
  35   //
  36   enum {kMissingCluster=0  // no cluster found on this layer
  37         ,kTransportFailed=1  // seed did not reach target layer
  38         ,kRWCheckFailed =2  // failed to rotate the seed to frame of the layer impact point
  39   };
  40   enum {kStopSearchOnSensor,kClusterNotMatching,kClusterMatching}; // flags for track-to-cluster checks
  41   //
  42   enum {kDummyLabel=-3141593};
  43   //
  44   AliITSUTrackerGlo(AliITSUReconstructor* rec);
  45   virtual ~AliITSUTrackerGlo();
  46
  47   virtual Int_t          Clusters2Tracks(AliESDEvent *event);
  48   virtual Int_t          PropagateBack(AliESDEvent *event);
  49   virtual Int_t          RefitInward(AliESDEvent *event);
  50   virtual Int_t          LoadClusters(TTree * treeRP=0);
  51   virtual void           UnloadClusters();
  52   virtual AliCluster*    GetCluster(Int_t index) const;
  53   void                   PrintSeedClusters(const AliITSUSeed* seed, Option_t* option="");
  54   //
  55   Int_t                  GetCountPronlongationTrials() const {return fCountProlongationTrials;}
  56   Int_t                  GetCountITSin()               const {return fCountITSin;}
  57   Int_t                  GetCountITSout()              const {return fCountITSout;}
  58   Int_t                  GetCountITSrefit()            const {return fCountITSrefit;}
  59
  60   //------------------------------------
  61   AliITSURecoDet*        GetITSInterface()       const {return fITS;}
  62   //
  63   //------------------------------------
  64   Bool_t                 NeedToProlong(AliESDtrack* estTr, Int_t esdID);
  65   void                   Init(AliITSUReconstructor* rec);
  66   void                   FindTrack(AliESDtrack* esdTr, Int_t esdID);
  67   void                   CreateDefaultTrackCond();
  68   AliITSUTrackHyp*       InitHypothesis(AliESDtrack *esdTr, Int_t esdID);
  69   Bool_t                 TransportToLayer(AliITSUSeed* seed, Int_t lFrom, Int_t lTo, Double_t rLim=-1);
  70   Bool_t                 TransportToLayer(AliExternalTrackParam* seed, Int_t lFrom, Int_t lTo, Double_t rLim=-1);
  71   Bool_t                 TransportToLayerX(AliExternalTrackParam* seed, Int_t lFrom, Int_t lTo, Double_t xStop);
  72   Bool_t                 GoToExitFromLayer(AliITSUSeed* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check=kTRUE);
  73   Bool_t                 GoToExitFromLayer(AliExternalTrackParam* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check=kTRUE);
  74   Bool_t                 GoToEntranceToLayer(AliITSUSeed* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check=kFALSE);
  75   Bool_t                 GoToEntranceToLayer(AliExternalTrackParam* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check=kFALSE);
  76   Bool_t                 PropagateSeed(AliITSUSeed *seed, Double_t xToGo, Double_t mass, Double_t maxStep=1.0, Bool_t matCorr=kTRUE);
  77   Bool_t                 PropagateSeed(AliExternalTrackParam *seed, Double_t xToGo, Double_t mass, Double_t maxStep=1.0, Bool_t matCorr=kTRUE);
  78   Double_t               RefitTrack(AliExternalTrackParam* trc, Double_t r, Int_t& nclFit, Int_t stopCond=0);
  79   Int_t                  GetTrackingPhase()                 const {return fTrackPhaseID;}
  80
  81   //
  82   void                   KillSeed(AliITSUSeed* seed, Bool_t branch=kFALSE);
  83   Bool_t                 NeedToKill(AliITSUSeed* seed, Int_t flag);
  84   Bool_t                 GetRoadWidth(AliITSUSeed* seed, int ilrA);
  85   Bool_t                 CheckBackwardMatching(AliITSUSeed* seed);
  86   Int_t                  CheckCluster(AliITSUSeed* seed, Int_t lr, Int_t clID);
  87   void                   AddProlongationHypothesis(AliITSUSeed* seed, Int_t lr);
  88   Bool_t                 AddSeedBranch(AliITSUSeed* seed);
  89   void                   ValidateAllowedBranches(Int_t accMax);
  90   void                   ValidateAllowedCandidates(Int_t ilr, Int_t accMax);
  91   void                   FlagSeedClusters(const AliITSUSeed* seed, Bool_t flg, UShort_t hypRef);
  92   //
  93   AliITSUSeed*           NewSeedFromPool(const AliITSUSeed* src=0);
  94   void                   ResetSeedsPool();
  95   void                   MarkSeedFree(AliITSUSeed* seed );
  96
  97   AliITSUTrackHyp*       GetTrackHyp(Int_t id)               const  {return (AliITSUTrackHyp*)fHypStore.UncheckedAt(id);}
  98   void                   SetTrackHyp(AliITSUTrackHyp* hyp,Int_t id) {fHypStore.AddAtAndExpand(hyp,id);}
  99   void                   DeleteLastSeedFromPool()                   {fSeedsPool.RemoveLast();}
 100   void                   CheckClusterSharingConflicts(AliITSUTrackHyp* hyp);
 101   void                   SaveReducedHypothesesTree(AliITSUTrackHyp* dest);
 102   void                   CleanHypothesis(AliITSUTrackHyp* hyp);
 103   void                   FinalizeHypotheses();
 104   Bool_t                 FinalizeHypothesis(AliITSUTrackHyp* hyp);
 105   void                   UpdateESDTrack(AliITSUTrackHyp* hyp,Int_t flag);
 106   void                   CookMCLabel(AliITSUTrackHyp* hyp);
 107   void                   SetTrackingPhase(Int_t p)        {fTrackPhaseID = p;}
 108   //
 109   // monitoring stuff
 110   void                   FlagSplitClusters();
 111   Bool_t                 ContainsSplitCluster(const AliITSUSeed* seed, Int_t maxSize=99999);
 112   void                   CheckClusterUsage();
 113   //
 114  protected:
 115   TObject*&              NextFreeSeed();
 116   //
 117  private:
 118   //
 119   AliITSUTrackerGlo(const AliITSUTrackerGlo&);
 120   AliITSUTrackerGlo &operator=(const AliITSUTrackerGlo &tr);
 121   //
 122  protected:
 123   AliITSUReconstructor*           fReconstructor;  // ITS global reconstructor
 124   AliITSURecoDet*                 fITS;            // interface to ITS, borrowed from reconstructor
 125   AliESDtrack*                    fCurrESDtrack;   // current esd track in processing
 126   Int_t                           fCurrESDtrMClb;  // its eventual mc label
 127   Double_t                        fCurrMass;       // current track mass
 128   Double_t                        fTrImpData[kNTrImpData];  // data on track impact on the layer
 129   //
 130   Int_t                           fCountProlongationTrials;   // number of TPC seeds
 131   Int_t                           fCountITSin;     // number of successful ITSin
 132   Int_t                           fCountITSout;    // number of successful ITSout
 133   Int_t                           fCountITSrefit;  // number of successful ITSrefit
 134   Int_t                           fNTracksESD;     // number of esd tracks
 135   //
 136   // the seeds management to be optimized
 137   TObjArray                       fHypStore;       // storage for tracks hypotheses
 138   Int_t                           fLayerMaxCandidates; //! size of tmp candidates array
 139   AliITSUSeed**                   fLayerCandidates;//! array for branches of current track prolongation
 140   Int_t                           fNBranchesAdded; // number of branches created for current seed in prolongation
 141   Int_t                           fNCandidatesAdded; // number of candidates added for current seed in prolongation
 142   AliITSUTrackHyp*                fCurrHyp;        //! hypotheses container for current track
 143   AliITSUTrackHyp*                fWorkHyp;        //! temporary hypothesis for track finding
 144   TClonesArray                    fSeedsPool;      //! pool for seeds
 145   TArrayI                         fFreeSeedsID;    //! array of ID's of freed seeds
 146   TArrayI                         fESDIndex;       //! array of ID's of freed seeds
 147   Int_t                           fNFreeSeeds;     //! number of seeds freed in the pool
 148   Int_t                           fLastSeedID;     //! id of the pool seed on which is returned by the NextFreeSeed method
 149   Int_t                           fNLrActive;      //! number of active layers
 150   //
 151   TObjArray                       fDefTrackConds;  //! default tracking conditions
 152   AliITSUTrackCond*               fCurrTrackCond;  //! current tracking condition
 153   Int_t                           fCurrActLrID;    //! current active layer ID being processed (set only when needed, not guaranteed)
 154   AliITSURecoLayer*               fCurrLayer;      //! current layer being processed  (set only when needed, not guaranteed)
 155   Int_t                           fTrackPhaseID;   //! tracking phase (clusters2tracks, backward, inward)
 156   Int_t                           fCurrPassID;     //! tracking pass (different tracking conditions)
 157   //
 158   static const Double_t           fgkToler;        // tracking tolerance
 159   //
 160 #ifdef  _ITSU_TUNING_MODE_
 161   // this code is only for special histos needed to extract some control parameters
 162   Int_t GetHistoID(Int_t lr, Int_t hid, Int_t pass=0, Int_t phase=0);
 163   TObjArray* BookControlHistos(const char* pref);
 164   TObjArray* fCHistoArrCorr; // set of histos for each tracking pass/phase: correct
 165   TObjArray* fCHistoArrFake; // set of histos for each tracking pass/phase: fakse
 166   enum {kHResY,kHResYP,kHResZ,kHResZP,kHChi2Cl,kHChi2Nrm,kHBestInBranch,kHBestInCand,kMaxHID=10};
 167   enum {kHChiMatch,kHChiITSSA}; // custom histos
 168   enum {kHistosPhase=kMaxHID*(AliITSUAux::kMaxLayers+1),kHistosPass=kNTrackingPhases*kHistosPhase};
 169   //
 170 #endif
 171   //
 172   ClassDef(AliITSUTrackerGlo,1)   //ITS upgrade tracker
 173
 174 };
 175
 176 //________________________________________
 177 inline TObject *&AliITSUTrackerGlo::NextFreeSeed()
 178 {
 179   // return next free slot where the seed can be created
 180   fLastSeedID = fNFreeSeeds ? fFreeSeedsID.GetArray()[--fNFreeSeeds] : fSeedsPool.GetEntriesFast();
 181   //  AliInfo(Form("%d",fLastSeedID));
 182   return fSeedsPool[ fLastSeedID ];
 183   //
 184 }
 185
 186 //_________________________________________________________________________
 187 inline AliITSUSeed* AliITSUTrackerGlo::NewSeedFromPool(const AliITSUSeed* src)
 188 {
 189   // create new seed, optionally copying from the source
 190   AliITSUSeed* sd =  src ? new( NextFreeSeed() ) AliITSUSeed(*src) : new( NextFreeSeed() ) AliITSUSeed();
 191   sd->SetPoolID(fLastSeedID);
 192   return sd;
 193 }
 194
 195 //_________________________________________________________________________
 196 inline void AliITSUTrackerGlo::KillSeed(AliITSUSeed* seed, Bool_t branch)
 197 {
 198   // flag seed as killed, if requested, kill recursively its parents whose sole child is the seed being killed
 199   seed->Kill();
 200   seed = (AliITSUSeed*)seed->GetParent();
 201   if (seed && !seed->DecChildren() && branch) KillSeed(seed,branch);
 202 }
 203
 204 //_________________________________________________________________________
 205 inline void AliITSUTrackerGlo::AddProlongationHypothesis(AliITSUSeed* seed, Int_t lr)
 206 {
 207   // add new seed prolongation hypothesis
 208 #ifdef  _ITSU_TUNING_MODE_
 209   seed->SetOrdCand(fCurrHyp->GetNSeeds(lr));
 210 #endif
 211   fCurrHyp->AddSeed(seed,lr);
 212 }
 213
 214 #endif
 215