AliMUONRawStreamTrackerHP.cxx

Go to the documentation of this file.

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        *
 * All rights reserved.                                                   *
 *                                                                        *
 * Primary Authors:                                                       *
 *   Artur Szostak <artursz@iafrica.com>                                  *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$*/


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

#include "AliMUONRawStreamTrackerHP.h"
#include "AliMUONTrackerDDLDecoder.h"
#include "AliMUONDspHeader.h"
#include "AliMUONBlockHeader.h"
#include "AliMUONBusStruct.h"
#include "AliMUONDDLTracker.h"
#include "AliMUONLogger.h"
#include "AliRawReader.h"
#include "AliRawDataHeaderV3.h"
#include "AliLog.h"
#include "AliDAQ.h"
#include <cassert>
#include <iostream>
using std::cout;
using std::endl;
using std::hex;
using std::dec;

ClassImp(AliMUONRawStreamTrackerHP)

const Int_t AliMUONRawStreamTrackerHP::fgkMaxDDL = 20;

AliMUONRawStreamTrackerHP::AliMUONRawStreamTrackerHP() :
  TObject(),
  fRawReader(NULL),
  fLogger(NULL),
  fDetailLevel(kMediumErrorDetail),
  fEnableMUONErrorLogger(kFALSE),
  fEnableRawReaderErrorLogger(kFALSE),
  fWarnings(kTRUE),
  fDecoder(),
  fDDL(0),
  fBufferSize(8192),
  fBuffer(new UChar_t[8192]),
  fkCurrentBusPatch(NULL),
  fkCurrentData(NULL),
  fkEndOfData(NULL),
  fHadError(kFALSE),
  fDone(kFALSE),
  fDDLObject(NULL),
  fTotalNumberOfGlitchErrors(0),
  fTotalNumberOfParityErrors(0),
  fTotalNumberOfPaddingErrors(0),
  fTotalNumberOfTokenLostErrors(0)
{
  
  // Must set this flag to get all information about parity errors though
  // the OnData method. OnError gets them either way.
  fDecoder.ExitOnError(false);
  fDecoder.SendDataOnParityError(true);

  fDecoder.GetHandler().SetMaxStructs(
      fDecoder.MaxBlocks(),
      fDecoder.MaxDSPs(),
      fDecoder.MaxBusPatches()
    );
  
  fDecoder.GetHandler().SetRawStream(this);
}


AliMUONRawStreamTrackerHP::AliMUONRawStreamTrackerHP(AliRawReader* rawReader) :
  TObject(),
  fRawReader(rawReader),
  fLogger(NULL),
  fDetailLevel(kMediumErrorDetail),
  fEnableMUONErrorLogger(kFALSE),
  fEnableRawReaderErrorLogger(kFALSE),
  fWarnings(kTRUE),
  fDecoder(),
  fDDL(0),
  fBufferSize(8192),
  fBuffer(new UChar_t[8192]),
  fkCurrentBusPatch(NULL),
  fkCurrentData(NULL),
  fkEndOfData(NULL),
  fHadError(kFALSE),
  fDone(kFALSE),
  fDDLObject(NULL),
  fTotalNumberOfGlitchErrors(0),
  fTotalNumberOfParityErrors(0),
  fTotalNumberOfPaddingErrors(0),
  fTotalNumberOfTokenLostErrors(0)
{
  
  // Must set this flag to get all information about parity errors though
  // the OnData method. OnError gets them either way.
  fDecoder.ExitOnError(false);
  fDecoder.SendDataOnParityError(true);

  fDecoder.GetHandler().SetMaxStructs(
      fDecoder.MaxBlocks(),
      fDecoder.MaxDSPs(),
      fDecoder.MaxBusPatches()
    );
  
  fDecoder.GetHandler().SetRawStream(this);
}


AliMUONRawStreamTrackerHP::~AliMUONRawStreamTrackerHP()
{
  
  if (fBuffer != NULL)
  {
    delete [] fBuffer;
  }
  if (fDDLObject != NULL)
  {
    delete fDDLObject;
  }
}


