]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TOF/AliTOFtrackerMI.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
added CheckActiveChannels.C macro used to check active channels as declared in TOF...
[u/mrichter/AliRoot.git] / TOF / AliTOFtrackerMI.cxx
CommitLineData
d88fbf15 1/**************************************************************************
2 * Copyright(c) 1998-1999, 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 **************************************************************************/
0e46b9ae 15
16//-----------------------------------------------------------------//
17// //
18// AliTOFtracker Class //
19// Task: Perform association of the ESD tracks to TOF Clusters //
20// and Update ESD track with associated TOF Cluster parameters //
21// //
22//-----------------------------------------------------------------//
d88fbf15 23
24#include <Rtypes.h>
0e46b9ae 25
d88fbf15 26#include "TClonesArray.h"
0e46b9ae 27#include "TTree.h"
d88fbf15 28#include "TTreeStream.h"
0e46b9ae 29
af885e0f 30#include "AliESDEvent.h"
0e46b9ae 31#include "AliESDtrack.h"
32
e0ddb533 33#include "AliTOFRecoParam.h"
3a646035 34#include "AliTOFReconstructor.h"
0e46b9ae 35#include "AliTOFcluster.h"
96f01799 36#include "AliTOFGeometry.h"
0e46b9ae 37#include "AliTOFtrackerMI.h"
38#include "AliTOFtrack.h"
5c7c93fa 39#include "AliTOFpidESD.h"
40
41class TGeoManager;
0e46b9ae 42
43extern TGeoManager *gGeoManager;
d88fbf15 44
45ClassImp(AliTOFtrackerMI)
46
47//_____________________________________________________________________________
e0ddb533 48AliTOFtrackerMI::AliTOFtrackerMI():
49 fRecoParam(0x0),
50 fGeom(0x0),
51 fPid(0x0),
58d8d9a3 52 fN(0),
53 fNseeds(0),
54 fNseedsTOF(0),
55 fngoodmatch(0),
56 fnbadmatch(0),
57 fnunmatch(0),
58 fnmatch(0),
8dacd1bb 59 fR(379.),
58d8d9a3 60 fTOFHeigth(15.3),
61 fdCut(3.),
62 fDx(1.5),
63 fDy(0),
64 fDz(0),
b42a5ea1 65 fTracks(new TClonesArray("AliTOFtrack")),
66 fSeeds(new TClonesArray("AliESDtrack")),
58d8d9a3 67 fDebugStreamer(0x0)
68 {
d88fbf15 69 //AliTOFtrackerMI main Ctor
70
96f01799 71 fDy=AliTOFGeometry::XPad();
72 fDz=AliTOFGeometry::ZPad();
e0ddb533 73 fDebugStreamer = new TTreeSRedirector("TOFdebug.root");
d88fbf15 74}
7aeeaf38 75
76//_____________________________________________________________________________
d88fbf15 77AliTOFtrackerMI::~AliTOFtrackerMI(){
78 //
79 //
80 //
81 if (fDebugStreamer) {
82 //fDebugStreamer->Close();
83 delete fDebugStreamer;
84 }
e0ddb533 85 delete fRecoParam;
86 delete fGeom;
87 delete fPid;
b42a5ea1 88 if (fTracks){
89 fTracks->Delete();
90 delete fTracks;
91 fTracks=0x0;
92 }
93 if (fSeeds){
94 fSeeds->Delete();
95 delete fSeeds;
96 fSeeds=0x0;
97 }
d88fbf15 98}
99
d88fbf15 100//_____________________________________________________________________________
af885e0f 101Int_t AliTOFtrackerMI::PropagateBack(AliESDEvent* event) {
d88fbf15 102 //
103 // Gets seeds from ESD event and Match with TOF Clusters
104 //
105
3a646035 106 // initialize RecoParam for current event
107
108 AliInfo("Initializing params for TOF... ");
109
110 fRecoParam = AliTOFReconstructor::GetRecoParam(); // instantiate reco param from STEER...
90b234fe 111
3a646035 112 if (fRecoParam == 0x0) {
113 AliFatal("No Reco Param found for TOF!!!");
114 }
115 //fRecoParam->Dump();
a825d829 116 //if(fRecoParam->GetApplyPbPbCuts())fRecoParam=fRecoParam->GetPbPbparam();
90b234fe 117 //fRecoParam->PrintParameters();
118
3a646035 119 Double_t parPID[2];
120 parPID[0]=fRecoParam->GetTimeResolution();
121 parPID[1]=fRecoParam->GetTimeNSigma();
122 fPid=new AliTOFpidESD(parPID);
d88fbf15 123
124 //Initialise some counters
125
126 fNseeds=0;
127 fNseedsTOF=0;
128 fngoodmatch=0;
129 fnbadmatch=0;
130 fnunmatch=0;
131 fnmatch=0;
132
133 Int_t ntrk=event->GetNumberOfTracks();
134 fNseeds = ntrk;
d88fbf15 135 TClonesArray &aESDTrack = *fSeeds;
136
137
138 //Load ESD tracks into a local Array of ESD Seeds
139
140 for (Int_t i=0; i<fNseeds; i++) {
141 AliESDtrack *t=event->GetTrack(i);
142 new(aESDTrack[i]) AliESDtrack(*t);
143 }
144
145 //Prepare ESD tracks candidates for TOF Matching
146 CollectESD();
147
148 //First Step with Strict Matching Criterion
149 //MatchTracks(kFALSE);
150
151 //Second Step with Looser Matching Criterion
152 //MatchTracks(kTRUE);
153 MatchTracksMI(kFALSE); // assign track to clusters
154 MatchTracksMI(kTRUE); // assign clusters to esd
155
156 Info("PropagateBack","Number of matched tracks: %d",fnmatch);
157 Info("PropagateBack","Number of good matched tracks: %d",fngoodmatch);
158 Info("PropagateBack","Number of bad matched tracks: %d",fnbadmatch);
159
160 //Update the matched ESD tracks
161
162 for (Int_t i=0; i<ntrk; i++) {
163 AliESDtrack *t=event->GetTrack(i);
164 AliESDtrack *seed =(AliESDtrack*)fSeeds->UncheckedAt(i);
2188ddfc 165
166 if ( (seed->GetStatus()&AliESDtrack::kTOFin)!=0 ) {
167 t->SetStatus(AliESDtrack::kTOFin);
168 //if(seed->GetTOFsignal()>0){
169 if ( (seed->GetStatus()&AliESDtrack::kTOFout)!=0 ) {
170 t->SetTOFsignal(seed->GetTOFsignal());
171 t->SetTOFcluster(seed->GetTOFcluster());
172 Int_t tlab[3];
173 seed->GetTOFLabel(tlab);
174 t->SetTOFLabel(tlab);
175 AliTOFtrack *track = new AliTOFtrack(*seed);
176 Float_t info[10];
177 Double_t times[10];
178 seed->GetTOFInfo(info);
179 seed->GetIntegratedTimes(times);
180 t->UpdateTrackParams(track,AliESDtrack::kTOFout);
181 t->SetIntegratedLength(seed->GetIntegratedLength());
182 t->SetIntegratedTimes(times);
183 t->SetTOFsignalToT(seed->GetTOFsignalToT());
184 t->SetTOFCalChannel(seed->GetTOFCalChannel());
185 //
186 t->SetTOFInfo(info);
187 delete track;
188 }
d88fbf15 189 }
190 }
191
192
193 //Make TOF PID
e0ddb533 194 fPid->MakePID(event);
d88fbf15 195
b42a5ea1 196 fSeeds->Clear();
197 fTracks->Clear();
d88fbf15 198 return 0;
199
200}
201//_________________________________________________________________________
202void AliTOFtrackerMI::CollectESD() {
203 //prepare the set of ESD tracks to be matched to clusters in TOF
204
d88fbf15 205 TClonesArray &aTOFTrack = *fTracks;
206 Int_t c0=0;
207 Int_t c1=0;
208 for (Int_t i=0; i<fNseeds; i++) {
209
210 AliESDtrack *t =(AliESDtrack*)fSeeds->UncheckedAt(i);
211 if ((t->GetStatus()&AliESDtrack::kTPCout)==0)continue;
212
d88fbf15 213 AliTOFtrack *track = new AliTOFtrack(*t); // New
2188ddfc 214 Float_t x = (Float_t)track->GetX(); //New
215
216 // TRD good tracks, already propagated at 371 cm
217 if ( ( (t->GetStatus()&AliESDtrack::kTRDout)!=0 ) &&
218 ( x >= AliTOFGeometry::Rmin() ) ) {
219 if ( track->PropagateToInnerTOF() ) {
220 track->SetSeedIndex(i);
221 t->UpdateTrackParams(track,AliESDtrack::kTOFin);
222 new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
223 fNseedsTOF++;
224 c0++;
225 delete track;
226 }
d88fbf15 227 }
228
2188ddfc 229 // Propagate the rest of TPCbp
d88fbf15 230 else {
2188ddfc 231 if ( track->PropagateToInnerTOF() ) { // temporary solution
d88fbf15 232 track->SetSeedIndex(i);
2188ddfc 233 t->UpdateTrackParams(track,AliESDtrack::kTOFin);
d88fbf15 234 new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
235 fNseedsTOF++;
236 c1++;
237 }
238 delete track;
239 }
240 }
241 //
242 //
243 printf("TRD\tOn\t%d\tOff\t%d\n",c0,c1);
244
245 // Sort according uncertainties on track position
246 fTracks->Sort();
247
248}
249
250
251
252
253
254
255
256//
257//
258//_________________________________________________________________________
259void AliTOFtrackerMI::MatchTracks( Bool_t /*mLastStep*/){
260 return;
261}
262//
263//
264//_________________________________________________________________________
265void AliTOFtrackerMI::MatchTracksMI(Bool_t mLastStep){
266
267 //Match ESD tracks to clusters in TOF
2bf66a2d 268 const Float_t kTofOffset = 26; // time offset
269 const Float_t kMinQuality = -6.; // minimal quality
270 const Float_t kMaxQualityD = 1.; // max delta quality if cluster used
271 const Float_t kForbiddenR = 0.1; // minimal PID according TPC
d88fbf15 272
273 static const Double_t kMasses[]={
274 0.000511, 0.105658, 0.139570, 0.493677, 0.938272, 1.875613
275 };
276
277 Int_t nSteps=(Int_t)(fTOFHeigth/0.1);
278
3a646035 279 //AliTOFcalib *calib = new AliTOFcalib(); // AdC
a533f541 280
d88fbf15 281 //PH Arrays (moved outside of the loop)
282 Float_t * trackPos[4];
283 for (Int_t ii=0; ii<4; ii++) trackPos[ii] = new Float_t[nSteps];
128563f6 284 Int_t * clind = new Int_t[fN];
d88fbf15 285
286 // Some init
287
288 Int_t index[1000];
3c609b5c 289 Float_t quality[1000];
d88fbf15 290 Float_t dist3D[1000][6];
291 Double_t times[1000][6];
292 Float_t mintimedist[1000];
293 Float_t likelihood[1000];
294 Float_t length[1000];
295 AliTOFcluster *clusters[1000];
3c609b5c 296 Double_t tpcpid[5];
d88fbf15 297 dist3D[0][0]=1;
298
299 for (Int_t i=0; i<fNseedsTOF; i++) {
300
301 AliTOFtrack *track =(AliTOFtrack*)fTracks->UncheckedAt(i);
302 AliESDtrack *t =(AliESDtrack*)fSeeds->UncheckedAt(track->GetSeedIndex());
303 Bool_t hasTime = ( (t->GetStatus()& AliESDtrack::kTIME)>0) ? kTRUE:kFALSE; // did we integrate time
304 Float_t trdquality = t->GetTRDQuality();
305 //
306 // Normalize tpc pid
307 //
308 t->GetTPCpid(tpcpid);
309 Double_t sumpid=0;
310 for (Int_t ipid=0;ipid<5;ipid++){
311 sumpid+=tpcpid[ipid];
312 }
313 for (Int_t ipid=0;ipid<5;ipid++){
314 if (sumpid>0) tpcpid[ipid]/=sumpid;
315 else{
316 tpcpid[ipid]=0.2;
317 }
318 }
319
320 if (trdquality<0) continue; // no chance
321 //
322 AliTOFtrack *trackTOFin =new AliTOFtrack(*track);
323 //
324 //propagat track to the middle of TOF
325 //
8dacd1bb 326 Float_t xs = 379.2; // should be defined in the TOF geometry
96f01799 327 Double_t ymax=xs*TMath::Tan(0.5*AliTOFGeometry::GetAlpha());
d3c7bfac 328 Bool_t skip=kFALSE;
d88fbf15 329 Double_t ysect=trackTOFin->GetYat(xs,skip);
330 if (skip){
8dacd1bb 331 xs = 373.;
96f01799 332 ymax=xs*TMath::Tan(0.5*AliTOFGeometry::GetAlpha());
d88fbf15 333 ysect=trackTOFin->GetYat(xs,skip);
334 }
335 if (ysect > ymax) {
96f01799 336 if (!trackTOFin->Rotate(AliTOFGeometry::GetAlpha())) {
d88fbf15 337 continue;
338 }
339 } else if (ysect <-ymax) {
96f01799 340 if (!trackTOFin->Rotate(-AliTOFGeometry::GetAlpha())) {
d88fbf15 341 continue;
342 }
343 }
344 if(!trackTOFin->PropagateTo(xs)) {
345 continue;
346 }
347 //
348 // Determine a window around the track
349 //
350 Double_t x,par[5];
351 trackTOFin->GetExternalParameters(x,par);
352 Double_t cov[15];
353 trackTOFin->GetExternalCovariance(cov);
354 Float_t scalefact=3.;
355 Double_t dphi=
356 scalefact*
2bf66a2d 357 ((5*TMath::Sqrt(cov[0]) + 3.*fDy + 10.*TMath::Abs(par[2]))/fR);
d88fbf15 358 Double_t dz=
359 scalefact*
2bf66a2d 360 (5*TMath::Sqrt(cov[2]) + 3.*fDz + 10.*TMath::Abs(par[3]));
d88fbf15 361
362 Double_t phi=TMath::ATan2(par[0],x) + trackTOFin->GetAlpha();
363 if (phi<-TMath::Pi())phi+=2*TMath::Pi();
364 if (phi>=TMath::Pi())phi-=2*TMath::Pi();
365 Double_t z=par[1];
366
367 Int_t nc =0;
368 Int_t nfound =0;
369 // find the clusters in the window of the track
370
371 for (Int_t k=FindClusterIndex(z-dz); k<fN; k++) {
372 AliTOFcluster *c=fClusters[k];
373 if (c->GetZ() > z+dz) break;
374 // if (c->IsUsed()) continue;
375
376 Double_t dph=TMath::Abs(c->GetPhi()-phi);
377 if (dph>TMath::Pi()) dph-=2.*TMath::Pi();
378 if (TMath::Abs(dph)>dphi) continue;
3c609b5c 379
128563f6 380 clind[nc] = k;
d88fbf15 381 nc++;
382 }
383
384 //
385 // select close clusters
386 //
387 Double_t mom=t->GetP();
388 // Bool_t dump = kTRUE;
389 for (Int_t icl=0; icl<nc; icl++){
390 Float_t distances[5];
391 if (nfound>=1000) break;
128563f6 392 index[nfound]=clind[icl];
393 AliTOFcluster *cluster = fClusters[clind[icl]];
2bf66a2d 394 GetLinearDistances(trackTOFin, cluster, distances);
d88fbf15 395 dist3D[nfound][0] = distances[4];
396 dist3D[nfound][1] = distances[1];
397 dist3D[nfound][2] = distances[2];
398 // cut on distance
399 if (TMath::Abs(dist3D[nfound][1])>20 || TMath::Abs(dist3D[nfound][2])>20) continue;
400 //
401 GetLikelihood(distances[1],distances[2],cov,trackTOFin, dist3D[nfound][3], dist3D[nfound][4]);
402 //
403 // cut on likelihood
404 if (dist3D[nfound][3]*dist3D[nfound][4]<0.00000000000001) continue; // log likelihood
405 if (TMath::Log(dist3D[nfound][3]*dist3D[nfound][4])<-9) continue; // log likelihood
406 //
407 clusters[nfound] = cluster;
408 //
2bf66a2d 409 //length and TOF updates
d88fbf15 410 trackTOFin->GetIntegratedTimes(times[nfound]);
411 length[nfound] = trackTOFin->GetIntegratedLength();
412 length[nfound]+=distances[4];
413 mintimedist[nfound]=1000;
96f01799 414 Double_t tof2=AliTOFGeometry::TdcBinWidth()*cluster->GetTDC()+kTofOffset; // in ps
d88fbf15 415 // Float_t tgamma = TMath::Sqrt(cluster->GetR()*cluster->GetR()+cluster->GetZ()*cluster->GetZ())/0.03; //time for "primary" gamma
416 //if (trackTOFin->GetPt()<0.7 && TMath::Abs(tgamma-tof2)<350) continue; // gamma conversion candidate - TEMPORARY
417 for(Int_t j=0;j<=5;j++){
418 Double_t mass=kMasses[j];
419 times[nfound][j]+=distances[4]/3e-2*TMath::Sqrt(mom*mom+mass*mass)/mom; // add time distance
420 if ( TMath::Abs(times[nfound][j]-tof2)<mintimedist[nfound] && tpcpid[j]>kForbiddenR){
421 mintimedist[nfound]=TMath::Abs(times[nfound][j]-tof2);
422 }
423 }
424 //
425 Float_t liketime = TMath::Exp(-mintimedist[nfound]/90.)+0.25*TMath::Exp(-mintimedist[nfound]/180.);
426 if (!hasTime) liketime=0.2;
427 likelihood[nfound] = TMath::Log(dist3D[nfound][3]*dist3D[nfound][4]*liketime);
428
429 if (TMath::Log(dist3D[nfound][3]*dist3D[nfound][4])<-1){
430 if (likelihood[nfound]<-9.) continue;
431 }
432 //
433 nfound++;
434 }
435 if (nfound == 0 ) {
436 fnunmatch++;
437 delete trackTOFin;
438 continue;
439 }
440 //
441 //choose the best cluster
442 //
3c609b5c 443 //Float_t quality[1000];
444 //Int_t index[1000];
445 for (Int_t kk=0; kk<1000; kk++) quality[kk]=0;
d88fbf15 446 //
447 AliTOFcluster * cgold=0;
448 Int_t igold =-1;
449 for (Int_t icl=0;icl<nfound;icl++){
450 quality[icl] = dist3D[icl][3]*dist3D[icl][4];
451 }
452 TMath::Sort(nfound,quality,index,kTRUE);
453 igold = index[0];
454 cgold = clusters[igold];
455 if (nfound>1 &&likelihood[index[1]]>likelihood[index[0]]){
456 if ( quality[index[0]]<quality[index[1]]+0.5){
457 igold = index[1];
458 cgold = clusters[igold];
459 }
460 }
461 //
462 //
463 Float_t qualityGold = TMath::Log(0.0000001+(quality[igold]*(0.1+TMath::Exp(-mintimedist[igold]/80.))*(0.2+trdquality)));
464 if (!mLastStep){
465 if (cgold->GetQuality()<qualityGold) cgold->SetQuality(qualityGold);
466 continue;
467 }
468 //
469 if (mLastStep){
470 //signed better cluster
471 if (cgold->GetQuality()>qualityGold+kMaxQualityD) continue;
472 if (2.*qualityGold-cgold->GetQuality()<kMinQuality) continue;
473 }
474
475 Int_t inonfake=-1;
476
477 for (Int_t icl=0;icl<nfound;icl++){
478 if (
479 (clusters[index[icl]]->GetLabel(0)==TMath::Abs(trackTOFin->GetLabel()))
480 ||
481 (clusters[index[icl]]->GetLabel(1)==TMath::Abs(trackTOFin->GetLabel()))
482 ||
483 (clusters[index[icl]]->GetLabel(2)==TMath::Abs(trackTOFin->GetLabel()))
484 ) {
485 inonfake = icl;
486 break;
487 }
488 }
489 fnmatch++;;
490 if (inonfake==0) fngoodmatch++;
491 else{
492 fnbadmatch++;
493 }
494
495 Int_t tlab[3];
496 tlab[0]=cgold->GetLabel(0);
497 tlab[1]=cgold->GetLabel(1);
498 tlab[2]=cgold->GetLabel(2);
499 // Double_t tof2=25.*cgold->GetTDC()-350; // in ps
96f01799 500 Double_t tof2=AliTOFGeometry::TdcBinWidth()*cgold->GetTDC()+kTofOffset; // in ps
d88fbf15 501 Float_t tgamma = TMath::Sqrt(cgold->GetR()*cgold->GetR()+cgold->GetZ()*cgold->GetZ())/0.03;
502 Float_t info[11]={dist3D[igold][0],dist3D[igold][1],dist3D[igold][2],dist3D[igold][3],dist3D[igold][4],mintimedist[igold],
503 -1,tgamma, qualityGold,cgold->GetQuality(),0};
504 // GetLinearDistances(trackTOFin,cgold,&info[6]);
505 if (inonfake>=0){
506 info[6] = inonfake;
507 // info[7] = mintimedist[index[inonfake]];
508 }
509 //
a533f541 510 // Store quantities to be used for TOF Calibration
7aeeaf38 511 Float_t tToT=cgold->GetToT(); // in ps
512 t->SetTOFsignalToT(tToT);
a533f541 513 Int_t ind[5];
514 ind[0]=cgold->GetDetInd(0);
515 ind[1]=cgold->GetDetInd(1);
516 ind[2]=cgold->GetDetInd(2);
517 ind[3]=cgold->GetDetInd(3);
518 ind[4]=cgold->GetDetInd(4);
96f01799 519 Int_t calindex = AliTOFGeometry::GetIndex(ind);
a533f541 520 t->SetTOFCalChannel(calindex);
521
d88fbf15 522 t->SetTOFInfo(info);
523 t->SetTOFsignal(tof2);
524 t->SetTOFcluster(cgold->GetIndex());
32ead898 525
526 AliDebug(2, Form("%7i %7i %10i %10i %10i %10i %7i",
527 i,
3a646035 528 fnmatch-1,
32ead898 529 TMath::Abs(trackTOFin->GetLabel()),
530 tlab[0], tlab[1], tlab[2],
531 igold)); // AdC
532
d88fbf15 533 AliTOFtrack *trackTOFout = new AliTOFtrack(*t);
8dacd1bb 534 trackTOFout->PropagateTo(379.);
77a9ea9a 535
536 // Fill the track residual histograms.
537 FillResiduals(trackTOFout,cgold,kFALSE);
538
d88fbf15 539 t->UpdateTrackParams(trackTOFout,AliESDtrack::kTOFout);
540 t->SetIntegratedLength(length[igold]);
541 t->SetIntegratedTimes(times[igold]);
542 t->SetTOFLabel(tlab);
543 //
544 delete trackTOFin;
545 delete trackTOFout;
546 //
547 }
548 //
549 //
550 //
551 for (Int_t ii=0; ii<4; ii++) delete [] trackPos[ii];
128563f6 552 delete [] clind;
3a646035 553 //delete calib; // AdC
d88fbf15 554}
d88fbf15 555//_________________________________________________________________________
128563f6 556
d88fbf15 557Int_t AliTOFtrackerMI::LoadClusters(TTree *cTree) {
558 //--------------------------------------------------------------------
559 //This function loads the TOF clusters
560 //--------------------------------------------------------------------
561
562 TBranch *branch=cTree->GetBranch("TOF");
563 if (!branch) {
564 AliError("can't get the branch with the TOF clusters !");
565 return 1;
566 }
567
b42a5ea1 568 static TClonesArray dummy("AliTOFcluster",10000);
569 dummy.Clear();
570 TClonesArray *clusters=&dummy;
d88fbf15 571 branch->SetAddress(&clusters);
572
573 cTree->GetEvent(0);
574 Int_t nc=clusters->GetEntriesFast();
575 AliInfo(Form("Number of clusters: %d",nc));
576
577 for (Int_t i=0; i<nc; i++) {
578 AliTOFcluster *c=(AliTOFcluster*)clusters->UncheckedAt(i);
d88fbf15 579
d88fbf15 580 fClusters[i]=new AliTOFcluster(*c); fN++;
581
582 //AliInfo(Form("%4i %4i %f %f %f %f %f %2i %1i %2i %1i %2i",i, fClusters[i]->GetIndex(),fClusters[i]->GetZ(),fClusters[i]->GetR(),fClusters[i]->GetPhi(), fClusters[i]->GetTDC(),fClusters[i]->GetADC(),fClusters[i]->GetDetInd(0),fClusters[i]->GetDetInd(1),fClusters[i]->GetDetInd(2),fClusters[i]->GetDetInd(3),fClusters[i]->GetDetInd(4)));
583 //AliInfo(Form("%i %f",i, fClusters[i]->GetZ()));
584 }
585
586 //AliInfo(Form("Number of clusters: %d",fN));
587
588 return 0;
589}
590//_________________________________________________________________________
591void AliTOFtrackerMI::UnloadClusters() {
592 //--------------------------------------------------------------------
593 //This function unloads TOF clusters
594 //--------------------------------------------------------------------
595 for (Int_t i=0; i<fN; i++) {
596 delete fClusters[i];
597 fClusters[i] = 0x0;
598 }
599 fN=0;
600}
601
602
603
604
605//_________________________________________________________________________
606Int_t AliTOFtrackerMI::InsertCluster(AliTOFcluster *c) {
607 //--------------------------------------------------------------------
608 //This function adds a cluster to the array of clusters sorted in Z
609 //--------------------------------------------------------------------
610 if (fN==kMaxCluster) {
0e46b9ae 611 AliError("Too many clusters !");
d88fbf15 612 return 1;
613 }
614
615 if (fN==0) {fClusters[fN++]=c; return 0;}
616 Int_t i=FindClusterIndex(c->GetZ());
617 memmove(fClusters+i+1 ,fClusters+i,(fN-i)*sizeof(AliTOFcluster*));
618 fClusters[i]=c; fN++;
619
620 return 0;
621}
622
623//_________________________________________________________________________
624Int_t AliTOFtrackerMI::FindClusterIndex(Double_t z) const {
625 //--------------------------------------------------------------------
626 // This function returns the index of the nearest cluster
627 //--------------------------------------------------------------------
628 if (fN==0) return 0;
629 if (z <= fClusters[0]->GetZ()) return 0;
630 if (z > fClusters[fN-1]->GetZ()) return fN;
631 Int_t b=0, e=fN-1, m=(b+e)/2;
632 for (; b<e; m=(b+e)/2) {
633 if (z > fClusters[m]->GetZ()) b=m+1;
634 else e=m;
635 }
636 return m;
637}
638
639
640
641Float_t AliTOFtrackerMI::GetLinearDistances(AliTOFtrack * track, AliTOFcluster *cluster, Float_t distances[5])
642{
643 //
644 // calclates distance between cluster and track
645 // use linear aproximation
646 //
647 const Float_t kRaddeg = 180/3.14159265358979312;
648 //
649 // Float_t tiltangle = fGeom->GetAngles(cluster->fdetIndex[1],cluster->fdetIndex[2])/kRaddeg; //tiltangle
650 Int_t cind[5];
651 cind[0]= cluster->GetDetInd(0);
652 cind[1]= cluster->GetDetInd(1);
653 cind[2]= cluster->GetDetInd(2);
654 cind[3]= cluster->GetDetInd(3);
655 cind[4]= cluster->GetDetInd(4);
96f01799 656 Float_t tiltangle = AliTOFGeometry::GetAngles(cluster->GetDetInd(1),cluster->GetDetInd(2))/kRaddeg; //tiltangle
d88fbf15 657
658 Float_t cpos[3]; //cluster position
659 Float_t cpos0[3]; //cluster position
660 // fGeom->GetPos(cluster->fdetIndex,cpos);
661 //fGeom->GetPos(cluster->fdetIndex,cpos0);
662 //
663 fGeom->GetPos(cind,cpos);
664 fGeom->GetPos(cind,cpos0);
665
666 Float_t phi = TMath::ATan2(cpos[1],cpos[0]);
667 if(phi<0) phi=2.*TMath::Pi()+phi;
668 // Get the local angle in the sector philoc
669 Float_t phiangle = (Int_t (phi*kRaddeg/20.) + 0.5)*20./kRaddeg;
670 //
671 Double_t v0[3];
672 Double_t dir[3];
6c94f330 673 track->GetXYZ(v0);
674 track->GetPxPyPz(dir);
d88fbf15 675 dir[0]/=track->GetP();
676 dir[1]/=track->GetP();
677 dir[2]/=track->GetP();
678 //
679 //
680 //rotate 0
681 Float_t sinphi = TMath::Sin(phiangle);
682 Float_t cosphi = TMath::Cos(phiangle);
683 Float_t sinth = TMath::Sin(tiltangle);
684 Float_t costh = TMath::Cos(tiltangle);
685 //
686 Float_t temp;
687 temp = cpos[0]*cosphi+cpos[1]*sinphi;
688 cpos[1] = -cpos[0]*sinphi+cpos[1]*cosphi;
689 cpos[0] = temp;
690 temp = v0[0]*cosphi+v0[1]*sinphi;
691 v0[1] = -v0[0]*sinphi+v0[1]*cosphi;
692 v0[0] = temp;
693 //
694 temp = cpos[0]*costh+cpos[2]*sinth;
695 cpos[2] = -cpos[0]*sinth+cpos[2]*costh;
696 cpos[0] = temp;
697 temp = v0[0]*costh+v0[2]*sinth;
698 v0[2] = -v0[0]*sinth+v0[2]*costh;
699 v0[0] = temp;
700 //
701 //
702 //rotate direction vector
703 //
704 temp = dir[0]*cosphi+dir[1]*sinphi;
705 dir[1] = -dir[0]*sinphi+dir[1]*cosphi;
706 dir[0] = temp;
707 //
708 temp = dir[0]*costh+dir[2]*sinth;
709 dir[2] = -dir[0]*sinth+dir[2]*costh;
710 dir[0] = temp;
711 //
712 Float_t v3[3];
713 Float_t k = (cpos[0]-v0[0])/dir[0];
714 v3[0] = v0[0]+k*dir[0];
715 v3[1] = v0[1]+k*dir[1];
716 v3[2] = v0[2]+k*dir[2];
717 //
718 distances[0] = v3[0]-cpos[0];
719 distances[1] = v3[1]-cpos[1];
720 distances[2] = v3[2]-cpos[2];
721 distances[3] = TMath::Sqrt( distances[0]*distances[0]+distances[1]*distances[1]+distances[2]*distances[2]); //distance
722 distances[4] = k; //length
723
724 //
725 // Debuging part of the matching
726 //
727 if (track->GetLabel()==cluster->GetLabel(0) ||track->GetLabel()==cluster->GetLabel(1) ){
728 TTreeSRedirector& cstream = *fDebugStreamer;
729 Float_t tdc = cluster->GetTDC();
730 cstream<<"Tracks"<<
731 "TOF.="<<track<<
732 "Cx="<<cpos0[0]<<
733 "Cy="<<cpos0[1]<<
734 "Cz="<<cpos0[2]<<
735 "Dist="<<k<<
736 "Dist0="<<distances[0]<<
737 "Dist1="<<distances[1]<<
738 "Dist2="<<distances[2]<<
739 "TDC="<<tdc<<
740 "\n";
741 }
742 return distances[3];
743}
744
745
746
747void AliTOFtrackerMI::GetLikelihood(Float_t dy, Float_t dz, const Double_t *cov, AliTOFtrack * /*track*/, Float_t & py, Float_t &pz)
748{
749 //
750 // get likelihood - track covariance taken
751 // 75 % of gauss with expected sigma
752 // 25 % of gauss with extended sigma
753
754 Double_t kMaxSigmaY = 0.6; // ~ 90% of TRD tracks
755 Double_t kMaxSigmaZ = 1.2; // ~ 90% of TRD tracks
756 Double_t kMeanSigmaY = 0.25; // mean TRD sigma
757 Double_t kMeanSigmaZ = 0.5; // mean TRD sigma
758
759
760 Float_t normwidth, normd, p0,p1;
761 Float_t sigmay = TMath::Max(TMath::Sqrt(cov[0]+kMeanSigmaY*kMeanSigmaY),kMaxSigmaY);
762 Float_t sigmaz = TMath::Max(TMath::Sqrt(cov[2]+kMeanSigmaZ*kMeanSigmaZ),kMaxSigmaZ);
763
764 py=0;
765 pz=0;
766 //
767 // py calculation - 75% admixture of original sigma - 25% tails
768 //
769 normwidth = fDy/sigmay;
770 normd = dy/sigmay;
771 p0 = 0.5*(1+TMath::Erf(normd-normwidth*0.5));
772 p1 = 0.5*(1+TMath::Erf(normd+normwidth*0.5));
773 py+= 0.75*(p1-p0);
774 //
775 normwidth = fDy/(3.*sigmay);
776 normd = dy/(3.*sigmay);
777 p0 = 0.5*(1+TMath::Erf(normd-normwidth*0.5));
778 p1 = 0.5*(1+TMath::Erf(normd+normwidth*0.5));
779 py+= 0.25*(p1-p0);
780 //
781 // pz calculation - 75% admixture of original sigma - 25% tails
782 //
783 normwidth = fDz/sigmaz;
784 normd = dz/sigmaz;
785 p0 = 0.5*(1+TMath::Erf(normd-normwidth*0.5));
786 p1 = 0.5*(1+TMath::Erf(normd+normwidth*0.5));
787 pz+= 0.75*(p1-p0);
788 //
789 normwidth = fDz/(3.*sigmaz);
790 normd = dz/(3.*sigmaz);
791 p0 = 0.5*(1+TMath::Erf(normd-normwidth*0.5));
792 p1 = 0.5*(1+TMath::Erf(normd+normwidth*0.5));
793 pz+= 0.25*(p1-p0);
794}
128563f6 795//_________________________________________________________________________
796
797void AliTOFtrackerMI::FillClusterArray(TObjArray* arr) const
798{
799 //
800 // Returns the TOF cluster array
801 //
802
803 if (fN==0)
804 arr = 0x0;
805 else
806 for (Int_t i=0; i<fN; ++i) arr->Add(fClusters[i]);
807
808}