Tracker update
authorshahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 15 Nov 2012 13:42:11 +0000 (13:42 +0000)
committershahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 15 Nov 2012 13:42:11 +0000 (13:42 +0000)
ITS/UPGRADE/AliITSUAux.h
ITS/UPGRADE/AliITSURecoLayer.h
ITS/UPGRADE/AliITSURecoParam.cxx
ITS/UPGRADE/AliITSURecoParam.h
ITS/UPGRADE/AliITSURecoSens.cxx
ITS/UPGRADE/AliITSUSeed.cxx
ITS/UPGRADE/AliITSUSeed.h
ITS/UPGRADE/AliITSUTrackerGlo.cxx
ITS/UPGRADE/AliITSUTrackerGlo.h

index cec6231..13db19a 100644 (file)
@@ -21,9 +21,14 @@ namespace AliITSUAux {
   void   BringTo02Pi(double &phi);
   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);
+  Bool_t IsCluster(UInt_t p);
   //
   const Double_t kNominalBz = 5.01;           // nominal field
-  const Double_t kPionMass = 1.3957e-01;
+  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
 }
 
 //_________________________________________________________________________________
@@ -46,5 +51,27 @@ inline Bool_t AliITSUAux::OKforPhiMax(double phiMax,double phi) {
   return ((dphi<0 && dphi>-Pi()) || dphi>Pi()) ? kTRUE:kFALSE;
 }
 