void AliMUONRawStreamTrackerHP::First()
{
  
  assert( GetReader() != NULL );
  
  fDDL = 0;
  fDone = kFALSE;
  NextDDL();
  fTotalNumberOfGlitchErrors = 0;
  fTotalNumberOfPaddingErrors = 0;
  fTotalNumberOfParityErrors = 0;
  fTotalNumberOfTokenLostErrors = 0;
}


Bool_t AliMUONRawStreamTrackerHP::NextDDL()
{

  assert( GetReader() != NULL );
  
  // The temporary object if generated in GetDDLTracker, is now stale,
  // so delete it.
  if (fDDLObject != NULL)
  {
    delete fDDLObject;
    fDDLObject = NULL;
  }
  
  // Better to reset these pointers.
  fkCurrentBusPatch = NULL;
  fkCurrentData = NULL;
  fkEndOfData = NULL;
  
  while (fDDL < GetMaxDDL())
  {
    GetReader()->Reset();
    GetReader()->Select("MUONTRK", fDDL, fDDL);  // Select the DDL file to be read.
    if (GetReader()->ReadHeader()) break;
    AliDebug(3, Form("Skipping DDL %d which does not seem to be there", fDDL+1));
    fDDL++;
  }

  // If we reach the end of the DDL list for this event then reset the
  // DDL counter, mark the iteration as done and exit.
  if (fDDL >= GetMaxDDL())
  {
    fDDL = 0;
    fDone = kTRUE;
    return kFALSE;
  }
  else
  {
    fDone = kFALSE;
  }

  AliDebug(3, Form("DDL Number %d\n", fDDL));
  
  Int_t dataSize = GetReader()->GetDataSize(); // in bytes
  // Check if we have enough buffer space already in fBuffer. If we do then
  // just continue reading otherwise we need to resize the buffer.
  if (fBufferSize < dataSize)
  {
    if (fBuffer != NULL)
    {
      delete [] fBuffer;
      fBuffer = NULL;
      fBufferSize = 0;
    }
    try
    {
      fBuffer = new UChar_t[dataSize];
      fBufferSize = dataSize;
    }
    catch (const std::bad_alloc&)
    {
      AliError("Could not allocate more buffer space. Cannot decode DDL.");
      return kFALSE;
    }
  }
  
  if (not GetReader()->ReadNext(fBuffer, dataSize))
  {
    return kFALSE;
  }
  
#ifndef R__BYTESWAP
  Swap(reinterpret_cast<UInt_t*>(fBuffer), dataSize / sizeof(UInt_t)); // Swap needed for mac power pc.
#endif
  
  fDDL++; // Remember to increment index to next DDL before the calls to
          // fDecoder.Decode since the callback methods of the decoder will
          // use AliMUONRawStreamTrackerHP::GetDDL()
  
  bool result = false;
  try
  {
    // Since we might allocate memory inside OnNewBuffer in the event
    // handler we need to trap any memory allocation exception to be robust.
    result = fDecoder.Decode(fBuffer, dataSize);
    fHadError = (result == true ? kFALSE : kTRUE);
    fTotalNumberOfGlitchErrors += fDecoder.GetHandler().GlitchErrorCount();
    fTotalNumberOfParityErrors += fDecoder.GetHandler().ParityErrorCount();
    fTotalNumberOfPaddingErrors += fDecoder.GetHandler().PaddingErrorCount();
    fTotalNumberOfTokenLostErrors += fDecoder.GetHandler().TokenLostCount();
  }
  catch (const std::bad_alloc&)
  {
    AliError("Could not allocate more buffer space. Cannot decode DDL.");
    return kFALSE;
  }

  // Update the current bus patch pointers.
  fkCurrentBusPatch = fDecoder.GetHandler().FirstBusPatch();
  if (fkCurrentBusPatch != fDecoder.GetHandler().EndOfBusPatch())
  {
    fkCurrentData = fkCurrentBusPatch->GetData();
    fkEndOfData = fkCurrentData + fkCurrentBusPatch->GetDataCount();
  }
  else
  {
    // If the DDL did not have any bus patches then mark both fCurrentData
    // and fEndOfData as NULL so that in Next() we are forced to find the
    // first non empty DDL.
    fkCurrentData = fkEndOfData = NULL;
  }

  return kTRUE;
}


