1 /**************************************************************************
2 * Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
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 ////////////////////////////////////////////////////
29 #include <TObjArray.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"
43 ClassImp(AliITStrackerSA)
45 //____________________________________________________________________________
46 AliITStrackerSA::AliITStrackerSA():AliITStrackerMI(),
64 // Default constructor
68 //____________________________________________________________________________
69 AliITStrackerSA::AliITStrackerSA(const Char_t *geom):AliITStrackerMI(0),
88 // Standard constructor (Vertex is known and passed to this obj.)
90 AliWarning("\"geom\" is actually a dummy argument !");
98 //____________________________________________________________________________
99 AliITStrackerSA::AliITStrackerSA(const Char_t *geom, AliESDVertex *vert):AliITStrackerMI(0),
118 // Standard constructor (Vertex is known and passed to this obj.)
120 AliWarning("\"geom\" is actually a dummy argument !");
126 //____________________________________________________________________________
127 AliITStrackerSA::AliITStrackerSA(const Char_t *geom, AliITSVertexer *vertexer):AliITStrackerMI(0),
146 // Standard constructor (Vertex is unknown - vertexer is passed to this obj)
148 AliWarning("\"geom\" is actually a dummy argument !");
151 fVertexer = vertexer;
155 //____________________________________________________________________________
156 AliITStrackerSA::AliITStrackerSA(const AliITStrackerSA& tracker):AliITStrackerMI(),
157 fPhiEstimate(tracker.fPhiEstimate),
158 fITSStandAlone(tracker.fITSStandAlone),
159 fLambdac(tracker.fLambdac),
160 fPhic(tracker.fPhic),
161 fCoef1(tracker.fCoef1),
162 fCoef2(tracker.fCoef2),
163 fCoef3(tracker.fCoef3),
164 fNloop(tracker.fNloop),
165 fPhiWin(tracker.fPhiWin),
166 fLambdaWin(tracker.fLambdaWin),
167 fVert(tracker.fVert),
168 fVertexer(tracker.fVertexer),
169 fListOfTracks(tracker.fListOfTracks),
170 fITSclusters(tracker.fITSclusters),
171 fSixPoints(tracker.fSixPoints),
172 fCluLayer(tracker.fCluLayer),
173 fCluCoord(tracker.fCluCoord) {
175 for(Int_t i=0;i<2;i++){
176 fPoint1[i]=tracker.fPoint1[i];
177 fPoint2[i]=tracker.fPoint2[i];
178 fPoint3[i]=tracker.fPoint3[i];
179 fPointc[i]=tracker.fPointc[i];
181 if(tracker.fVertexer && tracker.fVert){
182 fVert = new AliESDVertex(*tracker.fVert);
185 fVert = tracker.fVert;
187 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
188 fCluLayer[i] = tracker.fCluLayer[i];
189 fCluCoord[i] = tracker.fCluCoord[i];
192 //______________________________________________________________________
193 AliITStrackerSA& AliITStrackerSA::operator=(const AliITStrackerSA& source){
194 // Assignment operator.
195 this->~AliITStrackerSA();
196 new(this) AliITStrackerSA(source);
201 //____________________________________________________________________________
202 AliITStrackerSA::~AliITStrackerSA(){
204 // if fVertexer is not null, the AliESDVertex obj. is owned by this class
205 // and is deleted here
207 if(fVert)delete fVert;
212 if(fPhiWin)delete []fPhiWin;
213 if(fLambdaWin)delete []fLambdaWin;
214 fListOfTracks->Delete();
216 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
218 fCluLayer[i]->Delete();
225 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
227 fCluCoord[i]->Delete();
236 //____________________________________________________________________________
237 Int_t AliITStrackerSA::Clusters2Tracks(AliESD *event){
238 // This method is used to find and fit the tracks. By default the corresponding
239 // method in the parent class is invoked. In this way a combined tracking
240 // TPC+ITS is performed. If the flag fITSStandAlone is true, the tracking
241 // is done in the ITS only. In the standard reconstruction chain this option
242 // can be set via AliReconstruction::SetOption("ITS","onlyITS")
245 rc=AliITStrackerMI::Clusters2Tracks(event);
248 AliDebug(1,"Stand Alone flag set: doing tracking in ITS alone\n");
250 if(!rc) rc=FindTracks(event);
254 //____________________________________________________________________________
255 void AliITStrackerSA::Init(){
256 // Reset all data members
258 for(Int_t i=0;i<3;i++){fPoint1[i]=0;fPoint2[i]=0;fPoint3[i]=0;}
272 fListOfTracks=new TObjArray(0,0);
276 //_______________________________________________________________________
277 void AliITStrackerSA::ResetForFinding(){
278 // Reset data members used in all loops during track finding
280 for(Int_t i=0;i<3;i++){fPoint1[i]=0;fPoint2[i]=0;fPoint3[i]=0;}
288 fListOfTracks->Delete();
293 //______________________________________________________________________
294 Int_t AliITStrackerSA::FindTracks(AliESD* event){
296 // Track finder using the ESD object
299 //controllare numero cluster sui layer1 e 2 (morti?)
300 //non trova tracce...controllare..
303 Fatal("FindTracks","ITS cluster tree is not accessed - Abort!!!\n Please use method SetClusterTree to pass the pointer to the tree\n");
308 //Reads event and mark clusters of traks already found, with flag kITSin
309 Int_t nentr=event->GetNumberOfTracks();
311 AliESDtrack *track=event->GetTrack(nentr);
312 if (track->GetStatus()&AliESDtrack::kITSin==AliESDtrack::kITSin){
314 Int_t ncl = track->GetITSclusters(idx);
315 for(Int_t k=0;k<ncl;k++){
316 AliITSRecPoint* cll = (AliITSRecPoint*)GetCluster(idx[k]);
317 cll->SetBit(kSAflag);
322 Double_t primaryVertex[3];
323 event->GetVertex()->GetXYZ(primaryVertex);
324 //Creates TClonesArray with clusters for each layer. The clusters already used
325 //by AliITStrackerMI are not considered
327 Int_t nclusters[6]={0,0,0,0,0,0};
328 Int_t dmar[6]={0,0,0,0,0,0};
329 fCluLayer = new TClonesArray*[AliITSgeomTGeo::GetNLayers()];
330 fCluCoord = new TClonesArray*[AliITSgeomTGeo::GetNLayers()];
332 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
333 AliITSlayer &layer=fgLayers[i];
334 for(Int_t cli=0;cli<layer.GetNumberOfClusters();cli++){
335 AliITSRecPoint* cls = (AliITSRecPoint*)layer.GetCluster(cli);
336 if(cls->TestBit(kSAflag)==kTRUE) continue; //clusters used by TPC prol.
337 if(cls->GetQ()==0) continue; //fake clusters dead zones
341 fCluLayer[i] = new TClonesArray("AliITSRecPoint",nclusters[i]);
342 fCluCoord[i] = new TClonesArray("AliITSclusterTable",nclusters[i]);
346 Int_t * firstmod = new Int_t[AliITSgeomTGeo::GetNLayers()];
347 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
348 firstmod[i]=AliITSgeomTGeo::GetModuleIndex(i+1,1,1);
351 for(Int_t ilay=0;ilay<AliITSgeomTGeo::GetNLayers();ilay++){
352 TClonesArray &clulay = *fCluLayer[ilay];
353 TClonesArray &clucoo = *fCluCoord[ilay];
354 AliITSlayer &layer=fgLayers[ilay];
355 for(Int_t cli=0;cli<layer.GetNumberOfClusters();cli++){
356 AliITSRecPoint* cls = (AliITSRecPoint*)layer.GetCluster(cli);
357 if(cls->TestBit(kSAflag)==kTRUE) continue;
358 if(cls->GetQ()==0) continue;
359 Double_t phi=0;Double_t lambda=0;
360 Float_t x=0;Float_t y=0;Float_t z=0;
361 Float_t sx=0;Float_t sy=0;Float_t sz=0;
362 GetCoorAngles(cls,phi,lambda,x,y,z,primaryVertex);
363 GetCoorErrors(cls,sx,sy,sz);
364 new (clulay[dmar[ilay]]) AliITSRecPoint(*cls);
365 new (clucoo[dmar[ilay]]) AliITSclusterTable(x,y,z,sx,sy,sz,phi,lambda,cli);
374 //loop on the different windows
375 for(Int_t nloop=0;nloop<fNloop;nloop++){
376 for(Int_t ncl=0;ncl<fCluLayer[0]->GetEntries();ncl++){ //loop starting from layer 0
381 AliITSRecPoint* cl = (AliITSRecPoint*)fCluLayer[0]->At(ncl);
386 if (cl->GetQ()<=0) continue;
388 AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(0,ncl);
389 fPhic = arr->GetPhi();
390 fLambdac = arr->GetLambda();
391 if (TMath::Abs(fLambdac)>0.26*TMath::Pi()) continue;
392 fPhiEstimate = fPhic;
393 AliITStrackSA* trs = new AliITStrackSA();
394 fPoint1[0]=primaryVertex[0];
395 fPoint1[1]=primaryVertex[1];
398 fPoint2[0]=arr->GetX();
399 fPoint2[1]=arr->GetY();
400 Int_t * nn = new Int_t[AliITSgeomTGeo::GetNLayers()];//counter for clusters on each layer
401 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){ nn[i]=0;}
402 nn[0] = SearchClusters(0,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag);
404 nn[1] = SearchClusters(1,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag);
407 fPoint3[0] = fPointc[0];
408 fPoint3[1] = fPointc[1];
410 nn[2] = SearchClusters(2,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag);
411 if(nn[1]==0 && nn[2]==0) pflag=0;
412 if(nn[2]!=0 && nn[1]!=0){ pflag=1; UpdatePoints();}
413 if(nn[2]!=0 && nn[1]==0){
415 fPoint3[0]=fPointc[0];
416 fPoint3[1]=fPointc[1];
419 nn[3] = SearchClusters(3,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag);
421 if(nn[3]!=0) UpdatePoints();
422 nn[4] = SearchClusters(4,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag);
424 if(nn[4]!=0) UpdatePoints();
425 nn[5] = SearchClusters(5,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag);
429 Int_t numberofpoints;
430 if(fSixPoints) numberofpoints=6; //check of the candidate track
431 else numberofpoints=5; //if track is good (with the required number
432 for(Int_t nnp=0;nnp<AliITSgeomTGeo::GetNLayers();nnp++){ //of points) it is written on file
433 if(nn[nnp]!=0) layOK+=1;
435 if(layOK>=numberofpoints){
437 AliITStrackV2* tr2 = FitTrack(trs,primaryVertex);
441 AliESDtrack outtrack;
442 outtrack.UpdateTrackParams(tr2,AliESDtrack::kITSin);
443 event->AddTrack(&outtrack);
451 }//end loop on clusters of layer1
456 //if 5/6 points are required, second loop starting
457 //from second layer, to find tracks with point of
461 // counter for clusters on each layer
462 Int_t * nn = new Int_t[AliITSgeomTGeo::GetNLayers()-1];
463 for(Int_t nloop=0;nloop<fNloop;nloop++){
464 Int_t ncl2=fCluLayer[1]->GetEntries();
465 while(ncl2--){ //loop starting from layer 2
468 AliITSRecPoint* cl = (AliITSRecPoint*)fCluLayer[1]->At(ncl2);
471 AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(1,ncl2);
472 fPhic = arr->GetPhi();
473 fLambdac = arr->GetLambda();
474 fPhiEstimate = fPhic;
476 AliITStrackSA* trs = new AliITStrackSA();
477 fPoint1[0]=primaryVertex[0];
478 fPoint1[1]=primaryVertex[1];
480 fPoint2[0]=arr->GetX();
481 fPoint2[1]=arr->GetY();
482 for(Int_t kk=0;kk<AliITSgeomTGeo::GetNLayers()-1;kk++)nn[kk] = 0;
483 nn[0] = SearchClusters(1,fPhiWin[nloop],fLambdaWin[nloop],
484 trs,primaryVertex[2],pflag);
485 nn[1] = SearchClusters(2,fPhiWin[nloop],fLambdaWin[nloop],
486 trs,primaryVertex[2],pflag);
489 fPoint3[0]=fPointc[0];
490 fPoint3[1]=fPointc[1];
492 nn[2]= SearchClusters(3,fPhiWin[nloop],fLambdaWin[nloop],
493 trs,primaryVertex[2],pflag);
498 nn[3]= SearchClusters(4,fPhiWin[nloop],fLambdaWin[nloop],
499 trs,primaryVertex[2],pflag);
504 nn[4]=SearchClusters(5,fPhiWin[nloop],fLambdaWin[nloop],
505 trs,primaryVertex[2],pflag);
508 for(Int_t nnp=0;nnp<AliITSgeomTGeo::GetNLayers()-1;nnp++){
509 if(nn[nnp]!=0) fl+=1;
512 AliITStrackV2* tr2 = FitTrack(trs,primaryVertex);
517 AliESDtrack outtrack;
518 outtrack.UpdateTrackParams(tr2,AliESDtrack::kITSin);
519 event->AddTrack(&outtrack);
526 }//end loop on clusters of layer2
533 Info("FindTracks","Number of found tracks: %d",event->GetNumberOfTracks());
542 //________________________________________________________________________
544 AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVertex){
545 //fit of the found track
548 Int_t * firstmod = new Int_t[AliITSgeomTGeo::GetNLayers()];
549 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
550 firstmod[i]=AliITSgeomTGeo::GetModuleIndex(i+1,1,1);
553 Int_t nclusters = tr->GetNumberOfClustersSA();
554 TObjArray** listlayer = new TObjArray*[AliITSgeomTGeo::GetNLayers()];
555 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
556 listlayer[i] = new TObjArray(0,0);
574 Int_t * nnn = new Int_t[AliITSgeomTGeo::GetNLayers()];
575 Int_t * kkk = new Int_t[AliITSgeomTGeo::GetNLayers()];
576 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {nnn[i]=0;kkk[i]=0;}
578 for(Int_t ncl=0;ncl<nclusters;ncl++){
579 Int_t index = tr->GetClusterIndexSA(ncl);
580 AliITSRecPoint* cl = (AliITSRecPoint*)GetCluster(index);
581 if(cl->TestBit(kSAflag)==kTRUE) cl->ResetBit(kSAflag);
582 Int_t lay = (index & 0xf0000000) >> 28;
583 if(lay==0) { listlayer[0]->AddLast(cl); clind0[nnn[0]]=index;nnn[0]++;}
584 if(lay==1) { listlayer[1]->AddLast(cl); clind1[nnn[1]]=index;nnn[1]++;}
585 if(lay==2) { listlayer[2]->AddLast(cl); clind2[nnn[2]]=index;nnn[2]++;}
586 if(lay==3) { listlayer[3]->AddLast(cl); clind3[nnn[3]]=index;nnn[3]++;}
587 if(lay==4) { listlayer[4]->AddLast(cl); clind4[nnn[4]]=index;nnn[4]++;}
588 if(lay==5) { listlayer[5]->AddLast(cl); clind5[nnn[5]]=index;nnn[5]++;}
592 for(Int_t nlay=0;nlay<AliITSgeomTGeo::GetNLayers();nlay++){
593 for(Int_t ncl=0;ncl<tr->GetNumberOfMarked(nlay);ncl++){
594 Int_t mark = tr->GetClusterMark(nlay,ncl);
595 if(nlay==0) { mark0[kkk[0]]=mark;kkk[0]++;}
596 if(nlay==1) { mark1[kkk[1]]=mark;kkk[1]++;}
597 if(nlay==2) { mark2[kkk[2]]=mark;kkk[2]++;}
598 if(nlay==3) { mark3[kkk[3]]=mark;kkk[3]++;}
599 if(nlay==4) { mark4[kkk[4]]=mark;kkk[4]++;}
600 if(nlay==5) { mark5[kkk[5]]=mark;kkk[5]++;}
608 Int_t * end = new Int_t[AliITSgeomTGeo::GetNLayers()];
609 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
610 if(listlayer[i]->GetEntries()==0) end[i]=1;
611 else end[i]=listlayer[i]->GetEntries();
614 TClonesArray* listSA = new TClonesArray("AliITStrackSA");
615 TClonesArray &tri = *listSA;
618 if(end[0]==0) end[0]=1; //for tracks with cluster on layer 0 missing
619 for(Int_t l1=0;l1<end[0];l1++){//loop on layer 1
620 AliITSRecPoint* cl0 = (AliITSRecPoint*)listlayer[0]->At(l1);
621 Double_t x1,y1,z1,sx1,sy1,sz1;
622 Double_t x2,y2,z2,sx2,sy2,sz2;
623 AliITSRecPoint* p1=0;
624 AliITSRecPoint* p2=0;
625 Int_t index1=clind0[l1];
627 Int_t mrk1 = mark0[l1];
632 for(Int_t l2=0;l2<end[1];l2++){//loop on layer 2
633 AliITSRecPoint* cl1 = (AliITSRecPoint*)listlayer[1]->At(l2);
636 for(Int_t l3=0;l3<end[2];l3++){ //loop on layer 3
637 AliITSRecPoint* cl2 = (AliITSRecPoint*)listlayer[2]->At(l3);
639 if(cl0==0 && cl1!=0) {
640 p2 = cl2;index1=clind2[l3];mrk1=mark2[l3];lay1=2;
642 module1 = p1->GetDetectorIndex()+firstmod[1];
644 if(cl0!=0 && cl1==0){
646 p2=cl2;index2=clind2[l3];mrk2=mark2[l3];lay2=2;
647 module1 = p1->GetDetectorIndex()+firstmod[0];
649 if(cl0!=0 && cl1!=0){
652 module1 = p1->GetDetectorIndex()+firstmod[0];
657 AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(lay1,cln1);
658 AliITSclusterTable* arr1= (AliITSclusterTable*)GetClusterCoord(lay2,cln2);
672 Int_t layer,ladder,detector;
673 AliITSgeomTGeo::GetModuleId(module1,layer,ladder,detector);
674 Float_t yclu1 = p1->GetY();
675 Float_t zclu1 = p1->GetZ();
676 Double_t cv=Curvature(primaryVertex[0],primaryVertex[1],x1,y1,x2,y2);
678 Double_t tgl2 = (z2-z1)/TMath::Sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
679 Double_t phi2 = TMath::ATan2((y2-y1),(x2-x1));
681 for(Int_t l4=0;l4<end[3];l4++){ //loop on layer 4
682 AliITSRecPoint* cl3 = (AliITSRecPoint*)listlayer[3]->At(l4);
683 for(Int_t l5=0;l5<end[4];l5++){ //loop on layer 5
684 AliITSRecPoint* cl4 = (AliITSRecPoint*)listlayer[4]->At(l5);
685 for(Int_t l6=0;l6<end[5];l6++){ //loop on layer 6
686 AliITSRecPoint* cl5 = (AliITSRecPoint*)listlayer[5]->At(l6);
687 AliITStrackSA* trac = new AliITStrackSA(layer,ladder,detector,yclu1,zclu1,phi2,tgl2,cv,1);
690 trac->AddClusterV2(5,(clind5[l6] & 0x0fffffff)>>0);
691 trac->AddClusterMark(5,mark5[l6]);
694 trac->AddClusterV2(4,(clind4[l5] & 0x0fffffff)>>0);
695 trac->AddClusterMark(4,mark4[l5]);
698 trac->AddClusterV2(3,(clind3[l4] & 0x0fffffff)>>0);
699 trac->AddClusterMark(3,mark3[l4]);
702 trac->AddClusterV2(2,(clind2[l3] & 0x0fffffff)>>0);
703 trac->AddClusterMark(2,mark2[l3]);
706 trac->AddClusterV2(1,(clind1[l2] & 0x0fffffff)>>0);
707 trac->AddClusterMark(1,mark1[l2]);
710 trac->AddClusterV2(0,(clind0[l1] & 0x0fffffff)>>0);
711 trac->AddClusterMark(0,mark0[l1]);
713 //fit with Kalman filter using AliITStrackerMI::RefitAt()
716 AliITStrackMI* ot = new AliITStrackSA(*trac);
718 ot->ResetCovariance(10.);
721 if(RefitAt(49.,ot,trac)){ //fit from layer 1 to layer 6
722 AliITStrackMI *otrack2 = new AliITStrackMI(*ot);
723 otrack2->ResetCovariance(10.);
724 otrack2->ResetClusters();
725 //fit from layer 6 to layer 1
726 if(RefitAt(3.7,otrack2,ot)) {
727 fListOfTracks->AddLast(otrack2);
728 new (tri[nlist]) AliITStrackSA(*trac);
750 Int_t dim=fListOfTracks->GetEntries();
752 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
762 Int_t lowchi2 = FindTrackLowChiSquare(fListOfTracks,dim);
763 AliITStrackV2* otrack =(AliITStrackV2*)fListOfTracks->At(lowchi2);
764 AliITStrackSA* trsa = (AliITStrackSA*)listSA->At(lowchi2);
767 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
776 Int_t * indexc = new Int_t[AliITSgeomTGeo::GetNLayers()];
777 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) indexc[i]=0;
778 for(Int_t nind=0;nind<otrack->GetNumberOfClusters();nind++){
779 indexc[nind] = otrack->GetClusterIndex(nind);
781 AliITSRecPoint* cl0 = (AliITSRecPoint*)GetCluster(indexc[0]);
782 AliITSRecPoint* cl1 = (AliITSRecPoint*)GetCluster(indexc[1]);
783 AliITSRecPoint* cl2 = (AliITSRecPoint*)GetCluster(indexc[2]);
784 AliITSRecPoint* cl3 = (AliITSRecPoint*)GetCluster(indexc[3]);
785 AliITSRecPoint* cl4 = (AliITSRecPoint*)GetCluster(indexc[4]);
786 Int_t labl[3]={-1,-1,-1};
787 if(otrack->GetNumberOfClusters()==AliITSgeomTGeo::GetNLayers()){
788 AliITSRecPoint* cl5 = (AliITSRecPoint*)GetCluster(indexc[5]);
789 labl[0]=cl5->GetLabel(0);
790 labl[1]=cl5->GetLabel(1);
791 labl[2]=cl5->GetLabel(2);
794 if(otrack->GetNumberOfClusters()==(AliITSgeomTGeo::GetNLayers()-1)){
799 Int_t numberofpoints;
800 if(fSixPoints) numberofpoints=6;
801 else numberofpoints=5;
802 CookLabel(otrack,0.); //MI change - to see fake ratio
803 Int_t label = Label(cl0->GetLabel(0),cl1->GetLabel(0),
804 cl2->GetLabel(0),cl3->GetLabel(0),
805 cl4->GetLabel(0),labl[0],
806 cl0->GetLabel(1),cl1->GetLabel(1),
807 cl2->GetLabel(1),cl3->GetLabel(1),
808 cl4->GetLabel(1),labl[1],
809 cl0->GetLabel(2),cl1->GetLabel(2),
810 cl2->GetLabel(2),cl3->GetLabel(2),
811 cl4->GetLabel(2),labl[2],numberofpoints);
813 otrack->SetLabel(label);
814 //remove clusters of found track
816 for(Int_t nlay=0;nlay<AliITSgeomTGeo::GetNLayers();nlay++){
817 for(Int_t cln=0;cln<trsa->GetNumberOfMarked(nlay);cln++){
818 Int_t index = trsa->GetClusterMark(nlay,cln);
819 fCluLayer[nlay]->RemoveAt(index);
820 RemoveClusterCoord(nlay,index);
821 fCluLayer[nlay]->Compress();
827 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
838 //_______________________________________________________
839 Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t lambdawindow, AliITStrackSA* trs,Double_t /*zvertex*/,Int_t pflag){
840 //function used to to find the clusters associated to the track
842 AliITSlayer &lay = fgLayers[layer];
843 Double_t r=lay.GetR();
845 Float_t cx1,cx2,cy1,cy2;
846 FindEquation(fPoint1[0],fPoint1[1],fPoint2[0],fPoint2[1],fPoint3[0],fPoint3[1],fCoef1,fCoef2,fCoef3);
847 if (FindIntersection(fCoef1,fCoef2,fCoef3,-r*r,cx1,cy1,cx2,cy2)==0)
849 Double_t fi1=TMath::ATan2(cy1-fPoint1[1],cx1-fPoint1[0]);
850 Double_t fi2=TMath::ATan2(cy2-fPoint1[1],cx2-fPoint1[0]);
851 fPhiEstimate=ChoosePoint(fi1,fi2,fPhic);
855 Int_t ncl = fCluLayer[layer]->GetEntries();
856 for (Int_t index=0; index<ncl; index++) {
857 AliITSRecPoint *c = (AliITSRecPoint*)fCluLayer[layer]->At(index);
859 if (c->GetQ()<=0) continue;
861 AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(layer,index);
862 Double_t phi = arr->GetPhi();
863 if (TMath::Abs(phi-fPhiEstimate)>phiwindow) continue;
865 Double_t lambda = arr->GetLambda();
866 if (TMath::Abs(lambda-fLambdac)>lambdawindow) continue;
868 if(trs->GetNumberOfClustersSA()==trs->GetMaxNumberOfClusters()) return 0;
869 if(trs->GetNumberOfMarked(layer)==trs->GetMaxNMarkedPerLayer()) return 0;
870 Int_t orind = arr->GetOrInd();
871 trs->AddClusterSA(layer,orind);
872 trs->AddClusterMark(layer,index);
878 fPointc[0]=arr->GetX();
879 fPointc[1]=arr->GetY();
885 //________________________________________________________________
886 void AliITStrackerSA::UpdatePoints(){
887 //update of points for the estimation of the curvature
889 fPoint2[0]=fPoint3[0];
890 fPoint2[1]=fPoint3[1];
891 fPoint3[0]=fPointc[0];
892 fPoint3[1]=fPointc[1];
897 //___________________________________________________________________
898 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){
900 //given (x,y) of three recpoints (in global coordinates)
901 //returns the parameters a,b,c of circonference x*x + y*y +a*x + b*y +c
903 Float_t den = (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1);
905 a = ((y3-y1)*(x2*x2+y2*y2-x1*x1-y1*y1)-(y2-y1)*(x3*x3+y3*y3-x1*x1-y1*y1))/den;
906 b = -(x2*x2-x1*x1+y2*y2-y1*y1+a*(x2-x1))/(y2-y1);
907 c = -x1*x1-y1*y1-a*x1-b*y1;
910 //__________________________________________________________________________
911 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){
913 //Finds the intersection between the circonference of the track and the circonference centered in (0,0) represented by one layer
914 //c2 is -rlayer*rlayer
918 Double_t aA = (b1*b1)/(a1*a1)+1;
919 Double_t bB = (-2*m*b1/(a1*a1));
920 Double_t cC = c2+(m*m)/(a1*a1);
921 Double_t dD = bB*bB-4*aA*cC;
924 y1 = (-bB+TMath::Sqrt(dD))/(2*aA);
925 y2 = (-bB-TMath::Sqrt(dD))/(2*aA);
926 x1 = (c2-c1-b1*y1)/a1;
927 x2 = (c2-c1-b1*y2)/a1;
931 //____________________________________________________________________
932 Double_t AliITStrackerSA::Curvature(Double_t x1,Double_t y1,Double_t
933 x2,Double_t y2,Double_t x3,Double_t y3){
935 //calculates the curvature of track
936 Double_t den = (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1);
938 Double_t a = ((y3-y1)*(x2*x2+y2*y2-x1*x1-y1*y1)-(y2-y1)*(x3*x3+y3*y3-x1*x1-y1*y1))/den;
939 Double_t b = -(x2*x2-x1*x1+y2*y2-y1*y1+a*(x2-x1))/(y2-y1);
940 Double_t c = -x1*x1-y1*y1-a*x1-b*y1;
943 if((a*a+b*b-4*c)<0) return 0;
944 Double_t rad = TMath::Sqrt(a*a+b*b-4*c)/2.;
947 if((x1>0 && y1>0 && x1<xc)) rad*=-1;
948 if((x1<0 && y1>0 && x1<xc)) rad*=-1;
949 // if((x1<0 && y1<0 && x1<xc)) rad*=-1;
950 // if((x1>0 && y1<0 && x1<xc)) rad*=-1;
957 //____________________________________________________________________
958 Double_t AliITStrackerSA::ChoosePoint(Double_t p1, Double_t p2, Double_t pp){
960 //Returns the point closest to pp
962 Double_t diff1 = p1-pp;
963 Double_t diff2 = p2-pp;
965 if(TMath::Abs(diff1)<TMath::Abs(diff2)) fPhiEstimate=p1;
966 else fPhiEstimate=p2;
972 //_________________________________________________________________
973 Int_t AliITStrackerSA::FindTrackLowChiSquare(TObjArray* tracklist, Int_t dim) const {
974 // returns track with lowes chi square
976 //AliITStrackV2* trk = (AliITStrackV2*)tracklist->At(0);
980 //if(dim==0) return 0;
981 Double_t * chi2 = new Double_t[dim];
982 Int_t * index = new Int_t[dim];
983 for(Int_t i=0;i<dim;i++){
984 AliITStrackV2* trk = (AliITStrackV2*)tracklist->At(i);
985 chi2[i]=trk->GetChi2();
989 Int_t w=0;Double_t value;
992 for(Int_t j=w+1;j<dim;j++){
1007 return index[dim-1];
1010 //__________________________________________________________
1011 Int_t AliITStrackerSA::FindLabel(Int_t l1, Int_t l2, Int_t l3, Int_t l4, Int_t l5, Int_t l6){
1013 //function used to determine the track label
1015 Int_t lb[6] = {l1,l2,l3,l4,l5,l6};
1016 Int_t aa[6]={1,1,1,1,1,1};
1019 Int_t k=0;Int_t w=0;Int_t num=6;
1020 if(lb[5]==-1) num=5;
1024 for(Int_t i=k+1;i<num;i++){
1026 if(lb[k]==lb[i] && aa[k]!=0){
1037 for(Int_t j=0;j<6;j++){
1049 if(num==6) return lb[5];
1053 //_____________________________________________________________________________
1054 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,
1055 Int_t gl12, Int_t gl13, Int_t gl14,Int_t gl15, Int_t gl16, Int_t gl17, Int_t gl18, Int_t numberofpoints){
1058 //function used to assign label to the found track. If track is fake, the label is negative
1060 Int_t lb0[6] = {gl1,gl2,gl3,gl4,gl5,gl6};
1061 Int_t lb1[6] = {gl7,gl8,gl9,gl10,gl11,gl12};
1062 Int_t lb2[6] = {gl13,gl14,gl15,gl16,gl17,gl18};
1063 Int_t ll=FindLabel(lb0[0],lb0[1],lb0[2],lb0[3],lb0[4],lb0[5]);
1064 Int_t lflag=0;Int_t num=6;
1065 if(lb0[5]==-1 && lb1[5]==-1 && lb2[5]==-1) num=5;
1067 for(Int_t i=0;i<num;i++){
1068 if(lb0[i]==ll || lb1[i]==ll || lb2[i]==ll) lflag+=1;
1071 if(lflag>=numberofpoints) return ll;
1077 //_____________________________________________________________________________
1078 void AliITStrackerSA::SetWindowSizes(Int_t n, Double_t *phi, Double_t *lam){
1079 // Set sizes of the phi and lambda windows used for track finding
1081 if(phi){ // user defined values
1082 fPhiWin = new Double_t[fNloop];
1083 fLambdaWin = new Double_t[fNloop];
1084 for(Int_t k=0;k<fNloop;k++){
1086 fLambdaWin[k]=lam[k];
1089 else { // default values
1091 Double_t phid[33] = {0.002,0.003,0.004,0.0045,0.0047,
1092 0.005,0.0053,0.0055,
1093 0.006,0.0063,0.0065,0.007,0.0073,0.0075,0.0077,
1094 0.008,0.0083,0.0085,0.0087,0.009,0.0095,0.0097,
1095 0.01,0.0105,0.011,0.0115,0.012,0.0125,0.013,0.0135,0.0140,0.0145};
1096 Double_t lambdad[33] = {0.003,0.004,0.005,0.005,0.005,
1098 0.006,0.006,0.006,0.007,0.007,0.007,0.007,
1099 0.007,0.007,0.007,0.007,0.007,0.007,0.007,
1100 0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008};
1107 fPhiWin = new Double_t[fNloop];
1108 fLambdaWin = new Double_t[fNloop];
1110 for(Int_t k=0;k<fNloop;k++){
1112 fLambdaWin[k]=lambdad[k];
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
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);
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();
1130 Float_t cp=TMath::Cos(phi1), sp=TMath::Sin(phi1);
1131 Float_t r=tx*cp+ty*sp;
1133 xyz= r*cp - cl->GetY()*sp;
1134 y= r*sp + cl->GetY()*cp;
1138 cl->GetGlobalXYZ(xyz);
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])));
1147 //________________________________________________________________________
1148 void AliITStrackerSA::GetCoorErrors(AliITSRecPoint* cl,Float_t &sx,Float_t &sy, Float_t &sz){
1150 //returns sigmax, y, z of cluster in global coordinates
1152 Double_t rot[9]; fGeom->GetRotMatrix(module,rot);
1154 AliITSgeomTGeo::GetModuleId(module,lay,lad,det);
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();
1160 Float_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
1163 cl->GetGlobalCov(covm);
1164 sx=TMath::Sqrt(covm[0]);
1165 sy=TMath::Sqrt(covm[3]);
1166 sz=TMath::Sqrt(covm[5]);
1168 sx = TMath::Sqrt(sp*sp*cl->GetSigmaY2());
1169 sy = TMath::Sqrt(cp*cp*cl->GetSigmaY2());
1170 sz = TMath::Sqrt(cl->GetSigmaZ2());