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