Bool_t AliMUONRawStreamTrackerHP::IsDone() const
{
  
  return fDone;
}


Bool_t AliMUONRawStreamTrackerHP::Next(Int_t& busPatchId, 
                                       UShort_t& manuId, 
                                       UChar_t& manuChannel,
                                       UShort_t& adc, 
                                       Bool_t skipParityErrors)
{
  
  if (fkCurrentData == NULL) return kFALSE;
  
retry:
  // Check if we still have data to be returned for the current bus patch.
  if (fkCurrentData != fkEndOfData)
  {
    busPatchId = fkCurrentBusPatch->GetBusPatchId();
    AliMUONTrackerDDLDecoderEventHandler::UnpackADC(*fkCurrentData, manuId, manuChannel, adc);
    fkCurrentData++;
    return kTRUE;
  }
  else
  {
    // We hit the end of the current bus patch so check if we have any more
    // bus patches to process for the current DDL. If we do, then increment
    // the current bus patch, make sure it is not the last one and then try
    // reading the first element again.
    if (fkCurrentBusPatch != fDecoder.GetHandler().EndOfBusPatch())
    {
      fkCurrentBusPatch++;
      if (fkCurrentBusPatch != fDecoder.GetHandler().EndOfBusPatch())
      {
        fkCurrentData = fkCurrentBusPatch->GetData();
        fkEndOfData = fkCurrentData + fkCurrentBusPatch->GetDataCount();
        if ( skipParityErrors )
        {
          Bool_t ok(kTRUE);
          for ( Int_t i = 0; i < fkCurrentBusPatch->GetLength() && ok; ++ i )
          {
            ok = fkCurrentBusPatch->IsParityOk(i);
          }
          if (!ok) fkCurrentData = fkEndOfData;
        }
        goto retry;
      }
    }

    // This was the last bus patch in the DDL so read in the next one and
    // try reading the first data element again.
    // Note: fCurrentBusPatch is set inside NextDDL().
    if (NextDDL()) goto retry;
  }
  return kFALSE;
}


AliMUONDDLTracker* AliMUONRawStreamTrackerHP::GetDDLTracker() const
{
  
  if (fDDLObject != NULL) return fDDLObject;
  
  fDDLObject = new AliMUONDDLTracker;
  for (Int_t iBlock = 0; iBlock < (Int_t)GetBlockCount(); iBlock++)
  {
    AliMUONBlockHeader blockHeader;
    AliMUONDspHeader dspHeader;
    AliMUONBusStruct busPatch;
    
    const AliBlockHeader* bh = GetBlockHeader(iBlock);
    // Copy block header and add it to the DDL object.
    memcpy(blockHeader.GetHeader(), bh->GetHeader(), sizeof(AliMUONBlockHeaderStruct));
    fDDLObject->AddBlkHeader(blockHeader);
    
    for (Int_t iDsp = 0; iDsp < (Int_t)bh->GetDspCount(); iDsp++)
    {
      const AliDspHeader* dh = bh->GetDspHeader(iDsp);
      // Copy DSP header and add it to the DDL object.
      memcpy(dspHeader.GetHeader(), dh->GetHeader(), sizeof(AliMUONDSPHeaderStruct));
      fDDLObject->AddDspHeader(dspHeader, iBlock);
      
      const AliBusPatch* bp = dh->GetFirstBusPatch();
      while (bp != NULL)
      {
        // Copy bus patch header, data and add everything into DDL object.
        memcpy(busPatch.GetHeader(), bp->GetHeader(), sizeof(AliMUONBusPatchHeaderStruct));
        busPatch.SetAlloc(bp->GetLength());
        memcpy(busPatch.GetData(), bp->GetData(), bp->GetDataCount()*sizeof(UInt_t));
        busPatch.SetBlockId(iBlock);
        busPatch.SetDspId(iDsp);
        fDDLObject->AddBusPatch(busPatch, iBlock, iDsp);
        bp = bp->Next();
      }
    }
  }
  
  return fDDLObject;
}