+//_________________________________________________________________________________
+inline UInt_t AliITSUAux::PackCluster(Int_t lr, Int_t clID) {
+  // pack layer/cluster into single uint
+  UInt_t p = clID<0 ? 0 : clID+1;
+  p<<=kLrBitMax;
+  return p + 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 Bool_t AliITSUAux::IsCluster(UInt_t p) {
+  // does it correspond to cluster?
+  return p>kMaxLayers;
+}
+
 
 #endif
index 86dab15..cb8fe17 100644 (file)
@@ -3,10 +3,11 @@
 
 #include <TNamed.h>
 #include <TObjArray.h>
+#include <TClonesArray.h>
 #include "AliITSURecoSens.h"
-class TClonesArray;
 class AliITSUGeomTGeo;
 class AliITSsegmentation;
+class AliCluster;
 
 
 ///////////////////////////////////////////////////////////////////////
@@ -50,6 +51,7 @@ class AliITSURecoLayer : public TNamed
   AliITSURecoSens*   GetSensor(Int_t i)            const {return (AliITSURecoSens*)fSensors[i];}
   AliITSURecoSens*   GetSensor(Int_t ld,Int_t is)  const {return GetSensor(ld*fNSensInLadder+is);}
   TClonesArray*      GetClusters()                 const {return (TClonesArray*)fClusters;}
+  AliCluster*        GetCluster(Int_t icl)         const {return (AliCluster*)fClusters->UncheckedAt(icl);}
   void               SetClusters(TClonesArray* cl)       {fClusters = cl;}
   //
   Int_t              FindSensors(const double* impPar, AliITSURecoSens *sensors[AliITSURecoSens::kNNeighbors]);
index e8d5965..12e9bf9 100644 (file)
 
 ClassImp(AliITSURecoParam)
 
+
+const Double_t AliITSURecoParam::fgkMaxDforV0dghtrForProlongation = 30;
+const Double_t AliITSURecoParam::fgkMaxDForProlongation           = 40; 
+const Double_t AliITSURecoParam::fgkMaxDZForProlongation          = 60;      
+const Double_t AliITSURecoParam::fgkMinPtForProlongation          = 0.0; 
+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::fgkTanLorentzAngle               = 0;
+//
+
 //_____________________________________________________________________________
 AliITSURecoParam::AliITSURecoParam()
-:  fNLayers(0)
+  :  fNLayers(0)
+  ,fMaxDforV0dghtrForProlongation(fgkMaxDforV0dghtrForProlongation)
+  ,fMaxDForProlongation(fgkMaxDForProlongation)
+  ,fMaxDZForProlongation(fgkMaxDZForProlongation)
+  ,fMinPtForProlongation(fgkMaxDForProlongation)
+  ,fNSigmaRoadY(fgkNSigmaRoadY)
+  ,fNSigmaRoadZ(fgkNSigmaRoadZ)
+     //
   ,fTanLorentzAngle(0)
+  ,fSigmaY2(0)
+  ,fSigmaZ2(0)
 {
   // def c-tor
   SetName("ITS");
@@ -37,8 +58,17 @@ AliITSURecoParam::AliITSURecoParam()
 
 //_____________________________________________________________________________
 AliITSURecoParam::AliITSURecoParam(Int_t nLr)
-:  fNLayers(0)
+  :  fNLayers(0)
+  ,fMaxDforV0dghtrForProlongation(fgkMaxDforV0dghtrForProlongation)
+  ,fMaxDForProlongation(fgkMaxDForProlongation)
+  ,fMaxDZForProlongation(fgkMaxDZForProlongation)
+  ,fMinPtForProlongation(fgkMaxDForProlongation)
+  ,fNSigmaRoadY(fgkNSigmaRoadY)
+  ,fNSigmaRoadZ(fgkNSigmaRoadZ)
+     //
   ,fTanLorentzAngle(0)
+  ,fSigmaY2(0)
+  ,fSigmaZ2(0)
 {
   // def c-tor
   SetName("ITS");
@@ -51,6 +81,8 @@ AliITSURecoParam::~AliITSURecoParam()
 {
   // destructor
   delete[] fTanLorentzAngle;
+  delete[] fSigmaY2;
+  delete[] fSigmaZ2;
 }
 
 //_____________________________________________________________________________
@@ -89,9 +121,13 @@ void  AliITSURecoParam::SetNLayers(Int_t n)
   if (n<1) n = 1; // in case we want to have dummy params
   fNLayers = n;
   fTanLorentzAngle = new Double_t[n];
+  fSigmaY2 = new Double_t[n];
+  fSigmaZ2 = new Double_t[n];
   //
   for (int i=n;i--;) {
-    fTanLorentzAngle[i] = 0;
+    fTanLorentzAngle[i] = fgkTanLorentzAngle;
+    fSigmaY2[i] = fgkSigmaRoadY*fgkSigmaRoadY;
+    fSigmaZ2[i] = fgkSigmaRoadZ*fgkSigmaRoadZ;
   }
   //
 }
@@ -103,3 +139,19 @@ void  AliITSURecoParam::SetTanLorentzAngle(Int_t lr, Double_t v)
   if (lr>=fNLayers) AliFatal(Form("Number of defined layers is %d",fNLayers));
   fTanLorentzAngle[lr] = v;
 }
+
+//_____________________________________________________________________________
+void  AliITSURecoParam::SetSigmaY2(Int_t lr, Double_t v)
+{
+  // set Lorentz angle value
+  if (lr>=fNLayers) AliFatal(Form("Number of defined layers is %d",fNLayers));
+  fSigmaY2[lr] = v;
+}
+
+//_____________________________________________________________________________
+void  AliITSURecoParam::SetSigmaZ2(Int_t lr, Double_t v)
+{
+  // set Lorentz angle value
+  if (lr>=fNLayers) AliFatal(Form("Number of defined layers is %d",fNLayers));
+  fSigmaZ2[lr] = v;
+}
index e1e332a..8f4fea2 100644 (file)
@@ -25,15 +25,53 @@ class AliITSURecoParam : public AliDetectorRecoParam
   static AliITSURecoParam *GetHighFluxParam();// make reco parameters for high flux env. 
   static AliITSURecoParam *GetCosmicTestParam();// special setting for cosmic  
 
-  Double_t    GetTanLorentzAngle(Int_t lr)                 const;
+  Double_t    GetMaxDforV0dghtrForProlongation() const {return fMaxDforV0dghtrForProlongation;}
+  Double_t    GetMaxDForProlongation()           const {return fMaxDForProlongation;}
+  Double_t    GetMaxDZForProlongation()          const {return fMaxDZForProlongation;}
+  Double_t    GetMinPtForProlongation()          const {return fMinPtForProlongation;}
+  Double_t    GetTanLorentzAngle(Int_t lr)       const;
+  Double_t    GetSigmaY2(Int_t lr)               const;
+  Double_t    GetSigmaZ2(Int_t lr)               const;
+  Double_t    GetNSigmaRoadY()                   const {return fNSigmaRoadY;}
+  Double_t    GetNSigmaRoadZ()                   const {return fNSigmaRoadZ;}
   //
   void        SetNLayers(Int_t n);
-  void        SetTanLorentzAngle(Int_t lr, Double_t v=0.);
+  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        GetMaxDforV0dghtrForProlongation(Double_t v)            {fMaxDforV0dghtrForProlongation = v;}
+  void        SetMaxDForProlongation(Double_t v)                      {fMaxDForProlongation = v;}
+  void        SetMaxDZForProlongation(Double_t v)                     {fMaxDZForProlongation = v;}
+  void        SetMinPtForProlongation(Double_t v)                     {fMinPtForProlongation = v;}
+  void        SetNSigmaRoadY(Double_t v)                              {fNSigmaRoadY=v;}
+  void        SetNSigmaRoadZ(Double_t v)                              {fNSigmaRoadZ=v;}
 
 
  protected:
   Int_t          fNLayers;          // number of layers 
+  //
+  Double_t       fMaxDforV0dghtrForProlongation; // max. rphi imp. par. cut for V0 daughter
+  Double_t       fMaxDForProlongation; // max. rphi imp. par. cut
+  Double_t       fMaxDZForProlongation; // max. 3D imp. par. cut
+  Double_t       fMinPtForProlongation; // min. pt cut
+  Double_t       fNSigmaRoadY;          // N sigmas for road in Y
+  Double_t       fNSigmaRoadZ;          // N sigmas for road in Z
+  //
   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
+  //
+  static const Double_t fgkMaxDforV0dghtrForProlongation;      // default
+  static const Double_t fgkMaxDForProlongation;                // default
+  static const Double_t fgkMaxDZForProlongation;               // default
+  static const Double_t fgkMinPtForProlongation;               // default
+  static const Double_t fgkNSigmaRoadY;                        // default
+  static const Double_t fgkNSigmaRoadZ;                        // default
+  // for arrays
+  static const Double_t fgkSigmaRoadY;                         // default
+  static const Double_t fgkSigmaRoadZ;                         // default
+  static const Double_t fgkTanLorentzAngle;                    // default
   //
  private:
   AliITSURecoParam(const AliITSURecoParam & param);
@@ -49,6 +87,20 @@ inline Double_t AliITSURecoParam::GetTanLorentzAngle(Int_t lr) const
   return lr<fNLayers ? fTanLorentzAngle[lr]:0;
 }
 
