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