Updates for tracker
authorshahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 19 Nov 2012 16:02:15 +0000 (16:02 +0000)
committershahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 19 Nov 2012 16:02:15 +0000 (16:02 +0000)
ITS/UPGRADE/AliITSUAux.h
ITS/UPGRADE/AliITSURecoParam.cxx
ITS/UPGRADE/AliITSURecoParam.h
ITS/UPGRADE/AliITSUSeed.cxx
ITS/UPGRADE/AliITSUSeed.h
ITS/UPGRADE/AliITSUTrackerGlo.cxx
ITS/UPGRADE/AliITSUTrackerGlo.h

index 13db19a..88c5f0f 100644 (file)
@@ -22,13 +22,16 @@ namespace AliITSUAux {
   Bool_t OKforPhiMin(double phiMin,double phi);
   Bool_t OKforPhiMax(double phiMax,double phi);
   UInt_t PackCluster(Int_t lr, Int_t clID);
-  Int_t  UnPackCluster(UInt_t p, Int_t &lr);
+  Int_t  UnpackCluster(UInt_t p, Int_t &lr);
+  Int_t  UnpackLayer(UInt_t p);
+  Int_t  UnpackCluster(UInt_t p);
   Bool_t IsCluster(UInt_t p);
+  Int_t  NumberOfBitsSet(UInt_t x);
   //
   const Double_t kNominalBz = 5.01;           // nominal field
   const Double_t kPionMass  = 1.3957e-01;
-  const UInt_t   kLrBitMax  = 5;                            // layer mask highest bit
-  const UInt_t   kMaxLayers = UInt_t(Power(2.,int(kLrBitMax)-1));  // max number of active layers
+  const UInt_t   kLrBitMax  = 4;              // layer mask highest bit
+  const UInt_t   kMaxLayers = 15;             // max number of active layers
 }
 
 //_________________________________________________________________________________
@@ -60,18 +63,38 @@ inline UInt_t AliITSUAux::PackCluster(Int_t lr, Int_t clID) {
 }
 
 //_________________________________________________________________________________
