]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ITS/AliITStrackerSA.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- speed up T0 average calculation significantly
[u/mrichter/AliRoot.git] / ITS / AliITStrackerSA.cxx
CommitLineData
13918578 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
bf6adc12 16/* $Id$ */
17
13918578 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
aa4b78e1 25#include <stdlib.h>
bf6adc12 26
27#include <TArrayI.h>
13918578 28#include <TBranch.h>
13918578 29#include <TObjArray.h>
30#include <TTree.h>
bf6adc12 31
af885e0f 32#include "AliESDEvent.h"
bf6adc12 33#include "AliESDVertex.h"
34#include "AliESDtrack.h"
bf6adc12 35#include "AliITSVertexer.h"
13918578 36#include "AliITSclusterTable.h"
00a7cc50 37#include "AliITSRecPoint.h"
cc088660 38#include "AliITSgeomTGeo.h"
13918578 39#include "AliITStrackSA.h"
bf6adc12 40#include "AliITStrackerSA.h"
e340bb86 41#include "AliITSReconstructor.h"
b881f1fd 42#include "AliLog.h"
bf6adc12 43#include "AliRun.h"
13918578 44
45ClassImp(AliITStrackerSA)
46
47//____________________________________________________________________________
e399f961 48AliITStrackerSA::AliITStrackerSA():AliITStrackerMI(),
49fPhiEstimate(0),
1966f03c 50fITSStandAlone(0),
e399f961 51fLambdac(0),
52fPhic(0),
53fCoef1(0),
54fCoef2(0),
55fCoef3(0),
56fNloop(0),
57fPhiWin(0),
58fLambdaWin(0),
59fVert(0),
60fVertexer(0),
e399f961 61fListOfTracks(0),
deae0246 62fListOfSATracks(0),
e399f961 63fITSclusters(0),
12b1afb7 64fInwardFlag(0),
b8ed1a92 65fOuterStartLayer(0),
12b1afb7 66fInnerStartLayer(5),
67fMinNPoints(0),
3733ccd2 68fMinQ(0.),
e399f961 69fCluLayer(0),
70fCluCoord(0){
13918578 71 // Default constructor
72 Init();
627b6db6 73
13918578 74}
2257f27e 75//____________________________________________________________________________
cc088660 76AliITStrackerSA::AliITStrackerSA(const Char_t *geom):AliITStrackerMI(0),
e399f961 77fPhiEstimate(0),
1966f03c 78fITSStandAlone(0),
e399f961 79fLambdac(0),
80fPhic(0),
81fCoef1(0),
82fCoef2(0),
83fCoef3(0),
84fNloop(0),
85fPhiWin(0),
86fLambdaWin(0),
87fVert(0),
88fVertexer(0),
e399f961 89fListOfTracks(0),
deae0246 90fListOfSATracks(0),
e399f961 91fITSclusters(0),
12b1afb7 92fInwardFlag(0),
b8ed1a92 93fOuterStartLayer(0),
12b1afb7 94fInnerStartLayer(5),
95fMinNPoints(0),
3733ccd2 96fMinQ(0.),
e399f961 97fCluLayer(0),
98fCluCoord(0)
2257f27e 99{
100 // Standard constructor (Vertex is known and passed to this obj.)
cc088660 101 if (geom) {
102 AliWarning("\"geom\" is actually a dummy argument !");
103 }
104
2257f27e 105 Init();
106 fVert = 0;
627b6db6 107
2257f27e 108}
109
13918578 110//____________________________________________________________________________
cc088660 111AliITStrackerSA::AliITStrackerSA(const Char_t *geom, AliESDVertex *vert):AliITStrackerMI(0),
e399f961 112fPhiEstimate(0),
1966f03c 113fITSStandAlone(0),
e399f961 114fLambdac(0),
115fPhic(0),
116fCoef1(0),
117fCoef2(0),
118fCoef3(0),
119fNloop(0),
120fPhiWin(0),
121fLambdaWin(0),
122fVert(vert),
123fVertexer(0),
e399f961 124fListOfTracks(0),
deae0246 125fListOfSATracks(0),
e399f961 126fITSclusters(0),
12b1afb7 127fInwardFlag(0),
b8ed1a92 128fOuterStartLayer(0),
12b1afb7 129fInnerStartLayer(5),
130fMinNPoints(0),
3733ccd2 131fMinQ(0.),
e399f961 132fCluLayer(0),
1966f03c 133fCluCoord(0)
13918578 134{
135 // Standard constructor (Vertex is known and passed to this obj.)
cc088660 136 if (geom) {
137 AliWarning("\"geom\" is actually a dummy argument !");
138 }
13918578 139 Init();
627b6db6 140
13918578 141}
142
13918578 143//____________________________________________________________________________
cc088660 144AliITStrackerSA::AliITStrackerSA(const Char_t *geom, AliITSVertexer *vertexer):AliITStrackerMI(0),
e399f961 145fPhiEstimate(0),
1966f03c 146fITSStandAlone(0),
e399f961 147fLambdac(0),
148fPhic(0),
149fCoef1(0),
150fCoef2(0),
151fCoef3(0),
152fNloop(0),
153fPhiWin(0),
154fLambdaWin(0),
155fVert(),
156fVertexer(vertexer),
e399f961 157fListOfTracks(0),
deae0246 158fListOfSATracks(0),
e399f961 159fITSclusters(0),
12b1afb7 160fInwardFlag(0),
b8ed1a92 161fOuterStartLayer(0),
12b1afb7 162fInnerStartLayer(5),
163fMinNPoints(0),
3733ccd2 164fMinQ(0.),
e399f961 165fCluLayer(0),
1966f03c 166fCluCoord(0)
13918578 167{
168 // Standard constructor (Vertex is unknown - vertexer is passed to this obj)
cc088660 169 if (geom) {
170 AliWarning("\"geom\" is actually a dummy argument !");
171 }
13918578 172 Init();
173 fVertexer = vertexer;
627b6db6 174
13918578 175}
176
177//____________________________________________________________________________
e399f961 178AliITStrackerSA::AliITStrackerSA(const AliITStrackerSA& tracker):AliITStrackerMI(),
179fPhiEstimate(tracker.fPhiEstimate),
1966f03c 180fITSStandAlone(tracker.fITSStandAlone),
e399f961 181fLambdac(tracker.fLambdac),
182fPhic(tracker.fPhic),
183fCoef1(tracker.fCoef1),
184fCoef2(tracker.fCoef2),
185fCoef3(tracker.fCoef3),
186fNloop(tracker.fNloop),
187fPhiWin(tracker.fPhiWin),
188fLambdaWin(tracker.fLambdaWin),
189fVert(tracker.fVert),
190fVertexer(tracker.fVertexer),
e399f961 191fListOfTracks(tracker.fListOfTracks),
deae0246 192fListOfSATracks(tracker.fListOfSATracks),
e399f961 193fITSclusters(tracker.fITSclusters),
12b1afb7 194fInwardFlag(tracker.fInwardFlag),
b8ed1a92 195fOuterStartLayer(tracker.fOuterStartLayer),
12b1afb7 196fInnerStartLayer(tracker.fInnerStartLayer),
197fMinNPoints(tracker.fMinNPoints),
3733ccd2 198fMinQ(tracker.fMinQ),
e399f961 199fCluLayer(tracker.fCluLayer),
200fCluCoord(tracker.fCluCoord) {
13918578 201 // Copy constructor
13918578 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 }
13918578 208 if(tracker.fVertexer && tracker.fVert){
d681bb2d 209 fVert = new AliESDVertex(*tracker.fVert);
13918578 210 }
211 else {
212 fVert = tracker.fVert;
213 }
cc088660 214 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
7e5bf5af 215 fCluLayer[i] = tracker.fCluLayer[i];
216 fCluCoord[i] = tracker.fCluCoord[i];
217 }
13918578 218}
7d62fb64 219//______________________________________________________________________
e399f961 220AliITStrackerSA& AliITStrackerSA::operator=(const AliITStrackerSA& source){
221 // Assignment operator.
222 this->~AliITStrackerSA();
223 new(this) AliITStrackerSA(source);
224 return *this;
225
7d62fb64 226}
13918578 227
228//____________________________________________________________________________
229AliITStrackerSA::~AliITStrackerSA(){
230 // destructor
d681bb2d 231 // if fVertexer is not null, the AliESDVertex obj. is owned by this class
13918578 232 // and is deleted here
233 if(fVertexer){
234 if(fVert)delete fVert;
235 }
236 fVert = 0;
237 fVertexer = 0;
7e5bf5af 238
13918578 239 if(fPhiWin)delete []fPhiWin;
240 if(fLambdaWin)delete []fLambdaWin;
4e05ab9a 241 fListOfTracks->Delete();
adda6c2b 242 delete fListOfTracks;
deae0246 243 fListOfSATracks->Delete();
244 delete fListOfSATracks;
7e5bf5af 245 if(fCluLayer){
cc088660 246 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
7e5bf5af 247 if(fCluLayer[i]){
248 fCluLayer[i]->Delete();
249 delete fCluLayer[i];
250 }
251 }
252 delete [] fCluLayer;
253 }
254 if(fCluCoord){
cc088660 255 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
7e5bf5af 256 if(fCluCoord[i]){
257 fCluCoord[i]->Delete();
258 delete fCluCoord[i];
259 }
260 }
261 delete [] fCluCoord;
627b6db6 262 }
7e5bf5af 263
7e5bf5af 264}
13918578 265
1966f03c 266//____________________________________________________________________________
af885e0f 267Int_t AliITStrackerSA::Clusters2Tracks(AliESDEvent *event){
1966f03c 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 }
3bfb5cac 280 if(!rc){
281 rc=FindTracks(event,kFALSE);
282 if(AliITSReconstructor::GetRecoParam()->GetSAUseAllClusters()==kTRUE) {
283 rc=FindTracks(event,kTRUE);
284 }
285 }
286
1966f03c 287 return rc;
288}
289
13918578 290//____________________________________________________________________________
291void 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;
5b4dedce 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 }
3733ccd2 314 fMinQ=AliITSReconstructor::GetRecoParam()->GetSAMinClusterCharge();
2257f27e 315 fITSclusters = 0;
12b1afb7 316 SetOuterStartLayer(1);
1966f03c 317 SetSAFlag(kFALSE);
f2150e42 318 fListOfTracks=new TClonesArray("AliITStrackMI",100);
319 fListOfSATracks=new TClonesArray("AliITStrackSA",100);
7e5bf5af 320 fCluLayer = 0;
321 fCluCoord = 0;
12b1afb7 322 fMinNPoints = 3;
627b6db6 323 }
13918578 324//_______________________________________________________________________
325void 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;
f2150e42 336 fListOfTracks->Clear();
337 fListOfSATracks->Clear();
13918578 338}
bef31448 339
7e5bf5af 340
2257f27e 341
bef31448 342//______________________________________________________________________
3bfb5cac 343Int_t AliITStrackerSA::FindTracks(AliESDEvent* event, Bool_t useAllClusters){
bef31448 344
7e5bf5af 345// Track finder using the ESD object
6f178e14 346
b881f1fd 347 AliDebug(2,Form(" field is %f",event->GetMagneticField()));
4fa7f7d1 348 AliDebug(2,Form("SKIPPING %d %d %d %d %d %d",ForceSkippingOfLayer(0),ForceSkippingOfLayer(1),ForceSkippingOfLayer(2),ForceSkippingOfLayer(3),ForceSkippingOfLayer(4),ForceSkippingOfLayer(5)));
349
2257f27e 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;
bef31448 353 }
7e5bf5af 354 //Reads event and mark clusters of traks already found, with flag kITSin
ebda3140 355 Int_t nentr=event->GetNumberOfTracks();
3bfb5cac 356 if(!useAllClusters) {
5a03f353 357 while (nentr--) {
358 AliESDtrack *track=event->GetTrack(nentr);
5af4a2d0 359 if ((track->GetStatus()&AliESDtrack::kITSin) == AliESDtrack::kITSin){
5a03f353 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 }
ebda3140 366 }
367 }
a1995c09 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 }
ebda3140 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
deae0246 386 Int_t nclusters[AliITSgeomTGeo::kNLayers]={0,0,0,0,0,0};
387 Int_t dmar[AliITSgeomTGeo::kNLayers]={0,0,0,0,0,0};
ebda3140 388 if (fCluLayer == 0) {
deae0246 389 fCluLayer = new TClonesArray*[AliITSgeomTGeo::kNLayers];
390 fCluCoord = new TClonesArray*[AliITSgeomTGeo::kNLayers];
ebda3140 391 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
392 fCluLayer[i]=0;
393 fCluCoord[i]=0;
394 }
395 }
ebda3140 396 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
ebda3140 397 AliITSlayer &layer=fgLayers[i];
4fa7f7d1 398 if (!ForceSkippingOfLayer(i)) {
25be2b21 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
3733ccd2 403 if(i>1 && cls->GetQ()<=fMinQ) continue; // cut on SDD and SSD cluster charge
25be2b21 404 nclusters[i]++;
405 }
ebda3140 406 }
407 dmar[i]=0;
855b4730 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 }
ebda3140 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];
4fa7f7d1 426 if (!ForceSkippingOfLayer(ilay)) {
25be2b21 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;
3733ccd2 431 if(ilay>1 && cls->GetQ()<=fMinQ) continue;
25be2b21 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 }
ebda3140 441 }
442 }
7e5bf5af 443
6f178e14 444 // track counter
445 Int_t ntrack=0;
446
deae0246 447 static Int_t nClusLay[AliITSgeomTGeo::kNLayers];//counter for clusters on each layer
f2150e42 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 }
6f178e14 458
12b1afb7 459 // loop on minimum number of points
460 for(Int_t iMinNPoints=AliITSgeomTGeo::GetNLayers(); iMinNPoints>=fMinNPoints; iMinNPoints--) {
461
f2150e42 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;
12b1afb7 481
f2150e42 482 Int_t pflag=0;
483 Int_t kk;
484 for(kk=0;kk<AliITSgeomTGeo::GetNLayers();kk++) nClusLay[kk] = 0;
12b1afb7 485
f2150e42 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();
12b1afb7 502 }
503 }
f2150e42 504 nextLay+=seedStep;
505 if(nextLay<0 || nextLay==6) goon=kFALSE;
506 }
507
12b1afb7 508
f2150e42 509 Int_t layOK=0;
510 if(!fInwardFlag){
511 for(Int_t nnp=0;nnp<AliITSgeomTGeo::GetNLayers()-theLay;nnp++){
12b1afb7 512 if(nClusLay[nnp]!=0) layOK+=1;
513 }
f2150e42 514 }else{
515 for(Int_t nnp=theLay; nnp>=0; nnp--){
12b1afb7 516 if(nClusLay[nnp]!=0) layOK+=1;
517 }
f2150e42 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()));
12b1afb7 527
f2150e42 528 StoreTrack(tr2,event,useAllClusters);
529 ntrack++;
12b1afb7 530
f2150e42 531 }
532
533 }//end loop on clusters of theLay
534 } //end loop on window sizes
535 } //end loop on theLay
12b1afb7 536 }//end loop on min points
5a03f353 537
8403ece4 538 // search for 1-point tracks in SPD, only for cosmics
5a03f353 539 // (A.Dainese 21.03.08)
540 if(AliITSReconstructor::GetRecoParam()->GetSAOnePointTracks() &&
541 TMath::Abs(event->GetMagneticField())<0.01) {
8403ece4 542 Int_t outerLayer=1; // only SPD
543 for(Int_t innLay=0; innLay<=TMath::Min(1,fOuterStartLayer); innLay++) {
5a03f353 544 // counter for clusters on each layer
deae0246 545
5a03f353 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();
12b1afb7 550 Bool_t useRP=SetFirstPoint(innLay,nclInnLay,primaryVertex);
551 if(!useRP) continue;
f2150e42 552 AliITStrackSA trs;
12b1afb7 553
554 Int_t pflag=0;
5a03f353 555 Int_t kk;
deae0246 556 for(kk=0;kk<AliITSgeomTGeo::GetNLayers();kk++) nClusLay[kk] = 0;
5a03f353 557
558 kk=0;
deae0246 559 nClusLay[kk] = SearchClusters(innLay,fPhiWin[nloop],fLambdaWin[nloop],
f2150e42 560 &trs,primaryVertex[2],pflag);
8403ece4 561 for(Int_t nextLay=innLay+1; nextLay<=outerLayer; nextLay++) {
5a03f353 562 kk++;
deae0246 563 nClusLay[kk] = SearchClusters(nextLay,fPhiWin[nloop],fLambdaWin[nloop],
f2150e42 564 &trs,primaryVertex[2],pflag);
deae0246 565 if(nClusLay[kk]!=0){
5a03f353 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++){
deae0246 578 if(nClusLay[nnp]!=0) layOK+=1;
5a03f353 579 }
580 if(layOK==1) {
b881f1fd 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]));
5a03f353 582 AliITStrackV2* tr2 = 0;
583 Bool_t onePoint = kTRUE;
f2150e42 584 tr2 = FitTrack(&trs,primaryVertex,onePoint);
92bb7af4 585 if(!tr2){
92bb7af4 586 continue;
587 }
b881f1fd 588 AliDebug(2,Form("----NPOINTS fit: %d\n",tr2->GetNumberOfClusters()));
5a03f353 589
3bfb5cac 590 StoreTrack(tr2,event,useAllClusters);
5a03f353 591 ntrack++;
592
593 }
594
5a03f353 595 }//end loop on clusters of innLay
596 } //end loop on window sizes
597
5a03f353 598 } //end loop on innLay
599 } // end search 1-point tracks
ebda3140 600
3bfb5cac 601 if(!useAllClusters) AliInfo(Form("Number of found tracks: %d",event->GetNumberOfTracks()));
2d03436a 602 ResetForFinding();
2257f27e 603 return 0;
bef31448 604
605}
7e5bf5af 606
13918578 607//________________________________________________________________________
608
5a03f353 609AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVertex,Bool_t onePoint) {
ebda3140 610 //fit of the found track (most general case, also <6 points, layers missing)
611 // A.Dainese 16.11.07
13918578 612
13918578 613
deae0246 614 const Int_t kMaxClu=AliITStrackSA::kMaxNumberOfClusters;
13918578 615
deae0246 616 static Int_t firstmod[AliITSgeomTGeo::kNLayers];
617
618 static Int_t clind[AliITSgeomTGeo::kNLayers][kMaxClu];
619 static Int_t clmark[AliITSgeomTGeo::kNLayers][kMaxClu];
deae0246 620 static Int_t end[AliITSgeomTGeo::kNLayers];
621 static AliITSRecPoint *listlayer[AliITSgeomTGeo::kNLayers][kMaxClu];
13918578 622
ebda3140 623 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
b8ed1a92 624 firstmod[i]=AliITSgeomTGeo::GetModuleIndex(i+1,1,1);
deae0246 625 end[i]=0;
626 for(Int_t j=0;j<kMaxClu; j++){
ebda3140 627 clind[i][j]=0;
628 clmark[i][j]=0;
deae0246 629 listlayer[i][j]=0;
630 }
b8ed1a92 631 }
2755f080 632
2755f080 633
634 Int_t nclusters = tr->GetNumberOfClustersSA();
2755f080 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;
deae0246 640 Int_t nInLay=end[lay];
641 listlayer[lay][nInLay]=cl;
5691e727 642 clind[lay][nInLay]=index;
deae0246 643 end[lay]++;
2755f080 644 }
2755f080 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);
5691e727 649 clmark[nlay][ncl]=mark;
2755f080 650 }
651 }
652
2755f080 653
654 Int_t firstLay=-1,secondLay=-1;
2755f080 655 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
deae0246 656 if(end[i]==0) {
2755f080 657 end[i]=1;
deae0246 658 }else{
2755f080 659 if(firstLay==-1) {
660 firstLay=i;
661 } else if(secondLay==-1) {
662 secondLay=i;
663 }
664 }
665 }
666
deae0246 667 if(firstLay==-1 || (secondLay==-1 && !onePoint)) return 0;
f2150e42 668 TClonesArray &arrMI= *fListOfTracks;
669 TClonesArray &arrSA= *fListOfSATracks;
670 Int_t nFoundTracks=0;
671
2755f080 672 for(Int_t l0=0;l0<end[0];l0++){ //loop on layer 1
deae0246 673 AliITSRecPoint* cl0 = (AliITSRecPoint*)listlayer[0][l0];
2755f080 674 for(Int_t l1=0;l1<end[1];l1++){ //loop on layer 2
deae0246 675 AliITSRecPoint* cl1 = (AliITSRecPoint*)listlayer[1][l1];
2755f080 676 for(Int_t l2=0;l2<end[2];l2++){ //loop on layer 3
deae0246 677 AliITSRecPoint* cl2 = (AliITSRecPoint*)listlayer[2][l2];
2755f080 678 for(Int_t l3=0;l3<end[3];l3++){ //loop on layer 4
deae0246 679 AliITSRecPoint* cl3 = (AliITSRecPoint*)listlayer[3][l3];
2755f080 680 for(Int_t l4=0;l4<end[4];l4++){ //loop on layer 5
deae0246 681 AliITSRecPoint* cl4 = (AliITSRecPoint*)listlayer[4][l4];
2755f080 682 for(Int_t l5=0;l5<end[5];l5++){ //loop on layer 6
deae0246 683 AliITSRecPoint* cl5 = (AliITSRecPoint*)listlayer[5][l5];
2755f080 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;
ebda3140 696 index1=clind[0][l0];mrk1=clmark[0][l0];
2755f080 697 break;
698 case 1:
699 p1=cl1;
ebda3140 700 index1=clind[1][l1];mrk1=clmark[1][l1];
2755f080 701 break;
702 case 2:
703 p1=cl2;
ebda3140 704 index1=clind[2][l2];mrk1=clmark[2][l2];
2755f080 705 break;
706 case 3:
707 p1=cl3;
ebda3140 708 index1=clind[3][l3];mrk1=clmark[3][l3];
2755f080 709 break;
710 case 4:
711 p1=cl4;
ebda3140 712 index1=clind[4][l4];mrk1=clmark[4][l4];
2755f080 713 break;
714 }
715
716 switch(secondLay) {
717 case 1:
718 p2=cl1;
ebda3140 719 index2=clind[1][l1];mrk2=clmark[1][l1];
2755f080 720 break;
721 case 2:
722 p2=cl2;
ebda3140 723 index2=clind[2][l2];mrk2=clmark[2][l2];
2755f080 724 break;
725 case 3:
726 p2=cl3;
ebda3140 727 index2=clind[3][l3];mrk2=clmark[3][l3];
2755f080 728 break;
729 case 4:
730 p2=cl4;
ebda3140 731 index2=clind[4][l4];mrk2=clmark[4][l4];
2755f080 732 break;
733 case 5:
734 p2=cl5;
ebda3140 735 index2=clind[5][l5];mrk2=clmark[5][l5];
2755f080 736 break;
5a03f353 737 default:
738 p2=0;
739 index2=-1;mrk2=-1;
740 break;
2755f080 741 }
742
743 Int_t module1 = p1->GetDetectorIndex()+firstmod[firstLay];
5a03f353 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;
2755f080 749
750 Int_t cln1=mrk1;
2755f080 751 AliITSclusterTable* arr1 = (AliITSclusterTable*)GetClusterCoord(firstLay,cln1);
2755f080 752 x1 = arr1->GetX();
2755f080 753 y1 = arr1->GetY();
2755f080 754 z1 = arr1->GetZ();
2755f080 755 sx1 = arr1->GetSx();
2755f080 756 sy1 = arr1->GetSy();
2755f080 757 sz1 = arr1->GetSz();
225a692b 758
5a03f353 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
f2150e42 781 AliITStrackSA trac(layer,ladder,detector,yclu1,zclu1,phi2,tgl2,cv,1);
225a692b 782
783
2755f080 784 if(cl5!=0) {
f2150e42 785 trac.AddClusterV2(5,(clind[5][l5] & 0x0fffffff)>>0);
786 trac.AddClusterMark(5,clmark[5][l5]);
b8ed1a92 787 }
788 if(cl4!=0){
f2150e42 789 trac.AddClusterV2(4,(clind[4][l4] & 0x0fffffff)>>0);
790 trac.AddClusterMark(4,clmark[4][l4]);
b8ed1a92 791 }
792 if(cl3!=0){
f2150e42 793 trac.AddClusterV2(3,(clind[3][l3] & 0x0fffffff)>>0);
794 trac.AddClusterMark(3,clmark[3][l3]);
b8ed1a92 795 }
796 if(cl2!=0){
f2150e42 797 trac.AddClusterV2(2,(clind[2][l2] & 0x0fffffff)>>0);
798 trac.AddClusterMark(2,clmark[2][l2]);
b8ed1a92 799 }
800 if(cl1!=0){
f2150e42 801 trac.AddClusterV2(1,(clind[1][l1] & 0x0fffffff)>>0);
802 trac.AddClusterMark(1,clmark[1][l1]);
b8ed1a92 803 }
804 if(cl0!=0){
f2150e42 805 trac.AddClusterV2(0,(clind[0][l0] & 0x0fffffff)>>0);
806 trac.AddClusterMark(0,clmark[0][l0]);
b8ed1a92 807 }
808
b8ed1a92 809 //fit with Kalman filter using AliITStrackerMI::RefitAt()
f2150e42 810 AliITStrackSA ot(trac);
811
812 ot.ResetCovariance(10.);
813 ot.ResetClusters();
b8ed1a92 814
b881f1fd 815 // Propagate inside the innermost layer with a cluster
f2150e42 816 if(ot.Propagate(ot.GetX()-0.1*ot.GetX())) {
b881f1fd 817
f2150e42 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();
b881f1fd 822 //fit from layer 6 to layer 1
f2150e42 823 if(RefitAt(AliITSRecoParam::GetrInsideSPD1(),&otrack2,&ot)) {
824 new(arrMI[nFoundTracks]) AliITStrackMI(otrack2);
825 new(arrSA[nFoundTracks]) AliITStrackSA(trac);
826 ++nFoundTracks;
b881f1fd 827 }
b8ed1a92 828
b881f1fd 829 }
830 }
b8ed1a92 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
b8ed1a92 838
225a692b 839
b8ed1a92 840
deae0246 841 if(fListOfTracks->GetEntries()==0) return 0;
b8ed1a92 842
deae0246 843 Int_t lowchi2 = FindTrackLowChiSquare();
b8ed1a92 844 AliITStrackV2* otrack =(AliITStrackV2*)fListOfTracks->At(lowchi2);
deae0246 845 AliITStrackSA* trsa = (AliITStrackSA*)fListOfSATracks->At(lowchi2);
b8ed1a92 846
deae0246 847 if(otrack==0) return 0;
848
849 Int_t indexc[AliITSgeomTGeo::kNLayers];
b8ed1a92 850 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) indexc[i]=0;
851 for(Int_t nind=0;nind<otrack->GetNumberOfClusters();nind++){
852 indexc[nind] = otrack->GetClusterIndex(nind);
853 }
854 Int_t labl[6][3];
855 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
856 if(i<otrack->GetNumberOfClusters()) {
857 AliITSRecPoint* cl = (AliITSRecPoint*)GetCluster(indexc[i]);
858 labl[i][0]=cl->GetLabel(0);
859 labl[i][1]=cl->GetLabel(1);
860 labl[i][2]=cl->GetLabel(2);
861 } else {
862 labl[i][0]=-1;
863 labl[i][1]=-1;
864 labl[i][2]=-1;
865 }
866 }
2755f080 867
b8ed1a92 868 CookLabel(otrack,0.); //MI change - to see fake ratio
869
870 Int_t label=FindLabel(labl[0][0],labl[1][0],labl[2][0],labl[3][0],labl[4][0],labl[5][0]);
871 Int_t lflag=0;
2755f080 872 for(Int_t i=0;i<otrack->GetNumberOfClusters();i++)
b8ed1a92 873 if(labl[i][0]==label || labl[i][1]==label || labl[i][2]==label) lflag++;
874
2755f080 875 if(lflag<otrack->GetNumberOfClusters()) label = -label;
b8ed1a92 876 otrack->SetLabel(label);
877
878 //remove clusters of found track
879 for(Int_t nlay=0;nlay<AliITSgeomTGeo::GetNLayers();nlay++){
880 for(Int_t cln=0;cln<trsa->GetNumberOfMarked(nlay);cln++){
881 Int_t index = trsa->GetClusterMark(nlay,cln);
882 fCluLayer[nlay]->RemoveAt(index);
883 RemoveClusterCoord(nlay,index);
884 fCluLayer[nlay]->Compress();
7e5bf5af 885 }
886 }
7e5bf5af 887
13918578 888 return otrack;
889
890}
891
c421499f 892//_______________________________________________________
3bfb5cac 893void AliITStrackerSA::StoreTrack(AliITStrackV2 *t,AliESDEvent *event, Bool_t pureSA) const
c421499f 894{
895 //
896 // Add new track to the ESD
897 //
898 AliESDtrack outtrack;
899 outtrack.UpdateTrackParams(t,AliESDtrack::kITSin);
3bfb5cac 900 if(pureSA) outtrack.SetStatus(AliESDtrack::kITSpureSA);
c421499f 901 for(Int_t i=0;i<12;i++) {
902 outtrack.SetITSModuleIndex(i,t->GetModuleIndex(i));
903 }
09cf9d66 904 Double_t sdedx[4]={0.,0.,0.,0.};
905 for(Int_t i=0; i<4; i++) sdedx[i]=t->GetSampledEdx(i);
906 outtrack.SetITSdEdxSamples(sdedx);
c421499f 907 event->AddTrack(&outtrack);
908
909 return;
910}
bef31448 911
4e05ab9a 912
bef31448 913//_______________________________________________________
7e5bf5af 914Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t lambdawindow, AliITStrackSA* trs,Double_t /*zvertex*/,Int_t pflag){
13918578 915 //function used to to find the clusters associated to the track
2755f080 916
4fa7f7d1 917 if(ForceSkippingOfLayer(layer)) return 0;
2755f080 918
13918578 919 Int_t nc=0;
920 AliITSlayer &lay = fgLayers[layer];
7e5bf5af 921 Double_t r=lay.GetR();
2755f080 922 if(pflag==1){
cfe729e0 923 Float_t cx1,cx2,cy1,cy2;
924 FindEquation(fPoint1[0],fPoint1[1],fPoint2[0],fPoint2[1],fPoint3[0],fPoint3[1],fCoef1,fCoef2,fCoef3);
925 if (FindIntersection(fCoef1,fCoef2,fCoef3,-r*r,cx1,cy1,cx2,cy2)==0)
926 return 0;
1966f03c 927 Double_t fi1=TMath::ATan2(cy1-fPoint1[1],cx1-fPoint1[0]);
928 Double_t fi2=TMath::ATan2(cy2-fPoint1[1],cx2-fPoint1[0]);
cfe729e0 929 fPhiEstimate=ChoosePoint(fi1,fi2,fPhic);
930 }
13918578 931
7e5bf5af 932
933 Int_t ncl = fCluLayer[layer]->GetEntries();
934 for (Int_t index=0; index<ncl; index++) {
00a7cc50 935 AliITSRecPoint *c = (AliITSRecPoint*)fCluLayer[layer]->At(index);
7e5bf5af 936 if (!c) continue;
937 if (c->GetQ()<=0) continue;
3733ccd2 938 if(layer>1 && c->GetQ()<=fMinQ) continue;
7e5bf5af 939
940 AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(layer,index);
941 Double_t phi = arr->GetPhi();
cfe729e0 942 if (TMath::Abs(phi-fPhiEstimate)>phiwindow) continue;
494fda7c 943
7e5bf5af 944 Double_t lambda = arr->GetLambda();
cfe729e0 945 if (TMath::Abs(lambda-fLambdac)>lambdawindow) continue;
946
7e5bf5af 947 if(trs->GetNumberOfClustersSA()==trs->GetMaxNumberOfClusters()) return 0;
948 if(trs->GetNumberOfMarked(layer)==trs->GetMaxNMarkedPerLayer()) return 0;
949 Int_t orind = arr->GetOrInd();
950 trs->AddClusterSA(layer,orind);
951 trs->AddClusterMark(layer,index);
952
cfe729e0 953 nc++;
954 fLambdac=lambda;
955 fPhiEstimate=phi;
cfe729e0 956
7e5bf5af 957 fPointc[0]=arr->GetX();
958 fPointc[1]=arr->GetY();
959
cfe729e0 960 }
961 return nc;
962}
13918578 963
12b1afb7 964//________________________________________________________________
965Bool_t AliITStrackerSA::SetFirstPoint(Int_t lay, Int_t clu, Double_t* primaryVertex){
966 // Sets the first point (seed) for tracking
967
968 AliITSRecPoint* cl = (AliITSRecPoint*)fCluLayer[lay]->At(clu);
969 if(!cl) return kFALSE;
970 if (cl->GetQ()<=0) return kFALSE;
971 if(lay>1 && cl->GetQ()<=fMinQ) return kFALSE;
972
973 AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(lay,clu);
974 fPhic = arr->GetPhi();
975 fLambdac = arr->GetLambda();
976 fPhiEstimate = fPhic;
977 fPoint1[0]=primaryVertex[0];
978 fPoint1[1]=primaryVertex[1];
979 fPoint2[0]=arr->GetX();
980 fPoint2[1]=arr->GetY();
981 return kTRUE;
982}
983
bef31448 984//________________________________________________________________
985void AliITStrackerSA::UpdatePoints(){
986 //update of points for the estimation of the curvature
13918578 987
bef31448 988 fPoint2[0]=fPoint3[0];
989 fPoint2[1]=fPoint3[1];
990 fPoint3[0]=fPointc[0];
991 fPoint3[1]=fPointc[1];
13918578 992
993
13918578 994}
13918578 995
13918578 996//___________________________________________________________________
997Int_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){
998
999 //given (x,y) of three recpoints (in global coordinates)
1000 //returns the parameters a,b,c of circonference x*x + y*y +a*x + b*y +c
1001
1002 Float_t den = (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1);
1003 if(den==0) return 0;
1004 a = ((y3-y1)*(x2*x2+y2*y2-x1*x1-y1*y1)-(y2-y1)*(x3*x3+y3*y3-x1*x1-y1*y1))/den;
1005 b = -(x2*x2-x1*x1+y2*y2-y1*y1+a*(x2-x1))/(y2-y1);
1006 c = -x1*x1-y1*y1-a*x1-b*y1;
1007 return 1;
1008 }
1009//__________________________________________________________________________
1010 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){
1011
1012 //Finds the intersection between the circonference of the track and the circonference centered in (0,0) represented by one layer
1013 //c2 is -rlayer*rlayer
1014
1015 if(a1==0) return 0;
3a2f227d 1016 Double_t m = c2-c1;
1017 Double_t aA = (b1*b1)/(a1*a1)+1;
1018 Double_t bB = (-2*m*b1/(a1*a1));
1019 Double_t cC = c2+(m*m)/(a1*a1);
1020 Double_t dD = bB*bB-4*aA*cC;
1021 if(dD<0) return 0;
13918578 1022
3a2f227d 1023 y1 = (-bB+TMath::Sqrt(dD))/(2*aA);
1024 y2 = (-bB-TMath::Sqrt(dD))/(2*aA);
13918578 1025 x1 = (c2-c1-b1*y1)/a1;
1026 x2 = (c2-c1-b1*y2)/a1;
1027
1028 return 1;
1029}
1030//____________________________________________________________________
1031Double_t AliITStrackerSA::Curvature(Double_t x1,Double_t y1,Double_t
1032x2,Double_t y2,Double_t x3,Double_t y3){
1033
1034 //calculates the curvature of track
1035 Double_t den = (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1);
1036 if(den==0) return 0;
1037 Double_t a = ((y3-y1)*(x2*x2+y2*y2-x1*x1-y1*y1)-(y2-y1)*(x3*x3+y3*y3-x1*x1-y1*y1))/den;
1038 Double_t b = -(x2*x2-x1*x1+y2*y2-y1*y1+a*(x2-x1))/(y2-y1);
1039 Double_t c = -x1*x1-y1*y1-a*x1-b*y1;
1040 Double_t xc=-a/2.;
1041
1042 if((a*a+b*b-4*c)<0) return 0;
1043 Double_t rad = TMath::Sqrt(a*a+b*b-4*c)/2.;
1044 if(rad==0) return 0;
1045
1046 if((x1>0 && y1>0 && x1<xc)) rad*=-1;
1047 if((x1<0 && y1>0 && x1<xc)) rad*=-1;
1048 // if((x1<0 && y1<0 && x1<xc)) rad*=-1;
1049 // if((x1>0 && y1<0 && x1<xc)) rad*=-1;
1050
1051 return 1/rad;
1052
1053}
7e5bf5af 1054
1055
13918578 1056//____________________________________________________________________
1057Double_t AliITStrackerSA::ChoosePoint(Double_t p1, Double_t p2, Double_t pp){
1058
1059 //Returns the point closest to pp
1060
1061 Double_t diff1 = p1-pp;
1062 Double_t diff2 = p2-pp;
1063
1064 if(TMath::Abs(diff1)<TMath::Abs(diff2)) fPhiEstimate=p1;
1065 else fPhiEstimate=p2;
1066 return fPhiEstimate;
1067
1068}
1069
1070
1071//_________________________________________________________________
deae0246 1072Int_t AliITStrackerSA::FindTrackLowChiSquare() const {
1073 // returns track with lowest chi square
1074 Int_t dim=fListOfTracks->GetEntries();
1075 if(dim<=1) return 0;
1076 AliITStrackV2* trk = (AliITStrackV2*)fListOfTracks->At(0);
1077 Double_t minChi2=trk->GetChi2();
1078 Int_t index=0;
1079 for(Int_t i=1;i<dim;i++){
4adcf390 1080 trk = (AliITStrackV2*)fListOfTracks->At(i);
deae0246 1081 Double_t chi2=trk->GetChi2();
1082 if(chi2<minChi2){
1083 minChi2=chi2;
1084 index=i;
13918578 1085 }
13918578 1086 }
deae0246 1087 return index;
13918578 1088}
1089
1090//__________________________________________________________
2755f080 1091Int_t AliITStrackerSA::FindLabel(Int_t l0, Int_t l1, Int_t l2, Int_t l3, Int_t l4, Int_t l5){
13918578 1092
1093 //function used to determine the track label
1094
2755f080 1095 Int_t lb[6] = {l0,l1,l2,l3,l4,l5};
13918578 1096 Int_t aa[6]={1,1,1,1,1,1};
1097 Int_t ff=0;
1098 Int_t ll=0;
1099 Int_t k=0;Int_t w=0;Int_t num=6;
8b3779ef 1100 for(Int_t i=5;i>=0;i--) if(lb[i]==-1) num=i;
13918578 1101
1102 while(k<num){
1103
1104 for(Int_t i=k+1;i<num;i++){
1105
1106 if(lb[k]==lb[i] && aa[k]!=0){
1107
1108 aa[k]+=1;
1109 aa[i]=0;
1110 }
1111 }
8b3779ef 1112 k++;
13918578 1113 }
1114
1115 while(w<num){
8b3779ef 1116
13918578 1117 for(Int_t j=0;j<6;j++){
1118 if(aa[w]<aa[j]){
1119 ff=aa[w];
1120 aa[w]=aa[j];
1121 aa[j]=ff;
1122 ll=lb[w];
1123 lb[w]=lb[j];
1124 lb[j]=ll;
1125 }
1126 }
8b3779ef 1127 w++;
13918578 1128 }
8b3779ef 1129
1130 if(num<1) return -1;
1131 return lb[num-1];
13918578 1132}
1133
1134//_____________________________________________________________________________
1135Int_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,
2755f080 1136Int_t gl12, Int_t gl13, Int_t gl14,Int_t gl15, Int_t gl16, Int_t gl17, Int_t gl18, Int_t minNPoints){
13918578 1137
1138
1139 //function used to assign label to the found track. If track is fake, the label is negative
1140
1141 Int_t lb0[6] = {gl1,gl2,gl3,gl4,gl5,gl6};
1142 Int_t lb1[6] = {gl7,gl8,gl9,gl10,gl11,gl12};
1143 Int_t lb2[6] = {gl13,gl14,gl15,gl16,gl17,gl18};
1144 Int_t ll=FindLabel(lb0[0],lb0[1],lb0[2],lb0[3],lb0[4],lb0[5]);
1145 Int_t lflag=0;Int_t num=6;
1146 if(lb0[5]==-1 && lb1[5]==-1 && lb2[5]==-1) num=5;
1147
1148 for(Int_t i=0;i<num;i++){
1149 if(lb0[i]==ll || lb1[i]==ll || lb2[i]==ll) lflag+=1;
1150 }
1151
2755f080 1152 if(lflag>=minNPoints) return ll;
13918578 1153 else return -ll;
1154
1155
1156}
13918578 1157//_____________________________________________________________________________
5b4dedce 1158void AliITStrackerSA::SetCalculatedWindowSizes(Int_t n, Float_t phimin, Float_t phimax, Float_t lambdamin, Float_t lambdamax){
1159 // Set sizes of the phi and lambda windows used for track finding
1160 fNloop = n;
1161 if(fPhiWin) delete [] fPhiWin;
1162 if(fLambdaWin) delete [] fLambdaWin;
1163 fPhiWin = new Double_t[fNloop];
1164 fLambdaWin = new Double_t[fNloop];
1165 Float_t stepPhi=(phimax-phimin)/(Float_t)(fNloop-1);
1166 Float_t stepLambda=(lambdamax-lambdamin)/(Float_t)(fNloop-1);
1167 for(Int_t k=0;k<fNloop;k++){
1168 Float_t phi=phimin+k*stepPhi;
1169 Float_t lam=lambdamin+k*stepLambda;
1170 fPhiWin[k]=phi;
1171 fLambdaWin[k]=lam;
1172 }
1173}
1174//_____________________________________________________________________________
1175void AliITStrackerSA::SetFixedWindowSizes(Int_t n, Double_t *phi, Double_t *lam){
13918578 1176 // Set sizes of the phi and lambda windows used for track finding
1177 fNloop = n;
1178 if(phi){ // user defined values
1179 fPhiWin = new Double_t[fNloop];
1180 fLambdaWin = new Double_t[fNloop];
1181 for(Int_t k=0;k<fNloop;k++){
1182 fPhiWin[k]=phi[k];
1183 fLambdaWin[k]=lam[k];
1184 }
1185 }
1186 else { // default values
627b6db6 1187
1188 Double_t phid[33] = {0.002,0.003,0.004,0.0045,0.0047,
bef31448 1189 0.005,0.0053,0.0055,
1190 0.006,0.0063,0.0065,0.007,0.0073,0.0075,0.0077,
1191 0.008,0.0083,0.0085,0.0087,0.009,0.0095,0.0097,
627b6db6 1192 0.01,0.0105,0.011,0.0115,0.012,0.0125,0.013,0.0135,0.0140,0.0145};
1193 Double_t lambdad[33] = {0.003,0.004,0.005,0.005,0.005,
1194 0.005,0.005,0.006,
1195 0.006,0.006,0.006,0.007,0.007,0.007,0.007,
1196 0.007,0.007,0.007,0.007,0.007,0.007,0.007,
1197 0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008};
bef31448 1198
627b6db6 1199 if(fNloop!=33){
1200 fNloop = 33;
13918578 1201 }
627b6db6 1202
1203
13918578 1204 fPhiWin = new Double_t[fNloop];
1205 fLambdaWin = new Double_t[fNloop];
e340bb86 1206
e340bb86 1207 Double_t factor=AliITSReconstructor::GetRecoParam()->GetFactorSAWindowSizes(); // possibility to enlarge windows for cosmics reco with large misalignments (A.Dainese)
2755f080 1208
1209 for(Int_t k=0;k<fNloop;k++){
e340bb86 1210 fPhiWin[k]=phid[k]*factor;
1211 fLambdaWin[k]=lambdad[k]*factor;
13918578 1212 }
1213
1214 }
1215
1216}
7e5bf5af 1217//_______________________________________________________________________
cc088660 1218void AliITStrackerSA::GetCoorAngles(AliITSRecPoint* cl,Double_t &phi,Double_t &lambda, Float_t &x, Float_t &y,Float_t &z,Double_t* vertex){
7e5bf5af 1219 //Returns values of phi (azimuthal) and lambda angles for a given cluster
cc088660 1220/*
7e5bf5af 1221 Double_t rot[9]; fGeom->GetRotMatrix(module,rot);
1222 Int_t lay,lad,det; fGeom->GetModuleId(module,lay,lad,det);
1223 Float_t tx,ty,tz; fGeom->GetTrans(lay,lad,det,tx,ty,tz);
1224
1225 Double_t alpha=TMath::ATan2(rot[1],rot[0])+TMath::Pi();
1226 Double_t phi1=TMath::Pi()/2+alpha;
1227 if (lay==1) phi1+=TMath::Pi();
1228
1229 Float_t cp=TMath::Cos(phi1), sp=TMath::Sin(phi1);
1230 Float_t r=tx*cp+ty*sp;
1231
cc088660 1232 xyz= r*cp - cl->GetY()*sp;
7e5bf5af 1233 y= r*sp + cl->GetY()*cp;
1234 z=cl->GetZ();
cc088660 1235*/
1236 Float_t xyz[3];
1237 cl->GetGlobalXYZ(xyz);
1238 x=xyz[0];
1239 y=xyz[1];
1240 z=xyz[2];
1241
1966f03c 1242 phi=TMath::ATan2(y-vertex[1],x-vertex[0]);
7e5bf5af 1243 lambda=TMath::ATan2(z-vertex[2],TMath::Sqrt((x-vertex[0])*(x-vertex[0])+(y-vertex[1])*(y-vertex[1])));
1244}
13918578 1245
7e5bf5af 1246//________________________________________________________________________
cc088660 1247void AliITStrackerSA::GetCoorErrors(AliITSRecPoint* cl,Float_t &sx,Float_t &sy, Float_t &sz){
7e5bf5af 1248
cc088660 1249 //returns sigmax, y, z of cluster in global coordinates
1250/*
7e5bf5af 1251 Double_t rot[9]; fGeom->GetRotMatrix(module,rot);
cc088660 1252 Int_t lay,lad,det;
1253 AliITSgeomTGeo::GetModuleId(module,lay,lad,det);
7e5bf5af 1254
1255 Double_t alpha=TMath::ATan2(rot[1],rot[0])+TMath::Pi();
1256 Double_t phi=TMath::Pi()/2+alpha;
1257 if (lay==1) phi+=TMath::Pi();
1258
1259 Float_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
cc088660 1260*/
1261 Float_t covm[6];
1262 cl->GetGlobalCov(covm);
1263 sx=TMath::Sqrt(covm[0]);
1264 sy=TMath::Sqrt(covm[3]);
1265 sz=TMath::Sqrt(covm[5]);
1266/*
7e5bf5af 1267 sx = TMath::Sqrt(sp*sp*cl->GetSigmaY2());
1268 sy = TMath::Sqrt(cp*cp*cl->GetSigmaY2());
1269 sz = TMath::Sqrt(cl->GetSigmaZ2());
cc088660 1270*/
7e5bf5af 1271}
f2150e42 1272