]> 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
Use 1kHz sampling as default.
[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);
2755f080 638 Int_t lay = (index & 0xf0000000) >> 28;
deae0246 639 Int_t nInLay=end[lay];
640 listlayer[lay][nInLay]=cl;
5691e727 641 clind[lay][nInLay]=index;
deae0246 642 end[lay]++;
2755f080 643 }
2755f080 644
645 for(Int_t nlay=0;nlay<AliITSgeomTGeo::GetNLayers();nlay++){
646 for(Int_t ncl=0;ncl<tr->GetNumberOfMarked(nlay);ncl++){
647 Int_t mark = tr->GetClusterMark(nlay,ncl);
5691e727 648 clmark[nlay][ncl]=mark;
2755f080 649 }
650 }
651
2755f080 652
653 Int_t firstLay=-1,secondLay=-1;
2755f080 654 for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
deae0246 655 if(end[i]==0) {
2755f080 656 end[i]=1;
deae0246 657 }else{
2755f080 658 if(firstLay==-1) {
659 firstLay=i;
660 } else if(secondLay==-1) {
661 secondLay=i;
662 }
663 }
664 }
665
deae0246 666 if(firstLay==-1 || (secondLay==-1 && !onePoint)) return 0;
f2150e42 667 TClonesArray &arrMI= *fListOfTracks;
668 TClonesArray &arrSA= *fListOfSATracks;
669 Int_t nFoundTracks=0;
670
2755f080 671 for(Int_t l0=0;l0<end[0];l0++){ //loop on layer 1
deae0246 672 AliITSRecPoint* cl0 = (AliITSRecPoint*)listlayer[0][l0];
2755f080 673 for(Int_t l1=0;l1<end[1];l1++){ //loop on layer 2
deae0246 674 AliITSRecPoint* cl1 = (AliITSRecPoint*)listlayer[1][l1];
2755f080 675 for(Int_t l2=0;l2<end[2];l2++){ //loop on layer 3
deae0246 676 AliITSRecPoint* cl2 = (AliITSRecPoint*)listlayer[2][l2];
2755f080 677 for(Int_t l3=0;l3<end[3];l3++){ //loop on layer 4
deae0246 678 AliITSRecPoint* cl3 = (AliITSRecPoint*)listlayer[3][l3];
2755f080 679 for(Int_t l4=0;l4<end[4];l4++){ //loop on layer 5
deae0246 680 AliITSRecPoint* cl4 = (AliITSRecPoint*)listlayer[4][l4];
2755f080 681 for(Int_t l5=0;l5<end[5];l5++){ //loop on layer 6
deae0246 682 AliITSRecPoint* cl5 = (AliITSRecPoint*)listlayer[5][l5];
2755f080 683
684
685 Double_t x1,y1,z1,sx1,sy1,sz1;
686 Double_t x2,y2,z2,sx2,sy2,sz2;
687 AliITSRecPoint* p1=0;
688 AliITSRecPoint* p2=0;
689 Int_t index1=0,index2=0;
690 Int_t mrk1=0,mrk2=0;
691
692 switch(firstLay) {
693 case 0:
694 p1=cl0;
ebda3140 695 index1=clind[0][l0];mrk1=clmark[0][l0];
2755f080 696 break;
697 case 1:
698 p1=cl1;
ebda3140 699 index1=clind[1][l1];mrk1=clmark[1][l1];
2755f080 700 break;
701 case 2:
702 p1=cl2;
ebda3140 703 index1=clind[2][l2];mrk1=clmark[2][l2];
2755f080 704 break;
705 case 3:
706 p1=cl3;
ebda3140 707 index1=clind[3][l3];mrk1=clmark[3][l3];
2755f080 708 break;
709 case 4:
710 p1=cl4;
ebda3140 711 index1=clind[4][l4];mrk1=clmark[4][l4];
2755f080 712 break;
713 }
714
715 switch(secondLay) {
716 case 1:
717 p2=cl1;
ebda3140 718 index2=clind[1][l1];mrk2=clmark[1][l1];
2755f080 719 break;
720 case 2:
721 p2=cl2;
ebda3140 722 index2=clind[2][l2];mrk2=clmark[2][l2];
2755f080 723 break;
724 case 3:
725 p2=cl3;
ebda3140 726 index2=clind[3][l3];mrk2=clmark[3][l3];
2755f080 727 break;
728 case 4:
729 p2=cl4;
ebda3140 730 index2=clind[4][l4];mrk2=clmark[4][l4];
2755f080 731 break;
732 case 5:
733 p2=cl5;
ebda3140 734 index2=clind[5][l5];mrk2=clmark[5][l5];
2755f080 735 break;
5a03f353 736 default:
737 p2=0;
738 index2=-1;mrk2=-1;
739 break;
2755f080 740 }
741
742 Int_t module1 = p1->GetDetectorIndex()+firstmod[firstLay];
5a03f353 743 Int_t layer,ladder,detector;
744 AliITSgeomTGeo::GetModuleId(module1,layer,ladder,detector);
745 Float_t yclu1 = p1->GetY();
746 Float_t zclu1 = p1->GetZ();
747 Double_t cv=0,tgl2=0,phi2=0;
2755f080 748
749 Int_t cln1=mrk1;
2755f080 750 AliITSclusterTable* arr1 = (AliITSclusterTable*)GetClusterCoord(firstLay,cln1);
2755f080 751 x1 = arr1->GetX();
2755f080 752 y1 = arr1->GetY();
2755f080 753 z1 = arr1->GetZ();
2755f080 754 sx1 = arr1->GetSx();
2755f080 755 sy1 = arr1->GetSy();
2755f080 756 sz1 = arr1->GetSz();
225a692b 757
5a03f353 758 if(secondLay>0) {
759 Int_t cln2=mrk2;
760 AliITSclusterTable* arr2 = (AliITSclusterTable*)GetClusterCoord(secondLay,cln2);
761 x2 = arr2->GetX();
762 y2 = arr2->GetY();
763 z2 = arr2->GetZ();
764 sx2 = arr2->GetSx();
765 sy2 = arr2->GetSy();
766 sz2 = arr2->GetSz();
767 cv = Curvature(primaryVertex[0],primaryVertex[1],x1,y1,x2,y2);
768 tgl2 = (z2-z1)/TMath::Sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
769 phi2 = TMath::ATan2((y2-y1),(x2-x1));
770 } else { // special case of 1-point tracks, only for cosmics (B=0)
771 x2 = primaryVertex[0];
772 y2 = primaryVertex[1];
773 z2 = primaryVertex[2];
774 cv = 0;
775 tgl2 = (z1-z2)/TMath::Sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
776 phi2 = TMath::ATan2((y1-y2),(x1-x2));
777 }
778
779
f2150e42 780 AliITStrackSA trac(layer,ladder,detector,yclu1,zclu1,phi2,tgl2,cv,1);
225a692b 781
782
2755f080 783 if(cl5!=0) {
f2150e42 784 trac.AddClusterV2(5,(clind[5][l5] & 0x0fffffff)>>0);
785 trac.AddClusterMark(5,clmark[5][l5]);
b8ed1a92 786 }
787 if(cl4!=0){
f2150e42 788 trac.AddClusterV2(4,(clind[4][l4] & 0x0fffffff)>>0);
789 trac.AddClusterMark(4,clmark[4][l4]);
b8ed1a92 790 }
791 if(cl3!=0){
f2150e42 792 trac.AddClusterV2(3,(clind[3][l3] & 0x0fffffff)>>0);
793 trac.AddClusterMark(3,clmark[3][l3]);
b8ed1a92 794 }
795 if(cl2!=0){
f2150e42 796 trac.AddClusterV2(2,(clind[2][l2] & 0x0fffffff)>>0);
797 trac.AddClusterMark(2,clmark[2][l2]);
b8ed1a92 798 }
799 if(cl1!=0){
f2150e42 800 trac.AddClusterV2(1,(clind[1][l1] & 0x0fffffff)>>0);
801 trac.AddClusterMark(1,clmark[1][l1]);
b8ed1a92 802 }
803 if(cl0!=0){
f2150e42 804 trac.AddClusterV2(0,(clind[0][l0] & 0x0fffffff)>>0);
805 trac.AddClusterMark(0,clmark[0][l0]);
b8ed1a92 806 }
807
b8ed1a92 808 //fit with Kalman filter using AliITStrackerMI::RefitAt()
f2150e42 809 AliITStrackSA ot(trac);
810
811 ot.ResetCovariance(10.);
812 ot.ResetClusters();
b8ed1a92 813
b881f1fd 814 // Propagate inside the innermost layer with a cluster
f2150e42 815 if(ot.Propagate(ot.GetX()-0.1*ot.GetX())) {
b881f1fd 816
f2150e42 817 if(RefitAt(AliITSRecoParam::GetrInsideITSscreen(),&ot,&trac)){ //fit from layer 1 to layer 6
818 AliITStrackMI otrack2(ot);
819 otrack2.ResetCovariance(10.);
820 otrack2.ResetClusters();
b881f1fd 821 //fit from layer 6 to layer 1
f2150e42 822 if(RefitAt(AliITSRecoParam::GetrInsideSPD1(),&otrack2,&ot)) {
823 new(arrMI[nFoundTracks]) AliITStrackMI(otrack2);
824 new(arrSA[nFoundTracks]) AliITStrackSA(trac);
825 ++nFoundTracks;
b881f1fd 826 }
b8ed1a92 827
b881f1fd 828 }
829 }
b8ed1a92 830 }//end loop layer 6
831 }//end loop layer 5
832 }//end loop layer 4
833 }//end loop layer 3
834 }//end loop layer 2
835 }//end loop layer 1
836
b8ed1a92 837
225a692b 838
b8ed1a92 839
deae0246 840 if(fListOfTracks->GetEntries()==0) return 0;
b8ed1a92 841
deae0246 842 Int_t lowchi2 = FindTrackLowChiSquare();
b8ed1a92 843 AliITStrackV2* otrack =(AliITStrackV2*)fListOfTracks->At(lowchi2);
deae0246 844 AliITStrackSA* trsa = (AliITStrackSA*)fListOfSATracks->At(lowchi2);
b8ed1a92 845
deae0246 846 if(otrack==0) return 0;
847
b8ed1a92 848 CookLabel(otrack,0.); //MI change - to see fake ratio
ee16fb28 849 Int_t label=FindLabel(otrack);
b8ed1a92 850 otrack->SetLabel(label);
5ee2a45c 851 Double_t low=0.;
852 Double_t up=0.51;
853 otrack->CookdEdx(low,up);
b8ed1a92 854
855 //remove clusters of found track
856 for(Int_t nlay=0;nlay<AliITSgeomTGeo::GetNLayers();nlay++){
857 for(Int_t cln=0;cln<trsa->GetNumberOfMarked(nlay);cln++){
858 Int_t index = trsa->GetClusterMark(nlay,cln);
859 fCluLayer[nlay]->RemoveAt(index);
860 RemoveClusterCoord(nlay,index);
861 fCluLayer[nlay]->Compress();
7e5bf5af 862 }
863 }
7e5bf5af 864
13918578 865 return otrack;
866
867}
868
c421499f 869//_______________________________________________________
3bfb5cac 870void AliITStrackerSA::StoreTrack(AliITStrackV2 *t,AliESDEvent *event, Bool_t pureSA) const
c421499f 871{
872 //
873 // Add new track to the ESD
874 //
875 AliESDtrack outtrack;
876 outtrack.UpdateTrackParams(t,AliESDtrack::kITSin);
3bfb5cac 877 if(pureSA) outtrack.SetStatus(AliESDtrack::kITSpureSA);
c421499f 878 for(Int_t i=0;i<12;i++) {
879 outtrack.SetITSModuleIndex(i,t->GetModuleIndex(i));
880 }
09cf9d66 881 Double_t sdedx[4]={0.,0.,0.,0.};
882 for(Int_t i=0; i<4; i++) sdedx[i]=t->GetSampledEdx(i);
883 outtrack.SetITSdEdxSamples(sdedx);
c421499f 884 event->AddTrack(&outtrack);
885
886 return;
887}
bef31448 888
4e05ab9a 889
bef31448 890//_______________________________________________________
7e5bf5af 891Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t lambdawindow, AliITStrackSA* trs,Double_t /*zvertex*/,Int_t pflag){
13918578 892 //function used to to find the clusters associated to the track
2755f080 893
4fa7f7d1 894 if(ForceSkippingOfLayer(layer)) return 0;
2755f080 895
13918578 896 Int_t nc=0;
897 AliITSlayer &lay = fgLayers[layer];
7e5bf5af 898 Double_t r=lay.GetR();
2755f080 899 if(pflag==1){
cfe729e0 900 Float_t cx1,cx2,cy1,cy2;
901 FindEquation(fPoint1[0],fPoint1[1],fPoint2[0],fPoint2[1],fPoint3[0],fPoint3[1],fCoef1,fCoef2,fCoef3);
902 if (FindIntersection(fCoef1,fCoef2,fCoef3,-r*r,cx1,cy1,cx2,cy2)==0)
903 return 0;
1966f03c 904 Double_t fi1=TMath::ATan2(cy1-fPoint1[1],cx1-fPoint1[0]);
905 Double_t fi2=TMath::ATan2(cy2-fPoint1[1],cx2-fPoint1[0]);
cfe729e0 906 fPhiEstimate=ChoosePoint(fi1,fi2,fPhic);
907 }
13918578 908
7e5bf5af 909
910 Int_t ncl = fCluLayer[layer]->GetEntries();
911 for (Int_t index=0; index<ncl; index++) {
00a7cc50 912 AliITSRecPoint *c = (AliITSRecPoint*)fCluLayer[layer]->At(index);
7e5bf5af 913 if (!c) continue;
914 if (c->GetQ()<=0) continue;
3733ccd2 915 if(layer>1 && c->GetQ()<=fMinQ) continue;
7e5bf5af 916
917 AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(layer,index);
918 Double_t phi = arr->GetPhi();
cfe729e0 919 if (TMath::Abs(phi-fPhiEstimate)>phiwindow) continue;
494fda7c 920
7e5bf5af 921 Double_t lambda = arr->GetLambda();
cfe729e0 922 if (TMath::Abs(lambda-fLambdac)>lambdawindow) continue;
923
7e5bf5af 924 if(trs->GetNumberOfClustersSA()==trs->GetMaxNumberOfClusters()) return 0;
925 if(trs->GetNumberOfMarked(layer)==trs->GetMaxNMarkedPerLayer()) return 0;
926 Int_t orind = arr->GetOrInd();
927 trs->AddClusterSA(layer,orind);
928 trs->AddClusterMark(layer,index);
929
cfe729e0 930 nc++;
931 fLambdac=lambda;
932 fPhiEstimate=phi;
cfe729e0 933
7e5bf5af 934 fPointc[0]=arr->GetX();
935 fPointc[1]=arr->GetY();
936
cfe729e0 937 }
938 return nc;
939}
13918578 940
12b1afb7 941//________________________________________________________________
942Bool_t AliITStrackerSA::SetFirstPoint(Int_t lay, Int_t clu, Double_t* primaryVertex){
943 // Sets the first point (seed) for tracking
944
945 AliITSRecPoint* cl = (AliITSRecPoint*)fCluLayer[lay]->At(clu);
946 if(!cl) return kFALSE;
947 if (cl->GetQ()<=0) return kFALSE;
948 if(lay>1 && cl->GetQ()<=fMinQ) return kFALSE;
949
950 AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(lay,clu);
951 fPhic = arr->GetPhi();
952 fLambdac = arr->GetLambda();
953 fPhiEstimate = fPhic;
954 fPoint1[0]=primaryVertex[0];
955 fPoint1[1]=primaryVertex[1];
956 fPoint2[0]=arr->GetX();
957 fPoint2[1]=arr->GetY();
958 return kTRUE;
959}
960
bef31448 961//________________________________________________________________
962void AliITStrackerSA::UpdatePoints(){
963 //update of points for the estimation of the curvature
13918578 964
bef31448 965 fPoint2[0]=fPoint3[0];
966 fPoint2[1]=fPoint3[1];
967 fPoint3[0]=fPointc[0];
968 fPoint3[1]=fPointc[1];
13918578 969
970
13918578 971}
13918578 972
13918578 973//___________________________________________________________________
974Int_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){
975
976 //given (x,y) of three recpoints (in global coordinates)
977 //returns the parameters a,b,c of circonference x*x + y*y +a*x + b*y +c
978
979 Float_t den = (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1);
980 if(den==0) return 0;
981 a = ((y3-y1)*(x2*x2+y2*y2-x1*x1-y1*y1)-(y2-y1)*(x3*x3+y3*y3-x1*x1-y1*y1))/den;
982 b = -(x2*x2-x1*x1+y2*y2-y1*y1+a*(x2-x1))/(y2-y1);
983 c = -x1*x1-y1*y1-a*x1-b*y1;
984 return 1;
985 }
986//__________________________________________________________________________
987 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){
988
989 //Finds the intersection between the circonference of the track and the circonference centered in (0,0) represented by one layer
990 //c2 is -rlayer*rlayer
991
992 if(a1==0) return 0;
3a2f227d 993 Double_t m = c2-c1;
994 Double_t aA = (b1*b1)/(a1*a1)+1;
995 Double_t bB = (-2*m*b1/(a1*a1));
996 Double_t cC = c2+(m*m)/(a1*a1);
997 Double_t dD = bB*bB-4*aA*cC;
998 if(dD<0) return 0;
13918578 999
3a2f227d 1000 y1 = (-bB+TMath::Sqrt(dD))/(2*aA);
1001 y2 = (-bB-TMath::Sqrt(dD))/(2*aA);
13918578 1002 x1 = (c2-c1-b1*y1)/a1;
1003 x2 = (c2-c1-b1*y2)/a1;
1004
1005 return 1;
1006}
1007//____________________________________________________________________
1008Double_t AliITStrackerSA::Curvature(Double_t x1,Double_t y1,Double_t
1009x2,Double_t y2,Double_t x3,Double_t y3){
1010
1011 //calculates the curvature of track
1012 Double_t den = (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1);
1013 if(den==0) return 0;
1014 Double_t a = ((y3-y1)*(x2*x2+y2*y2-x1*x1-y1*y1)-(y2-y1)*(x3*x3+y3*y3-x1*x1-y1*y1))/den;
1015 Double_t b = -(x2*x2-x1*x1+y2*y2-y1*y1+a*(x2-x1))/(y2-y1);
1016 Double_t c = -x1*x1-y1*y1-a*x1-b*y1;
1017 Double_t xc=-a/2.;
1018
1019 if((a*a+b*b-4*c)<0) return 0;
1020 Double_t rad = TMath::Sqrt(a*a+b*b-4*c)/2.;
1021 if(rad==0) return 0;
1022
1023 if((x1>0 && y1>0 && x1<xc)) rad*=-1;
1024 if((x1<0 && y1>0 && x1<xc)) rad*=-1;
1025 // if((x1<0 && y1<0 && x1<xc)) rad*=-1;
1026 // if((x1>0 && y1<0 && x1<xc)) rad*=-1;
1027
1028 return 1/rad;
1029
1030}
7e5bf5af 1031
1032
13918578 1033//____________________________________________________________________
1034Double_t AliITStrackerSA::ChoosePoint(Double_t p1, Double_t p2, Double_t pp){
1035
1036 //Returns the point closest to pp
1037
1038 Double_t diff1 = p1-pp;
1039 Double_t diff2 = p2-pp;
1040
1041 if(TMath::Abs(diff1)<TMath::Abs(diff2)) fPhiEstimate=p1;
1042 else fPhiEstimate=p2;
1043 return fPhiEstimate;
1044
1045}
1046
1047
1048//_________________________________________________________________
deae0246 1049Int_t AliITStrackerSA::FindTrackLowChiSquare() const {
1050 // returns track with lowest chi square
1051 Int_t dim=fListOfTracks->GetEntries();
1052 if(dim<=1) return 0;
1053 AliITStrackV2* trk = (AliITStrackV2*)fListOfTracks->At(0);
1054 Double_t minChi2=trk->GetChi2();
1055 Int_t index=0;
1056 for(Int_t i=1;i<dim;i++){
4adcf390 1057 trk = (AliITStrackV2*)fListOfTracks->At(i);
deae0246 1058 Double_t chi2=trk->GetChi2();
1059 if(chi2<minChi2){
1060 minChi2=chi2;
1061 index=i;
13918578 1062 }
13918578 1063 }
deae0246 1064 return index;
13918578 1065}
1066
1067//__________________________________________________________
ee16fb28 1068Int_t AliITStrackerSA::FindLabel(AliITStrackV2* track){
1069 //
13918578 1070
ee16fb28 1071 Int_t labl[AliITSgeomTGeo::kNLayers][3];
1072 Int_t cnts[AliITSgeomTGeo::kNLayers][3];
1073 for(Int_t j=0;j<AliITSgeomTGeo::GetNLayers();j++){
1074 for(Int_t k=0;k<3;k++){
1075 labl[j][k]=-2;
1076 cnts[j][k]=1;
13918578 1077 }
13918578 1078 }
ee16fb28 1079 Int_t iNotLabel=0;
1080 for(Int_t i=0;i<track->GetNumberOfClusters(); i++) {
1081 Int_t indexc = track->GetClusterIndex(i);
1082 AliITSRecPoint* cl = (AliITSRecPoint*)GetCluster(indexc);
1083 Int_t iLayer=cl->GetLayer();
1084 for(Int_t k=0;k<3;k++){
1085 labl[iLayer][k]=cl->GetLabel(k);
1086 if(labl[iLayer][k]<0) iNotLabel++;
1087 }
1088 }
1089 if(iNotLabel==3*track->GetNumberOfClusters()) return -2;
1090
1091 for(Int_t j1=0;j1<AliITSgeomTGeo::kNLayers; j1++) {
1092 for(Int_t j2=0; j2<j1; j2++){
1093 for(Int_t k1=0; k1<3; k1++){
1094 for(Int_t k2=0; k2<3; k2++){
1095 if(labl[j1][k1]>=0 && labl[j1][k1]==labl[j2][k2] && cnts[j2][k2]>0){
1096 cnts[j2][k2]++;
1097 cnts[j1][k1]=0;
1098 }
1099 }
1100 }
13918578 1101 }
13918578 1102 }
13918578 1103
13918578 1104
ee16fb28 1105 Int_t cntMax=0;
1106 Int_t label=-1;
1107 for(Int_t j=0;j<AliITSgeomTGeo::kNLayers;j++){
1108 for(Int_t k=0;k<3;k++){
1109 if(cnts[j][k]>cntMax && labl[j][k]>=0){
1110 cntMax=cnts[j][k];
1111 label=labl[j][k];
1112 }
1113 }
13918578 1114 }
1115
ee16fb28 1116 Int_t lflag=0;
1117 for(Int_t i=0;i<AliITSgeomTGeo::kNLayers;i++)
1118 if(labl[i][0]==label || labl[i][1]==label || labl[i][2]==label) lflag++;
13918578 1119
ee16fb28 1120 if(lflag<track->GetNumberOfClusters()) label = -label;
1121 return label;
13918578 1122}
13918578 1123//_____________________________________________________________________________
5b4dedce 1124void AliITStrackerSA::SetCalculatedWindowSizes(Int_t n, Float_t phimin, Float_t phimax, Float_t lambdamin, Float_t lambdamax){
1125 // Set sizes of the phi and lambda windows used for track finding
1126 fNloop = n;
1127 if(fPhiWin) delete [] fPhiWin;
1128 if(fLambdaWin) delete [] fLambdaWin;
1129 fPhiWin = new Double_t[fNloop];
1130 fLambdaWin = new Double_t[fNloop];
1131 Float_t stepPhi=(phimax-phimin)/(Float_t)(fNloop-1);
1132 Float_t stepLambda=(lambdamax-lambdamin)/(Float_t)(fNloop-1);
1133 for(Int_t k=0;k<fNloop;k++){
1134 Float_t phi=phimin+k*stepPhi;
1135 Float_t lam=lambdamin+k*stepLambda;
1136 fPhiWin[k]=phi;
1137 fLambdaWin[k]=lam;
1138 }
1139}
1140//_____________________________________________________________________________
1141void AliITStrackerSA::SetFixedWindowSizes(Int_t n, Double_t *phi, Double_t *lam){
13918578 1142 // Set sizes of the phi and lambda windows used for track finding
1143 fNloop = n;
1144 if(phi){ // user defined values
1145 fPhiWin = new Double_t[fNloop];
1146 fLambdaWin = new Double_t[fNloop];
1147 for(Int_t k=0;k<fNloop;k++){
1148 fPhiWin[k]=phi[k];
1149 fLambdaWin[k]=lam[k];
1150 }
1151 }
1152 else { // default values
627b6db6 1153
1154 Double_t phid[33] = {0.002,0.003,0.004,0.0045,0.0047,
bef31448 1155 0.005,0.0053,0.0055,
1156 0.006,0.0063,0.0065,0.007,0.0073,0.0075,0.0077,
1157 0.008,0.0083,0.0085,0.0087,0.009,0.0095,0.0097,
627b6db6 1158 0.01,0.0105,0.011,0.0115,0.012,0.0125,0.013,0.0135,0.0140,0.0145};
1159 Double_t lambdad[33] = {0.003,0.004,0.005,0.005,0.005,
1160 0.005,0.005,0.006,
1161 0.006,0.006,0.006,0.007,0.007,0.007,0.007,
1162 0.007,0.007,0.007,0.007,0.007,0.007,0.007,
1163 0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008,0.008};
bef31448 1164
627b6db6 1165 if(fNloop!=33){
1166 fNloop = 33;
13918578 1167 }
627b6db6 1168
1169
13918578 1170 fPhiWin = new Double_t[fNloop];
1171 fLambdaWin = new Double_t[fNloop];
e340bb86 1172
e340bb86 1173 Double_t factor=AliITSReconstructor::GetRecoParam()->GetFactorSAWindowSizes(); // possibility to enlarge windows for cosmics reco with large misalignments (A.Dainese)
2755f080 1174
1175 for(Int_t k=0;k<fNloop;k++){
e340bb86 1176 fPhiWin[k]=phid[k]*factor;
1177 fLambdaWin[k]=lambdad[k]*factor;
13918578 1178 }
1179
1180 }
1181
1182}
7e5bf5af 1183//_______________________________________________________________________
cc088660 1184void AliITStrackerSA::GetCoorAngles(AliITSRecPoint* cl,Double_t &phi,Double_t &lambda, Float_t &x, Float_t &y,Float_t &z,Double_t* vertex){
7e5bf5af 1185 //Returns values of phi (azimuthal) and lambda angles for a given cluster
cc088660 1186/*
7e5bf5af 1187 Double_t rot[9]; fGeom->GetRotMatrix(module,rot);
1188 Int_t lay,lad,det; fGeom->GetModuleId(module,lay,lad,det);
1189 Float_t tx,ty,tz; fGeom->GetTrans(lay,lad,det,tx,ty,tz);
1190
1191 Double_t alpha=TMath::ATan2(rot[1],rot[0])+TMath::Pi();
1192 Double_t phi1=TMath::Pi()/2+alpha;
1193 if (lay==1) phi1+=TMath::Pi();
1194
1195 Float_t cp=TMath::Cos(phi1), sp=TMath::Sin(phi1);
1196 Float_t r=tx*cp+ty*sp;
1197
cc088660 1198 xyz= r*cp - cl->GetY()*sp;
7e5bf5af 1199 y= r*sp + cl->GetY()*cp;
1200 z=cl->GetZ();
cc088660 1201*/
1202 Float_t xyz[3];
1203 cl->GetGlobalXYZ(xyz);
1204 x=xyz[0];
1205 y=xyz[1];
1206 z=xyz[2];
1207
1966f03c 1208 phi=TMath::ATan2(y-vertex[1],x-vertex[0]);
7e5bf5af 1209 lambda=TMath::ATan2(z-vertex[2],TMath::Sqrt((x-vertex[0])*(x-vertex[0])+(y-vertex[1])*(y-vertex[1])));
1210}
13918578 1211
7e5bf5af 1212//________________________________________________________________________
cc088660 1213void AliITStrackerSA::GetCoorErrors(AliITSRecPoint* cl,Float_t &sx,Float_t &sy, Float_t &sz){
7e5bf5af 1214
cc088660 1215 //returns sigmax, y, z of cluster in global coordinates
1216/*
7e5bf5af 1217 Double_t rot[9]; fGeom->GetRotMatrix(module,rot);
cc088660 1218 Int_t lay,lad,det;
1219 AliITSgeomTGeo::GetModuleId(module,lay,lad,det);
7e5bf5af 1220
1221 Double_t alpha=TMath::ATan2(rot[1],rot[0])+TMath::Pi();
1222 Double_t phi=TMath::Pi()/2+alpha;
1223 if (lay==1) phi+=TMath::Pi();
1224
1225 Float_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
cc088660 1226*/
1227 Float_t covm[6];
1228 cl->GetGlobalCov(covm);
1229 sx=TMath::Sqrt(covm[0]);
1230 sy=TMath::Sqrt(covm[3]);
1231 sz=TMath::Sqrt(covm[5]);
1232/*
7e5bf5af 1233 sx = TMath::Sqrt(sp*sp*cl->GetSigmaY2());
1234 sy = TMath::Sqrt(cp*cp*cl->GetSigmaY2());
1235 sz = TMath::Sqrt(cl->GetSigmaZ2());
cc088660 1236*/
7e5bf5af 1237}
f2150e42 1238