-inline Int_t AliITSUAux::UnPackCluster(UInt_t p, Int_t &lr) {
+inline Int_t AliITSUAux::UnpackCluster(UInt_t p, Int_t &lr) {
   // unpack layer/cluster
   lr = p&kMaxLayers;
   p>>=kLrBitMax;
   return int(p)-1;
 }
 
+//_________________________________________________________________________________
+inline Int_t AliITSUAux::UnpackLayer(UInt_t p) {
+  // unpack layer
+  return p&kMaxLayers;
+}
+
+//_________________________________________________________________________________
+inline Int_t AliITSUAux::UnpackCluster(UInt_t p) {
+  // unpack cluster
+  return int(p>>kLrBitMax)-1;
+}
+
 //_________________________________________________________________________________
 inline Bool_t AliITSUAux::IsCluster(UInt_t p) {
   // does it correspond to cluster?
   return p>kMaxLayers;
 }
 
+//_________________________________________________________________________________
+inline Int_t AliITSUAux::NumberOfBitsSet(UInt_t x) {
+  // count number of non-0 bits in 32bit word
+  x = x - ((x >> 1) & 0x55555555);
+  x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
+  return (((x + (x >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
+}
+
 
 #endif
index 12e9bf9..c1adfeb 100644 (file)
@@ -34,6 +34,7 @@ const Double_t AliITSURecoParam::fgkNSigmaRoadY                   = 5.;
 const Double_t AliITSURecoParam::fgkNSigmaRoadZ                   = 5.; 
 const Double_t AliITSURecoParam::fgkSigmaRoadY                    = 1000e-4;
 const Double_t AliITSURecoParam::fgkSigmaRoadZ                    = 1000e-4;
+const Double_t AliITSURecoParam::fgkMaxTr2ClChi2                  = 15.;;
 const Double_t AliITSURecoParam::fgkTanLorentzAngle               = 0;
 //
 
@@ -50,6 +51,7 @@ AliITSURecoParam::AliITSURecoParam()
   ,fTanLorentzAngle(0)
   ,fSigmaY2(0)
   ,fSigmaZ2(0)
+  ,fMaxTr2ClChi2(0)
 {
   // def c-tor
   SetName("ITS");
@@ -69,6 +71,7 @@ AliITSURecoParam::AliITSURecoParam(Int_t nLr)
   ,fTanLorentzAngle(0)
   ,fSigmaY2(0)
   ,fSigmaZ2(0)
+  ,fMaxTr2ClChi2(0)
 {
   // def c-tor
   SetName("ITS");
@@ -83,6 +86,7 @@ AliITSURecoParam::~AliITSURecoParam()
   delete[] fTanLorentzAngle;
   delete[] fSigmaY2;
   delete[] fSigmaZ2;
+  delete[] fMaxTr2ClChi2;
 }
 
 //_____________________________________________________________________________
@@ -123,11 +127,13 @@ void  AliITSURecoParam::SetNLayers(Int_t n)
   fTanLorentzAngle = new Double_t[n];
   fSigmaY2 = new Double_t[n];
   fSigmaZ2 = new Double_t[n];
+  fMaxTr2ClChi2 = new Double_t[n];
   //
   for (int i=n;i--;) {
     fTanLorentzAngle[i] = fgkTanLorentzAngle;
     fSigmaY2[i] = fgkSigmaRoadY*fgkSigmaRoadY;
     fSigmaZ2[i] = fgkSigmaRoadZ*fgkSigmaRoadZ;
+    fMaxTr2ClChi2[i] = fgkMaxTr2ClChi2;
   }
   //
 }
@@ -155,3 +161,11 @@ void  AliITSURecoParam::SetSigmaZ2(Int_t lr, Double_t v)
   if (lr>=fNLayers) AliFatal(Form("Number of defined layers is %d",fNLayers));
   fSigmaZ2[lr] = v;
 }
+
+//_____________________________________________________________________________
+void  AliITSURecoParam::SetMaxTr2ClChi2(Int_t lr, Double_t v)
+{
+  // set Lorentz angle value
+  if (lr>=fNLayers) AliFatal(Form("Number of defined layers is %d",fNLayers));
+  fMaxTr2ClChi2[lr] = v;
+}
index 8f4fea2..24002d1 100644 (file)
@@ -32,6 +32,8 @@ class AliITSURecoParam : public AliDetectorRecoParam
   Double_t    GetTanLorentzAngle(Int_t lr)       const;
   Double_t    GetSigmaY2(Int_t lr)               const;
   Double_t    GetSigmaZ2(Int_t lr)               const;
+  Double_t    GetMaxTr2ClChi2(Int_t lr)          const;
+
   Double_t    GetNSigmaRoadY()                   const {return fNSigmaRoadY;}
   Double_t    GetNSigmaRoadZ()                   const {return fNSigmaRoadZ;}
   //
@@ -39,7 +41,8 @@ class AliITSURecoParam : public AliDetectorRecoParam
   void        SetTanLorentzAngle(Int_t lr, Double_t v);
   void        SetSigmaY2(Int_t lr, Double_t v);
   void        SetSigmaZ2(Int_t lr, Double_t v);
-
+  void        SetMaxTr2ClChi2(Int_t lr, Double_t v);
+  //
   void        GetMaxDforV0dghtrForProlongation(Double_t v)            {fMaxDforV0dghtrForProlongation = v;}
   void        SetMaxDForProlongation(Double_t v)                      {fMaxDForProlongation = v;}
   void        SetMaxDZForProlongation(Double_t v)                     {fMaxDZForProlongation = v;}
@@ -61,6 +64,8 @@ class AliITSURecoParam : public AliDetectorRecoParam
   Double_t*      fTanLorentzAngle;  //[fNLayers] Optional Lorentz angle for each layer
   Double_t*      fSigmaY2;          //[fNLayers] addition to road width^2
   Double_t*      fSigmaZ2;          //[fNLayers] addition to road width^2
+  Double_t*      fMaxTr2ClChi2;     //[fNLayers] max track-to-cluster chi2
+
   //
   static const Double_t fgkMaxDforV0dghtrForProlongation;      // default
   static const Double_t fgkMaxDForProlongation;                // default
@@ -71,6 +76,7 @@ class AliITSURecoParam : public AliDetectorRecoParam
   // for arrays
   static const Double_t fgkSigmaRoadY;                         // default
   static const Double_t fgkSigmaRoadZ;                         // default
+  static const Double_t fgkMaxTr2ClChi2;                       // default
   static const Double_t fgkTanLorentzAngle;                    // default
   //
  private:
@@ -91,14 +97,21 @@ inline Double_t AliITSURecoParam::GetTanLorentzAngle(Int_t lr) const
 inline Double_t AliITSURecoParam::GetSigmaY2(Int_t lr) const 
 {
   // get tg of Lorentz Angle for the layer
-  return lr<fNLayers ? fSigmaY2[lr]:0;
+  return lr<fNLayers ? fSigmaY2[lr]:fgkSigmaRoadY*fgkSigmaRoadY; //0;
 }
 
 //_____________________________________________________________________________
 inline Double_t AliITSURecoParam::GetSigmaZ2(Int_t lr) const 
 {
   // get tg of Lorentz Angle for the layer
-  return lr<fNLayers ? fSigmaZ2[lr]:0;
+  return lr<fNLayers ? fSigmaZ2[lr]:fgkSigmaRoadZ*fgkSigmaRoadZ;//0;
+}
+
+//_____________________________________________________________________________
+inline Double_t AliITSURecoParam::GetMaxTr2ClChi2(Int_t lr) const
+{
+  // get tg of Lorentz Angle for the layer
+  return lr<fNLayers ? fMaxTr2ClChi2[lr]:fgkMaxTr2ClChi2; //0;
 }
 
 #endif
index 0721425..39c57d7 100644 (file)
@@ -1,14 +1,16 @@
+#include <TString.h>
 #include <TMath.h>
 #include "AliITSUSeed.h"
-#include "AliITSUAux.h"
-using namespace AliITSUAux;
 using namespace TMath;
 
 ClassImp(AliITSUSeed)
 
 //_________________________________________________________________________
 AliITSUSeed::AliITSUSeed() 
-:  fClID(0)
+: fHitsPattern(0)
+  ,fClID(0)
+  ,fChi2Glo(0)
+  ,fChi2Cl(0)
   ,fParent(0)
 {
   // def c-tor
@@ -23,7 +25,10 @@ AliITSUSeed::~AliITSUSeed()
 //_________________________________________________________________________
 AliITSUSeed::AliITSUSeed(const AliITSUSeed& src) 
   :AliExternalTrackParam(src)
+  ,fHitsPattern(src.fHitsPattern)
   ,fClID(src.fClID)
+  ,fChi2Glo(src.fChi2Glo)
+  ,fChi2Cl(src.fChi2Cl)
   ,fParent(src.fParent) 
 {
   // def c-tor
@@ -34,8 +39,25 @@ AliITSUSeed &AliITSUSeed::operator=(const AliITSUSeed& src)
 {
   // def c-tor
   if (this == &src) return *this;
-  fClID = src.fClID;
-  fParent = src.fParent;
+  fClID        = src.fClID;
+  fHitsPattern = src.fHitsPattern;
+  fChi2Glo     = src.fChi2Glo;
+  fChi2Cl      = src.fChi2Cl;
+  fParent      = src.fParent;
   AliExternalTrackParam::operator=(src);
   return *this;
 }
+
+//_________________________________________________________________________
+void AliITSUSeed::Print(Option_t* opt) const
+{
+  // print seed info
+  int lr,cl = GetLrCluster(lr);
+  printf("Lr%d Cl:%4d Chi2Glo:%6.3f Chi2Cl:",lr,cl,GetChi2Glo());
+  cl<0 ? printf("  NA  ") : printf("%6.3f",GetChi2Cl());
+  printf(" |"); 
+  for (int i=0;i<=lr;i++) printf("%c",HasClusterOnLayer(i) ? '+':'-');
+  TString opts = opt; opts.ToLower();
+  if (opts.Contains("etp")) AliExternalTrackParam::Print();
+  if (opts.Contains("parent") && GetParent()) GetParent()->Print(opt);
+}
index ea41403..54711c8 100644 (file)
@@ -2,6 +2,8 @@
 #define ALIITSUSEED_H
 
 #include "AliExternalTrackParam.h"
+#include "AliITSUAux.h"
+using namespace AliITSUAux;
 
 
 class AliITSUSeed: public AliExternalTrackParam
@@ -11,19 +13,42 @@ class AliITSUSeed: public AliExternalTrackParam
   AliITSUSeed(const AliITSUSeed& src);
   AliITSUSeed &operator=(const AliITSUSeed &src);
   virtual ~AliITSUSeed();
+  virtual void    Print(Option_t* option = "") const;
   //
-  void            SetClusterID(UInt_t id)  {fClID = id;}
-  void            SetParent(TObject* par)  {fParent = par;}
+  void            SetLrClusterID(Int_t lr, Int_t cl);
+  void            SetLr(Int_t lr)                        {SetLrClusterID(lr,-1);} // lr w/o cluster
+  void            SetLrClusterID(UInt_t id)              {fClID = id;}
+  void            SetParent(TObject* par)                {fParent = par;}
+  void            SetChi2Cl(Double_t v)                  {fChi2Glo += fChi2Cl= v;}
   //
-  UInt_t          GetClusterID()     const {return fClID;}
-  TObject*        GetParent()        const {return fParent;}
+  UInt_t          GetLrClusterID()                 const {return fClID;}
+  Int_t           GetLrCluster(Int_t &lr)          const {return UnpackCluster(fClID,lr);}
+  Int_t           GetLayerID()                     const {return UnpackLayer(fClID);}
+  Int_t           GetClusterID()                   const {return UnpackCluster(fClID);}
+  Bool_t          HasClusterOnLayer(Int_t lr)      const {return fHitsPattern&(0x1<<lr);}
+  Int_t           GetNLayersHit()                  const {return NumberOfBitsSet(fHitsPattern);}
+  Float_t         GetChi2Cl()                      const {return fChi2Cl;}
+  Float_t         GetChi2Glo()                     const {return fChi2Glo;}
+  //
+  TObject*        GetParent()                      const {return fParent;}
   //
  protected:
+  UShort_t              fHitsPattern;       // bit pattern of hits
   UInt_t                fClID;              // packed cluster info (see AliITSUAux::PackCluster)
+  Float_t               fChi2Glo;           // current chi2 global
+  Float_t               fChi2Cl;            // track-cluster chi2
   TObject*              fParent;            // parent track (in higher tree hierarchy)
   
   ClassDef(AliITSUSeed,1)
 };
 
+//_________________________________________________________________________
+inline void AliITSUSeed::SetLrClusterID(Int_t lr, Int_t cl)
+{
+  // assign layer, cluster (if -1 - no hit on this layer)
+  fClID = PackCluster(lr,cl);
+  if (cl>=0) fHitsPattern &= 0x1<<lr;
+}
+
 
 #endif
index 65a3e4d..31af7a7 100644 (file)
@@ -174,13 +174,13 @@ void AliITSUTrackerGlo::FindTrack(AliESDtrack* esdTr)
 {
   // find prolongaion candidates finding for single seed
   //
-  const double kTolerX = 5e-4;
-  //
   if (!NeedToProlong(esdTr)) return;  // are we interested in this track?
   if (!InitSeed(esdTr))      return;  // initialize prolongations hypotheses tree
   //
   AliITSURecoSens *hitSens[AliITSURecoSens::kNNeighbors];
-  AliITSUSeed seed0;
+  AliITSUSeed seedUC;  // copy of the seed from the upper layer
+  AliITSUSeed seedT;   // transient seed between the seedUC and new prolongation hypothesis
+  //
   TObjArray clArr; // container for transfer of clusters matching to seed
   //
   for (int ila=fITS->GetNLayersActive();ila--;) {
@@ -188,37 +188,39 @@ void AliITSUTrackerGlo::FindTrack(AliESDtrack* esdTr)
     int nSeedsUp = GetNSeeds(ilaUp);
     for (int isd=0;isd<nSeedsUp;isd++) {
       AliITSUSeed* seedU = GetSeed(ilaUp,isd);  // seed on prev.active layer to prolong
-      seed0 = *seedU;
+      seedUC = *seedU;
+      seedUC.SetParent(seedU);
       // go till next active layer
-      if (!TransportToLayer(&seed0, fITS->GetLrIDActive(ilaUp), fITS->GetLrIDActive(ila)) ) {
+      if (!TransportToLayer(&seedUC, fITS->GetLrIDActive(ilaUp), fITS->GetLrIDActive(ila)) ) {
        //
        // Check if the seed satisfies to track definition
-       if (NeedToKill(&seed0,kTransportFailed)) KillSeed(ilaUp,isd); 
+       if (NeedToKill(&seedUC,kTransportFailed)) KillSeed(ilaUp,isd); 
        continue; // RS TODO: decide what to do with tracks stopped on higher layers w/o killing
       }
       AliITSURecoLayer* lrA = fITS->GetLayerActive(ila);
-      if (!GetRoadWidth(&seed0, ila)) { // failed to find road width on the layer
-       if (NeedToKill(&seed0,kRWCheckFailed)) KillSeed(ilaUp,isd); 
+      if (!GetRoadWidth(&seedUC, ila)) { // failed to find road width on the layer
+       if (NeedToKill(&seedUC,kRWCheckFailed)) KillSeed(ilaUp,isd); 
        continue;
       }
       int nsens = lrA->FindSensors(&fTrImpData[kTrPhi0], hitSens);  // find detectors which may be hit by the track (max 4)
       //
       for (int isn=nsens;isn--;) {
+       seedT = seedUC;
        AliITSURecoSens* sens = hitSens[isn];
-       AliITSUSeed* seedT = NewSeedFromPool(&seed0);
-       seedT->SetParent(seedU);
-       if (!seedT->Propagate(sens->GetPhiTF(),sens->GetXTF(),GetBz())) {DeleteLastSeedFromPool(); continue;}
-       int clID    = sens->GetFirstClusterId();
+       //
+       if (!seedT.Propagate(sens->GetPhiTF(),sens->GetXTF(),GetBz())) continue; // propagation failed, seedT is intact
+       int clID0 = sens->GetFirstClusterId();
        for (int icl=sens->GetNClusters();icl--;) {
-         AliITSUClusterPix* cl = (AliITSUClusterPix*)lrA->GetCluster(clID); // cluster data is in the tracking frame
-         if (TMath::Abs(cl->GetX())>kTolerX) { // if due to the misalingment X is large, propagate track only
-           if (!seedT->PropagateParamOnlyTo(seedT->GetX()+cl->GetX(),GetBz())) {DeleteLastSeedFromPool(); continue;}
-         }
-         
-
+         int res = CheckCluster(&seedT,ila,clID0+icl);
+         //
+         if (res==kStopSearchOnSensor) break;     // stop looking on this sensor
+         if (res==kClusterNotMatching) continue;  // cluster does not match
+         // cluster is matching and it was added to the hypotheses tree
        }
       }
-      
+      // cluster search is done. Do we need ta have a version of this seed skipping current layer
+      seedT.SetLr(ila);
+      if (!NeedToKill(&seedT,kMissingCluster)) AddProlongationHypothesis(NewSeedFromPool(&seedT) ,ila);      
     }
   }
   //
@@ -235,7 +237,7 @@ Bool_t AliITSUTrackerGlo::InitSeed(AliESDtrack *esdTr)
   AliITSUSeed* seed = NewSeedFromPool();
   seed->AliExternalTrackParam::operator=(*esdTr);
   seed->SetParent(esdTr);
-  fSeedsLr[fITS->GetNLayersActive()].AddLast(seed);
+  AddProlongationHypothesis(seed,fITS->GetNLayersActive());
   return kTRUE;
   // TO DO
 }
@@ -336,3 +338,50 @@ AliITSUSeed* AliITSUTrackerGlo::NewSeedFromPool(const AliITSUSeed* src)
     new(fSeedsPool[fSeedsPool.GetEntriesFast()]) AliITSUSeed(*src) :
     new(fSeedsPool[fSeedsPool.GetEntriesFast()]) AliITSUSeed();
 }
+
+//_________________________________________________________________________
+Int_t AliITSUTrackerGlo::CheckCluster(AliITSUSeed* track, Int_t lr, Int_t clID) 
+{
+  // Check if the cluster (in tracking frame!) is matching to track. 
+  // The track must be already propagated to sensor tracking frame.
+  // Returns:  kStopSearchOnSensor if the search on given sensor should be stopped, 
+  //           kClusterMatching    if the cluster is matching
+  //           kClusterMatching    otherwise
+  //
+  // The seed is already propagated to cluster
+  const double kTolerX = 5e-4;
+  AliCluster *cl = fITS->GetLayerActive(lr)->GetCluster(clID);
+  //
+  if (TMath::Abs(cl->GetX())>kTolerX) { // if due to the misalingment X is large, propagate track only
+    if (!track->PropagateParamOnlyTo(track->GetX()+cl->GetX(),GetBz())) return kStopSearchOnSensor; // propagation failed, seedT is intact
+  }
+  double dy = cl->GetY() - track->GetY();
+  double dy2 = dy*dy;
+  double tol2 = (track->GetSigmaY2() + AliITSUReconstructor::GetRecoParam()->GetSigmaY2(lr))*
+    AliITSUReconstructor::GetRecoParam()->GetNSigmaRoadY()*AliITSUReconstructor::GetRecoParam()->GetNSigmaRoadY(); // RS TOOPTIMIZE
+  if (dy2>tol2) {                          // the clusters are sorted in Z(col) then in Y(row). 
+    if (dy>0) return kStopSearchOnSensor;  // No chance that other cluster of this sensor will match (all Y's will be even larger)
+    else      return kClusterNotMatching;   // Other clusters may match
+  }
+  double dz2 = cl->GetZ()-track->GetZ();
+  dz2 *= dz2;
+  tol2 = (track->GetSigmaZ2() + AliITSUReconstructor::GetRecoParam()->GetSigmaZ2(lr))*
+    AliITSUReconstructor::GetRecoParam()->GetNSigmaRoadZ()*AliITSUReconstructor::GetRecoParam()->GetNSigmaRoadZ(); // RS TOOPTIMIZE
+  if (dz2>tol2) return kClusterNotMatching; // Other clusters may match
+  //
+  // check chi2
+  Double_t p[2]={cl->GetY(), cl->GetZ()};
+  Double_t cov[3]={cl->GetSigmaY2(), cl->GetSigmaYZ(), cl->GetSigmaZ2()};
+  double chi2 = track->GetPredictedChi2(p,cov);
+  if (chi2>AliITSUReconstructor::GetRecoParam()->GetMaxTr2ClChi2(lr)) return kClusterNotMatching;
+  //
+  track = NewSeedFromPool(track);  // input track will be reused, use its clone for updates
+  if (!track->Update(p,cov)) return kClusterNotMatching;
+  track->SetChi2Cl(chi2);
+  track->SetLrClusterID(lr,clID);
+  cl->IncreaseClusterUsage();
+  //
+  AddProlongationHypothesis(track,lr);
+  //
+  return kClusterMatching;
+}
index 1dfa0aa..a06f4b7 100644 (file)
@@ -9,10 +9,10 @@
 
 #include "AliTracker.h"
 #include "AliESDEvent.h"
+#include "AliITSUSeed.h"
 
 class AliITSUReconstructor;
 class AliITSURecoDet;
-class AliITSUSeed;
 class AliITSUClusterPix;
 
 class TTree;
@@ -28,9 +28,11 @@ class AliITSUTrackerGlo : public AliTracker {
     kTrPhi0, kTrDPhi, kTrZ0, kTrDZ,     // mean phi,dPhi, mean z, dZ (don't change this order)
     kNTrImpData};
   //
-  enum {kTransportFailed=1  // seed did not reach target layer
+  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
 
   AliITSUTrackerGlo(AliITSUReconstructor* rec);
   virtual ~AliITSUTrackerGlo();
@@ -54,6 +56,8 @@ class AliITSUTrackerGlo : public AliTracker {
   Bool_t                 NeedToKill(AliITSUSeed* seed, Int_t flag) {return kFALSE;} // todo
   void                   KillSeed(Int_t ilr, Int_t id) {} // todo
   Bool_t                 GetRoadWidth(AliITSUSeed* seed, int ilrA);
+  Int_t                  CheckCluster(AliITSUSeed* seed, Int_t lr, Int_t clID);
+  void                   AddProlongationHypothesis(AliITSUSeed* seed, Int_t lr);
   //
   AliITSUSeed*           NewSeedFromPool(const AliITSUSeed* src=0);
   void                   DeleteLastSeedFromPool()               {fSeedsPool.RemoveLast();}
@@ -77,5 +81,14 @@ class AliITSUTrackerGlo : public AliTracker {
   ClassDef(AliITSUTrackerGlo,1)   //ITS upgrade tracker
     
 };
+
+//_________________________________________________________________________
+inline void AliITSUTrackerGlo::AddProlongationHypothesis(AliITSUSeed* seed, Int_t lr)
+{
+  // add new seed prolongation hypothesis 
+  fSeedsLr[lr].AddLast(seed);
+}
+
+
 #endif