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