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