MUON/AliMUONRawStreamTrackerHP.cxx

   1 /**************************************************************************
   2  * This file is property of and copyright by the ALICE HLT Project        *
   3  * All rights reserved.                                                   *
   4  *                                                                        *
   5  * Primary Authors:                                                       *
   6  *   Artur Szostak <artursz@iafrica.com>                                  *
   7  *                                                                        *
   8  * Permission to use, copy, modify and distribute this software and its   *
   9  * documentation strictly for non-commercial purposes is hereby granted   *
  10  * without fee, provided that the above copyright notice appears in all   *
  11  * copies and that both the copyright notice and this permission notice   *
  12  * appear in the supporting documentation. The authors make no claims     *
  13  * about the suitability of this software for any purpose. It is          *
  14  * provided "as is" without express or implied warranty.                  *
  15  **************************************************************************/
  16
  17 /* $Id$*/
  18
  19 ///
  20 /// \file   AliMUONRawStreamTrackerHP.cxx
  21 /// \author Artur Szostak <artursz@iafrica.com>
  22 /// \date   29-11-2007
  23 /// \brief  Implementation of the the high performance decoder AliMUONRawStreamTrackerHP.
  24 ///
  25
  26 //-----------------------------------------------------------------------------
  27 /// \ingroup raw
  28 /// \class AliMUONRawStreamTrackerHP
  29 /// \brief A high performance stream decoder for muon tracking DDL streams.
  30 ///
  31 /// This is the raw stream class which interfaces between the high performance
  32 /// core decoder and the AliRawReader class.
  33 /// To gain the most out of the decoder, the Next() method which returns batches
  34 /// of decoded digit / channel information should be used. That is:
  35 /// \code
  36 ///   const AliBusPatch* Next();
  37 /// \endcode
  38 ///
  39 /// This decoder tries to implement as similar an interface as possible to
  40 /// AliMUONRawStreamTracker where possible. However certain constructs which
  41 /// would slow us down too much are avoided.
  42 ///
  43 /// \author Artur Szostak <artursz@iafrica.com>
  44 //-----------------------------------------------------------------------------
  45
  46 #include "AliMUONRawStreamTrackerHP.h"
  47 #include "AliMUONDspHeader.h"
  48 #include "AliMUONBlockHeader.h"
  49 #include "AliMUONBusStruct.h"
  50 #include "AliMUONDDLTracker.h"
  51 #include "AliRawReader.h"
  52 #include "AliLog.h"
  53 #include <cassert>
  54 #include <iostream>
  55 #include <iomanip>
  56 using std::cout;
  57 using std::endl;
  58 using std::hex;
  59 using std::dec;
  60
  61 /// \cond CLASSIMP
  62 ClassImp(AliMUONRawStreamTrackerHP)
  63 /// \endcond
  64
  65
  66 AliMUONRawStreamTrackerHP::AliMUONRawStreamTrackerHP() :
  67         AliMUONVRawStreamTracker(),
  68         fDecoder(),
  69         fDDL(0),
  70         fBufferSize(8192),
  71         fBuffer(new UChar_t[8192]),
  72         fCurrentBusPatch(NULL),
  73         fCurrentData(NULL),
  74         fEndOfData(NULL),
  75         fHadError(kFALSE),
  76         fDone(kFALSE),
  77         fDDLObject(NULL)
  78 {
  79         ///
  80         /// Default constructor.
  81         ///
  82
  83         // Must set this flag to get all information about parity errors though
  84         // the OnData method. OnError gets them either way.
  85         fDecoder.ExitOnError(false);
  86         fDecoder.SendDataOnParityError(true);
  87
  88         fDecoder.GetHandler().SetMaxStructs(
  89                         fDecoder.MaxBlocks(),
  90                         fDecoder.MaxDSPs(),
  91                         fDecoder.MaxBusPatches()
  92                 );
  93
  94         fDecoder.GetHandler().SetRawStream(this);
  95 }
  96
  97
  98 AliMUONRawStreamTrackerHP::AliMUONRawStreamTrackerHP(AliRawReader* rawReader) :
  99         AliMUONVRawStreamTracker(rawReader),
 100         fDecoder(),
 101         fDDL(0),
 102         fBufferSize(8192),
 103         fBuffer(new UChar_t[8192]),
 104         fCurrentBusPatch(NULL),
 105         fCurrentData(NULL),
 106         fEndOfData(NULL),
 107         fHadError(kFALSE),
 108         fDone(kFALSE),
 109         fDDLObject(NULL)
 110 {
 111         ///
 112         /// Constructor with AliRawReader as argument.
 113         ///
 114
 115         // Must set this flag to get all information about parity errors though
 116         // the OnData method. OnError gets them either way.
 117         fDecoder.ExitOnError(false);
 118         fDecoder.SendDataOnParityError(true);
 119
 120         fDecoder.GetHandler().SetMaxStructs(
 121                         fDecoder.MaxBlocks(),
 122                         fDecoder.MaxDSPs(),
 123                         fDecoder.MaxBusPatches()
 124                 );
 125
 126         fDecoder.GetHandler().SetRawStream(this);
 127 }
 128
 129
 130 AliMUONRawStreamTrackerHP::~AliMUONRawStreamTrackerHP()
 131 {
 132         ///
 133         /// Default destructor.
 134         ///
 135
 136         if (fBuffer != NULL)
 137         {
 138                 delete [] fBuffer;
 139         }
 140         if (fDDLObject != NULL)
 141         {
 142                 delete fDDLObject;
 143         }
 144 }
 145
 146
 147 void AliMUONRawStreamTrackerHP::First()
 148 {
 149         /// Initialise or reset the iterator.
 150         /// The first DDL will be found and decoded.
 151
 152         assert( GetReader() != NULL );
 153
 154         fDDL = 0;
 155         fDone = kFALSE;
 156         NextDDL();
 157 }
 158
 159
 160 Bool_t AliMUONRawStreamTrackerHP::NextDDL()
 161 {
 162         /// Reading the next tracker DDL and decode the payload with the
 163         /// high performance decoder.
 164         /// \return kTRUE if the next DDL was successfully read and kFALSE otherwise.
 165
 166         assert( GetReader() != NULL );
 167
 168         // The temporary object if generated in GetDDLTracker, is now stale,
 169         // so delete it.
 170         if (fDDLObject != NULL)
 171         {
 172                 delete fDDLObject;
 173                 fDDLObject = NULL;
 174         }
 175
 176         // Better to reset these pointers.
 177         fCurrentBusPatch = NULL;
 178         fCurrentData = NULL;
 179         fEndOfData = NULL;
 180
 181         while (fDDL < GetMaxDDL())
 182         {
 183                 GetReader()->Reset();
 184                 GetReader()->Select("MUONTRK", fDDL, fDDL);  // Select the DDL file to be read.
 185                 if (GetReader()->ReadHeader()) break;
 186                 AliDebug(3, Form("Skipping DDL %d which does not seem to be there", fDDL+1));
 187                 fDDL++;
 188         }
 189
 190         // If we reach the end of the DDL list for this event then reset the
 191         // DDL counter, mark the iteration as done and exit.
 192         if (fDDL >= GetMaxDDL())
 193         {
 194                 fDDL = 0;
 195                 fDone = kTRUE;
 196                 return kFALSE;
 197         }
 198         else
 199         {
 200                 fDone = kFALSE;
 201         }
 202
 203         AliDebug(3, Form("DDL Number %d\n", fDDL));
 204
 205         Int_t dataSize = GetReader()->GetDataSize(); // in bytes
 206         // Check if we have enough buffer space already in fBuffer. If we do then
 207         // just continue reading otherwise we need to resize the buffer.
 208         if (fBufferSize < dataSize)
 209         {
 210                 if (fBuffer != NULL)
 211                 {
 212                         delete [] fBuffer;
 213                         fBuffer = NULL;
 214                         fBufferSize = 0;
 215                 }
 216                 try
 217                 {
 218                         fBuffer = new UChar_t[dataSize];
 219                         fBufferSize = dataSize;
 220                 }
 221                 catch (const std::bad_alloc&)
 222                 {
 223                         AliError("Could not allocate more buffer space. Cannot decode DDL.");
 224                         return kFALSE;
 225                 }
 226         }
 227
 228         if (not GetReader()->ReadNext(fBuffer, dataSize))
 229         {
 230                 return kFALSE;
 231         }
 232
 233 #ifndef R__BYTESWAP
 234         Swap(reinterpret_cast<UInt_t*>(fBuffer), dataSize / sizeof(UInt_t)); // Swap needed for mac power pc.
 235 #endif
 236
 237         bool result = false;
 238         try
 239         {
 240                 // Since we might allocate memory inside OnNewBuffer in the event
 241                 // handler we need to trap any memory allocation exception to be robust.
 242                 result = fDecoder.Decode(fBuffer, dataSize);
 243                 fHadError = (result == true ? kFALSE : kTRUE);
 244         }
 245         catch (const std::bad_alloc&)
 246         {
 247                 AliError("Could not allocate more buffer space. Cannot decode DDL.");
 248                 return kFALSE;
 249         }
 250
 251         // Update the current bus patch pointers.
 252         fCurrentBusPatch = fDecoder.GetHandler().FirstBusPatch();
 253         if (fCurrentBusPatch != fDecoder.GetHandler().EndOfBusPatch())
 254         {
 255                 fCurrentData = fCurrentBusPatch->GetData();
 256                 fEndOfData = fCurrentData + fCurrentBusPatch->GetDataCount();
 257         }
 258         else
 259         {
 260                 // If the DDL did not have any bus patches then mark both fCurrentData
 261                 // and fEndOfData as NULL so that in Next() we are forced to find the
 262                 // first non empty DDL.
 263                 fCurrentData = fEndOfData = NULL;
 264         }
 265
 266         fDDL++; // Remember to increment index to next DDL.
 267         return kTRUE;
 268 }
 269
 270
 271 Bool_t AliMUONRawStreamTrackerHP::IsDone() const
 272 {
 273         /// Indicates whether the iteration is finished or not.
 274         /// \return kTRUE if we already read all the digits and kFALSE if not.
 275
 276         return fDone;
 277 }
 278
 279
 280 Bool_t AliMUONRawStreamTrackerHP::Next(
 281                 Int_t& busPatchId, UShort_t& manuId, UChar_t& manuChannel,
 282                 UShort_t& adc
 283         )
 284 {
 285         /// Advance one step in the iteration. Returns false if finished.
 286         /// [out] \param busPatchId  This is filled with the bus patch ID of the digit.
 287         /// [out] \param manuId      This is filled with the MANU ID of the digit.
 288         /// [out] \param manuChannel This is filled with the MANU channel ID of the digit.
 289         /// [out] \param adc         This is filled with the ADC signal value of the digit.
 290         /// \return kTRUE if we read another digit and kFALSE if we have read all the
 291         ///    digits already, i.e. at the end of the iteration.
 292
 293         if (fCurrentData == NULL) return kFALSE;
 294
 295 retry:
 296         // Check if we still have data to be returned for the current bus patch.
 297         if (fCurrentData != fEndOfData)
 298         {
 299                 busPatchId = fCurrentBusPatch->GetBusPatchId();
 300                 AliMUONTrackerDDLDecoderEventHandler::UnpackADC(*fCurrentData, manuId, manuChannel, adc);
 301                 fCurrentData++;
 302                 return kTRUE;
 303         }
 304         else
 305         {
 306                 // We hit the end of the current bus patch so check if we have any more
 307                 // bus patches to process for the current DDL. If we do, then increment
 308                 // the current bus patch, make sure it is not the last one and then try
 309                 // reading the first element again.
 310                 if (fCurrentBusPatch != fDecoder.GetHandler().EndOfBusPatch())
 311                 {
 312                         fCurrentBusPatch++;
 313                         if (fCurrentBusPatch != fDecoder.GetHandler().EndOfBusPatch())
 314                         {
 315                                 fCurrentData = fCurrentBusPatch->GetData();
 316                                 fEndOfData = fCurrentData + fCurrentBusPatch->GetDataCount();
 317                                 goto retry;
 318                         }
 319                 }
 320
 321                 // This was the last bus patch in the DDL so read in the next one and
 322                 // try reading the first data element again.
 323                 // Note: fCurrentBusPatch is set inside NextDDL().
 324                 if (NextDDL()) goto retry;
 325         }
 326         return kFALSE;
 327 }
 328
 329
 330 AliMUONDDLTracker* AliMUONRawStreamTrackerHP::GetDDLTracker() const
 331 {
 332         /// Construct and return a pointer to the DDL payload object.
 333         /// \return Pointer to internally constructed AliMUONDDLTracker object.
 334         ///         The object is owned by this class and should not be deleted
 335         ///         by the caller.
 336         ///
 337         /// \note This method should not be used just to gain access to the DDL
 338         /// payload, unless there is a good reason to have the AliMUONDDLTracker
 339         /// object. For example, if you want to modify the data and then save it
 340         /// to another DDL stream. Otherwise it can be an order of magnitude
 341         /// faster to access the DDL headers and data with the GetBlockHeader,
 342         /// GetDspHeader and GetBusPatch methods for example.
 343         /// Refer to the MUONRawStreamTracker.C macro to see how to use the fast
 344         /// decoder interface optimally.
 345
 346         if (fDDLObject != NULL) return fDDLObject;
 347
 348         fDDLObject = new AliMUONDDLTracker;
 349         for (Int_t iBlock = 0; iBlock < (Int_t)GetBlockCount(); iBlock++)
 350         {
 351                 AliMUONBlockHeader blockHeader;
 352                 AliMUONDspHeader dspHeader;
 353                 AliMUONBusStruct busPatch;
 354
 355                 const AliBlockHeader* bh = GetBlockHeader(iBlock);
 356                 // Copy block header and add it to the DDL object.
 357                 memcpy(blockHeader.GetHeader(), bh->GetHeader(), sizeof(AliMUONBlockHeaderStruct));
 358                 fDDLObject->AddBlkHeader(blockHeader);
 359
 360                 for (Int_t iDsp = 0; iDsp < (Int_t)bh->GetDspCount(); iDsp++)
 361                 {
 362                         const AliDspHeader* dh = bh->GetDspHeader(iDsp);
 363                         // Copy DSP header and add it to the DDL object.
 364                         memcpy(dspHeader.GetHeader(), dh->GetHeader(), sizeof(AliMUONDSPHeaderStruct));
 365                         fDDLObject->AddDspHeader(dspHeader, iBlock);
 366
 367                         const AliBusPatch* bp = dh->GetFirstBusPatch();
 368                         while (bp != NULL)
 369                         {
 370                                 // Copy bus patch header, data and add everything into DDL object.
 371                                 memcpy(busPatch.GetHeader(), bp->GetHeader(), sizeof(AliMUONBusPatchHeaderStruct));
 372                                 busPatch.SetAlloc(bp->GetLength());
 373                                 memcpy(busPatch.GetData(), bp->GetData(), bp->GetDataCount()*sizeof(UInt_t));
 374                                 busPatch.SetBlockId(iBlock);
 375                                 busPatch.SetDspId(iDsp);
 376                                 fDDLObject->AddBusPatch(busPatch, iBlock, iDsp);
 377                                 bp = bp->Next();
 378                         }
 379                 }
 380         }
 381
 382         return fDDLObject;
 383 }
 384
 385
 386 void AliMUONRawStreamTrackerHP::SetMaxBlock(Int_t blk)
 387 {
 388         /// Set maximum number of blocks per DDL allowed.
 389         fDecoder.MaxBlocks( (UInt_t) blk );
 390
 391         fDecoder.GetHandler().SetMaxStructs(
 392                         fDecoder.MaxBlocks(),
 393                         fDecoder.MaxDSPs(),
 394                         fDecoder.MaxBusPatches()
 395                 );
 396 }
 397
 398
 399 void AliMUONRawStreamTrackerHP::SetMaxDsp(Int_t dsp)
 400 {
 401         /// Set maximum number of Dsp per block allowed.
 402         fDecoder.MaxDSPs( (UInt_t) dsp );
 403
 404         fDecoder.GetHandler().SetMaxStructs(
 405                         fDecoder.MaxBlocks(),
 406                         fDecoder.MaxDSPs(),
 407                         fDecoder.MaxBusPatches()
 408                 );
 409 }
 410
 411
 412 void AliMUONRawStreamTrackerHP::SetMaxBus(Int_t bus)
 413 {
 414         /// Set maximum number of Buspatch per Dsp allowed.
 415         fDecoder.MaxBusPatches( (UInt_t) bus );
 416
 417         fDecoder.GetHandler().SetMaxStructs(
 418                         fDecoder.MaxBlocks(),
 419                         fDecoder.MaxDSPs(),
 420                         fDecoder.MaxBusPatches()
 421                 );
 422 }
 423
 424 ///////////////////////////////////////////////////////////////////////////////
 425
 426 void AliMUONRawStreamTrackerHP::AliBlockHeader::Print() const
 427 {
 428         /// Print header to screen.
 429
 430         cout << "CRT info"        << endl;
 431         if (fHeader == NULL)
 432         {
 433                 cout << "Header is NULL" << endl;
 434                 return;
 435         }
 436         cout << "DataKey: 0x"     << hex << fHeader->fDataKey << dec << endl;
 437         cout << "TotalLength: "   << fHeader->fTotalLength << endl;
 438         cout << "Length: "        << fHeader->fLength << endl;
 439         cout << "DspId: "         << fHeader->fDSPId << endl;
 440         cout << "L0Trigger: "     << fHeader->fL0Trigger << endl;
 441         cout << "MiniEventId: "   << fHeader->fMiniEventId<< endl;
 442         cout << "EventId1: "      << fHeader->fEventId1 << endl;
 443         cout << "EventId2: "      << fHeader->fEventId2 << endl;
 444 }
 445
 446
 447 void AliMUONRawStreamTrackerHP::AliDspHeader::Print() const
 448 {
 449         /// Print header to screen.
 450
 451         cout << "FRT info"        << endl;
 452         if (fHeader == NULL)
 453         {
 454                 cout << "Header is NULL" << endl;
 455                 return;
 456         }
 457         cout << "DataKey: 0x"     << hex << fHeader->fDataKey << dec << endl;
 458         cout << "TotalLength: "   << fHeader->fTotalLength << endl;
 459         cout << "Length : "       << fHeader->fLength << endl;
 460         cout << "DspId: "         << fHeader->fDSPId << endl;
 461         cout << "BlkL1ATrigger: " << fHeader->fBlkL1ATrigger << endl;
 462         cout << "MiniEventId: "   << fHeader->fMiniEventId << endl;
 463         cout << "L1ATrigger: "    << fHeader->fL1ATrigger << endl;
 464         cout << "L1RTrigger: "    << fHeader->fL1RTrigger << endl;
 465         cout << "PaddingWord: "   << fHeader->fPaddingWord << endl;
 466         cout << "ErrorWord: "     << fHeader->fErrorWord << endl;
 467 }
 468
 469
 470 void AliMUONRawStreamTrackerHP::AliBusPatch::Print(const Option_t* opt) const
 471 {
 472         /// Print header to screen.
 473         cout << "Bus patch info" << endl;
 474         if (fHeader == NULL)
 475         {
 476                 cout << "Header is NULL" << endl;
 477                 return;
 478         }
 479         cout << "DataKey: 0x"    << hex << fHeader->fDataKey << dec << endl;
 480         cout << "fTotalLength: " << fHeader->fTotalLength << endl;
 481         cout << "fLength: "      << fHeader->fLength << endl;
 482         cout << "fBusPatchId: "  << fHeader->fBusPatchId << endl;
 483
 484         if (TString(opt).Contains("all"))
 485         {
 486                 for (UInt_t i = 0; i < fHeader->fLength; ++i)
 487                         cout << "Data["<< i << "] = " << fData[i] << endl;
 488         }
 489 }
 490
 491 ///////////////////////////////////////////////////////////////////////////////
 492
 493 AliMUONRawStreamTrackerHP::AliDecoderEventHandler::AliDecoderEventHandler() :
 494         fRawStream(NULL),
 495         fBufferStart(NULL),
 496         fBlockCount(0),
 497         fBlocks(NULL),
 498         fDSPs(NULL),
 499         fBusPatches(NULL),
 500         fEndOfBusPatches(NULL),
 501         fMaxChannels(8192),
 502         fParityOk(new Bool_t[8192]),
 503         fCurrentBlock(NULL),
 504         fCurrentDSP(NULL),
 505         fCurrentBusPatch(NULL),
 506         fCurrentParityOkFlag(NULL),
 507         fParityErrors(0),
 508         fGlitchErrors(0),
 509         fPaddingErrors(0),
 510         fWarnings(kTRUE)
 511 {
 512         /// Default constructor initialises the internal parity flags buffer to
 513         /// store 8192 elements. This array will grow dynamically if needed.
 514 }
 515
 516
 517 AliMUONRawStreamTrackerHP::AliDecoderEventHandler::~AliDecoderEventHandler()
 518 {
 519         /// Default destructor cleans up the allocated memory.
 520
 521         if (fParityOk != NULL) delete [] fParityOk;
 522         if (fBlocks != NULL) delete [] fBlocks;
 523         if (fDSPs != NULL) delete [] fDSPs;
 524         if (fBusPatches != NULL) delete [] fBusPatches;
 525 }
 526
 527
 528 void AliMUONRawStreamTrackerHP::AliDecoderEventHandler::SetMaxStructs(
 529                 UInt_t maxBlocks, UInt_t maxDsps, UInt_t maxBusPatches
 530         )
 531 {
 532         /// Sets the maximum number of structures allowed.
 533
 534         // Start by clearing the current arrays.
 535         if (fBlocks != NULL)
 536         {
 537                 delete [] fBlocks;
 538                 fBlocks = NULL;
 539         }
 540         if (fDSPs != NULL)
 541         {
 542                 delete [] fDSPs;
 543                 fDSPs = NULL;
 544         }
 545         if (fBusPatches != NULL)
 546         {
 547                 delete [] fBusPatches;
 548                 fBusPatches = NULL;
 549         }
 550         fCurrentBlock = NULL;
 551         fCurrentDSP = NULL;
 552         fCurrentBusPatch = NULL;
 553
 554         // Allocate new memory.
 555         fBlocks = new AliBlockHeader[maxBlocks];
 556         fDSPs = new AliDspHeader[maxBlocks*maxDsps];
 557         fBusPatches = new AliBusPatch[maxBlocks*maxDsps*maxBusPatches];
 558         fEndOfBusPatches = fBusPatches;
 559 }
 560
 561
 562 void AliMUONRawStreamTrackerHP::AliDecoderEventHandler::OnNewBuffer(
 563                 const void* buffer, UInt_t bufferSize
 564         )
 565 {
 566         /// This is called by the high performance decoder when a new DDL payload
 567         /// is about to be decoded.
 568         /// \param buffer  The pointer to the buffer storing the DDL payload.
 569         /// \param bufferSize  The size of the buffer in bytes.
 570
 571         assert( fRawStream != NULL );
 572
 573         // remember the start of the buffer to be used in OnError.
 574         fBufferStart = buffer;
 575
 576         // Reset error counters.
 577         fParityErrors = 0;
 578         fGlitchErrors = 0;
 579         fPaddingErrors = 0;
 580
 581         // Check if we will have enough space in the fParityOk array.
 582         // If we do not then we need to resize the array.
 583         // bufferSize / sizeof(UInt_t) will be a safe over estimate of the
 584         // number of channels that we will find.
 585         UInt_t maxChannelsPossible = bufferSize / sizeof(UInt_t);
 586         if (maxChannelsPossible > fMaxChannels)
 587         {
 588                 if (fParityOk != NULL)
 589                 {
 590                         delete [] fParityOk;
 591                         fParityOk = NULL;
 592                         fMaxChannels = 0;
 593                 }
 594                 fParityOk = new Bool_t[maxChannelsPossible];
 595                 fMaxChannels = maxChannelsPossible;
 596         }
 597
 598         // Reset the current pointers which will be used to track where we need to
 599         // fill fBlocks, fDSPs, fBusPatches and the parity flag. We have to subtract
 600         // one space because we will increment the pointer the first time in the
 601         // OnNewXZY methods.
 602         fCurrentBlock = fBlocks-1;
 603         fCurrentDSP = fDSPs-1;
 604         fCurrentBusPatch = fBusPatches-1;
 605         fCurrentParityOkFlag = fParityOk-1;
 606         fBlockCount = 0;
 607 }
 608
 609
 610 void AliMUONRawStreamTrackerHP::AliDecoderEventHandler::OnError(
 611                 ErrorCode error, const void* location
 612         )
 613 {
 614         /// This is called by the high performance decoder when a error occurs
 615         /// when trying to decode the DDL payload. This indicates corruption in
 616         /// the data. This method converts the error code to a descriptive message
 617         /// and logs this with the raw reader.
 618         /// \param error  The error code indicating the problem.
 619         /// \param location  A pointer to the location within the DDL payload buffer
 620         ///              being decoded where the problem with the data was found.
 621
 622         assert( fRawStream != NULL );
 623         assert( fRawStream->GetReader() != NULL );
 624
 625         Char_t* message = NULL;
 626         UInt_t word = 0;
 627
 628         switch (error)
 629         {
 630         case kGlitchFound:
 631                 fGlitchErrors++;
 632                 message = Form(
 633                         "Glitch error detected in DSP %d, skipping event ",
 634                         fCurrentBlock->GetDspId()
 635                 );
 636                 fRawStream->GetReader()->AddMajorErrorLog(error, message);
 637                 break;
 638
 639         case kBadPaddingWord:
 640                 fPaddingErrors++;
 641                 // We subtract 1 from the current numbers of blocks, DSPs
 642                 // and bus patches to get the indices.
 643                 message = Form(
 644                         "Padding word error for iBlock %d, iDsp %d, iBus %d\n",
 645                         fBlockCount-1,
 646                         fCurrentBlock->GetDspCount()-1,
 647                         fCurrentDSP->GetBusPatchCount()-1
 648                 );
 649                 fRawStream->GetReader()->AddMinorErrorLog(error, message);
 650                 break;
 651
 652         case kParityError:
 653                 fParityErrors++;
 654                 // location points to the incorrect data word and
 655                 // fCurrentBusPatch->GetData() returns a pointer to the start of
 656                 // bus patches data, so the difference divided by 4 gives the 32
 657                 // bit word number.
 658                 word = ((unsigned long)location - (unsigned long)fCurrentBusPatch->GetData())
 659                                 / sizeof(UInt_t);
 660                 message = Form(
 661                         "Parity error in word %d for manuId %d and channel %d in buspatch %d\n",
 662                         word,
 663                         fCurrentBusPatch->GetManuId(word),
 664                         fCurrentBusPatch->GetChannelId(word),
 665                         fCurrentBusPatch->GetBusPatchId()
 666                 );
 667                 fRawStream->GetReader()->AddMinorErrorLog(error, message);
 668                 break;
 669
 670         default:
 671                 message = Form(
 672                         "%s (At byte %d in DDL.)",
 673                         ErrorCodeToMessage(error),
 674                         (unsigned long)location - (unsigned long)fBufferStart + sizeof(AliRawDataHeader)
 675                 );
 676                 fRawStream->GetReader()->AddMajorErrorLog(error, message);
 677                 break;
 678         }
 679
 680         if (fWarnings)
 681         {
 682                 AliWarningGeneral(
 683                                 "AliMUONRawStreamTrackerHP::AliDecoderEventHandler",
 684                                 message
 685                         );
 686         }
 687 }
 688