+//_____________________________________________________________________________
+inline Double_t AliITSURecoParam::GetSigmaY2(Int_t lr) const 
+{
+  // get tg of Lorentz Angle for the layer
+  return lr<fNLayers ? fSigmaY2[lr]:0;
+}
+
+//_____________________________________________________________________________
+inline Double_t AliITSURecoParam::GetSigmaZ2(Int_t lr) const 
+{
+  // get tg of Lorentz Angle for the layer
+  return lr<fNLayers ? fSigmaZ2[lr]:0;
+}
+
 #endif
 
 
index ec0e49c..a8770bb 100644 (file)
@@ -1,6 +1,7 @@
 #include "AliITSURecoSens.h"
 #include "AliITSUGeomTGeo.h"
 #include "AliITSsegmentation.h"
+#include "AliExternalTrackParam.h"
 
 ClassImp(AliITSURecoSens)
 
index 62b608e..0721425 100644 (file)
@@ -8,7 +8,8 @@ ClassImp(AliITSUSeed)
 
 //_________________________________________________________________________
 AliITSUSeed::AliITSUSeed() 
-: fMass(kPionMass)
+:  fClID(0)
+  ,fParent(0)
 {
   // def c-tor
 }
@@ -21,8 +22,9 @@ AliITSUSeed::~AliITSUSeed()
 
 //_________________________________________________________________________
 AliITSUSeed::AliITSUSeed(const AliITSUSeed& src) 
