[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSUTrackerGlo.h

#ifndef ALIITSTRACKERU_H
#define ALIITSTRACKERU_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

//-------------------------------------------------------------------------
//                ITS upgrade tracker base class
//-------------------------------------------------------------------------
#include "AliTracker.h"
#include "AliESDEvent.h"
#include "AliITSUSeed.h"
#include "AliITSUTrackCond.h"
#include "AliITSUTrackHyp.h"
#include "AliITSUAux.h"
#include <TArrayI.h>

class AliITSUReconstructor;
class AliITSURecoDet;
class AliITSUClusterPix;
class AliESDtrack;
class AliITSURecoLayer;
class TTree;


//-------------------------------------------------------------------------
class AliITSUTrackerGlo : public AliTracker {

  public:
  enum {kClus2Tracks,kPropBack,kRefitInw,kNTrackingPhases};   // tracking phases
  enum { // info from track extrapolation to layer for cluster check
    kTrXIn ,kTrYIn ,kTrZIn ,kTrPhiIn , // entrance (outer) point on the layer from above 
    kTrXOut,kTrYOut,kTrZOut,kTrPhiOut, // exit (inner) point on the layer
    kTrPhi0, kTrDPhi, kTrZ0, kTrDZ,     // mean phi,dPhi, mean z, dZ (don't change this order)
    kNTrImpData};
  //
  enum {kMissingCluster=0  // no cluster found on this layer
	,kTransportFailed=1  // seed did not reach target layer
	,kRWCheckFailed =2  // failed to rotate the seed to frame of the layer impact point
  };
  enum {kStopSearchOnSensor,kClusterNotMatching,kClusterMatching}; // flags for track-to-cluster checks
  //
  enum {kDummyLabel=-3141593};
  //
  AliITSUTrackerGlo(AliITSUReconstructor* rec);
  virtual ~AliITSUTrackerGlo();

  virtual Int_t          Clusters2Tracks(AliESDEvent *event);
  virtual Int_t          PropagateBack(AliESDEvent *event);
  virtual Int_t          RefitInward(AliESDEvent *event);
  virtual Int_t          LoadClusters(TTree * treeRP=0);
  virtual void           UnloadClusters();
  virtual AliCluster*    GetCluster(Int_t index) const;
  void                   FlagSplitClusters();
  Bool_t                 ContainsSplitCluster(const AliITSUSeed* seed, Int_t maxSize=99999);
  void                   PrintSeedClusters(const AliITSUSeed* seed, Option_t* option="");
  //
  Int_t                  GetCountPronlongationTrials() const {return fCountProlongationTrials;}
  Int_t                  GetCountITSin()               const {return fCountITSin;}
  Int_t                  GetCountITSout()              const {return fCountITSout;}
  Int_t                  GetCountITSrefit()            const {return fCountITSrefit;}

  //------------------------------------
  AliITSURecoDet*        GetITSInterface()       const {return fITS;}
  //
  //------------------------------------
  Bool_t                 NeedToProlong(AliESDtrack* estTr);
  void                   Init(AliITSUReconstructor* rec);
  void                   FindTrack(AliESDtrack* esdTr, Int_t esdID);
  void                   CreateDefaultTrackCond();
  AliITSUTrackHyp*       InitHypothesis(AliESDtrack *esdTr, Int_t esdID);
  Bool_t                 TransportToLayer(AliITSUSeed* seed, Int_t lFrom, Int_t lTo, Double_t rLim=-1);
  Bool_t                 TransportToLayer(AliExternalTrackParam* seed, Int_t lFrom, Int_t lTo, Double_t rLim=-1);
  Bool_t                 TransportToLayerX(AliExternalTrackParam* seed, Int_t lFrom, Int_t lTo, Double_t xStop);  
  Bool_t                 GoToExitFromLayer(AliITSUSeed* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check=kTRUE);
  Bool_t                 GoToExitFromLayer(AliExternalTrackParam* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check=kTRUE);
  Bool_t                 GoToEntranceToLayer(AliITSUSeed* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check=kFALSE);
  Bool_t                 GoToEntranceToLayer(AliExternalTrackParam* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check=kFALSE);
  Bool_t                 PropagateSeed(AliITSUSeed *seed, Double_t xToGo, Double_t mass, Double_t maxStep=1.0, Bool_t matCorr=kTRUE);
  Bool_t                 PropagateSeed(AliExternalTrackParam *seed, Double_t xToGo, Double_t mass, Double_t maxStep=1.0, Bool_t matCorr=kTRUE);
  Double_t               RefitTrack(AliExternalTrackParam* trc, Double_t r, Int_t stopCond=0);
  Int_t                  GetTrackingPhase()                 const {return fTrackPhase;}

  //
  void                   KillSeed(AliITSUSeed* seed, Bool_t branch=kFALSE);
  Bool_t                 NeedToKill(AliITSUSeed* seed, Int_t flag);
  Bool_t                 GetRoadWidth(AliITSUSeed* seed, int ilrA);
  Bool_t                 CheckBackwardMatching(AliITSUSeed* seed);
  Int_t                  CheckCluster(AliITSUSeed* seed, Int_t lr, Int_t clID);
  void                   AddProlongationHypothesis(AliITSUSeed* seed, Int_t lr);
  Bool_t                 AddSeedBranch(AliITSUSeed* seed);
  void                   ValidateAllowedBranches(Int_t accMax);
  void                   ValidateAllowedCandidates(Int_t ilr, Int_t accMax);
  void                   FlagSeedClusters(const AliITSUSeed* seed, Bool_t flg, UShort_t hypRef);
  //
  AliITSUSeed*           NewSeedFromPool(const AliITSUSeed* src=0);
  void                   ResetSeedsPool();
  void                   MarkSeedFree(AliITSUSeed* seed );

  AliITSUTrackHyp*       GetTrackHyp(Int_t id)               const  {return (AliITSUTrackHyp*)fHypStore.UncheckedAt(id);}
  void                   SetTrackHyp(AliITSUTrackHyp* hyp,Int_t id) {fHypStore.AddAtAndExpand(hyp,id);}
  void                   DeleteLastSeedFromPool()                   {fSeedsPool.RemoveLast();}
  void                   CheckClusterSharingConflicts(AliITSUTrackHyp* hyp);
  void                   SaveReducedHypothesesTree(AliITSUTrackHyp* dest);
  void                   FinalizeHypotheses();
  Bool_t                 FinalizeHypothesis(AliITSUTrackHyp* hyp);
  void                   UpdateESDTrack(AliITSUTrackHyp* hyp,Int_t flag);
  void                   CookMCLabel(AliITSUTrackHyp* hyp);
  void                   SetTrackingPhase(Int_t p)        {fTrackPhase = p;}
 //
 protected:
  TObject*&              NextFreeSeed();
  //
 private:
  //
  AliITSUTrackerGlo(const AliITSUTrackerGlo&);
  AliITSUTrackerGlo &operator=(const AliITSUTrackerGlo &tr);
  //
 protected:
  AliITSUReconstructor*           fReconstructor;  // ITS global reconstructor 
  AliITSURecoDet*                 fITS;            // interface to ITS, borrowed from reconstructor
  AliESDtrack*                    fCurrESDtrack;   // current esd track in processing
  Int_t                           fCurrESDtrMClb;  // its eventual mc label
  Double_t                        fCurrMass;       // current track mass
  Double_t                        fTrImpData[kNTrImpData];  // data on track impact on the layer
  //
  Int_t                           fCountProlongationTrials;   // number of TPC seeds
  Int_t                           fCountITSin;     // number of successful ITSin 
  Int_t                           fCountITSout;    // number of successful ITSout
  Int_t                           fCountITSrefit;  // number of successful ITSrefit 
  //
  // the seeds management to be optimized
  TObjArray                       fHypStore;       // storage for tracks hypotheses
  Int_t                           fLayerMaxCandidates; //! size of tmp candidates array 
  AliITSUSeed**                   fLayerCandidates;//! array for branches of current track prolongation
  Int_t                           fNBranchesAdded; // number of branches created for current seed in prolongation
  Int_t                           fNCandidatesAdded; // number of candidates added for current seed in prolongation
  AliITSUTrackHyp*                fCurrHyp;        //! hypotheses container for current track
  AliITSUTrackHyp*                fWorkHyp;        //! temporary hypothesis for track finding
  TClonesArray                    fSeedsPool;      //! pool for seeds
  TArrayI                         fFreeSeedsID;    //! array of ID's of freed seeds
  TArrayI                         fESDIndex;       //! array of ID's of freed seeds
  Int_t                           fNFreeSeeds;     //! number of seeds freed in the pool
  Int_t                           fLastSeedID;     //! id of the pool seed on which is returned by the NextFreeSeed method
  Int_t                           fNLrActive;      //! number of active layers
  //
  TObjArray                       fDefTrackConds;  //! default tracking conditions
  AliITSUTrackCond*               fCurrTrackCond;  //! current tracking condition
  Int_t                           fCurrActLrID;    //! current active layer ID being processed (set only when needed, not guaranteed)
  AliITSURecoLayer*               fCurrLayer;      //! current layer being processed  (set only when needed, not guaranteed)
  Int_t                           fTrackPhase;     //! tracking phase
  //
  static const Double_t           fgkToler;        // tracking tolerance
  //
#ifdef  _ITSU_TUNING_MODE_
  // this code is only for special histos needed to extract some control parameters
  void BookControlHistos(const char* pref);
  TObjArray* fCHistoArrCorr;
  TObjArray* fCHistoArrFake;
  enum {kHResY=0,kHResYP=10,kHResZ=20,kHResZP=30,kHChi2Cl=40,kHChi2Nrm=50,kHBestInBranch=60,kHBestInCand=70};
  enum {kHChiMatch,kHChiITSSA}; // custom histos 
  enum {kHistosPhase=100};
  //
#endif
  //
  ClassDef(AliITSUTrackerGlo,1)   //ITS upgrade tracker
    
};

//________________________________________
inline TObject *&AliITSUTrackerGlo::NextFreeSeed()
{
  // return next free slot where the seed can be created
  fLastSeedID = fNFreeSeeds ? fFreeSeedsID.GetArray()[--fNFreeSeeds] : fSeedsPool.GetEntriesFast();
  //  AliInfo(Form("%d",fLastSeedID));
  return fSeedsPool[ fLastSeedID ];
  //
}

//_________________________________________________________________________
inline AliITSUSeed* AliITSUTrackerGlo::NewSeedFromPool(const AliITSUSeed* src)
{
  // create new seed, optionally copying from the source
  AliITSUSeed* sd =  src ? new( NextFreeSeed() ) AliITSUSeed(*src) : new( NextFreeSeed() ) AliITSUSeed();
  sd->SetPoolID(fLastSeedID);
  return sd;
}

//_________________________________________________________________________
inline void AliITSUTrackerGlo::KillSeed(AliITSUSeed* seed, Bool_t branch)
{
  // flag seed as killed, if requested, kill recursively its parents whose sole child is the seed being killed
  seed->Kill();
  seed = (AliITSUSeed*)seed->GetParent();
  if (seed && !seed->DecChildren() && branch) KillSeed(seed,branch);
}

//_________________________________________________________________________
inline void AliITSUTrackerGlo::AddProlongationHypothesis(AliITSUSeed* seed, Int_t lr)
{
  // add new seed prolongation hypothesis 
#ifdef  _ITSU_TUNING_MODE_
  seed->SetOrdCand(fCurrHyp->GetNSeeds(lr));
#endif
  fCurrHyp->AddSeed(seed,lr);  
}

#endif
Commit	Line	Data
32d38de2	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	//-------------------------------------------------------------------------
32d38de2	9	#include "AliTracker.h"
32d38de2	10	#include "AliESDEvent.h"
f8832015	11	#include "AliITSUSeed.h"
c8d1f258	12	#include "AliITSUTrackCond.h"
716ccba7	13	#include "AliITSUTrackHyp.h"
08419930	14	#include "AliITSUAux.h"
9cdcba2c	15	#include <TArrayI.h>
32d38de2	16
	17	class AliITSUReconstructor;
	18	class AliITSURecoDet;
c61e50c3	19	class AliITSUClusterPix;
0091e9f0	20	class AliESDtrack;
e2d2481c	21	class AliITSURecoLayer;
32d38de2	22	class TTree;
32d38de2	23
c61e50c3	24
32d38de2	25	//-------------------------------------------------------------------------
	26	class AliITSUTrackerGlo : public AliTracker {
	27
	28	public:
76390254	29	enum {kClus2Tracks,kPropBack,kRefitInw,kNTrackingPhases}; // tracking phases
32d38de2	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)
c61e50c3	34	kNTrImpData};
32d38de2	35	//
f8832015	36	enum {kMissingCluster=0 // no cluster found on this layer
f8832015	37	,kTransportFailed=1 // seed did not reach target layer
32d38de2	38	,kRWCheckFailed =2 // failed to rotate the seed to frame of the layer impact point
32d38de2	39	};
f8832015	40	enum {kStopSearchOnSensor,kClusterNotMatching,kClusterMatching}; // flags for track-to-cluster checks
dd2117a2	41	//
dd2117a2	42	enum {kDummyLabel=-3141593};
38997c3c	43	//
32d38de2	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;
53870004	53	void FlagSplitClusters();
	54	Bool_t ContainsSplitCluster(const AliITSUSeed* seed, Int_t maxSize=99999);
	55	void PrintSeedClusters(const AliITSUSeed* seed, Option_t* option="");
