ITS/AliITStrackerSA.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 ////////////////////////////////////////////////////
  19 //  Stand alone tracker class                     //
  20 //  Origin:  Elisabetta Crescio                   //
  21 //  e-mail:  crescio@to.infn.it                   //
  22 //  tracks are saved as AliITStrackV2 objects     //
  23 ////////////////////////////////////////////////////
  24
  25 #include <stdlib.h>
  26
  27 #include <TArrayI.h>
  28 #include <TBranch.h>
  29 #include <TObjArray.h>
  30 #include <TTree.h>
  31
  32 #include "AliESDEvent.h"
  33 #include "AliESDVertex.h"
  34 #include "AliESDtrack.h"
  35 #include "AliITSVertexer.h"
  36 #include "AliITSclusterTable.h"
  37 #include "AliITSRecPoint.h"
  38 #include "AliITSgeomTGeo.h"
  39 #include "AliITStrackSA.h"
  40 #include "AliITStrackerSA.h"
  41 #include "AliITSReconstructor.h"
  42 #include "AliLog.h"
  43 #include "AliRun.h"
  44
  45 ClassImp(AliITStrackerSA)
  46
  47 //____________________________________________________________________________
  48 AliITStrackerSA::AliITStrackerSA():AliITStrackerMI(),
  49 fPhiEstimate(0),
  50 fITSStandAlone(0),
  51 fLambdac(0),
  52 fPhic(0),
  53 fCoef1(0),
  54 fCoef2(0),
  55 fCoef3(0),
  56 fNloop(0),
  57 fPhiWin(0),
  58 fLambdaWin(0),
  59 fVert(0),
  60 fVertexer(0),
  61 fListOfTracks(0),
  62 fListOfSATracks(0),
  63 fITSclusters(0),
  64 fInwardFlag(0),
  65 fOuterStartLayer(0),
  66 fInnerStartLayer(5),
  67 fMinNPoints(0),
  68 fMinQ(0.),
  69 fCluLayer(0),
  70 fCluCoord(0){
  71   // Default constructor
  72   Init();
  73
  74 }
  75 //____________________________________________________________________________
  76 AliITStrackerSA::AliITStrackerSA(const Char_t *geom):AliITStrackerMI(0),
  77 fPhiEstimate(0),
  78 fITSStandAlone(0),
  79 fLambdac(0),
  80 fPhic(0),
  81 fCoef1(0),
  82 fCoef2(0),
  83 fCoef3(0),
  84 fNloop(0),
  85 fPhiWin(0),
  86 fLambdaWin(0),
  87 fVert(0),
  88 fVertexer(0),
  89 fListOfTracks(0),
  90 fListOfSATracks(0),
  91 fITSclusters(0),
  92 fInwardFlag(0),
  93 fOuterStartLayer(0),
  94 fInnerStartLayer(5),
  95 fMinNPoints(0),
  96 fMinQ(0.),
  97 fCluLayer(0),
  98 fCluCoord(0)
  99 {
 100   // Standard constructor (Vertex is known and passed to this obj.)
 101   if (geom) {
 102     AliWarning("\"geom\" is actually a dummy argument !");
 103   }
 104
 105   Init();
 106   fVert = 0;
 107
 108 }
 109
 110 //____________________________________________________________________________
 111 AliITStrackerSA::AliITStrackerSA(const Char_t *geom, AliESDVertex *vert):AliITStrackerMI(0),
 112 fPhiEstimate(0),
 113 fITSStandAlone(0),
 114 fLambdac(0),
 115 fPhic(0),
 116 fCoef1(0),
 117 fCoef2(0),
 118 fCoef3(0),
 119 fNloop(0),
 120 fPhiWin(0),
 121 fLambdaWin(0),
 122 fVert(vert),
 123 fVertexer(0),
 124 fListOfTracks(0),
 125 fListOfSATracks(0),
 126 fITSclusters(0),
 127 fInwardFlag(0),
 128 fOuterStartLayer(0),
 129 fInnerStartLayer(5),
 130 fMinNPoints(0),
 131 fMinQ(0.),
 132 fCluLayer(0),
 133 fCluCoord(0)
 134 {
 135   // Standard constructor (Vertex is known and passed to this obj.)
 136   if (geom) {
 137     AliWarning("\"geom\" is actually a dummy argument !");
 138   }
 139   Init();
 140
 141 }
 142
 143 //____________________________________________________________________________
 144 AliITStrackerSA::AliITStrackerSA(const Char_t *geom, AliITSVertexer *vertexer):AliITStrackerMI(0),
 145 fPhiEstimate(0),
 146 fITSStandAlone(0),
 147 fLambdac(0),
 148 fPhic(0),
 149 fCoef1(0),
 150 fCoef2(0),
 151 fCoef3(0),
 152 fNloop(0),
 153 fPhiWin(0),
 154 fLambdaWin(0),
 155 fVert(),
 156 fVertexer(vertexer),
 157 fListOfTracks(0),
 158 fListOfSATracks(0),
 159 fITSclusters(0),
 160 fInwardFlag(0),
 161 fOuterStartLayer(0),
 162 fInnerStartLayer(5),
 163 fMinNPoints(0),
 164 fMinQ(0.),
 165 fCluLayer(0),
 166 fCluCoord(0)
 167 {
 168   // Standard constructor (Vertex is unknown - vertexer is passed to this obj)
 169   if (geom) {
 170     AliWarning("\"geom\" is actually a dummy argument !");
 171   }
 172   Init();
 173   fVertexer = vertexer;
 174
 175 }
 176
 177 //____________________________________________________________________________
 178 AliITStrackerSA::AliITStrackerSA(const AliITStrackerSA& tracker):AliITStrackerMI(),
 179 fPhiEstimate(tracker.fPhiEstimate),
 180 fITSStandAlone(tracker.fITSStandAlone),
 181 fLambdac(tracker.fLambdac),
 182 fPhic(tracker.fPhic),
 183 fCoef1(tracker.fCoef1),
 184 fCoef2(tracker.fCoef2),
 185 fCoef3(tracker.fCoef3),
 186 fNloop(tracker.fNloop),
 187 fPhiWin(tracker.fPhiWin),
 188 fLambdaWin(tracker.fLambdaWin),
 189 fVert(tracker.fVert),
 190 fVertexer(tracker.fVertexer),
 191 fListOfTracks(tracker.fListOfTracks),
 192 fListOfSATracks(tracker.fListOfSATracks),
 193 fITSclusters(tracker.fITSclusters),
 194 fInwardFlag(tracker.fInwardFlag),
 195 fOuterStartLayer(tracker.fOuterStartLayer),
 196 fInnerStartLayer(tracker.fInnerStartLayer),
 197 fMinNPoints(tracker.fMinNPoints),
 198 fMinQ(tracker.fMinQ),
 199 fCluLayer(tracker.fCluLayer),
 200 fCluCoord(tracker.fCluCoord) {
 201   // Copy constructor
 202   for(Int_t i=0;i<2;i++){
 203     fPoint1[i]=tracker.fPoint1[i];
 204     fPoint2[i]=tracker.fPoint2[i];
 205     fPoint3[i]=tracker.fPoint3[i];
 206     fPointc[i]=tracker.fPointc[i];
 207   }
 208   if(tracker.fVertexer && tracker.fVert){
 209     fVert = new AliESDVertex(*tracker.fVert);
 210   }
 211   else {
 212     fVert = tracker.fVert;
 213   }
 214   for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
 215     fCluLayer[i] = tracker.fCluLayer[i];
 216     fCluCoord[i] = tracker.fCluCoord[i];
 217   }
 218 }
 219 //______________________________________________________________________
 220 AliITStrackerSA& AliITStrackerSA::operator=(const AliITStrackerSA& source){
 221     // Assignment operator.
 222   this->~AliITStrackerSA();
 223   new(this) AliITStrackerSA(source);
 224   return *this;
 225
 226 }
 227
 228 //____________________________________________________________________________
 229 AliITStrackerSA::~AliITStrackerSA(){
 230   // destructor
 231   // if fVertexer is not null, the AliESDVertex obj. is owned by this class
 232   // and is deleted here
 233   if(fVertexer){
 234     if(fVert)delete fVert;
 235   }
 236   fVert = 0;
 237   fVertexer = 0;
 238
 239   if(fPhiWin)delete []fPhiWin;
 240   if(fLambdaWin)delete []fLambdaWin;
 241   fListOfTracks->Delete();
 242   delete fListOfTracks;
 243   fListOfSATracks->Delete();
 244   delete fListOfSATracks;
 245   if(fCluLayer){
 246     for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
 247       if(fCluLayer[i]){
 248         fCluLayer[i]->Delete();
 249         delete fCluLayer[i];
 250       }
 251     }
 252     delete [] fCluLayer;
 253   }
 254   if(fCluCoord){
 255     for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
 256       if(fCluCoord[i]){
 257         fCluCoord[i]->Delete();
 258         delete fCluCoord[i];
 259       }
 260     }
 261     delete [] fCluCoord;
 262   }
 263
 264 }
 265
 266 //____________________________________________________________________________
 267 Int_t AliITStrackerSA::Clusters2Tracks(AliESDEvent *event){
 268 // This method is used to find and fit the tracks. By default the corresponding
 269 // method in the parent class is invoked. In this way a combined tracking
 270 // TPC+ITS is performed. If the flag fITSStandAlone is true, the tracking
 271 // is done in the ITS only. In the standard reconstruction chain this option
 272 // can be set via AliReconstruction::SetOption("ITS","onlyITS")
 273   Int_t rc=0;
 274   if(!fITSStandAlone){
 275     rc=AliITStrackerMI::Clusters2Tracks(event);
 276   }
 277   else {
 278     AliDebug(1,"Stand Alone flag set: doing tracking in ITS alone\n");
 279   }
 280   if(!rc){
 281     rc=FindTracks(event,kFALSE);
 282     if(AliITSReconstructor::GetRecoParam()->GetSAUseAllClusters()==kTRUE) {
 283       rc=FindTracks(event,kTRUE);
 284     }
 285   }
 286
 287   return rc;
 288 }
 289
 290 //____________________________________________________________________________
 291 void AliITStrackerSA::Init(){
 292   //  Reset all data members
 293     fPhiEstimate=0;
 294     for(Int_t i=0;i<3;i++){fPoint1[i]=0;fPoint2[i]=0;fPoint3[i]=0;}
 295     fLambdac=0;
 296     fPhic=0;
 297     fCoef1=0;
 298     fCoef2=0;
 299     fCoef3=0;
 300     fPointc[0]=0;
 301     fPointc[1]=0;
 302     fVert = 0;
 303     fVertexer = 0;
 304     Int_t nLoops=AliITSReconstructor::GetRecoParam()->GetNLoopsSA();
 305     if(nLoops==33){
 306       SetFixedWindowSizes();
 307     }else{
 308       Double_t phimin=AliITSReconstructor::GetRecoParam()->GetMinPhiSA();
 309       Double_t phimax=AliITSReconstructor::GetRecoParam()->GetMaxPhiSA();
 310       Double_t lambmin=AliITSReconstructor::GetRecoParam()->GetMinLambdaSA();
 311       Double_t lambmax=AliITSReconstructor::GetRecoParam()->GetMaxLambdaSA();
 312       SetCalculatedWindowSizes(nLoops,phimin,phimax,lambmin,lambmax);
 313     }
 314     fMinQ=AliITSReconstructor::GetRecoParam()->GetSAMinClusterCharge();
 315     fITSclusters = 0;
 316     SetOuterStartLayer(1);
 317     SetSAFlag(kFALSE);
 318     fListOfTracks=new TClonesArray("AliITStrackMI",100);
 319     fListOfSATracks=new TClonesArray("AliITStrackSA",100);
 320     fCluLayer = 0;
 321     fCluCoord = 0;
 322     fMinNPoints = 3;
 323  }
 324 //_______________________________________________________________________
 325 void AliITStrackerSA::ResetForFinding(){
 326   //  Reset data members used in all loops during track finding
 327     fPhiEstimate=0;
 328     for(Int_t i=0;i<3;i++){fPoint1[i]=0;fPoint2[i]=0;fPoint3[i]=0;}
 329     fLambdac=0;
 330     fPhic=0;
 331     fCoef1=0;
 332     fCoef2=0;
 333     fCoef3=0;
 334     fPointc[0]=0;
 335     fPointc[1]=0;
 336     fListOfTracks->Clear();
 337     fListOfSATracks->Clear();
 338 }
 339
 340
 341
 342 //______________________________________________________________________
 343 Int_t AliITStrackerSA::FindTracks(AliESDEvent* event, Bool_t useAllClusters){
 344
 345 // Track finder using the ESD object
 346
 347   AliDebug(2,Form(" field is %f",event->GetMagneticField()));
 348   AliDebug(2,Form("SKIPPING %d %d %d %d %d %d",ForceSkippingOfLayer(0),ForceSkippingOfLayer(1),ForceSkippingOfLayer(2),ForceSkippingOfLayer(3),ForceSkippingOfLayer(4),ForceSkippingOfLayer(5)));
 349
 350   if(!fITSclusters){
 351     Fatal("FindTracks","ITS cluster tree is not accessed - Abort!!!\n Please use method SetClusterTree to pass the pointer to the tree\n");
 352     return -1;
 353   }
 354   //Reads event and mark clusters of traks already found, with flag kITSin
 355   Int_t nentr=event->GetNumberOfTracks();
 356   if(!useAllClusters) {
 357     while (nentr--) {
 358       AliESDtrack *track=event->GetTrack(nentr);
 359       if ((track->GetStatus()&AliESDtrack::kITSin) == AliESDtrack::kITSin){
 360         Int_t idx[12];
 361         Int_t ncl = track->GetITSclusters(idx);
 362         for(Int_t k=0;k<ncl;k++){
 363           AliITSRecPoint* cll = (AliITSRecPoint*)GetCluster(idx[k]);
 364           cll->SetBit(kSAflag);
 365         }
 366       }
 367     }
 368   }else{
 369     while (nentr--) {
 370       AliESDtrack *track=event->GetTrack(nentr);
 371       if ((track->GetStatus()&AliESDtrack::kITSin) == AliESDtrack::kITSin){
 372         Int_t idx[12];
 373         Int_t ncl = track->GetITSclusters(idx);
 374         for(Int_t k=0;k<ncl;k++){
 375           AliITSRecPoint* cll = (AliITSRecPoint*)GetCluster(idx[k]);
 376           cll->ResetBit(kSAflag);
 377         }
 378       }
 379     }
 380   }
 381   //Get primary vertex
 382   Double_t primaryVertex[3];
 383   event->GetVertex()->GetXYZ(primaryVertex);
 384   //Creates TClonesArray with clusters for each layer. The clusters already used
 385   //by AliITStrackerMI are not considered
 386   Int_t nclusters[AliITSgeomTGeo::kNLayers]={0,0,0,0,0,0};
 387   Int_t dmar[AliITSgeomTGeo::kNLayers]={0,0,0,0,0,0};
 388   if (fCluLayer == 0) {
 389     fCluLayer = new TClonesArray*[AliITSgeomTGeo::kNLayers];
 390     fCluCoord = new TClonesArray*[AliITSgeomTGeo::kNLayers];
 391     for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
 392       fCluLayer[i]=0;
 393       fCluCoord[i]=0;
 394     }
 395   }
 396   for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
 397     AliITSlayer &layer=fgLayers[i];
 398     if (!ForceSkippingOfLayer(i)) {
 399       for(Int_t cli=0;cli<layer.GetNumberOfClusters();cli++){
 400         AliITSRecPoint* cls = (AliITSRecPoint*)layer.GetCluster(cli);
 401         if(cls->TestBit(kSAflag)==kTRUE) continue; //clusters used by TPC prol.
 402         if(cls->GetQ()==0) continue; //fake clusters dead zones
 403         if(i>1 && cls->GetQ()<=fMinQ) continue; // cut on SDD and SSD cluster charge
 404         nclusters[i]++;
 405       }
 406     }
 407     dmar[i]=0;
 408     if(!fCluLayer[i]){
 409       fCluLayer[i] = new TClonesArray("AliITSRecPoint",nclusters[i]);
 410     }else{
 411       fCluLayer[i]->Delete();
 412       fCluLayer[i]->Expand(nclusters[i]);
 413     }
 414     if(!fCluCoord[i]){
 415       fCluCoord[i] = new TClonesArray("AliITSclusterTable",nclusters[i]);
 416     }else{
 417       fCluCoord[i]->Delete();
 418       fCluCoord[i]->Expand(nclusters[i]);
 419     }
 420   }
 421
 422   for(Int_t ilay=0;ilay<AliITSgeomTGeo::GetNLayers();ilay++){
 423     TClonesArray &clulay = *fCluLayer[ilay];
 424     TClonesArray &clucoo = *fCluCoord[ilay];
 425     AliITSlayer &layer=fgLayers[ilay];
 426     if (!ForceSkippingOfLayer(ilay)) {
 427       for(Int_t cli=0;cli<layer.GetNumberOfClusters();cli++){
 428         AliITSRecPoint* cls = (AliITSRecPoint*)layer.GetCluster(cli);
 429         if(cls->TestBit(kSAflag)==kTRUE) continue;
 430         if(cls->GetQ()==0) continue;
 431         if(ilay>1 && cls->GetQ()<=fMinQ) continue;
 432         Double_t phi=0;Double_t lambda=0;
 433         Float_t x=0;Float_t y=0;Float_t z=0;
 434         Float_t sx=0;Float_t sy=0;Float_t sz=0;
 435         GetCoorAngles(cls,phi,lambda,x,y,z,primaryVertex);
 436         GetCoorErrors(cls,sx,sy,sz);
 437         new (clulay[dmar[ilay]]) AliITSRecPoint(*cls);
 438         new (clucoo[dmar[ilay]]) AliITSclusterTable(x,y,z,sx,sy,sz,phi,lambda,cli);
 439         dmar[ilay]++;
 440       }
 441     }
 442   }
 443
 444   // track counter
 445   Int_t ntrack=0;
 446
 447   static Int_t nClusLay[AliITSgeomTGeo::kNLayers];//counter for clusters on each layer
 448   Int_t startLayForSeed=0;
 449   Int_t lastLayForSeed=fOuterStartLayer;
 450   Int_t nSeedSteps=lastLayForSeed-startLayForSeed;
 451   Int_t seedStep=1;
 452   if(fInwardFlag){
 453     startLayForSeed=AliITSgeomTGeo::GetNLayers()-1;
 454     lastLayForSeed=fInnerStartLayer;
 455     nSeedSteps=startLayForSeed-lastLayForSeed;
 456     seedStep=-1;
 457   }
 458
 459   // loop on minimum number of points
 460   for(Int_t iMinNPoints=AliITSgeomTGeo::GetNLayers(); iMinNPoints>=fMinNPoints; iMinNPoints--) {
 461
 462     // loop on starting layer for track finding
 463     for(Int_t iSeedLay=0; iSeedLay<=nSeedSteps; iSeedLay++) {
 464       Int_t theLay=startLayForSeed+iSeedLay*seedStep;
 465       if(ForceSkippingOfLayer(theLay)) continue;
 466       Int_t minNPoints=iMinNPoints-theLay;
 467       if(fInwardFlag) minNPoints=iMinNPoints-(AliITSgeomTGeo::GetNLayers()-1-theLay);
 468       for(Int_t i=theLay+1;i<AliITSgeomTGeo::GetNLayers();i++)
 469         if(ForceSkippingOfLayer(i))
 470           minNPoints--;
 471       if(minNPoints<fMinNPoints) continue;
 472
 473       // loop on phi and lambda window size
 474       for(Int_t nloop=0;nloop<fNloop;nloop++){
 475         Int_t nclTheLay=fCluLayer[theLay]->GetEntries();
 476         while(nclTheLay--){
 477           ResetForFinding();
 478           Bool_t useRP=SetFirstPoint(theLay,nclTheLay,primaryVertex);
 479           if(!useRP) continue;
 480           AliITStrackSA trs;
 481
 482           Int_t pflag=0;
 483           Int_t kk;
 484           for(kk=0;kk<AliITSgeomTGeo::GetNLayers();kk++) nClusLay[kk] = 0;
 485
 486           kk=0;
 487           nClusLay[kk] = SearchClusters(theLay,fPhiWin[nloop],fLambdaWin[nloop],
 488                                         &trs,primaryVertex[2],pflag);
 489           Int_t nextLay=theLay+seedStep;
 490           Bool_t goon=kTRUE;
 491           while(goon){
 492             kk++;
 493             nClusLay[kk] = SearchClusters(nextLay,fPhiWin[nloop],fLambdaWin[nloop],
 494                                             &trs,primaryVertex[2],pflag);
 495             if(nClusLay[kk]!=0){
 496               pflag=1;
 497               if(kk==1) {
 498                 fPoint3[0]=fPointc[0];
 499                 fPoint3[1]=fPointc[1];
 500               } else {
 501                 UpdatePoints();
 502               }
 503             }
 504             nextLay+=seedStep;
 505             if(nextLay<0 || nextLay==6) goon=kFALSE;
 506           }
 507
 508
 509           Int_t layOK=0;
 510           if(!fInwardFlag){
 511             for(Int_t nnp=0;nnp<AliITSgeomTGeo::GetNLayers()-theLay;nnp++){
 512               if(nClusLay[nnp]!=0) layOK+=1;
 513             }
 514           }else{
 515             for(Int_t nnp=theLay; nnp>=0; nnp--){
 516               if(nClusLay[nnp]!=0) layOK+=1;
 517             }
 518           }
 519           if(layOK>=minNPoints){
 520             AliDebug(2,Form("---NPOINTS: %d; MAP: %d %d %d %d %d %d\n",layOK,nClusLay[0],nClusLay[1],nClusLay[2],nClusLay[3],nClusLay[4],nClusLay[5]));
 521             AliITStrackV2* tr2 = 0;
 522             tr2 = FitTrack(&trs,primaryVertex);
 523             if(!tr2){
 524               continue;
 525             }
 526             AliDebug(2,Form("---NPOINTS fit: %d\n",tr2->GetNumberOfClusters()));
 527
 528             StoreTrack(tr2,event,useAllClusters);
 529             ntrack++;
 530
 531           }
 532
 533         }//end loop on clusters of theLay
 534       } //end loop on window sizes
 535     } //end loop on theLay
 536   }//end loop on min points
 537
 538   // search for 1-point tracks in SPD, only for cosmics
 539   // (A.Dainese 21.03.08)
 540   if(AliITSReconstructor::GetRecoParam()->GetSAOnePointTracks() &&
 541      TMath::Abs(event->GetMagneticField())<0.01) {
 542     Int_t outerLayer=1; // only SPD
 543     for(Int_t innLay=0; innLay<=TMath::Min(1,fOuterStartLayer); innLay++) {
 544       //   counter for clusters on each layer
 545
 546       for(Int_t nloop=0;nloop<fNloop;nloop++){
 547         Int_t nclInnLay=fCluLayer[innLay]->GetEntries();
 548         while(nclInnLay--){ //loop starting from layer innLay
 549           ResetForFinding();
 550           Bool_t useRP=SetFirstPoint(innLay,nclInnLay,primaryVertex);
 551           if(!useRP) continue;
 552           AliITStrackSA trs;
 553
 554           Int_t pflag=0;
 555           Int_t kk;
 556           for(kk=0;kk<AliITSgeomTGeo::GetNLayers();kk++) nClusLay[kk] = 0;
 557
 558           kk=0;
 559           nClusLay[kk] = SearchClusters(innLay,fPhiWin[nloop],fLambdaWin[nloop],
 560                                   &trs,primaryVertex[2],pflag);
 561           for(Int_t nextLay=innLay+1; nextLay<=outerLayer; nextLay++) {
 562             kk++;
 563             nClusLay[kk] = SearchClusters(nextLay,fPhiWin[nloop],fLambdaWin[nloop],
 564                                     &trs,primaryVertex[2],pflag);
 565             if(nClusLay[kk]!=0){
 566               pflag=1;
 567               if(kk==1) {
 568                 fPoint3[0]=fPointc[0];
 569                 fPoint3[1]=fPointc[1];
 570               } else {
 571                 UpdatePoints();
 572               }
 573             }
 574           }
 575
 576           Int_t layOK=0;
 577           for(Int_t nnp=0;nnp<AliITSgeomTGeo::GetNLayers()-innLay;nnp++){
 578             if(nClusLay[nnp]!=0) layOK+=1;
 579           }
 580           if(layOK==1) {
 581             AliDebug(2,Form("----NPOINTS: %d; MAP: %d %d %d %d %d %d\n",layOK,nClusLay[0],nClusLay[1],nClusLay[2],nClusLay[3],nClusLay[4],nClusLay[5]));
 582             AliITStrackV2* tr2 = 0;
 583             Bool_t onePoint = kTRUE;
 584             tr2 = FitTrack(&trs,primaryVertex,onePoint);
 585             if(!tr2){
 586               continue;
 587             }
 588             AliDebug(2,Form("----NPOINTS fit: %d\n",tr2->GetNumberOfClusters()));
 589
 590             StoreTrack(tr2,event,useAllClusters);
 591             ntrack++;
 592
 593           }
 594
 595         }//end loop on clusters of innLay
 596       } //end loop on window sizes
 597
 598     } //end loop on innLay
 599   } // end search 1-point tracks
 600
 601   if(!useAllClusters) AliInfo(Form("Number of found tracks: %d",event->GetNumberOfTracks()));
 602   ResetForFinding();
 603   return 0;
 604
 605 }
 606
 607 //________________________________________________________________________
 608
 609 AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVertex,Bool_t onePoint) {
 610   //fit of the found track (most general case, also <6 points, layers missing)
 611   // A.Dainese 16.11.07
 612
 613
 614   const Int_t kMaxClu=AliITStrackSA::kMaxNumberOfClusters;
 615
 616   static Int_t firstmod[AliITSgeomTGeo::kNLayers];
 617
 618   static Int_t clind[AliITSgeomTGeo::kNLayers][kMaxClu];
 619   static Int_t clmark[AliITSgeomTGeo::kNLayers][kMaxClu];
 620   static Int_t end[AliITSgeomTGeo::kNLayers];
 621   static AliITSRecPoint *listlayer[AliITSgeomTGeo::kNLayers][kMaxClu];
 622
 623   for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
 624     firstmod[i]=AliITSgeomTGeo::GetModuleIndex(i+1,1,1);
 625     end[i]=0;
 626     for(Int_t j=0;j<kMaxClu; j++){
 627       clind[i][j]=0;
 628       clmark[i][j]=0;
 629       listlayer[i][j]=0;
 630    }
 631   }
 632
 633
 634   Int_t nclusters = tr->GetNumberOfClustersSA();
 635   for(Int_t ncl=0;ncl<nclusters;ncl++){
 636     Int_t index = tr->GetClusterIndexSA(ncl);
 637     AliITSRecPoint* cl = (AliITSRecPoint*)GetCluster(index);
 638     Int_t lay = (index & 0xf0000000) >> 28;
 639     Int_t nInLay=end[lay];
 640     listlayer[lay][nInLay]=cl;
 641     clind[lay][nInLay]=index;
 642     end[lay]++;
 643   }
 644
 645   for(Int_t nlay=0;nlay<AliITSgeomTGeo::GetNLayers();nlay++){
 646     for(Int_t ncl=0;ncl<tr->GetNumberOfMarked(nlay);ncl++){
 647       Int_t mark = tr->GetClusterMark(nlay,ncl);
 648       clmark[nlay][ncl]=mark;
 649     }
 650   }
 651
 652
 653   Int_t firstLay=-1,secondLay=-1;
 654   for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
 655     if(end[i]==0) {
 656       end[i]=1;
 657     }else{
 658       if(firstLay==-1) {
 659         firstLay=i;
 660       } else if(secondLay==-1) {
 661         secondLay=i;
 662       }
 663     }
 664   }
 665
 666   if(firstLay==-1 || (secondLay==-1 && !onePoint)) return 0;
 667   TClonesArray &arrMI= *fListOfTracks;
 668   TClonesArray &arrSA= *fListOfSATracks;
 669   Int_t nFoundTracks=0;
 670
 671   for(Int_t l0=0;l0<end[0];l0++){ //loop on layer 1
 672     AliITSRecPoint* cl0 = (AliITSRecPoint*)listlayer[0][l0];
 673     for(Int_t l1=0;l1<end[1];l1++){ //loop on layer 2
 674       AliITSRecPoint* cl1 = (AliITSRecPoint*)listlayer[1][l1];
 675       for(Int_t l2=0;l2<end[2];l2++){  //loop on layer 3
 676         AliITSRecPoint* cl2 = (AliITSRecPoint*)listlayer[2][l2];
 677         for(Int_t l3=0;l3<end[3];l3++){ //loop on layer 4
 678           AliITSRecPoint* cl3 = (AliITSRecPoint*)listlayer[3][l3];
 679           for(Int_t l4=0;l4<end[4];l4++){ //loop on layer 5
 680             AliITSRecPoint* cl4 = (AliITSRecPoint*)listlayer[4][l4];
 681             for(Int_t l5=0;l5<end[5];l5++){ //loop on layer 6
 682               AliITSRecPoint* cl5 = (AliITSRecPoint*)listlayer[5][l5];
 683
 684
 685               Double_t x1,y1,z1,sx1,sy1,sz1;
 686               Double_t x2,y2,z2,sx2,sy2,sz2;
 687               AliITSRecPoint* p1=0;
 688               AliITSRecPoint* p2=0;
 689               Int_t index1=0,index2=0;
 690               Int_t mrk1=0,mrk2=0;
 691
 692               switch(firstLay) {
 693               case 0:
 694                 p1=cl0;
 695                 index1=clind[0][l0];mrk1=clmark[0][l0];
 696                 break;
 697               case 1:
 698                 p1=cl1;
 699                 index1=clind[1][l1];mrk1=clmark[1][l1];
 700                 break;
 701               case 2:
 702                 p1=cl2;
 703                 index1=clind[2][l2];mrk1=clmark[2][l2];
 704                 break;
 705               case 3:
 706                 p1=cl3;
 707                 index1=clind[3][l3];mrk1=clmark[3][l3];
 708                 break;
 709               case 4:
 710                 p1=cl4;
 711                 index1=clind[4][l4];mrk1=clmark[4][l4];
 712                 break;
 713               }
 714
 715               switch(secondLay) {
 716               case 1:
 717                 p2=cl1;
 718                 index2=clind[1][l1];mrk2=clmark[1][l1];
 719                 break;
 720               case 2:
 721                 p2=cl2;
 722                 index2=clind[2][l2];mrk2=clmark[2][l2];
 723                 break;
 724               case 3:
 725                 p2=cl3;
 726                 index2=clind[3][l3];mrk2=clmark[3][l3];
 727                 break;
 728               case 4:
 729                 p2=cl4;
 730                 index2=clind[4][l4];mrk2=clmark[4][l4];
 731                 break;
 732               case 5:
 733                 p2=cl5;
 734                 index2=clind[5][l5];mrk2=clmark[5][l5];
 735                 break;
 736               default:
 737                 p2=0;
 738                 index2=-1;mrk2=-1;
 739                 break;
 740               }
 741
 742               Int_t module1 = p1->GetDetectorIndex()+firstmod[firstLay];
 743               Int_t layer,ladder,detector;
 744               AliITSgeomTGeo::GetModuleId(module1,layer,ladder,detector);
 745               Float_t yclu1 = p1->GetY();
 746               Float_t zclu1 = p1->GetZ();
 747               Double_t cv=0,tgl2=0,phi2=0;
 748
 749               Int_t cln1=mrk1;
 750               AliITSclusterTable* arr1 = (AliITSclusterTable*)GetClusterCoord(firstLay,cln1);
 751               x1 = arr1->GetX();
 752               y1 = arr1->GetY();
 753               z1 = arr1->GetZ();
 754               sx1 = arr1->GetSx();
 755               sy1 = arr1->GetSy();
 756               sz1 = arr1->GetSz();
 757
 758               if(secondLay>0) {
 759                 Int_t cln2=mrk2;
 760                 AliITSclusterTable* arr2 = (AliITSclusterTable*)GetClusterCoord(secondLay,cln2);
 761                 x2 = arr2->GetX();
 762                 y2 = arr2->GetY();
 763                 z2 = arr2->GetZ();
 764                 sx2 = arr2->GetSx();
 765                 sy2 = arr2->GetSy();
 766                 sz2 = arr2->GetSz();
 767                 cv = Curvature(primaryVertex[0],primaryVertex[1],x1,y1,x2,y2);
 768                 tgl2 = (z2-z1)/TMath::Sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
 769                 phi2 = TMath::ATan2((y2-y1),(x2-x1));
 770               } else { // special case of 1-point tracks, only for cosmics (B=0)
 771                 x2 = primaryVertex[0];
 772                 y2 = primaryVertex[1];
 773                 z2 = primaryVertex[2];
 774                 cv = 0;
 775                 tgl2 = (z1-z2)/TMath::Sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
 776                 phi2 = TMath::ATan2((y1-y2),(x1-x2));
 777               }
 778
 779
 780               AliITStrackSA trac(layer,ladder,detector,yclu1,zclu1,phi2,tgl2,cv,1);
 781
 782
 783               if(cl5!=0) {
 784                 trac.AddClusterV2(5,(clind[5][l5] & 0x0fffffff)>>0);
 785                 trac.AddClusterMark(5,clmark[5][l5]);
 786               }
 787               if(cl4!=0){
 788                 trac.AddClusterV2(4,(clind[4][l4] & 0x0fffffff)>>0);
 789                 trac.AddClusterMark(4,clmark[4][l4]);
 790               }
 791               if(cl3!=0){
 792                 trac.AddClusterV2(3,(clind[3][l3] & 0x0fffffff)>>0);
 793                 trac.AddClusterMark(3,clmark[3][l3]);
 794               }
 795               if(cl2!=0){
 796                 trac.AddClusterV2(2,(clind[2][l2] & 0x0fffffff)>>0);
 797                 trac.AddClusterMark(2,clmark[2][l2]);
 798               }
 799               if(cl1!=0){
 800                 trac.AddClusterV2(1,(clind[1][l1] & 0x0fffffff)>>0);
 801                 trac.AddClusterMark(1,clmark[1][l1]);
 802               }
 803               if(cl0!=0){
 804                 trac.AddClusterV2(0,(clind[0][l0] & 0x0fffffff)>>0);
 805                 trac.AddClusterMark(0,clmark[0][l0]);
 806               }
 807
 808               //fit with Kalman filter using AliITStrackerMI::RefitAt()
 809               AliITStrackSA ot(trac);
 810
 811               ot.ResetCovariance(10.);
 812               ot.ResetClusters();
 813
 814               // Propagate inside the innermost layer with a cluster
 815               if(ot.Propagate(ot.GetX()-0.1*ot.GetX())) {
 816
 817                 if(RefitAt(AliITSRecoParam::GetrInsideITSscreen(),&ot,&trac)){ //fit from layer 1 to layer 6
 818                   AliITStrackMI otrack2(ot);
 819                   otrack2.ResetCovariance(10.);
 820                   otrack2.ResetClusters();
 821                   //fit from layer 6 to layer 1
 822                   if(RefitAt(AliITSRecoParam::GetrInsideSPD1(),&otrack2,&ot)) {
 823                     new(arrMI[nFoundTracks]) AliITStrackMI(otrack2);
 824                     new(arrSA[nFoundTracks]) AliITStrackSA(trac);
 825                     ++nFoundTracks;
 826                   }
 827
 828                 }
 829               }
 830             }//end loop layer 6
 831           }//end loop layer 5
 832         }//end loop layer 4
 833       }//end loop layer 3
 834     }//end loop layer 2
 835   }//end loop layer 1
 836
 837
 838
 839
 840   if(fListOfTracks->GetEntries()==0) return 0;
 841
 842   Int_t lowchi2 = FindTrackLowChiSquare();
 843   AliITStrackV2* otrack =(AliITStrackV2*)fListOfTracks->At(lowchi2);
 844   AliITStrackSA* trsa = (AliITStrackSA*)fListOfSATracks->At(lowchi2);
 845
 846   if(otrack==0) return 0;
 847
 848   CookLabel(otrack,0.); //MI change - to see fake ratio
 849   Int_t label=FindLabel(otrack);
 850   otrack->SetLabel(label);
 851   Double_t low=0.;
 852   Double_t up=0.51;
 853   otrack->CookdEdx(low,up);
 854
 855   //remove clusters of found track
 856   for(Int_t nlay=0;nlay<AliITSgeomTGeo::GetNLayers();nlay++){
 857     for(Int_t cln=0;cln<trsa->GetNumberOfMarked(nlay);cln++){
 858       Int_t index = trsa->GetClusterMark(nlay,cln);
 859       fCluLayer[nlay]->RemoveAt(index);
 860       RemoveClusterCoord(nlay,index);
 861       fCluLayer[nlay]->Compress();
 862     }
 863   }
 864
 865   return otrack;
 866
 867 }
 868
 869 //_______________________________________________________
 870 void AliITStrackerSA::StoreTrack(AliITStrackV2 *t,AliESDEvent *event, Bool_t pureSA) const
 871 {
 872   //
 873   // Add new track to the ESD
 874   //
 875   AliESDtrack outtrack;
 876   outtrack.UpdateTrackParams(t,AliESDtrack::kITSin);
 877   if(pureSA) outtrack.SetStatus(AliESDtrack::kITSpureSA);
 878   for(Int_t i=0;i<12;i++) {
 879     outtrack.SetITSModuleIndex(i,t->GetModuleIndex(i));
 880   }
 881   Double_t sdedx[4]={0.,0.,0.,0.};
 882   for(Int_t i=0; i<4; i++) sdedx[i]=t->GetSampledEdx(i);
 883   outtrack.SetITSdEdxSamples(sdedx);
 884   event->AddTrack(&outtrack);
 885
 886   return;
 887 }
 888
 889
 890 //_______________________________________________________
 891 Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t lambdawindow, AliITStrackSA* trs,Double_t /*zvertex*/,Int_t pflag){
 892   //function used to to find the clusters associated to the track
 893
 894   if(ForceSkippingOfLayer(layer)) return 0;
 895
 896   Int_t nc=0;
 897   AliITSlayer &lay = fgLayers[layer];
 898   Double_t r=lay.GetR();
 899   if(pflag==1){
 900     Float_t cx1,cx2,cy1,cy2;
 901     FindEquation(fPoint1[0],fPoint1[1],fPoint2[0],fPoint2[1],fPoint3[0],fPoint3[1],fCoef1,fCoef2,fCoef3);
 902     if (FindIntersection(fCoef1,fCoef2,fCoef3,-r*r,cx1,cy1,cx2,cy2)==0)
 903        return 0;
 904     Double_t fi1=TMath::ATan2(cy1-fPoint1[1],cx1-fPoint1[0]);
 905     Double_t fi2=TMath::ATan2(cy2-fPoint1[1],cx2-fPoint1[0]);
 906     fPhiEstimate=ChoosePoint(fi1,fi2,fPhic);
 907   }
 908
 909
 910   Int_t ncl = fCluLayer[layer]->GetEntries();
 911   for (Int_t index=0; index<ncl; index++) {
 912     AliITSRecPoint *c = (AliITSRecPoint*)fCluLayer[layer]->At(index);
 913     if (!c) continue;
 914     if (c->GetQ()<=0) continue;
 915     if(layer>1 && c->GetQ()<=fMinQ) continue;
 916
 917      AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(layer,index);
 918      Double_t phi = arr->GetPhi();
 919      if (TMath::Abs(phi-fPhiEstimate)>phiwindow) continue;
 920
 921      Double_t lambda = arr->GetLambda();
 922      if (TMath::Abs(lambda-fLambdac)>lambdawindow) continue;
 923
 924      if(trs->GetNumberOfClustersSA()==trs->GetMaxNumberOfClusters()) return 0;
 925      if(trs->GetNumberOfMarked(layer)==trs->GetMaxNMarkedPerLayer()) return 0;
 926      Int_t orind = arr->GetOrInd();
 927      trs->AddClusterSA(layer,orind);
 928      trs->AddClusterMark(layer,index);
 929
 930      nc++;
 931      fLambdac=lambda;
 932      fPhiEstimate=phi;
 933
 934      fPointc[0]=arr->GetX();
 935      fPointc[1]=arr->GetY();
 936
 937   }
 938   return nc;
 939 }
 940
 941 //________________________________________________________________
 942 Bool_t AliITStrackerSA::SetFirstPoint(Int_t lay, Int_t clu, Double_t* primaryVertex){
 943   // Sets the first point (seed) for tracking
 944
 945   AliITSRecPoint* cl = (AliITSRecPoint*)fCluLayer[lay]->At(clu);
 946   if(!cl) return kFALSE;
 947   if (cl->GetQ()<=0) return kFALSE;
 948   if(lay>1 && cl->GetQ()<=fMinQ) return kFALSE;
 949
 950   AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(lay,clu);
 951   fPhic = arr->GetPhi();
 952   fLambdac = arr->GetLambda();
 953   fPhiEstimate = fPhic;
 954   fPoint1[0]=primaryVertex[0];
 955   fPoint1[1]=primaryVertex[1];
 956   fPoint2[0]=arr->GetX();
 957   fPoint2[1]=arr->GetY();
 958   return kTRUE;
 959 }
 960
 961 //________________________________________________________________
 962 void AliITStrackerSA::UpdatePoints(){
 963   //update of points for the estimation of the curvature
 964
 965   fPoint2[0]=fPoint3[0];
 966   fPoint2[1]=fPoint3[1];
 967   fPoint3[0]=fPointc[0];
 968   fPoint3[1]=fPointc[1];
 969
 970
 971 }
 972
 973 //___________________________________________________________________
 974 Int_t AliITStrackerSA::FindEquation(Float_t x1, Float_t y1, Float_t x2, Float_t y2, Float_t x3, Float_t y3,Float_t& a, Float_t& b, Float_t& c){
 975
 976    //given (x,y) of three recpoints (in global coordinates)
 977    //returns the parameters a,b,c of circonference x*x + y*y +a*x + b*y +c
 978
 979    Float_t den = (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1);
 980    if(den==0) return 0;
 981    a = ((y3-y1)*(x2*x2+y2*y2-x1*x1-y1*y1)-(y2-y1)*(x3*x3+y3*y3-x1*x1-y1*y1))/den;
 982    b = -(x2*x2-x1*x1+y2*y2-y1*y1+a*(x2-x1))/(y2-y1);
 983    c = -x1*x1-y1*y1-a*x1-b*y1;
 984    return 1;
 985  }
 986 //__________________________________________________________________________
 987  Int_t AliITStrackerSA::FindIntersection(Float_t a1, Float_t b1, Float_t c1, Float_t c2,Float_t& x1,Float_t& y1, Float_t& x2, Float_t& y2){
 988
 989  //Finds the intersection between the circonference of the track and the circonference centered in (0,0) represented by one layer
 990  //c2 is -rlayer*rlayer
 991
 992   if(a1==0) return 0;
 993  Double_t m = c2-c1;
 994  Double_t aA = (b1*b1)/(a1*a1)+1;
 995  Double_t bB = (-2*m*b1/(a1*a1));
 996  Double_t cC = c2+(m*m)/(a1*a1);
 997  Double_t dD = bB*bB-4*aA*cC;
 998  if(dD<0) return 0;
 999
1000  y1 = (-bB+TMath::Sqrt(dD))/(2*aA);
1001  y2 = (-bB-TMath::Sqrt(dD))/(2*aA);
1002  x1 = (c2-c1-b1*y1)/a1;
1003  x2 = (c2-c1-b1*y2)/a1;
1004
1005  return 1;
1006 }
1007 //____________________________________________________________________
1008 Double_t AliITStrackerSA::Curvature(Double_t x1,Double_t y1,Double_t
1009 x2,Double_t y2,Double_t x3,Double_t y3){
1010
1011   //calculates the curvature of track
1012   Double_t den = (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1);
1013   if(den==0) return 0;
1014   Double_t a = ((y3-y1)*(x2*x2+y2*y2-x1*x1-y1*y1)-(y2-y1)*(x3*x3+y3*y3-x1*x1-y1*y1))/den;
1015   Double_t b = -(x2*x2-x1*x1+y2*y2-y1*y1+a*(x2-x1))/(y2-y1);
1016   Double_t c = -x1*x1-y1*y1-a*x1-b*y1;
1017   Double_t xc=-a/2.;
1018
1019   if((a*a+b*b-4*c)<0) return 0;
1020   Double_t rad = TMath::Sqrt(a*a+b*b-4*c)/2.;
1021   if(rad==0) return 0;
1022
1023   if((x1>0 && y1>0 && x1<xc)) rad*=-1;
1024   if((x1<0 && y1>0 && x1<xc)) rad*=-1;
1025   //  if((x1<0 && y1<0 && x1<xc)) rad*=-1;
1026   // if((x1>0 && y1<0 && x1<xc)) rad*=-1;
1027
1028   return 1/rad;
1029
1030 }
1031
1032
1033 //____________________________________________________________________
1034 Double_t AliITStrackerSA::ChoosePoint(Double_t p1, Double_t p2, Double_t pp){
1035
1036   //Returns the point closest to pp
1037
1038   Double_t diff1 = p1-pp;
1039   Double_t diff2 = p2-pp;
1040
1041   if(TMath::Abs(diff1)<TMath::Abs(diff2)) fPhiEstimate=p1;
1042   else fPhiEstimate=p2;
1043   return fPhiEstimate;
1044
1045 }
1046
1047
1048 //_________________________________________________________________
1049 Int_t AliITStrackerSA::FindTrackLowChiSquare() const {
1050   // returns track with lowest chi square
1051   Int_t dim=fListOfTracks->GetEntries();
1052   if(dim<=1) return 0;
1053   AliITStrackV2* trk = (AliITStrackV2*)fListOfTracks->At(0);
1054   Double_t minChi2=trk->GetChi2();
1055   Int_t index=0;
1056   for(Int_t i=1;i<dim;i++){
1057     trk = (AliITStrackV2*)fListOfTracks->At(i);
1058     Double_t chi2=trk->GetChi2();
1059     if(chi2<minChi2){
1060       minChi2=chi2;
1061       index=i;
1062     }
1063   }
1064   return index;
1065 }
1066
1067 //__________________________________________________________
1068 Int_t AliITStrackerSA::FindLabel(AliITStrackV2* track){
1069   //
1070
1071   Int_t labl[AliITSgeomTGeo::kNLayers][3];
1072   Int_t cnts[AliITSgeomTGeo::kNLayers][3];
1073   for(Int_t j=0;j<AliITSgeomTGeo::GetNLayers();j++){
1074     for(Int_t k=0;k<3;k++){
1075       labl[j][k]=-2;
1076       cnts[j][k]=1;
1077     }
1078   }
1079   Int_t iNotLabel=0;
1080   for(Int_t i=0;i<track->GetNumberOfClusters(); i++) {
1081     Int_t indexc = track->GetClusterIndex(i);
1082     AliITSRecPoint* cl = (AliITSRecPoint*)GetCluster(indexc);
1083     Int_t iLayer=cl->GetLayer();
1084     for(Int_t k=0;k<3;k++){
1085       labl[iLayer][k]=cl->GetLabel(k);
1086       if(labl[iLayer][k]<0) iNotLabel++;
1087     }
1088   }
1089   if(iNotLabel==3*track->GetNumberOfClusters()) return -2;
1090
1091   for(Int_t j1=0;j1<AliITSgeomTGeo::kNLayers; j1++) {
1092     for(Int_t j2=0; j2<j1;  j2++){
1093       for(Int_t k1=0; k1<3; k1++){
1094         for(Int_t k2=0; k2<3; k2++){
1095           if(labl[j1][k1]>=0 && labl[j1][k1]==labl[j2][k2] && cnts[j2][k2]>0){
1096             cnts[j2][k2]++;
1097             cnts[j1][k1]=0;
1098           }
1099         }
1100       }
1101     }
1102   }
1103
1104
1105   Int_t cntMax=0;
1106   Int_t label=-1;
1107   for(Int_t j=0;j<AliITSgeomTGeo::kNLayers;j++){
1108     for(Int_t k=0;k<3;k++){
1109       if(cnts[j][k]>cntMax && labl[j][k]>=0){
1110         cntMax=cnts[j][k];
1111         label=labl[j][k];
1112       }
1113     }
1114   }
1115
1116   Int_t lflag=0;
1117   for(Int_t i=0;i<AliITSgeomTGeo::kNLayers;i++)
1118     if(labl[i][0]==label || labl[i][1]==label || labl[i][2]==label) lflag++;
1119
1120   if(lflag<track->GetNumberOfClusters()) label = -label;
1121   return label;
1122 }
1123 //_____________________________________________________________________________
1124 void AliITStrackerSA::SetCalculatedWindowSizes(Int_t n, Float_t phimin, Float_t phimax, Float_t lambdamin, Float_t lambdamax){
1125   // Set sizes of the phi and lambda windows used for track finding
1126   fNloop = n;
1127   if(fPhiWin) delete [] fPhiWin;
1128   if(fLambdaWin) delete [] fLambdaWin;
1129   fPhiWin = new Double_t[fNloop];
1130   fLambdaWin = new Double_t[fNloop];
1131   Float_t stepPhi=(phimax-phimin)/(Float_t)(fNloop-1);
1132   Float_t stepLambda=(lambdamax-lambdamin)/(Float_t)(fNloop-1);
1133   for(Int_t k=0;k<fNloop;k++){
1134     Float_t phi=phimin+k*stepPhi;
1135     Float_t lam=lambdamin+k*stepLambda;
1136     fPhiWin[k]=phi;
1137     fLambdaWin[k]=lam;
1138   }
1139 }
1140 //_____________________________________________________________________________
1141 void AliITStrackerSA::SetFixedWindowSizes(Int_t n, Double_t *phi, Double_t *lam){
1142   // Set sizes of the phi and lambda windows used for track finding
1143   fNloop = n;
1144   if(phi){ // user defined values
1145     fPhiWin = new Double_t[fNloop];
1146     fLambdaWin = new Double_t[fNloop];
1147     for(Int_t k=0;k<fNloop;k++){
1148       fPhiWin[k]=phi[k];
1149       fLambdaWin[k]=lam[k];
1150     }
1151   }
1152   else {  // default values
1153
1154     Double_t phid[33]   = {0.002,0.003,0.004,0.0045,0.0047,
1155                            0.005,0.0053,0.0055,
1156                            0.006,0.0063,0.0065,0.007,0.0073,0.0075,0.0077,
1157                            0.008,0.0083,0.0085,0.0087,0.009,0.0095,0.0097,
1158                            0.01,0.0105,0.011,0.0115,0.012,0.0125,0.013,0.0135,0.0140,0.0145};
1159     Double_t lambdad[33] = {0.003,0.004,0.005,0.005,0.005,
1160                             0.005,0.005,0.006,
1161                             0.006,0.006,0.006,0.007,0.007,0.007,0.007,
1162                             0.007,0.007,0.007,0.007,0.007,0.007,0.007,
1163                             0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008};
1164
1165     if(fNloop!=33){
1166       fNloop = 33;
1167     }
1168
1169
1170     fPhiWin = new Double_t[fNloop];
1171     fLambdaWin = new Double_t[fNloop];
1172
1173     Double_t factor=AliITSReconstructor::GetRecoParam()->GetFactorSAWindowSizes(); // possibility to enlarge windows for cosmics reco with large misalignments (A.Dainese)
1174
1175     for(Int_t k=0;k<fNloop;k++){
1176       fPhiWin[k]=phid[k]*factor;
1177       fLambdaWin[k]=lambdad[k]*factor;
1178     }
1179
1180   }
1181
1182 }
1183 //_______________________________________________________________________
1184 void AliITStrackerSA::GetCoorAngles(AliITSRecPoint* cl,Double_t &phi,Double_t &lambda, Float_t &x, Float_t &y,Float_t &z,Double_t* vertex){
1185   //Returns values of phi (azimuthal) and lambda angles for a given cluster
1186 /*
1187   Double_t rot[9];     fGeom->GetRotMatrix(module,rot);
1188   Int_t lay,lad,det; fGeom->GetModuleId(module,lay,lad,det);
1189   Float_t tx,ty,tz;  fGeom->GetTrans(lay,lad,det,tx,ty,tz);
1190
1191   Double_t alpha=TMath::ATan2(rot[1],rot[0])+TMath::Pi();
1192   Double_t phi1=TMath::Pi()/2+alpha;
1193   if (lay==1) phi1+=TMath::Pi();
1194
1195   Float_t cp=TMath::Cos(phi1), sp=TMath::Sin(phi1);
1196   Float_t r=tx*cp+ty*sp;
1197
1198   xyz= r*cp - cl->GetY()*sp;
1199   y= r*sp + cl->GetY()*cp;
1200   z=cl->GetZ();
1201 */
1202   Float_t xyz[3];
1203   cl->GetGlobalXYZ(xyz);
1204   x=xyz[0];
1205   y=xyz[1];
1206   z=xyz[2];
1207
1208   phi=TMath::ATan2(y-vertex[1],x-vertex[0]);
1209   lambda=TMath::ATan2(z-vertex[2],TMath::Sqrt((x-vertex[0])*(x-vertex[0])+(y-vertex[1])*(y-vertex[1])));
1210 }
1211
1212 //________________________________________________________________________
1213 void AliITStrackerSA::GetCoorErrors(AliITSRecPoint* cl,Float_t &sx,Float_t &sy, Float_t &sz){
1214
1215   //returns sigmax, y, z of cluster in global coordinates
1216 /*
1217   Double_t rot[9];     fGeom->GetRotMatrix(module,rot);
1218   Int_t lay,lad,det;
1219   AliITSgeomTGeo::GetModuleId(module,lay,lad,det);
1220
1221   Double_t alpha=TMath::ATan2(rot[1],rot[0])+TMath::Pi();
1222   Double_t phi=TMath::Pi()/2+alpha;
1223   if (lay==1) phi+=TMath::Pi();
1224
1225   Float_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
1226 */
1227   Float_t covm[6];
1228   cl->GetGlobalCov(covm);
1229   sx=TMath::Sqrt(covm[0]);
1230   sy=TMath::Sqrt(covm[3]);
1231   sz=TMath::Sqrt(covm[5]);
1232 /*
1233   sx = TMath::Sqrt(sp*sp*cl->GetSigmaY2());
1234   sy = TMath::Sqrt(cp*cp*cl->GetSigmaY2());
1235   sz = TMath::Sqrt(cl->GetSigmaZ2());
1236 */
1237 }
1238