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