Code clean-up in order to improve its speed and memory use (E. Crescio)
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 24 Mar 2004 18:40:50 +0000 (18:40 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 24 Mar 2004 18:40:50 +0000 (18:40 +0000)
ITS/AliITSclusterTable.cxx
ITS/AliITSclusterTable.h
ITS/AliITStrackerSA.cxx
ITS/AliITStrackerSA.h

index 228fce2..665670b 100644 (file)
@@ -30,7 +30,7 @@
 ///////////////////////////////////////////////////////////////////////////
 
 
-#include <stdlib.h>
+// #include <stdlib.h>
 #include "AliITSclusterTable.h"
 #include "AliITSclusterV2.h"
 #include "AliITSgeom.h"
@@ -39,7 +39,6 @@
 #include<TClonesArray.h>
 #include<TTree.h>
 ClassImp(AliITSclusterTable)
-
 //__________________________________________________________
 AliITSclusterTable::AliITSclusterTable(){
 // Default constructor
@@ -79,7 +78,6 @@ AliITSclusterTable::AliITSclusterTable(AliITSgeom* geom, AliITStrackerSA* tracke
   fSyList =0;
   fSzList =0;
 }
-
 //______________________________________________________________________
 AliITSclusterTable::AliITSclusterTable(const AliITSclusterTable &tab) : 
                     TObject(tab) {
@@ -138,7 +136,6 @@ void AliITSclusterTable::FillArray(TTree* clusterTree){
   fDet = new TArrayI*[nm];
 
   TArrayI** vect = new TArrayI*[fGeom->GetNlayers()];
-  
   Int_t * firstmod = new Int_t[fGeom->GetNlayers()+1];
   firstmod[fGeom->GetNlayers()]=fGeom->GetIndexMax();  // upper limit
   for(Int_t nlayer=0;nlayer<fGeom->GetNlayers();nlayer++){
@@ -156,7 +153,6 @@ void AliITSclusterTable::FillArray(TTree* clusterTree){
   TClonesArray* clus = new TClonesArray("AliITSclusterV2",10000);
   brancht->SetAddress(&clus);
  
-  
   for(Int_t mod=0;mod<nm;mod++){
     Int_t nc=0;
     clusterTree->GetEvent(mod);
@@ -171,13 +167,12 @@ void AliITSclusterTable::FillArray(TTree* clusterTree){
     else {
       for(Int_t n=0;n<vect[nlr]->GetSize();n++){
        Int_t mm=vect[nlr]->At(n);
-       if (nc>=fDet[mod]->GetSize()) fDet[mod]->Set(nc*2+10);  
+       if(nc>=fDet[mod]->GetSize()) fDet[mod]->Set(nc*2+10);
        if(mm==mod) {(*fDet[mod])[nc]=n; nc+=1; }
       }
     }
   }
 
-
   clus->Delete();
   delete clus;
   for(Int_t n=0;n<fGeom->GetNlayers();n++)delete vect[n];
@@ -189,7 +184,6 @@ void AliITSclusterTable::FillArray(TTree* clusterTree){
 void AliITSclusterTable::FillArrayLabel(Int_t numberofparticles){
   //
 
-
   fLbl = new TArrayI*[numberofparticles];
   const Int_t knm =fGeom->GetNlayers();
   for(Int_t nlab=0;nlab<numberofparticles;nlab++){
@@ -247,16 +241,15 @@ Int_t AliITSclusterTable::FindIndex(Int_t ndim, Int_t *ptr, Int_t value){
 
 void AliITSclusterTable::FillArrayCoorAngles(){
   //Fill arrays with phi,lambda and indices of clusters for each layer
-  Info("FillArrayCoorAngles","Filling Array...");
-
   fPhiList = new TArrayD*[fGeom->GetNlayers()];
   fLambdaList = new TArrayD*[fGeom->GetNlayers()];
-  fXList = new TArrayD*[fGeom->GetNlayers()];
-  fYList = new TArrayD*[fGeom->GetNlayers()];
-  fZList = new TArrayD*[fGeom->GetNlayers()];
-  fSxList = new TArrayD*[fGeom->GetNlayers()];
-  fSyList = new TArrayD*[fGeom->GetNlayers()];
-  fSzList = new TArrayD*[fGeom->GetNlayers()];
+  fXList = new TArrayF*[fGeom->GetNlayers()];
+  fYList = new TArrayF*[fGeom->GetNlayers()];
+  fZList = new TArrayF*[fGeom->GetNlayers()];
+  fSxList = new TArrayF*[fGeom->GetNlayers()];
+  fSyList = new TArrayF*[fGeom->GetNlayers()];
+  fSzList = new TArrayF*[fGeom->GetNlayers()];
 
   Int_t * firstmod = new Int_t[fGeom->GetNlayers()+1];
   firstmod[fGeom->GetNlayers()]=fGeom->GetIndexMax();  // upper limit
@@ -266,18 +259,18 @@ void AliITSclusterTable::FillArrayCoorAngles(){
     Int_t ncl = fTracker->GetNumberOfClustersLayer(nlay);
     fPhiList[nlay] = new TArrayD(ncl);
     fLambdaList[nlay]=new TArrayD(ncl);
-    fXList[nlay]=new TArrayD(ncl);
-    fYList[nlay]=new TArrayD(ncl);
-    fZList[nlay]=new TArrayD(ncl);
-    fSxList[nlay]=new TArrayD(ncl);
-    fSyList[nlay]=new TArrayD(ncl);
-    fSzList[nlay]=new TArrayD(ncl);
+    fXList[nlay]=new TArrayF(ncl);
+    fYList[nlay]=new TArrayF(ncl);
+    fZList[nlay]=new TArrayF(ncl);
+    fSxList[nlay]=new TArrayF(ncl);
+    fSyList[nlay]=new TArrayF(ncl);
+    fSzList[nlay]=new TArrayF(ncl);
 
     for(Int_t j=0;j<ncl;j++){
       AliITSclusterV2* cl = fTracker->GetClusterLayer(nlay,j);
       Double_t phi=0;Double_t lambda=0;
-      Double_t x=0;Double_t y=0;Double_t z=0;
-      Double_t sx=0;Double_t sy=0;Double_t sz=0;
+      Float_t x=0;Float_t y=0;Float_t z=0;
+      Float_t sx=0;Float_t sy=0;Float_t sz=0;
       Int_t module = cl->GetDetectorIndex()+firstmod[nlay];
       GetCoorAngles(cl,module,phi,lambda,x,y,z);
       GetCoorErrors(cl,module,sx,sy,sz);
@@ -296,8 +289,7 @@ void AliITSclusterTable::FillArrayCoorAngles(){
   
   delete [] firstmod;
 }
-
-void AliITSclusterTable::GetCoorAngles(AliITSclusterV2* cl,Int_t module,Double_t &phi,Double_t &lambda, Double_t &x, Double_t &y,Double_t &z){
+void AliITSclusterTable::GetCoorAngles(AliITSclusterV2* cl,Int_t module,Double_t &phi,Double_t &lambda, Float_t &x, Float_t &y,Float_t &z){
   //Returns values of phi (azimuthal) and lambda angles for a given cluster
   
   Double_t rot[9];     fGeom->GetRotMatrix(module,rot);
@@ -308,8 +300,8 @@ void AliITSclusterTable::GetCoorAngles(AliITSclusterV2* cl,Int_t module,Double_t
   Double_t phi1=TMath::Pi()/2+alpha;
   if (lay==1) phi1+=TMath::Pi();
 
-  Double_t cp=TMath::Cos(phi1), sp=TMath::Sin(phi1);
-  Double_t r=tx*cp+ty*sp;
+  Float_t cp=TMath::Cos(phi1), sp=TMath::Sin(phi1);
+  Float_t r=tx*cp+ty*sp;
 
   x= r*cp - cl->GetY()*sp;
   y= r*sp + cl->GetY()*cp;
@@ -319,7 +311,7 @@ void AliITSclusterTable::GetCoorAngles(AliITSclusterV2* cl,Int_t module,Double_t
   lambda=TMath::ATan2(z-fPrimaryVertex[2],TMath::Sqrt((x-fPrimaryVertex[0])*(x-fPrimaryVertex[0])+(y-fPrimaryVertex[1])*(y-fPrimaryVertex[1])));
 }
 
-void AliITSclusterTable::GetCoorErrors(AliITSclusterV2* cl, Int_t module,Double_t &sx,Double_t &sy, Double_t &sz){
+void AliITSclusterTable::GetCoorErrors(AliITSclusterV2* cl, Int_t module,Float_t &sx,Float_t &sy, Float_t &sz){
 
   //returns x,y,z of cluster in global coordinates
 
@@ -330,9 +322,8 @@ void AliITSclusterTable::GetCoorErrors(AliITSclusterV2* cl, Int_t module,Double_
   Double_t phi=TMath::Pi()/2+alpha;
   if (lay==1) phi+=TMath::Pi();
 
-  Double_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
+  Float_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
 
   sx = TMath::Sqrt(sp*sp*cl->GetSigmaY2());
   sy = TMath::Sqrt(cp*cp*cl->GetSigmaY2());
   sz = TMath::Sqrt(cl->GetSigmaZ2());
index 6f3c6c7..ff80d59 100644 (file)
@@ -18,6 +18,7 @@
 
 #include <TArrayI.h>
 #include <TArrayD.h>
+#include <TArrayF.h>
 #include <TObject.h>
 
 class TTree;
@@ -35,8 +36,8 @@ class AliITSclusterTable : public TObject {
   void FillArray(TTree* clusterTree);
   void FillArrayLabel(Int_t numberofparticles);
   void FillArrayCoorAngles();
-  void GetCoorAngles(AliITSclusterV2* cl,Int_t module,Double_t &phi,Double_t &lambda,Double_t &x,Double_t &y,Double_t &z);
-  void GetCoorErrors(AliITSclusterV2* cl, Int_t module,Double_t &sx,Double_t &sy, Double_t &sz);
+  void GetCoorAngles(AliITSclusterV2* cl,Int_t module,Double_t &phi,Double_t &lambda,Float_t &x,Float_t &y,Float_t &z);
+  void GetCoorErrors(AliITSclusterV2* cl, Int_t module,Float_t &sx,Float_t &sy, Float_t &sz);
   virtual ~AliITSclusterTable();
 
 
@@ -47,23 +48,23 @@ class AliITSclusterTable : public TObject {
   Int_t      ThisParticleIsTrackable(Int_t label,Int_t numberofpoints=6);
   Double_t   GetPhiCluster(Int_t layer, Int_t i){return fPhiList[layer]->At(i);}
   Double_t   GetLambdaCluster(Int_t layer, Int_t i) {return fLambdaList[layer]->At(i);}
-  Double_t   GetXCluster(Int_t layer, Int_t i){return fXList[layer]->At(i);}
-  Double_t   GetYCluster(Int_t layer, Int_t i) {return fYList[layer]->At(i);}
-  Double_t   GetZCluster(Int_t layer, Int_t i) {return fZList[layer]->At(i);}
-  Double_t   GetXClusterError(Int_t layer, Int_t i) {return fSxList[layer]->At(i);}
-  Double_t   GetYClusterError(Int_t layer, Int_t i) {return fSyList[layer]->At(i);}
-  Double_t   GetZClusterError(Int_t layer, Int_t i) {return fSzList[layer]->At(i);}
+  Float_t   GetXCluster(Int_t layer, Int_t i){return fXList[layer]->At(i);}
+  Float_t   GetYCluster(Int_t layer, Int_t i) {return fYList[layer]->At(i);}
+  Float_t   GetZCluster(Int_t layer, Int_t i) {return fZList[layer]->At(i);}
+  Float_t   GetXClusterError(Int_t layer, Int_t i) {return fSxList[layer]->At(i);}
+  Float_t   GetYClusterError(Int_t layer, Int_t i) {return fSyList[layer]->At(i);}
+  Float_t   GetZClusterError(Int_t layer, Int_t i) {return fSzList[layer]->At(i);}
 
   TArrayI*   GetListOfClusters(Int_t mod) const {return fDet[mod];}
   TArrayI*   GetNClustersSameLabel(Int_t label) const {return fLbl[label];}
   TArrayD*   GetListOfPhi(Int_t layer) const {return fPhiList[layer];}
   TArrayD*   GetListOfLambda(Int_t layer) const {return fLambdaList[layer];}
-  TArrayD*   GetListOfX(Int_t layer) const {return fXList[layer];}
-  TArrayD*   GetListOfY(Int_t layer) const {return fYList[layer];}
-  TArrayD*   GetListOfZ(Int_t layer) const {return fZList[layer];}
-  TArrayD*   GetListOfSx(Int_t layer)const {return fSxList[layer];}
-  TArrayD*   GetListOfSy(Int_t layer)const {return fSyList[layer];}
-  TArrayD*   GetListOfSz(Int_t layer)const {return fSzList[layer];}
+  TArrayF*   GetListOfX(Int_t layer) const {return fXList[layer];}
+  TArrayF*   GetListOfY(Int_t layer) const {return fYList[layer];}
+  TArrayF*   GetListOfZ(Int_t layer) const {return fZList[layer];}
+  TArrayF*   GetListOfSx(Int_t layer)const {return fSxList[layer];}
+  TArrayF*   GetListOfSy(Int_t layer)const {return fSyList[layer];}
+  TArrayF*   GetListOfSz(Int_t layer)const {return fSzList[layer];}
  protected: 
 
   // copy constructor (NO copy allowed: the constructor is protected
@@ -81,12 +82,12 @@ class AliITSclusterTable : public TObject {
                            // with the same label for each label.
   TArrayD**    fPhiList;   //Array of cluster azimuthal angles on each layer
   TArrayD**    fLambdaList;//Array of cluster Lambda angles on each layer
-  TArrayD**    fXList;     //Array of cluster x coordinates on each layer
-  TArrayD**    fYList;     //Array of cluster y coordinates on each layer
-  TArrayD**    fZList;    // Array of cluster z coordinates on each layer
-  TArrayD**    fSxList;    //Array of cluster errors on x on each layer
-  TArrayD**    fSyList;    //Array of cluster errors on y on each layer
-  TArrayD**    fSzList;    //Array of cluster errors on z on each layer
+  TArrayF**    fXList;     //Array of cluster x coordinates on each layer
+  TArrayF**    fYList;     //Array of cluster y coordinates on each layer
+  TArrayF**    fZList;    // Array of cluster z coordinates on each layer
+  TArrayF**    fSxList;    //Array of cluster errors on x on each layer
+  TArrayF**    fSyList;    //Array of cluster errors on y on each layer
+  TArrayF**    fSzList;    //Array of cluster errors on z on each layer
  
   AliITSgeom *fGeom;      //! ITS geometry
   AliITStrackerSA *fTracker; //! SA tracker
index 3487d18..486769a 100644 (file)
@@ -1,3 +1,4 @@
+
 /**************************************************************************
  * Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
  *                                                                        *
@@ -20,7 +21,6 @@
 //  tracks are saved as AliITStrackV2 objects     //
 ////////////////////////////////////////////////////
 
-#include <stdlib.h>
 #include "TArrayI.h"
 #include <TBranch.h>
 #include <TMath.h>
@@ -115,8 +115,8 @@ AliITStrackerSA::AliITStrackerSA(AliITStrackerSA& tracker):AliITStrackerV2(){
   }
   fVertexer = tracker.fVertexer;
   fGeom = tracker.fGeom;
-  fFlagLoad = tracker.fFlagLoad;
   fTable = tracker.fTable;
+  fListOfTracks = tracker.fListOfTracks;
 }
 
 //____________________________________________________________________________
@@ -130,11 +130,11 @@ AliITStrackerSA::~AliITStrackerSA(){
   fVert = 0;
   fVertexer = 0;
   fGeom = 0;
-  fFlagLoad = 0;
   if(fPhiWin)delete []fPhiWin;
   if(fLambdaWin)delete []fLambdaWin;
   fTable =0;
-}
+  fListOfTracks->Delete();
+ }
 
 //____________________________________________________________________________
 void AliITStrackerSA::Init(){
@@ -151,11 +151,11 @@ void AliITStrackerSA::Init(){
     fVert = 0;
     fVertexer = 0;
     fGeom = 0;
-    fFlagLoad = 0;
     SetWindowSizes();
     fTable = 0;
     fITSclusters = 0;
     SetSixPoints();
+    fListOfTracks=new TObjArray(0,0);
 }
 //_______________________________________________________________________
 void AliITStrackerSA::ResetForFinding(){
@@ -169,6 +169,7 @@ void AliITStrackerSA::ResetForFinding(){
     fCoef3=0;
     fPointc[0]=0;
     fPointc[1]=0;
+    fListOfTracks->Delete();
 }
 //____________________________________________________________________________
 void AliITStrackerSA::FindTracks(TTree *out,Int_t evnumber){
@@ -298,7 +299,7 @@ void AliITStrackerSA::FindTracks(TTree *out,Int_t evnumber){
             AliITSclusterV2* kl = (AliITSclusterV2*)GetCluster(index);
             if(kl->IsUsed()==1) kl->Use();
           }
-          continue;
+         continue;
         }
         outrack=tr2;  
         out->Fill();
@@ -411,6 +412,7 @@ Int_t AliITStrackerSA::FindTracks(AliESD* event){
 
   // Track finder using the ESD object
 
+
   if(!fITSclusters){
     Fatal("FindTracks","ITS cluster tree is not accessed - Abort!!!\n Please use method SetClusterTree to pass the pointer to the tree\n");
     return -1;
@@ -429,10 +431,11 @@ Int_t AliITStrackerSA::FindTracks(AliESD* event){
   }
 
   //Fill array with cluster indices for each module
-  fTable = new AliITSclusterTable(fGeom,this,primaryVertex);
-  fTable->FillArray(fITSclusters);
-  fTable->FillArrayCoorAngles();
-  
+  if(!fTable){
+    fTable = new AliITSclusterTable(fGeom,this,primaryVertex);
+    fTable->FillArray(fITSclusters);
+    fTable->FillArrayCoorAngles();
+   }
 
   Int_t * firstmod = new Int_t[fGeom->GetNlayers()];
   for(Int_t i=0;i<fGeom->GetNlayers();i++){
@@ -505,19 +508,19 @@ Int_t AliITStrackerSA::FindTracks(AliESD* event){
             AliITSclusterV2* kl = (AliITSclusterV2*)GetCluster(index);
             if(kl->IsUsed()==1) kl->Use();
           }
-          continue;
+         continue;
         }
        
        AliESDtrack outtrack;
        outtrack.UpdateTrackParams(tr2,AliESDtrack::kITSin);
        event->AddTrack(&outtrack);
-        
        ntrack++;
         Int_t nct = tr2->GetNumberOfClusters();
        while(nct--){
           Int_t index = tr2->GetClusterIndex(nct);     
           AliITSclusterV2* kl = (AliITSclusterV2*)GetCluster(index);      
           if(kl->IsUsed()==0) kl->Use();
+         
         }
       } 
       else{
@@ -526,7 +529,7 @@ Int_t AliITStrackerSA::FindTracks(AliESD* event){
           Int_t index = trs->GetClusterIndexSA(nct);
           AliITSclusterV2* kl = (AliITSclusterV2*)GetCluster(index);
           if(kl->IsUsed()==1) kl->Use();
-        }
+       }
       }
       delete trs;
       delete[] nn;
@@ -583,13 +586,13 @@ Int_t AliITStrackerSA::FindTracks(AliESD* event){
               AliITSclusterV2* kl = (AliITSclusterV2*)GetCluster(index);
               if(kl->IsUsed()==1) kl->Use();
             }
+
             continue;
           }
 
          AliESDtrack outtrack;
          outtrack.UpdateTrackParams(tr2,AliESDtrack::kITSin);
          event->AddTrack(&outtrack);
-
           Int_t nct = tr2->GetNumberOfClusters();
           while(nct--){
             Int_t index = tr2->GetClusterIndex(nct);     
@@ -632,7 +635,6 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert
   for(Int_t i=0;i<fGeom->GetNlayers();i++){
     firstmod[i]=fGeom->GetModuleIndex(i+1,1,1);
   }  
-  TObjArray* listoftracks=new TObjArray(0,0);
   AliITStrackV2* otrack2;
   Int_t nclusters = tr->GetNumberOfClustersSA();
   TObjArray** listlayer = new TObjArray*[fGeom->GetNlayers()];
@@ -797,7 +799,7 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert
                 otrack2->ResetCovariance(); 
                 otrack2->ResetClusters();
                 //fit from layer 6 to layer 1
-                if(RefitAt(3.7,otrack2,ot)) listoftracks->AddLast(otrack2);
+                if(RefitAt(3.7,otrack2,ot)) fListOfTracks->AddLast(otrack2);
                               
               }       
           
@@ -821,9 +823,8 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert
 
   delete [] end;
 
-  Int_t dim=listoftracks->GetEntries();
+  Int_t dim=fListOfTracks->GetEntries();
   if(dim==0){
-    delete listoftracks;
     for(Int_t i=0;i<fGeom->GetNlayers();i++){
       delete listlayer[i];
     }
@@ -831,7 +832,7 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert
     return 0;
   }
 
-  AliITStrackV2* otrack =(AliITStrackV2*)FindTrackLowChiSquare(listoftracks,dim);
+  AliITStrackV2* otrack =(AliITStrackV2*)FindTrackLowChiSquare(fListOfTracks,dim);
 
   if(otrack==0) return 0;
   Int_t * indexc = new Int_t[fGeom->GetNlayers()];
@@ -871,7 +872,6 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert
                        cl4->GetLabel(2),labl[2],numberofpoints);
   
   otrack->SetLabel(label);  
-  delete listoftracks;
   for(Int_t i=0;i<fGeom->GetNlayers();i++){
     delete listlayer[i];
   }
@@ -882,9 +882,10 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert
 }
 
 //_______________________________________________________________________
-void AliITStrackerSA::UseFoundTracksV2(Int_t evnum,TTree* treev2, TTree* clustertree){
+void AliITStrackerSA::UseFoundTracksV2(Int_t evnum,TTree* treev2){
   // Marks as used clusters belonging to tracks found with V2 TPC+ITS tracking
   //(or AliITStrackV2 tracks found with function FindTracks of this class)
+  
 
   //Get primary vertex
   if(fVertexer){
@@ -906,9 +907,6 @@ void AliITStrackerSA::UseFoundTracksV2(Int_t evnum,TTree* treev2, TTree* cluster
     fTable->FillArray(fITSclusters);
     fTable->FillArrayCoorAngles();
   }
-  SetEventNumber(evnum);
-  if(GetFlagLoadedClusters()==0) LoadClusters(clustertree);
-  SetFlagLoadedClusters(1);
 
   TBranch* bra = (TBranch*)treev2->GetBranch("tracks");
   if(!bra) Warning("UseFoundTracksV2","No branch for track tree");
@@ -929,33 +927,20 @@ void AliITStrackerSA::UseFoundTracksV2(Int_t evnum,TTree* treev2, TTree* cluster
 }
 
 //_______________________________________________________________________
-void AliITStrackerSA::UseFoundTracksV2(Int_t evnum,AliESD *event, TTree* 
-clustertree){
+void AliITStrackerSA::UseFoundTracksV2(AliESD *event){
   // Marks as used clusters belonging to tracks found with V2 TPC+ITS tracking
 
   //Get primary vertex
-  if(fVertexer){
-    if(fVert)delete fVert;
-    fVert = fVertexer->FindVertexForCurrentEvent(evnum);
-  }
-  else {
-    gAlice->GetEvent(evnum);
-    if(!fVert){
-      Fatal("FindTracks","Vertex is missing\n");
-      return;
-    }
-  }
+
   Double_t primaryVertex[3];
-  fVert->GetXYZ(primaryVertex);
+  event->GetVertex()->GetXYZ(primaryVertex);
 
   if(!fTable){
     fTable = new AliITSclusterTable(fGeom,this,primaryVertex);
     fTable->FillArray(fITSclusters);
     fTable->FillArrayCoorAngles(); 
   }
-  SetEventNumber(evnum);
-  if(GetFlagLoadedClusters()==0) LoadClusters(clustertree);
-  SetFlagLoadedClusters(1);
+
   Int_t ntracks = event->GetNumberOfTracks();
   while (ntracks--) {
     AliESDtrack *esd=event->GetTrack(ntracks);
@@ -1012,36 +997,55 @@ Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t la
   Int_t nm[8]={0,0,0,0,0,0,0,0};
   nm[0] = lay.FindDetectorIndex(fi+phiwindow,zed);
   nm[1] = lay.FindDetectorIndex(fi-phiwindow,zed);
-  nm[2]  = lay.FindDetectorIndex(fi,zed1);
-  nm[3]  = lay.FindDetectorIndex(fi,zed2);
-  nm[4]  = lay.FindDetectorIndex(fi+phiwindow,zed1);
-  nm[5]  = lay.FindDetectorIndex(fi-phiwindow,zed1);
-  nm[6]  = lay.FindDetectorIndex(fi+phiwindow,zed2);
-  nm[7]  = lay.FindDetectorIndex(fi-phiwindow,zed2);
+  nm[2] = lay.FindDetectorIndex(fi,zed1);
+  nm[3] = lay.FindDetectorIndex(fi,zed2);
+  nm[4] = lay.FindDetectorIndex(fi+phiwindow,zed1);
+  nm[5] = lay.FindDetectorIndex(fi-phiwindow,zed1);
+  nm[6] = lay.FindDetectorIndex(fi+phiwindow,zed2);
+  nm[7] = lay.FindDetectorIndex(fi-phiwindow,zed2);
+
 
   Int_t nn=0;
   TArrayI* array =(TArrayI*)table->GetListOfClusters(nmod);
-  TArrayI* list = new TArrayI(array->GetSize());
+  TArrayI* listc = new TArrayI(array->GetSize());
   for(Int_t i=0;i<array->GetSize();i++){
     Int_t in=(Int_t)array->At(i);
-    list->AddAt(in,nn);
+    listc->AddAt(in,nn);
     nn++;
   }
   
-//  Info("SearchClusters", "layer %d, module %d", layer, nmod);
+  Int_t k=0;
+  Int_t val;
+  while(k<8){
+    for(Int_t h=k+1;h<8;h++){
+      if(nm[k]>nm[h]){
+       val=nm[k];
+       nm[k]=nm[h];
+       nm[h]=val;
+      }
+     
+   }
+    k++;
+  }
+  Int_t value=-5;
   for(Int_t ii=0;ii<8;ii++){
-    if(nm[ii]!=nmod && nm[ii]>=0){
+    if(nm[ii]!=value && nm[ii]!=nmod && nm[ii]>=0){
       TArrayI* ar =(TArrayI*)table->GetListOfClusters(nm[ii]+firstmod[layer]);
-      list->Set(list->GetSize()+ar->GetSize());
+      listc->Set(listc->GetSize()+ar->GetSize());
       for(Int_t j=0;j<ar->GetSize();j++){
-        Int_t in=(Int_t)ar->At(j);
-        list->AddAt(in,nn);
-        nn++;
+       Int_t in=(Int_t)ar->At(j);
+       listc->AddAt(in,nn);
+       nn++;
+       value=nm[ii];
       }
     }
   }
-  for(Int_t i=0;i<list->GetSize();i++){
-    Int_t index = (Int_t)list->At(i);
+  
+  for(Int_t i=0;i<listc->GetSize();i++){
+    Int_t index = (Int_t)listc->At(i);
     AliITSclusterV2* cllay = lay.GetCluster(index);
     if(cllay==0) continue;
     if(cllay->IsUsed()==1) continue;  
@@ -1052,9 +1056,9 @@ Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t la
        TMath::Abs(fPhiEstimate-phi)<phiwindow){
       nc+=1;
       fLambdac = lambda;
-      if(trs->GetNumberOfClustersSA()==20){
+      if(trs->GetNumberOfClustersSA()==15){
        delete[] firstmod;
-        delete list;
+        delete listc;
         return 0;
       }
       trs->AddClusterSA(layer,index);
@@ -1065,7 +1069,7 @@ Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t la
     }
 
   }
-  delete list;
+  delete listc;
   delete [] firstmod;
   return nc;
 
@@ -1281,24 +1285,21 @@ void AliITStrackerSA::SetWindowSizes(Int_t n, Double_t *phi, Double_t *lam){
   }
   else {  // default values
     
-    Double_t phid[40]   = {0.001,0.0015,0.002,0.0023,0.0025,0.0027,0.003,
-                          0.0033,0.0035,0.0037,0.004,0.0043,0.0045,0.0047,
+    Double_t phid[32]   = {0.002,0.003,0.004,0.0045,0.0047,
                           0.005,0.0053,0.0055,
                           0.006,0.0063,0.0065,0.007,0.0073,0.0075,0.0077,
                           0.008,0.0083,0.0085,0.0087,0.009,0.0095,0.0097,
                           0.01,0.0105,0.011,0.0115,0.012,0.0125,0.013,0.0135,
                           0.014};
-    Double_t lambdad[40] = {0.001,0.0015,0.002,0.0023,0.0025,0.0027,0.003,
-                           0.0033,0.0035,0.0037,0.004,0.0043,0.0045,0.0047,
+    Double_t lambdad[32] = {0.002,0.003,0.004,0.0045,0.0047,
                            0.005,0.0053,0.0055,
                            0.006,0.0063,0.0065,0.007,0.0073,0.0075,0.0077,
                            0.008,0.0083,0.0085,0.0087,0.009,0.0095,0.0097,
                            0.01,0.015,0.011,0.0115,0.012,0.0125,0.013,0.0135,
                            0.014};
     
-    if(fNloop!=40){
-      fNloop = 40;
-      Warning("SetWindowSizes","Number of loop forced to the default value %d",fNloop);
+    if(fNloop!=32){
+      fNloop = 32;
     }
    
     fPhiWin = new Double_t[fNloop];
index 46bd8f0..ca282c3 100644 (file)
@@ -44,8 +44,8 @@ class AliITStrackerSA : public AliITStrackerV2 {
   void SetSixPoints(Bool_t sp = kTRUE){fSixPoints = sp;}
   Bool_t GetSixPoints() const {return fSixPoints;}
   void SetWindowSizes(Int_t n=46, Double_t *phi=0, Double_t *lam=0);
-  void UseFoundTracksV2(Int_t evnum,TTree* treev2, TTree* clustertree);
-  void UseFoundTracksV2(Int_t evnum,AliESD *event, TTree* clustertree);
+  void UseFoundTracksV2(Int_t evnum,TTree* treev2);
+  void UseFoundTracksV2(AliESD *event);
 
  protected:
 
@@ -56,12 +56,8 @@ class AliITStrackerSA : public AliITStrackerV2 {
   AliITStrackerSA& operator=(const AliITStrackerSA& /* trkr */);
   //Initialization
   void Init();
-  Int_t     GetFlagLoadedClusters() const {return fFlagLoad;}
-   
-  void     ResetForFinding();
-  void     SetFlagLoadedClusters(Int_t d) {fFlagLoad=d;}
-
-  void     UpdatePoints();
+  void ResetForFinding();
+  void UpdatePoints();
 
   static Double_t Curvature(Double_t x1,Double_t y1,Double_t x2,Double_t y2,
                      Double_t x3,Double_t y3);
@@ -85,10 +81,10 @@ class AliITStrackerSA : public AliITStrackerV2 {
  
 
   Double_t fPhiEstimate; //Estimation of phi angle on next layer
-  Double_t fPoint1[2];   //! coord. of 1-st point to evaluate the curvature
-  Double_t fPoint2[2];   //! coord. of 2-nd point to evaluate the curvature
-  Double_t fPoint3[2];   //! coord. of 3-rd point to evaluate the curvature
-  Double_t fPointc[2];   //! current point coord (for curvature eval.)
+  Float_t fPoint1[2];   //! coord. of 1-st point to evaluate the curvature
+  Float_t fPoint2[2];   //! coord. of 2-nd point to evaluate the curvature
+  Float_t fPoint3[2];   //! coord. of 3-rd point to evaluate the curvature
+  Float_t fPointc[2];   //! current point coord (for curvature eval.)
   Double_t fLambdac;    //! current value of the Lambda angle in the window
   Double_t fPhic;       //! current value of the Phi angle in the window
   Float_t fCoef1;       //! param. of the equation of the circ. approx a layer
@@ -100,8 +96,8 @@ class AliITStrackerSA : public AliITStrackerV2 {
   AliESDVertex *fVert;        //! primary vertex
   AliITSVertexer *fVertexer;  //! vertexer 
   AliITSgeom *fGeom;          //! ITS geometry
+  TObjArray *fListOfTracks;   //! container for found tracks 
   TTree *fITSclusters;        //! pointer to ITS tree of clusters
-  Int_t fFlagLoad;            //  flag for loaded clusters (1==already loaded)
   Bool_t fSixPoints;          // If true 6/6 points are required (default). 5/6 otherwise
   AliITSclusterTable* fTable; //  table with clusters
   ClassDef(AliITStrackerSA,1)