0ddbf657	56	//
	57	Int_t GetCountPronlongationTrials() const {return fCountProlongationTrials;}
	58	Int_t GetCountITSin() const {return fCountITSin;}
	59	Int_t GetCountITSout() const {return fCountITSout;}
	60	Int_t GetCountITSrefit() const {return fCountITSrefit;}
	61
0091e9f0	62	//------------------------------------
	63	AliITSURecoDet* GetITSInterface() const {return fITS;}
	64	//
32d38de2	65	//------------------------------------
	66	Bool_t NeedToProlong(AliESDtrack* estTr);
	67	void Init(AliITSUReconstructor* rec);
716ccba7	68	void FindTrack(AliESDtrack* esdTr, Int_t esdID);
42c3d4bd	69	void CreateDefaultTrackCond();
6cd80116	70	AliITSUTrackHyp* InitHypothesis(AliESDtrack *esdTr, Int_t esdID);
70cb7fe4	71	Bool_t TransportToLayer(AliITSUSeed* seed, Int_t lFrom, Int_t lTo, Double_t rLim=-1);
70cb7fe4	72	Bool_t TransportToLayer(AliExternalTrackParam* seed, Int_t lFrom, Int_t lTo, Double_t rLim=-1);
b515ad7e	73	Bool_t TransportToLayerX(AliExternalTrackParam* seed, Int_t lFrom, Int_t lTo, Double_t xStop);
e7d83d38	74	Bool_t GoToExitFromLayer(AliITSUSeed* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check=kTRUE);
e7d83d38	75	Bool_t GoToExitFromLayer(AliExternalTrackParam* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check=kTRUE);
e2d2481c	76	Bool_t GoToEntranceToLayer(AliITSUSeed* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check=kFALSE);
e2d2481c	77	Bool_t GoToEntranceToLayer(AliExternalTrackParam* seed, AliITSURecoLayer* lr, Int_t dir, Bool_t check=kFALSE);
44785f3e	78	Bool_t PropagateSeed(AliITSUSeed *seed, Double_t xToGo, Double_t mass, Double_t maxStep=1.0, Bool_t matCorr=kTRUE);
3e4e3c23	79	Bool_t PropagateSeed(AliExternalTrackParam *seed, Double_t xToGo, Double_t mass, Double_t maxStep=1.0, Bool_t matCorr=kTRUE);
9cdcba2c	80	Double_t RefitTrack(AliExternalTrackParam* trc, Double_t r, Int_t stopCond=0);
e7d83d38	81	Int_t GetTrackingPhase() const {return fTrackPhase;}
e7d83d38	82
44785f3e	83	//
b8b59e05	84	void KillSeed(AliITSUSeed* seed, Bool_t branch=kFALSE);
c8d1f258	85	Bool_t NeedToKill(AliITSUSeed* seed, Int_t flag);
c61e50c3	86	Bool_t GetRoadWidth(AliITSUSeed* seed, int ilrA);
9cdcba2c	87	Bool_t CheckBackwardMatching(AliITSUSeed* seed);
f8832015	88	Int_t CheckCluster(AliITSUSeed* seed, Int_t lr, Int_t clID);
f8832015	89	void AddProlongationHypothesis(AliITSUSeed* seed, Int_t lr);
38997c3c	90	Bool_t AddSeedBranch(AliITSUSeed* seed);
	91	void ValidateAllowedBranches(Int_t accMax);
	92	void ValidateAllowedCandidates(Int_t ilr, Int_t accMax);