void AliMUONRawStreamTrackerHP::SetMaxBlock(Int_t blk)
{
  fDecoder.MaxBlocks( (UInt_t) blk );
  
  fDecoder.GetHandler().SetMaxStructs(
      fDecoder.MaxBlocks(),
      fDecoder.MaxDSPs(),
      fDecoder.MaxBusPatches()
    );
}


void AliMUONRawStreamTrackerHP::SetMaxDsp(Int_t dsp)
{
  fDecoder.MaxDSPs( (UInt_t) dsp );
  
  fDecoder.GetHandler().SetMaxStructs(
      fDecoder.MaxBlocks(),
      fDecoder.MaxDSPs(),
      fDecoder.MaxBusPatches()
    );
}


void AliMUONRawStreamTrackerHP::SetMaxBus(Int_t bus)
{
  fDecoder.MaxBusPatches( (UInt_t) bus );
  
  fDecoder.GetHandler().SetMaxStructs(
      fDecoder.MaxBlocks(),
      fDecoder.MaxDSPs(),
      fDecoder.MaxBusPatches()
    );
}


void AliMUONRawStreamTrackerHP::AliBlockHeader::Print() const
{
  
  cout << "CRT info"        << endl;
  if (fHeader == NULL)
  {
    cout << "Header is NULL" << endl;
    return;
  }
  cout << "DataKey: 0x"     << hex << fHeader->fDataKey << dec << endl;
  cout << "TotalLength: "   << fHeader->fTotalLength << endl;
  cout << "Length: "        << fHeader->fLength << endl;
  cout << "DspId: "         << fHeader->fDSPId << endl;
  cout << "L0Trigger: "     << fHeader->fL0Trigger << endl;
  cout << "MiniEventId: "   << fHeader->fMiniEventId<< endl; 
  cout << "EventId1: "      << fHeader->fEventId1 << endl;
  cout << "EventId2: "      << fHeader->fEventId2 << endl;
}


void AliMUONRawStreamTrackerHP::AliDspHeader::Print() const
{
  
  cout << "FRT info"        << endl;
  if (fHeader == NULL)
  {
    cout << "Header is NULL" << endl;
    return;
  }
  cout << "DataKey: 0x"     << hex << fHeader->fDataKey << dec << endl;
  cout << "TotalLength: "   << fHeader->fTotalLength << endl;
  cout << "Length : "       << fHeader->fLength << endl;
  cout << "DspId: "         << fHeader->fDSPId << endl;
  cout << "BlkL1ATrigger: " << fHeader->fBlkL1ATrigger << endl;
  cout << "MiniEventId: "   << fHeader->fMiniEventId << endl;
  cout << "L1ATrigger: "    << fHeader->fL1ATrigger << endl;
  cout << "L1RTrigger: "    << fHeader->fL1RTrigger << endl;
  cout << "PaddingWord: "   << fHeader->fPaddingWord << endl;
  cout << "ErrorWord: "     << fHeader->fErrorWord << endl;
}


void AliMUONRawStreamTrackerHP::AliBusPatch::Print(const Option_t* opt) const
{
  cout << "Bus patch info" << endl;
  if (fHeader == NULL)
  {
    cout << "Header is NULL" << endl;
    return;
  }
  cout << "DataKey: 0x"    << hex << fHeader->fDataKey << dec << endl;
  cout << "fTotalLength: " << fHeader->fTotalLength << endl;
  cout << "fLength: "      << fHeader->fLength << endl;
  cout << "fBusPatchId: "  << fHeader->fBusPatchId << endl;

  if (TString(opt).Contains("all"))
  {
    for (UInt_t i = 0; i < fHeader->fLength; ++i)
      cout << "Data["<< i << "] = " << fData[i] << endl;
  }
}


