Optional scoring for background studies in HALL.
[u/mrichter/AliRoot.git] / TOF / AliTOFDecoderV2.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: AliTOFDecoder.cxx,v $
18 Revision 1.4  2007/05/18 13:08:57  decaro
19 Coding convention: RS1 violation -> suppression
20
21 Revision 1.3  2007/05/08 11:56:05  arcelli
22 improved verbosity in verbose mode (R.Preghenella)
23
24 Revision 1.2  2007/05/03 11:34:43  decaro
25 Coding convention: RS1 violation -> suppression
26
27 Revision 1.1  2007/04/27 11:00:32  arcelli
28 TOF Raw Data decoder
29
30   author: Roberto Preghenella (R+), preghenella@bo.infn.it
31 */
32
33
34 //////////////////////////////////////////////////////////////////////
35 //                                                                  //
36 //                                                                  //
37 //   Class for raw data decoding                                    //
38 //                                                                  //
39 //                                                                  //
40 //////////////////////////////////////////////////////////////////////
41                                
42
43 #include "AliLog.h"
44 #include "AliTOFRawDataFormat.h"
45 #include "AliTOFDecoderV2.h"
46 #include "AliTOFTDCHit.h"
47 #include "AliTOFDecoderSummaryData.h"
48 #include "AliTOFDRMSummaryData.h"
49 #include "AliTOFLTMSummaryData.h"
50 #include "AliTOFTRMSummaryData.h"
51 #include "AliTOFChainSummaryData.h"
52 #include "AliTOFTDCHitBuffer.h"
53 #include "AliTOFTDCErrorBuffer.h"
54 #include "AliRawDataHeader.h"
55
56 ClassImp(AliTOFDecoderV2)
57
58 //_________________________________________________________________
59
60 AliTOFDecoderV2::AliTOFDecoderV2(AliRawReader *reader) :
61   TObject(),
62   fRawReader(reader),
63   fVerbose(kFALSE),
64   fLogErrors(kTRUE),
65   fV2718Patch(kFALSE),
66   fRecoverError(kTRUE),
67   fRecoverErrorThr(0),
68   fSpider(kTRUE),
69   fRunNumber(0),
70   fEventNumber(0),
71   fEquipmentID(0),
72   fDecoderSummaryData(0x0),
73   fDRMSummaryData(0x0),
74   fLTMSummaryData(0x0),
75   fTRMSummaryData(0x0),
76   fChainSummaryData(0x0),
77   fTDCHitBuffer(0x0),
78   fTDCPackedHitBuffer(0x0),
79   fTDCErrorBuffer(0x0),
80   fDRMGlobalHeader(0x0),
81   fDRMGlobalTrailer(0x0),
82   fDRMStatusHeader1(0x0),
83   fDRMStatusHeader2(0x0),
84   fDRMStatusHeader3(0x0),
85   fDRMStatusHeader4(0x0),
86   fDRMEventCRC(0x0),
87   fLTMGlobalHeader(0x0),
88   fLTMGlobalTrailer(0x0),
89   fLTMPDLData(0x0),
90   fLTMADCData(0x0),
91   fLTMORData(0x0),
92   fTRMGlobalHeader(0x0),
93   fTRMGlobalTrailer(0x0),
94   fTRMChainHeader(0x0),
95   fTRMChainTrailer(0x0),
96   fTDCPackedHit(0x0),
97   fTDCUnpackedHit(0x0),
98   fTRMTDCError(0x0),
99   fTRMDiagnosticErrorWord1(0x0),
100   fTRMDiagnosticErrorWord2(0x0),
101   fSpiderTDCID(-1),
102   fSpiderTDCPackedHitBuffer(0x0)
103 {
104   //default constructor
105   if (fRawReader)
106     fRawReader->Select("TOF", 0, 71);
107
108   fDecoderSummaryData = new AliTOFDecoderSummaryData();
109
110   for (Int_t iChan = 0; iChan < N_CHANNEL; iChan++)
111     fSpiderBufferFull[iChan] = kFALSE;
112 }
113
114 //_________________________________________________________________
115
116 AliTOFDecoderV2::AliTOFDecoderV2(const AliTOFDecoderV2 &source) : 
117   TObject(),
118   fRawReader(source.fRawReader),
119   fVerbose(source.fVerbose),
120   fLogErrors(source.fLogErrors),
121   fV2718Patch(source.fV2718Patch),
122   fRecoverError(source.fRecoverError),
123   fRecoverErrorThr(source.fRecoverErrorThr),
124   fSpider(source.fSpider),
125   fRunNumber(source.fRunNumber),
126   fEventNumber(source.fEventNumber),
127   fEquipmentID(source.fEquipmentID),
128   fDecoderSummaryData(0x0),
129   fDRMSummaryData(0x0),
130   fLTMSummaryData(0x0),
131   fTRMSummaryData(0x0),
132   fChainSummaryData(0x0),
133   fTDCHitBuffer(0x0),
134   fTDCPackedHitBuffer(0x0),
135   fTDCErrorBuffer(0x0),
136   fDRMGlobalHeader(0x0),
137   fDRMGlobalTrailer(0x0),
138   fDRMStatusHeader1(0x0),
139   fDRMStatusHeader2(0x0),
140   fDRMStatusHeader3(0x0),
141   fDRMStatusHeader4(0x0),
142   fDRMEventCRC(0x0),
143   fLTMGlobalHeader(0x0),
144   fLTMGlobalTrailer(0x0),
145   fLTMPDLData(0x0),
146   fLTMADCData(0x0),
147   fLTMORData(0x0),
148   fTRMGlobalHeader(0x0),
149   fTRMGlobalTrailer(0x0),
150   fTRMChainHeader(0x0),
151   fTRMChainTrailer(0x0),
152   fTDCPackedHit(0x0),
153   fTDCUnpackedHit(0x0),
154   fTRMTDCError(0x0),
155   fTRMDiagnosticErrorWord1(0x0),
156   fTRMDiagnosticErrorWord2(0x0),
157   fSpiderTDCID(-1),
158   fSpiderTDCPackedHitBuffer(0x0)
159 {
160   //copy constructor
161   fDecoderSummaryData = new AliTOFDecoderSummaryData(*source.fDecoderSummaryData);
162   
163   for (Int_t iChan = 0; iChan < N_CHANNEL; iChan++)
164     fSpiderBufferFull[iChan] = kFALSE;
165 }
166
167 //_________________________________________________________________
168
169 AliTOFDecoderV2 &
170 AliTOFDecoderV2::operator = (const AliTOFDecoderV2 &source)
171 {
172   //operator =
173   if (this == &source) return *this;
174   TObject::operator=(source);
175   fRawReader = source.fRawReader;
176   fVerbose = source.fVerbose;
177   fLogErrors = source.fLogErrors;
178   fV2718Patch = source.fV2718Patch;
179   fRecoverError = source.fRecoverError;
180   fRecoverErrorThr = source.fRecoverErrorThr;
181   fSpider = source.fSpider;
182   fRunNumber = source.fRunNumber;
183   fEventNumber = source.fEventNumber;
184   fEquipmentID = source.fEquipmentID;
185   *fDecoderSummaryData = *source.fDecoderSummaryData;
186   return *this;
187 }
188
189 AliTOFDecoderV2::~AliTOFDecoderV2()
190 {
191     delete fDecoderSummaryData;
192 }
193
194 //_________________________________________________________________
195
196 Bool_t
197 AliTOFDecoderV2::Decode(UInt_t *rawData, UInt_t nWords)
198 {
199   /* main decoding routine.
200    * it loops over nWords 32-bit words 
201    * starting at *rawData and decodes them.
202    * it also fills some buffers in order to
203    * have the decoded data available for other
204    * classes.
205    */
206
207   //reset decoder summary data
208   fDecoderSummaryData->Reset();
209
210   //fill decoder summary data
211   fDecoderSummaryData->SetRunNumber(fRunNumber);
212   fDecoderSummaryData->SetEventNumber(fEventNumber);
213   fDecoderSummaryData->SetEquipmentID(fEquipmentID);
214   fDecoderSummaryData->SetInputWords(nWords);
215   fDecoderSummaryData->SetRecoverError(fRecoverError);
216   fDecoderSummaryData->SetSpider(fSpider);
217
218   AliTOFTDCHit hit;
219   AliTOFTDCError error;
220
221   //decoder status
222   UShort_t decoderStatus = 0x0;
223
224   //CRC variables
225   UInt_t drmCRC = 0x0;
226   UInt_t ltmCRC = 0x0;
227   UInt_t trmCRC = 0x0;
228
229   // error warning counter
230   Int_t errorWarning = 0;
231   
232   if (fRecoverError && fVerbose)
233     AliInfo("Recover error option enabled: potentially dangerous!");
234
235   /*** V2718 patch ***/
236   if (fV2718Patch){
237     decoderStatus = decoderStatus | DRM_BIT;
238     fDecoderSummaryData->SetDecoderStatus(decoderStatus);
239     fDecoderSummaryData->SetCurrentDRMID(0x0);
240     fDecoderSummaryData->SetV2718Patch(kTRUE);
241     fDRMSummaryData = fDecoderSummaryData->GetDRMSummaryData();
242     fDRMSummaryData->SetHeader(kTRUE);
243     fDRMSummaryData->SetDRMID(0x0);
244     if (fVerbose)
245       AliInfo("DRM not present: - V2718 patch decoding -");
246   }
247   /*** V2718 patch ***/
248
249   if (fVerbose)
250     AliInfo("Start decoding");
251   
252   if (fVerbose)
253     AliInfo("Loop over the data and decode");
254   
255   if (fVerbose)
256     AliInfo("  St    Hex Word \t   Decoded Word");
257   
258   //loop over raw data
259   for (UInt_t iWord = 0; 
260        iWord < nWords; 
261        iWord++, rawData++, fDecoderSummaryData->SetDecodedWords(iWord)){
262     
263     //try to recover error
264     if (fDecoderSummaryData->GetRecoveringError() && fVerbose)
265       AliInfo(Form("  %02x - 0x%08x",decoderStatus,*rawData));
266     
267     //compute CRC with current data
268     drmCRC ^= *rawData;
269     ltmCRC ^= *rawData;
270     trmCRC ^= *rawData;
271
272     //switch word type
273     switch (*rawData & WORD_TYPE_MASK){
274       
275     case GLOBAL_HEADER:
276       
277       //switch slot ID
278       switch (*rawData & SLOT_ID_MASK){
279         
280         //DRM global header (slotID=1)
281       case 1:
282         //try to recover error
283         if (fDecoderSummaryData->GetRecoveringError())
284           continue;
285         //check decode status
286         if ( decoderStatus != DRM_HEADER_STATUS ){
287           if (fLogErrors)
288             AliError(Form("  %02x - 0x%08x [ERROR] Unexpected DRM global header (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
289           fDecoderSummaryData->SetErrorDetected(kTRUE);
290           fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
291           errorWarning++;
292           //try to recover error
293           if (fRecoverError){
294             if (errorWarning > fRecoverErrorThr) {
295               if (fVerbose)
296                 AliInfo("Trying to recover the error: searching for the next header");
297               fDecoderSummaryData->SetRecoveringError(kTRUE);
298               continue;
299             }
300             else {
301               if (fVerbose)
302                 AliInfo("Do not try to recover error yet, go on with decoding process");
303               continue;
304             }
305           }
306           return(fDecoderSummaryData->GetErrorDetected());
307         }
308         //decode status ok
309         errorWarning = 0;
310         //set DRM global header
311         fDRMGlobalHeader = (AliTOFDRMGlobalHeader *)rawData;
312         //reset DRM CRC
313         drmCRC = 0x0;
314         //fill decoder summary data
315         fDecoderSummaryData->SetCurrentDRMID(fDRMGlobalHeader->GetDRMID());
316         fDecoderSummaryData->SetCurrentSlotID(fDRMGlobalHeader->GetSlotID());
317         //get DRM summary data
318         fDRMSummaryData = fDecoderSummaryData->GetDRMSummaryData();
319         //reset DRM summary data
320         fDRMSummaryData->Reset();
321         //fill DRM summary data
322         FillDRMSummaryData(fDRMGlobalHeader);
323         //print verbose
324         if (fVerbose)
325           AliInfo(Form("  %02x - 0x%08x \t  DRM global header",decoderStatus,*rawData));
326         //change decode status
327         decoderStatus = decoderStatus | DRM_BIT;
328         fDecoderSummaryData->SetDecoderStatus(decoderStatus);
329         //decode DRM status headers
330         for (Int_t i = 0; i < DRM_STATUS_HEADER_WORDS; i++){
331           iWord++;
332           rawData++;
333           drmCRC ^= *rawData;
334
335           switch (i){
336           case 0: //DRM status header 1
337             fDRMStatusHeader1 = (AliTOFDRMStatusHeader1 *)rawData;
338             FillDRMSummaryData(fDRMStatusHeader1);
339             if (fVerbose)
340               AliInfo(Form("  %02x - 0x%08x \t  DRM status header 1",decoderStatus,*rawData));
341             break;
342           case 1: //DRM status header 2
343             fDRMStatusHeader2 = (AliTOFDRMStatusHeader2 *)rawData;
344             FillDRMSummaryData(fDRMStatusHeader2);
345             if (fVerbose)
346               AliInfo(Form("  %02x - 0x%08x \t  DRM status header 2",decoderStatus,*rawData));
347             break;
348           case 2: //DRM status header 3
349             fDRMStatusHeader3 = (AliTOFDRMStatusHeader3 *)rawData;
350             FillDRMSummaryData(fDRMStatusHeader3);
351             if (fVerbose)
352               AliInfo(Form("  %02x - 0x%08x \t  DRM status header 3",decoderStatus,*rawData));
353             break;
354           case 3: //DRM status header 4
355             fDRMStatusHeader4 = (AliTOFDRMStatusHeader4 *)rawData;
356             FillDRMSummaryData(fDRMStatusHeader4);
357             if (fVerbose)
358               AliInfo(Form("  %02x - 0x%08x \t  DRM status header 4",decoderStatus,*rawData));
359             break;
360           }
361         }
362         //decode DRM event CRC
363         iWord++;
364         rawData++;
365         drmCRC ^= *rawData;
366         //remove DRM event CRC from DRM CRC
367         drmCRC ^= *rawData;
368         fDRMEventCRC = (AliTOFDRMEventCRC *)rawData;
369         FillDRMSummaryData(fDRMEventCRC);
370         if (fVerbose)
371           AliInfo(Form("  %02x - 0x%08x \t  DRM event CRC",decoderStatus,*rawData));
372         break;
373         
374         //LTM global header (slotID=2)
375       case 2:
376         //recover error
377         if (fDecoderSummaryData->GetRecoveringError()){
378           //change decode status
379           decoderStatus = LTM_HEADER_STATUS;
380           fDecoderSummaryData->SetDecoderStatus(decoderStatus);
381           fDecoderSummaryData->SetRecoveringError(kFALSE);
382           if (fVerbose)
383             AliInfo("LTM global header found: error probably recovered");
384         }
385         //check decode status
386         if ( decoderStatus != LTM_HEADER_STATUS ){
387           if (fLogErrors)
388             AliError(Form("  %02x - 0x%08x [ERROR] Unexpected LTM global header (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
389           fDecoderSummaryData->SetErrorDetected(kTRUE);
390           fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
391           errorWarning++;
392           //try to recover error
393           if (fRecoverError){
394             if (errorWarning > fRecoverErrorThr) {
395               if (fVerbose)
396                 AliInfo("Trying to recover the error: searching for the next header");
397               fDecoderSummaryData->SetRecoveringError(kTRUE);
398               continue;
399             }
400             else {
401               if (fVerbose)
402                 AliInfo("Do not try to recover error yet, go on with decoding process");
403               continue;
404             }
405           }
406           return(fDecoderSummaryData->GetErrorDetected());
407         }
408         //decode status ok
409         errorWarning = 0;
410         //set LTM global header
411         fLTMGlobalHeader = (AliTOFLTMGlobalHeader *)rawData;
412         //reset LTM CRC
413         ltmCRC = 0x0;
414         //fill decoder summary data
415         fDecoderSummaryData->SetCurrentSlotID(fLTMGlobalHeader->GetSlotID());
416         //get LTM summary data
417         fLTMSummaryData = fDRMSummaryData->GetLTMSummaryData();
418         //reset LTM summary data
419         fLTMSummaryData->Reset();
420         //fill LTM summary data
421         FillLTMSummaryData(fLTMGlobalHeader);
422         //set DRM slot enable mask bit
423         fDRMSummaryData->SetDecoderSlotEnableMaskBit(fLTMGlobalHeader->GetSlotID() - 2);
424         //print verbose
425         if (fVerbose)
426           AliInfo(Form("  %02x - 0x%08x \t  LTM global header",decoderStatus,*rawData));
427         //change decode status
428         decoderStatus = decoderStatus | LTM_BIT;
429         fDecoderSummaryData->SetDecoderStatus(decoderStatus);
430         
431         //decode LTM PDL data
432         for (Int_t iPDLWord = 0; iPDLWord < LTM_PDL_DATA_WORDS; iPDLWord++){
433           iWord++;
434           rawData++;
435           drmCRC ^= *rawData;
436           ltmCRC ^= *rawData;
437           //set LTM PDL data
438           fLTMPDLData = (AliTOFLTMPDLData *)rawData;
439           //fill LTM summary data
440           FillLTMSummaryData(fLTMPDLData, iPDLWord);
441           //print verbose
442           if (fVerbose)
443             AliInfo(Form("  %02x - 0x%08x \t  LTM PDL data \t\t PDL1=%03d PDL2=%03d PDL3=%03d PDL4=%03d",decoderStatus,*rawData,fLTMPDLData->GetPDLValue1(),fLTMPDLData->GetPDLValue2(),fLTMPDLData->GetPDLValue3(),fLTMPDLData->GetPDLValue4()));
444         }
445         //decode LTM ADC data
446         for (Int_t iADCWord = 0; iADCWord < LTM_ADC_DATA_WORDS; iADCWord++){
447           iWord++;
448           rawData++;
449           drmCRC ^= *rawData;
450           ltmCRC ^= *rawData;
451           //set LTM ADC data
452           fLTMADCData = (AliTOFLTMADCData *)rawData;
453           //fill LTM summary data
454           FillLTMSummaryData(fLTMADCData, iADCWord);
455           //print verbose
456           if (fVerbose)
457             AliInfo(Form("  %02x - 0x%08x \t  LTM ADC data \t\t ADC1=%04d ADC2=%04d ADC3=%04d",decoderStatus,*rawData,fLTMADCData->GetADCValue1(),fLTMADCData->GetADCValue2(),fLTMADCData->GetADCValue3()));
458         }
459         //decode LTM OR data
460         for (Int_t iORWord = 0; iORWord < LTM_OR_DATA_WORDS; iORWord++){
461           iWord++;
462           rawData++;
463           drmCRC ^= *rawData;
464           ltmCRC ^= *rawData;
465           //set LTM OR data
466           fLTMORData = (AliTOFLTMORData *)rawData;
467           //fill LTM summary data
468           FillLTMSummaryData(fLTMORData, iORWord);
469           //print verbose
470           if (fVerbose)
471             AliInfo(Form("  %02x - 0x%08x \t  LTM OR data \t\t ADC1=%04d ADC2=%04d ADC3=%04d",decoderStatus,*rawData,fLTMORData->GetORValue1(),fLTMORData->GetORValue2(),fLTMORData->GetORValue3()));
472         }
473         break;
474         
475         //TRM global header (slotID=3-12)
476       case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: case 12:
477         //recover error
478         if (fDecoderSummaryData->GetRecoveringError()){
479           //change decode status
480           decoderStatus = TRM_HEADER_STATUS;
481           fDecoderSummaryData->SetDecoderStatus(decoderStatus);
482           fDecoderSummaryData->SetRecoveringError(kFALSE);
483           if (fVerbose)
484             AliInfo("TRM global header found: error probably recovered");
485         }
486         //check decode status
487         if ( decoderStatus != TRM_HEADER_STATUS ){
488           if (fLogErrors)
489             AliError(Form("  %02x - 0x%08x [ERROR] Unexpected TRM global header (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
490           fDecoderSummaryData->SetErrorDetected(kTRUE);
491           fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
492           errorWarning++;
493           //try to recover error
494           if (fRecoverError){
495             if (errorWarning > fRecoverErrorThr) {
496               if (fVerbose)
497                 AliInfo("Trying to recover the error: searching for the next header");
498               fDecoderSummaryData->SetRecoveringError(kTRUE);
499               continue;
500             }
501             else {
502               if (fVerbose)
503                 AliInfo("Do not try to recover error yet, go on with decoding process");
504               continue;
505             }
506           }
507           return(fDecoderSummaryData->GetErrorDetected());
508         }
509         //decode status ok
510         errorWarning = 0;
511         //set TRM global header
512         fTRMGlobalHeader = (AliTOFTRMGlobalHeader *)rawData;    
513         //reset TRM CRC
514         trmCRC = 0x0;
515         //fill decoder summary data
516         fDecoderSummaryData->SetCurrentSlotID(fTRMGlobalHeader->GetSlotID());
517         //get TRM summary data
518         fTRMSummaryData = fDRMSummaryData->GetTRMSummaryData(fTRMGlobalHeader->GetSlotID() - TRM_FIRST_SLOT_ID);
519         //reset TRM summary data
520         fTRMSummaryData->Reset();
521         //fill TRM summary data
522         FillTRMSummaryData(fTRMGlobalHeader);
523         //set DRM slot enable mask bit
524         fDRMSummaryData->SetDecoderSlotEnableMaskBit(fTRMGlobalHeader->GetSlotID() - 2);
525         //print verbose
526         if (fVerbose)
527           AliInfo(Form("  %02x - 0x%08x \t  TRM global header \t slotID=%02d ACQ=%01d L=%01d",decoderStatus,*rawData,fTRMGlobalHeader->GetSlotID(),fTRMGlobalHeader->GetACQBits(),fTRMGlobalHeader->GetLBit()));
528         //change decode status
529         decoderStatus = decoderStatus | TRM_BIT;
530         fDecoderSummaryData->SetDecoderStatus(decoderStatus);
531         break;
532         
533       default:
534         if (fLogErrors)
535           AliError(Form("  %02x - 0x%08x [ERROR] Not valid slotID in global header (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
536         fDecoderSummaryData->SetErrorDetected(kTRUE);
537         fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
538           //try to recover error
539           if (fRecoverError){
540             if (errorWarning > fRecoverErrorThr) {
541               if (fVerbose)
542                 AliInfo("Trying to recover the error: searching for the next header");
543               fDecoderSummaryData->SetRecoveringError(kTRUE);
544               continue;
545             }
546             else {
547               if (fVerbose)
548                 AliInfo("Do not try to recover error yet, go on with decoding process");
549               continue;
550             }
551           }
552         return(fDecoderSummaryData->GetErrorDetected());
553         break;
554         
555       }
556       //end switch slotID
557       break;
558       
559     case GLOBAL_TRAILER:
560    
561    //switch slot ID
562    switch (*rawData & SLOT_ID_MASK){
563      
564      //DRM global trailer (slotID=1)
565    case 1:
566      //recover error
567      if (fDecoderSummaryData->GetRecoveringError()){
568        //change decode status
569        decoderStatus = DRM_TRAILER_STATUS;
570        fDecoderSummaryData->SetDecoderStatus(decoderStatus);
571        fDecoderSummaryData->SetRecoveringError(kFALSE);
572        if (fVerbose)
573          AliInfo("DRM global trailer found: error probably recovered");
574      }
575      //check decode status
576      if ( decoderStatus != DRM_TRAILER_STATUS ){
577        if (fLogErrors)
578          AliError(Form("  %02x - 0x%08x [ERROR] Unexpected DRM global trailer (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
579        fDecoderSummaryData->SetErrorDetected(kTRUE);
580        fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
581           errorWarning++;
582           //try to recover error
583           if (fRecoverError){
584             if (errorWarning > fRecoverErrorThr) {
585               if (fVerbose)
586                 AliInfo("Trying to recover the error: searching for the next header");
587               fDecoderSummaryData->SetRecoveringError(kTRUE);
588               continue;
589             }
590             else {
591               if (fVerbose)
592                 AliInfo("Do not try to recover error yet, go on with decoding process");
593               continue;
594             }
595           }
596           return(fDecoderSummaryData->GetErrorDetected());
597         }
598         //decode status ok
599         errorWarning = 0;
600         //set DRM global trailer
601         fDRMGlobalTrailer = (AliTOFDRMGlobalTrailer *)rawData;
602         //remove global trailer from DRM CRC
603         drmCRC ^= *rawData;
604         //fill DRM summary data
605         FillDRMSummaryData(fDRMGlobalTrailer);
606         fDRMSummaryData->SetDecoderCRC(COMPUTE_DRM_CRC(drmCRC));
607         //print verbose
608         if (fVerbose)
609           AliInfo(Form("  %02x - 0x%08x \t  DRM global trailer",decoderStatus,*rawData));
610         //change decode status
611         decoderStatus = decoderStatus & ~DRM_BIT;
612         fDecoderSummaryData->SetDecoderStatus(decoderStatus);
613         break;
614         
615         //LTM global trailer (slotID=2)
616       case 2:
617         //try to recover error
618         if (fDecoderSummaryData->GetRecoveringError())
619           continue;
620         //check decode status
621         if ( decoderStatus != LTM_TRAILER_STATUS ){
622           if (fLogErrors)
623             AliError(Form("  %02x - 0x%08x [ERROR] Unexpected LTM global trailer (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
624           fDecoderSummaryData->SetErrorDetected(kTRUE);
625           fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
626           errorWarning++;
627           //try to recover error
628           if (fRecoverError){
629             if (errorWarning > fRecoverErrorThr) {
630               if (fVerbose)
631                 AliInfo("Trying to recover the error: searching for the next header");
632               fDecoderSummaryData->SetRecoveringError(kTRUE);
633               continue;
634             }
635             else {
636               if (fVerbose)
637                 AliInfo("Do not try to recover error yet, go on with decoding process");
638               continue;
639             }
640           }
641           return(fDecoderSummaryData->GetErrorDetected());
642         }
643         //decode status ok
644         errorWarning = 0;
645         //set LTM global trailer
646         fLTMGlobalTrailer = (AliTOFLTMGlobalTrailer *)rawData;
647         //remove global trailer from LTM CRC
648         ltmCRC ^= *rawData;
649         //fill LTM summary data
650         FillLTMSummaryData(fLTMGlobalTrailer);
651         fLTMSummaryData->SetDecoderCRC(COMPUTE_LTM_CRC(ltmCRC));
652         //print verbose
653         if (fVerbose)
654           AliInfo(Form("  %02x - 0x%08x \t  LTM global trailer",decoderStatus,*rawData));
655         //change decode status
656         decoderStatus = decoderStatus & ~LTM_BIT;
657         fDecoderSummaryData->SetDecoderStatus(decoderStatus);
658         break;
659         
660         //TRM global trailer (slotID=15)
661       case 15:
662         //try to recover error
663         if (fDecoderSummaryData->GetRecoveringError())
664           continue;
665         //check decode status
666         if ( decoderStatus != TRM_TRAILER_STATUS ){
667           if (fLogErrors)
668             AliError(Form("  %02x - 0x%08x [ERROR] Unexpected TRM global trailer (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
669           fDecoderSummaryData->SetErrorDetected(kTRUE);
670           fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
671           errorWarning++;
672           //try to recover error
673           if (fRecoverError){
674             if (errorWarning > fRecoverErrorThr) {
675               if (fVerbose)
676                 AliInfo("Trying to recover the error: searching for the next header");
677               fDecoderSummaryData->SetRecoveringError(kTRUE);
678               continue;
679             }
680             else {
681               if (fVerbose)
682                 AliInfo("Do not try to recover error yet, go on with decoding process");
683               continue;
684             }
685           }
686           return(fDecoderSummaryData->GetErrorDetected());
687         }
688         //decode status ok
689         errorWarning = 0;
690         //set TRM global trailer
691         fTRMGlobalTrailer = (AliTOFTRMGlobalTrailer *)rawData;  
692         //remove global trailer from TRM CRC
693         trmCRC ^= *rawData;
694         //fill TRM summary data
695         FillTRMSummaryData(fTRMGlobalTrailer);
696         fTRMSummaryData->SetDecoderCRC(COMPUTE_TRM_CRC(trmCRC));
697         //print verbose
698         if (fVerbose)
699           AliInfo(Form("  %02x - 0x%08x \t  TRM global trailer \t CRC=%04d eventCounter=%04d",decoderStatus,*rawData,fTRMGlobalTrailer->GetEventCRC(),fTRMGlobalTrailer->GetEventCounter()));
700         //change decode status
701         decoderStatus = decoderStatus & ~TRM_BIT;
702         fDecoderSummaryData->SetDecoderStatus(decoderStatus);
703         break; 
704         
705       default:
706         //try to recover error
707         if (fDecoderSummaryData->GetRecoveringError())
708           continue;
709         if (fLogErrors)
710           AliError(Form("  %02x - 0x%08x [ERROR] Not valid slotID/pattern in global trailer (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
711         fDecoderSummaryData->SetErrorDetected(kTRUE);
712         fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
713           errorWarning++;
714         //try to recover error
715         if (fRecoverError){
716           if (fVerbose)
717             AliInfo("Trying to recover the error: searching for the next header");
718           fDecoderSummaryData->SetRecoveringError(kTRUE);
719           continue;
720         }
721         return(fDecoderSummaryData->GetErrorDetected());
722         break;
723       }
724       break;
725       
726     case CHAIN_A_HEADER:
727
728       //try to recover error
729       if (fDecoderSummaryData->GetRecoveringError())
730         continue;
731       //check decode status
732       if ( decoderStatus != CHAIN_A_HEADER_STATUS  && !fDecoderSummaryData->GetRecoveringError() ){
733         if (fLogErrors)
734           AliError(Form("  %02x - 0x%08x [ERROR] Unexpected TRM chain A header (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
735         fDecoderSummaryData->SetErrorDetected(kTRUE);
736         fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
737           errorWarning++;
738           //try to recover error
739           if (fRecoverError){
740             if (errorWarning > fRecoverErrorThr) {
741               if (fVerbose)
742                 AliInfo("Trying to recover the error: searching for the next header");
743               fDecoderSummaryData->SetRecoveringError(kTRUE);
744               continue;
745             }
746             else {
747               if (fVerbose)
748                 AliInfo("Do not try to recover error yet, go on with decoding process");
749               continue;
750             }
751           }
752         return(fDecoderSummaryData->GetErrorDetected());
753       }
754       //decode status ok
755         errorWarning = 0;
756       //set TRM chain header
757       fTRMChainHeader = (AliTOFTRMChainHeader *)rawData;
758       //fill decoder summary data
759       fDecoderSummaryData->SetCurrentChain(0);
760       //get chain summary data
761       fChainSummaryData = fTRMSummaryData->GetChainSummaryData(0);
762       //reset chain summary data
763       fChainSummaryData->Reset();
764       //fill chain summary data
765       FillChainSummaryData(fTRMChainHeader);
766       //get tdc hit buffer
767       fTDCHitBuffer = fChainSummaryData->GetTDCHitBuffer();
768       //reset tdc hit buffer
769       fTDCHitBuffer->Reset();
770       //get tdc packed hit buffer
771       fTDCPackedHitBuffer = fChainSummaryData->GetTDCPackedHitBuffer();
772       //reset tdc packed hit buffer
773       fTDCPackedHitBuffer->Reset();
774       //get tdc error buffer
775       fTDCErrorBuffer = fChainSummaryData->GetTDCErrorBuffer();
776       //reset tdc error buffer
777       fTDCErrorBuffer->Reset();
778       //print verbose
779       if (fVerbose)
780         AliInfo(Form("  %02x - 0x%08x \t  TRM chain A header \t chain=%01d bunchID=%04d",decoderStatus,*rawData,0,fTRMChainHeader->GetBunchID()));
781       //change decode status
782       decoderStatus = decoderStatus | CHAIN_A_BIT;
783       fDecoderSummaryData->SetDecoderStatus(decoderStatus);
784       //reset spider
785       if (fSpider)
786         ResetSpider();
787       break;
788       
789     case CHAIN_A_TRAILER:
790
791       //try to recover error
792       if (fDecoderSummaryData->GetRecoveringError())
793         continue;
794       //check decode status
795       if ( decoderStatus != CHAIN_A_TRAILER_STATUS  && !fDecoderSummaryData->GetRecoveringError()){
796           if (fLogErrors)
797             AliError(Form("  %02x - 0x%08x [ERROR] Unexpected TRM chain A trailer (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
798         fDecoderSummaryData->SetErrorDetected(kTRUE);
799         fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
800           errorWarning++;
801           //try to recover error
802           if (fRecoverError){
803             if (errorWarning > fRecoverErrorThr) {
804               if (fVerbose)
805                 AliInfo("Trying to recover the error: searching for the next header");
806               fDecoderSummaryData->SetRecoveringError(kTRUE);
807               continue;
808             }
809             else {
810               if (fVerbose)
811                 AliInfo("Do not try to recover error yet, go on with decoding process");
812               continue;
813             }
814           }
815         return(fDecoderSummaryData->GetErrorDetected());
816       }
817       //decode status ok
818         errorWarning = 0;
819       //set TRM chain trailer
820       fTRMChainTrailer = (AliTOFTRMChainTrailer *)rawData;
821       //fill chain summary data
822       FillChainSummaryData(fTRMChainTrailer);
823       //print verbose
824       if (fVerbose)
825         AliInfo(Form("  %02x - 0x%08x \t  TRM chain A trailer",decoderStatus,*rawData));
826       //change decode status
827       decoderStatus = decoderStatus & ~CHAIN_A_BIT;
828       fDecoderSummaryData->SetDecoderStatus(decoderStatus);
829       break;
830       
831     case CHAIN_B_HEADER:
832
833       //try to recover error
834       if (fDecoderSummaryData->GetRecoveringError())
835         continue;
836       //check decode status
837       if ( decoderStatus != CHAIN_B_HEADER_STATUS  && !fDecoderSummaryData->GetRecoveringError()){
838           if (fLogErrors)
839             AliError(Form("  %02x - 0x%08x [ERROR] Unexpected TRM chain B header (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
840         fDecoderSummaryData->SetErrorDetected(kTRUE);
841         fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
842           errorWarning++;
843           //try to recover error
844           if (fRecoverError){
845             if (errorWarning > fRecoverErrorThr) {
846               if (fVerbose)
847                 AliInfo("Trying to recover the error: searching for the next header");
848               fDecoderSummaryData->SetRecoveringError(kTRUE);
849               continue;
850             }
851             else {
852               if (fVerbose)
853                 AliInfo("Do not try to recover error yet, go on with decoding process");
854               continue;
855             }
856           }
857         return(fDecoderSummaryData->GetErrorDetected());
858       }
859       //decode status ok
860         errorWarning = 0;
861       //set TRM chain header
862       fTRMChainHeader = (AliTOFTRMChainHeader *)rawData;
863       //fill decoder summary data
864       fDecoderSummaryData->SetCurrentChain(1);
865       //get chain summary data
866       fChainSummaryData = fTRMSummaryData->GetChainSummaryData(1);
867       //reset chain summary data
868       fChainSummaryData->Reset();
869       //fill chain summary data
870       FillChainSummaryData(fTRMChainHeader);
871       //get tdc hit buffer
872       fTDCHitBuffer = fChainSummaryData->GetTDCHitBuffer();
873       //reset tdc hit buffer
874       fTDCHitBuffer->Reset();
875       //get tdc packed hit buffer
876       fTDCPackedHitBuffer = fChainSummaryData->GetTDCPackedHitBuffer();
877       //reset tdc packed hit buffer
878       fTDCPackedHitBuffer->Reset();
879       //get tdc error buffer
880       fTDCErrorBuffer = fChainSummaryData->GetTDCErrorBuffer();
881       //reset tdc error buffer
882       fTDCErrorBuffer->Reset();
883       //print verbose
884       if (fVerbose)
885         AliInfo(Form("  %02x - 0x%08x \t  TRM chain B header \t chain=%01d bunchID=%04d",decoderStatus,*rawData,1,fTRMChainHeader->GetBunchID()));
886       //change decode status
887       decoderStatus = decoderStatus | CHAIN_B_BIT;
888       fDecoderSummaryData->SetDecoderStatus(decoderStatus);
889       //reset spider
890       if (fSpider)
891         ResetSpider();
892       break;
893       
894     case CHAIN_B_TRAILER:
895
896       //try to recover error
897       if (fDecoderSummaryData->GetRecoveringError())
898         continue;
899       //check decode status
900       if ( decoderStatus != CHAIN_B_TRAILER_STATUS  && !fDecoderSummaryData->GetRecoveringError()){
901           if (fLogErrors)
902             AliError(Form("  %02x - 0x%08x [ERROR] Unexpected TRM chain B trailer (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
903         fDecoderSummaryData->SetErrorDetected(kTRUE);
904         fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
905           errorWarning++;
906           //try to recover error
907           if (fRecoverError){
908             if (errorWarning > fRecoverErrorThr) {
909               if (fVerbose)
910                 AliInfo("Trying to recover the error: searching for the next header");
911               fDecoderSummaryData->SetRecoveringError(kTRUE);
912               continue;
913             }
914             else {
915               if (fVerbose)
916                 AliInfo("Do not try to recover error yet, go on with decoding process");
917               continue;
918             }
919           }
920         return(fDecoderSummaryData->GetErrorDetected());
921       }
922       //decode status ok
923         errorWarning = 0;
924       //set TRM chain trailer
925       fTRMChainTrailer = (AliTOFTRMChainTrailer *)rawData;
926       //fill chain summary data
927       FillChainSummaryData(fTRMChainTrailer);
928       //print verbose
929       if (fVerbose)
930         AliInfo(Form("  %02x - 0x%08x \t  TRM chain B trailer",decoderStatus,*rawData));
931       //change decode status
932       decoderStatus = decoderStatus & ~CHAIN_B_BIT;
933       fDecoderSummaryData->SetDecoderStatus(decoderStatus);
934       break;
935       
936     case ERROR:
937
938       //try to recover error
939       if (fDecoderSummaryData->GetRecoveringError())
940         continue;
941       //decode TRM TDC error
942       fTRMTDCError = (AliTOFTRMTDCError *)rawData;
943       //check diagnostic word
944       if (fTRMTDCError->GetTDCID() == 15) {
945         if (fVerbose)
946           AliInfo(Form("  %02x - 0x%08x \t  Diagnostic error word",decoderStatus,*rawData));
947         break;
948       }
949       //set error data
950       error.SetErrorFlags(fTRMTDCError->GetErrorFlags());
951       error.SetTDCID(fTRMTDCError->GetTDCID());
952       //fill TDC error buffer
953       fTDCErrorBuffer->Add(error);
954       if (fVerbose)
955         AliInfo(Form("  %02x - 0x%08x \t  TDC error",decoderStatus,*rawData));
956       break;
957       
958     case FILLER:
959
960       //try to recover error
961       if (fDecoderSummaryData->GetRecoveringError())
962         continue;
963       if (fVerbose)
964         AliInfo(Form("  %02x - 0x%08x \t  Filler",decoderStatus,*rawData));
965       break;
966       
967     default:
968
969       //try to recover error
970       if (fDecoderSummaryData->GetRecoveringError())
971         continue;
972       //check decode status
973       if ( decoderStatus != CHAIN_A_TDC_HIT_STATUS &&
974            decoderStatus != CHAIN_B_TDC_HIT_STATUS  && !fDecoderSummaryData->GetRecoveringError()){
975           if (fLogErrors)
976             AliError(Form("  %02x - 0x%08x [ERROR] Unexpected or unknown word (curslot=%d)",decoderStatus,*rawData,fDecoderSummaryData->GetCurrentSlotID()));
977         fDecoderSummaryData->SetErrorDetected(kTRUE);
978         fDecoderSummaryData->SetErrorSlotID(fDecoderSummaryData->GetCurrentSlotID());
979           errorWarning++;
980           //try to recover error
981           if (fRecoverError){
982             if (errorWarning > fRecoverErrorThr) {
983               if (fVerbose)
984                 AliInfo("Trying to recover the error: searching for the next header");
985               fDecoderSummaryData->SetRecoveringError(kTRUE);
986               continue;
987             }
988             else {
989               if (fVerbose)
990                 AliInfo("Do not try to recover error yet, go on with decoding process");
991               continue;
992             }
993           }
994         return(fDecoderSummaryData->GetErrorDetected());
995       }
996       //decode status ok
997         errorWarning = 0;
998       
999       //switch TRM ACQ
1000       switch (fTRMSummaryData->GetACQBits()){
1001         
1002       case PACKING_ENABLED_ACQ:
1003         //decode TDC packed/unpacked hit
1004         fTDCPackedHit = (AliTOFTDCPackedHit *)rawData;
1005         fTDCUnpackedHit = (AliTOFTDCUnpackedHit *)rawData;
1006         //set hit data
1007         hit.SetChan(fTDCUnpackedHit->GetChan());
1008         hit.SetTDCID(fTDCUnpackedHit->GetTDCID());
1009         hit.SetEBit(fTDCUnpackedHit->GetEBit());
1010         hit.SetPSBits(fTDCUnpackedHit->GetPSBits());
1011         //switch PS bits
1012         switch (hit.GetPSBits()){
1013           //packed hit or overflow hit
1014         case PACKED_HIT_PS: case TOT_OVF_HIT_PS:
1015           hit.SetHitTime(fTDCPackedHit->GetHitTime());
1016           hit.SetTOTWidth(fTDCPackedHit->GetTOTWidth());
1017           //add hit
1018           fTDCHitBuffer->Add(hit);
1019           fTDCPackedHitBuffer->Add(hit);
1020           break; 
1021           //orphane leading
1022         case LEADING_HIT_PS:
1023           hit.SetHitTime(fTDCUnpackedHit->GetHitTime());
1024           hit.SetTOTWidth(0);
1025           //add hit
1026           fTDCHitBuffer->Add(hit);
1027           fTDCPackedHitBuffer->Add(hit);
1028           break;
1029           //orphane trailing
1030         case TRAILING_HIT_PS:
1031           hit.SetHitTime(fTDCUnpackedHit->GetHitTime());
1032           hit.SetTOTWidth(0);
1033           //add hit
1034           fTDCHitBuffer->Add(hit);
1035           break;
1036         }
1037         //end switch PS bits
1038         //print verbose
1039         if (fVerbose)
1040           switch (hit.GetPSBits()){
1041           case PACKED_HIT_PS:
1042             AliInfo(Form("  %02x - 0x%08x \t  TDC hit [packed] \t PS=%1d TDC=%1d chan=%1d TOT=%3d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetTOTWidth(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1043             break;
1044           case LEADING_HIT_PS:
1045             AliInfo(Form("  %02x - 0x%08x \t  TDC hit [orp.lead] \t PS=%1d TDC=%1d chan=%1d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1046             break;
1047           case TRAILING_HIT_PS:
1048             AliInfo(Form("  %02x - 0x%08x \t  TDC hit [orp.trai] \t PS=%1d TDC=%1d chan=%1d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1049             break;
1050           case TOT_OVF_HIT_PS:
1051             AliInfo(Form("  %02x - 0x%08x \t  TDC hit [TOT ovfl] \t PS=%1d TDC=%1d chan=%1d TOT=%3d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetTOTWidth(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1052             break;
1053           }
1054         break;
1055         
1056       case LEADING_ONLY_ACQ: case TRAILING_ONLY_ACQ:
1057         //decode TDC unpacked hit
1058         fTDCUnpackedHit = (AliTOFTDCUnpackedHit *)rawData;
1059         //set hit data
1060         hit.SetChan(fTDCUnpackedHit->GetChan());
1061         hit.SetTDCID(fTDCUnpackedHit->GetTDCID());
1062         hit.SetEBit(fTDCUnpackedHit->GetEBit());
1063         hit.SetPSBits(fTDCUnpackedHit->GetPSBits());
1064         hit.SetHitTime(fTDCUnpackedHit->GetHitTime());
1065         hit.SetTOTWidth(0);
1066         //add hit
1067         fTDCHitBuffer->Add(hit);
1068         //print verbose
1069         if (fVerbose)
1070           switch (hit.GetPSBits()){
1071           case LEADING_HIT_PS:
1072             AliInfo(Form("  %02x - 0x%08x \t  TDC hit [leading] \t PS=%1d TDC=%1d chan=%1d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1073             break;
1074           case TRAILING_HIT_PS:
1075             AliInfo(Form("  %02x - 0x%08x \t  TDC hit [trailing] \t PS=%1d TDC=%1d chan=%1d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1076           }
1077         break;
1078         
1079       case PACKING_DISABLED_ACQ:
1080         //decode TDC unpacked hit
1081         fTDCUnpackedHit = (AliTOFTDCUnpackedHit *)rawData;
1082         //set hit data
1083         hit.SetChan(fTDCUnpackedHit->GetChan());
1084         hit.SetTDCID(fTDCUnpackedHit->GetTDCID());
1085         hit.SetEBit(fTDCUnpackedHit->GetEBit());
1086         hit.SetPSBits(fTDCUnpackedHit->GetPSBits());
1087         hit.SetHitTime(fTDCUnpackedHit->GetHitTime());
1088         hit.SetTOTWidth(0);
1089         //add hit
1090         fTDCHitBuffer->Add(hit);
1091         //print verbose
1092         if (fVerbose)
1093           switch (hit.GetPSBits()){
1094           case LEADING_HIT_PS:
1095             AliInfo(Form("  %02x - 0x%08x \t  TDC hit [leading] \t PS=%1d TDC=%1d chan=%1d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1096             break;
1097           case TRAILING_HIT_PS:
1098             AliInfo(Form("  %02x - 0x%08x \t  TDC hit [trailing] \t PS=%1d TDC=%1d chan=%1d time=%4d (%7.1f ns)",decoderStatus,*rawData,hit.GetPSBits(),hit.GetTDCID(),hit.GetChan(),hit.GetHitTime(),hit.GetHitTime()*TIME_BIN_WIDTH));
1099           } //print verbose
1100         //spider
1101         if (fSpider)
1102           Spider(hit);
1103
1104         break;
1105       }
1106       //end switch TRM ACQ
1107
1108       break;
1109       
1110     }
1111     
1112   }
1113   //end equipment data loop
1114   
1115   if (fVerbose)
1116     AliInfo("End of data loop");
1117
1118   //reset spider
1119   if (fSpider)
1120     ResetSpider();
1121   
1122   /*** V2718 patch ***/
1123   if (fV2718Patch){
1124     decoderStatus = decoderStatus & ~DRM_BIT;
1125     fDecoderSummaryData->SetDecoderStatus(decoderStatus);
1126     fDRMSummaryData->SetTrailer(kTRUE);
1127     fDRMSummaryData->SetSlotEnableMask(fDRMSummaryData->GetDecoderSlotEnableMask());
1128     fDRMSummaryData->SetCBit(1);
1129     fDRMSummaryData->SetLocalEventCounter(fTRMSummaryData->GetEventCounter());
1130     if (fVerbose)
1131       AliInfo("DRM was not present: - V2718 end patch decoding -");
1132   }
1133   /*** V2718 patch ***/
1134  
1135   if (fVerbose)
1136     AliInfo("Decoder is exiting succesfully.");
1137
1138   return(fDecoderSummaryData->GetErrorDetected());  
1139 }
1140
1141 //_________________________________________________________________
1142
1143 void
1144 AliTOFDecoderV2::FillDRMSummaryData(const AliTOFDRMGlobalHeader *DRMGlobalHeader)
1145 {
1146   /*
1147    *
1148    * FillDRMSummaryData
1149    *
1150    */
1151
1152   fDRMSummaryData->SetHeader(kTRUE);
1153   fDRMSummaryData->SetSlotID(DRMGlobalHeader->GetSlotID());
1154   fDRMSummaryData->SetEventWords(DRMGlobalHeader->GetEventWords());
1155   fDRMSummaryData->SetDRMID(DRMGlobalHeader->GetDRMID());
1156 }
1157
1158 //_________________________________________________________________
1159
1160 void
1161 AliTOFDecoderV2::FillDRMSummaryData(const AliTOFDRMGlobalTrailer *DRMGlobalTrailer)
1162 {
1163   /*
1164    *
1165    * FillDRMSummaryData
1166    *
1167    */
1168
1169   fDRMSummaryData->SetTrailer(kTRUE);
1170   fDRMSummaryData->SetLocalEventCounter(DRMGlobalTrailer->GetLocalEventCounter());
1171 }
1172
1173 //_________________________________________________________________
1174
1175 void
1176 AliTOFDecoderV2::FillDRMSummaryData(const AliTOFDRMStatusHeader1 *DRMStatusHeader1)
1177 {
1178   /*
1179    *
1180    * FillDRMSummaryData
1181    *
1182    */
1183
1184   fDRMSummaryData->SetPartecipatingSlotID(DRMStatusHeader1->GetPartecipatingSlotID());
1185   fDRMSummaryData->SetCBit(DRMStatusHeader1->GetCBit());
1186   fDRMSummaryData->SetVersID(DRMStatusHeader1->GetVersID());
1187   fDRMSummaryData->SetDRMhSize(DRMStatusHeader1->GetDRMhSize());
1188 }
1189
1190 //_________________________________________________________________
1191
1192 void
1193 AliTOFDecoderV2::FillDRMSummaryData(const AliTOFDRMStatusHeader2 *DRMStatusHeader2)
1194 {
1195   /*
1196    *
1197    * FillDRMSummaryData
1198    *
1199    */
1200
1201   fDRMSummaryData->SetSlotEnableMask(DRMStatusHeader2->GetSlotEnableMask());
1202   fDRMSummaryData->SetFaultID(DRMStatusHeader2->GetFaultID());
1203   fDRMSummaryData->SetRTOBit(DRMStatusHeader2->GetRTOBit());
1204 }
1205
1206 //_________________________________________________________________
1207
1208 void
1209 AliTOFDecoderV2::FillDRMSummaryData(const AliTOFDRMStatusHeader3 *DRMStatusHeader3)
1210 {
1211   /*
1212    *
1213    * FillDRMSummaryData
1214    *
1215    */
1216
1217   fDRMSummaryData->SetL0BCID(DRMStatusHeader3->GetL0BCID());
1218   fDRMSummaryData->SetRunTimeInfo(DRMStatusHeader3->GetRunTimeInfo());
1219 }
1220
1221 //_________________________________________________________________
1222
1223 void
1224 AliTOFDecoderV2::FillDRMSummaryData(const AliTOFDRMStatusHeader4 *DRMStatusHeader4)
1225 {
1226   /*
1227    *
1228    * FillDRMSummaryData
1229    *
1230    */
1231
1232   fDRMSummaryData->SetTemperature(DRMStatusHeader4->GetTemperature());
1233   fDRMSummaryData->SetACKBit(DRMStatusHeader4->GetACKBit());
1234   fDRMSummaryData->SetSensAD(DRMStatusHeader4->GetSensAD());
1235 }
1236
1237 //_________________________________________________________________
1238
1239 void
1240 AliTOFDecoderV2::FillDRMSummaryData(const AliTOFDRMEventCRC *DRMEventCRC)
1241 {
1242   /*
1243    *
1244    * FillDRMSummaryData
1245    *
1246    */
1247
1248   fDRMSummaryData->SetEventCRC(DRMEventCRC->GetEventCRC());
1249 }
1250
1251 //_________________________________________________________________
1252
1253 void
1254 AliTOFDecoderV2::FillLTMSummaryData(const AliTOFLTMGlobalHeader *LTMGlobalHeader)
1255 {
1256   /*
1257    *
1258    * FillLTMSummaryData
1259    *
1260    */
1261
1262   fLTMSummaryData->SetHeader(kTRUE);
1263   fLTMSummaryData->SetSlotID(LTMGlobalHeader->GetSlotID());
1264   fLTMSummaryData->SetEventWords(LTMGlobalHeader->GetEventWords());
1265   fLTMSummaryData->SetCBit(LTMGlobalHeader->GetCBit());
1266   fLTMSummaryData->SetFault(LTMGlobalHeader->GetFault());
1267 }
1268
1269 //_________________________________________________________________
1270
1271 void
1272 AliTOFDecoderV2::FillLTMSummaryData(const AliTOFLTMGlobalTrailer *LTMGlobalTrailer)
1273 {
1274   /*
1275    *
1276    * FillLTMSummaryData
1277    *
1278    */
1279
1280   fLTMSummaryData->SetTrailer(kTRUE);
1281   fLTMSummaryData->SetEventCRC(LTMGlobalTrailer->GetEventCRC());
1282   fLTMSummaryData->SetEventNumber(LTMGlobalTrailer->GetEventNumber());
1283 }
1284
1285 //_________________________________________________________________
1286
1287 void
1288 AliTOFDecoderV2::FillLTMSummaryData(const AliTOFLTMPDLData *LTMPDLData, Int_t PDLWord)
1289 {
1290   /*
1291    *
1292    * FillLTMSummaryData
1293    *
1294    */
1295
1296   fLTMSummaryData->SetPDL(4 * PDLWord + 0, LTMPDLData->GetPDLValue1());
1297   fLTMSummaryData->SetPDL(4 * PDLWord + 1, LTMPDLData->GetPDLValue2());
1298   fLTMSummaryData->SetPDL(4 * PDLWord + 2, LTMPDLData->GetPDLValue3());
1299   fLTMSummaryData->SetPDL(4 * PDLWord + 3, LTMPDLData->GetPDLValue4());
1300 }
1301
1302 //_________________________________________________________________
1303
1304 void
1305 AliTOFDecoderV2::FillLTMSummaryData(const AliTOFLTMADCData *LTMADCData, Int_t ADCWord)
1306 {
1307   /*
1308    *
1309    * FillLTMSummaryData
1310    *
1311    */
1312
1313   fLTMSummaryData->SetADC(3 * ADCWord + 0, LTMADCData->GetADCValue1());
1314   fLTMSummaryData->SetADC(3 * ADCWord + 1, LTMADCData->GetADCValue2());
1315   fLTMSummaryData->SetADC(3 * ADCWord + 2, LTMADCData->GetADCValue3());
1316 }
1317
1318 //_________________________________________________________________
1319
1320 void
1321 AliTOFDecoderV2::FillLTMSummaryData(const AliTOFLTMORData *LTMORData, Int_t ORWord)
1322 {
1323   /*
1324    *
1325    * FillLTMSummaryData
1326    *
1327    */
1328
1329   fLTMSummaryData->SetOR(3 * ORWord + 0, LTMORData->GetORValue1());
1330   fLTMSummaryData->SetOR(3 * ORWord + 1, LTMORData->GetORValue2());
1331   fLTMSummaryData->SetOR(3 * ORWord + 2, LTMORData->GetORValue3());
1332 }
1333
1334 //_________________________________________________________________
1335
1336 void
1337 AliTOFDecoderV2::FillTRMSummaryData(const AliTOFTRMGlobalHeader *TRMGlobalHeader)
1338 {
1339   /*
1340    *
1341    * FillTRMSummaryData
1342    *
1343    */
1344
1345   fTRMSummaryData->SetHeader(kTRUE);
1346   fTRMSummaryData->SetSlotID(TRMGlobalHeader->GetSlotID());
1347   fTRMSummaryData->SetEventWords(TRMGlobalHeader->GetEventWords());
1348   fTRMSummaryData->SetACQBits(TRMGlobalHeader->GetACQBits());
1349   fTRMSummaryData->SetLBit(TRMGlobalHeader->GetLBit());
1350   fTRMSummaryData->SetEBit(TRMGlobalHeader->GetEBit());
1351 }
1352
1353 //_________________________________________________________________
1354
1355 void
1356 AliTOFDecoderV2::FillTRMSummaryData(const AliTOFTRMGlobalTrailer *TRMGlobalTrailer)
1357 {
1358   /*
1359    *
1360    * FillTRMSummaryData
1361    *
1362    */
1363
1364   fTRMSummaryData->SetTrailer(kTRUE);
1365   fTRMSummaryData->SetEventCRC(TRMGlobalTrailer->GetEventCRC());
1366   fTRMSummaryData->SetEventCounter(TRMGlobalTrailer->GetEventCounter());
1367 }
1368
1369 //_________________________________________________________________
1370
1371 void
1372 AliTOFDecoderV2::FillChainSummaryData(const AliTOFTRMChainHeader *TRMChainHeader)
1373 {
1374   /*
1375    *
1376    * FillChainSummaryData
1377    *
1378    */
1379
1380   fChainSummaryData->SetHeader(kTRUE);
1381   switch (*(UInt_t *)TRMChainHeader & WORD_TYPE_MASK){
1382   case CHAIN_A_HEADER:
1383     fChainSummaryData->SetChain(0);
1384     break;
1385   case CHAIN_B_HEADER:
1386     fChainSummaryData->SetChain(1);
1387     break;
1388   }
1389   fChainSummaryData->SetBunchID(TRMChainHeader->GetBunchID());
1390   fChainSummaryData->SetPB24Temp(TRMChainHeader->GetPB24Temp());
1391   fChainSummaryData->SetPB24ID(TRMChainHeader->GetPB24ID());
1392   fChainSummaryData->SetTSBit(TRMChainHeader->GetTSBit());
1393 }
1394
1395 //_________________________________________________________________
1396
1397 void
1398 AliTOFDecoderV2::FillChainSummaryData(const AliTOFTRMChainTrailer *TRMChainTrailer)
1399 {
1400   /*
1401    *
1402    * FillChainSummaryData
1403    *
1404    */
1405
1406   fChainSummaryData->SetTrailer(kTRUE);
1407   fChainSummaryData->SetStatus(TRMChainTrailer->GetStatus());
1408   fChainSummaryData->SetEventCounter(TRMChainTrailer->GetEventCounter());
1409 }
1410
1411 //_________________________________________________________________
1412
1413 void
1414 AliTOFDecoderV2::ResetSpider()
1415 {                     
1416   //reset condition
1417   if (fVerbose)
1418     AliInfo("Reset signal received, empty and reset buffer");
1419   for (Int_t iChan = 0; iChan < N_CHANNEL; iChan++){
1420     if (fSpiderBufferFull[iChan]) {
1421       if (fVerbose)
1422         AliInfo(Form("Spider buffer is full for channel %d", iChan));
1423       fSpiderTDCPackedHitBuffer->Add(fSpiderBuffer[iChan]);
1424     }
1425     fSpiderBufferFull[iChan] = kFALSE;
1426   }
1427   fSpiderTDCID = -1;
1428   return;
1429 }
1430
1431 void
1432 AliTOFDecoderV2::Spider(AliTOFTDCHit &hit){
1433   
1434   if (fVerbose)
1435     AliInfo("Hit has been received from decode main routine");
1436
1437   //check new TDC
1438   if (fSpiderTDCID != hit.GetTDCID()){
1439     if (fVerbose)
1440       AliInfo("Data coming from a new TDC, empty and reset buffer");
1441     for (Int_t iChan = 0; iChan < N_CHANNEL; iChan++){
1442       if (fSpiderBufferFull[iChan])
1443         fSpiderTDCPackedHitBuffer->Add(fSpiderBuffer[iChan]);
1444       fSpiderBufferFull[iChan] = kFALSE;
1445     }
1446     fSpiderTDCPackedHitBuffer = fTDCPackedHitBuffer;
1447     fSpiderTDCID = hit.GetTDCID();
1448   }           
1449
1450   //switch PS bits
1451   switch(hit.GetPSBits()){
1452     //leading hit
1453   case LEADING_HIT_PS:
1454     //check buffer status
1455     if (fSpiderBufferFull[hit.GetChan()]){ //buffer full
1456       fSpiderTDCPackedHitBuffer->Add(fSpiderBuffer[hit.GetChan()]); //buffered hit is orphane
1457       fSpiderBuffer[hit.GetChan()] = hit; //current hit into buffer
1458       if (fVerbose)
1459         AliInfo("Leading hit and buffer full, buffered hit is a orphane leading hit");
1460     } 
1461     else{ //buffer empty
1462       fSpiderBuffer[hit.GetChan()] = hit; //current hit into buffer
1463       fSpiderBufferFull[hit.GetChan()] = kTRUE; //set buffer full
1464     }
1465     break;
1466     //trailing hit
1467   case TRAILING_HIT_PS:
1468     //check buffer status
1469     if (fSpiderBufferFull[hit.GetChan()]){ //buffer full
1470       fSpiderTDCPackedHitBuffer->Add(fSpiderBuffer[hit.GetChan()] << hit); //pack hits (Leading << Trailing) and save
1471       fSpiderBufferFull[hit.GetChan()] = kFALSE; //unset buffer full
1472       if (fVerbose)
1473         AliInfo("Trailing hit and buffer full, pack leading and trailing hit");
1474     } 
1475     else{ //buffer empty
1476       ; //do nothing
1477       if (fVerbose)
1478         AliInfo("Trailing hit and buffer empty, trow trailing hit away");
1479     }
1480     break;
1481   } //switch PS bits
1482
1483 }
1484
1485 //_________________________________________________________________
1486
1487 Bool_t 
1488 AliTOFDecoderV2::DecodeNext()
1489 {
1490   /* decode next */
1491
1492   if (!fRawReader || !fRawReader->ReadHeader())
1493     return kFALSE;
1494
1495   const Int_t size = fRawReader->GetDataSize(); 
1496   UChar_t *data = new UChar_t[size];
1497   if (fRawReader->ReadNext(data, size) != 1) {
1498     delete [] data;
1499     return kFALSE;
1500   }
1501       
1502   /* decode equipment data */
1503   SetEquipmentID(fRawReader->GetEquipmentId());
1504   Decode((UInt_t *)data, size / 4);
1505
1506   delete [] data;
1507   return kTRUE;
1508 }