-  : AliExternalTrackParam(src)
-  , fMass(src.fMass)
+  :AliExternalTrackParam(src)
+  ,fClID(src.fClID)
+  ,fParent(src.fParent) 
 {
   // def c-tor
 }
@@ -32,7 +34,8 @@ AliITSUSeed &AliITSUSeed::operator=(const AliITSUSeed& src)
 {
   // def c-tor
   if (this == &src) return *this;
-  fMass = src.fMass;
+  fClID = src.fClID;
+  fParent = src.fParent;
   AliExternalTrackParam::operator=(src);
   return *this;
 }
index d74bf45..ea41403 100644 (file)
@@ -12,8 +12,15 @@ class AliITSUSeed: public AliExternalTrackParam
   AliITSUSeed &operator=(const AliITSUSeed &src);
   virtual ~AliITSUSeed();
   //
+  void            SetClusterID(UInt_t id)  {fClID = id;}
+  void            SetParent(TObject* par)  {fParent = par;}
+  //
+  UInt_t          GetClusterID()     const {return fClID;}
+  TObject*        GetParent()        const {return fParent;}
+  //
  protected:
-  Double_t         fMass;
+  UInt_t                fClID;              // packed cluster info (see AliITSUAux::PackCluster)
+  TObject*              fParent;            // parent track (in higher tree hierarchy)
   
   ClassDef(AliITSUSeed,1)
 };
index ca0421c..65a3e4d 100644 (file)
@@ -35,6 +35,7 @@
 #include "AliITSReconstructor.h"
 #include "AliITSUSeed.h"
 #include "AliITSUAux.h"
+#include "AliITSUClusterPix.h"
 using namespace AliITSUAux;
 using namespace TMath;
 
@@ -45,7 +46,8 @@ AliITSUTrackerGlo::AliITSUTrackerGlo(AliITSUReconstructor* rec)
 :  fReconstructor(rec)
   ,fITS(0)
   ,fCurrMass(kPionMass)
-  ,fSeedsPool("AliITSUSeed",100)
+  ,fSeedsLr(0)
+  ,fSeedsPool("AliITSUSeed",0)
 {
   // Default constructor
   if (rec) Init(rec);
@@ -57,6 +59,7 @@ AliITSUTrackerGlo::~AliITSUTrackerGlo()
  // Default destructor
  //  
   delete fITS;
+  delete[] fSeedsLr;
   //
 }
 
@@ -64,10 +67,17 @@ AliITSUTrackerGlo::~AliITSUTrackerGlo()
 void AliITSUTrackerGlo::Init(AliITSUReconstructor* rec)
 {
   // init with external reconstructor
+  //
   fITS = new AliITSURecoDet(rec->GetGeom(),"ITSURecoInterface");
   for (int ilr=fITS->GetNLayersActive();ilr--;) {
     fITS->GetLayerActive(ilr)->SetClusters(rec->GetClusters(ilr));
   }
+  //
+  fSeedsPool.ExpandCreateFast(1000); // RS TOCHECK
+  int n = fITS->GetNLayersActive()+1;
+  fSeedsLr = new TObjArray[n];
+  //
+
 }
 
 //_________________________________________________________________________
@@ -147,14 +157,14 @@ Bool_t AliITSUTrackerGlo::NeedToProlong(AliESDtrack* esdTr)
       esdTr->IsOn(AliESDtrack::kITSin)  ||
       esdTr->GetKinkIndex(0)>0) return kFALSE;
   //
-  if (esdTr->Pt()<AliITSReconstructor::GetRecoParam()->GetMinPtForProlongation()) return kFALSE;
+  if (esdTr->Pt()<AliITSUReconstructor::GetRecoParam()->GetMinPtForProlongation()) return kFALSE;
   //
   float dtz[2];
   esdTr->GetDZ(GetX(),GetY(),GetZ(),bz,dtz); 
   // if track is not V0 candidata but has large offset wrt IP, reject it. RS TOCHECK
