X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITStrackerV2.cxx;h=44375b53cebf6210327cb5fd76b82764065a9b1c;hb=7b54ea5c7f4a049ae41d5026aba55d64b07bf6cf;hp=2e5bb19b9e4795bf8e87bd080540b2dbc82e8be3;hpb=c630aafd1da7fec82908f28924c025969497227d;p=u%2Fmrichter%2FAliRoot.git

diff --git a/ITS/AliITStrackerV2.cxx b/ITS/AliITStrackerV2.cxx
index 2e5bb19b9e4..44375b53ceb 100644
--- a/ITS/AliITStrackerV2.cxx
+++ b/ITS/AliITStrackerV2.cxx
@@ -15,25 +15,27 @@
 
 //-------------------------------------------------------------------------
 //               Implementation of the ITS tracker class
-//
+//    It reads AliITSclusterV2 clusters and creates AliITStrackV2 tracks
+//                   and fills with them the ESD
 //          Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
 //     dEdx analysis by: Boris Batyunya, JINR, Boris.Batiounia@cern.ch
 //-------------------------------------------------------------------------
 
+#include <new>
+
 #include <TFile.h>
 #include <TTree.h>
 #include <TRandom.h>
 
 #include "AliITSgeom.h"
 #include "AliITSRecPoint.h"
-#include "AliTPCtrack.h"
 #include "AliESD.h"
 #include "AliITSclusterV2.h"
 #include "AliITStrackerV2.h"
 
 ClassImp(AliITStrackerV2)
 
-AliITStrackerV2::AliITSlayer AliITStrackerV2::fLayers[kMaxLayer]; // ITS layers
+AliITStrackerV2::AliITSlayer AliITStrackerV2::fgLayers[kMaxLayer]; // ITS layers
 
 AliITStrackerV2::AliITStrackerV2(const AliITSgeom *geom) : AliTracker() {
   //--------------------------------------------------------------------
@@ -41,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);
@@ -60,18 +61,24 @@ AliITStrackerV2::AliITStrackerV2(const AliITSgeom *geom) : AliTracker() {
     r += TMath::Sqrt(x*x + y*y);
     r*=0.25;
 
-    new (fLayers+i-1) AliITSlayer(r,poff,zoff,nlad,ndet);
+    new (fgLayers+i-1) AliITSlayer(r,poff,zoff,nlad,ndet);
 
     for (Int_t j=1; j<nlad+1; j++) {
       for (Int_t k=1; k<ndet+1; k++) { //Fill this layer with detectors
         Float_t x,y,zshift; g->GetTrans(i,j,k,x,y,zshift); 
         Double_t rot[9]; g->GetRotMatrix(i,j,k,rot);
 
-        Double_t r =-x*rot[1] + y*rot[0];         if (i==1) r=-r;
-        Double_t phi=TMath::ATan2(rot[1],rot[0]); if (i==1) phi-=3.1415927;
-        phi+=0.5*TMath::Pi(); if (phi<0) phi += 2*TMath::Pi();
-        AliITSdetector &det=fLayers[i-1].GetDetector((j-1)*ndet + k-1); 
+        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;
 
+        AliITSdetector &det=fgLayers[i-1].GetDetector((j-1)*ndet + k-1); 
         new(&det) AliITSdetector(r,phi); 
       } 
     }  
@@ -113,18 +120,28 @@ Int_t AliITStrackerV2::LoadClusters(TTree *cTree) {
 
   Int_t j=0;
   for (Int_t i=0; i<kMaxLayer; i++) {
-    Int_t ndet=fLayers[i].GetNdetectors();
-    Int_t jmax = j + fLayers[i].GetNladders()*ndet;
+    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);
-        fLayers[i].InsertCluster(new AliITSclusterV2(*c));
+
+        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();
     }
-    fLayers[i].ResetRoad(); //road defined by the cluster density
+    fgLayers[i].ResetRoad(); //road defined by the cluster density
   }
 
   return 0;
