Macro to Create pulser run data from an LDC
[u/mrichter/AliRoot.git] / TOF / AliTOFRawStream.cxx
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$
18 Revision 1.19  2007/05/18 13:07:53  decaro
19 Error messages stored in the global raw-reader error log (Cvetan, Chiara)
20
21 Revision 1.18  2007/05/08 11:53:29  arcelli
22 Improved class flexibility for further use (R.Preghenella)
23
24 Revision 1.17  2007/05/03 08:53:50  decaro
25 Coding convention: RS3 violation -> suppression
26
27 Revision 1.16  2007/05/03 08:22:22  decaro
28 Coding convention: RN17 violation -> suppression
29
30 Revision 1.15  2007/04/30 15:22:06  arcelli
31 Change TOF digit Time, Tot etc to int type
32
33 Revision 1.14  2007/04/27 11:11:53  arcelli
34 updates for the new decoder
35
36 Revision 1.13  2007/03/16 11:46:35  decaro
37 Coding convention: RN17 rule violation -> suppression
38
39 Revision 1.12  2007/02/22 09:43:45  decaro
40 Added AliTOFRawStream::GetIndex method for online calibration (C.Zampolli)
41
42 Revision 1.11  2007/02/20 15:57:00  decaro
43 Raw data update: to read the TOF raw data defined in UNPACKED mode
44
45 Revision 1.10  2006/12/15 14:01:38  cvetan
46 Memory leak fixed
47
48 Revision 1.9  2006/10/13 11:22:27  arcelli
49 remove warnings due to uninitialized AliTOFtdcDigit data members
50
51 Revision 1.8  2006/08/22 13:30:17  arcelli
52 removal of effective c++ warnings (C.Zampolli)
53
54 Revision 1.7  2006/08/10 14:46:54  decaro
55 TOF raw data format: updated version
56
57 Revision 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
68 Revision 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
74 Revision 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
104 ClassImp(AliTOFRawStream)
105
106
107 //_____________________________________________________________________________
108 AliTOFRawStream::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 //_____________________________________________________________________________
157 AliTOFRawStream::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 //_____________________________________________________________________________
202 AliTOFRawStream::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 //_____________________________________________________________________________
284 AliTOFRawStream& 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 //_____________________________________________________________________________
336 AliTOFRawStream::~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
356 void 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 //_____________________________________________________________________________
465 Bool_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
696 void 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
718 void 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
740 void 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
763 void 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
790 void 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 //----------------------------------------------------------------------------
817 Int_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 //----------------------------------------------------------------------------
827 Int_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 //----------------------------------------------------------------------------
913 Int_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 //----------------------------------------------------------------------------
1008 Int_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 //----------------------------------------------------------------------------
1042 Int_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 //----------------------------------------------------------------------------
1055 Int_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 //----------------------------------------------------------------------------
1069 void AliTOFRawStream::EquipmentId2VolumeId(AliTOFHitData *hitData, Int_t *volume) const
1070 {
1071   EquipmentId2VolumeId(hitData->GetDDLID(),hitData->GetSlotID(),hitData->GetChain(),hitData->GetTDC(),hitData->GetChan(),volume);
1072 }
1073 //----------------------------------------------------------------------------
1074 void 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 //-----------------------------------------------------------------------------
1127 Bool_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 //-----------------------------------------------------------------------------
1153 Bool_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 //---------------------------------------------------------------------------
1224 void
1225 AliTOFRawStream::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 //---------------------------------------------------------------------------
1238 Bool_t
1239 AliTOFRawStream::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