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