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