-  if ( !(esdTr->GetV0Index(0)>0 && dtz[0]>AliITSReconstructor::GetRecoParam()->GetMaxDforV0dghtrForProlongation()) 
-       && (Abs(dtz[0])>AliITSReconstructor::GetRecoParam()->GetMaxDForProlongation() ||
-          Abs(dtz[1])>AliITSReconstructor::GetRecoParam()->GetMaxDZForProlongation())) return kFALSE;
+  if ( !(esdTr->GetV0Index(0)>0 && dtz[0]>AliITSUReconstructor::GetRecoParam()->GetMaxDforV0dghtrForProlongation()) 
+       && (Abs(dtz[0])>AliITSUReconstructor::GetRecoParam()->GetMaxDForProlongation() ||
+          Abs(dtz[1])>AliITSUReconstructor::GetRecoParam()->GetMaxDZForProlongation())) return kFALSE;
   //
   return kTRUE;
 }
@@ -164,18 +174,21 @@ 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
+  if (!InitSeed(esdTr))      return;  // initialize prolongations hypotheses tree
   //
-  double rwData[kNTrData];
   AliITSURecoSens *hitSens[AliITSURecoSens::kNNeighbors];
   AliITSUSeed seed0;
+  TObjArray clArr; // container for transfer of clusters matching to seed
   //
   for (int ila=fITS->GetNLayersActive();ila--;) {
     int ilaUp = ila+1;                         // prolong seeds from layer above
     int nSeedsUp = GetNSeeds(ilaUp);
     for (int isd=0;isd<nSeedsUp;isd++) {
-      seed0 = *GetSeed(ilaUp,isd);  // copy of the seed on prev.active layer
+      AliITSUSeed* seedU = GetSeed(ilaUp,isd);  // seed on prev.active layer to prolong
+      seed0 = *seedU;
       // go till next active layer
       if (!TransportToLayer(&seed0, fITS->GetLrIDActive(ilaUp), fITS->GetLrIDActive(ila)) ) {
        //
@@ -184,33 +197,56 @@ void AliITSUTrackerGlo::FindTrack(AliESDtrack* esdTr)
        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, rwData)) { // failed to find road width on the layer
+      if (!GetRoadWidth(&seed0, ila)) { // failed to find road width on the layer
        if (NeedToKill(&seed0,kRWCheckFailed)) KillSeed(ilaUp,isd); 
        continue;
       }
-      int nsens = lrA->FindSensors(&rwData[kTrPhi0], hitSens);  // find detectors which may be hit by the track (max 4)
+      int nsens = lrA->FindSensors(&fTrImpData[kTrPhi0], hitSens);  // find detectors which may be hit by the track (max 4)
       //
       for (int isn=nsens;isn--;) {
+       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();
+       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;}
+         }
+         
 
-
+       }
       }
       
     }
   }
   //
+  ResetSeedTree();
 }
 
 //_________________________________________________________________________
 Bool_t AliITSUTrackerGlo::InitSeed(AliESDtrack *esdTr)
 {
-  // int prolongaion candidates finding for single seed
+  // init prolongaion candidates finding for single seed
   fCurrMass = esdTr->GetMass();
   if (fCurrMass<kPionMass*0.9) fCurrMass = kPionMass; // don't trust to mu, e identification from TPCin
+  //
+  AliITSUSeed* seed = NewSeedFromPool();
+  seed->AliExternalTrackParam::operator=(*esdTr);
+  seed->SetParent(esdTr);
+  fSeedsLr[fITS->GetNLayersActive()].AddLast(seed);
   return kTRUE;
   // TO DO
 }
 
