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