@@ -134,7 +151,7 @@ void AliITStrackerV2::UnloadClusters() {
   //--------------------------------------------------------------------
   //This function unloads ITS clusters
   //--------------------------------------------------------------------
-  for (Int_t i=0; i<kMaxLayer; i++) fLayers[i].ResetClusters();
+  for (Int_t i=0; i<kMaxLayer; i++) fgLayers[i].ResetClusters();
 }
 
 static Int_t CorrectForDeadZoneMaterial(AliITStrackV2 *t) {
@@ -162,7 +179,7 @@ static Int_t CorrectForDeadZoneMaterial(AliITStrackV2 *t) {
      //Double_t x,y,z; t->GetGlobalXYZat(rr,x,y,z);
      //if (TMath::Abs(y)<yyr) t->PropagateTo(rr,-dr,x0r); 
      if (!t->PropagateTo(rcd,-dcd,x0cd)) return 1;
-     if (!t->PropagateTo(riw,-diw,x0iw)) return 1;
+     if (!t->PropagateTo(riw+0.001,-diw,x0iw)) return 1;
   } else {
   ::Error("CorrectForDeadZoneMaterial","track is already in the dead zone !");
     return 1;
@@ -184,7 +201,9 @@ Int_t AliITStrackerV2::Clusters2Tracks(AliESD *event) {
     while (nentr--) {
       AliESDtrack *esd=event->GetTrack(nentr);
 
-      if (esd->GetStatus() != AliESDtrack::kTPCin) continue;
+      if ((esd->GetStatus()&AliESDtrack::kTPCin)==0) continue;
+      if (esd->GetStatus()&AliESDtrack::kTPCout) continue;
+      if (esd->GetStatus()&AliESDtrack::kITSin) continue;
 
       AliITStrackV2 *t=0;
       try {
@@ -194,7 +213,10 @@ Int_t AliITStrackerV2::Clusters2Tracks(AliESD *event) {
         delete t;
         continue;
       }
-      if (TMath::Abs(t->GetD())>4) continue;
+      if (TMath::Abs(t->GetD())>4) {
+	delete t;
+	continue;
+      }
 
       if (CorrectForDeadZoneMaterial(t)!=0) {
          Warning("Clusters2Tracks",
@@ -249,95 +271,6 @@ Int_t AliITStrackerV2::Clusters2Tracks(AliESD *event) {
   return 0;
 }
 
-Int_t AliITStrackerV2::Clusters2Tracks(TTree *tpcTree, TTree *itsTree) {
-  //--------------------------------------------------------------------
-  // This functions reconstructs ITS tracks
-  // The clusters must be already loaded !
-  //--------------------------------------------------------------------
-  Int_t nentr=0; TObjArray itsTracks(15000);
-
-  {/* Read TPC tracks */ 
-    AliTPCtrack *itrack=new AliTPCtrack; 
-    TBranch *branch=tpcTree->GetBranch("tracks");
-    if (!branch) {
-       Error("Clusters2Tracks","Can't get the branch !");
-       return 1;
-    }
-    tpcTree->SetBranchAddress("tracks",&itrack);
-    nentr=(Int_t)tpcTree->GetEntries();
-
-    Info("Clusters2Tracks","Number of TPC tracks: %d\n",nentr);
-
-    for (Int_t i=0; i<nentr; i++) {
-       tpcTree->GetEvent(i);
-       AliITStrackV2 *t=0;
-       try {
-           t=new AliITStrackV2(*itrack);
-       } catch (const Char_t *msg) {
-           Warning("Clusters2Tracks",msg);
-           delete t;
-           continue;
-       }
-       if (TMath::Abs(t->GetD())>4) continue;
-
-       if (CorrectForDeadZoneMaterial(t)!=0) {
-	 Warning("Clusters2Tracks",
-                 "failed to correct for the material in the dead zone !\n");
-         continue;
-       }
-
-       itsTracks.AddLast(t);
-    }
-    delete itrack;
-  }
-  itsTracks.Sort();
-  nentr=itsTracks.GetEntriesFast();
-
-
-  AliITStrackV2 *otrack=&fBestTrack;
-  TBranch *branch=itsTree->GetBranch("tracks");
-  if (!branch) itsTree->Branch("tracks","AliITStrackV2",&otrack,32000,3);
-  else branch->SetAddress(&otrack);
-
-  for (fPass=0; fPass<2; fPass++) {
-     Int_t &constraint=fConstraint[fPass]; if (constraint<0) continue;
-     for (Int_t i=0; i<nentr; i++) {
-       AliITStrackV2 *t=(AliITStrackV2*)itsTracks.UncheckedAt(i);
-       if (t==0) continue;           //this track has been already tracked
-       Int_t tpcLabel=t->GetLabel(); //save the TPC track label
-
-       ResetTrackToFollow(*t);
-       ResetBestTrack();
-
-       for (FollowProlongation(); fI<kMaxLayer; fI++) {
-          while (TakeNextProlongation()) FollowProlongation();
-       }
-
-       if (fBestTrack.GetNumberOfClusters() == 0) continue;
-
-       if (fConstraint[fPass]) {
-          ResetTrackToFollow(*t);
-	  if (!RefitAt(3.7, &fTrackToFollow, &fBestTrack)) continue;
-          ResetBestTrack();
-       }
-
-       fBestTrack.SetLabel(tpcLabel);
-       fBestTrack.CookdEdx();
-       CookLabel(&fBestTrack,0.); //For comparison only
-       itsTree->Fill();
-       UseClusters(&fBestTrack);
-       delete itsTracks.RemoveAt(i);
-     }
-  }
-
-  nentr=(Int_t)itsTree->GetEntries();
-  Info("Clusters2Tracks","Number of prolonged tracks: %d\n",nentr);
-
-  itsTracks.Delete();
-
-  return 0;
-}
-
 Int_t AliITStrackerV2::PropagateBack(AliESD *event) {
   //--------------------------------------------------------------------
   // This functions propagates reconstructed ITS tracks back
@@ -350,7 +283,8 @@ Int_t AliITStrackerV2::PropagateBack(AliESD *event) {
   for (Int_t i=0; i<nentr; i++) {
      AliESDtrack *esd=event->GetTrack(i);
 
-     if (esd->GetStatus()!=(AliESDtrack::kTPCin|AliESDtrack::kITSin)) continue;
+     if ((esd->GetStatus()&AliESDtrack::kITSin)==0) continue;
+     if (esd->GetStatus()&AliESDtrack::kITSout) continue;
 
      AliITStrackV2 *t=0;
      try {
@@ -364,12 +298,13 @@ Int_t AliITStrackerV2::PropagateBack(AliESD *event) {
      ResetTrackToFollow(*t);
 
      // propagete to vertex [SR, GSI 17.02.2003]
-     fTrackToFollow.PropagateTo(3.,0.0028,65.19);
-     fTrackToFollow.PropagateToVertex();
-
-     // Start Time measurement [SR, GSI 17.02.2003]
-     fTrackToFollow.StartTimeIntegral();
-     fTrackToFollow.PropagateTo(3.,-0.0028,65.19);
+     // Start Time measurement [SR, GSI 17.02.2003], corrected by I.Belikov
+     if (fTrackToFollow.PropagateTo(3.,0.0028,65.19)) {
+       if (fTrackToFollow.PropagateToVertex()) {
+          fTrackToFollow.StartTimeIntegral();
+       }
+       fTrackToFollow.PropagateTo(3.,-0.0028,65.19);
+     }
 
      fTrackToFollow.ResetCovariance(); fTrackToFollow.ResetClusters();
      if (RefitAt(49.,&fTrackToFollow,t)) {
@@ -380,7 +315,7 @@ Int_t AliITStrackerV2::PropagateBack(AliESD *event) {
           continue;
         }
         fTrackToFollow.SetLabel(t->GetLabel());
-        fTrackToFollow.CookdEdx();
+        //fTrackToFollow.CookdEdx();
         CookLabel(&fTrackToFollow,0.); //For comparison only
         fTrackToFollow.UpdateESDtrack(AliESDtrack::kITSout);
         UseClusters(&fTrackToFollow);
@@ -394,94 +329,6 @@ Int_t AliITStrackerV2::PropagateBack(AliESD *event) {
   return 0;
 }
 
-Int_t AliITStrackerV2::PropagateBack(TTree *inp, TTree *out) {
-  //--------------------------------------------------------------------
-  //This functions propagates reconstructed ITS tracks back
-  //--------------------------------------------------------------------
-  Error("PropagateBack","This method is not converted to NewIO yet\n");
-  return 1;
-  /*
-  TFile *in=(TFile*)inp;
-  TDirectory *savedir=gDirectory; 
-
-  if (LoadClusters()!=0) return 1;
-
-  if (!in->IsOpen()) {
-    Error("PropagateBack","file with ITS tracks is not open !\n");
-    return 1;
-  }
-
-  if (!out->IsOpen()) {
-  Error("PropagateBack","file for back propagated ITS tracks is not open !\n");
-  return 2;
-  }
-
-  in->cd();
-
-  Char_t tname[100];
-  sprintf(tname,"TreeT_ITS_%d",GetEventNumber());
-  TTree *itsTree=(TTree*)in->Get(tname);
-  if (!itsTree) {
-    Error("PropagateBack","can't get a tree with ITS tracks !\n");
-    return 3;
-  }
-  AliITStrackV2 *itrack=new AliITStrackV2; 
-  itsTree->SetBranchAddress("tracks",&itrack);
-
-  out->cd();
-
-  sprintf(tname,"TreeT_ITSb_%d",GetEventNumber());
-  TTree backTree(tname,"Tree with back propagated ITS tracks");
-  AliTPCtrack *otrack=0;
-  backTree.Branch("tracks","AliTPCtrack",&otrack,32000,2);
-
-  Int_t nentr=(Int_t)itsTree->GetEntries();
-  Int_t i;
-  for (i=0; i<nentr; i++) {
-    itsTree->GetEvent(i);
-    Int_t itsLabel=itrack->GetLabel(); //save the ITS track label
-    ResetTrackToFollow(*itrack);
-
-    // propagete to vertex [SR, GSI 17.02.2003]
-    fTrackToFollow.PropagateTo(3.,0.0028,65.19);
-    fTrackToFollow.PropagateToVertex();
-
-    // Start Time measurement [SR, GSI 17.02.2003]
-    fTrackToFollow.StartTimeIntegral();
-    fTrackToFollow.PropagateTo(3.,-0.0028,65.19);
-    //
-
-    fTrackToFollow.ResetCovariance(); fTrackToFollow.ResetClusters();
-    if (!RefitAt(49.,&fTrackToFollow,itrack)) continue;
-
-    if (CorrectForDeadZoneMaterial(&fTrackToFollow)!=0) {
-       Warning("PropagateBack",
-               "failed to correct for the material in the dead zone !\n");
-       continue;
-    }
-   
-    fTrackToFollow.SetLabel(itsLabel);
-    otrack=new AliTPCtrack(fTrackToFollow,fTrackToFollow.GetAlpha()); 
-    backTree.Fill(); delete otrack;
-    UseClusters(&fTrackToFollow);
-  }
-  i=(Int_t)backTree.GetEntries();
-  backTree.Write();
-
-  Info("PropagateBack","Number of ITS tracks: %d\n",nentr);
-  Info("PropagateBack","Number of back propagated ITS tracks: %d\n",i);
-
-  delete itrack;
-  delete itsTree; //Thanks to Mariana Bondila
-
-  UnloadClusters();
-
-  savedir->cd();
-
-  return 0;
-  */
-}
-
 Int_t AliITStrackerV2::RefitInward(AliESD *event) {
   //--------------------------------------------------------------------
   // This functions refits ITS tracks using the 
@@ -495,10 +342,10 @@ Int_t AliITStrackerV2::RefitInward(AliESD *event) {
   for (Int_t i=0; i<nentr; i++) {
     AliESDtrack *esd=event->GetTrack(i);
 
-    ULong_t flags = AliESDtrack::kITSin | AliESDtrack::kTPCrefit;
-
-    if ( (esd->GetStatus() & flags) != flags ) continue;
-    if ( esd->GetStatus() & AliESDtrack::kITSrefit) continue;
+    if ((esd->GetStatus()&AliESDtrack::kITSout) == 0) continue;
+    if (esd->GetStatus()&AliESDtrack::kITSrefit) continue;
+    if (esd->GetStatus()&AliESDtrack::kTPCout)
+    if ((esd->GetStatus()&AliESDtrack::kTPCrefit)==0) continue;
 
     AliITStrackV2 *t=0;
     try {
@@ -524,9 +371,40 @@ Int_t AliITStrackerV2::RefitInward(AliESD *event) {
        fTrackToFollow.SetLabel(t->GetLabel());
        fTrackToFollow.CookdEdx();
        CookLabel(&fTrackToFollow,0.); //For comparison only
-       fTrackToFollow.UpdateESDtrack(AliESDtrack::kITSrefit);
-       UseClusters(&fTrackToFollow);
-       ntrk++;
+
+       if (fTrackToFollow.PropagateTo(3.,0.0028,65.19)) {//The beam pipe    
+         Double_t a=fTrackToFollow.GetAlpha();
+         Double_t cs=TMath::Cos(a),sn=TMath::Sin(a);
+         Double_t xv= GetX()*cs + GetY()*sn;
+         Double_t yv=-GetX()*sn + GetY()*cs;
+         
+         Double_t c=fTrackToFollow.GetC(), snp=fTrackToFollow.GetSnp();
+         Double_t x=fTrackToFollow.GetX(), y=fTrackToFollow.GetY();
+         Double_t tgfv=-(c*(x-xv)-snp)/(c*(y-yv) + TMath::Sqrt(1.-snp*snp));
+         Double_t fv=TMath::ATan(tgfv);
+
+         cs=TMath::Cos(fv); sn=TMath::Sin(fv);
+         x = xv*cs + yv*sn;
+         yv=-xv*sn + yv*cs; xv=x;
+
+	 if (fTrackToFollow.Propagate(fv+a,xv)) {
+            fTrackToFollow.UpdateESDtrack(AliESDtrack::kITSrefit);
+            Float_t d=fTrackToFollow.GetD(GetX(),GetY());
+            Float_t z=fTrackToFollow.GetZ()-GetZ();
+            fTrackToFollow.GetESDtrack()->SetImpactParameters(d,z);
+            UseClusters(&fTrackToFollow);
+            {
+            AliITSclusterV2 c; c.SetY(yv); c.SetZ(GetZ());
+            c.SetSigmaY2(GetSigmaY()*GetSigmaY());
+            c.SetSigmaZ2(GetSigmaZ()*GetSigmaZ());
+            Double_t chi2=fTrackToFollow.GetPredictedChi2(&c);
+            if (chi2<kMaxChi2)
+	       if (fTrackToFollow.Update(&c,-chi2,0))
+                   fTrackToFollow.SetConstrainedESDtrack(chi2);            
+            }
+            ntrk++;
+         }
+       }
     }
     delete t;
   }
@@ -536,151 +414,13 @@ Int_t AliITStrackerV2::RefitInward(AliESD *event) {
   return 0;
 }
 
-Int_t AliITStrackerV2::RefitInward(TTree *in, TTree *out) {
-  //--------------------------------------------------------------------
-  // This functions refits ITS tracks using the 
-  // "inward propagated" TPC tracks
-  //--------------------------------------------------------------------
-  Error("RefitInward","This method is not converted to NewIO yet\n");
-  return 1;
-  /*
-  TFile *in=(TFile*)inp;
-  TDirectory *savedir=gDirectory; 
-
-  if (LoadClusters()!=0) return 1;
-
-  if (!inSeeds->IsOpen()) {
-    Error("RefitInward","file with inward TPC tracks is not open !\n");
-    return 2;
-  }
-
-  if (!in->IsOpen()) {
-    Error("RefitInward","file with ITS tracks is not open !\n");
-    return 2;
-  }
-
-  if (!out->IsOpen()) {
-    Error("RefitInward","file for inward ITS tracks is not open !\n");
-    return 3;
-  }
-
-  Int_t i;
-
-  //LUT used for the track matching (S.Radomski's idea)
-  const Int_t nLab = 400000; // limit on the number of track labels
-  Int_t lut[nLab];
-  for(i=0; i<nLab; i++) lut[i] = -1;
-
-  Char_t tname[100];
-
-  TObjArray itsTracks(15000);
-  {// Read the ITS tracks  
-    sprintf(tname,"TreeT_ITS_%d",GetEventNumber());
-    TTree *itsTree=(TTree*)in->Get(tname);
-    if (!itsTree) {
-      Error("RefitInward","can't get a tree with ITS tracks !\n");
-      return 3;
-    }
-    AliITStrackV2 *itrack=new AliITStrackV2; 
-    itsTree->SetBranchAddress("tracks",&itrack);
-    Int_t nits=(Int_t)itsTree->GetEntries();
-
-    Info("RefitInward","Number of ITS tracks: %d\n",nits);
-
-    for (Int_t i=0; i<nits; i++) {
-       itsTree->GetEvent(i);
-       Int_t lab=TMath::Abs(itrack->GetLabel());
-       if (lab < nLab) {
-         if (lut[lab]>=0) Warning("RefitInward","double track %d\n",lab);
-         lut[lab]=i;
-       } else {
-         Warning("RefitInward","Too big ITS track label: %d\n!",lab);
-         continue;
-       } 
-       itsTracks.AddLast(new AliITStrackV2(*itrack));
-    }
-    delete itsTree;
-    delete itrack;
-  }
-
-  //Get the input seeds tree
-  inSeeds->cd();
-  sprintf(tname,"tracksTPC_%d",GetEventNumber());
-  TTree *tpcTree=(TTree*)inSeeds->Get(tname);
-  if (!tpcTree) {
-     Error("RefitInward","can't get a tree with TPC tracks !\n");
-     return 3;
-  }
-  AliTPCtrack *itrack=new AliTPCtrack; 
-  tpcTree->SetBranchAddress("tracks",&itrack);
-  Int_t ntpc=(Int_t)tpcTree->GetEntries();
-
-  Info("RefitInward","Number of TPC tracks: %d\n",ntpc);
-
-  //Create the output tree
-  out->cd();
-  sprintf(tname,"TreeT_ITSinward_%d",GetEventNumber());
-  TTree outTree(tname,"Tree with inward refitted ITS tracks");
-  AliITStrackV2 *otrack=0;
-  outTree.Branch("tracks","AliITStrackV2",&otrack,32000,0);
-
-  for (i=0; i<ntpc; i++) {
-    tpcTree->GetEvent(i);
-    try {
-      otrack=new AliITStrackV2(*itrack);
-    } catch (const Char_t *msg) {
-      Warning("RefitInward",msg);
-      delete otrack;
-      continue;
-    }
-    //check if this track was reconstructed in the ITS
-    Int_t lab=TMath::Abs(otrack->GetLabel());
-    if (lab >= nLab) {
-      Warning("RefitInward","Too big TPC track label: %d\n!",lab); 
-      continue;
-    }
-    Int_t idx=lut[lab];
-    if (idx<0) continue; //no prolongation in the ITS for this track
-    
-    if (CorrectForDeadZoneMaterial(otrack)!=0) {
-       Warning("RefitInward",
-               "failed to correct for the material in the dead zone !\n");
-       continue;
-    }
-
-    //Refitting...
-    {
-    AliITStrackV2 *ctrack=(AliITStrackV2*)itsTracks.UncheckedAt(idx);
-    if (!RefitAt(3.7, otrack, ctrack)) continue;
-    }
-    otrack->SetLabel(itrack->GetLabel()); //For comparison only
-    otrack->CookdEdx();
-    CookLabel(otrack,0.); //For comparison only
-    outTree.Fill();
-    delete otrack;
-  }
-  i=(Int_t)outTree.GetEntries();
-  Info("RefitInward","Number of inward refitted ITS tracks: %d\n",i);
-  outTree.Write();
-
-  delete tpcTree;
-  delete itrack;
-  UnloadClusters();
-  itsTracks.Delete();
-
-  savedir->cd();
-
-  return 0;
-  */
-}
-
 AliCluster *AliITStrackerV2::GetCluster(Int_t index) const {
   //--------------------------------------------------------------------
   //       Return pointer to a given cluster
   //--------------------------------------------------------------------
   Int_t l=(index & 0xf0000000) >> 28;
   Int_t c=(index & 0x0fffffff) >> 00;
-  return fLayers[l].GetCluster(c);
+  return fgLayers[l].GetCluster(c);
 }
 
 
@@ -691,13 +431,13 @@ void AliITStrackerV2::FollowProlongation() {
   while (fI>fLastLayerToTrackTo) {
     Int_t i=fI-1;
 
-    AliITSlayer &layer=fLayers[i];
+    AliITSlayer &layer=fgLayers[i];
     AliITStrackV2 &track=fTracks[i];
 
     Double_t r=layer.GetR();
 
     if (i==3 || i==1) {
-       Double_t rs=0.5*(fLayers[i+1].GetR() + r);
+       Double_t rs=0.5*(fgLayers[i+1].GetR() + r);
        Double_t d=0.0034, x0=38.6;
        if (i==1) {rs=9.; d=0.0097; x0=42;}
        if (!fTrackToFollow.PropagateTo(rs,d,x0)) {
@@ -713,6 +453,7 @@ void AliITStrackerV2::FollowProlongation() {
       return;
     }
     Double_t phi=TMath::ATan2(y,x);
+
     Int_t idet=layer.FindDetectorIndex(phi,z);
     if (idet<0) {
       //Warning("FollowProlongation","failed to find a detector !\n");
@@ -754,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;
 
@@ -788,7 +530,7 @@ Int_t AliITStrackerV2::TakeNextProlongation() {
   //
   //  dEdx analysis by: Boris Batyunya, JINR, Boris.Batiounia@cern.ch 
   //--------------------------------------------------------------------
-  AliITSlayer &layer=fLayers[fI];
+  AliITSlayer &layer=fgLayers[fI];
   ResetTrackToFollow(fTracks[fI]);
 
   Double_t dz=7*TMath::Sqrt(fTrackToFollow.GetSigmaZ2() + kSigmaZ2[fI]);
@@ -800,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();
 
@@ -818,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;
   }
@@ -833,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;
@@ -856,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::
@@ -869,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
 }
@@ -880,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() {
@@ -897,37 +655,57 @@ 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);
+  if (sec>=kNsector) {
+     ::Error("InsertCluster","Wrong sector !\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++;
-
+  Int_t &n=fN[sec];
+  if (n>=kMaxClusterPerSector) {
+     ::Error("InsertCluster","Too many clusters !\n");
+     return 1;
+  }
+  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; 
@@ -935,48 +713,75 @@ 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 (i1==kNsector) i1--;
+    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==kNsector) i2--;
+    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
   //--------------------------------------------------------------------
-  Double_t dphi=phi-fPhiOffset;
+  Double_t dphi=-(phi-fPhiOffset);
   if      (dphi <  0) dphi += 2*TMath::Pi();
   else if (dphi >= 2*TMath::Pi()) dphi -= 2*TMath::Pi();
   Int_t np=Int_t(dphi*fNladders*0.5/TMath::Pi()+0.5);
@@ -1101,10 +906,10 @@ Double_t AliITStrackerV2::GetEffectiveThickness(Double_t y,Double_t z) const
   Double_t d=0.0028*3*3; //beam pipe
   Double_t x0=0;
 
-  Double_t xn=fLayers[fI].GetR();
+  Double_t xn=fgLayers[fI].GetR();
   for (Int_t i=0; i<fI; i++) {
-    Double_t xi=fLayers[i].GetR();
-    d+=fLayers[i].GetThickness(y,z,x0)*xi*xi;
+    Double_t xi=fgLayers[i].GetR();
+    d+=fgLayers[i].GetThickness(y,z,x0)*xi*xi;
   }
 
   if (fI>1) {
@@ -1113,35 +918,13 @@ Double_t AliITStrackerV2::GetEffectiveThickness(Double_t y,Double_t z) const
   }
 
   if (fI>3) {
-    Double_t xi=0.5*(fLayers[3].GetR()+fLayers[4].GetR());
+    Double_t xi=0.5*(fgLayers[3].GetR()+fgLayers[4].GetR());
     d+=0.0034*xi*xi;
   }
 
   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) {
   //--------------------------------------------------------------------
@@ -1167,13 +950,13 @@ AliITStrackerV2::RefitAt(Double_t xx,AliITStrackV2 *t,const AliITStrackV2 *c) {
   }
 
   for (Int_t i=from; i != to; i += step) {
-     AliITSlayer &layer=fLayers[i];
+     AliITSlayer &layer=fgLayers[i];
      Double_t r=layer.GetR();
  
      {
      Double_t hI=i-0.5*step; 
      if (TMath::Abs(hI-1.5)<0.01 || TMath::Abs(hI-3.5)<0.01) {             
-        Double_t rs=0.5*(fLayers[i-step].GetR() + r);
+        Double_t rs=0.5*(fgLayers[i-step].GetR() + r);
         Double_t d=0.0034, x0=38.6; 
         if (TMath::Abs(hI-1.5)<0.01) {rs=9.; d=0.0097; x0=42;}
         if (!t->PropagateTo(rs,-step*d,x0)) {
@@ -1282,10 +1065,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 && 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 && c->GetSigmaZ2()>0.1) c->UnUse();
 
 }