AliMUONRawStreamTrackerHP::AliDecoderEventHandler::AliDecoderEventHandler() :
  fRawStream(NULL),
  fBufferStart(NULL),
  fBlockCount(0),
  fBlocks(NULL),
  fDSPs(NULL),
  fBusPatches(NULL),
  fEndOfBusPatches(NULL),
  fMaxChannels(8192),
  fParityOk(new Bool_t[8192]),
  fCurrentBlock(NULL),
  fCurrentDSP(NULL),
  fCurrentBusPatch(NULL),
  fCurrentParityOkFlag(NULL),
  fParityErrors(0),
  fGlitchErrors(0),
  fPaddingErrors(0),
  fTokenLostErrors(0),
  fMaxBlocks(),
  fMaxDsps(),
  fMaxBusPatches()
{
}


AliMUONRawStreamTrackerHP::AliDecoderEventHandler::~AliDecoderEventHandler()
{
  
  if (fParityOk != NULL) delete [] fParityOk;
  if (fBlocks != NULL) delete [] fBlocks;
  if (fDSPs != NULL) delete [] fDSPs;
  if (fBusPatches != NULL) delete [] fBusPatches;
}


void AliMUONRawStreamTrackerHP::AliDecoderEventHandler::SetMaxStructs(
    UInt_t maxBlocks, UInt_t maxDsps, UInt_t maxBusPatches
  )
{
  
  // Start by clearing the current arrays.
  if (fBlocks != NULL)
  {
    delete [] fBlocks;
    fBlocks = NULL;
  }
  if (fDSPs != NULL)
  {
    delete [] fDSPs;
    fDSPs = NULL;
  }
  if (fBusPatches != NULL)
  {
    delete [] fBusPatches;
    fBusPatches = NULL;
  }
  fCurrentBlock = NULL;
  fCurrentDSP = NULL;
  fCurrentBusPatch = NULL;
  
  // Allocate new memory.
  fBlocks = new AliBlockHeader[maxBlocks];
  fDSPs = new AliDspHeader[maxBlocks*maxDsps];
  fBusPatches = new AliBusPatch[maxBlocks*maxDsps*maxBusPatches];
  fEndOfBusPatches = fBusPatches;

  fMaxBlocks = maxBlocks;
  fMaxDsps = maxDsps;
  fMaxBusPatches = maxBusPatches;
}


void AliMUONRawStreamTrackerHP::AliDecoderEventHandler::OnNewBuffer(
    const void* buffer, UInt_t bufferSize
  )
{

  // remember the start of the buffer to be used in OnError.
  fBufferStart = buffer;

  // Reset error counters.
  fParityErrors = 0;
  fGlitchErrors = 0;
  fPaddingErrors = 0;
  fTokenLostErrors = 0;

  // Check if we will have enough space in the fParityOk array.
  // If we do not then we need to resize the array.
  // bufferSize / sizeof(UInt_t) will be a safe over estimate of the
  // number of channels that we will find.
  UInt_t maxChannelsPossible = bufferSize / sizeof(UInt_t);
  if (maxChannelsPossible > fMaxChannels)
  {
    if (fParityOk != NULL)
    {
      delete [] fParityOk;
      fParityOk = NULL;
      fMaxChannels = 0;
    }
    fParityOk = new Bool_t[maxChannelsPossible];
    fMaxChannels = maxChannelsPossible;
  }
  
  // Reset the current pointers which will be used to track where we need to
  // fill fBlocks, fDSPs, fBusPatches and the parity flag. We have to subtract
  // one space because we will increment the pointer the first time in the
  // OnNewXZY methods.
  fCurrentBlock = fBlocks-1;
  fCurrentDSP = fDSPs-1;
  fCurrentBusPatch = fBusPatches-1;
  fCurrentParityOkFlag = fParityOk-1;
  fBlockCount = 0;
}