+//_________________________________________________________________________
+void AliITSUTrackerGlo::ResetSeedTree()
+{
+  // reset current hypotheses tree
+  for (int i=fITS->GetNLayersActive()+1;i--;) fSeedsLr[fITS->GetNLayersActive()].Clear();
+}
+
 //_________________________________________________________________________
 Bool_t AliITSUTrackerGlo::TransportToLayer(AliITSUSeed* seed, Int_t lFrom, Int_t lTo)
 {
@@ -251,18 +287,18 @@ Bool_t AliITSUTrackerGlo::TransportToLayer(AliITSUSeed* seed, Int_t lFrom, Int_t
 }
 
 //_________________________________________________________________________
-Bool_t AliITSUTrackerGlo::GetRoadWidth(AliITSUSeed* seed, int ilrA, double* rwData)
+Bool_t AliITSUTrackerGlo::GetRoadWidth(AliITSUSeed* seed, int ilrA)
 {
   // calculate road width in terms of phi and z for the track which MUST be on the external radius of the layer
   // as well as some aux info
   double bz = GetBz();
   AliITSURecoLayer* lrA = fITS->GetLayerActive(ilrA);
-  seed->GetXYZ(&rwData[kTrXIn]);    // lab position at the entrance from above
+  seed->GetXYZ(&fTrImpData[kTrXIn]);    // lab position at the entrance from above
   //
-  rwData[kTrPhiIn] = ATan2(rwData[kTrYIn],rwData[kTrXIn]);
-  if (!seed->Rotate(rwData[kTrPhiIn])) return kFALSE; // go to the frame of the entry point into the layer
-  double dr  = lrA->GetDR();                          // approximate X dist at the inner radius
-  if (!seed->GetXYZAt(seed->GetX()-dr, bz, rwData + kTrXOut)) {
+  fTrImpData[kTrPhiIn] = ATan2(fTrImpData[kTrYIn],fTrImpData[kTrXIn]);
+  if (!seed->Rotate(fTrImpData[kTrPhiIn])) return kFALSE; // go to the frame of the entry point into the layer
+  double dr  = lrA->GetDR();                              // approximate X dist at the inner radius
+  if (!seed->GetXYZAt(seed->GetX()-dr, bz, fTrImpData + kTrXOut)) {
     // special case: track does not reach inner radius, might be tangential
     double r = seed->GetD(0,0,bz);
     double x;
@@ -272,28 +308,28 @@ Bool_t AliITSUTrackerGlo::GetRoadWidth(AliITSUSeed* seed, int ilrA, double* rwDa
       return kFALSE;
     }
     dr = Abs(seed->GetX() - x);
-    if (!seed->GetXYZAt(x, bz, rwData + kTrXOut)) {
+    if (!seed->GetXYZAt(x, bz, fTrImpData + kTrXOut)) {
       AliError(Form("This should not happen: x=%f",x));
       seed->Print();
       return kFALSE;      
     }
   }
   //
-  rwData[kTrPhiOut] = ATan2(rwData[kTrYOut],rwData[kTrXOut]);
-  double sgy = seed->GetSigmaY2() + dr*seed->GetSigmaSnp2() + AliITSReconstructor::GetRecoParam()->GetSigmaY2(ilrA);
-  double sgz = seed->GetSigmaZ2() + dr*seed->GetSigmaTgl2() + AliITSReconstructor::GetRecoParam()->GetSigmaZ2(ilrA);
-  sgy = Sqrt(sgy)*AliITSReconstructor::GetRecoParam()->GetNSigmaRoadY();
-  sgz = Sqrt(sgz)*AliITSReconstructor::GetRecoParam()->GetNSigmaRoadZ();
-  rwData[kTrPhi0] = 0.5*(rwData[kTrPhiOut]+rwData[kTrPhiIn]);
-  rwData[kTrZ0]   = 0.5*(rwData[kTrZOut]+rwData[kTrPhiIn]);
-  rwData[kTrDPhi] = 0.5*Abs(rwData[kTrPhiOut]-rwData[kTrPhiIn]) + sgy/lrA->GetR();
-  rwData[kTrDZ]   = 0.5*Abs(rwData[kTrZOut]-rwData[kTrPhiIn])   + sgz;
+  fTrImpData[kTrPhiOut] = ATan2(fTrImpData[kTrYOut],fTrImpData[kTrXOut]);
+  double sgy = seed->GetSigmaY2() + dr*dr*seed->GetSigmaSnp2() + AliITSUReconstructor::GetRecoParam()->GetSigmaY2(ilrA);
+  double sgz = seed->GetSigmaZ2() + dr*dr*seed->GetSigmaTgl2() + AliITSUReconstructor::GetRecoParam()->GetSigmaZ2(ilrA);
+  sgy = Sqrt(sgy)*AliITSUReconstructor::GetRecoParam()->GetNSigmaRoadY();
+  sgz = Sqrt(sgz)*AliITSUReconstructor::GetRecoParam()->GetNSigmaRoadZ();
+  fTrImpData[kTrPhi0] = 0.5*(fTrImpData[kTrPhiOut]+fTrImpData[kTrPhiIn]);
+  fTrImpData[kTrZ0]   = 0.5*(fTrImpData[kTrZOut]+fTrImpData[kTrPhiIn]);
+  fTrImpData[kTrDPhi] = 0.5*Abs(fTrImpData[kTrPhiOut]-fTrImpData[kTrPhiIn]) + sgy/lrA->GetR();
+  fTrImpData[kTrDZ]   = 0.5*Abs(fTrImpData[kTrZOut]-fTrImpData[kTrPhiIn])   + sgz;
   //  
   return kTRUE;
 }
 
 //_________________________________________________________________________
-AliITSUSeed* AliITSUTrackerGlo::NewSeed(const AliITSUSeed* src)
+AliITSUSeed* AliITSUTrackerGlo::NewSeedFromPool(const AliITSUSeed* src)
 {
   // create new seed, optionally copying from the source
   return src ? 
index f8429fa..1dfa0aa 100644 (file)
 class AliITSUReconstructor;
 class AliITSURecoDet;
 class AliITSUSeed;
+class AliITSUClusterPix;
+
 class TTree;
 
+
 //-------------------------------------------------------------------------
 class AliITSUTrackerGlo : public AliTracker {
 
@@ -23,7 +26,7 @@ class AliITSUTrackerGlo : public AliTracker {
     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)
-    kNTrData};
+    kNTrImpData};
   //
   enum {kTransportFailed=1  // seed did not reach target layer
        ,kRWCheckFailed =2  // failed to rotate the seed to frame of the layer impact point
@@ -45,15 +48,17 @@ class AliITSUTrackerGlo : public AliTracker {
   void                   Init(AliITSUReconstructor* rec);
   void                   FindTrack(AliESDtrack* esdTr);
   Bool_t                 InitSeed(AliESDtrack *esdTr);
-  Int_t                  GetNSeeds(Int_t lr)              const {return 0;} //todo
-  AliITSUSeed*           GetSeed(Int_t lr, Int_t sID)     const {return 0;} //todo
+  Int_t                  GetNSeeds(Int_t lr)              const {return fSeedsLr[lr].GetEntriesFast();} //RS TOCHECK
+  AliITSUSeed*           GetSeed(Int_t lr, Int_t sID)     const {return (AliITSUSeed*)fSeedsLr[lr].UncheckedAt(sID);} //RS TOCHECK
   Bool_t                 TransportToLayer(AliITSUSeed* seed, Int_t lFrom, Int_t lTo);
   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, double* rwData);
+  Bool_t                 GetRoadWidth(AliITSUSeed* seed, int ilrA);
+  //
+  AliITSUSeed*           NewSeedFromPool(const AliITSUSeed* src=0);
+  void                   DeleteLastSeedFromPool()               {fSeedsPool.RemoveLast();}
+  void                   ResetSeedTree();  // RS TOCHECK
   //
-  AliITSUSeed*           NewSeed(const AliITSUSeed* src=0);
-
  private:
   
   AliITSUTrackerGlo(const AliITSUTrackerGlo&);
@@ -63,8 +68,10 @@ class AliITSUTrackerGlo : public AliTracker {
   AliITSUReconstructor*           fReconstructor;  // ITS global reconstructor 
   AliITSURecoDet*                 fITS;            // interface to ITS
   Double_t                        fCurrMass;       // current track mass
+  Double_t                        fTrImpData[kNTrImpData];  // data on track impact on the layer
   //
-
+  // the seeds management to be optimized
+  TObjArray*                      fSeedsLr;        // seeds at each layer
   TClonesArray                    fSeedsPool;      // pool for seeds
 
   ClassDef(AliITSUTrackerGlo,1)   //ITS upgrade tracker