08419930	93	void FlagSeedClusters(const AliITSUSeed* seed, Bool_t flg, UShort_t hypRef);
c61e50c3	94	//
c61e50c3	95	AliITSUSeed* NewSeedFromPool(const AliITSUSeed* src=0);
b8b59e05	96	void ResetSeedsPool();
	97	void MarkSeedFree(AliITSUSeed* seed );
	98
716ccba7	99	AliITSUTrackHyp* GetTrackHyp(Int_t id) const {return (AliITSUTrackHyp*)fHypStore.UncheckedAt(id);}
	100	void SetTrackHyp(AliITSUTrackHyp* hyp,Int_t id) {fHypStore.AddAtAndExpand(hyp,id);}
	101	void DeleteLastSeedFromPool() {fSeedsPool.RemoveLast();}
08419930	102	void CheckClusterSharingConflicts(AliITSUTrackHyp* hyp);
6cd80116	103	void SaveReducedHypothesesTree(AliITSUTrackHyp* dest);
3e4e3c23	104	void FinalizeHypotheses();
9cdcba2c	105	Bool_t FinalizeHypothesis(AliITSUTrackHyp* hyp);
68a0f687	106	void UpdateESDTrack(AliITSUTrackHyp* hyp,Int_t flag);
dd2117a2	107	void CookMCLabel(AliITSUTrackHyp* hyp);
e7d83d38	108	void SetTrackingPhase(Int_t p) {fTrackPhase = p;}
716ccba7	109	//
b8b59e05	110	protected:
	111	TObject*& NextFreeSeed();
	112	//
