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