]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - TOF/AliTOFtracker.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Changed scripts for new TrainSetup
[u/mrichter/AliRoot.git] / TOF / AliTOFtracker.cxx
... / ...
CommitLineData
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 **************************************************************************/
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// -- Authors : S. Arcelli, C. Zampolli (Bologna University and INFN) //
23// -- Contacts: Annalisa.De.Caro@cern.ch //
24// -- : Chiara.Zampolli@bo.infn.it //
25// -- : Silvia.Arcelli@bo.infn.it //
26// //
27//--------------------------------------------------------------------//
28
29#include <Rtypes.h>
30#include <TROOT.h>
31
32#include <TSeqCollection.h>
33#include <TClonesArray.h>
34#include <TObjArray.h>
35#include <TGeoManager.h>
36#include <TTree.h>
37#include <TFile.h>
38#include <TH2F.h>
39
40#include "AliGeomManager.h"
41#include "AliESDtrack.h"
42#include "AliESDEvent.h"
43#include "AliESDpid.h"
44#include "AliLog.h"
45#include "AliTrackPointArray.h"
46#include "AliCDBManager.h"
47
48//#include "AliTOFpidESD.h"
49#include "AliTOFRecoParam.h"
50#include "AliTOFReconstructor.h"
51#include "AliTOFcluster.h"
52#include "AliTOFGeometry.h"
53#include "AliTOFtracker.h"
54#include "AliTOFtrack.h"
55
56extern TGeoManager *gGeoManager;
57extern TROOT *gROOT;
58
59
60ClassImp(AliTOFtracker)
61
62//_____________________________________________________________________________
63AliTOFtracker::AliTOFtracker():
64 fkRecoParam(0x0),
65 fGeom(0x0),
66 fN(0),
67 fNseeds(0),
68 fNseedsTOF(0),
69 fngoodmatch(0),
70 fnbadmatch(0),
71 fnunmatch(0),
72 fnmatch(0),
73 fTracks(new TClonesArray("AliTOFtrack")),
74 fSeeds(new TObjArray(100)),
75 fTOFtrackPoints(new TObjArray(10)),
76 fHDigClusMap(0x0),
77 fHDigNClus(0x0),
78 fHDigClusTime(0x0),
79 fHDigClusToT(0x0),
80 fHRecNClus(0x0),
81 fHRecDist(0x0),
82 fHRecSigYVsP(0x0),
83 fHRecSigZVsP(0x0),
84 fHRecSigYVsPWin(0x0),
85 fHRecSigZVsPWin(0x0),
86 fCalTree(0x0),
87 fIch(-1),
88 fToT(-1.),
89 fTime(-1.),
90 fExpTimePi(-1.),
91 fExpTimeKa(-1.),
92 fExpTimePr(-1.)
93{
94 //AliTOFtracker main Ctor
95
96 for (Int_t ii=0; ii<kMaxCluster; ii++) fClusters[ii]=0x0;
97
98 // Getting the geometry
99 fGeom = new AliTOFGeometry();
100
101 InitCheckHists();
102
103}
104//_____________________________________________________________________________
105AliTOFtracker::~AliTOFtracker() {
106 //
107 // Dtor
108 //
109
110 SaveCheckHists();
111
112 if(!(AliCDBManager::Instance()->GetCacheFlag())){
113 delete fkRecoParam;
114 }
115 delete fGeom;
116 delete fHDigClusMap;
117 delete fHDigNClus;
118 delete fHDigClusTime;
119 delete fHDigClusToT;
120 delete fHRecNClus;
121 delete fHRecDist;
122 delete fHRecSigYVsP;
123 delete fHRecSigZVsP;
124 delete fHRecSigYVsPWin;
125 delete fHRecSigZVsPWin;
126 delete fCalTree;
127 if (fTracks){
128 fTracks->Delete();
129 delete fTracks;
130 fTracks=0x0;
131 }
132 if (fSeeds){
133 fSeeds->Delete();
134 delete fSeeds;
135 fSeeds=0x0;
136 }
137 if (fTOFtrackPoints){
138 fTOFtrackPoints->Delete();
139 delete fTOFtrackPoints;
140 fTOFtrackPoints=0x0;
141 }
142
143 for (Int_t ii=0; ii<kMaxCluster; ii++)
144 if (fClusters[ii]) fClusters[ii]->Delete();
145
146}
147//_____________________________________________________________________________
148void AliTOFtracker::GetPidSettings(AliESDpid *esdPID) {
149 //
150 // Sets TOF resolution from RecoParams
151 //
152 if (fkRecoParam)
153 esdPID->GetTOFResponse().SetTimeResolution(fkRecoParam->GetTimeResolution());
154 else
155 AliWarning("fkRecoParam not yet set; cannot set PID settings");
156}
157//_____________________________________________________________________________
158Int_t AliTOFtracker::PropagateBack(AliESDEvent * const event) {
159 //
160 // Gets seeds from ESD event and Match with TOF Clusters
161 //
162
163 // initialize RecoParam for current event
164 AliDebug(1,"Initializing params for TOF");
165
166 fkRecoParam = AliTOFReconstructor::GetRecoParam(); // instantiate reco param from STEER...
167
168 if (fkRecoParam == 0x0) {
169 AliFatal("No Reco Param found for TOF!!!");
170 }
171 //fkRecoParam->Dump();
172 //if(fkRecoParam->GetApplyPbPbCuts())fkRecoParam=fkRecoParam->GetPbPbparam();
173 //fkRecoParam->PrintParameters();
174
175 //Initialise some counters
176
177 fNseeds=0;
178 fNseedsTOF=0;
179 fngoodmatch=0;
180 fnbadmatch=0;
181 fnunmatch=0;
182 fnmatch=0;
183
184 Int_t ntrk=event->GetNumberOfTracks();
185 fNseeds = ntrk;
186
187
188 //Load ESD tracks into a local Array of ESD Seeds
189 for (Int_t i=0; i<fNseeds; i++)
190 fSeeds->AddLast(event->GetTrack(i));
191
192 //Prepare ESD tracks candidates for TOF Matching
193 CollectESD();
194
195 //First Step with Strict Matching Criterion
196 MatchTracks(kFALSE);
197
198 //Second Step with Looser Matching Criterion
199 MatchTracks(kTRUE);
200
201 AliInfo(Form("Number of matched tracks = %d (good = %d, bad = %d)",fnmatch,fngoodmatch,fnbadmatch));
202
203 //Update the matched ESD tracks
204
205 for (Int_t i=0; i<ntrk; i++) {
206 AliESDtrack *t=event->GetTrack(i);
207 AliESDtrack *seed =(AliESDtrack*)fSeeds->At(i);
208
209 if ( (seed->GetStatus()&AliESDtrack::kTOFin)!=0 ) {
210 t->SetStatus(AliESDtrack::kTOFin);
211 //if(seed->GetTOFsignal()>0){
212 if ( (seed->GetStatus()&AliESDtrack::kTOFout)!=0 ) {
213 t->SetStatus(AliESDtrack::kTOFout);
214 t->SetTOFsignal(seed->GetTOFsignal());
215 t->SetTOFcluster(seed->GetTOFcluster());
216 t->SetTOFsignalToT(seed->GetTOFsignalToT());
217 t->SetTOFsignalRaw(seed->GetTOFsignalRaw());
218 t->SetTOFsignalDz(seed->GetTOFsignalDz());
219 t->SetTOFsignalDx(seed->GetTOFsignalDx());
220 t->SetTOFDeltaBC(seed->GetTOFDeltaBC());
221 t->SetTOFL0L1(seed->GetTOFL0L1());
222 t->SetTOFCalChannel(seed->GetTOFCalChannel());
223 Int_t tlab[3]; seed->GetTOFLabel(tlab);
224 t->SetTOFLabel(tlab);
225
226 Double_t alphaA = (Double_t)t->GetAlpha();
227 Double_t xA = (Double_t)t->GetX();
228 Double_t yA = (Double_t)t->GetY();
229 Double_t zA = (Double_t)t->GetZ();
230 Double_t p1A = (Double_t)t->GetSnp();
231 Double_t p2A = (Double_t)t->GetTgl();
232 Double_t p3A = (Double_t)t->GetSigned1Pt();
233 const Double_t *covA = (Double_t*)t->GetCovariance();
234
235 // Make attention, please:
236 // AliESDtrack::fTOFInfo array does not be stored in the AliESDs.root file
237 // it is there only for a check during the reconstruction step.
238 Float_t info[10]; seed->GetTOFInfo(info);
239 t->SetTOFInfo(info);
240 AliDebug(3,Form(" distance=%f; residual in the pad reference frame: dX=%f, dZ=%f", info[0],info[1],info[2]));
241
242 // Check done:
243 // by calling the AliESDtrack::UpdateTrackParams,
244 // the current track parameters are changed
245 // and it could cause refit problems.
246 // We need to update only the following track parameters:
247 // the track length and expected times.
248 // Removed AliESDtrack::UpdateTrackParams call
249 // Called AliESDtrack::SetIntegratedTimes(...) and
250 // AliESDtrack::SetIntegratedLength() routines.
251 /*
252 AliTOFtrack *track = new AliTOFtrack(*seed);
253 t->UpdateTrackParams(track,AliESDtrack::kTOFout); // to be checked - AdC
254 delete track;
255 Double_t time[10]; t->GetIntegratedTimes(time);
256 */
257
258 Double_t time[10]; seed->GetIntegratedTimes(time);
259 t->SetIntegratedTimes(time);
260
261 Double_t length = seed->GetIntegratedLength();
262 t->SetIntegratedLength(length);
263
264 Double_t alphaB = (Double_t)t->GetAlpha();
265 Double_t xB = (Double_t)t->GetX();
266 Double_t yB = (Double_t)t->GetY();
267 Double_t zB = (Double_t)t->GetZ();
268 Double_t p1B = (Double_t)t->GetSnp();
269 Double_t p2B = (Double_t)t->GetTgl();
270 Double_t p3B = (Double_t)t->GetSigned1Pt();
271 const Double_t *covB = (Double_t*)t->GetCovariance();
272 AliDebug(2,"Track params -now(before)-:");
273 AliDebug(2,Form(" X: %f(%f), Y: %f(%f), Z: %f(%f) --- alpha: %f(%f)",
274 xB,xA,
275 yB,yA,
276 zB,zA,
277 alphaB,alphaA));
278 AliDebug(2,Form(" p1: %f(%f), p2: %f(%f), p3: %f(%f)",
279 p1B,p1A,
280 p2B,p2A,
281 p3B,p3A));
282 AliDebug(2,Form(" cov1: %f(%f), cov2: %f(%f), cov3: %f(%f)"
283 " cov4: %f(%f), cov5: %f(%f), cov6: %f(%f)"
284 " cov7: %f(%f), cov8: %f(%f), cov9: %f(%f)"
285 " cov10: %f(%f), cov11: %f(%f), cov12: %f(%f)"
286 " cov13: %f(%f), cov14: %f(%f), cov15: %f(%f)",
287 covB[0],covA[0],
288 covB[1],covA[1],
289 covB[2],covA[2],
290 covB[3],covA[3],
291 covB[4],covA[4],
292 covB[5],covA[5],
293 covB[6],covA[6],
294 covB[7],covA[7],
295 covB[8],covA[8],
296 covB[9],covA[9],
297 covB[10],covA[10],
298 covB[11],covA[11],
299 covB[12],covA[12],
300 covB[13],covA[13],
301 covB[14],covA[14]
302 ));
303 AliDebug(3,Form(" TOF params: %6d %f %f %f %f %f %6d %3d %f %f %f %f %f %f",
304 i,
305 t->GetTOFsignalRaw(),
306 t->GetTOFsignal(),
307 t->GetTOFsignalToT(),
308 t->GetTOFsignalDz(),
309 t->GetTOFsignalDx(),
310 t->GetTOFCalChannel(),
311 t->GetTOFcluster(),
312 t->GetIntegratedLength(),
313 time[0], time[1], time[2], time[3], time[4]
314 )
315 );
316 }
317 }
318 }
319
320 //Make TOF PID
321 // Now done in AliESDpid
322 // fPid->MakePID(event,timeZero);
323
324 fSeeds->Clear();
325 //fTracks->Delete();
326 fTracks->Clear();
327 return 0;
328
329}
330//_________________________________________________________________________
331void AliTOFtracker::CollectESD() {
332 //prepare the set of ESD tracks to be matched to clusters in TOF
333
334 Int_t seedsTOF1=0;
335 Int_t seedsTOF3=0;
336 Int_t seedsTOF2=0;
337
338 TClonesArray &aTOFTrack = *fTracks;
339 for (Int_t i=0; i<fNseeds; i++) {
340
341 AliESDtrack *t =(AliESDtrack*)fSeeds->At(i);
342 if ((t->GetStatus()&AliESDtrack::kTPCout)==0)continue;
343
344 AliTOFtrack *track = new AliTOFtrack(*t); // New
345 Float_t x = (Float_t)track->GetX(); //New
346
347 // TRD 'good' tracks
348 if ( ( (t->GetStatus()&AliESDtrack::kTRDout)!=0 ) ) {
349
350 AliDebug(1,Form(" Before propagation till inner TOF radius, ESDtrackLength=%f, TOFtrackLength=%f",t->GetIntegratedLength(),track->GetIntegratedLength()));
351
352 // TRD 'good' tracks, already propagated at 371 cm
353 if( x >= AliTOFGeometry::Rmin() ) {
354
355 if ( track->PropagateToInnerTOF() ) {
356
357 AliDebug(1,Form(" TRD propagated track till rho = %fcm."
358 " And then the track has been propagated till rho = %fcm.",
359 x, (Float_t)track->GetX()));
360
361 track->SetSeedIndex(i);
362 t->UpdateTrackParams(track,AliESDtrack::kTOFin);
363 new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
364 fNseedsTOF++;
365 seedsTOF1++;
366
367 AliDebug(1,Form(" After propagation till inner TOF radius, ESDtrackLength=%f, TOFtrackLength=%f",t->GetIntegratedLength(),track->GetIntegratedLength()));
368 }
369 delete track;
370
371 }
372 else { // TRD 'good' tracks, propagated rho<371cm
373
374 if ( track->PropagateToInnerTOF() ) {
375
376 AliDebug(1,Form(" TRD propagated track till rho = %fcm."
377 " And then the track has been propagated till rho = %fcm.",
378 x, (Float_t)track->GetX()));
379
380 track->SetSeedIndex(i);
381 t->UpdateTrackParams(track,AliESDtrack::kTOFin);
382 new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
383 fNseedsTOF++;
384 seedsTOF3++;
385
386 AliDebug(1,Form(" After propagation till inner TOF radius, ESDtrackLength=%f, TOFtrackLength=%f",t->GetIntegratedLength(),track->GetIntegratedLength()));
387 }
388 delete track;
389
390 }
391 //delete track;
392 }
393
394 else { // Propagate the rest of TPCbp
395
396 AliDebug(1,Form(" Before propagation till inner TOF radius, ESDtrackLength=%f, TOFtrackLength=%f",t->GetIntegratedLength(),track->GetIntegratedLength()));
397
398 if ( track->PropagateToInnerTOF() ) {
399
400 AliDebug(1,Form(" TPC propagated track till rho = %fcm."
401 " And then the track has been propagated till rho = %fcm.",
402 x, (Float_t)track->GetX()));
403
404 track->SetSeedIndex(i);
405 t->UpdateTrackParams(track,AliESDtrack::kTOFin);
406 new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
407 fNseedsTOF++;
408 seedsTOF2++;
409
410 AliDebug(1,Form(" After propagation till inner TOF radius, ESDtrackLength=%f, TOFtrackLength=%f",t->GetIntegratedLength(),track->GetIntegratedLength()));
411 }
412 delete track;
413 }
414 }
415
416 AliInfo(Form("Number of TOF seeds = %d (kTRDout371 = %d, kTRDoutLess371 = %d, !kTRDout = %d)",fNseedsTOF,seedsTOF1,seedsTOF3,seedsTOF2));
417
418 // Sort according uncertainties on track position
419 fTracks->Sort();
420
421}
422
423//_________________________________________________________________________
424void AliTOFtracker::MatchTracks( Bool_t mLastStep){
425
426 // Parameters used/regulating the reconstruction
427
428 //static Float_t corrLen=0.;//0.75;
429 static Float_t detDepth=18.;
430 static Float_t padDepth=0.5;
431
432 const Float_t kSpeedOfLight= 2.99792458e-2; // speed of light [cm/ps]
433 const Float_t kTimeOffset = 0.; // time offset for tracking algorithm [ps]
434
435 Float_t dY=AliTOFGeometry::XPad();
436 Float_t dZ=AliTOFGeometry::ZPad();
437
438 Float_t sensRadius = fkRecoParam->GetSensRadius();
439 Float_t stepSize = fkRecoParam->GetStepSize();
440 Float_t scaleFact = fkRecoParam->GetWindowScaleFact();
441 Float_t dyMax=fkRecoParam->GetWindowSizeMaxY();
442 Float_t dzMax=fkRecoParam->GetWindowSizeMaxZ();
443 Float_t dCut=fkRecoParam->GetDistanceCut();
444 if (dCut==3. && fNseedsTOF<=10) {
445 dCut=10.;
446 AliInfo(Form("Matching window=%f, since low multiplicity event (fNseedsTOF=%d)",
447 dCut, fNseedsTOF));
448 }
449 Double_t maxChi2=fkRecoParam->GetMaxChi2TRD();
450 Bool_t timeWalkCorr = fkRecoParam->GetTimeWalkCorr();
451 if(!mLastStep){
452 AliDebug(1,"++++++++++++++TOF Reconstruction Parameters:++++++++++++ \n");
453 AliDebug(1,Form("TOF sens radius: %f",sensRadius));
454 AliDebug(1,Form("TOF step size: %f",stepSize));
455 AliDebug(1,Form("TOF Window scale factor: %f",scaleFact));
456 AliDebug(1,Form("TOF Window max dy: %f",dyMax));
457 AliDebug(1,Form("TOF Window max dz: %f",dzMax));
458 AliDebug(1,Form("TOF distance Cut: %f",dCut));
459 AliDebug(1,Form("TOF Max Chi2: %f",maxChi2));
460 AliDebug(1,Form("Time Walk Correction? : %d",timeWalkCorr));
461 }
462
463 //Match ESD tracks to clusters in TOF
464
465 // Get the number of propagation steps
466 Int_t nSteps=(Int_t)(detDepth/stepSize);
467 AliDebug(1,Form(" Number of steps to be done %d",nSteps));
468
469 //PH Arrays (moved outside of the loop)
470 Float_t * trackPos[4];
471 for (Int_t ii=0; ii<4; ii++) trackPos[ii] = new Float_t[nSteps];
472 Int_t * clind = new Int_t[fN];
473
474 // Some init
475 const Int_t kNclusterMax = 1000; // related to fN value
476 TGeoHMatrix global[kNclusterMax];
477
478 //The matching loop
479 for (Int_t iseed=0; iseed<fNseedsTOF; iseed++) {
480
481 fTOFtrackPoints->Delete();
482
483 for (Int_t ii=0; ii<kNclusterMax; ii++)
484 global[ii] = 0x0;
485 AliTOFtrack *track =(AliTOFtrack*)fTracks->UncheckedAt(iseed);
486 AliESDtrack *t =(AliESDtrack*)fSeeds->At(track->GetSeedIndex());
487 //if ( t->GetTOFsignal()>0. ) continue;
488 if ( (t->GetStatus()&AliESDtrack::kTOFout)!=0 ) continue;
489 AliTOFtrack *trackTOFin = new AliTOFtrack(*track);
490
491 // Determine a window around the track
492 Double_t x,par[5];
493 trackTOFin->GetExternalParameters(x,par);
494 Double_t cov[15];
495 trackTOFin->GetExternalCovariance(cov);
496
497 if (cov[0]<0. || cov[2]<0.) {
498 AliWarning(Form("Very strange track (%d)! At least one of its covariance matrix diagonal elements is negative!",iseed));
499 //delete trackTOFin;
500 //continue;
501 }
502
503 Double_t dphi=
504 scaleFact*
505 ((5*TMath::Sqrt(TMath::Abs(cov[0])) + 0.5*dY + 2.5*TMath::Abs(par[2]))/sensRadius);
506 Double_t dz=
507 scaleFact*
508 (5*TMath::Sqrt(TMath::Abs(cov[2])) + 0.5*dZ + 2.5*TMath::Abs(par[3]));
509
510 Double_t phi=TMath::ATan2(par[0],x) + trackTOFin->GetAlpha();
511 if (phi<-TMath::Pi())phi+=2*TMath::Pi();
512 if (phi>=TMath::Pi())phi-=2*TMath::Pi();
513 Double_t z=par[1];
514
515 //upper limit on window's size.
516 if (dz> dzMax) dz=dzMax;
517 if (dphi*sensRadius> dyMax) dphi=dyMax/sensRadius;
518
519
520 // find the clusters in the window of the track
521 Int_t nc=0;
522 for (Int_t k=FindClusterIndex(z-dz); k<fN; k++) {
523
524 if (nc>=kNclusterMax) {
525 AliWarning("No more matchable clusters can be stored! Please, increase the corresponding vectors size.");
526 break;
527 }
528
529 AliTOFcluster *c=fClusters[k];
530 if (c->GetZ() > z+dz) break;
531 if (c->IsUsed()) continue;
532 if (!c->GetStatus()) {
533 AliDebug(1,"Cluster in channel declared bad!");
534 continue; // skip bad channels as declared in OCDB
535 }
536
537 Double_t dph=TMath::Abs(c->GetPhi()-phi);
538 if (dph>TMath::Pi()) dph-=2.*TMath::Pi();
539 if (TMath::Abs(dph)>dphi) continue;
540
541 Double_t yc=(c->GetPhi() - trackTOFin->GetAlpha())*c->GetR();
542 Double_t p[2]={yc, c->GetZ()};
543 Double_t cov2[3]= {dY*dY/12., 0., dZ*dZ/12.};
544 if (trackTOFin->AliExternalTrackParam::GetPredictedChi2(p,cov2) > maxChi2)continue;
545
546 clind[nc] = k;
547 Char_t path[200];
548 Int_t ind[5];
549 ind[0]=c->GetDetInd(0);
550 ind[1]=c->GetDetInd(1);
551 ind[2]=c->GetDetInd(2);
552 ind[3]=c->GetDetInd(3);
553 ind[4]=c->GetDetInd(4);
554 fGeom->GetVolumePath(ind,path);
555 gGeoManager->cd(path);
556 global[nc] = *gGeoManager->GetCurrentMatrix();
557 nc++;
558 }
559
560 AliDebug(1,Form(" Number of matchable TOF clusters for the track number %d: %d",iseed,nc));
561
562 if (nc == 0 ) {
563 fnunmatch++;
564 delete trackTOFin;
565 continue;
566 }
567
568 //start fine propagation
569
570 Int_t nStepsDone = 0;
571 for( Int_t istep=0; istep<nSteps; istep++){
572
573 // First of all, propagate the track...
574 Float_t xs = AliTOFGeometry::RinTOF()+istep*stepSize;
575 if (!(trackTOFin->PropagateTo(xs))) break;
576
577 // ...and then, if necessary, rotate the track
578 Double_t ymax = xs*TMath::Tan(0.5*AliTOFGeometry::GetAlpha());
579 Double_t ysect = trackTOFin->GetY();
580 if (ysect > ymax) {
581 if (!(trackTOFin->Rotate(AliTOFGeometry::GetAlpha()))) break;
582 } else if (ysect <-ymax) {
583 if (!(trackTOFin->Rotate(-AliTOFGeometry::GetAlpha()))) break;
584 }
585
586 nStepsDone++;
587 AliDebug(2,Form(" current step %d (%d) - nStepsDone=%d",istep,nSteps,nStepsDone));
588
589 // store the running point (Globalrf) - fine propagation
590
591 Double_t r[3];
592 trackTOFin->GetXYZ(r);
593 trackPos[0][nStepsDone-1]= (Float_t) r[0];
594 trackPos[1][nStepsDone-1]= (Float_t) r[1];
595 trackPos[2][nStepsDone-1]= (Float_t) r[2];
596 trackPos[3][nStepsDone-1]= trackTOFin->GetIntegratedLength();
597 }
598
599
600#if 0
601 /*****************/
602 /**** OLD CODE ***/
603 /*****************/
604
605 Int_t nfound = 0;
606 Bool_t accept = kFALSE;
607 Bool_t isInside = kFALSE;
608 for (Int_t istep=0; istep<nStepsDone; istep++) {
609
610 Float_t ctrackPos[3];
611 ctrackPos[0] = trackPos[0][istep];
612 ctrackPos[1] = trackPos[1][istep];
613 ctrackPos[2] = trackPos[2][istep];
614
615 //now see whether the track matches any of the TOF clusters
616
617 Float_t dist3d[3];
618 accept = kFALSE;
619 for (Int_t i=0; i<nc; i++) {
620 isInside = fGeom->IsInsideThePad((TGeoHMatrix*)(&global[i]),ctrackPos,dist3d);
621
622 if ( mLastStep ) {
623 Float_t yLoc = dist3d[1];
624 Float_t rLoc = TMath::Sqrt(dist3d[0]*dist3d[0]+dist3d[2]*dist3d[2]);
625 accept = (TMath::Abs(yLoc)<padDepth*0.5 && rLoc<dCut);
626 AliDebug(2," I am in the case mLastStep==kTRUE ");
627 }
628 else {
629 accept = isInside;
630 }
631 if (accept) {
632
633 fTOFtrackPoints->AddLast(new AliTOFtrackPoint(clind[i],
634 TMath::Sqrt(dist3d[0]*dist3d[0] + dist3d[1]*dist3d[1] + dist3d[2]*dist3d[2]),
635 dist3d[2],dist3d[0],dist3d[1],
636 AliTOFGeometry::RinTOF()+istep*stepSize,trackPos[3][istep]));
637
638 AliDebug(2,Form(" dist3dLoc[0] = %f, dist3dLoc[1] = %f, dist3dLoc[2] = %f ",dist3d[0],dist3d[1],dist3d[2]));
639 nfound++;
640 if(accept &&!mLastStep)break;
641 }//end if accept
642
643 } //end for on the clusters
644 if(accept &&!mLastStep)break;
645 } //end for on the steps
646
647 /*****************/
648 /**** OLD CODE ***/
649 /*****************/
650#endif
651
652 AliDebug(1,Form(" Number of steps done for the track number %d: %d",iseed,nStepsDone));
653
654 if ( nStepsDone == 0 ) {
655 fnunmatch++;
656 delete trackTOFin;
657 continue;
658 }
659
660 /*****************/
661 /**** NEW CODE ***/
662 /*****************/
663
664 Int_t nfound = 0;
665 Bool_t accept = kFALSE;
666 Bool_t isInside = kFALSE;
667 for (Int_t istep=0; istep<nStepsDone; istep++) {
668
669 Bool_t gotInsideCluster = kFALSE;
670 Int_t trackInsideCluster = -1;
671
672 Float_t ctrackPos[3];
673 ctrackPos[0] = trackPos[0][istep];
674 ctrackPos[1] = trackPos[1][istep];
675 ctrackPos[2] = trackPos[2][istep];
676
677 //now see whether the track matches any of the TOF clusters
678
679 Float_t dist3d[3]={0.,0.,0.};
680 accept = kFALSE;
681 for (Int_t i=0; i<nc; i++) {
682
683 // ***** NEW *****
684 /* check whether track was inside another cluster
685 * and in case inhibit this cluster.
686 * this will allow to only go on and add track points for
687 * that cluster where the track got inside first */
688 if (gotInsideCluster && trackInsideCluster != i) {
689 AliDebug(2,Form(" A - istep=%d ~ %d %d ~ nfound=%d",istep,trackInsideCluster,i,nfound));
690 continue;
691 }
692 AliDebug(2,Form(" B - istep=%d ~ %d %d ~ nfound=%d",istep,trackInsideCluster,i,nfound));
693
694 /* check whether track is inside this cluster */
695 for (Int_t hh=0; hh<3; hh++) dist3d[hh]=0.;
696 isInside = fGeom->IsInsideThePad((TGeoHMatrix*)(&global[i]),ctrackPos,dist3d);
697
698 // ***** NEW *****
699 /* if track is inside this cluster set flags which will then
700 * inhibit to add track points for the other clusters */
701 if (isInside) {
702 gotInsideCluster = kTRUE;
703 trackInsideCluster = i;
704 }
705
706 if ( mLastStep ) {
707 Float_t yLoc = dist3d[1];
708 Float_t rLoc = TMath::Sqrt(dist3d[0]*dist3d[0]+dist3d[2]*dist3d[2]);
709 accept = (TMath::Abs(yLoc)<padDepth*0.5 && rLoc<dCut);
710 AliDebug(2," I am in the case mLastStep==kTRUE ");
711 }
712
713 //***** NEW *****
714 /* add point everytime that:
715 * - the track is inside the cluster
716 * - the track got inside the cluster, even when it eventually exited the cluster
717 * - the tracks is within dCut from the cluster
718 */
719 if (accept || isInside || gotInsideCluster) {
720
721 fTOFtrackPoints->AddLast(new AliTOFtrackPoint(clind[i],
722 TMath::Sqrt(dist3d[0]*dist3d[0] + dist3d[1]*dist3d[1] + dist3d[2]*dist3d[2]),
723 dist3d[2],dist3d[0],dist3d[1],
724 AliTOFGeometry::RinTOF()+istep*stepSize,trackPos[3][istep]));
725
726 AliDebug(2,Form(" dist3dLoc[0] = %f, dist3dLoc[1] = %f, dist3dLoc[2] = %f ",dist3d[0],dist3d[1],dist3d[2]));
727 nfound++;
728
729 AliDebug(2,Form(" C - istep=%d ~ %d %d ~ nfound=%d",istep,trackInsideCluster,i,nfound));
730
731 // ***** NEW *****
732 /* do not break loop in any case
733 * if the track got inside a cluster all other clusters
734 * are inhibited */
735 // if(accept &&!mLastStep)break;
736
737 }//end if accept
738
739 } //end for on the clusters
740
741 // ***** NEW *****
742 /* do not break loop in any case
743 * if the track got inside a cluster all other clusters
744 * are inhibited but we want to go on adding track points */
745 // if(accept &&!mLastStep)break;
746
747 } //end for on the steps
748
749
750 AliDebug(1,Form(" Number of track points for the track number %d: %d",iseed,nfound));
751
752 if (nfound == 0 ) {
753 fnunmatch++;
754 delete trackTOFin;
755 continue;
756 }
757
758 // now choose the cluster to be matched with the track.
759
760 Int_t idclus=-1;
761 Float_t recL = 0.;
762 Float_t xpos=0.;
763 Float_t mindist=1000.;
764 Float_t mindistZ=0.;
765 Float_t mindistY=0.;
766 Float_t mindistX=stepSize;
767 for (Int_t iclus= 0; iclus<nfound;iclus++) {
768 AliTOFtrackPoint *matchableTOFcluster = (AliTOFtrackPoint*)fTOFtrackPoints->At(iclus);
769 //if ( matchableTOFcluster->Distance()<mindist ) {
770 if ( TMath::Abs(matchableTOFcluster->DistanceX())<TMath::Abs(mindistX) &&
771 TMath::Abs(matchableTOFcluster->DistanceX())<=stepSize ) {
772 mindist = matchableTOFcluster->Distance();
773 mindistZ = matchableTOFcluster->DistanceZ(); // Z distance in the
774 // RF of the hit pad
775 // closest to the
776 // reconstructed
777 // track
778 mindistY = matchableTOFcluster->DistanceY(); // Y distance in the
779 // RF of the hit pad
780 // closest to the
781 // reconstructed
782 // track
783 mindistX = matchableTOFcluster->DistanceX(); // X distance in the
784 // RF of the hit pad
785 // closest to the
786 // reconstructed
787 // track
788 xpos = matchableTOFcluster->PropRadius();
789 idclus = matchableTOFcluster->Index();
790 recL = matchableTOFcluster->Length();// + corrLen*0.5;
791
792 AliDebug(1,Form(" %d(%d) --- %f (%f, %f, %f), step=%f -- idclus=%d --- seed=%d, trackId=%d, trackLab=%d", iclus,nfound,
793 mindist,mindistX,mindistY,mindistZ,stepSize,idclus,iseed,track->GetSeedIndex(),track->GetLabel()));
794
795 }
796 } // loop on found TOF track points
797
798 if (TMath::Abs(mindistX)>stepSize && idclus!=-1) {
799 AliInfo(Form("--------Not matched --- but idclus=%d, trackId=%d, trackLab=%d",
800 idclus,track->GetSeedIndex(),track->GetLabel()));
801 idclus=-1;
802 }
803
804 if (idclus==-1) {
805 AliDebug(1,Form("Reconstructed track %d doesn't match any TOF cluster", iseed));
806 fnunmatch++;
807 delete trackTOFin;
808 continue;
809 }
810
811 AliDebug(1,"--------Matched");
812
813 fnmatch++;
814
815 AliTOFcluster *c=fClusters[idclus];
816
817 AliDebug(2, Form("%7d %7d %10d %10d %10d %10d %7d",
818 iseed,
819 fnmatch-1,
820 TMath::Abs(trackTOFin->GetLabel()),
821 c->GetLabel(0), c->GetLabel(1), c->GetLabel(2),
822 idclus)); // AdC
823
824 c->Use();
825
826 // Track length correction for matching Step 2
827 /*
828 if (mLastStep) {
829 Float_t rc = TMath::Sqrt(c->GetR()*c->GetR() + c->GetZ()*c->GetZ());
830 Float_t rt = TMath::Sqrt(trackPos[0][70]*trackPos[0][70]
831 +trackPos[1][70]*trackPos[1][70]
832 +trackPos[2][70]*trackPos[2][70]);
833 Float_t dlt=rc-rt;
834 recL=trackPos[3][70]+dlt;
835 }
836 */
837 if (
838 (c->GetLabel(0)==TMath::Abs(trackTOFin->GetLabel()))
839 ||
840 (c->GetLabel(1)==TMath::Abs(trackTOFin->GetLabel()))
841 ||
842 (c->GetLabel(2)==TMath::Abs(trackTOFin->GetLabel()))
843 ) {
844 fngoodmatch++;
845
846 AliDebug(2,Form(" track label good %5d",trackTOFin->GetLabel()));
847
848 }
849 else {
850 fnbadmatch++;
851
852 AliDebug(2,Form(" track label bad %5d",trackTOFin->GetLabel()));
853
854 }
855
856 delete trackTOFin;
857
858 // Store quantities to be used in the TOF Calibration
859 Float_t tToT=AliTOFGeometry::ToTBinWidth()*c->GetToT()*1E-3; // in ns
860 t->SetTOFsignalToT(tToT);
861 Float_t rawTime=AliTOFGeometry::TdcBinWidth()*c->GetTDCRAW()+kTimeOffset; // RAW time,in ps
862 t->SetTOFsignalRaw(rawTime);
863 t->SetTOFsignalDz(mindistZ);
864 t->SetTOFsignalDx(mindistY);
865 t->SetTOFDeltaBC(c->GetDeltaBC());
866 t->SetTOFL0L1(c->GetL0L1Latency());
867
868 Float_t info[10] = {mindist,mindistY,mindistZ,
869 0.,0.,0.,0.,0.,0.,0.};
870 t->SetTOFInfo(info);
871 AliDebug(2,Form(" distance=%f; residual in the pad reference frame: dX=%f, dZ=%f", info[0],info[1],info[2]));
872
873
874 Int_t ind[5];
875 ind[0]=c->GetDetInd(0);
876 ind[1]=c->GetDetInd(1);
877 ind[2]=c->GetDetInd(2);
878 ind[3]=c->GetDetInd(3);
879 ind[4]=c->GetDetInd(4);
880 Int_t calindex = AliTOFGeometry::GetIndex(ind);
881 t->SetTOFCalChannel(calindex);
882
883 // keep track of the track labels in the matched cluster
884 Int_t tlab[3];
885 tlab[0]=c->GetLabel(0);
886 tlab[1]=c->GetLabel(1);
887 tlab[2]=c->GetLabel(2);
888 AliDebug(2,Form(" tdc time of the matched track %6d = ",c->GetTDC()));
889 Double_t tof=AliTOFGeometry::TdcBinWidth()*c->GetTDC()+kTimeOffset; // in ps
890 AliDebug(2,Form(" tof time of the matched track: %f = ",tof));
891 Double_t tofcorr=tof;
892 if(timeWalkCorr)tofcorr=CorrectTimeWalk(mindistZ,tof);
893 AliDebug(2,Form(" tof time of the matched track, after TW corr: %f = ",tofcorr));
894 //Set TOF time signal and pointer to the matched cluster
895 t->SetTOFsignal(tofcorr);
896 t->SetTOFcluster(idclus); // pointing to the recPoints tree
897
898 AliDebug(2,Form(" Setting TOF raw time: %f, z distance: %f corrected time: %f ",rawTime,mindistZ,tofcorr));
899
900 //Tracking info
901 Double_t time[AliPID::kSPECIES]; t->GetIntegratedTimes(time); // in ps
902 Double_t mom=t->GetP();
903 AliDebug(2,Form(" Momentum for track %d -> %f", iseed,mom));
904 for (Int_t j=0;j<AliPID::kSPECIES;j++) {
905 Double_t mass=AliPID::ParticleMass(j);
906 time[j]+=(recL-trackPos[3][0])/kSpeedOfLight*TMath::Sqrt(mom*mom+mass*mass)/mom;
907 }
908
909 AliTOFtrack *trackTOFout = new AliTOFtrack(*t);
910 if (!(trackTOFout->PropagateTo(xpos))) {
911 delete trackTOFout;
912 continue;
913 }
914
915 // If necessary, rotate the track
916 Double_t yATxposMax=xpos*TMath::Tan(0.5*AliTOFGeometry::GetAlpha());
917 Double_t yATxpos=trackTOFout->GetY();
918 if (yATxpos > yATxposMax) {
919 if (!(trackTOFout->Rotate(AliTOFGeometry::GetAlpha()))) {
920 delete trackTOFout;
921 continue;
922 }
923 } else if (yATxpos < -yATxposMax) {
924 if (!(trackTOFout->Rotate(-AliTOFGeometry::GetAlpha()))) {
925 delete trackTOFout;
926 continue;
927 }
928 }
929
930 // Fill the track residual histograms.
931 FillResiduals(trackTOFout,c,kFALSE);
932
933 t->UpdateTrackParams(trackTOFout,AliESDtrack::kTOFout);
934 t->SetIntegratedLength(recL);
935 t->SetIntegratedTimes(time);
936 t->SetTOFLabel(tlab);
937
938
939 // Fill Reco-QA histos for Reconstruction
940 fHRecNClus->Fill(nc);
941 fHRecDist->Fill(mindist);
942 if (cov[0]>=0.)
943 fHRecSigYVsP->Fill(mom,TMath::Sqrt(cov[0]));
944 else
945 fHRecSigYVsP->Fill(mom,-TMath::Sqrt(-cov[0]));
946 if (cov[2]>=0.)
947 fHRecSigZVsP->Fill(mom,TMath::Sqrt(cov[2]));
948 else
949 fHRecSigZVsP->Fill(mom,-TMath::Sqrt(-cov[2]));
950 fHRecSigYVsPWin->Fill(mom,dphi*sensRadius);
951 fHRecSigZVsPWin->Fill(mom,dz);
952
953 // Fill Tree for on-the-fly offline Calibration
954
955 if ( !((t->GetStatus() & AliESDtrack::kTIME)==0 ) ) {
956 fIch=calindex;
957 fToT=tToT;
958 fTime=rawTime;
959 fExpTimePi=time[2];
960 fExpTimeKa=time[3];
961 fExpTimePr=time[4];
962 fCalTree->Fill();
963 }
964 delete trackTOFout;
965 }
966
967 for (Int_t ii=0; ii<4; ii++) delete [] trackPos[ii];
968 delete [] clind;
969
970}
971//_________________________________________________________________________
972Int_t AliTOFtracker::LoadClusters(TTree *cTree) {
973 //--------------------------------------------------------------------
974 //This function loads the TOF clusters
975 //--------------------------------------------------------------------
976
977 Int_t npadX = AliTOFGeometry::NpadX();
978 Int_t npadZ = AliTOFGeometry::NpadZ();
979 Int_t nStripA = AliTOFGeometry::NStripA();
980 Int_t nStripB = AliTOFGeometry::NStripB();
981 Int_t nStripC = AliTOFGeometry::NStripC();
982
983 TBranch *branch=cTree->GetBranch("TOF");
984 if (!branch) {
985 AliError("can't get the branch with the TOF clusters !");
986 return 1;
987 }
988
989 static TClonesArray dummy("AliTOFcluster",10000);
990 dummy.Clear();
991 TClonesArray *clusters=&dummy;
992 branch->SetAddress(&clusters);
993
994 cTree->GetEvent(0);
995 Int_t nc=clusters->GetEntriesFast();
996 fHDigNClus->Fill(nc);
997
998 AliInfo(Form("Number of clusters: %d",nc));
999
1000 for (Int_t i=0; i<nc; i++) {
1001 AliTOFcluster *c=(AliTOFcluster*)clusters->UncheckedAt(i);
1002//PH fClusters[i]=new AliTOFcluster(*c); fN++;
1003 fClusters[i]=c; fN++;
1004
1005 // Fill Digits QA histos
1006
1007 Int_t isector = c->GetDetInd(0);
1008 Int_t iplate = c->GetDetInd(1);
1009 Int_t istrip = c->GetDetInd(2);
1010 Int_t ipadX = c->GetDetInd(4);
1011 Int_t ipadZ = c->GetDetInd(3);
1012
1013 Float_t time =(AliTOFGeometry::TdcBinWidth()*c->GetTDC())*1E-3; // in ns
1014 Float_t tot = (AliTOFGeometry::TdcBinWidth()*c->GetToT())*1E-3;//in ns
1015
1016 Int_t stripOffset = 0;
1017 switch (iplate) {
1018 case 0:
1019 stripOffset = 0;
1020 break;
1021 case 1:
1022 stripOffset = nStripC;
1023 break;
1024 case 2:
1025 stripOffset = nStripC+nStripB;
1026 break;
1027 case 3:
1028 stripOffset = nStripC+nStripB+nStripA;
1029 break;
1030 case 4:
1031 stripOffset = nStripC+nStripB+nStripA+nStripB;
1032 break;
1033 default:
1034 AliError(Form("Wrong plate number in TOF (%d) !",iplate));
1035 break;
1036 };
1037 Int_t zindex=npadZ*(istrip+stripOffset)+(ipadZ+1);
1038 Int_t phiindex=npadX*isector+ipadX+1;
1039 fHDigClusMap->Fill(zindex,phiindex);
1040 fHDigClusTime->Fill(time);
1041 fHDigClusToT->Fill(tot);
1042
1043 }
1044
1045
1046 return 0;
1047}
1048//_________________________________________________________________________
1049void AliTOFtracker::UnloadClusters() {
1050 //--------------------------------------------------------------------
1051 //This function unloads TOF clusters
1052 //--------------------------------------------------------------------
1053 for (Int_t i=0; i<fN; i++) {
1054//PH delete fClusters[i];
1055 fClusters[i] = 0x0;
1056 }
1057 fN=0;
1058}
1059
1060//_________________________________________________________________________
1061Int_t AliTOFtracker::FindClusterIndex(Double_t z) const {
1062 //--------------------------------------------------------------------
1063 // This function returns the index of the nearest cluster
1064 //--------------------------------------------------------------------
1065 if (fN==0) return 0;
1066 if (z <= fClusters[0]->GetZ()) return 0;
1067 if (z > fClusters[fN-1]->GetZ()) return fN;
1068 Int_t b=0, e=fN-1, m=(b+e)/2;
1069 for (; b<e; m=(b+e)/2) {
1070 if (z > fClusters[m]->GetZ()) b=m+1;
1071 else e=m;
1072 }
1073 return m;
1074}
1075
1076//_________________________________________________________________________
1077Bool_t AliTOFtracker::GetTrackPoint(Int_t index, AliTrackPoint& p) const
1078{
1079 // Get track space point with index i
1080 // Coordinates are in the global system
1081 AliTOFcluster *cl = fClusters[index];
1082 Float_t xyz[3];
1083 xyz[0] = cl->GetR()*TMath::Cos(cl->GetPhi());
1084 xyz[1] = cl->GetR()*TMath::Sin(cl->GetPhi());
1085 xyz[2] = cl->GetZ();
1086 Float_t phiangle = (Int_t(cl->GetPhi()*TMath::RadToDeg()/20.)+0.5)*20.*TMath::DegToRad();
1087 Float_t sinphi = TMath::Sin(phiangle), cosphi = TMath::Cos(phiangle);
1088 Float_t tiltangle = AliTOFGeometry::GetAngles(cl->GetDetInd(1),cl->GetDetInd(2))*TMath::DegToRad();
1089 Float_t sinth = TMath::Sin(tiltangle), costh = TMath::Cos(tiltangle);
1090 Float_t sigmay2 = AliTOFGeometry::XPad()*AliTOFGeometry::XPad()/12.;
1091 Float_t sigmaz2 = AliTOFGeometry::ZPad()*AliTOFGeometry::ZPad()/12.;
1092 Float_t cov[6];
1093 cov[0] = sinphi*sinphi*sigmay2 + cosphi*cosphi*sinth*sinth*sigmaz2;
1094 cov[1] = -sinphi*cosphi*sigmay2 + sinphi*cosphi*sinth*sinth*sigmaz2;
1095 cov[2] = -cosphi*sinth*costh*sigmaz2;
1096 cov[3] = cosphi*cosphi*sigmay2 + sinphi*sinphi*sinth*sinth*sigmaz2;
1097 cov[4] = -sinphi*sinth*costh*sigmaz2;
1098 cov[5] = costh*costh*sigmaz2;
1099 p.SetXYZ(xyz[0],xyz[1],xyz[2],cov);
1100
1101 // Detector numbering scheme
1102 Int_t nSector = AliTOFGeometry::NSectors();
1103 Int_t nPlate = AliTOFGeometry::NPlates();
1104 Int_t nStripA = AliTOFGeometry::NStripA();
1105 Int_t nStripB = AliTOFGeometry::NStripB();
1106 Int_t nStripC = AliTOFGeometry::NStripC();
1107
1108 Int_t isector = cl->GetDetInd(0);
1109 if (isector >= nSector)
1110 AliError(Form("Wrong sector number in TOF (%d) !",isector));
1111 Int_t iplate = cl->GetDetInd(1);
1112 if (iplate >= nPlate)
1113 AliError(Form("Wrong plate number in TOF (%d) !",iplate));
1114 Int_t istrip = cl->GetDetInd(2);
1115
1116 Int_t stripOffset = 0;
1117 switch (iplate) {
1118 case 0:
1119 stripOffset = 0;
1120 break;
1121 case 1:
1122 stripOffset = nStripC;
1123 break;
1124 case 2:
1125 stripOffset = nStripC+nStripB;
1126 break;
1127 case 3:
1128 stripOffset = nStripC+nStripB+nStripA;
1129 break;
1130 case 4:
1131 stripOffset = nStripC+nStripB+nStripA+nStripB;
1132 break;
1133 default:
1134 AliError(Form("Wrong plate number in TOF (%d) !",iplate));
1135 break;
1136 };
1137
1138 Int_t idet = (2*(nStripC+nStripB)+nStripA)*isector +
1139 stripOffset +
1140 istrip;
1141 UShort_t volid = AliGeomManager::LayerToVolUID(AliGeomManager::kTOF,idet);
1142 p.SetVolumeID((UShort_t)volid);
1143 return kTRUE;
1144}
1145//_________________________________________________________________________
1146void AliTOFtracker::InitCheckHists() {
1147
1148 //Init histos for Digits/Reco QA and Calibration
1149
1150
1151 TDirectory *dir = gDirectory;
1152 TFile *logFileTOF = 0;
1153
1154 TSeqCollection *list = gROOT->GetListOfFiles();
1155 int n = list->GetEntries();
1156 Bool_t isThere=kFALSE;
1157 for(int i=0; i<n; i++) {
1158 logFileTOF = (TFile*)list->At(i);
1159 if (strstr(logFileTOF->GetName(), "TOFQA.root")){
1160 isThere=kTRUE;
1161 break;
1162 }
1163 }
1164
1165 if(!isThere)logFileTOF = new TFile( "TOFQA.root","RECREATE");
1166 logFileTOF->cd();
1167
1168 fCalTree = new TTree("CalTree", "Tree for TOF calibration");
1169 fCalTree->Branch("TOFchannelindex",&fIch,"iTOFch/I");
1170 fCalTree->Branch("ToT",&fToT,"TOFToT/F");
1171 fCalTree->Branch("TOFtime",&fTime,"TOFtime/F");
1172 fCalTree->Branch("PionExpTime",&fExpTimePi,"PiExpTime/F");
1173 fCalTree->Branch("KaonExpTime",&fExpTimeKa,"KaExpTime/F");
1174 fCalTree->Branch("ProtonExpTime",&fExpTimePr,"PrExpTime/F");
1175
1176 //Digits "QA"
1177 fHDigClusMap = new TH2F("TOFDig_ClusMap", "",182,0.5,182.5,864, 0.5,864.5);
1178 fHDigNClus = new TH1F("TOFDig_NClus", "",200,0.5,200.5);
1179 fHDigClusTime = new TH1F("TOFDig_ClusTime", "",2000,0.,200.);
1180 fHDigClusToT = new TH1F("TOFDig_ClusToT", "",500,0.,100);
1181
1182 //Reco "QA"
1183 fHRecNClus =new TH1F("TOFRec_NClusW", "",50,0.5,50.5);
1184 fHRecDist=new TH1F("TOFRec_Dist", "",50,0.5,10.5);
1185 fHRecSigYVsP=new TH2F("TOFDig_SigYVsP", "",40,0.,4.,100, 0.,5.);
1186 fHRecSigZVsP=new TH2F("TOFDig_SigZVsP", "",40,0.,4.,100, 0.,5.);
1187 fHRecSigYVsPWin=new TH2F("TOFDig_SigYVsPWin", "",40,0.,4.,100, 0.,50.);
1188 fHRecSigZVsPWin=new TH2F("TOFDig_SigZVsPWin", "",40,0.,4.,100, 0.,50.);
1189
1190 dir->cd();
1191
1192}
1193
1194//_________________________________________________________________________
1195void AliTOFtracker::SaveCheckHists() {
1196
1197 //write histos for Digits/Reco QA and Calibration
1198
1199 TDirectory *dir = gDirectory;
1200 TFile *logFileTOF = 0;
1201
1202 TSeqCollection *list = gROOT->GetListOfFiles();
1203 int n = list->GetEntries();
1204 Bool_t isThere=kFALSE;
1205 for(int i=0; i<n; i++) {
1206 logFileTOF = (TFile*)list->At(i);
1207 if (strstr(logFileTOF->GetName(), "TOFQA.root")){
1208 isThere=kTRUE;
1209 break;
1210 }
1211 }
1212
1213 if(!isThere) {
1214 AliError(Form("File TOFQA.root not found!! not wring histograms...."));
1215 return;
1216 }
1217 logFileTOF->cd();
1218 fHDigClusMap->Write(fHDigClusMap->GetName(), TObject::kOverwrite);
1219 fHDigNClus->Write(fHDigNClus->GetName(), TObject::kOverwrite);
1220 fHDigClusTime->Write(fHDigClusTime->GetName(), TObject::kOverwrite);
1221 fHDigClusToT->Write(fHDigClusToT->GetName(), TObject::kOverwrite);
1222 fHRecNClus->Write(fHRecNClus->GetName(), TObject::kOverwrite);
1223 fHRecDist->Write(fHRecDist->GetName(), TObject::kOverwrite);
1224 fHRecSigYVsP->Write(fHRecSigYVsP->GetName(), TObject::kOverwrite);
1225 fHRecSigZVsP->Write(fHRecSigZVsP->GetName(), TObject::kOverwrite);
1226 fHRecSigYVsPWin->Write(fHRecSigYVsPWin->GetName(), TObject::kOverwrite);
1227 fHRecSigZVsPWin->Write(fHRecSigZVsPWin->GetName(), TObject::kOverwrite);
1228 fCalTree->Write(fCalTree->GetName(),TObject::kOverwrite);
1229 logFileTOF->Flush();
1230
1231 dir->cd();
1232 }
1233//_________________________________________________________________________
1234Float_t AliTOFtracker::CorrectTimeWalk( Float_t dist, Float_t tof) const {
1235
1236 //dummy, for the moment
1237 Float_t tofcorr=0.;
1238 if(dist<AliTOFGeometry::ZPad()*0.5){
1239 tofcorr=tof;
1240 //place here the actual correction
1241 }else{
1242 tofcorr=tof;
1243 }
1244 return tofcorr;
1245}
1246//_________________________________________________________________________
1247
1248void AliTOFtracker::FillClusterArray(TObjArray* arr) const
1249{
1250 //
1251 // Returns the TOF cluster array
1252 //
1253
1254 if (fN==0)
1255 arr = 0x0;
1256 else
1257 for (Int_t i=0; i<fN; ++i) arr->Add(fClusters[i]);
1258
1259}
1260//_________________________________________________________________________
1261