32d38de2	113	private:
b8b59e05	114	//
32d38de2	115	AliITSUTrackerGlo(const AliITSUTrackerGlo&);
	116	AliITSUTrackerGlo &operator=(const AliITSUTrackerGlo &tr);
	117	//
	118	protected:
	119	AliITSUReconstructor* fReconstructor; // ITS global reconstructor
3d4dc3e2	120	AliITSURecoDet* fITS; // interface to ITS, borrowed from reconstructor
0091e9f0	121	AliESDtrack* fCurrESDtrack; // current esd track in processing
0ddbf657	122	Int_t fCurrESDtrMClb; // its eventual mc label
32d38de2	123	Double_t fCurrMass; // current track mass
c61e50c3	124	Double_t fTrImpData[kNTrImpData]; // data on track impact on the layer
32d38de2	125	//
0ddbf657	126	Int_t fCountProlongationTrials; // number of TPC seeds
	127	Int_t fCountITSin; // number of successful ITSin
	128	Int_t fCountITSout; // number of successful ITSout
	129	Int_t fCountITSrefit; // number of successful ITSrefit
	130	//
c61e50c3	131	// the seeds management to be optimized
716ccba7	132	TObjArray fHypStore; // storage for tracks hypotheses
6cd80116	133	Int_t fLayerMaxCandidates; //! size of tmp candidates array
6cd80116	134	AliITSUSeed** fLayerCandidates;//! array for branches of current track prolongation
38997c3c	135	Int_t fNBranchesAdded; // number of branches created for current seed in prolongation
38997c3c	136	Int_t fNCandidatesAdded; // number of candidates added for current seed in prolongation
6cd80116	137	AliITSUTrackHyp* fCurrHyp; //! hypotheses container for current track
6cd80116	138	AliITSUTrackHyp* fWorkHyp; //! temporary hypothesis for track finding
b8b59e05	139	TClonesArray fSeedsPool; //! pool for seeds
b8b59e05	140	TArrayI fFreeSeedsID; //! array of ID's of freed seeds
9cdcba2c	141	TArrayI fESDIndex; //! array of ID's of freed seeds
b8b59e05	142	Int_t fNFreeSeeds; //! number of seeds freed in the pool
b8b59e05	143	Int_t fLastSeedID; //! id of the pool seed on which is returned by the NextFreeSeed method
6cd80116	144	Int_t fNLrActive; //! number of active layers
c8d1f258	145	//
42c3d4bd	146	TObjArray fDefTrackConds; //! default tracking conditions
c03e4f8a	147	AliITSUTrackCond* fCurrTrackCond; //! current tracking condition
	148	Int_t fCurrActLrID; //! current active layer ID being processed (set only when needed, not guaranteed)
	149	AliITSURecoLayer* fCurrLayer; //! current layer being processed (set only when needed, not guaranteed)
	150	Int_t fTrackPhase; //! tracking phase
