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     for(Int_t cli=0;cli<layer.GetNumberOfClusters();cli++){
 349       AliITSRecPoint* cls = (AliITSRecPoint*)layer.GetCluster(cli);
 350       if(cls->TestBit(kSAflag)==kTRUE) continue; //clusters used by TPC prol.
 351       if(cls->GetQ()==0) continue; //fake clusters dead zones
 352       nclusters[i]++;
 353     }
 354     dmar[i]=0;
 355     delete fCluLayer[i];
 356     fCluLayer[i] = new TClonesArray("AliITSRecPoint",nclusters[i]);
 357     delete fCluCoord[i];
 358     fCluCoord[i] = new TClonesArray("AliITSclusterTable",nclusters[i]);
 359   }
 360
 361   for(Int_t ilay=0;ilay<AliITSgeomTGeo::GetNLayers();ilay++){
 362     TClonesArray &clulay = *fCluLayer[ilay];
 363     TClonesArray &clucoo = *fCluCoord[ilay];
 364     AliITSlayer &layer=fgLayers[ilay];
 365     for(Int_t cli=0;cli<layer.GetNumberOfClusters();cli++){
 366       AliITSRecPoint* cls = (AliITSRecPoint*)layer.GetCluster(cli);
 367       if(cls->TestBit(kSAflag)==kTRUE) continue;
 368       if(cls->GetQ()==0) continue;
 369       Double_t phi=0;Double_t lambda=0;
 370       Float_t x=0;Float_t y=0;Float_t z=0;
 371       Float_t sx=0;Float_t sy=0;Float_t sz=0;
 372       GetCoorAngles(cls,phi,lambda,x,y,z,primaryVertex);
 373       GetCoorErrors(cls,sx,sy,sz);
 374       new (clulay[dmar[ilay]]) AliITSRecPoint(*cls);
 375       new (clucoo[dmar[ilay]]) AliITSclusterTable(x,y,z,sx,sy,sz,phi,lambda,cli);
 376       dmar[ilay]++;
 377     }
 378   }
 379
 380   Int_t minNPoints = (fSixPoints ? AliITSgeomTGeo::GetNLayers() : AliITSgeomTGeo::GetNLayers()-1);
 381   for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
 382     if(AliITSReconstructor::GetRecoParam()->GetLayersToSkip(i)) {
 383       minNPoints--;
 384     }
 385   }
 386
 387
 388   Int_t ntrack=0;
 389   //loop on the different windows
 390   Int_t * nn = new Int_t[AliITSgeomTGeo::GetNLayers()];//counter for clusters on each layer
 391   for(Int_t nloop=0;nloop<fNloop;nloop++){
 392     for(Int_t ncl=0;ncl<fCluLayer[0]->GetEntries();ncl++){ //loop starting from layer 0
 393
 394       ResetForFinding();
 395       Int_t pflag=0;
 396
 397       AliITSRecPoint* cl = (AliITSRecPoint*)fCluLayer[0]->At(ncl);
 398
 399       if(!cl) continue;
 400       if (cl->GetQ()<=0) continue;
 401
 402       AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(0,ncl);
 403       fPhic = arr->GetPhi();
 404       fLambdac = arr->GetLambda();
 405       if (TMath::Abs(fLambdac)>0.26*TMath::Pi()) continue;
 406       fPhiEstimate = fPhic;
 407       AliITStrackSA* trs = new AliITStrackSA();
 408       fPoint1[0]=primaryVertex[0];
 409       fPoint1[1]=primaryVertex[1];
 410
 411
 412       fPoint2[0]=arr->GetX();
 413       fPoint2[1]=arr->GetY();
 414       for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){ nn[i]=0;}
 415       nn[0] = SearchClusters(0,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag);
 416       nn[1] = SearchClusters(1,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag);
 417       if(nn[1]>0){
 418         pflag=1;
 419         fPoint3[0] = fPointc[0];
 420         fPoint3[1] = fPointc[1];
 421       }
 422       nn[2] = SearchClusters(2,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag);
 423       if(nn[1]==0 && nn[2]==0) pflag=0;
 424       if(nn[2]!=0 && nn[1]!=0){ pflag=1; UpdatePoints();}
 425       if(nn[2]!=0 && nn[1]==0){
 426         pflag=1;
 427         fPoint3[0]=fPointc[0];
 428         fPoint3[1]=fPointc[1];
 429       }
 430
 431       nn[3] = SearchClusters(3,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag);
 432       pflag=1;
 433       if(nn[3]!=0) UpdatePoints();
 434       nn[4] = SearchClusters(4,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag);
 435       pflag=1;
 436       if(nn[4]!=0) UpdatePoints();
 437       nn[5] = SearchClusters(5,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag);
 438
 439
 440       Int_t layOK=0;
 441       //check of the candidate track
 442       for(Int_t nnp=0;nnp<AliITSgeomTGeo::GetNLayers();nnp++) {
 443         if(nn[nnp]!=0) layOK+=1;
 444       }
 445
 446       if(layOK>=minNPoints){
 447         AliITStrackV2* tr2 = 0;
 448         tr2 = FitTrack(trs,primaryVertex);
 449         if(!tr2) continue;
 450
 451         AliESDtrack outtrack;
 452         outtrack.UpdateTrackParams(tr2,AliESDtrack::kITSin);
 453         event->AddTrack(&outtrack);
 454         ntrack++;
 455       }
 456       delete trs;
 457      }//end loop on clusters of layer1
 458      //end loop2
 459   }
 460
 461   delete[] nn;
 462
 463
 464   minNPoints--;
 465
 466   //if 5/6 points are required, second loop starting
 467   //from second layer (SPD2), to find tracks with point of
 468   //layer 1 missing
 469   if(!fSixPoints) {
 470     //printf("looking from SPD2\n");
 471     //   counter for clusters on each layer
 472     Int_t * nn = new Int_t[AliITSgeomTGeo::GetNLayers()-1];
 473     for(Int_t nloop=0;nloop<fNloop;nloop++){
 474       Int_t ncl2=fCluLayer[1]->GetEntries();
 475       while(ncl2--){ //loop starting from layer 2
 476         ResetForFinding();
 477         Int_t pflag=0;
 478         AliITSRecPoint* cl = (AliITSRecPoint*)fCluLayer[1]->At(ncl2);
 479
 480         if(!cl) continue;
 481         AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(1,ncl2);
 482         fPhic = arr->GetPhi();
 483         fLambdac = arr->GetLambda();
 484         fPhiEstimate = fPhic;
 485
 486         AliITStrackSA* trs = new AliITStrackSA();
 487         fPoint1[0]=primaryVertex[0];
 488         fPoint1[1]=primaryVertex[1];
 489
 490         fPoint2[0]=arr->GetX();
 491         fPoint2[1]=arr->GetY();
 492         for(Int_t kk=0;kk<AliITSgeomTGeo::GetNLayers()-1;kk++)nn[kk] = 0;
 493         nn[0] = SearchClusters(1,fPhiWin[nloop],fLambdaWin[nloop],
 494                                trs,primaryVertex[2],pflag);
 495         nn[1] = SearchClusters(2,fPhiWin[nloop],fLambdaWin[nloop],
 496                                trs,primaryVertex[2],pflag);
 497         if(nn[1]!=0){
 498           pflag=1;
 499           fPoint3[0]=fPointc[0];
 500           fPoint3[1]=fPointc[1];
 501         }
 502         nn[2]= SearchClusters(3,fPhiWin[nloop],fLambdaWin[nloop],
 503                               trs,primaryVertex[2],pflag);
 504         if(nn[2]!=0){
 505           pflag=1;
 506           UpdatePoints();
 507         }
 508         nn[3]= SearchClusters(4,fPhiWin[nloop],fLambdaWin[nloop],
 509                               trs,primaryVertex[2],pflag);
 510         if(nn[3]!=0){
 511           pflag=1;
 512           UpdatePoints();
 513         }
 514         nn[4]=SearchClusters(5,fPhiWin[nloop],fLambdaWin[nloop],
 515                              trs,primaryVertex[2],pflag);
 516
 517         Int_t fl=0;
 518         for(Int_t nnp=0;nnp<AliITSgeomTGeo::GetNLayers()-1;nnp++){
 519           if(nn[nnp]!=0) fl+=1;
 520         }
 521         if(fl>=minNPoints){  // 5/6
 522           AliITStrackV2* tr2 = 0;
 523           tr2 = FitTrack(trs,primaryVertex);
 524           if(!tr2) continue;
 525
 526           AliESDtrack outtrack;
 527           outtrack.UpdateTrackParams(tr2,AliESDtrack::kITSin);
 528           event->AddTrack(&outtrack);
 529           ntrack++;
 530
 531         }
 532
 533         delete trs;
 534       }//end loop on clusters of layer2
 535     }
 536
 537     delete [] nn;
 538   } //end opt="5/6"
 539
 540   // search for tracks starting from SPD2, SDD1, SDD2, SSD2
 541   // for cosmics (A. Dainese 31.07.07)
 542   if(fOuterStartLayer>0) {
 543     for(Int_t innLay=1; innLay<=fOuterStartLayer; innLay++) {
 544       //printf("Searching from layer %d outward\n",innLay);
 545       minNPoints=AliITSgeomTGeo::GetNLayers()-innLay;
 546       for(Int_t i=innLay;i<AliITSgeomTGeo::GetNLayers();i++)
 547         if(AliITSReconstructor::GetRecoParam()->GetLayersToSkip(i))
 548           minNPoints--;
 549       //   counter for clusters on each layer
 550       Int_t * nn = new Int_t[AliITSgeomTGeo::GetNLayers()-innLay];
 551       for(Int_t nloop=0;nloop<fNloop;nloop++){
 552         Int_t nclInnLay=fCluLayer[innLay]->GetEntries();
 553         while(nclInnLay--){ //loop starting from layer innLay
 554           ResetForFinding();
 555           Int_t pflag=0;
 556           AliITSRecPoint* cl = (AliITSRecPoint*)fCluLayer[innLay]->At(nclInnLay);
 557
 558           if(!cl) continue;
 559           AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(innLay,nclInnLay);
 560           fPhic = arr->GetPhi();
 561           fLambdac = arr->GetLambda();
 562           fPhiEstimate = fPhic;
 563
 564           AliITStrackSA* trs = new AliITStrackSA();
 565           fPoint1[0]=primaryVertex[0];
 566           fPoint1[1]=primaryVertex[1];
 567           fPoint2[0]=arr->GetX();
 568           fPoint2[1]=arr->GetY();
 569
 570           Int_t kk;
 571           for(kk=0;kk<AliITSgeomTGeo::GetNLayers()-innLay;kk++) nn[kk] = 0;
 572
 573           kk=0;
 574           nn[kk] = SearchClusters(innLay,fPhiWin[nloop],fLambdaWin[nloop],
 575                                   trs,primaryVertex[2],pflag);
 576           for(Int_t nextLay=innLay+1; nextLay<AliITSgeomTGeo::GetNLayers(); nextLay++) {
 577             kk++;
 578             nn[kk] = SearchClusters(nextLay,fPhiWin[nloop],fLambdaWin[nloop],
 579                                     trs,primaryVertex[2],pflag);
 580             if(nn[kk]!=0){
 581               pflag=1;
 582               if(kk==1) {
 583                 fPoint3[0]=fPointc[0];
 584                 fPoint3[1]=fPointc[1];
 585               } else {
 586                 UpdatePoints();
 587               }
 588             }
 589           }
 590
 591           Int_t fl=0;
 592           for(Int_t nnp=0;nnp<AliITSgeomTGeo::GetNLayers()-innLay;nnp++){
 593             if(nn[nnp]!=0) fl+=1;
 594           }
 595           if(fl>=minNPoints){
 596             AliITStrackV2* tr2 = 0;
 597             tr2 = FitTrack(trs,primaryVertex);
 598             if(!tr2) continue;
 599
 600
 601             AliESDtrack outtrack;
 602             outtrack.UpdateTrackParams(tr2,AliESDtrack::kITSin);
 603             event->AddTrack(&outtrack);
 604             ntrack++;
 605
 606           }
 607
 608           delete trs;
 609         }//end loop on clusters of innLay
 610       } //end loop on window sizes
 611
 612       delete [] nn;
 613     } //end loop on innLay
 614   } //end if(fOuterStartLayer>0)
 615
 616
 617   delete [] firstmod;
 618   Info("FindTracks","Number of found tracks: %d",event->GetNumberOfTracks());
 619   return 0;
 620
 621 }
 622
 623 //________________________________________________________________________
 624
 625 AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVertex) {
 626   //fit of the found track (most general case, also <6 points, layers missing)
 627   // A.Dainese 16.11.07
 628
 629
 630   Int_t * firstmod = new Int_t[AliITSgeomTGeo::GetNLayers()];
 631   TObjArray** listlayer = new TObjArray*[AliITSgeomTGeo::GetNLayers()];
 632   Int_t ** clind=new Int_t*[AliITSgeomTGeo::GetNLayers()];
 633   Int_t ** clmark=new Int_t*[AliITSgeomTGeo::GetNLayers()];
 634   Int_t * nnn = new Int_t[AliITSgeomTGeo::GetNLayers()];
 635   Int_t * kkk = new Int_t[AliITSgeomTGeo::GetNLayers()];
 636
 637   const Int_t maxclu=AliITStrackSA::GetMaxNumberOfClusters();
 638
 639   for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
 640     firstmod[i]=AliITSgeomTGeo::GetModuleIndex(i+1,1,1);
 641     listlayer[i] = new TObjArray(0,0);
 642     nnn[i]=0;
 643     kkk[i]=0;
 644     clind[i]=new Int_t[maxclu];
 645     clmark[i]=new Int_t[maxclu];
 646     for(Int_t j=0;j<maxclu; j++){
 647       clind[i][j]=0;
 648       clmark[i][j]=0;
 649     }
 650   }
 651
 652
 653   Int_t nclusters = tr->GetNumberOfClustersSA();
 654   for(Int_t ncl=0;ncl<nclusters;ncl++){
 655     Int_t index = tr->GetClusterIndexSA(ncl);
 656     AliITSRecPoint* cl = (AliITSRecPoint*)GetCluster(index);
 657     if(cl->TestBit(kSAflag)==kTRUE) cl->ResetBit(kSAflag);
 658     Int_t lay = (index & 0xf0000000) >> 28;
 659     listlayer[lay]->AddLast(cl);
 660     Int_t ind=nnn[lay];
 661     clind[lay][ind]=index;
 662   }
 663   delete [] nnn;
 664
 665   for(Int_t nlay=0;nlay<AliITSgeomTGeo::GetNLayers();nlay++){
 666     for(Int_t ncl=0;ncl<tr->GetNumberOfMarked(nlay);ncl++){
 667       Int_t mark = tr->GetClusterMark(nlay,ncl);
 668       Int_t ind=kkk[nlay];
 669       clmark[nlay][ind]=mark;
 670     }
 671   }
 672
 673   delete [] kkk;
 674
 675   Int_t firstLay=-1,secondLay=-1;
 676   Int_t * end = new Int_t[AliITSgeomTGeo::GetNLayers()];
 677   for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
 678     if(listlayer[i]->GetEntries()==0) {
 679       end[i]=1;
 680     } else {
 681       end[i]=listlayer[i]->GetEntries();
 682       if(firstLay==-1) {
 683         firstLay=i;
 684       } else if(secondLay==-1) {
 685         secondLay=i;
 686       }
 687     }
 688   }
 689
 690   TClonesArray* listSA = new TClonesArray("AliITStrackSA");
 691   TClonesArray &tri = *listSA;
 692   Int_t nlist=0;
 693
 694   for(Int_t l0=0;l0<end[0];l0++){ //loop on layer 1
 695     AliITSRecPoint* cl0 = (AliITSRecPoint*)listlayer[0]->At(l0);
 696     for(Int_t l1=0;l1<end[1];l1++){ //loop on layer 2
 697       AliITSRecPoint* cl1 = (AliITSRecPoint*)listlayer[1]->At(l1);
 698       for(Int_t l2=0;l2<end[2];l2++){  //loop on layer 3
 699         AliITSRecPoint* cl2 = (AliITSRecPoint*)listlayer[2]->At(l2);
 700         for(Int_t l3=0;l3<end[3];l3++){ //loop on layer 4
 701           AliITSRecPoint* cl3 = (AliITSRecPoint*)listlayer[3]->At(l3);
 702           for(Int_t l4=0;l4<end[4];l4++){ //loop on layer 5
 703             AliITSRecPoint* cl4 = (AliITSRecPoint*)listlayer[4]->At(l4);
 704             for(Int_t l5=0;l5<end[5];l5++){ //loop on layer 6
 705               AliITSRecPoint* cl5 = (AliITSRecPoint*)listlayer[5]->At(l5);
 706
 707
 708               Double_t x1,y1,z1,sx1,sy1,sz1;
 709               Double_t x2,y2,z2,sx2,sy2,sz2;
 710               AliITSRecPoint* p1=0;
 711               AliITSRecPoint* p2=0;
 712               Int_t index1=0,index2=0;
 713               Int_t mrk1=0,mrk2=0;
 714
 715               switch(firstLay) {
 716               case 0:
 717                 p1=cl0;
 718                 index1=clind[0][l0];mrk1=clmark[0][l0];
 719                 break;
 720               case 1:
 721                 p1=cl1;
 722                 index1=clind[1][l1];mrk1=clmark[1][l1];
 723                 break;
 724               case 2:
 725                 p1=cl2;
 726                 index1=clind[2][l2];mrk1=clmark[2][l2];
 727                 break;
 728               case 3:
 729                 p1=cl3;
 730                 index1=clind[3][l3];mrk1=clmark[3][l3];
 731                 break;
 732               case 4:
 733                 p1=cl4;
 734                 index1=clind[4][l4];mrk1=clmark[4][l4];
 735                 break;
 736               }
 737
 738               switch(secondLay) {
 739               case 1:
 740                 p2=cl1;
 741                 index2=clind[1][l1];mrk2=clmark[1][l1];
 742                 break;
 743               case 2:
 744                 p2=cl2;
 745                 index2=clind[2][l2];mrk2=clmark[2][l2];
 746                 break;
 747               case 3:
 748                 p2=cl3;
 749                 index2=clind[3][l3];mrk2=clmark[3][l3];
 750                 break;
 751               case 4:
 752                 p2=cl4;
 753                 index2=clind[4][l4];mrk2=clmark[4][l4];
 754                 break;
 755               case 5:
 756                 p2=cl5;
 757                 index2=clind[5][l5];mrk2=clmark[5][l5];
 758                 break;
 759               }
 760
 761               Int_t module1 = p1->GetDetectorIndex()+firstmod[firstLay];
 762
 763               Int_t cln1=mrk1;
 764               Int_t cln2=mrk2;
 765               AliITSclusterTable* arr1 = (AliITSclusterTable*)GetClusterCoord(firstLay,cln1);
 766               AliITSclusterTable* arr2 = (AliITSclusterTable*)GetClusterCoord(secondLay,cln2);
 767               x1 = arr1->GetX();
 768               x2 = arr2->GetX();
 769               y1 = arr1->GetY();
 770               y2 = arr2->GetY();
 771               z1 = arr1->GetZ();
 772               z2 = arr2->GetZ();
 773               sx1 = arr1->GetSx();
 774               sx2 = arr2->GetSx();
 775               sy1 = arr1->GetSy();
 776               sy2 = arr2->GetSy();
 777               sz1 = arr1->GetSz();
 778               sz2 = arr2->GetSz();
 779
 780               Int_t layer,ladder,detector;
 781               AliITSgeomTGeo::GetModuleId(module1,layer,ladder,detector);
 782               Float_t yclu1 = p1->GetY();
 783               Float_t zclu1 = p1->GetZ();
 784               Double_t cv=Curvature(primaryVertex[0],primaryVertex[1],x1,y1,x2,y2);
 785               Double_t tgl2 = (z2-z1)/TMath::Sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
 786               Double_t phi2 = TMath::ATan2((y2-y1),(x2-x1));
 787               AliITStrackSA* trac = new AliITStrackSA(layer,ladder,detector,yclu1,zclu1,phi2,tgl2,cv,1);
 788
 789               if(cl5!=0) {
 790                 trac->AddClusterV2(5,(clind[5][l5] & 0x0fffffff)>>0);
 791                 trac->AddClusterMark(5,clmark[5][l5]);
 792               }
 793               if(cl4!=0){
 794                 trac->AddClusterV2(4,(clind[4][l4] & 0x0fffffff)>>0);
 795                 trac->AddClusterMark(4,clmark[4][l4]);
 796               }
 797               if(cl3!=0){
 798                 trac->AddClusterV2(3,(clind[3][l3] & 0x0fffffff)>>0);
 799                 trac->AddClusterMark(3,clmark[3][l3]);
 800               }
 801               if(cl2!=0){
 802                 trac->AddClusterV2(2,(clind[2][l2] & 0x0fffffff)>>0);
 803                 trac->AddClusterMark(2,clmark[2][l2]);
 804               }
 805               if(cl1!=0){
 806                 trac->AddClusterV2(1,(clind[1][l1] & 0x0fffffff)>>0);
 807                 trac->AddClusterMark(1,clmark[1][l1]);
 808               }
 809               if(cl0!=0){
 810                 trac->AddClusterV2(0,(clind[0][l0] & 0x0fffffff)>>0);
 811                 trac->AddClusterMark(0,clmark[0][l0]);
 812               }
 813
 814
 815               //fit with Kalman filter using AliITStrackerMI::RefitAt()
 816               AliITStrackMI* ot = new AliITStrackSA(*trac);
 817
 818               ot->ResetCovariance(10.);
 819               ot->ResetClusters();
 820
 821               if(RefitAt(AliITSRecoParam::GetrInsideITSscreen(),ot,trac)){ //fit from layer 1 to layer 6
 822                 AliITStrackMI *otrack2 = new AliITStrackMI(*ot);
 823                 otrack2->ResetCovariance(10.);
 824                 otrack2->ResetClusters();
 825                 //fit from layer 6 to layer 1
 826                 if(RefitAt(AliITSRecoParam::GetrInsideSPD1(),otrack2,ot)) {
 827                   fListOfTracks->AddLast(otrack2);
 828                   new (tri[nlist]) AliITStrackSA(*trac);
 829                   nlist++;
 830                 } else {
 831                   delete otrack2;
 832                 }
 833
 834               }
 835
 836               delete ot;
 837               delete trac;
 838             }//end loop layer 6
 839           }//end loop layer 5
 840         }//end loop layer 4
 841       }//end loop layer 3
 842     }//end loop layer 2
 843   }//end loop layer 1
 844
 845   delete [] end;
 846
 847
 848
 849   Int_t dim=fListOfTracks->GetEntries();
 850   if(dim==0){
 851     for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
 852       delete listlayer[i];
 853       delete clind[i];
 854       delete clmark[i];
 855     }
 856     delete [] listlayer;
 857     delete [] clind;
 858     delete [] clmark;
 859     listSA->Delete();
 860     delete listSA;
 861     delete [] firstmod;
 862     return 0;
 863   }
 864
 865   Int_t lowchi2 = FindTrackLowChiSquare(fListOfTracks,dim);
 866   AliITStrackV2* otrack =(AliITStrackV2*)fListOfTracks->At(lowchi2);
 867   AliITStrackSA* trsa = (AliITStrackSA*)listSA->At(lowchi2);
 868
 869   if(otrack==0) {
 870     for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
 871       delete listlayer[i];
 872       delete clind[i];
 873       delete clmark[i];
 874     }
 875     delete [] listlayer;
 876     delete [] clind;
 877     delete [] clmark;
 878     listSA->Delete();
 879     delete listSA;
 880     delete [] firstmod;
 881     delete [] clind;
 882     delete [] clmark;
 883     return 0;
 884   }
 885   Int_t * indexc = new Int_t[AliITSgeomTGeo::GetNLayers()];
 886   for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) indexc[i]=0;
 887   for(Int_t nind=0;nind<otrack->GetNumberOfClusters();nind++){
 888     indexc[nind] = otrack->GetClusterIndex(nind);
 889   }
 890   Int_t labl[6][3];
 891   for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
 892     if(i<otrack->GetNumberOfClusters()) {
 893       AliITSRecPoint* cl = (AliITSRecPoint*)GetCluster(indexc[i]);
 894       labl[i][0]=cl->GetLabel(0);
 895       labl[i][1]=cl->GetLabel(1);
 896       labl[i][2]=cl->GetLabel(2);
 897     } else {
 898       labl[i][0]=-1;
 899       labl[i][1]=-1;
 900       labl[i][2]=-1;
 901     }
 902   }
 903   delete [] indexc;
 904
 905   CookLabel(otrack,0.); //MI change - to see fake ratio
 906
 907   Int_t label=FindLabel(labl[0][0],labl[1][0],labl[2][0],labl[3][0],labl[4][0],labl[5][0]);
 908   Int_t lflag=0;
 909   for(Int_t i=0;i<otrack->GetNumberOfClusters();i++)
 910     if(labl[i][0]==label || labl[i][1]==label || labl[i][2]==label) lflag++;
 911
 912   if(lflag<otrack->GetNumberOfClusters()) label = -label;
 913   otrack->SetLabel(label);
 914
 915   //remove clusters of found track
 916   for(Int_t nlay=0;nlay<AliITSgeomTGeo::GetNLayers();nlay++){
 917     for(Int_t cln=0;cln<trsa->GetNumberOfMarked(nlay);cln++){
 918       Int_t index = trsa->GetClusterMark(nlay,cln);
 919       fCluLayer[nlay]->RemoveAt(index);
 920       RemoveClusterCoord(nlay,index);
 921       fCluLayer[nlay]->Compress();
 922     }
 923   }
 924   listSA->Delete();
 925   delete listSA;
 926
 927   for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
 928     delete listlayer[i];
 929     delete clind[i];
 930     delete clmark[i];
 931   }
 932   delete [] listlayer;
 933   delete [] firstmod;
 934   delete [] clind;
 935   delete [] clmark;
 936   return otrack;
 937
 938 }
 939
 940
 941
 942 //_______________________________________________________
 943 Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t lambdawindow, AliITStrackSA* trs,Double_t /*zvertex*/,Int_t pflag){
 944   //function used to to find the clusters associated to the track
 945
 946   if(AliITSReconstructor::GetRecoParam()->GetLayersToSkip(layer)) return 0;
 947
 948   Int_t nc=0;
 949   AliITSlayer &lay = fgLayers[layer];
 950   Double_t r=lay.GetR();
 951   if(pflag==1){
 952     Float_t cx1,cx2,cy1,cy2;
 953     FindEquation(fPoint1[0],fPoint1[1],fPoint2[0],fPoint2[1],fPoint3[0],fPoint3[1],fCoef1,fCoef2,fCoef3);
 954     if (FindIntersection(fCoef1,fCoef2,fCoef3,-r*r,cx1,cy1,cx2,cy2)==0)
 955        return 0;
 956     Double_t fi1=TMath::ATan2(cy1-fPoint1[1],cx1-fPoint1[0]);
 957     Double_t fi2=TMath::ATan2(cy2-fPoint1[1],cx2-fPoint1[0]);
 958     fPhiEstimate=ChoosePoint(fi1,fi2,fPhic);
 959   }
 960
 961
 962   Int_t ncl = fCluLayer[layer]->GetEntries();
 963   for (Int_t index=0; index<ncl; index++) {
 964     AliITSRecPoint *c = (AliITSRecPoint*)fCluLayer[layer]->At(index);
 965     if (!c) continue;
 966     if (c->GetQ()<=0) continue;
 967
 968      AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(layer,index);
 969      Double_t phi = arr->GetPhi();
 970      if (TMath::Abs(phi-fPhiEstimate)>phiwindow) continue;
 971
 972      Double_t lambda = arr->GetLambda();
 973      if (TMath::Abs(lambda-fLambdac)>lambdawindow) continue;
 974
 975      if(trs->GetNumberOfClustersSA()==trs->GetMaxNumberOfClusters()) return 0;
 976      if(trs->GetNumberOfMarked(layer)==trs->GetMaxNMarkedPerLayer()) return 0;
 977      Int_t orind = arr->GetOrInd();
 978      trs->AddClusterSA(layer,orind);
 979      trs->AddClusterMark(layer,index);
 980
 981      nc++;
 982      fLambdac=lambda;
 983      fPhiEstimate=phi;
 984
 985      fPointc[0]=arr->GetX();
 986      fPointc[1]=arr->GetY();
 987
 988   }
 989   return nc;
 990 }
 991
 992 //________________________________________________________________
 993 void AliITStrackerSA::UpdatePoints(){
 994   //update of points for the estimation of the curvature
 995
 996   fPoint2[0]=fPoint3[0];
 997   fPoint2[1]=fPoint3[1];
 998   fPoint3[0]=fPointc[0];
 999   fPoint3[1]=fPointc[1];
1000
1001
1002 }
1003
1004 //___________________________________________________________________
1005 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){
1006
1007    //given (x,y) of three recpoints (in global coordinates)
1008    //returns the parameters a,b,c of circonference x*x + y*y +a*x + b*y +c
1009
1010    Float_t den = (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1);
1011    if(den==0) return 0;
1012    a = ((y3-y1)*(x2*x2+y2*y2-x1*x1-y1*y1)-(y2-y1)*(x3*x3+y3*y3-x1*x1-y1*y1))/den;
1013    b = -(x2*x2-x1*x1+y2*y2-y1*y1+a*(x2-x1))/(y2-y1);
1014    c = -x1*x1-y1*y1-a*x1-b*y1;
1015    return 1;
1016  }
1017 //__________________________________________________________________________
1018  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){
1019
1020  //Finds the intersection between the circonference of the track and the circonference centered in (0,0) represented by one layer
1021  //c2 is -rlayer*rlayer
1022
1023   if(a1==0) return 0;
1024  Double_t m = c2-c1;
1025  Double_t aA = (b1*b1)/(a1*a1)+1;
1026  Double_t bB = (-2*m*b1/(a1*a1));
1027  Double_t cC = c2+(m*m)/(a1*a1);
1028  Double_t dD = bB*bB-4*aA*cC;
1029  if(dD<0) return 0;
1030
1031  y1 = (-bB+TMath::Sqrt(dD))/(2*aA);
1032  y2 = (-bB-TMath::Sqrt(dD))/(2*aA);
1033  x1 = (c2-c1-b1*y1)/a1;
1034  x2 = (c2-c1-b1*y2)/a1;
1035
1036  return 1;
1037 }
1038 //____________________________________________________________________
1039 Double_t AliITStrackerSA::Curvature(Double_t x1,Double_t y1,Double_t
1040 x2,Double_t y2,Double_t x3,Double_t y3){
1041
1042   //calculates the curvature of track
1043   Double_t den = (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1);
1044   if(den==0) return 0;
1045   Double_t a = ((y3-y1)*(x2*x2+y2*y2-x1*x1-y1*y1)-(y2-y1)*(x3*x3+y3*y3-x1*x1-y1*y1))/den;
1046   Double_t b = -(x2*x2-x1*x1+y2*y2-y1*y1+a*(x2-x1))/(y2-y1);
1047   Double_t c = -x1*x1-y1*y1-a*x1-b*y1;
1048   Double_t xc=-a/2.;
1049
1050   if((a*a+b*b-4*c)<0) return 0;
1051   Double_t rad = TMath::Sqrt(a*a+b*b-4*c)/2.;
1052   if(rad==0) return 0;
1053
1054   if((x1>0 && y1>0 && x1<xc)) rad*=-1;
1055   if((x1<0 && y1>0 && x1<xc)) rad*=-1;
1056   //  if((x1<0 && y1<0 && x1<xc)) rad*=-1;
1057   // if((x1>0 && y1<0 && x1<xc)) rad*=-1;
1058
1059   return 1/rad;
1060
1061 }
1062
1063
1064 //____________________________________________________________________
1065 Double_t AliITStrackerSA::ChoosePoint(Double_t p1, Double_t p2, Double_t pp){
1066
1067   //Returns the point closest to pp
1068
1069   Double_t diff1 = p1-pp;
1070   Double_t diff2 = p2-pp;
1071
1072   if(TMath::Abs(diff1)<TMath::Abs(diff2)) fPhiEstimate=p1;
1073   else fPhiEstimate=p2;
1074   return fPhiEstimate;
1075
1076 }
1077
1078
1079 //_________________________________________________________________
1080 Int_t AliITStrackerSA::FindTrackLowChiSquare(TObjArray* tracklist, Int_t dim) const {
1081   // returns track with lowers chi square
1082   if(dim==1){
1083     //AliITStrackV2* trk = (AliITStrackV2*)tracklist->At(0);
1084     //return trk;
1085     return 0;
1086   }
1087   if(dim==0) return 0;
1088   Double_t * chi2 = new Double_t[dim];
1089   Int_t * index = new Int_t[dim];
1090   for(Int_t i=0;i<dim;i++){
1091     AliITStrackV2* trk = (AliITStrackV2*)tracklist->At(i);
1092     chi2[i]=trk->GetChi2();
1093     index[i]=i;
1094   }
1095
1096   Int_t w=0;Double_t value;
1097   Int_t lp;
1098   while(w<dim){
1099     for(Int_t j=w+1;j<dim;j++){
1100       if(chi2[w]<chi2[j]){
1101         value=chi2[w];
1102         chi2[w]=chi2[j];
1103         chi2[j]=value;
1104         lp=index[w];
1105         index[w]=index[j];
1106         index[j]=lp;
1107       }
1108     }
1109     w++;
1110   }
1111   Int_t tmp = index[dim-1];
1112   delete [] chi2;
1113   delete [] index;
1114   return tmp;
1115 }
1116
1117 //__________________________________________________________
1118 Int_t AliITStrackerSA::FindLabel(Int_t l0, Int_t l1, Int_t l2, Int_t l3, Int_t l4, Int_t l5){
1119
1120   //function used to determine the track label
1121
1122   Int_t lb[6] = {l0,l1,l2,l3,l4,l5};
1123   Int_t aa[6]={1,1,1,1,1,1};
1124   Int_t ff=0;
1125   Int_t ll=0;
1126   Int_t k=0;Int_t w=0;Int_t num=6;
1127   for(Int_t i=5;i>=0;i--) if(lb[i]==-1) num=i;
1128
1129   while(k<num){
1130
1131     for(Int_t i=k+1;i<num;i++){
1132
1133       if(lb[k]==lb[i] && aa[k]!=0){
1134
1135         aa[k]+=1;
1136         aa[i]=0;
1137       }
1138     }
1139     k++;
1140   }
1141
1142   while(w<num){
1143
1144     for(Int_t j=0;j<6;j++){
1145       if(aa[w]<aa[j]){
1146       ff=aa[w];
1147       aa[w]=aa[j];
1148       aa[j]=ff;
1149       ll=lb[w];
1150       lb[w]=lb[j];
1151       lb[j]=ll;
1152      }
1153     }
1154     w++;
1155   }
1156
1157   if(num<1) return -1;
1158   return lb[num-1];
1159 }
1160
1161 //_____________________________________________________________________________
1162 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,
1163 Int_t gl12, Int_t gl13, Int_t gl14,Int_t gl15, Int_t gl16, Int_t gl17, Int_t gl18, Int_t minNPoints){
1164
1165
1166   //function used to assign label to the found track. If track is fake, the label is negative
1167
1168   Int_t lb0[6] = {gl1,gl2,gl3,gl4,gl5,gl6};
1169   Int_t lb1[6] = {gl7,gl8,gl9,gl10,gl11,gl12};
1170   Int_t lb2[6] = {gl13,gl14,gl15,gl16,gl17,gl18};
1171   Int_t ll=FindLabel(lb0[0],lb0[1],lb0[2],lb0[3],lb0[4],lb0[5]);
1172   Int_t lflag=0;Int_t num=6;
1173   if(lb0[5]==-1 && lb1[5]==-1 && lb2[5]==-1) num=5;
1174
1175   for(Int_t i=0;i<num;i++){
1176     if(lb0[i]==ll || lb1[i]==ll || lb2[i]==ll) lflag+=1;
1177   }
1178
1179   if(lflag>=minNPoints) return ll;
1180   else return -ll;
1181
1182
1183 }
1184
1185 //_____________________________________________________________________________
1186 void AliITStrackerSA::SetWindowSizes(Int_t n, Double_t *phi, Double_t *lam){
1187   // Set sizes of the phi and lambda windows used for track finding
1188   fNloop = n;
1189   if(phi){ // user defined values
1190     fPhiWin = new Double_t[fNloop];
1191     fLambdaWin = new Double_t[fNloop];
1192     for(Int_t k=0;k<fNloop;k++){
1193       fPhiWin[k]=phi[k];
1194       fLambdaWin[k]=lam[k];
1195     }
1196   }
1197   else {  // default values
1198
1199     Double_t phid[33]   = {0.002,0.003,0.004,0.0045,0.0047,
1200                            0.005,0.0053,0.0055,
1201                            0.006,0.0063,0.0065,0.007,0.0073,0.0075,0.0077,
1202                            0.008,0.0083,0.0085,0.0087,0.009,0.0095,0.0097,
1203                            0.01,0.0105,0.011,0.0115,0.012,0.0125,0.013,0.0135,0.0140,0.0145};
1204     Double_t lambdad[33] = {0.003,0.004,0.005,0.005,0.005,
1205                             0.005,0.005,0.006,
1206                             0.006,0.006,0.006,0.007,0.007,0.007,0.007,
1207                             0.007,0.007,0.007,0.007,0.007,0.007,0.007,
1208                             0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008};
1209
1210     if(fNloop!=33){
1211       fNloop = 33;
1212     }
1213
1214
1215     fPhiWin = new Double_t[fNloop];
1216     fLambdaWin = new Double_t[fNloop];
1217
1218     Double_t factor=AliITSReconstructor::GetRecoParam()->GetFactorSAWindowSizes(); // possibility to enlarge windows for cosmics reco with large misalignments (A.Dainese)
1219
1220     for(Int_t k=0;k<fNloop;k++){
1221       fPhiWin[k]=phid[k]*factor;
1222       fLambdaWin[k]=lambdad[k]*factor;
1223     }
1224
1225   }
1226
1227 }
1228 //_______________________________________________________________________
1229 void AliITStrackerSA::GetCoorAngles(AliITSRecPoint* cl,Double_t &phi,Double_t &lambda, Float_t &x, Float_t &y,Float_t &z,Double_t* vertex){
1230   //Returns values of phi (azimuthal) and lambda angles for a given cluster
1231 /*
1232   Double_t rot[9];     fGeom->GetRotMatrix(module,rot);
1233   Int_t lay,lad,det; fGeom->GetModuleId(module,lay,lad,det);
1234   Float_t tx,ty,tz;  fGeom->GetTrans(lay,lad,det,tx,ty,tz);
1235
1236   Double_t alpha=TMath::ATan2(rot[1],rot[0])+TMath::Pi();
1237   Double_t phi1=TMath::Pi()/2+alpha;
1238   if (lay==1) phi1+=TMath::Pi();
1239
1240   Float_t cp=TMath::Cos(phi1), sp=TMath::Sin(phi1);
1241   Float_t r=tx*cp+ty*sp;
1242
1243   xyz= r*cp - cl->GetY()*sp;
1244   y= r*sp + cl->GetY()*cp;
1245   z=cl->GetZ();
1246 */
1247   Float_t xyz[3];
1248   cl->GetGlobalXYZ(xyz);
1249   x=xyz[0];
1250   y=xyz[1];
1251   z=xyz[2];
1252
1253   phi=TMath::ATan2(y-vertex[1],x-vertex[0]);
1254   lambda=TMath::ATan2(z-vertex[2],TMath::Sqrt((x-vertex[0])*(x-vertex[0])+(y-vertex[1])*(y-vertex[1])));
1255 }
1256
1257 //________________________________________________________________________
1258 void AliITStrackerSA::GetCoorErrors(AliITSRecPoint* cl,Float_t &sx,Float_t &sy, Float_t &sz){
1259
1260   //returns sigmax, y, z of cluster in global coordinates
1261 /*
1262   Double_t rot[9];     fGeom->GetRotMatrix(module,rot);
1263   Int_t lay,lad,det;
1264   AliITSgeomTGeo::GetModuleId(module,lay,lad,det);
1265
1266   Double_t alpha=TMath::ATan2(rot[1],rot[0])+TMath::Pi();
1267   Double_t phi=TMath::Pi()/2+alpha;
1268   if (lay==1) phi+=TMath::Pi();
1269
1270   Float_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
1271 */
1272   Float_t covm[6];
1273   cl->GetGlobalCov(covm);
1274   sx=TMath::Sqrt(covm[0]);
1275   sy=TMath::Sqrt(covm[3]);
1276   sz=TMath::Sqrt(covm[5]);
1277 /*
1278   sx = TMath::Sqrt(sp*sp*cl->GetSigmaY2());
1279   sy = TMath::Sqrt(cp*cp*cl->GetSigmaY2());
1280   sz = TMath::Sqrt(cl->GetSigmaZ2());
1281 */
1282 }
1283