Faster version of the tracker V2
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 16 Nov 2004 11:54:48 +0000 (11:54 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 16 Nov 2004 11:54:48 +0000 (11:54 +0000)
ITS/AliITSclusterV2.h
ITS/AliITStrackV2.cxx
ITS/AliITStrackerV2.cxx
ITS/AliITStrackerV2.h

index 268bafc1d9ed7c95bf3e6eb7ef00604911c1d7c5..7f68622ec10c4161b9becf707dc85c841a80777a 100644 (file)
@@ -16,7 +16,9 @@
 //_____________________________________________________________________________
 class AliITSclusterV2 : public AliCluster {
 public:
-  AliITSclusterV2() : AliCluster() {fQ=0; fLayer=0; fNz=1; fNy=1; fType=0;fDeltaProb=0;}
+  AliITSclusterV2() : AliCluster() {
+    fQ=0; fLayer=0; fNz=fNy=1; fType=0; fDeltaProb=0;
+  }
   AliITSclusterV2(Int_t *lab,Float_t *hit, Int_t *info) : AliCluster(lab,hit) {
     fIndex=lab[3];
     fQ=hit[4];
@@ -27,23 +29,27 @@ public:
     fType=0;
     fDeltaProb=0.;
   }
+
   void Use() {fQ=-fQ;}
+  void UnUse() {fQ=TMath::Abs(fQ);}
   void SetQ(Float_t q) {fQ=q;}
   void SetDetectorIndex(Int_t i) { fIndex=i; }
   void SetLayer(Int_t layer) {fLayer=layer;}
   void SetNz(Int_t nz) {fNz =nz;}
   void SetNy(Int_t ny){fNy=ny;}
   void SetChargeRatio(Float_t ratio) { fChargeRatio = ratio;}
+  void SetPhiR(Float_t y) { fChargeRatio=y; }
   void SetType(Int_t type){ fType=type;}
   void SetDeltaProbability(Float_t prob){fDeltaProb = prob;}
 
-  Int_t IsUsed() const {return (fQ<0) ? 1 : 0;}
+  Int_t IsUsed() const {return (fQ<0)?1:0;}
   Float_t GetQ() const {return TMath::Abs(fQ);}
   Int_t GetDetectorIndex() const { return 0x3FF&fIndex; }
   Int_t GetLayer() const {return fLayer;}
   Int_t GetNz() const {return fNz;}
   Int_t GetNy() const {return fNy;}
   Float_t GetChargeRatio() const {return fChargeRatio;}
+  Float_t GetPhiR() const {return fChargeRatio;}
   Int_t GetPindex() const { return 0xFFF00000&fIndex; }  //SSD clusters only
   Int_t GetNindex() const { return 0xFFC00&fIndex; }  //SSD clusters only
   Int_t GetType() const {return fType;}  // type of the cluster
index 35cfdccd8b544ac244441af1dcc7f4b5354db978..86df5a7da4c45e1c522ff718f9982e1823dcc114 100644 (file)
@@ -19,9 +19,6 @@
 //          Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
 //     dEdx analysis by: Boris Batyunya, JINR, Boris.Batiounia@cern.ch
 //-------------------------------------------------------------------------
-
-#include <TMatrixD.h>
-
 #include <TMath.h>
 
 #include "AliCluster.h"
@@ -474,7 +471,6 @@ Int_t AliITStrackV2::Propagate(Double_t alp,Double_t xk) {
   Double_t ca=TMath::Cos(alp-fAlpha), sa=TMath::Sin(alp-fAlpha);
   Double_t sf=fP2, cf=TMath::Sqrt(1.- fP2*fP2);
 
-  TMatrixD *T=0;
   // **** rotation **********************
   {
   fAlpha = alp;
@@ -482,34 +478,24 @@ Int_t AliITStrackV2::Propagate(Double_t alp,Double_t xk) {
   fP0= -x*sa + p0*ca;
   fP2=  sf*ca - cf*sa;
 
-  static TMatrixD C(5,5); 
-  C(0,0)=c00;
-  C(1,0)=c10; C(1,1)=c11;
-  C(2,0)=c20; C(2,1)=c21; C(2,2)=c22;
-  C(3,0)=c30; C(3,1)=c31; C(3,2)=c32; C(3,3)=c33;
-  C(4,0)=c40; C(4,1)=c41; C(4,2)=c42; C(4,3)=c43; C(4,4)=c44;
-  C(0,1)=C(1,0);
-  C(0,2)=C(2,0); C(1,2)=C(2,1);
-  C(0,3)=C(3,0); C(1,3)=C(3,1); C(2,3)=C(3,2);
-  C(0,4)=C(4,0); C(1,4)=C(4,1); C(2,4)=C(4,2); C(3,4)=C(4,3);
-
-  
-  static TMatrixD F(6,5);
-  F(0,0)=sa; 
-  F(1,0)=ca;
-  F(2,1)=F(4,3)=F(5,4)=1; 
-  F(3,2)=ca + sf/cf*sa;
-
-  //TMatrixD tmp(C,TMatrixD::kMult,TMatrixD(TMatrixD::kTransposed, F)); 
-  
-  static TMatrixD Ft(5,6);
-  Ft(0,0)=sa; 
-  Ft(0,1)=ca;
-  Ft(1,2)=Ft(3,4)=Ft(4,5)=1; 
-  Ft(2,3)=ca + sf/cf*sa;
-
-  TMatrixD tmp(C,TMatrixD::kMult,Ft); 
-  T=new TMatrixD(F,TMatrixD::kMult,tmp); 
+  Double_t rr=(ca+sf/cf*sa);  
+
+  fC00 *= (ca*ca);
+  fC10 *= ca; 
+  fC20 *= ca*rr;
+  fC30 *= ca;
+  fC40 *= ca;
+  //fC11 = fC11;
+  fC21 *= rr;
+  //fC31 = fC31; 
+  //fC41 = fC41;
+  fC22 *= rr*rr;
+  fC32 *= rr;
+  fC42 *= rr;
+  //fC33=fC33;
+  //fC43=fC43;
+  //fC44=fC44;
   }
 
   // **** translation ******************
@@ -529,27 +515,45 @@ Int_t AliITStrackV2::Propagate(Double_t alp,Double_t xk) {
   fP1 += dx*(f1+f2)/(f1*r2 + f2*r1)*fP3;
   fP2 += dx*fP4;
 
-  static TMatrixD F(5,6);
-  F(0,1)=F(1,2)=F(2,3)=F(3,4)=F(4,5)=1; 
-  F(0,3)=dx/(r1+r2)*(2+(f1+f2)*(f2/r2+f1/r1)/(r1+r2)); 
-  F(0,5)=dx*dx/(r1+r2)*(1+(f1+f2)*f2/(r1+r2));
-  F(1,3)=dx*fP3/(f1*r2 + f2*r1)*(2-(f1+f2)*(r2-f1*f2/r2+r1-f2*f1/r1)/(f1*r2 + f2*r1));
-  F(1,4)=dx*(f1+f2)/(f1*r2 + f2*r1);
-  F(1,5)=dx*dx*fP3/(f1*r2 + f2*r1)*(1-(f1+f2)*(-f1*f2/r2+r1)/(f1*r2 + f2*r1));
-  F(2,5)=dx;
-  F(0,0)=-1/(r1+r2)*((f1+f2)+dx*fP4*(1+(f1+f2)/(r1+r2)*f2/r2));
-  F(1,0)=-fP3/(f1*r2 + f2*r1)*((f1+f2)+dx*fP4*(1+(f1+f2)/(f1*r2 + f2*r1)*(f1*f2/r2-r1)));
-  F(2,0)=-fP4;
-
-  TMatrixD tmp(*T,TMatrixD::kMult,TMatrixD(TMatrixD::kTransposed, F)); 
-  delete T;
-  TMatrixD C(F,TMatrixD::kMult,tmp);
-
-  fC00=C(0,0); 
-  fC10=C(1,0); fC11=C(1,1); 
-  fC20=C(2,0); fC21=C(2,1); fC22=C(2,2);
-  fC30=C(3,0); fC31=C(3,1); fC32=C(3,2); fC33=C(3,3);
-  fC40=C(4,0); fC41=C(4,1); fC42=C(4,2); fC43=C(4,3); fC44=C(4,4);
+  //f = F - 1
+  
+  Double_t f02=    dx/(r1*r1*r1);
+  Double_t f04=0.5*dx*dx/(r1*r1*r1);
+  Double_t f12=    dx*fP3*f1/(r1*r1*r1);
+  Double_t f14=0.5*dx*dx*fP3*f1/(r1*r1*r1);
+  Double_t f13=    dx/r1;
+  Double_t f24=    dx; 
+  
+  //b = C*ft
+  Double_t b00=f02*fC20 + f04*fC40, b01=f12*fC20 + f14*fC40 + f13*fC30;
+  Double_t b02=f24*fC40;
+  Double_t b10=f02*fC21 + f04*fC41, b11=f12*fC21 + f14*fC41 + f13*fC31;
+  Double_t b12=f24*fC41;
+  Double_t b20=f02*fC22 + f04*fC42, b21=f12*fC22 + f14*fC42 + f13*fC32;
+  Double_t b22=f24*fC42;
+  Double_t b40=f02*fC42 + f04*fC44, b41=f12*fC42 + f14*fC44 + f13*fC43;
+  Double_t b42=f24*fC44;
+  Double_t b30=f02*fC32 + f04*fC43, b31=f12*fC32 + f14*fC43 + f13*fC33;
+  Double_t b32=f24*fC43;
+  
+  //a = f*b = f*C*ft
+  Double_t a00=f02*b20+f04*b40,a01=f02*b21+f04*b41,a02=f02*b22+f04*b42;
+  Double_t a11=f12*b21+f14*b41+f13*b31,a12=f12*b22+f14*b42+f13*b32;
+  Double_t a22=f24*b42;
+
+  //F*C*Ft = C + (b + bt + a)
+  fC00 += b00 + b00 + a00;
+  fC10 += b10 + b01 + a01; 
+  fC20 += b20 + b02 + a02;
+  fC30 += b30;
+  fC40 += b40;
+  fC11 += b11 + b11 + a11;
+  fC21 += b21 + b12 + a12;
+  fC31 += b31; 
+  fC41 += b41;
+  fC22 += b22 + b22 + a22;
+  fC32 += b32;
+  fC42 += b42;
 
   if (!Invariant()) {
      fAlpha=alpha; 
@@ -567,6 +571,7 @@ Int_t AliITStrackV2::Propagate(Double_t alp,Double_t xk) {
   return 1;
 }
 
+
 Double_t AliITStrackV2::GetD(Double_t x, Double_t y) const {
   //------------------------------------------------------------------
   // This function calculates the transverse impact parameter
index bb19687bc316237877ec43048e1ad6a71cd7f4e6..efced05e745921724aeb56ee1269835ab9eb720e 100644 (file)
@@ -43,8 +43,7 @@ AliITStrackerV2::AliITStrackerV2(const AliITSgeom *geom) : AliTracker() {
   //--------------------------------------------------------------------
   AliITSgeom *g=(AliITSgeom*)geom;
 
-  Float_t x,y,z;
-  Int_t i;
+  Float_t x,y,z;  Int_t i;
   for (i=1; i<kMaxLayer+1; i++) {
     Int_t nlad=g->GetNladders(i);
     Int_t ndet=g->GetNdetectors(i);
@@ -72,6 +71,10 @@ AliITStrackerV2::AliITStrackerV2(const AliITSgeom *geom) : AliTracker() {
         Double_t phi=TMath::ATan2(rot[1],rot[0])+TMath::Pi();
         phi+=TMath::Pi()/2;
         if (i==1) phi+=TMath::Pi();
+
+        if (phi<0) phi+=TMath::TwoPi();
+        else if (phi>=TMath::TwoPi()) phi-=TMath::TwoPi();
+
         Double_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
         Double_t r=x*cp+y*sp;
 
@@ -85,7 +88,7 @@ AliITStrackerV2::AliITStrackerV2(const AliITSgeom *geom) : AliTracker() {
   fI=kMaxLayer;
 
   fPass=0;
-  fConstraint[0]=1; fConstraint[1]=0;//-1;
+  fConstraint[0]=1; fConstraint[1]=0;
 
   Double_t xyz[]={kXV,kYV,kZV}, ers[]={kSigmaXV,kSigmaYV,kSigmaZV}; 
   SetVertex(xyz,ers);
@@ -119,11 +122,21 @@ Int_t AliITStrackerV2::LoadClusters(TTree *cTree) {
   for (Int_t i=0; i<kMaxLayer; i++) {
     Int_t ndet=fgLayers[i].GetNdetectors();
     Int_t jmax = j + fgLayers[i].GetNladders()*ndet;
+
+    Double_t r=fgLayers[i].GetR();
+    Double_t circ=TMath::TwoPi()*r;
+
     for (; j<jmax; j++) {           
       if (!cTree->GetEvent(j)) continue;
       Int_t ncl=clusters->GetEntriesFast();
       while (ncl--) {
         AliITSclusterV2 *c=(AliITSclusterV2*)clusters->UncheckedAt(ncl);
+
+        Int_t idx=c->GetDetectorIndex();
+        Double_t y=r*fgLayers[i].GetDetector(idx).GetPhi()+c->GetY();
+        if (y>circ) y-=circ; else if (y<0) y+=circ;
+        c->SetPhiR(y);
+
         fgLayers[i].InsertCluster(new AliITSclusterV2(*c));
       }
       clusters->Delete();
@@ -482,14 +495,15 @@ void AliITStrackerV2::FollowProlongation() {
       return;
     }
 
+    fI--;
+
     Double_t zmin=track.GetZ() - dz; 
     Double_t zmax=track.GetZ() + dz;
     Double_t ymin=track.GetY() + r*phi - dy;
     Double_t ymax=track.GetY() + r*phi + dy;
-    layer.SelectClusters(zmin,zmax,ymin,ymax); 
-    fI--;
+    if (layer.SelectClusters(zmin,zmax,ymin,ymax)==0) 
+       if (fLayersNotToSkip[fI]) return;  
 
-    //take another prolongation
     if (!TakeNextProlongation()) 
        if (fLayersNotToSkip[fI]) return;
 
@@ -528,7 +542,8 @@ Int_t AliITStrackerV2::TakeNextProlongation() {
   } 
 
   const AliITSclusterV2 *c=0; Int_t ci=-1;
-  Double_t chi2=12345.;
+  const AliITSclusterV2 *cc=0; Int_t cci=-1;
+  Double_t chi2=kMaxChi2;
   while ((c=layer.GetNextCluster(ci))!=0) {
     Int_t idet=c->GetDetectorIndex();
 
@@ -546,13 +561,16 @@ Int_t AliITStrackerV2::TakeNextProlongation() {
     if (TMath::Abs(fTrackToFollow.GetZ() - c->GetZ()) > dz) continue;
     if (TMath::Abs(fTrackToFollow.GetY() - c->GetY()) > dy) continue;
 
-    chi2=fTrackToFollow.GetPredictedChi2(c); if (chi2<kMaxChi2) break;
+    Double_t ch2=fTrackToFollow.GetPredictedChi2(c); 
+    if (ch2 > chi2) continue;
+    chi2=ch2;
+    cc=c; cci=ci;
+    break;
   }
 
-  if (chi2>=kMaxChi2) return 0;
-  if (!c) return 0;
+  if (!cc) return 0;
 
-  if (!fTrackToFollow.Update(c,chi2,(fI<<28)+ci)) {
+  if (!fTrackToFollow.Update(cc,chi2,(fI<<28)+cci)) {
      //Warning("TakeNextProlongation","filtering failed !\n");
      return 0;
   }
@@ -561,7 +579,7 @@ Int_t AliITStrackerV2::TakeNextProlongation() {
   if (TMath::Abs(fTrackToFollow.GetD())>4) return 0;
 
   fTrackToFollow.
-    SetSampledEdx(c->GetQ(),fTrackToFollow.GetNumberOfClusters()-1); //b.b.
+    SetSampledEdx(cc->GetQ(),fTrackToFollow.GetNumberOfClusters()-1); //b.b.
 
   {
   Double_t x0;
@@ -584,8 +602,14 @@ AliITStrackerV2::AliITSlayer::AliITSlayer() {
   //--------------------------------------------------------------------
   //default AliITSlayer constructor
   //--------------------------------------------------------------------
-  fN=0;
+  fR=0.; fPhiOffset=0.; fZOffset=0.;
+  fNladders=0; fNdetectors=0;
   fDetectors=0;
+  
+  for (Int_t i=0; i<kNsector; i++) fN[i]=0;
+  fNsel=0;
+
+  fRoad=2*fR*TMath::Sqrt(3.14/1.);//assuming that there's only one cluster
 }
 
 AliITStrackerV2::AliITSlayer::
@@ -597,8 +621,10 @@ AliITSlayer(Double_t r,Double_t p,Double_t z,Int_t nl,Int_t nd) {
   fNladders=nl; fNdetectors=nd;
   fDetectors=new AliITSdetector[fNladders*fNdetectors];
 
-  fN=0;
-  fI=0;
+  for (Int_t i=0; i<kNsector; i++) fN[i]=0;
+  fNsel=0;
+
+  for (Int_t i=0; i<kMaxClusterPerLayer; i++) fClusters[i]=0;
 
   fRoad=2*fR*TMath::Sqrt(3.14/1.);//assuming that there's only one cluster
 }
@@ -608,16 +634,20 @@ AliITStrackerV2::AliITSlayer::~AliITSlayer() {
   // AliITSlayer destructor
   //--------------------------------------------------------------------
   delete[] fDetectors;
-  for (Int_t i=0; i<fN; i++) delete fClusters[i];
+  ResetClusters();
 }
 
 void AliITStrackerV2::AliITSlayer::ResetClusters() {
   //--------------------------------------------------------------------
   // This function removes loaded clusters
   //--------------------------------------------------------------------
-  for (Int_t i=0; i<fN; i++) delete fClusters[i];
-  fN=0;
-  fI=0;
+   for (Int_t s=0; s<kNsector; s++) {
+       Int_t &n=fN[s];
+       while (n) {
+          n--;
+          delete fClusters[s*kMaxClusterPerSector+n];
+       }
+   }
 }
 
 void AliITStrackerV2::AliITSlayer::ResetRoad() {
@@ -625,37 +655,53 @@ void AliITStrackerV2::AliITSlayer::ResetRoad() {
   // This function calculates the road defined by the cluster density
   //--------------------------------------------------------------------
   Int_t n=0;
-  for (Int_t i=0; i<fN; i++) {
-     if (TMath::Abs(fClusters[i]->GetZ())<fR) n++;
+  for (Int_t s=0; s<kNsector; s++) {
+    Int_t i=fN[s];
+    while (i--) 
+       if (TMath::Abs(fClusters[s*kMaxClusterPerSector+i]->GetZ())<fR) n++;
   }
   if (n>1) fRoad=2*fR*TMath::Sqrt(3.14/n);
 }
 
 Int_t AliITStrackerV2::AliITSlayer::InsertCluster(AliITSclusterV2 *c) {
   //--------------------------------------------------------------------
-  //This function adds a cluster to this layer
+  // This function inserts a cluster to this layer in increasing
+  // order of the cluster's fZ
   //--------------------------------------------------------------------
-  if (fN==kMaxClusterPerLayer) {
-    ::Error("InsertCluster","Too many clusters !\n");
-    return 1;
+  Float_t circ=TMath::TwoPi()*fR;
+  Int_t sec=Int_t(kNsector*c->GetPhiR()/circ);
+  Int_t &n=fN[sec];
+  if (n>=kMaxClusterPerSector) {
+     ::Error("InsertCluster","Too many clusters !\n");
+     return 1;
   }
-
-  if (fN==0) {fClusters[fN++]=c; return 0;}
-  Int_t i=FindClusterIndex(c->GetZ());
-  memmove(fClusters+i+1 ,fClusters+i,(fN-i)*sizeof(AliITSclusterV2*));
-  fClusters[i]=c; fN++;
-
+  if (n==0) fClusters[sec*kMaxClusterPerSector]=c;
+  else {
+     Int_t i=FindClusterIndex(c->GetZ(),sec);
+     Int_t k=n-i+sec*kMaxClusterPerSector;
+     memmove(fClusters+i+1 ,fClusters+i,k*sizeof(AliITSclusterV2*));
+     fClusters[i]=c;
+  }
+  n++;
   return 0;
 }
 
-Int_t AliITStrackerV2::AliITSlayer::FindClusterIndex(Double_t z) const {
+Int_t 
+AliITStrackerV2::AliITSlayer::FindClusterIndex(Float_t z,Int_t s) const {
   //--------------------------------------------------------------------
-  // This function returns the index of the nearest cluster 
+  // For the sector "s", this function returns the index of the first 
+  // with its fZ >= "z". 
   //--------------------------------------------------------------------
-  if (fN==0) return 0;
-  if (z <= fClusters[0]->GetZ()) return 0;
-  if (z > fClusters[fN-1]->GetZ()) return fN;
-  Int_t b=0, e=fN-1, m=(b+e)/2;
+  Int_t nc=fN[s];
+  if (nc==0) return kMaxClusterPerSector*s;
+
+  Int_t b=kMaxClusterPerSector*s;
+  if (z <= fClusters[b]->GetZ()) return b;
+
+  Int_t e=b+nc-1;
+  if (z > fClusters[e]->GetZ()) return e+1;
+
+  Int_t m=(b+e)/2;
   for (; b<e; m=(b+e)/2) {
     if (z > fClusters[m]->GetZ()) b=m+1;
     else e=m; 
@@ -663,44 +709,71 @@ Int_t AliITStrackerV2::AliITSlayer::FindClusterIndex(Double_t z) const {
   return m;
 }
 
-void AliITStrackerV2::AliITSlayer::
-SelectClusters(Double_t zmin,Double_t zmax,Double_t ymin, Double_t ymax) {
+Int_t AliITStrackerV2::AliITSlayer::
+SelectClusters(Float_t zmin,Float_t zmax,Float_t ymin, Float_t ymax) {
   //--------------------------------------------------------------------
-  // This function sets the "window"
+  // This function selects clusters within the "window"
   //--------------------------------------------------------------------
-  fI=FindClusterIndex(zmin); fZmax=zmax;
-  Double_t circle=2*TMath::Pi()*fR;
-  if (ymax>circle) { ymax-=circle; ymin-=circle; }
-  fYmin=ymin; fYmax=ymax;
+    Float_t circ=fR*TMath::TwoPi();
+
+    if (ymin>circ) ymin-=circ; else if (ymin<0) ymin+=circ;
+    if (ymax>circ) ymax-=circ; else if (ymax<0) ymax+=circ;
+
+    Int_t i1=Int_t(kNsector*ymin/circ);
+    if (fN[i1]!=0) {
+       Float_t ym = (ymax<ymin) ? ymax+circ : ymax;
+       Int_t i=FindClusterIndex(zmin,i1), imax=i1*kMaxClusterPerSector+fN[i1];
+       for (; i<imax; i++) {
+           AliITSclusterV2 *c=fClusters[i];
+           if (c->IsUsed()) continue;
+           if (c->GetZ()>zmax) break;
+           if (c->GetPhiR()<=ymin) continue;
+           if (c->GetPhiR()>ym) continue;
+           fIndex[fNsel++]=i;
+       }
+    }
+
+    Int_t i2=Int_t(kNsector*ymax/circ);
+    if (i2==i1) return fNsel;
+
+    if (fN[i2]!=0) {
+       Float_t ym = (ymin>ymax) ? ymin-circ : ymin;
+       Int_t i=FindClusterIndex(zmin,i2), imax=i2*kMaxClusterPerSector+fN[i2];
+       for (; i<imax; i++) {
+           AliITSclusterV2 *c=fClusters[i];
+           if (c->IsUsed()) continue;
+           if (c->GetZ()>zmax) break;
+           if (c->GetPhiR()<=ym) continue;
+           if (c->GetPhiR()>ymax) continue;
+           fIndex[fNsel++]=i;
+       }
+    }
+
+    return fNsel;
 }
 
 const AliITSclusterV2 *AliITStrackerV2::AliITSlayer::GetNextCluster(Int_t &ci){
   //--------------------------------------------------------------------
   // This function returns clusters within the "window" 
   //--------------------------------------------------------------------
-  const AliITSclusterV2 *cluster=0;
-  for (Int_t i=fI; i<fN; i++) {
-    const AliITSclusterV2 *c=fClusters[i];
-    if (c->GetZ() > fZmax) break;
-    if (c->IsUsed()) continue;
-    const AliITSdetector &det=GetDetector(c->GetDetectorIndex());    
-    Double_t y=fR*det.GetPhi() + c->GetY();
-
-    if (y>2.*fR*TMath::Pi()) y -= 2*fR*TMath::Pi();
-    if (y>1.*fR*TMath::Pi() && fYmax<y) y -= 2*fR*TMath::Pi();
-
-    if (y<fYmin) continue;
-    if (y>fYmax) continue;
-    cluster=c; ci=i;
-    fI=i+1;
-    break; 
+  AliITSclusterV2 *c=0;
+  ci=-1;
+  if (fNsel) {
+     fNsel--;
+     ci=fIndex[fNsel]; 
+     c=fClusters[ci];
   }
+  return c; 
+}
 
-  return cluster;
+Int_t AliITStrackerV2::AliITSlayer::GetNumberOfClusters() const {
+  Int_t n=0;
+  for (Int_t s=0; s<kNsector; s++) n+=fN[s];
+  return n; 
 }
 
-Int_t AliITStrackerV2::AliITSlayer::
-FindDetectorIndex(Double_t phi, Double_t z) const {
+Int_t 
+AliITStrackerV2::AliITSlayer::FindDetectorIndex(Double_t phi,Double_t z)const {
   //--------------------------------------------------------------------
   //This function finds the detector crossed by the track
   //--------------------------------------------------------------------
@@ -848,28 +921,6 @@ Double_t AliITStrackerV2::GetEffectiveThickness(Double_t y,Double_t z) const
   return d/(xn*xn);
 }
 
-Int_t AliITStrackerV2::AliITSlayer::InRoad() const {
-  //--------------------------------------------------------------------
-  // This function returns number of clusters within the "window" 
-  //--------------------------------------------------------------------
-  Int_t ncl=0;
-  for (Int_t i=fI; i<fN; i++) {
-    const AliITSclusterV2 *c=fClusters[i];
-    if (c->GetZ() > fZmax) break;
-    if (c->IsUsed()) continue;
-    const AliITSdetector &det=GetDetector(c->GetDetectorIndex());    
-    Double_t y=fR*det.GetPhi() + c->GetY();
-
-    if (y>2.*fR*TMath::Pi()) y -= 2*fR*TMath::Pi();
-    if (y>1.*fR*TMath::Pi() && fYmax<y) y -= 2*fR*TMath::Pi();
-
-    if (y<fYmin) continue;
-    if (y>fYmax) continue;
-    ncl++;
-  }
-  return ncl;
-}
-
 Bool_t 
 AliITStrackerV2::RefitAt(Double_t xx,AliITStrackV2 *t,const AliITStrackV2 *c) {
   //--------------------------------------------------------------------
@@ -1010,10 +1061,8 @@ void AliITStrackerV2::UseClusters(const AliKalmanTrack *t, Int_t from) const {
   AliTracker::UseClusters(t,from);
 
   AliITSclusterV2 *c=(AliITSclusterV2 *)GetCluster(t->GetClusterIndex(0));
-  //if (c->GetQ()>2) c->Use();
-  if (c->GetSigmaZ2()>0.1) c->Use();
+  if (c->GetSigmaZ2()>0.1) c->UnUse();
   c=(AliITSclusterV2 *)GetCluster(t->GetClusterIndex(1));
-  //if (c->GetQ()>2) c->Use();
-  if (c->GetSigmaZ2()>0.1) c->Use();
+  if (c->GetSigmaZ2()>0.1) c->UnUse();
 
 }
index 84dc746de3143739d96e96b483f3b557064f3afa..bca24192ca80bc0698dcd829cee546219181c1ee 100644 (file)
@@ -23,11 +23,14 @@ class AliITStrackerV2 : public AliTracker {
 public:
   AliITStrackerV2():AliTracker(){}
   AliITStrackerV2(const AliITSgeom *geom);
+  ~AliITStrackerV2(){}
   AliCluster *GetCluster(Int_t index) const;
-  AliITSclusterV2 *GetClusterLayer(Int_t layn, Int_t ncl) const
-                        {return fgLayers[layn].GetCluster(ncl);}
-  Int_t GetNumberOfClustersLayer(Int_t layn) const 
-                        {return fgLayers[layn].GetNumberOfClusters();}
+  AliITSclusterV2 *GetCluster(Int_t l, Int_t c) const {
+    return fgLayers[l].GetCluster(c);
+  }
+  Int_t GetNumberOfClustersLayer(Int_t n) const {
+     return fgLayers[n].GetNumberOfClusters();
+  }   
   Int_t LoadClusters(TTree *cf);
   void UnloadClusters();
   Int_t Clusters2Tracks(AliESD *event);
@@ -55,24 +58,24 @@ public:
 
   class AliITSlayer {
   public:
+    enum {kNsector=5, kMaxClusterPerSector=kMaxClusterPerLayer/kNsector};
     AliITSlayer();
     AliITSlayer(Double_t r, Double_t p, Double_t z, Int_t nl, Int_t nd);
    ~AliITSlayer();
     Int_t InsertCluster(AliITSclusterV2 *c);
     void ResetClusters();
-    void SelectClusters(Double_t zmi,Double_t zma,Double_t ymi,Double_t yma);
+    Int_t SelectClusters(Float_t zmi, Float_t zma, Float_t ymi, Float_t yma);
     const AliITSclusterV2 *GetNextCluster(Int_t &ci);
     void ResetRoad();
     Double_t GetRoad() const {return fRoad;}
     Double_t GetR() const {return fR;}
-    AliITSclusterV2 *GetCluster(Int_t i) const {return fClusters[i];
+    AliITSclusterV2 *GetCluster(Int_t i) const { return fClusters[i]; 
     AliITSdetector &GetDetector(Int_t n) const { return fDetectors[n]; }
     Int_t FindDetectorIndex(Double_t phi, Double_t z) const;
     Double_t GetThickness(Double_t y, Double_t z, Double_t &x0) const;
-    Int_t InRoad() const ;
-    Int_t GetNumberOfClusters() const {return fN;}
     Int_t GetNladders() const {return fNladders;}
     Int_t GetNdetectors() const {return fNdetectors;}
+    Int_t GetNumberOfClusters() const;
   protected:
     Double_t fR;                // mean radius of this layer
     Double_t fPhiOffset;        // offset of the first detector in Phi
@@ -80,14 +83,15 @@ public:
     Double_t fZOffset;          // offset of the first detector in Z
     Int_t fNdetectors;          // detectors/ladder
     AliITSdetector *fDetectors; // array of detectors
-    Int_t fN;                   // number of clusters
+
     AliITSclusterV2 *fClusters[kMaxClusterPerLayer]; // pointers to clusters
-    Double_t fZmax;      //    edges
-    Double_t fYmin;      //   of  the
-    Double_t fYmax;      //   "window"
-    Int_t fI;            // index of the current cluster within the "window"
-    Double_t fRoad;      // road defined by the cluster density
-    Int_t FindClusterIndex(Double_t z) const;
+    Int_t fN[kNsector];         // numbers of clusters sector by sector 
+
+    Int_t fIndex[kMaxClusterPerLayer]; // indexes of selected clusters 
+    Int_t fNsel;                       // number of selected clusters
+
+    Double_t fRoad;     // road defined by the cluster density
+    Int_t FindClusterIndex(Float_t z, Int_t s) const;
   };
 
 protected: