]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - TOF/AliTOFRawStream.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
bugfix: corrected URI format for local CDB initialization
[u/mrichter/AliRoot.git] / TOF / AliTOFRawStream.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$Log$
18Revision 1.19 2007/05/18 13:07:53 decaro
19Error messages stored in the global raw-reader error log (Cvetan, Chiara)
20
21Revision 1.18 2007/05/08 11:53:29 arcelli
22Improved class flexibility for further use (R.Preghenella)
23
24Revision 1.17 2007/05/03 08:53:50 decaro
25Coding convention: RS3 violation -> suppression
26
27Revision 1.16 2007/05/03 08:22:22 decaro
28Coding convention: RN17 violation -> suppression
29
30Revision 1.15 2007/04/30 15:22:06 arcelli
31Change TOF digit Time, Tot etc to int type
32
33Revision 1.14 2007/04/27 11:11:53 arcelli
34updates for the new decoder
35
36Revision 1.13 2007/03/16 11:46:35 decaro
37Coding convention: RN17 rule violation -> suppression
38
39Revision 1.12 2007/02/22 09:43:45 decaro
40Added AliTOFRawStream::GetIndex method for online calibration (C.Zampolli)
41
42Revision 1.11 2007/02/20 15:57:00 decaro
43Raw data update: to read the TOF raw data defined in UNPACKED mode
44
45Revision 1.10 2006/12/15 14:01:38 cvetan
46Memory leak fixed
47
48Revision 1.9 2006/10/13 11:22:27 arcelli
49remove warnings due to uninitialized AliTOFtdcDigit data members
50
51Revision 1.8 2006/08/22 13:30:17 arcelli
52removal of effective c++ warnings (C.Zampolli)
53
54Revision 1.7 2006/08/10 14:46:54 decaro
55TOF raw data format: updated version
56
57Revision 1.6.1 2006/06/28 A. De Caro, R. Preghenella:
58 Update TOF raw data format
59 according to the final version
60 (see the ALICE internal note in preparation
61 'ALICE TOF raw data format')
62 Added the methods for the correspoonding numbering
63 between the equipment IDs and the volume IDs:
64 Equip2VolNPlate(...)
65 Equip2VolNStrip(...)
66 Equip2VolNPad(...)
67
68Revision 0.02 2005/07/28 A. De Caro:
69 Update format TOF raw data
70 (temporary solution)
71 Correction of few wrong corrispondences
72 between 'software' and 'hardware' numberings
73
74Revision 0.01 2005/07/22 A. De Caro
75 Implement methods Next()
76 GetSector(),
77 GetPlate(),
78 GetStrip(),
79 GetPadZ(),
80 GetPadX()
81*/
82
83////////////////////////////////////////////////////////////////////////
84// //
85// This class provides access to TOF raw data in DDL files. //
86// //
87// It loops over all TOF raw data given by the AliRawReader. //
88// //
89////////////////////////////////////////////////////////////////////////
90
91
92#include "TClonesArray.h"
93
94#include "AliDAQ.h"
95#include "AliLog.h"
96#include "AliRawReader.h"
97
98#include "AliTOFGeometry.h"
99#include "AliTOFrawData.h"
100#include "AliTOFRawMap.h"
101#include "AliTOFRawStream.h"
102
103
104ClassImp(AliTOFRawStream)
105
106
107//_____________________________________________________________________________
108AliTOFRawStream::AliTOFRawStream(AliRawReader* rawReader):
109 fRawReader(rawReader),
110 // fTOFrawData(new TClonesArray("AliTOFrawData",1000)),
111 fTOFrawData(0x0),
112 fDecoder(new AliTOFDecoder()),
113 fDDL(-1),
114 fTRM(-1),
115 fTRMchain(-1),
116 fTDC(-1),
117 fTDCchannel(-1),
118 fTime(-1),
119 fToT(-1),
120 fLeadingEdge(-1),
121 fTrailingEdge(-1),
122 fErrorFlag(-1),
123 fSector(-1),
124 fPlate(-1),
125 fStrip(-1),
126 fPadX(-1),
127 fPadZ(-1),
128 fPackedDigits(0),
129 fWordType(-1),
130 fSlotID(-1),
131 fACQ(-1),
132 fPSbit(-1),
133 fTDCerrorFlag(-1),
134 fInsideDRM(kFALSE),
135 fInsideTRM(kFALSE),
136 fInsideLTM(kFALSE),
137 fInsideTRMchain0(kFALSE),
138 fInsideTRMchain1(kFALSE)
139{
140 //
141 // create an object to read TOF raw digits
142 //
143
144 for (Int_t i=0;i<AliDAQ::NumberOfDdls("TOF");i++){
145 fDataBuffer[i]=new AliTOFHitDataBuffer();
146 fPackedDataBuffer[i]=new AliTOFHitDataBuffer();
147 }
148
149 fTOFrawData = new TClonesArray("AliTOFrawData",1000);
150 fTOFrawData->SetOwner();
151
152 fRawReader->Reset();
153 fRawReader->Select("TOF");
154}
155
156//_____________________________________________________________________________
157AliTOFRawStream::AliTOFRawStream():
158 fRawReader(0x0),
159 // fTOFrawData(new TClonesArray("AliTOFrawData",1000)),
160 fTOFrawData(0x0),
161 fDecoder(new AliTOFDecoder()),
162 fDDL(-1),
163 fTRM(-1),
164 fTRMchain(-1),
165 fTDC(-1),
166 fTDCchannel(-1),
167 fTime(-1),
168 fToT(-1),
169 fLeadingEdge(-1),
170 fTrailingEdge(-1),
171 fErrorFlag(-1),
172 fSector(-1),
173 fPlate(-1),
174 fStrip(-1),
175 fPadX(-1),
176 fPadZ(-1),
177 fPackedDigits(0),
178 fWordType(-1),
179 fSlotID(-1),
180 fACQ(-1),
181 fPSbit(-1),
182 fTDCerrorFlag(-1),
183 fInsideDRM(kFALSE),
184 fInsideTRM(kFALSE),
185 fInsideLTM(kFALSE),
186 fInsideTRMchain0(kFALSE),
187 fInsideTRMchain1(kFALSE)
188{
189 //
190 // default ctr
191 //
192 for (Int_t i=0;i<AliDAQ::NumberOfDdls("TOF");i++){
193 fDataBuffer[i]=new AliTOFHitDataBuffer();
194 fPackedDataBuffer[i]=new AliTOFHitDataBuffer();
195 }
196
197 fTOFrawData = new TClonesArray("AliTOFrawData",1000);
198 fTOFrawData->SetOwner();
199}
200
201//_____________________________________________________________________________
202AliTOFRawStream::AliTOFRawStream(const AliTOFRawStream& stream) :
203 TObject(stream),
204 fRawReader(0x0),
205 // fTOFrawData(new TClonesArray("AliTOFrawData",1000)),
206 fTOFrawData(0x0),
207 fDecoder(new AliTOFDecoder()),
208 fDDL(-1),
209 fTRM(-1),
210 fTRMchain(-1),
211 fTDC(-1),
212 fTDCchannel(-1),
213 fTime(-1),
214 fToT(-1),
215 fLeadingEdge(-1),
216 fTrailingEdge(-1),
217 fErrorFlag(-1),
218 fSector(-1),
219 fPlate(-1),
220 fStrip(-1),
221 fPadX(-1),
222 fPadZ(-1),
223 fPackedDigits(0),
224 fWordType(-1),
225 fSlotID(-1),
226 fACQ(-1),
227 fPSbit(-1),
228 fTDCerrorFlag(-1),
229 fInsideDRM(kFALSE),
230 fInsideTRM(kFALSE),
231 fInsideLTM(kFALSE),
232 fInsideTRMchain0(kFALSE),
233 fInsideTRMchain1(kFALSE)
234{
235 //
236 // copy constructor
237 //
238
239 fRawReader = stream.fRawReader;
240
241 fTOFrawData = stream.fTOFrawData;
242
243 fDDL = stream.fDDL;
244 fTRM = stream.fTRM;
245 fTRMchain = stream.fTRMchain;
246 fTDC = stream.fTDC;
247 fTDCchannel = stream.fTDCchannel;
248 fTime = stream.fTime;
249 fToT = stream.fToT;
250 fLeadingEdge = stream.fLeadingEdge;
251 fTrailingEdge = stream.fTrailingEdge;
252
253 fErrorFlag = stream.fErrorFlag;
254
255 fSector = stream.fSector;
256 fPlate = stream.fPlate;
257 fStrip = stream.fStrip;
258 fPadX = stream.fPadX;
259 fPadZ = stream.fPadZ;
260
261 fPackedDigits = stream.fPackedDigits;
262
263 fWordType = stream.fWordType;
264 fSlotID = stream.fSlotID;
265 fACQ = stream.fACQ;
266 fPSbit = stream.fPSbit;
267 fTDCerrorFlag = stream.fTDCerrorFlag;
268 fInsideDRM = stream.fInsideDRM;
269 fInsideTRM = stream.fInsideTRM;
270 fInsideLTM = stream.fInsideLTM;
271 fInsideTRMchain0 = stream.fInsideTRMchain0;
272 fInsideTRMchain1 = stream.fInsideTRMchain1;
273
274 for (Int_t i=0;i<AliDAQ::NumberOfDdls("TOF");i++){
275 fDataBuffer[i]= new AliTOFHitDataBuffer(*stream.fDataBuffer[i]);
276 fPackedDataBuffer[i]= new AliTOFHitDataBuffer(*stream.fPackedDataBuffer[i]);
277 }
278
279 fTOFrawData = new TClonesArray(*stream.fTOFrawData);
280
281}
282
283//_____________________________________________________________________________
284AliTOFRawStream& AliTOFRawStream::operator = (const AliTOFRawStream& stream)
285{
286 //
287 // assignment operator
288 //
289
290 fRawReader = stream.fRawReader;
291
292 fTOFrawData = stream.fTOFrawData;
293
294 fDDL = stream.fDDL;
295 fTRM = stream.fTRM;
296 fTRMchain = stream.fTRMchain;
297 fTDC = stream.fTDC;
298 fTDCchannel = stream.fTDCchannel;
299 fTime = stream.fTime;
300 fToT = stream.fToT;
301 fLeadingEdge = stream.fLeadingEdge;
302 fTrailingEdge = stream.fTrailingEdge;
303 fErrorFlag = stream.fErrorFlag;
304
305 fSector = stream.fSector;
306 fPlate = stream.fPlate;
307 fStrip = stream.fStrip;
308 fPadX = stream.fPadX;
309 fPadZ = stream.fPadZ;
310
311 fPackedDigits = stream.fPackedDigits;
312
313 fWordType = stream.fWordType;
314 fSlotID = stream.fSlotID;
315 fACQ = stream.fACQ;
316 fPSbit = stream.fPSbit;
317 fTDCerrorFlag = stream.fTDCerrorFlag;
318 fInsideDRM = stream.fInsideDRM;
319 fInsideTRM = stream.fInsideTRM;
320 fInsideLTM = stream.fInsideLTM;
321 fInsideTRMchain0 = stream.fInsideTRMchain0;
322 fInsideTRMchain1 = stream.fInsideTRMchain1;
323
324 for (Int_t i=0;i<AliDAQ::NumberOfDdls("TOF");i++){
325 fDataBuffer[i] = stream.fDataBuffer[i];
326 fPackedDataBuffer[i] = stream.fPackedDataBuffer[i];
327 }
328
329 fTOFrawData = stream.fTOFrawData;
330
331 return *this;
332
333}
334
335//_____________________________________________________________________________
336AliTOFRawStream::~AliTOFRawStream()
337{
338// destructor
339
340 fPackedDigits = 0;
341
342 for (Int_t i=0;i<72;i++){
343 delete fDataBuffer[i];
344 delete fPackedDataBuffer[i];
345 }
346
347 delete fDecoder;
348
349 fTOFrawData->Clear();
350 delete fTOFrawData;
351}
352
353
354//_____________________________________________________________________________
355
356void AliTOFRawStream::LoadRawData(Int_t indexDDL)
357{
358
359 /*
360 for (Int_t indexDDL = 0;
361 indexDDL < AliDAQ::NumberOfDdls("TOF");
362 indexDDL++) {
363 */
364
365 fTOFrawData = new TClonesArray("AliTOFrawData",1000); //potential memory leak
366 //fTOFrawData->Clear();
367 fPackedDigits = 0;
368
369 // create raw data map
370 AliTOFRawMap *rawMap = new AliTOFRawMap(fTOFrawData);
371 rawMap->Clear();
372
373 Int_t slot[4] = {-1, -1, -1, -1};
374
375 fRawReader->Reset();
376 fRawReader->Select("TOF", indexDDL, indexDDL);
377
378 Bool_t signal = kFALSE;
379
380
381
382 while(Next()) {
383
384 signal = (fSector!=-1 && fPlate!=-1 && fStrip!=-1 && fPadZ!=-1 && fPadX!=-1);
385 if (signal) {
386 //printf(" %2i %1i %2i %1i %2i \n", fSector, fPlate, fStrip, fPadZ, fPadX);
387
388 slot[0] = fTRM;
389 slot[1] = fTRMchain;
390 slot[2] = fTDC;
391 slot[3] = fTDCchannel;
392
393 if (rawMap->TestHit(slot) != kEmpty) {
394
395 AliTOFrawData *rawDigit = static_cast<AliTOFrawData*>(rawMap->GetHit(slot));
396
397 if (rawDigit->GetLeading()!=-1 && rawDigit->GetTrailing()==-1 &&
398 fLeadingEdge==-1 && fTrailingEdge!=-1) {
399
400 rawDigit->Update(fTime, fToT, fLeadingEdge, fTrailingEdge, fPSbit, fACQ, fErrorFlag);
401 }
402 else if ( ((rawDigit->GetTOF()!=-1 || rawDigit->GetLeading()!=-1 || rawDigit->GetTrailing()!=-1) &&
403 (fLeadingEdge!=-1 || fTrailingEdge!=-1 || fTime!=-1) )
404
405/* else if ( ((rawDigit->GetTOF()!=-1 || rawDigit->GetLeading()!=-1 || rawDigit->GetTrailing()!=-1) &&
406 (fTime!=-1 || fLeadingEdge!=-1 || fTrailingEdge!=-1))*/ /*||
407 (rawDigit->GetLeading()==-1 && rawDigit->GetTrailing()!=-1 &&
408 fLeadingEdge!=-1 && fTrailingEdge==-1) */)
409 {
410
411 TClonesArray &arrayTofRawData = *fTOFrawData;
412 new (arrayTofRawData[fPackedDigits++]) AliTOFrawData(fTRM, fTRMchain, fTDC, fTDCchannel, fTime, fToT, fLeadingEdge, fTrailingEdge, fPSbit, fACQ, fErrorFlag);
413
414 rawMap->SetHit(slot);
415
416 }
417
418
419 }
420 else {
421
422 TClonesArray &arrayTofRawData = *fTOFrawData;
423 new (arrayTofRawData[fPackedDigits++]) AliTOFrawData(fTRM, fTRMchain, fTDC, fTDCchannel, fTime, fToT, fLeadingEdge, fTrailingEdge, fPSbit, fACQ, fErrorFlag);
424
425 rawMap->SetHit(slot);
426
427 } // else if (rawMap->TestHit(slot) == kEmpty)
428
429 } // if (signal)
430
431 } // closed -> while (Next())
432
433 /*
434 fDDL = fRawReader->GetDDLID();
435
436 for (Int_t ii=0; ii<fTOFrawData->GetEntriesFast(); ii++) {
437
438 AliTOFrawData *dummy = (AliTOFrawData*)fTOFrawData->UncheckedAt(ii);
439
440 fTRM = dummy->GetTRM();
441 fTRMchain = dummy->GetTRMchain();
442 fTDC = dummy->GetTDC();
443 fTDCchannel = dummy->GetTDCchannel();
444
445 SetSector();
446 SetPlate();
447 SetStrip();
448 SetPadZ();
449 SetPadX();
450
451 printf(" %2i, %2i %1i, %2i, %1i --> %2i, %1i, %2i, %1i, %2i \n",
452 fDDL, fTRM, fTRMchain, fTDC, fTDCchannel,
453 fSector, fPlate, fStrip, fPadZ, fPadX);
454
455 } // closed loop on TOF raw data TClonesArray
456 */
457
458 //} // closed loop on indexDDL
459
460
461
462}
463
464//_____________________________________________________________________________
465Bool_t AliTOFRawStream::Next()
466{
467 //
468 // Read next 32-bit word in TOF raw data files
469 // returns kFALSE if there is no word left
470 //
471
472 UInt_t data;
473
474 if (!fRawReader->ReadNextInt(data)) return kFALSE;
475
476 if (fSector!=-1 && fPlate!=-1 && fStrip!=-1 && fPadZ!=-1 && fPadX!=-1) {
477 fSector = -1;
478 fPlate = -1;
479 fStrip = -1;
480 fPadZ = -1;
481 fPadX = -1;
482 fTime = -1;
483 fToT = -1;
484 fLeadingEdge = -1;
485 fTrailingEdge = -1;
486 }
487
488 fDDL = fRawReader->GetDDLID();
489
490 fWordType = GetField(data,WORD_TYPE_MASK,WORD_TYPE_POSITION);
491
492 switch (fWordType) { // switch word type
493
494 case GLOBAL_HEADER_TYPE: // global header
495 fSlotID = GetField(data, HEADER_SLOT_ID_MASK, HEADER_SLOT_ID_POSITION);
496 fTRM = fSlotID;
497
498
499 switch (fSlotID) { // switch global header slot ID
500
501 case DRM_ID_NUMBER: //DRM global header
502 if (fInsideDRM) { // unexpected DRM global headers -> exit
503 break;
504 }
505 fInsideDRM = kTRUE; // DRM global header accepted
506 break;
507
508 case LTM_ID_NUMBER: // LTM global header
509 if (fInsideLTM) { // unexpected LTM global headers -> exit
510 break;
511 }
512 fInsideLTM = kTRUE; // LTM global header accepted
513 break;
514
515 case 3: //TRM header
516 case 4: //TRM header
517 case 5: //TRM header
518 case 6: //TRM header
519 case 7: //TRM header
520 case 8: //TRM header
521 case 9: //TRM header
522 case 10: //TRM header
523 case 11: //TRM header
524 case 12: //TRM header
525 if (fInsideTRM) { // unexpected TRM global headers -> exit
526 break;
527 }
528 fInsideTRM = kTRUE; // TRM global header accepted
529 fACQ = GetField(data,TRM_ACQ_BITS_MASK,TRM_ACQ_BITS_POSITION);
530 break;
531
532 default: // unexpected global header slot ID
533 break;
534
535 } //end switch global header slot id
536
537 break;
538
539
540 case GLOBAL_TRAILER_TYPE: // global trailer
541 fSlotID = GetField(data,HEADER_SLOT_ID_MASK,HEADER_SLOT_ID_POSITION);
542
543
544 switch (fSlotID) { // switch global trailer slot ID
545
546 case DRM_ID_NUMBER: // DRM global trailer
547 if (!fInsideDRM) { // unexpected DRM global trailers -> exit
548 break;
549 }
550 fInsideDRM = kFALSE; // DRM global trailer accepted
551 fInsideTRM = kFALSE;
552 fInsideLTM = kFALSE;
553 fInsideTRMchain0 = kFALSE;
554 fInsideTRMchain1 = kFALSE;
555 fSector = -1;
556 fPlate = -1;
557 fStrip = -1;
558 fPadZ = -1;
559 fPadX = -1;
560 fDDL = -1;
561 fTRM = -1;
562 fTDC = -1;
563 fTRMchain = -1;
564 fTDCchannel = -1;
565 fTime = -1;
566 fToT = -1;
567 fLeadingEdge = -1;
568 fTrailingEdge = -1;
569 fErrorFlag = -1;
570 fACQ = -1;
571 fPSbit = -1;
572 fTDCerrorFlag = -1;
573 break;
574 case LTM_ID_NUMBER: // LTM global trailer
575 if (!fInsideLTM) { // unexpected LTM global trailer -> exit
576 break;
577 }
578 fInsideLTM = kFALSE; // LTM global trailer accepted
579 break;
580 case 15: //TRM global trailer
581 if (!fInsideTRM) { // unexpected TRM global trailers -> exit
582 break;
583 }
584 fInsideTRM = kFALSE; // TRM global trailer accepted
585 break;
586 default: // unexpected global trailer slot ID
587 break;
588 } //end switch global trailer slot id
589
590
591 break;
592
593
594 case ERROR_TYPE: // TDC error
595 fTDC = GetField(data,TRM_TDC_ERROR_TDC_ID_MASK,TRM_TDC_ERROR_TDC_ID_POSITION);
596 fTDCerrorFlag = GetField(data,TRM_TDC_ERROR_FLAGS_MASK,TRM_TDC_ERROR_FLAGS_POSITION);
597 break;
598
599
600 case FILLER_TYPE: // filler
601 break;
602
603
604 default: // other word types
605
606 if (fInsideTRM) { // inside TRM
607
608 switch (fWordType) { // switch word type inside TRM
609 case TRM_CHAIN0_HEADER_TYPE: // TRM chain0 header
610 if (fInsideTRMchain0) { // unexpected TRM chain0 header
611 break;
612 }
613 fInsideTRMchain0 = kTRUE;
614 fTRMchain = 0;
615 break;
616 case TRM_CHAIN0_TRAILER_TYPE: // TRM chain0 trailer
617 if (!fInsideTRMchain0) { // unexpected TRM chain0 trailer
618 break;
619 }
620 fInsideTRMchain0 = kFALSE;
621 fTRMchain = -1;
622 break;
623 case TRM_CHAIN1_HEADER_TYPE: // TRM chain1 header
624 if (fInsideTRMchain1) { // unexpected TRM chain1 header
625 break;
626 }
627 fInsideTRMchain1 = kTRUE;
628 fTRMchain = 1;
629 break;
630 case TRM_CHAIN1_TRAILER_TYPE: // TRM chain1 trailer
631 if (!fInsideTRMchain1) { // unexpected TRM chain1 trailer
632 break;
633 }
634 fInsideTRMchain1 = kFALSE;
635 fTRMchain = -1;
636 break;
637 } // end switch word type inside TRM
638
639 } // end if (fInsideTRM)
640
641
642 if (
643 ((fInsideTRMchain0&&!fInsideTRMchain1) || (!fInsideTRMchain0&&fInsideTRMchain1))
644 && fWordType!=TRM_CHAIN0_HEADER_TYPE && fWordType!=TRM_CHAIN0_TRAILER_TYPE
645 && fWordType!=TRM_CHAIN1_HEADER_TYPE && fWordType!=TRM_CHAIN1_TRAILER_TYPE
646 ){ // inside TRM chains
647
648 fPSbit = GetField(data,TRM_PS_BITS_MASK,TRM_PS_BITS_POSITION);
649 fTDC = GetField(data,TRM_TDC_ID_MASK,TRM_TDC_ID_POSITION);
650 fTDCchannel = GetField(data,TRM_CHAN_MASK,TRM_CHAN_POSITION);
651 fErrorFlag = GetField(data,TRM_E_BIT_MASK,TRM_E_BIT_POSITION);
652
653 SetSector();
654 SetPlate();
655 SetStrip();
656 SetPadZ();
657 SetPadX();
658
659
660 switch (fPSbit) { // switch fPSbit bits inside TRM chains
661
662 case 0: // packing ok, digit time and TOT
663 fToT = GetField(data,TRM_TOT_WIDTH_MASK, TRM_TOT_WIDTH_POSITION);
664 fTime = GetField(data,TRM_DIGIT_TIME_MASK,TRM_DIGIT_TIME_POSITION);
665 break;
666
667 case 1: // leading edge digit, long digit time, no TOT
668 //fToT = -1;
669 //fTime = -1;
670 fLeadingEdge = GetField(data,TRM_LONG_DIGIT_TIME_MASK,TRM_LONG_DIGIT_TIME_POSITION);
671 break;
672
673 case 2: // trailing edge digit, long digit time, no TOT
674 //fToT = -1;
675 //fTime = -1;
676 fTrailingEdge = GetField(data,TRM_LONG_DIGIT_TIME_MASK,TRM_LONG_DIGIT_TIME_POSITION);
677 break;
678
679 case 3: // TOT overflow
680 fToT = GetField(data,TRM_TOT_WIDTH_MASK, TRM_TOT_WIDTH_POSITION);
681 fTime = GetField(data,TRM_DIGIT_TIME_MASK,TRM_DIGIT_TIME_POSITION);
682 break;
683
684 } // end switch PS bits inside TRM chains
685
686 } // end if is inside TRM chains
687
688 } // end switch on fWordType
689
690
691 return kTRUE;
692
693}
694//_____________________________________________________________________________
695
696void AliTOFRawStream::SetSector()
697{
698 //
699 // Evaluate the TOF sector number -> [ 0;17]
700 // corresponding to the TOF equipment IDs:
701 // fDDL -> [ 0;71]
702 // fTRM -> [ 3;12]
703 // fTRMchain -> [ 0; 1]
704 // fTDC -> [ 0;14]
705 // fTDCchannel -> [ 0; 7]
706 //
707
708 Int_t iSector = -1;
709
710 if (!(fDDL==-1)) iSector = Int_t((Float_t)(fDDL)/AliTOFGeometry::NDDL());
711
712 fSector = iSector;
713
714}
715//_____________________________________________________________________________
716
717
718void AliTOFRawStream::SetPlate()
719{
720 //
721 // Evaluate the TOF plate number ->[ 0; 4]
722 // corresponding to the TOF equipment IDs:
723 // fDDL -> [ 0;71]
724 // fTRM -> [ 3;12]
725 // fTRMchain -> [ 0; 1]
726 // fTDC -> [ 0;14]
727 // fTDCchannel -> [ 0; 7]
728 //
729
730 Int_t iPlate = -1;
731 if (!(fDDL==-1 || fTRM==-1 || fTDC==-1
732 || fSector==-1))
733 iPlate = Equip2VolNplate(GetDDLnumberPerSector(fDDL), fTRM, fTDC);
734
735 fPlate = iPlate;
736
737}
738//_____________________________________________________________________________
739
740void AliTOFRawStream::SetStrip()
741{
742 //
743 // Evaluate the TOF strip number per module -> [ 0; 14/18]
744 // corresponding to the TOF equipment IDs:
745 // fDDL -> [ 0;71]
746 // fTRM -> [ 3;12]
747 // fTRMchain -> [ 0; 1]
748 // fTDC -> [ 0;14]
749 // fTDCchannel -> [ 0; 7]
750 //
751
752 Int_t iStrip = -1;
753
754 if (!(fDDL==-1 || fTRM==-1 || fTDC==-1
755 || fSector==-1 || fPlate==-1))
756 iStrip = Equip2VolNstrip(GetDDLnumberPerSector(fDDL), fTRM, fTDC);
757
758 fStrip = iStrip;
759
760}
761//_____________________________________________________________________________
762
763void AliTOFRawStream::SetPadZ()
764{
765 //
766 // Evaluate the TOF padRow number per strip -> [ 0; 1]
767 // corresponding to the TOF equipment IDs:
768 // fDDL -> [ 0;71]
769 // fTRM -> [ 3;12]
770 // fTRMchain -> [ 0; 1]
771 // fTDC -> [ 0;14]
772 // fTDCchannel -> [ 0; 7]
773 //
774
775 Int_t iPadZ = -1;
776
777 if (!(fDDL==-1 || fTRM==-1 || fTRMchain==-1 || fTDC==-1 || fTDCchannel==-1
778 || fSector==-1 || fPlate==-1 || fStrip==-1))
779 {
780 Int_t iPadAlongTheStrip = Equip2VolNpad(GetDDLnumberPerSector(fDDL), fTRMchain, fTDC, fTDCchannel);
781 if (iPadAlongTheStrip!=-1)
782 iPadZ = iPadAlongTheStrip%AliTOFGeometry::NpadZ();
783 }
784
785 fPadZ = iPadZ;
786
787}
788//_____________________________________________________________________________
789
790void AliTOFRawStream::SetPadX()
791{
792 //
793 // Evaluate the TOF pad number per strip padRow -> [ 0;47]
794 // corresponding to the TOF equipment IDs:
795 // fDDL -> [ 0;71]
796 // fTRM -> [ 3;12]
797 // fTRMchain -> [ 0; 1]
798 // fTDC -> [ 0;14]
799 // fTDCchannel -> [ 0; 7]
800 //
801
802 Int_t iPadX = -1;
803
804 if (!(fDDL==-1 || fTRM==-1 || fTRMchain==-1 || fTDC==-1 || fTDCchannel==-1
805 || fSector==-1 || fPlate==-1 || fStrip==-1))
806 {
807 Int_t iPadAlongTheStrip = Equip2VolNpad(GetDDLnumberPerSector(fDDL), fTRMchain, fTDC, fTDCchannel);
808 if (iPadAlongTheStrip!=-1)
809 iPadX = (Int_t)(iPadAlongTheStrip/(Float_t(AliTOFGeometry::NpadZ())));
810 }
811
812 fPadX = iPadX;
813
814}
815
816//----------------------------------------------------------------------------
817Int_t AliTOFRawStream::GetField(UInt_t word, Int_t fieldMask, Int_t fieldPosition) const
818{
819 //
820 //
821 //
822
823 return ((word & fieldMask) >> fieldPosition);
824}
825
826//----------------------------------------------------------------------------
827Int_t AliTOFRawStream::Equip2VolNplate(Int_t iDDL, Int_t nTRM, Int_t nTDC) const
828{
829 //
830 // Returns the TOF plate number [0;4]
831 // corresponding to the TOF equipment ID numbers:
832 // iDDL -> DDL number per sector [0;3]
833 // nTRM -> TRM number [3;12]
834 // nTDC -> TDC number [0;14]
835 //
836
837 Int_t iPlate = -1;
838 if (iDDL==0) {
839
840 if (nTRM>=4 && nTRM<7) {
841 iPlate = 0;
842 } else if (nTRM==7) {
843 if (nTDC<12) iPlate = 0;
844 else iPlate = 1;
845 } else if (nTRM>=8 && nTRM<11) {
846 iPlate = 1;
847 } else if (nTRM==11) {
848 if (nTDC<9) iPlate = 1;
849 else iPlate = 2;
850 }else if (nTRM==12) {
851 iPlate = 2;
852 }
853
854 } else if (iDDL==1) {
855
856 if (nTRM==3) {
857 if (nTDC<3) iPlate = 0;
858 } else if (nTRM>=4 && nTRM<7) {
859 iPlate = 0;
860 } else if (nTRM==7) {
861 if (nTDC<6) iPlate = 1;
862 else iPlate = 0;
863 } else if (nTRM>=8 && nTRM<11) {
864 iPlate = 1;
865 } else if (nTRM==11) {
866 if (nTDC<9) iPlate = 2;
867 else iPlate = 1;
868 } else if (nTRM==12) {
869 iPlate = 2;
870 }
871
872 } else if (iDDL==2) {
873
874 if (nTRM>=4 && nTRM<7) {
875 iPlate = 4;
876 } else if (nTRM==7) {
877 if (nTDC<12) iPlate = 4;
878 else iPlate = 3;
879 } else if (nTRM>=8 && nTRM<11) {
880 iPlate = 3;
881 } else if (nTRM==11) {
882 if (nTDC<9) iPlate = 3;
883 else iPlate = 2;
884 }else if (nTRM==12) {
885 iPlate = 2;
886 }
887
888 } else if (iDDL==3) {
889
890 if (nTRM==3) {
891 if (nTDC<3) iPlate = 4;
892 } else if (nTRM>=4 && nTRM<7) {
893 iPlate = 4;
894 } else if (nTRM==7) {
895 if (nTDC<6) iPlate = 3;
896 else iPlate = 4;
897 } else if (nTRM>=8 && nTRM<11) {
898 iPlate = 3;
899 } else if (nTRM==11) {
900 if (nTDC<9) iPlate = 2;
901 else iPlate = 3;
902 } else if (nTRM==12) {
903 iPlate = 2;
904 }
905
906 }
907
908 return iPlate;
909
910}
911
912//----------------------------------------------------------------------------
913Int_t AliTOFRawStream::Equip2VolNstrip(Int_t iDDL, Int_t nTRM, Int_t nTDC) const
914{
915 //
916 // Returns the TOF strip number per module:
917 // [0;14], in the central plates,
918 // [0;18], in the intermediate and external plates
919 // corresponding to the TOF equipment ID numbers:
920 // iDDL -> DDL number per sector [0;3]
921 // nTRM -> TRM number [3;12]
922 // nTDC -> TDC number [0;14]
923 //
924
925 Int_t iStrip = -1;
926
927 if (iDDL==0) {
928
929 if (nTRM== 4) iStrip = (Int_t)(nTDC/3.);
930 else if (nTRM== 5) iStrip = 5 + (Int_t)(nTDC/3.);
931 else if (nTRM== 6) iStrip = 10 + (Int_t)(nTDC/3.);
932 else if (nTRM== 7) {
933 if (nTDC<12) iStrip = 15 + (Int_t)(nTDC/3.);
934 else iStrip = (Int_t)(nTDC/3.) - 4;
935 }
936 else if (nTRM== 8) iStrip = 1 + (Int_t)(nTDC/3.);
937 else if (nTRM== 9) iStrip = 6 + (Int_t)(nTDC/3.);
938 else if (nTRM==10) iStrip = 11 + (Int_t)(nTDC/3.);
939 else if (nTRM==11) {
940 if (nTDC<9) iStrip = 16 + (Int_t)(nTDC/3.);
941 else iStrip = (Int_t)(nTDC/3.) - 3;
942 }
943 else if (nTRM==12) iStrip = 2 + (Int_t)(nTDC/3.);
944
945 } else if (iDDL==1) {
946
947 if (nTRM==3 && nTDC<3) iStrip = (Int_t)(nTDC/3.);
948 else if (nTRM== 4) iStrip = 5 - (Int_t)(nTDC/3.);
949 else if (nTRM== 5) iStrip = 10 - (Int_t)(nTDC/3.);
950 else if (nTRM== 6) iStrip = 15 - (Int_t)(nTDC/3.);
951 else if (nTRM== 7) {
952 if (nTDC<6) iStrip = 1 - (Int_t)(nTDC/3.);
953 else iStrip = 20 - (Int_t)(nTDC/3.);
954 }
955 else if (nTRM== 8) iStrip = 6 - (Int_t)(nTDC/3.);
956 else if (nTRM== 9) iStrip = 11 - (Int_t)(nTDC/3.);
957 else if (nTRM==10) iStrip = 16 - (Int_t)(nTDC/3.);
958 else if (nTRM==11) {
959 if (nTDC<9) iStrip = 2 - (Int_t)(nTDC/3.);
960 else iStrip = 21 - (Int_t)(nTDC/3.);
961 }
962 else if (nTRM==12) iStrip = 7 - (Int_t)(nTDC/3.);
963
964 } else if (iDDL==2) {
965
966 if (nTRM== 4) iStrip = 18 - (Int_t)(nTDC/3.);
967 else if (nTRM== 5) iStrip = 18 - ( 5 + (Int_t)(nTDC/3.));
968 else if (nTRM== 6) iStrip = 18 - (10 + (Int_t)(nTDC/3.));
969 else if (nTRM== 7) {
970 if (nTDC<12) iStrip = 18 - (15 + (Int_t)(nTDC/3.));
971 else iStrip = 18 - ((Int_t)(nTDC/3.) - 4);
972 }
973 else if (nTRM== 8) iStrip = 18 - ( 1 + (Int_t)(nTDC/3.));
974 else if (nTRM== 9) iStrip = 18 - ( 6 + (Int_t)(nTDC/3.));
975 else if (nTRM==10) iStrip = 18 - (11 + (Int_t)(nTDC/3.));
976 else if (nTRM==11) {
977 if (nTDC<9) iStrip = 18 - (16 + (Int_t)(nTDC/3.));
978 else iStrip = 14 - ((Int_t)(nTDC/3.) - 3);
979 }
980 else if (nTRM==12) iStrip = 14 - ( 2 + (Int_t)(nTDC/3.));
981
982 } else if (iDDL==3) {
983
984 if (nTRM==3 && nTDC<3) iStrip = 18 - (Int_t)(nTDC/3.);
985 else if (nTRM== 4) iStrip = 18 - ( 5 - (Int_t)(nTDC/3.));
986 else if (nTRM== 5) iStrip = 18 - (10 - (Int_t)(nTDC/3.));
987 else if (nTRM== 6) iStrip = 18 - (15 - (Int_t)(nTDC/3.));
988 else if (nTRM== 7) {
989 if (nTDC<6) iStrip = 18 - (1 - (Int_t)(nTDC/3.));
990 else iStrip = 18 - (20 - (Int_t)(nTDC/3.));
991 }
992 else if (nTRM== 8) iStrip = 18 - ( 6 - (Int_t)(nTDC/3.));
993 else if (nTRM== 9) iStrip = 18 - (11 - (Int_t)(nTDC/3.));
994 else if (nTRM==10) iStrip = 18 - (16 - (Int_t)(nTDC/3.));
995 else if (nTRM==11) {
996 if (nTDC<9) iStrip = 14 - ( 2 - (Int_t)(nTDC/3.));
997 else iStrip = 18 - (21 - (Int_t)(nTDC/3.));
998 }
999 else if (nTRM==12) iStrip = 14 - ( 7 - (Int_t)(nTDC/3.));
1000
1001 }
1002
1003 return iStrip;
1004
1005}
1006
1007//----------------------------------------------------------------------------
1008Int_t AliTOFRawStream::Equip2VolNpad(Int_t iDDL, Int_t iChain, Int_t nTDC,
1009 Int_t iCH) const
1010{
1011 //
1012 // Returns the TOF pad number per strip [0;95]
1013 // corresponding to the TOF equipment ID numbers:
1014 // iDDL -> DDL number per sector [0;3]
1015 // iChain -> TRM chain number [0;1]
1016 // nTDC -> TDC number [0;14]
1017 // iCH -> TDC channel number [0;7]
1018 //
1019
1020 Int_t iPadAlongTheStrip = -1;
1021
1022 Int_t iTDClocal = nTDC%3 + (1-iChain)*3;
1023
1024 if (iDDL==0 || iDDL==3) iTDClocal = 5 - iTDClocal;
1025 else if (iDDL==1 || iDDL==2) iTDClocal = 6 + (5 - iTDClocal);
1026
1027 Int_t iCHlocal = iCH;
1028 if (iDDL==0 || iDDL==3) iCHlocal = 7 - iCH;
1029
1030 iPadAlongTheStrip = iTDClocal*AliTOFGeometry::NCh() + iCHlocal;
1031
1032 if (((iDDL==1 || iDDL==2) && iPadAlongTheStrip< AliTOFGeometry::NpadX()) ||
1033 ((iDDL==0 || iDDL==3) && iPadAlongTheStrip>=AliTOFGeometry::NpadX())) {
1034 fRawReader->AddMajorErrorLog(kPadXError);
1035 AliWarning("Problems with the padX number!");
1036 }
1037 return iPadAlongTheStrip;
1038
1039}
1040
1041//----------------------------------------------------------------------------
1042Int_t AliTOFRawStream::GetSectorNumber(Int_t nDDL) const
1043{
1044 //
1045 // Returns the sector number [0;17]
1046 // corresponing to the assigned DRM/DDL number [0;71]
1047 //
1048
1049 Int_t iSector = Int_t((Float_t)(nDDL)/AliTOFGeometry::NDDL());
1050
1051 return iSector;
1052
1053}
1054//----------------------------------------------------------------------------
1055Int_t AliTOFRawStream::GetDDLnumberPerSector(Int_t nDDL) const
1056{
1057 //
1058 // Return the DRM/DDL number per sector [0;3]
1059 // corresponing to the assigned DRM/DDL number [0;71]
1060 //
1061
1062 Int_t iDDL = nDDL%AliTOFGeometry::NDDL();
1063
1064 return iDDL;
1065
1066}
1067
1068//----------------------------------------------------------------------------
1069void AliTOFRawStream::EquipmentId2VolumeId(AliTOFHitData *hitData, Int_t *volume) const
1070{
1071 EquipmentId2VolumeId(hitData->GetDDLID(),hitData->GetSlotID(),hitData->GetChain(),hitData->GetTDC(),hitData->GetChan(),volume);
1072}
1073//----------------------------------------------------------------------------
1074void AliTOFRawStream::EquipmentId2VolumeId(Int_t nDDL, Int_t nTRM, Int_t iChain,
1075 Int_t nTDC, Int_t iCH,
1076 Int_t *volume) const
1077{
1078 //
1079 // To convert:
1080 // nDDL (variable in [0;71]) -> number of the DDL file
1081 // nTRM (variable in [3;12]) -> number of the TRM slot
1082 // iChain (variable in [0; 1]) -> number of the TRM chain
1083 // nTDC (variable in [0;14]) -> number of the TDC
1084 // iCH (variable in [0; 7]) -> number of the TDC channel
1085 //
1086 // in:
1087 // sector number, i.e. volume[0] (variable in [0,17])
1088 // plate number, i.e. volume[1] (variable in [0, 5])
1089 // strip number, i.e. volume[2] (variable in [0,14/18])
1090 // padX number, i.e. volume[3] (variable in [0,47])
1091 // padZ number, i.e. volume[4] (variable in [0, 1])
1092 //
1093
1094 Int_t iDDL = GetDDLnumberPerSector(nDDL);
1095
1096 Int_t iSector = GetSectorNumber(nDDL);
1097
1098 Int_t iPlate = Equip2VolNplate(iDDL, nTRM, nTDC);
1099 if (iPlate==-1) {
1100 fRawReader->AddMajorErrorLog(kPlateError,"plate = -1");
1101 AliWarning("Problems with the plate number!");
1102 }
1103
1104 Int_t iStrip = Equip2VolNstrip(iDDL, nTRM, nTDC);
1105 if (iStrip==-1) {
1106 fRawReader->AddMajorErrorLog(kStripError,"strip = -1");
1107 AliWarning("Problems with the strip number!");
1108 }
1109
1110 Int_t iPadAlongTheStrip = Equip2VolNpad(iDDL, iChain, nTDC, iCH);
1111 if (iPadAlongTheStrip==-1){
1112 fRawReader->AddMajorErrorLog(kPadAlongStripError,"pad = -1");
1113 AliWarning("Problems with the pad number along the strip!");
1114 }
1115
1116 Int_t iPadX = (Int_t)(iPadAlongTheStrip/(Float_t(AliTOFGeometry::NpadZ())));
1117 Int_t iPadZ = iPadAlongTheStrip%AliTOFGeometry::NpadZ();
1118
1119 volume[0] = iSector;
1120 volume[1] = iPlate;
1121 volume[2] = iStrip;
1122 volume[3] = iPadX;
1123 volume[4] = iPadZ;
1124
1125}
1126//-----------------------------------------------------------------------------
1127Bool_t AliTOFRawStream::DecodeDDL(Int_t nDDLMin, Int_t nDDLMax, Int_t verbose = 0) {
1128 //
1129 // To decode raw data for DDL number in [nDDLmin; nDDLmax]
1130 //
1131
1132 //check and fix valid DDL range
1133 if (nDDLMin < 0){
1134 nDDLMin = 0;
1135 fRawReader->AddMinorErrorLog(kDDLMinError);
1136 AliWarning("Wrong DDL range: setting first DDL ID to 0");
1137 }
1138 if (nDDLMax > 71){
1139 nDDLMax = 71;
1140 fRawReader->AddMinorErrorLog(kDDLMaxError);
1141 AliWarning("Wrong DDL range: setting last DDL ID to 71");
1142 }
1143
1144 //select required DDLs
1145 fRawReader->Select("TOF", nDDLMin, nDDLMax);
1146
1147 if (verbose)
1148 AliInfo(Form("Selected TOF DDL range: %d-%d", nDDLMin, nDDLMax));
1149
1150 return(Decode(verbose));
1151}
1152//-----------------------------------------------------------------------------
1153Bool_t AliTOFRawStream::Decode(Int_t verbose = 0) {
1154 //
1155 // New decoder method
1156 //
1157
1158 Int_t currentEquipment;
1159 Int_t currentDDL;
1160
1161 //pointers
1162 UChar_t *data = 0x0;
1163
1164 //loop and read DDL headers
1165 while(fRawReader->ReadHeader()){
1166
1167 //memory leak prevention (actually data should be always 0x0 here)
1168 if (data != 0x0)
1169 delete [] data;
1170
1171 //get equipment infos
1172 currentEquipment = fRawReader->GetEquipmentId();
1173 currentDDL = fRawReader->GetDDLID();
1174 const Int_t kDataSize = fRawReader->GetDataSize();
1175 const Int_t kDataWords = kDataSize / 4;
1176 data = new UChar_t[kDataSize];
1177
1178 if (verbose)
1179 AliInfo(Form("Found equipment # %d header (DDL # %d): %d bytes (%d words)", currentEquipment, currentDDL, kDataSize, kDataWords));
1180
1181 if (verbose)
1182 AliInfo(Form("Reading equipment #%d (DDL # %d) data...", currentEquipment, currentDDL));
1183
1184 //read equipment payload
1185 if (!fRawReader->ReadNext(data, kDataSize))
1186 {
1187 fRawReader->AddMajorErrorLog(kDDLdataReading);
1188 if (verbose)
1189 AliWarning("Error while reading DDL data. Go to next equipment");
1190 delete [] data;
1191 data = 0x0;
1192 continue;
1193 }
1194
1195 if (verbose)
1196 AliInfo(Form("Equipment # %d (DDL # %d) data has been readed", currentEquipment, currentDDL));
1197
1198
1199 //set up the decoder
1200 fDecoder->SetVerbose(verbose);
1201 fDecoder->SetDataBuffer(fDataBuffer[currentDDL]);
1202 fDecoder->SetPackedDataBuffer(fPackedDataBuffer[currentDDL]);
1203
1204 //start decoding
1205 if (fDecoder->Decode((UInt_t *)data, kDataWords) == kTRUE) {
1206 fRawReader->AddMajorErrorLog(kDDLDecoder,Form("DDL # = %d",currentDDL));
1207 AliWarning(Form("Error while decoding DDL # %d: decoder returned with errors", currentDDL));
1208 }
1209
1210 delete [] data;
1211 data = 0x0;
1212 }
1213
1214 //reset reader
1215 fRawReader->Reset();
1216
1217 if (verbose)
1218 AliInfo("All done");
1219
1220 return kFALSE;
1221
1222}
1223//---------------------------------------------------------------------------
1224void
1225AliTOFRawStream::ResetBuffers()
1226{
1227 //
1228 // To reset the buffers
1229 //
1230
1231 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls("TOF"); iDDL++){
1232 ResetDataBuffer(iDDL);
1233 ResetPackedDataBuffer(iDDL);
1234 }
1235}
1236
1237//---------------------------------------------------------------------------
1238Bool_t
1239AliTOFRawStream::LoadRawDataBuffers(Int_t indexDDL, Int_t verbose)
1240{
1241 //
1242 // To load the buffers
1243 //
1244
1245 fTOFrawData->Clear();
1246 fPackedDigits = 0;
1247
1248 if (verbose > 0)
1249 AliInfo(Form("Decoding raw data for DDL # %d ...", indexDDL));
1250
1251 if (DecodeDDL(indexDDL, indexDDL, verbose) != 0){ //decode DDL
1252 fRawReader->AddMajorErrorLog(kDDLDecoder,Form("DDL # = %d",indexDDL));
1253 AliWarning(Form("Error while decoding DDL # %d", indexDDL));
1254 return kTRUE;
1255 }
1256
1257 if (verbose > 0)
1258 AliInfo(Form("Done. %d packed %s been found.", fPackedDataBuffer[indexDDL]->GetEntries(), fPackedDataBuffer[indexDDL]->GetEntries() > 1 ? "hits have" : "hit has"));
1259
1260 AliTOFHitData *hitData; //hit data pointer
1261
1262 if (verbose > 0)
1263 AliInfo("Filling TClonesArray ...");
1264
1265 //loop over DDL packed hits
1266 for (Int_t iHit = 0; iHit < fPackedDataBuffer[indexDDL]->GetEntries(); iHit++){
1267 hitData = fPackedDataBuffer[indexDDL]->GetHit(iHit); //get hit data
1268 Int_t hitACQ = hitData->GetACQ();
1269 Int_t hitPS = hitData->GetPS();
1270 Int_t hitSlotID = hitData->GetSlotID();
1271 Int_t hitChain = hitData->GetChain();
1272 Int_t hitTDC = hitData->GetTDC();
1273 Int_t hitChan = hitData->GetChan();
1274 Int_t hitTimeBin = hitData->GetTimeBin();
1275 Int_t hitTOTBin = hitData->GetTOTBin();
1276
1277 Int_t hitLeading = -1;
1278 Int_t hitTrailing = -1;
1279 Int_t hitError = -1;
1280
1281 TClonesArray &arrayTofRawData = *fTOFrawData;
1282 new (arrayTofRawData[fPackedDigits++]) AliTOFrawData(hitSlotID, hitChain, hitTDC, hitChan, hitTimeBin, hitTOTBin, hitLeading, hitTrailing, hitPS, hitACQ, hitError);
1283 }
1284
1285 if (verbose > 0)
1286 AliInfo("Done.");
1287
1288 if (verbose > 0)
1289 AliInfo("Resetting buffers ...");
1290
1291 fDataBuffer[indexDDL]->Reset();
1292 fPackedDataBuffer[indexDDL]->Reset();
1293
1294 if (verbose > 0)
1295 AliInfo("Done.");
1296
1297 return kFALSE;
1298}
1299