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           while(goon){
 495             kk++;
 496             nClusLay[kk] = SearchClusters(nextLay,fPhiWin[nloop],fLambdaWin[nloop],
 497                                             &trs,primaryVertex[2],pflag);
 498             if(nClusLay[kk]!=0){
 499               pflag=1;
 500               if(kk==1) {
 501                 fPoint3[0]=fPointc[0];
 502                 fPoint3[1]=fPointc[1];
 503               } else {
 504                 UpdatePoints();
 505               }
 506             }
 507             nextLay+=seedStep;
 508             if(nextLay<0 || nextLay==6) goon=kFALSE;
 509           }
 510
 511
 512           Int_t layOK=0;
 513           if(!fInwardFlag){
 514             for(Int_t nnp=0;nnp<AliITSgeomTGeo::GetNLayers()-theLay;nnp++){
 515               if(nClusLay[nnp]!=0) layOK+=1;
 516             }
 517           }else{
 518             for(Int_t nnp=theLay; nnp>=0; nnp--){
 519               if(nClusLay[nnp]!=0) layOK+=1;
 520             }
 521           }
 522           if(layOK>=minNPoints){
 523             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]));
 524             AliITStrackV2* tr2 = 0;
 525             tr2 = FitTrack(&trs,primaryVertex);
 526             if(!tr2){
 527               continue;
 528             }
 529             AliDebug(2,Form("---NPOINTS fit: %d\n",tr2->GetNumberOfClusters()));
 530
 531             StoreTrack(tr2,event,useAllClusters);
 532             ntrack++;
 533
 534           }
 535
 536         }//end loop on clusters of theLay
 537       } //end loop on window sizes
 538     } //end loop on theLay
 539   }//end loop on min points
 540
 541   // search for 1-point tracks in SPD, only for cosmics
 542   // (A.Dainese 21.03.08)
 543   if(AliITSReconstructor::GetRecoParam()->GetSAOnePointTracks() &&
 544      TMath::Abs(event->GetMagneticField())<0.01) {
 545     Int_t outerLayer=1; // only SPD
 546     for(Int_t innLay=0; innLay<=TMath::Min(1,fOuterStartLayer); innLay++) {
 547       //   counter for clusters on each layer
 548
 549       for(Int_t nloop=0;nloop<fNloop;nloop++){
 550         Int_t nclInnLay=fCluLayer[innLay]->GetEntries();
 551         while(nclInnLay--){ //loop starting from layer innLay
 552           ResetForFinding();
 553           Bool_t useRP=SetFirstPoint(innLay,nclInnLay,primaryVertex);
 554           if(!useRP) continue;
 555           AliITStrackSA trs;
 556
 557           Int_t pflag=0;
 558           Int_t kk;
 559           for(kk=0;kk<AliITSgeomTGeo::GetNLayers();kk++) nClusLay[kk] = 0;
 560
 561           kk=0;
 562           nClusLay[kk] = SearchClusters(innLay,fPhiWin[nloop],fLambdaWin[nloop],
 563                                   &trs,primaryVertex[2],pflag);
 564           for(Int_t nextLay=innLay+1; nextLay<=outerLayer; nextLay++) {
 565             kk++;
 566             nClusLay[kk] = SearchClusters(nextLay,fPhiWin[nloop],fLambdaWin[nloop],
 567                                     &trs,primaryVertex[2],pflag);
 568             if(nClusLay[kk]!=0){
 569               pflag=1;
 570               if(kk==1) {
 571                 fPoint3[0]=fPointc[0];
 572                 fPoint3[1]=fPointc[1];
 573               } else {
 574                 UpdatePoints();
 575               }
 576             }
 577           }
 578
 579           Int_t layOK=0;
 580           for(Int_t nnp=0;nnp<AliITSgeomTGeo::GetNLayers()-innLay;nnp++){
 581             if(nClusLay[nnp]!=0) layOK+=1;
 582           }
 583           if(layOK==1) {
 584             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]));
 585             AliITStrackV2* tr2 = 0;
 586             Bool_t onePoint = kTRUE;
 587             tr2 = FitTrack(&trs,primaryVertex,onePoint);
 588             if(!tr2){
 589               continue;
 590             }
 591             AliDebug(2,Form("----NPOINTS fit: %d\n",tr2->GetNumberOfClusters()));
 592
 593             StoreTrack(tr2,event,useAllClusters);
 594             ntrack++;
 595
 596           }
 597
 598         }//end loop on clusters of innLay
 599       } //end loop on window sizes
 600
 601     } //end loop on innLay
 602   } // end search 1-point tracks
 603
 604   if(!useAllClusters) AliInfo(Form("Number of found tracks: %d",event->GetNumberOfTracks()));
 605   ResetForFinding();
 606   return 0;
 607
 608 }
 609
 610 //________________________________________________________________________
 611
 612 AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVertex,Bool_t onePoint) {
 613   //fit of the found track (most general case, also <6 points, layers missing)
 614   // A.Dainese 16.11.07
 615
 616
 617   const Int_t kMaxClu=AliITStrackSA::kMaxNumberOfClusters;
 618
 619   static Int_t firstmod[AliITSgeomTGeo::kNLayers];
 620   static Int_t clind[AliITSgeomTGeo::kNLayers][kMaxClu];
 621   static Int_t clmark[AliITSgeomTGeo::kNLayers][kMaxClu];
 622   static Int_t end[AliITSgeomTGeo::kNLayers];
 623   static Int_t indices[AliITSgeomTGeo::kNLayers];
 624
 625   static AliITSRecPoint *listlayer[AliITSgeomTGeo::kNLayers][kMaxClu];
 626
 627   for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
 628     firstmod[i]=AliITSgeomTGeo::GetModuleIndex(i+1,1,1);
 629     end[i]=0;
 630     for(Int_t j=0;j<kMaxClu; j++){
 631       clind[i][j]=0;
 632       clmark[i][j]=0;
 633       listlayer[i][j]=0;
 634    }
 635   }
 636
 637
 638   Int_t nclusters = tr->GetNumberOfClustersSA();
 639   for(Int_t ncl=0;ncl<nclusters;ncl++){
 640     Int_t index = tr->GetClusterIndexSA(ncl);
 641     AliITSRecPoint* cl = (AliITSRecPoint*)GetCluster(index);
 642     Int_t lay = (index & 0xf0000000) >> 28;
 643     Int_t nInLay=end[lay];
 644     listlayer[lay][nInLay]=cl;
 645     clind[lay][nInLay]=index;
 646     end[lay]++;
 647   }
 648
 649   for(Int_t nlay=0;nlay<AliITSgeomTGeo::GetNLayers();nlay++){
 650     for(Int_t ncl=0;ncl<tr->GetNumberOfMarked(nlay);ncl++){
 651       Int_t mark = tr->GetClusterMark(nlay,ncl);
 652       clmark[nlay][ncl]=mark;
 653     }
 654   }
 655
 656
 657   Int_t firstLay=-1,secondLay=-1;
 658   for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
 659     if(end[i]==0) {
 660       end[i]=1;
 661     }else{
 662       if(firstLay==-1) {
 663         firstLay=i;
 664       } else if(secondLay==-1) {
 665         secondLay=i;
 666       }
 667     }
 668   }
 669
 670   if(firstLay==-1 || (secondLay==-1 && !onePoint)) return 0;
 671   TClonesArray &arrMI= *fListOfTracks;
 672   TClonesArray &arrSA= *fListOfSATracks;
 673   Int_t nFoundTracks=0;
 674
 675
 676   for(Int_t l0=0;l0<end[0];l0++){ //loop on layer 1
 677     indices[0]=l0;
 678     for(Int_t l1=0;l1<end[1];l1++){ //loop on layer 2
 679       indices[1]=l1;
 680       for(Int_t l2=0;l2<end[2];l2++){  //loop on layer 3
 681         indices[2]=l2;
 682         for(Int_t l3=0;l3<end[3];l3++){ //loop on layer 4
 683           indices[3]=l3;
 684           for(Int_t l4=0;l4<end[4];l4++){ //loop on layer 5
 685             indices[4]=l4;
 686             for(Int_t l5=0;l5<end[5];l5++){ //loop on layer 6
 687               indices[5]=l5;
 688
 689               // estimate curvature from 2 innermost points (or innermost point + vertex)
 690
 691               Int_t iFirstLay=indices[firstLay];
 692               Int_t mrk1=clmark[firstLay][iFirstLay];
 693
 694               AliITSRecPoint* p1=(AliITSRecPoint*)listlayer[firstLay][iFirstLay];
 695               Int_t module1 = p1->GetDetectorIndex()+firstmod[firstLay];
 696               Int_t layer,ladder,detector;
 697               AliITSgeomTGeo::GetModuleId(module1,layer,ladder,detector);
 698               Float_t yclu1 = p1->GetY();
 699               Float_t zclu1 = p1->GetZ();
 700
 701               Double_t x1,y1,z1;
 702               Double_t x2,y2,z2;
 703               Double_t cv=0,tgl2=0,phi2=0;
 704               AliITSclusterTable* arr1 = (AliITSclusterTable*)GetClusterCoord(firstLay,mrk1);
 705               x1 = arr1->GetX();
 706               y1 = arr1->GetY();
 707               z1 = arr1->GetZ();
 708
 709               if(secondLay>0) {
 710                 Int_t iSecondLay=indices[secondLay];
 711                 Int_t mrk2=clmark[secondLay][iSecondLay];
 712                 AliITSclusterTable* arr2 = (AliITSclusterTable*)GetClusterCoord(secondLay,mrk2);
 713                 x2 = arr2->GetX();
 714                 y2 = arr2->GetY();
 715                 z2 = arr2->GetZ();
 716                 cv = Curvature(primaryVertex[0],primaryVertex[1],x1,y1,x2,y2);
 717                 tgl2 = (z2-z1)/TMath::Sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
 718                 phi2 = TMath::ATan2((y2-y1),(x2-x1));
 719               } else { // special case of 1-point tracks, only for cosmics (B=0)
 720                 x2 = primaryVertex[0];
 721                 y2 = primaryVertex[1];
 722                 z2 = primaryVertex[2];
 723                 cv = 0;
 724                 tgl2 = (z1-z2)/TMath::Sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
 725                 phi2 = TMath::ATan2((y1-y2),(x1-x2));
 726               }
 727
 728               // create track and attach it the RecPoints
 729               AliITStrackSA trac(layer,ladder,detector,yclu1,zclu1,phi2,tgl2,cv,1);
 730               for(Int_t iLay=5; iLay>=0; iLay--){
 731                 Int_t iInLay=indices[iLay];
 732                 AliITSRecPoint* cl=(AliITSRecPoint*)listlayer[iLay][iInLay];
 733                 if(cl!=0){
 734                   trac.AddClusterV2(iLay,(clind[iLay][iInLay] & 0x0fffffff)>>0);
 735                   trac.AddClusterMark(iLay,clmark[iLay][iInLay]);
 736                 }
 737               }
 738
 739               //fit with Kalman filter using AliITStrackerMI::RefitAt()
 740               AliITStrackSA ot(trac);
 741
 742               ot.ResetCovariance(10.);
 743               ot.ResetClusters();
 744
 745               // Propagate inside the innermost layer with a cluster
 746               if(ot.Propagate(ot.GetX()-0.1*ot.GetX())) {
 747
 748                 if(RefitAt(AliITSRecoParam::GetrInsideITSscreen(),&ot,&trac)){ //fit from layer 1 to layer 6
 749                   AliITStrackMI otrack2(ot);
 750                   otrack2.ResetCovariance(10.);
 751                   otrack2.ResetClusters();
 752                   //fit from layer 6 to layer 1
 753                   if(RefitAt(AliITSRecoParam::GetrInsideSPD1(),&otrack2,&ot)) {
 754                     new(arrMI[nFoundTracks]) AliITStrackMI(otrack2);
 755                     new(arrSA[nFoundTracks]) AliITStrackSA(trac);
 756                     ++nFoundTracks;
 757                   }
 758
 759                 }
 760               }
 761             }//end loop layer 6
 762           }//end loop layer 5
 763         }//end loop layer 4
 764       }//end loop layer 3
 765     }//end loop layer 2
 766   }//end loop layer 1
 767
 768
 769
 770
 771   if(fListOfTracks->GetEntries()==0) return 0;
 772
 773   Int_t lowchi2 = FindTrackLowChiSquare();
 774   AliITStrackV2* otrack =(AliITStrackV2*)fListOfTracks->At(lowchi2);
 775   AliITStrackSA* trsa = (AliITStrackSA*)fListOfSATracks->At(lowchi2);
 776
 777   if(otrack==0) return 0;
 778
 779   CookLabel(otrack,0.); //MI change - to see fake ratio
 780   Int_t label=FindLabel(otrack);
 781   otrack->SetLabel(label);
 782   Double_t low=0.;
 783   Double_t up=0.51;
 784   otrack->CookdEdx(low,up);
 785
 786   //remove clusters of found track
 787   for(Int_t nlay=0;nlay<AliITSgeomTGeo::GetNLayers();nlay++){
 788     for(Int_t cln=0;cln<trsa->GetNumberOfMarked(nlay);cln++){
 789       Int_t index = trsa->GetClusterMark(nlay,cln);
 790       fCluLayer[nlay]->RemoveAt(index);
 791       RemoveClusterCoord(nlay,index);
 792       fCluLayer[nlay]->Compress();
 793     }
 794   }
 795
 796   return otrack;
 797
 798 }
 799
 800 //_______________________________________________________
 801 void AliITStrackerSA::StoreTrack(AliITStrackV2 *t,AliESDEvent *event, Bool_t pureSA) const
 802 {
 803   //
 804   // Add new track to the ESD
 805   //
 806   AliESDtrack outtrack;
 807   outtrack.UpdateTrackParams(t,AliESDtrack::kITSin);
 808   if(pureSA) outtrack.SetStatus(AliESDtrack::kITSpureSA);
 809   for(Int_t i=0;i<12;i++) {
 810     outtrack.SetITSModuleIndex(i,t->GetModuleIndex(i));
 811   }
 812   Double_t sdedx[4]={0.,0.,0.,0.};
 813   for(Int_t i=0; i<4; i++) sdedx[i]=t->GetSampledEdx(i);
 814   outtrack.SetITSdEdxSamples(sdedx);
 815   event->AddTrack(&outtrack);
 816
 817   return;
 818 }
 819
 820
 821 //_______________________________________________________
 822 Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t lambdawindow, AliITStrackSA* trs,Double_t /*zvertex*/,Int_t pflag){
 823   //function used to to find the clusters associated to the track
 824
 825   if(ForceSkippingOfLayer(layer)) return 0;
 826
 827   Int_t nc=0;
 828   AliITSlayer &lay = fgLayers[layer];
 829   Double_t r=lay.GetR();
 830   if(pflag==1){
 831     Float_t cx1,cx2,cy1,cy2;
 832     FindEquation(fPoint1[0],fPoint1[1],fPoint2[0],fPoint2[1],fPoint3[0],fPoint3[1],fCoef1,fCoef2,fCoef3);
 833     if (FindIntersection(fCoef1,fCoef2,fCoef3,-r*r,cx1,cy1,cx2,cy2)==0)
 834        return 0;
 835     Double_t fi1=TMath::ATan2(cy1-fPoint1[1],cx1-fPoint1[0]);
 836     Double_t fi2=TMath::ATan2(cy2-fPoint1[1],cx2-fPoint1[0]);
 837     fPhiEstimate=ChoosePoint(fi1,fi2,fPhic);
 838   }
 839
 840
 841   Double_t phiExpect=fPhiEstimate;
 842   Double_t lamExpect=fLambdac;
 843
 844   Int_t ncl = fCluLayer[layer]->GetEntriesFast();
 845   for (Int_t index=0; index<ncl; index++) {
 846     AliITSRecPoint *c = (AliITSRecPoint*)fCluLayer[layer]->UncheckedAt(index);
 847     if (!c) continue;
 848
 849     AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(layer,index);
 850
 851     Double_t lambda = arr->GetLambda();
 852     if (TMath::Abs(lambda-lamExpect)>lambdawindow) continue;
 853
 854     Double_t phi = arr->GetPhi();
 855     Double_t deltaPhi = phi-phiExpect;
 856     if(deltaPhi>TMath::Pi()) deltaPhi-=2*TMath::Pi();
 857     else if(deltaPhi<-TMath::Pi()) deltaPhi+=2*TMath::Pi();
 858     if (TMath::Abs(deltaPhi)>phiwindow) continue;
 859
 860     if(trs->GetNumberOfClustersSA()==trs->GetMaxNumberOfClusters()) return 0;
 861     if(trs->GetNumberOfMarked(layer)==trs->GetMaxNMarkedPerLayer()) return 0;
 862     Int_t orind = arr->GetOrInd();
 863     trs->AddClusterSA(layer,orind);
 864     trs->AddClusterMark(layer,index);
 865     nc++;
 866     fLambdac=lambda;
 867     fPhiEstimate=phi;
 868
 869     fPointc[0]=arr->GetX();
 870     fPointc[1]=arr->GetY();
 871
 872   }
 873   return nc;
 874 }
 875
 876 //________________________________________________________________
 877 Bool_t AliITStrackerSA::SetFirstPoint(Int_t lay, Int_t clu, Double_t* primaryVertex){
 878   // Sets the first point (seed) for tracking
 879
 880   AliITSRecPoint* cl = (AliITSRecPoint*)fCluLayer[lay]->UncheckedAt(clu);
 881   if(!cl) return kFALSE;
 882   if (cl->GetQ()<=0) return kFALSE;
 883   if(lay>1 && cl->GetQ()<=fMinQ) return kFALSE;
 884
 885   AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(lay,clu);
 886   fPhic = arr->GetPhi();
 887   fLambdac = arr->GetLambda();
 888   fPhiEstimate = fPhic;
 889   fPoint1[0]=primaryVertex[0];
 890   fPoint1[1]=primaryVertex[1];
 891   fPoint2[0]=arr->GetX();
 892   fPoint2[1]=arr->GetY();
 893   return kTRUE;
 894 }
 895
 896 //________________________________________________________________
 897 void AliITStrackerSA::UpdatePoints(){
 898   //update of points for the estimation of the curvature
 899
 900   fPoint2[0]=fPoint3[0];
 901   fPoint2[1]=fPoint3[1];
 902   fPoint3[0]=fPointc[0];
 903   fPoint3[1]=fPointc[1];
 904
 905
 906 }
 907
 908 //___________________________________________________________________
 909 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){
 910
 911    //given (x,y) of three recpoints (in global coordinates)
 912    //returns the parameters a,b,c of circonference x*x + y*y +a*x + b*y +c
 913
 914    Float_t den = (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1);
 915    if(den==0) return 0;
 916    a = ((y3-y1)*(x2*x2+y2*y2-x1*x1-y1*y1)-(y2-y1)*(x3*x3+y3*y3-x1*x1-y1*y1))/den;
 917    b = -(x2*x2-x1*x1+y2*y2-y1*y1+a*(x2-x1))/(y2-y1);
 918    c = -x1*x1-y1*y1-a*x1-b*y1;
 919    return 1;
 920  }
 921 //__________________________________________________________________________
 922  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){
 923
 924  //Finds the intersection between the circonference of the track and the circonference centered in (0,0) represented by one layer
 925  //c2 is -rlayer*rlayer
 926
 927   if(a1==0) return 0;
 928  Double_t m = c2-c1;
 929  Double_t aA = (b1*b1)/(a1*a1)+1;
 930  Double_t bB = (-2*m*b1/(a1*a1));
 931  Double_t cC = c2+(m*m)/(a1*a1);
 932  Double_t dD = bB*bB-4*aA*cC;
 933  if(dD<0) return 0;
 934
 935  y1 = (-bB+TMath::Sqrt(dD))/(2*aA);
 936  y2 = (-bB-TMath::Sqrt(dD))/(2*aA);
 937  x1 = (c2-c1-b1*y1)/a1;
 938  x2 = (c2-c1-b1*y2)/a1;
 939
 940  return 1;
 941 }
 942 //____________________________________________________________________
 943 Double_t AliITStrackerSA::Curvature(Double_t x1,Double_t y1,Double_t
 944 x2,Double_t y2,Double_t x3,Double_t y3){
 945
 946   //calculates the curvature of track
 947   Double_t den = (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1);
 948   if(den==0) return 0;
 949   Double_t a = ((y3-y1)*(x2*x2+y2*y2-x1*x1-y1*y1)-(y2-y1)*(x3*x3+y3*y3-x1*x1-y1*y1))/den;
 950   Double_t b = -(x2*x2-x1*x1+y2*y2-y1*y1+a*(x2-x1))/(y2-y1);
 951   Double_t c = -x1*x1-y1*y1-a*x1-b*y1;
 952   Double_t xc=-a/2.;
 953
 954   if((a*a+b*b-4*c)<0) return 0;
 955   Double_t rad = TMath::Sqrt(a*a+b*b-4*c)/2.;
 956   if(rad==0) return 0;
 957
 958   if((x1>0 && y1>0 && x1<xc)) rad*=-1;
 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
 963   return 1/rad;
 964
 965 }
 966
 967
 968 //____________________________________________________________________
 969 Double_t AliITStrackerSA::ChoosePoint(Double_t p1, Double_t p2, Double_t pp){
 970
 971   //Returns the point closest to pp
 972
 973   Double_t diff1 = p1-pp;
 974   Double_t diff2 = p2-pp;
 975
 976   if(TMath::Abs(diff1)<TMath::Abs(diff2)) fPhiEstimate=p1;
 977   else fPhiEstimate=p2;
 978   return fPhiEstimate;
 979
 980 }
 981
 982
 983 //_________________________________________________________________
 984 Int_t AliITStrackerSA::FindTrackLowChiSquare() const {
 985   // returns track with lowest chi square
 986   Int_t dim=fListOfTracks->GetEntries();
 987   if(dim<=1) return 0;
 988   AliITStrackV2* trk = (AliITStrackV2*)fListOfTracks->At(0);
 989   Double_t minChi2=trk->GetChi2();
 990   Int_t index=0;
 991   for(Int_t i=1;i<dim;i++){
 992     trk = (AliITStrackV2*)fListOfTracks->At(i);
 993     Double_t chi2=trk->GetChi2();
 994     if(chi2<minChi2){
 995       minChi2=chi2;
 996       index=i;
 997     }
 998   }
 999   return index;
1000 }
1001
1002 //__________________________________________________________
1003 Int_t AliITStrackerSA::FindLabel(AliITStrackV2* track){
1004   //
1005
1006   Int_t labl[AliITSgeomTGeo::kNLayers][3];
1007   Int_t cnts[AliITSgeomTGeo::kNLayers][3];
1008   for(Int_t j=0;j<AliITSgeomTGeo::GetNLayers();j++){
1009     for(Int_t k=0;k<3;k++){
1010       labl[j][k]=-2;
1011       cnts[j][k]=1;
1012     }
1013   }
1014   Int_t iNotLabel=0;
1015   for(Int_t i=0;i<track->GetNumberOfClusters(); i++) {
1016     Int_t indexc = track->GetClusterIndex(i);
1017     AliITSRecPoint* cl = (AliITSRecPoint*)GetCluster(indexc);
1018     Int_t iLayer=cl->GetLayer();
1019     for(Int_t k=0;k<3;k++){
1020       labl[iLayer][k]=cl->GetLabel(k);
1021       if(labl[iLayer][k]<0) iNotLabel++;
1022     }
1023   }
1024   if(iNotLabel==3*track->GetNumberOfClusters()) return -2;
1025
1026   for(Int_t j1=0;j1<AliITSgeomTGeo::kNLayers; j1++) {
1027     for(Int_t j2=0; j2<j1;  j2++){
1028       for(Int_t k1=0; k1<3; k1++){
1029         for(Int_t k2=0; k2<3; k2++){
1030           if(labl[j1][k1]>=0 && labl[j1][k1]==labl[j2][k2] && cnts[j2][k2]>0){
1031             cnts[j2][k2]++;
1032             cnts[j1][k1]=0;
1033           }
1034         }
1035       }
1036     }
1037   }
1038
1039
1040   Int_t cntMax=0;
1041   Int_t label=-1;
1042   for(Int_t j=0;j<AliITSgeomTGeo::kNLayers;j++){
1043     for(Int_t k=0;k<3;k++){
1044       if(cnts[j][k]>cntMax && labl[j][k]>=0){
1045         cntMax=cnts[j][k];
1046         label=labl[j][k];
1047       }
1048     }
1049   }
1050
1051   Int_t lflag=0;
1052   for(Int_t i=0;i<AliITSgeomTGeo::kNLayers;i++)
1053     if(labl[i][0]==label || labl[i][1]==label || labl[i][2]==label) lflag++;
1054
1055   if(lflag<track->GetNumberOfClusters()) label = -label;
1056   return label;
1057 }
1058 //_____________________________________________________________________________
1059 void AliITStrackerSA::SetCalculatedWindowSizes(Int_t n, Float_t phimin, Float_t phimax, Float_t lambdamin, Float_t lambdamax){
1060   // Set sizes of the phi and lambda windows used for track finding
1061   fNloop = n;
1062   if(fPhiWin) delete [] fPhiWin;
1063   if(fLambdaWin) delete [] fLambdaWin;
1064   fPhiWin = new Double_t[fNloop];
1065   fLambdaWin = new Double_t[fNloop];
1066   Float_t stepPhi=(phimax-phimin)/(Float_t)(fNloop-1);
1067   Float_t stepLambda=(lambdamax-lambdamin)/(Float_t)(fNloop-1);
1068   for(Int_t k=0;k<fNloop;k++){
1069     Float_t phi=phimin+k*stepPhi;
1070     Float_t lam=lambdamin+k*stepLambda;
1071     fPhiWin[k]=phi;
1072     fLambdaWin[k]=lam;
1073   }
1074 }
1075 //_____________________________________________________________________________
1076 void AliITStrackerSA::SetFixedWindowSizes(Int_t n, Double_t *phi, Double_t *lam){
1077   // Set sizes of the phi and lambda windows used for track finding
1078   fNloop = n;
1079   if(phi){ // user defined values
1080     fPhiWin = new Double_t[fNloop];
1081     fLambdaWin = new Double_t[fNloop];
1082     for(Int_t k=0;k<fNloop;k++){
1083       fPhiWin[k]=phi[k];
1084       fLambdaWin[k]=lam[k];
1085     }
1086   }
1087   else {  // default values
1088
1089     Double_t phid[33]   = {0.002,0.003,0.004,0.0045,0.0047,
1090                            0.005,0.0053,0.0055,
1091                            0.006,0.0063,0.0065,0.007,0.0073,0.0075,0.0077,
1092                            0.008,0.0083,0.0085,0.0087,0.009,0.0095,0.0097,
1093                            0.01,0.0105,0.011,0.0115,0.012,0.0125,0.013,0.0135,0.0140,0.0145};
1094     Double_t lambdad[33] = {0.003,0.004,0.005,0.005,0.005,
1095                             0.005,0.005,0.006,
1096                             0.006,0.006,0.006,0.007,0.007,0.007,0.007,
1097                             0.007,0.007,0.007,0.007,0.007,0.007,0.007,
1098                             0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008};
1099
1100     if(fNloop!=33){
1101       fNloop = 33;
1102     }
1103
1104
1105     fPhiWin = new Double_t[fNloop];
1106     fLambdaWin = new Double_t[fNloop];
1107
1108     Double_t factor=AliITSReconstructor::GetRecoParam()->GetFactorSAWindowSizes(); // possibility to enlarge windows for cosmics reco with large misalignments (A.Dainese)
1109
1110     for(Int_t k=0;k<fNloop;k++){
1111       fPhiWin[k]=phid[k]*factor;
1112       fLambdaWin[k]=lambdad[k]*factor;
1113     }
1114
1115   }
1116
1117 }
1118 //_______________________________________________________________________
1119 void AliITStrackerSA::GetCoorAngles(AliITSRecPoint* cl,Double_t &phi,Double_t &lambda, Float_t &x, Float_t &y,Float_t &z,Double_t* vertex){
1120   //Returns values of phi (azimuthal) and lambda angles for a given cluster
1121 /*
1122   Double_t rot[9];     fGeom->GetRotMatrix(module,rot);
1123   Int_t lay,lad,det; fGeom->GetModuleId(module,lay,lad,det);
1124   Float_t tx,ty,tz;  fGeom->GetTrans(lay,lad,det,tx,ty,tz);
1125
1126   Double_t alpha=TMath::ATan2(rot[1],rot[0])+TMath::Pi();
1127   Double_t phi1=TMath::Pi()/2+alpha;
1128   if (lay==1) phi1+=TMath::Pi();
1129
1130   Float_t cp=TMath::Cos(phi1), sp=TMath::Sin(phi1);
1131   Float_t r=tx*cp+ty*sp;
1132
1133   xyz= r*cp - cl->GetY()*sp;
1134   y= r*sp + cl->GetY()*cp;
1135   z=cl->GetZ();
1136 */
1137   Float_t xyz[3];
1138   cl->GetGlobalXYZ(xyz);
1139   x=xyz[0];
1140   y=xyz[1];
1141   z=xyz[2];
1142
1143   phi=TMath::ATan2(y-vertex[1],x-vertex[0]);
1144   lambda=TMath::ATan2(z-vertex[2],TMath::Sqrt((x-vertex[0])*(x-vertex[0])+(y-vertex[1])*(y-vertex[1])));
1145 }
1146
1147 //________________________________________________________________________
1148 void AliITStrackerSA::GetCoorErrors(AliITSRecPoint* cl,Float_t &sx,Float_t &sy, Float_t &sz){
1149
1150   //returns sigmax, y, z of cluster in global coordinates
1151 /*
1152   Double_t rot[9];     fGeom->GetRotMatrix(module,rot);
1153   Int_t lay,lad,det;
1154   AliITSgeomTGeo::GetModuleId(module,lay,lad,det);
1155
1156   Double_t alpha=TMath::ATan2(rot[1],rot[0])+TMath::Pi();
1157   Double_t phi=TMath::Pi()/2+alpha;
1158   if (lay==1) phi+=TMath::Pi();
1159
1160   Float_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
1161 */
1162   Float_t covm[6];
1163   cl->GetGlobalCov(covm);
1164   sx=TMath::Sqrt(covm[0]);
1165   sy=TMath::Sqrt(covm[3]);
1166   sz=TMath::Sqrt(covm[5]);
1167 /*
1168   sx = TMath::Sqrt(sp*sp*cl->GetSigmaY2());
1169   sy = TMath::Sqrt(cp*cp*cl->GetSigmaY2());
1170   sz = TMath::Sqrt(cl->GetSigmaZ2());
1171 */
1172 }
1173