New AliTRDcluster constructor
[u/mrichter/AliRoot.git] / TOF / AliTOFClusterFinder.cxx
CommitLineData
d08a92dd 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/*
15ec34b9 17$Log$
ef58b2af 18Revision 1.27 2007/05/02 16:31:49 arcelli
19Add methods to handle single event reconstruction. retrieval of Calib info moved to AliTOFReconstructor ctor, and passed via a pointer to AliTOFcalib
20
94f5f8f2 21Revision 1.26 2007/04/30 19:02:24 arcelli
22hopefully the last refinements for correct type conversion in calibration
23
a33fec85 24Revision 1.25 2007/04/30 15:22:17 arcelli
25Change TOF digit Time, Tot etc to int type
26
bf33f8f0 27Revision 1.24 2007/04/27 11:19:31 arcelli
28updates for the new decoder
29
7813bb1a 30Revision 1.23 2007/04/23 16:51:39 decaro
31Digits-to-raw_data conversion: correction for a more real description (A.De Caro, R.Preghenella)
32
515faf5d 33Revision 1.22 2007/04/19 17:26:32 arcelli
34Fix a bug (add some debug printout
35
0451c2e6 36Revision 1.21 2007/04/18 17:28:12 arcelli
37Set the ToT bin width to the one actually used...
38
605370db 39Revision 1.20 2007/03/09 09:57:23 arcelli
40 Remove a forgotten include of Riostrem
41
c77771e2 42Revision 1.19 2007/03/08 15:41:20 arcelli
43set uncorrected times when filling RecPoints
44
3432ebfa 45Revision 1.18 2007/03/06 16:31:20 arcelli
46Add Uncorrected TOF Time signal
47
aa5476d8 48Revision 1.17 2007/02/28 18:09:11 arcelli
49Add protection against failed retrieval of the CDB cal object, now Reconstruction exits with AliFatal
50
a1cab04c 51Revision 1.16 2007/02/20 15:57:00 decaro
52Raw data update: to read the TOF raw data defined in UNPACKED mode
53
d08a92dd 54
55Revision 0.03 2005/07/28 A. De Caro
56 Implement public method
57 Raw2Digits(Int_t, AliRawReader *)
58 to convert digits from raw data in MC digits
59 (temporary solution)
60
61Revision 0.02 2005/07/27 A. De Caro
62 Implement public method
63 Digits2RecPoint(Int_t)
64 to convert digits in clusters
65
66Revision 0.02 2005/07/26 A. De Caro
67 Implement private methods
68 InsertCluster(AliTOFcluster *)
69 FindClusterIndex(Double_t)
70 originally implemented in AliTOFtracker
71 by S. Arcelli and C. Zampolli
72
73Revision 0.01 2005/07/25 A. De Caro
74 Implement public methods
75 Digits2RecPoint(AliRawReader *, TTree *)
76 Digits2RecPoint(Int_t, AliRawReader *)
77 to convert raw data in clusters
78 */
79
80////////////////////////////////////////////////////////////////
81// //
82// Class for TOF cluster finder //
83// //
84// Starting from Raw Data, create rec points, //
85// fill TreeR for TOF, //
86// write TOF.RecPoints.root file //
87// //
88////////////////////////////////////////////////////////////////
89
15ec34b9 90
0e46b9ae 91#include "TClonesArray.h"
15ec34b9 92//#include "TFile.h"
515faf5d 93#include "TStopwatch.h"
0e46b9ae 94#include "TTree.h"
d08a92dd 95
d0eb8f39 96#include "AliDAQ.h"
0e46b9ae 97#include "AliLoader.h"
d08a92dd 98#include "AliLog.h"
0e46b9ae 99#include "AliRawReader.h"
d08a92dd 100#include "AliRunLoader.h"
d08a92dd 101
37879eed 102#include "AliTOFCal.h"
15ec34b9 103#include "AliTOFcalib.h"
37879eed 104#include "AliTOFChannel.h"
d08a92dd 105#include "AliTOFClusterFinder.h"
0e46b9ae 106#include "AliTOFcluster.h"
107#include "AliTOFdigit.h"
0e46b9ae 108#include "AliTOFGeometry.h"
15ec34b9 109#include "AliTOFGeometryV5.h"
110#include "AliTOFrawData.h"
0e46b9ae 111#include "AliTOFRawStream.h"
3432ebfa 112#include "Riostream.h"
0e46b9ae 113
15ec34b9 114//extern TFile *gFile;
d08a92dd 115
116ClassImp(AliTOFClusterFinder)
117
94f5f8f2 118AliTOFClusterFinder::AliTOFClusterFinder(AliTOFcalib *calib):
d08a92dd 119 fRunLoader(0),
120 fTOFLoader(0),
121 fTreeD(0),
122 fTreeR(0),
58d8d9a3 123 fTOFGeometry(new AliTOFGeometryV5()),
d08a92dd 124 fDigits(new TClonesArray("AliTOFdigit", 4000)),
125 fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
15ec34b9 126 fNumberOfTofClusters(0),
7813bb1a 127 fVerbose(0),
94f5f8f2 128 fDecoderVersion(0),
129 fTOFcalib(calib)
d08a92dd 130{
131//
132// Constructor
133//
134
3bbdf45d 135 AliInfo("V5 TOF Geometry is taken as the default");
37879eed 136
d08a92dd 137}
138//______________________________________________________________________________
139
94f5f8f2 140AliTOFClusterFinder::AliTOFClusterFinder(AliRunLoader* runLoader, AliTOFcalib *calib):
d08a92dd 141 fRunLoader(runLoader),
142 fTOFLoader(runLoader->GetLoader("TOFLoader")),
143 fTreeD(0),
144 fTreeR(0),
58d8d9a3 145 fTOFGeometry(new AliTOFGeometryV5()),
d08a92dd 146 fDigits(new TClonesArray("AliTOFdigit", 4000)),
147 fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
15ec34b9 148 fNumberOfTofClusters(0),
7813bb1a 149 fVerbose(0),
94f5f8f2 150 fDecoderVersion(0),
151 fTOFcalib(calib)
d08a92dd 152{
153//
154// Constructor
155//
156
d08a92dd 157}
7aeeaf38 158
159//------------------------------------------------------------------------
160AliTOFClusterFinder::AliTOFClusterFinder(const AliTOFClusterFinder &source)
58d8d9a3 161 :TObject(),
162 fRunLoader(0),
163 fTOFLoader(0),
164 fTreeD(0),
165 fTreeR(0),
166 fTOFGeometry(new AliTOFGeometryV5()),
167 fDigits(new TClonesArray("AliTOFdigit", 4000)),
168 fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
15ec34b9 169 fNumberOfTofClusters(0),
94f5f8f2 170 fVerbose(0),
171 fDecoderVersion(0),
172 fTOFcalib(0)
7aeeaf38 173{
174 // copy constructor
175 this->fDigits=source.fDigits;
176 this->fRecPoints=source.fRecPoints;
177 this->fTOFGeometry=source.fTOFGeometry;
7813bb1a 178 this->fDecoderVersion=source.fDecoderVersion;
94f5f8f2 179 this->fTOFcalib=source.fTOFcalib;
7aeeaf38 180
181}
182
183//------------------------------------------------------------------------
d0eb8f39 184AliTOFClusterFinder& AliTOFClusterFinder::operator=(const AliTOFClusterFinder &source)
7aeeaf38 185{
186 // ass. op.
187 this->fDigits=source.fDigits;
188 this->fRecPoints=source.fRecPoints;
189 this->fTOFGeometry=source.fTOFGeometry;
15ec34b9 190 this->fVerbose=source.fVerbose;
7813bb1a 191 this->fDecoderVersion=source.fDecoderVersion;
94f5f8f2 192 this->fTOFcalib=source.fTOFcalib;
7aeeaf38 193 return *this;
194
195}
d08a92dd 196//______________________________________________________________________________
197
198AliTOFClusterFinder::~AliTOFClusterFinder()
199{
200
201 //
202 // Destructor
203 //
204
205 if (fDigits)
206 {
207 fDigits->Delete();
208 delete fDigits;
209 fDigits=0;
210 }
211 if (fRecPoints)
212 {
213 fRecPoints->Delete();
214 delete fRecPoints;
215 fRecPoints=0;
216 }
217
218 delete fTOFGeometry;
219
220}
221//______________________________________________________________________________
222
223void AliTOFClusterFinder::Digits2RecPoints(Int_t iEvent)
224{
225 //
226 // Converts digits to recpoints for TOF
227 //
228
515faf5d 229 TStopwatch stopwatch;
230 stopwatch.Start();
231
d08a92dd 232 fRunLoader->GetEvent(iEvent);
233
234 fTreeD = fTOFLoader->TreeD();
235 if (fTreeD == 0x0)
236 {
237 AliFatal("AliTOFClusterFinder: Can not get TreeD");
238 }
239
240 TBranch *branch = fTreeD->GetBranch("TOF");
241 if (!branch) {
242 AliError("can't get the branch with the TOF digits !");
243 return;
244 }
245
15ec34b9 246 TClonesArray *digits = new TClonesArray("AliTOFdigit",10000);
d08a92dd 247 branch->SetAddress(&digits);
248
249 ResetRecpoint();
250
251 fTreeR = fTOFLoader->TreeR();
252 if (fTreeR == 0x0)
253 {
254 fTOFLoader->MakeTree("R");
255 fTreeR = fTOFLoader->TreeR();
256 }
257
258 Int_t bufsize = 32000;
259 fTreeR->Branch("TOF", &fRecPoints, bufsize);
260
261 fTreeD->GetEvent(0);
262 Int_t nDigits = digits->GetEntriesFast();
263 AliDebug(2,Form("Number of TOF digits: %d",nDigits));
264
265 Int_t ii, jj;
bf33f8f0 266 Int_t dig[5]; //cluster detector indeces
267 Float_t g[3]; //cluster cartesian coord
268 Double_t h[3]; // the cluster spatial cyl. coordinates
269 Int_t parTOF[5]; //The TOF signal parameters
270 Bool_t status=kTRUE; // assume all sim channels ok in the beginning...
d08a92dd 271 for (ii=0; ii<nDigits; ii++) {
272 AliTOFdigit *d = (AliTOFdigit*)digits->UncheckedAt(ii);
273 dig[0]=d->GetSector();
274 dig[1]=d->GetPlate();
275 dig[2]=d->GetStrip();
276 dig[3]=d->GetPadz();
277 dig[4]=d->GetPadx();
278
bf33f8f0 279 // AliDebug(2,Form(" %2i %1i %2i %1i %2i ",dig[0],dig[1],dig[2],dig[3],dig[4]));
d0eb8f39 280
d08a92dd 281 for (jj=0; jj<3; jj++) g[jj] = 0.;
282 fTOFGeometry->GetPos(dig,g);
283
284 h[0] = TMath::Sqrt(g[0]*g[0]+g[1]*g[1]);
285 h[1] = TMath::ATan2(g[1],g[0]);
286 h[2] = g[2];
d08a92dd 287
bf33f8f0 288 parTOF[0] = d->GetTdc(); //the TDC signal
289 parTOF[1] = d->GetToT(); //the ToT signal
290 parTOF[2] = d->GetAdc(); // the adc charge
291 parTOF[3] = d->GetTdcND(); // non decalibrated sim time
292 parTOF[4] = d->GetTdc(); // raw time, == Tdc time for the moment
293 AliTOFcluster *tofCluster = new AliTOFcluster(h,dig,parTOF,status,d->GetTracks(),ii);
d08a92dd 294 InsertCluster(tofCluster);
295
296 }
297
94f5f8f2 298 AliInfo(Form("Number of found clusters: %i for event: %i", fNumberOfTofClusters, iEvent));
d08a92dd 299
37879eed 300 CalibrateRecPoint();
d08a92dd 301 FillRecPoint();
302
303 fTreeR->Fill();
304 ResetRecpoint();
305
306 fTOFLoader = fRunLoader->GetLoader("TOFLoader");
307 fTOFLoader->WriteRecPoints("OVERWRITE");
308
515faf5d 309 AliInfo(Form("Execution time to read TOF digits and to write TOF clusters : R:%.4fs C:%.4fs",
310 stopwatch.RealTime(),stopwatch.CpuTime()));
311
94f5f8f2 312 digits->Delete();
313 delete digits;
314}
315
316//______________________________________________________________________________
317
318void AliTOFClusterFinder::Digits2RecPoints(TTree* digitsTree, TTree* clusterTree)
319{
320 //
321 // Converts digits to recpoints for TOF
322 //
323
324 TStopwatch stopwatch;
325 stopwatch.Start();
326
327 /// fRunLoader->GetEvent(iEvent);
328
329 if (digitsTree == 0x0)
330 {
331 AliFatal("AliTOFClusterFinder: Can not get TreeD");
332 }
333
334 TBranch *branch = digitsTree->GetBranch("TOF");
335 if (!branch) {
336 AliError("can't get the branch with the TOF digits !");
337 return;
338 }
339
340 TClonesArray *digits = new TClonesArray("AliTOFdigit",10000);
341 branch->SetAddress(&digits);
342
343 ResetRecpoint();
344
345 fTreeR=clusterTree;
346 Int_t bufsize = 32000;
347 fTreeR->Branch("TOF", &fRecPoints, bufsize);
348
349 digitsTree->GetEvent(0);
350 Int_t nDigits = digits->GetEntriesFast();
351 AliDebug(2,Form("Number of TOF digits: %d",nDigits));
352
353 Int_t ii, jj;
354 Int_t dig[5]; //cluster detector indeces
355 Float_t g[3]; //cluster cartesian coord
356 Double_t h[3]; // the cluster spatial cyl. coordinates
357 Int_t parTOF[5]; //The TOF signal parameters
358 Bool_t status=kTRUE; // assume all sim channels ok in the beginning...
359 for (ii=0; ii<nDigits; ii++) {
360 AliTOFdigit *d = (AliTOFdigit*)digits->UncheckedAt(ii);
361 dig[0]=d->GetSector();
362 dig[1]=d->GetPlate();
363 dig[2]=d->GetStrip();
364 dig[3]=d->GetPadz();
365 dig[4]=d->GetPadx();
366
367 // AliDebug(2,Form(" %2i %1i %2i %1i %2i ",dig[0],dig[1],dig[2],dig[3],dig[4]));
368
369 for (jj=0; jj<3; jj++) g[jj] = 0.;
370 fTOFGeometry->GetPos(dig,g);
371
372 h[0] = TMath::Sqrt(g[0]*g[0]+g[1]*g[1]);
373 h[1] = TMath::ATan2(g[1],g[0]);
374 h[2] = g[2];
375
376 parTOF[0] = d->GetTdc(); //the TDC signal
377 parTOF[1] = d->GetToT(); //the ToT signal
378 parTOF[2] = d->GetAdc(); // the adc charge
379 parTOF[3] = d->GetTdcND(); // non decalibrated sim time
380 parTOF[4] = d->GetTdc(); // raw time, == Tdc time for the moment
381 AliTOFcluster *tofCluster = new AliTOFcluster(h,dig,parTOF,status,d->GetTracks(),ii);
382 InsertCluster(tofCluster);
383
384 }
385
386 AliInfo(Form("Number of found clusters: %i", fNumberOfTofClusters));
387
388 CalibrateRecPoint();
389 FillRecPoint();
390
391 clusterTree->Fill();
392 ResetRecpoint();
393
394 AliInfo(Form("Execution time to read TOF digits and to write TOF clusters : R:%.4fs C:%.4fs",
395 stopwatch.RealTime(),stopwatch.CpuTime()));
396
397 digits->Delete();
398 delete digits;
d08a92dd 399}
400//______________________________________________________________________________
401
402void AliTOFClusterFinder::Digits2RecPoints(AliRawReader *rawReader,
403 TTree *clustersTree)
404{
405 //
406 // Converts RAW data to recpoints for TOF
407 //
408
515faf5d 409 TStopwatch stopwatch;
410 stopwatch.Start();
411
d0eb8f39 412 //const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
413 const Int_t kDDL = AliDAQ::NumberOfDdls("TOF");
d08a92dd 414
415 ResetRecpoint();
416
417 Int_t bufsize = 32000;
418 clustersTree->Branch("TOF", &fRecPoints, bufsize);
419
15ec34b9 420 TClonesArray * clonesRawData;
421
d08a92dd 422 Int_t ii = 0;
15ec34b9 423 Int_t dummy = -1;
d08a92dd 424
425 Int_t detectorIndex[5];
426 Float_t position[3];
bf33f8f0 427 Double_t cylindricalPosition[3];
428 Int_t parTOF[5];
d08a92dd 429
15ec34b9 430 ofstream ftxt;
431 if (fVerbose==2) ftxt.open("TOFdigitsRead.txt",ios::app);
432
ef58b2af 433 AliTOFRawStream tofInput(rawReader);
434
15ec34b9 435 Int_t indexDDL = 0;
436 for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
437
438 rawReader->Reset();
7813bb1a 439 if (fDecoderVersion) {
440 AliInfo("Using New Decoder \n");
441 tofInput.LoadRawDataBuffers(indexDDL,fVerbose);
442 }
443 else tofInput.LoadRawData(indexDDL);
15ec34b9 444
445 clonesRawData = (TClonesArray*)tofInput.GetRawData();
446
447 for (Int_t iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
448
449 AliTOFrawData *tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
450
451 if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
452
453 if (fVerbose==2) {
454 if (indexDDL<10) ftxt << " " << indexDDL;
455 else ftxt << " " << indexDDL;
456 if (tofRawDatum->GetTRM()<10) ftxt << " " << tofRawDatum->GetTRM();
457 else ftxt << " " << tofRawDatum->GetTRM();
458 ftxt << " " << tofRawDatum->GetTRMchain();
459 if (tofRawDatum->GetTDC()<10) ftxt << " " << tofRawDatum->GetTDC();
460 else ftxt << " " << tofRawDatum->GetTDC();
461 ftxt << " " << tofRawDatum->GetTDCchannel();
462 }
463
464 tofInput.EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
465 tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
466 dummy = detectorIndex[3];
467 detectorIndex[3] = detectorIndex[4];
468 detectorIndex[4] = dummy;
469
470 if (fVerbose==2) {
471 if (detectorIndex[0]<10) ftxt << " -> " << detectorIndex[0];
472 else ftxt << " -> " << detectorIndex[0];
473 ftxt << " " << detectorIndex[1];
474 if (detectorIndex[2]<10) ftxt << " " << detectorIndex[2];
475 else ftxt << " " << detectorIndex[2];
476 ftxt << " " << detectorIndex[3];
477 if (detectorIndex[4]<10) ftxt << " " << detectorIndex[4];
478 else ftxt << " " << detectorIndex[4];
479 }
480
481 for (ii=0; ii<3; ii++) position[ii] = 0.;
482 fTOFGeometry->GetPos(detectorIndex, position);
483
484 cylindricalPosition[0] = TMath::Sqrt(position[0]*position[0] + position[1]*position[1]);
485 cylindricalPosition[1] = TMath::ATan2(position[1], position[0]);
486 cylindricalPosition[2] = position[2];
bf33f8f0 487
488 parTOF[0] = tofRawDatum->GetTOF(); //TDC
489 parTOF[1] = tofRawDatum->GetTOT(); // TOT
490 parTOF[2] = tofRawDatum->GetTOT(); //ADC==TOF
491 parTOF[3] = -1;//raw data: no track of undecalib sim time
492 parTOF[4] = tofRawDatum->GetTOF(); // RAW time
493 AliTOFcluster *tofCluster = new AliTOFcluster(cylindricalPosition, detectorIndex, parTOF);
15ec34b9 494 InsertCluster(tofCluster);
495
496 if (fVerbose==2) {
bf33f8f0 497 if (parTOF[1]<10)ftxt << " " << parTOF[1];
498 else if (parTOF[1]>=10 && parTOF[1]<100) ftxt << " " << parTOF[1];
499 else ftxt << " " << parTOF[1];
500 if (parTOF[0]<10) ftxt << " " << parTOF[0] << endl;
501 else if (parTOF[0]>=10 && parTOF[0]<100) ftxt << " " << parTOF[0] << endl;
502 else if (parTOF[0]>=100 && parTOF[0]<1000) ftxt << " " << parTOF[0] << endl;
503 else ftxt << " " << parTOF[3] << endl;
15ec34b9 504 }
505
506 } // closed loop on TOF raw data per current DDL file
507
508 clonesRawData->Clear();
509
510 } // closed loop on DDL index
511
15ec34b9 512 if (fVerbose==2) ftxt.close();
d08a92dd 513
514 AliInfo(Form("Number of found clusters: %i", fNumberOfTofClusters));
515
37879eed 516 CalibrateRecPoint();
d08a92dd 517 FillRecPoint();
518
519 clustersTree->Fill();
37879eed 520
d08a92dd 521 ResetRecpoint();
522
515faf5d 523 AliDebug(1, Form("Execution time to read TOF raw data and to write TOF clusters : R:%.4fs C:%.4fs",
524 stopwatch.RealTime(),stopwatch.CpuTime()));
525
d08a92dd 526}
527//______________________________________________________________________________
528
529void AliTOFClusterFinder::Digits2RecPoints(Int_t iEvent, AliRawReader *rawReader)
530{
531 //
532 // Converts RAW data to recpoints for TOF
533 //
534
515faf5d 535 TStopwatch stopwatch;
536 stopwatch.Start();
537
d0eb8f39 538 //const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
539 const Int_t kDDL = AliDAQ::NumberOfDdls("TOF");
d08a92dd 540
541 fRunLoader->GetEvent(iEvent);
542
543 AliDebug(2,Form(" Event number %2i ", iEvent));
544
545 fTreeR = fTOFLoader->TreeR();
546
547 if (fTreeR == 0x0){
548 fTOFLoader->MakeTree("R");
549 fTreeR = fTOFLoader->TreeR();
550 }
551
552 Int_t bufsize = 32000;
553 fTreeR->Branch("TOF", &fRecPoints, bufsize);
554
15ec34b9 555 TClonesArray * clonesRawData;
556
d08a92dd 557 Int_t ii = 0;
15ec34b9 558 Int_t dummy = -1;
d08a92dd 559
d0eb8f39 560 Int_t detectorIndex[5] = {-1, -1, -1, -1, -1};
d08a92dd 561 Float_t position[3];
562 Double_t cylindricalPosition[5];
bf33f8f0 563 Int_t parTOF[5];
15ec34b9 564 ofstream ftxt;
565 if (fVerbose==2) ftxt.open("TOFdigitsRead.txt",ios::app);
566
ef58b2af 567 AliTOFRawStream tofInput(rawReader);
568
15ec34b9 569 Int_t indexDDL = 0;
d08a92dd 570 for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
571
572 rawReader->Reset();
7813bb1a 573 if (fDecoderVersion) {
574 AliInfo("Using New Decoder \n");
575 tofInput.LoadRawDataBuffers(indexDDL,fVerbose);
576 }
577 else tofInput.LoadRawData(indexDDL);
15ec34b9 578
579 clonesRawData = (TClonesArray*)tofInput.GetRawData();
580
581 for (Int_t iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
582
583 AliTOFrawData *tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
584
585 if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
586
587 if (fVerbose==2) {
588 if (indexDDL<10) ftxt << " " << indexDDL;
589 else ftxt << " " << indexDDL;
590 if (tofRawDatum->GetTRM()<10) ftxt << " " << tofRawDatum->GetTRM();
591 else ftxt << " " << tofRawDatum->GetTRM();
592 ftxt << " " << tofRawDatum->GetTRMchain();
593 if (tofRawDatum->GetTDC()<10) ftxt << " " << tofRawDatum->GetTDC();
594 else ftxt << " " << tofRawDatum->GetTDC();
595 ftxt << " " << tofRawDatum->GetTDCchannel();
596 }
597
598 tofInput.EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
599 tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
600 dummy = detectorIndex[3];
601 detectorIndex[3] = detectorIndex[4];
602 detectorIndex[4] = dummy;
603
604 if (fVerbose==2) {
605 if (detectorIndex[0]<10) ftxt << " -> " << detectorIndex[0];
606 else ftxt << " -> " << detectorIndex[0];
607 ftxt << " " << detectorIndex[1];
608 if (detectorIndex[2]<10) ftxt << " " << detectorIndex[2];
609 else ftxt << " " << detectorIndex[2];
610 ftxt << " " << detectorIndex[3];
611 if (detectorIndex[4]<10) ftxt << " " << detectorIndex[4];
612 else ftxt << " " << detectorIndex[4];
613 }
d0eb8f39 614
d08a92dd 615 for (ii=0; ii<3; ii++) position[ii] = 0.;
d08a92dd 616 fTOFGeometry->GetPos(detectorIndex, position);
15ec34b9 617
618 cylindricalPosition[0] = TMath::Sqrt(position[0]*position[0] + position[1]*position[1]);
619 cylindricalPosition[1] = TMath::ATan2(position[1], position[0]);
620 cylindricalPosition[2] = position[2];
bf33f8f0 621 parTOF[0] = tofRawDatum->GetTOF(); // TDC
622 parTOF[1] = tofRawDatum->GetTOT(); // TOT
623 parTOF[2] = tofRawDatum->GetTOT(); // raw data have ADC=TOT
624 parTOF[3] = -1; //raw data: no track of the undecalib sim time
625 parTOF[4] = tofRawDatum->GetTOF(); // Raw time == TDC
626 AliTOFcluster *tofCluster = new AliTOFcluster(cylindricalPosition, detectorIndex, parTOF);
d08a92dd 627 InsertCluster(tofCluster);
628
15ec34b9 629 if (fVerbose==2) {
bf33f8f0 630 if (parTOF[1]<10)ftxt << " " << parTOF[1];
631 else if (parTOF[1]>=10 && parTOF[1]<100) ftxt << " " << parTOF[1];
632 else ftxt << " " << parTOF[1];
633 if (parTOF[0]<10) ftxt << " " << parTOF[0] << endl;
634 else if (parTOF[0]>=10 && parTOF[0]<100) ftxt << " " << parTOF[0] << endl;
635 else if (parTOF[0]>=100 && parTOF[0]<1000) ftxt << " " << parTOF[0] << endl;
636 else ftxt << " " << parTOF[3] << endl;
15ec34b9 637 }
d08a92dd 638
15ec34b9 639 } // closed loop on TOF raw data per current DDL file
640
641 clonesRawData->Clear();
642
643 } // closed loop on DDL index
644
645 if (fVerbose==2) ftxt.close();
d08a92dd 646
94f5f8f2 647 AliInfo(Form("Number of found clusters: %i for event: %i", fNumberOfTofClusters, iEvent));
d08a92dd 648
37879eed 649 CalibrateRecPoint();
d08a92dd 650 FillRecPoint();
651
652 fTreeR->Fill();
653 ResetRecpoint();
654
655 fTOFLoader = fRunLoader->GetLoader("TOFLoader");
656 fTOFLoader->WriteRecPoints("OVERWRITE");
657
515faf5d 658 AliDebug(1, Form("Execution time to read TOF raw data and to write TOF clusters : R:%.4fs C:%.4fs",
659 stopwatch.RealTime(),stopwatch.CpuTime()));
660
d08a92dd 661}
662//______________________________________________________________________________
663
664void AliTOFClusterFinder::Raw2Digits(Int_t iEvent, AliRawReader *rawReader)
665{
666 //
667 // Converts RAW data to MC digits for TOF
668 //
669 // (temporary solution)
670 //
671
515faf5d 672 TStopwatch stopwatch;
673 stopwatch.Start();
674
15ec34b9 675 //const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
676 const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
677
d08a92dd 678 fRunLoader->GetEvent(iEvent);
679
680 fTreeD = fTOFLoader->TreeD();
681 if (fTreeD)
682 {
d0eb8f39 683 AliInfo("TreeD re-creation");
d08a92dd 684 fTreeD = 0x0;
685 fTOFLoader->MakeTree("D");
686 fTreeD = fTOFLoader->TreeD();
687 }
688
15ec34b9 689 TClonesArray *tofDigits = new TClonesArray("AliTOFdigit",10000);
d08a92dd 690 Int_t bufsize = 32000;
691 fTreeD->Branch("TOF", &tofDigits, bufsize);
692
d08a92dd 693 fRunLoader->GetEvent(iEvent);
694
695 AliDebug(2,Form(" Event number %2i ", iEvent));
696
15ec34b9 697 TClonesArray * clonesRawData;
698
699 Int_t dummy = -1;
d08a92dd 700
701 Int_t detectorIndex[5];
bf33f8f0 702 Int_t digit[4];
d08a92dd 703
ef58b2af 704 AliTOFRawStream tofInput(rawReader);
705
15ec34b9 706 Int_t indexDDL = 0;
d08a92dd 707 for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
708
709 rawReader->Reset();
7813bb1a 710 if (fDecoderVersion) {
711 AliInfo("Using New Decoder \n");
712 tofInput.LoadRawDataBuffers(indexDDL,fVerbose);
713 }
714 else tofInput.LoadRawData(indexDDL);
d08a92dd 715
15ec34b9 716 clonesRawData = (TClonesArray*)tofInput.GetRawData();
d08a92dd 717
15ec34b9 718 for (Int_t iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
d0eb8f39 719
15ec34b9 720 AliTOFrawData *tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
d0eb8f39 721
15ec34b9 722 if (!tofRawDatum->GetTOT() || !tofRawDatum->GetTOF()) continue;
723
724 tofInput.EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
725 tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
726 dummy = detectorIndex[3];
727 detectorIndex[3] = detectorIndex[4];
728 detectorIndex[4] = dummy;
d0eb8f39 729
bf33f8f0 730 digit[0] = tofInput.GetTofBin();
731 digit[1] = tofInput.GetToTbin();
732 digit[2] = tofInput.GetToTbin();
733 digit[3] = -1;
d08a92dd 734
735 Int_t tracknum[3]={-1,-1,-1};
736
737 TClonesArray &aDigits = *tofDigits;
738 Int_t last=tofDigits->GetEntriesFast();
739 new (aDigits[last]) AliTOFdigit(tracknum, detectorIndex, digit);
740
741 } // while loop
742
15ec34b9 743 clonesRawData->Clear();
744
d08a92dd 745 } // DDL Loop
746
747 fTreeD->Fill();
748
749 fTOFLoader = fRunLoader->GetLoader("TOFLoader");
750 fTOFLoader->WriteDigits("OVERWRITE");
751
515faf5d 752 AliDebug(1, Form("Execution time to read TOF raw data and to write TOF clusters : R:%.2fs C:%.2fs",
753 stopwatch.RealTime(),stopwatch.CpuTime()));
754
d08a92dd 755}
94f5f8f2 756
757//______________________________________________________________________________
758
759void AliTOFClusterFinder::Raw2Digits(AliRawReader *rawReader, TTree* digitsTree)
760{
761 //
762 // Converts RAW data to MC digits for TOF for the current event
763 //
764 //
765
766 TStopwatch stopwatch;
767 stopwatch.Start();
768
769 const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
770
771 if (!digitsTree)
772 {
773 AliError("No input digits Tree");
774 return;
775 }
776
777 TClonesArray *tofDigits = new TClonesArray("AliTOFdigit",10000);
778 Int_t bufsize = 32000;
779 digitsTree->Branch("TOF", &tofDigits, bufsize);
780
781 /// fRunLoader->GetEvent(iEvent);
782
783 /// AliDebug(2,Form(" Event number %2i ", iEvent));
784
785 TClonesArray * clonesRawData;
786
787 Int_t dummy = -1;
788
789 Int_t detectorIndex[5];
790 Int_t digit[4];
791
ef58b2af 792 AliTOFRawStream tofInput(rawReader);
793
94f5f8f2 794 Int_t indexDDL = 0;
795 for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
796
797 rawReader->Reset();
94f5f8f2 798 if (fDecoderVersion) {
799 AliInfo("Using New Decoder \n");
800 tofInput.LoadRawDataBuffers(indexDDL,fVerbose);
801 }
802 else tofInput.LoadRawData(indexDDL);
803
804 clonesRawData = (TClonesArray*)tofInput.GetRawData();
805
806 for (Int_t iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
807
808 AliTOFrawData *tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
809
810 if (!tofRawDatum->GetTOT() || !tofRawDatum->GetTOF()) continue;
811
812 tofInput.EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
813 tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
814 dummy = detectorIndex[3];
815 detectorIndex[3] = detectorIndex[4];
816 detectorIndex[4] = dummy;
817
818 digit[0] = tofInput.GetTofBin();
819 digit[1] = tofInput.GetToTbin();
820 digit[2] = tofInput.GetToTbin();
821 digit[3] = -1;
822
823 Int_t tracknum[3]={-1,-1,-1};
824
825 TClonesArray &aDigits = *tofDigits;
826 Int_t last=tofDigits->GetEntriesFast();
827 new (aDigits[last]) AliTOFdigit(tracknum, detectorIndex, digit);
828
829 } // while loop
830
831 clonesRawData->Clear();
832
833 } // DDL Loop
834
835 digitsTree->Fill();
836
837 AliDebug(1, Form("Got %d digits: ", tofDigits->GetEntries()));
838 AliDebug(1, Form("Execution time to read TOF raw data and fill TOF digit tree : R:%.2fs C:%.2fs",
839 stopwatch.RealTime(),stopwatch.CpuTime()));
840
841}
d08a92dd 842//______________________________________________________________________________
843
844Int_t AliTOFClusterFinder::InsertCluster(AliTOFcluster *tofCluster) {
845 //---------------------------------------------------------------------------//
846 // This function adds a TOF cluster to the array of TOF clusters sorted in Z //
847 //---------------------------------------------------------------------------//
848 if (fNumberOfTofClusters==kTofMaxCluster) {
849 AliError("Too many clusters !");
850 return 1;
851 }
852
853 if (fNumberOfTofClusters==0) {
854 fTofClusters[fNumberOfTofClusters++] = tofCluster;
855 return 0;
856 }
857
858 Int_t ii = FindClusterIndex(tofCluster->GetZ());
859 memmove(fTofClusters+ii+1 ,fTofClusters+ii,(fNumberOfTofClusters-ii)*sizeof(AliTOFcluster*));
860 fTofClusters[ii] = tofCluster;
861 fNumberOfTofClusters++;
862
863 return 0;
864
865}
866//_________________________________________________________________________
867
868Int_t AliTOFClusterFinder::FindClusterIndex(Double_t z) const {
869 //--------------------------------------------------------------------
870 // This function returns the index of the nearest cluster
871 //--------------------------------------------------------------------
872 if (fNumberOfTofClusters==0) return 0;
873 if (z <= fTofClusters[0]->GetZ()) return 0;
874 if (z > fTofClusters[fNumberOfTofClusters-1]->GetZ()) return fNumberOfTofClusters;
875 Int_t b = 0, e = fNumberOfTofClusters-1, m = (b+e)/2;
876 for (; b<e; m=(b+e)/2) {
877 if (z > fTofClusters[m]->GetZ()) b=m+1;
878 else e=m;
879 }
880
881 return m;
882
883}
884//_________________________________________________________________________
885
886void AliTOFClusterFinder::FillRecPoint()
887{
888 //
889 // Copy the global array of AliTOFcluster, i.e. fTofClusters (sorted
890 // in Z) in the global TClonesArray of AliTOFcluster,
891 // i.e. fRecPoints.
892 //
893
894 Int_t ii, jj;
895
896 Int_t detectorIndex[5];
bf33f8f0 897 Double_t cylindricalPosition[3];
898 Int_t parTOF[5];
d08a92dd 899 Int_t trackLabels[3];
900 Int_t digitIndex = -1;
bf33f8f0 901 Bool_t status=kTRUE;
d08a92dd 902
903 TClonesArray &lRecPoints = *fRecPoints;
904
905 for (ii=0; ii<fNumberOfTofClusters; ii++) {
906
907 digitIndex = fTofClusters[ii]->GetIndex();
908 for(jj=0; jj<5; jj++) detectorIndex[jj] = fTofClusters[ii]->GetDetInd(jj);
909 for(jj=0; jj<3; jj++) trackLabels[jj] = fTofClusters[ii]->GetLabel(jj);
910 cylindricalPosition[0] = fTofClusters[ii]->GetR();
911 cylindricalPosition[1] = fTofClusters[ii]->GetPhi();
912 cylindricalPosition[2] = fTofClusters[ii]->GetZ();
bf33f8f0 913 parTOF[0] = fTofClusters[ii]->GetTDC(); // TDC
914 parTOF[1] = fTofClusters[ii]->GetToT(); // TOT
915 parTOF[2] = fTofClusters[ii]->GetADC(); // ADC=TOT
916 parTOF[3] = fTofClusters[ii]->GetTDCND(); // TDCND
917 parTOF[4] = fTofClusters[ii]->GetTDCRAW();//RAW
918 status=fTofClusters[ii]->GetStatus();
919 new(lRecPoints[ii]) AliTOFcluster(cylindricalPosition, detectorIndex, parTOF,status,trackLabels,digitIndex);
d08a92dd 920
921 } // loop on clusters
922
923}
37879eed 924
925//_________________________________________________________________________
926void AliTOFClusterFinder::CalibrateRecPoint()
927{
928 //
929 // Copy the global array of AliTOFcluster, i.e. fTofClusters (sorted
930 // in Z) in the global TClonesArray of AliTOFcluster,
931 // i.e. fRecPoints.
932 //
933
934 Int_t ii, jj;
935
936 Int_t detectorIndex[5];
937 Int_t digitIndex = -1;
a33fec85 938 Double_t tToT;
939 Double_t timeCorr;
bf33f8f0 940 Int_t tdcCorr;
37879eed 941 AliInfo(" Calibrating TOF Clusters: ")
a1cab04c 942
94f5f8f2 943 AliTOFCal *calTOFArray = fTOFcalib->GetTOFCalArray();
37879eed 944
945 for (ii=0; ii<fNumberOfTofClusters; ii++) {
946 digitIndex = fTofClusters[ii]->GetIndex();
947 for(jj=0; jj<5; jj++) detectorIndex[jj] = fTofClusters[ii]->GetDetInd(jj);
948
94f5f8f2 949 Int_t index = fTOFcalib->GetIndex(detectorIndex);
37879eed 950
340693af 951 AliTOFChannel * calChannel = calTOFArray->GetChannel(index);
58d8d9a3 952
953 // Get channel status
954 Bool_t status=calChannel->GetStatus();
955 if(status)fTofClusters[ii]->SetStatus(!status); //odd convention, to avoid conflict with calibration objects currently in the db (temporary solution).
58d8d9a3 956 // Get Rough channel online equalization
957 Float_t roughDelay=calChannel->GetDelay();
0451c2e6 958 AliDebug(2,Form(" channel delay = %f", roughDelay));
58d8d9a3 959 // Get Refined channel offline calibration parameters
37879eed 960 Float_t par[6];
961 for (Int_t j = 0; j<6; j++){
340693af 962 par[j]=calChannel->GetSlewPar(j);
bf33f8f0 963 AliDebug(2,Form(" Calib Pars = %f, %f, %f, %f, %f, %f ",par[0],par[1],par[2],par[3],par[4],par[5]));
964 }
965 AliDebug(2,Form(" The ToT and Time, uncorr (counts) = %i , %i", fTofClusters[ii]->GetToT(),fTofClusters[ii]->GetTDC()));
a33fec85 966 tToT = (Double_t)(fTofClusters[ii]->GetToT()*AliTOFGeometry::ToTBinWidth()); tToT*=1.E-3; //ToT in ns
967 AliDebug(2,Form(" The ToT and Time, uncorr (ns)= %e, %e",fTofClusters[ii]->GetTDC()*AliTOFGeometry::TdcBinWidth()*1.E-3,tToT));
bf33f8f0 968 timeCorr=par[0]+par[1]*tToT+par[2]*tToT*tToT+par[3]*tToT*tToT*tToT+par[4]*tToT*tToT*tToT*tToT+par[5]*tToT*tToT*tToT*tToT*tToT+roughDelay; // the time correction
969 AliDebug(2,Form(" The time correction (ns) = %f", timeCorr));
a33fec85 970 timeCorr=(Double_t)(fTofClusters[ii]->GetTDC())*AliTOFGeometry::TdcBinWidth()*1.E-3-timeCorr;//redefine the time
971 timeCorr*=1.E3;
972 AliDebug(2,Form(" The channel time, corr (ps)= %e",timeCorr ));
973 tdcCorr=(Int_t)(timeCorr/AliTOFGeometry::TdcBinWidth()); //the corrected time (tdc counts)
340693af 974 fTofClusters[ii]->SetTDC(tdcCorr);
a33fec85 975 AliDebug(2,Form(" The channel time, corr (counts) = %i",fTofClusters[ii]->GetTDC()));
37879eed 976
977 } // loop on clusters
978
37879eed 979}
d08a92dd 980//______________________________________________________________________________
981
982void AliTOFClusterFinder::ResetRecpoint()
983{
984 //
985 // Clear the list of reconstructed points
986 //
987
988 fNumberOfTofClusters = 0;
989 if (fRecPoints) fRecPoints->Clear();
990
991}
992//______________________________________________________________________________
993
994void AliTOFClusterFinder::Load()
995{
996 //
997 // Load TOF.Digits.root and TOF.RecPoints.root files
998 //
999
1000 fTOFLoader->LoadDigits("READ");
1001 fTOFLoader->LoadRecPoints("recreate");
1002
1003}
1004//______________________________________________________________________________
1005
1006void AliTOFClusterFinder::LoadClusters()
1007{
1008 //
1009 // Load TOF.RecPoints.root file
1010 //
1011
1012 fTOFLoader->LoadRecPoints("recreate");
1013
1014}
1015//______________________________________________________________________________
1016
1017void AliTOFClusterFinder::UnLoad()
1018{
1019 //
1020 // Unload TOF.Digits.root and TOF.RecPoints.root files
1021 //
1022
1023 fTOFLoader->UnloadDigits();
1024 fTOFLoader->UnloadRecPoints();
1025
1026}
1027//______________________________________________________________________________
1028
1029void AliTOFClusterFinder::UnLoadClusters()
1030{
1031 //
1032 // Unload TOF.RecPoints.root file
1033 //
1034
1035 fTOFLoader->UnloadRecPoints();
1036
1037}
1038//______________________________________________________________________________