c8d1f258	151	//
e2d2481c	152	static const Double_t fgkToler; // tracking tolerance
e2d2481c	153	//
08419930	154	#ifdef _ITSU_TUNING_MODE_
53870004	155	// this code is only for special histos needed to extract some control parameters
08419930	156	void BookControlHistos(const char* pref);
	157	TObjArray* fCHistoArrCorr;
	158	TObjArray* fCHistoArrFake;
c03e4f8a	159	enum {kHResY=0,kHResYP=10,kHResZ=20,kHResZP=30,kHChi2Cl=40,kHChi2Nrm=50,kHBestInBranch=60,kHBestInCand=70};
08419930	160	enum {kHChiMatch,kHChiITSSA}; // custom histos
53870004	161	enum {kHistosPhase=100};
	162	//
	163	#endif
bdb92766	164	//
32d38de2	165	ClassDef(AliITSUTrackerGlo,1) //ITS upgrade tracker
	166
	167	};
f8832015	168
b8b59e05	169	//________________________________________
	170	inline TObject *&AliITSUTrackerGlo::NextFreeSeed()
	171	{
	172	// return next free slot where the seed can be created
	173	fLastSeedID = fNFreeSeeds ? fFreeSeedsID.GetArray()[--fNFreeSeeds] : fSeedsPool.GetEntriesFast();
	174	// AliInfo(Form("%d",fLastSeedID));
	175	return fSeedsPool[ fLastSeedID ];
	176	//
	177	}
	178
	179	//_________________________________________________________________________
	180	inline AliITSUSeed* AliITSUTrackerGlo::NewSeedFromPool(const AliITSUSeed* src)
	181	{
	182	// create new seed, optionally copying from the source
	183	AliITSUSeed* sd = src ? new( NextFreeSeed() ) AliITSUSeed(*src) : new( NextFreeSeed() ) AliITSUSeed();
	184	sd->SetPoolID(fLastSeedID);
	185	return sd;
	186	}
	187
	188	//_________________________________________________________________________
	189	inline void AliITSUTrackerGlo::KillSeed(AliITSUSeed* seed, Bool_t branch)
	190	{
	191	// flag seed as killed, if requested, kill recursively its parents whose sole child is the seed being killed
	192	seed->Kill();
	193	seed = (AliITSUSeed*)seed->GetParent();
	194	if (seed && !seed->DecChildren() && branch) KillSeed(seed,branch);
	195	}
f8832015	196
38997c3c	197	//_________________________________________________________________________
	198	inline void AliITSUTrackerGlo::AddProlongationHypothesis(AliITSUSeed* seed, Int_t lr)
	199	{
	200	// add new seed prolongation hypothesis
08419930	201	#ifdef _ITSU_TUNING_MODE_
	202	seed->SetOrdCand(fCurrHyp->GetNSeeds(lr));
	203	#endif
	204	fCurrHyp->AddSeed(seed,lr);
38997c3c	205	}
38997c3c	206
32d38de2	207	#endif
32d38de2	208