void AliMUONRawStreamTrackerHP::Swap(UInt_t* buffer, Int_t size) const
{
  // swap from little to big endian
  
  typedef struct {
    UInt_t b1:8; 
    UInt_t b2:8; 
    UInt_t b3:8; 
    UInt_t b4:8; 
  } RawWord;
  
  RawWord* word, temp;
  word = (RawWord*) buffer;
  
  for (Int_t i = 0; i < size; i++)
  {
    temp = *(((RawWord*)buffer)+i);
    word->b1 = temp.b4;
    word->b2 = temp.b3;
    word->b3 = temp.b2;
    word->b4 = temp.b1;
    word++;
  }
}


void AliMUONRawStreamTrackerHP::AliDecoderEventHandler::OnError(
    ErrorCode error, const void* location
  )
{
  
  assert(fRawStream != NULL);
  
  const char* message = NULL;
  UInt_t word = 0;
  bool logAsMajorError = true;
  
  // Build the detailed part of the error message if high detail selected.
  const char* detail = "";
  if (fRawStream->GetLoggingDetailLevel() == kHighErrorDetail)
  {
    bool blockPtrOk = fBlockCount > 0;
    bool dspPtrOk = blockPtrOk ? fCurrentBlock->GetDspCount() > 0 : false;
    bool buspatchPtrOk = dspPtrOk ? fCurrentDSP->GetBusPatchCount() > 0 : false;
    // We subtract 1 from the current numbers of blocks, DSPs
    // and bus patches to get the iBlock, iDsp and iBus indices.
    detail = Form(
      "At byte %lu in DDL %d, event %d, iBlock %d, iDsp %d [DSP ID: %d (0x%X)],"
      " iBus %d [bus patch ID: %d (0x%X)].",
      (unsigned long)location - (unsigned long)fBufferStart + sizeof(AliRawDataHeaderV3),
      AliDAQ::DdlID("MUONTRK", fRawStream->GetDDL()),
      fRawStream->GetReader()->GetEventIndex(),
      int(fBlockCount)-1,
      blockPtrOk ? int(fCurrentBlock->GetDspCount())-1 : -1,
      blockPtrOk ? fCurrentBlock->GetDspId() : -1,
      blockPtrOk ? fCurrentBlock->GetDspId() : -1,
      dspPtrOk ? int(fCurrentDSP->GetBusPatchCount())-1 : -1,
      buspatchPtrOk ? fCurrentBusPatch->GetBusPatchId() : -1,
      buspatchPtrOk ? fCurrentBusPatch->GetBusPatchId() : -1
    );
  }
  
  // Build the log message.
  switch (error)
  {
  case kGlitchFound:
    fGlitchErrors++;
    switch (fRawStream->GetLoggingDetailLevel())
    {
    case kLowErrorDetail:
      message = "Glitch error detected.";
      break;
    case kMediumErrorDetail:
      message = Form(
        "Glitch error detected in DSP %d (0x%X), skipping event.",
        fCurrentBlock->GetDspId(), fCurrentBlock->GetDspId()
      );
      break;
    case kHighErrorDetail:
    default:
      message = Form("%s %s", ErrorCodeToMessage(error), detail);
      break;
    }
    logAsMajorError = true;
    break;

  case kBadPaddingWord:
    fPaddingErrors++;
    switch (fRawStream->GetLoggingDetailLevel())
    {
    case kLowErrorDetail:
      message = "Padding word error detected.";
      break;
    case kMediumErrorDetail:
      // We subtract 1 from the current numbers of blocks, DSPs
      // and bus patches to get the indices.
      message = Form(
        "Padding word error for iBlock %d, iDsp %d, iBus %d.",
        fBlockCount-1,
        fCurrentBlock->GetDspCount()-1,
        fCurrentDSP->GetBusPatchCount()-1
      );
      break;
    case kHighErrorDetail:
    default:
      message = Form("%s %s", ErrorCodeToMessage(error), detail);
      break;
    }
    logAsMajorError = false;
    break;

  case kParityError:
    fParityErrors++;
    switch (fRawStream->GetLoggingDetailLevel())
    {
    case kLowErrorDetail:
      message = "Parity error detected.";
      break;
    case kMediumErrorDetail:
      message = Form(
        "Parity error in buspatch %d (0x%X).",
        fCurrentBusPatch->GetBusPatchId(),
        fCurrentBusPatch->GetBusPatchId()
      );
      break;
    case kHighErrorDetail:
    default:
      // location points to the incorrect data word and
      // fCurrentBusPatch->GetData() returns a pointer to the start of
      // bus patches data, so the difference divided by 4 gives the 32
      // bit word number.
      word = (reinterpret_cast<size_t>(location) - reinterpret_cast<size_t>(fCurrentBusPatch->GetData()))
        / sizeof(UInt_t);
      message = Form(
        "Parity error in word %d for manuId %d and channel %d in buspatch %d. %s",
        word,
        fCurrentBusPatch->GetManuId(word),
        fCurrentBusPatch->GetChannelId(word),
        fCurrentBusPatch->GetBusPatchId(),
        detail
      );
      break;
    }
    logAsMajorError = false;
    break;
    
  case kTokenLost:
    fTokenLostErrors++;
    switch (fRawStream->GetLoggingDetailLevel())
    {
    case kLowErrorDetail:
      message = "Lost token error detected.";
      break;
    case kMediumErrorDetail:
      word = *reinterpret_cast<const UInt_t*>(location);
      message = Form(
        "Lost token error detected with address 0x%X of DDL %d and code %d.",
        ((word & 0xFFFF0000)),
        fRawStream->GetDDL(),
        (word & 0xF)
      );
      break;
    case kHighErrorDetail:
    default:
      word = *reinterpret_cast<const UInt_t*>(location);
      message = Form(
        "Lost token error detected with address 0x%X and code %d. %s",
        ((word & 0xFFFF0000)),
        (word & 0xF),
        detail
      );
      break;
    }
    logAsMajorError = false;
    break;

  default:
    switch (fRawStream->GetLoggingDetailLevel())
    {
    case kLowErrorDetail:
      message = ErrorCodeToMessage(error);
      break;
    case kMediumErrorDetail:
      message = Form(
        "%s (At byte %lu)",
        ErrorCodeToMessage(error),
        (unsigned long)location - (unsigned long)fBufferStart + sizeof(AliRawDataHeaderV3)
      );
      break;
    case kHighErrorDetail:
    default:
      message = Form(
        "%s Error code: %d (%s). %s",
        ErrorCodeToMessage(error),
        error, ErrorCodeToString(error),
        detail
      );
      break;
    }
    logAsMajorError = true;
    break;
  }
  
  // Now log the error message depending on the logging flags set.
  if (fRawStream->IsRawReaderErrorLoggerEnabled())
  {
    if (logAsMajorError)
      fRawStream->GetReader()->AddMajorErrorLog(Int_t(error), message);
    else
      fRawStream->GetReader()->AddMinorErrorLog(Int_t(error), message);
  }
  if (fRawStream->IsMUONErrorLoggerEnabled())
  {
    AliMUONLogger* logger = fRawStream->GetMUONErrorLogger();
    if (logger != NULL)
    {
      logger->Log(message);
    }
    else
    {
      AliErrorGeneral(
        "AliMUONRawStreamTrackerHP::AliDecoderEventHandler",
        "Enabled logging to AliMUONLogger, but the logger object"
        " was not set with SetMUONErrorLogger()."
      );
    }
  }
  if (fRawStream->IsWarningsEnabled())
  {
    AliWarningGeneral(
        "AliMUONRawStreamTrackerHP::AliDecoderEventHandler",
        message
      );
  }
}