MUON/AliMUONRawStreamTrackerHP.h

   1 #ifndef ALIMUONRAWSTREAMTRACKERHP_H
   2 #define ALIMUONRAWSTREAMTRACKERHP_H
   3 /* This file is property of and copyright by the ALICE HLT Project        *
   4  * ALICE Experiment at CERN, All rights reserved.                         *
   5  * See cxx source for full Copyright notice                               */
   6
   7 /* $Id$*/
   8
   9 ///
  10 /// \file   AliMUONRawStreamTrackerHP.h
  11 /// \author Artur Szostak <artursz@iafrica.com>
  12 /// \date   29-11-2007
  13 /// \brief  Declaration of the high performance decoder for muon trigger chamber raw streams.
  14 ///
  15
  16 #include "AliMUONVRawStreamTracker.h"
  17 #include "AliMUONTrackerDDLDecoder.h"
  18
  19 class AliMUONRawStreamTrackerHP : public AliMUONVRawStreamTracker
  20 {
  21 public:
  22         class AliDspHeader;
  23         class AliBusPatch;
  24
  25         /// Default constructor.
  26         AliMUONRawStreamTrackerHP();
  27
  28         /// Constructor for setting the raw reader.
  29         AliMUONRawStreamTrackerHP(AliRawReader* rawReader);
  30
  31         /// Default destructor.
  32         virtual ~AliMUONRawStreamTrackerHP();
  33
  34         // The following public methods are all inherited from AliMUONVRawStreamTracker:
  35
  36         /// Initialize iterator
  37         virtual void First();
  38
  39         /// DDL iterator
  40         virtual Bool_t NextDDL();
  41
  42         /// Whether the iteration is finished or not
  43         virtual Bool_t IsDone() const;
  44
  45         /// Nothing is actually done in the AddErrorMessage method because we log
  46         /// the error messages as we find them in AliDecoderEventHandler::OnError().
  47         virtual void AddErrorMessage() { };
  48
  49         /// Advance one step in the iteration. Returns false if finished.
  50         virtual Bool_t Next(Int_t& busPatchId,
  51                                 UShort_t& manuId, UChar_t& manuChannel,
  52                                 UShort_t& adc);
  53
  54         /// Returns the next batch of decoded channel data.
  55         const AliBusPatch* Next();
  56
  57         /// Return maximum number of blocks per DDL allowed.
  58         virtual Int_t GetMaxBlock() const { return (Int_t) fDecoder.MaxBlocks(); }
  59         /// Return maximum number of Dsp per block allowed.
  60         virtual Int_t GetMaxDsp() const { return (Int_t) fDecoder.MaxDSPs(); }
  61         /// Return maximum number of Buspatch per Dsp allowed.
  62         virtual Int_t GetMaxBus() const { return (Int_t) fDecoder.MaxBusPatches(); }
  63
  64         /// Set maximum number of blocks per DDL allowed.
  65         virtual void SetMaxBlock(Int_t blk);
  66         /// Set maximum number of Dsp per block allowed.
  67         virtual void SetMaxDsp(Int_t dsp);
  68         /// Set maximum number of Buspatch per Dsp allowed.
  69         virtual void SetMaxBus(Int_t bus);
  70
  71         /// Return number of the current DDL.
  72         virtual Int_t GetDDL() const { return fDDL - 1; }
  73
  74         /// check error/Warning presence
  75         virtual Bool_t IsErrorMessage() const { return fHadError; }
  76
  77         /// Get number of parity errors
  78         Int_t   GetParityErrors() const
  79         {
  80                 return (Int_t) fDecoder.GetHandler().ParityErrorCount();
  81         }
  82
  83         /// Get number of glitch errors
  84         Int_t   GetGlitchErrors() const
  85         {
  86                 return (Int_t) fDecoder.GetHandler().GlitchErrorCount();
  87         }
  88
  89         /// Get number of padding word errors
  90         Int_t   GetPaddingErrors() const
  91         {
  92                 return (Int_t) fDecoder.GetHandler().PaddingErrorCount();
  93         }
  94
  95         /// Set warnings flag to disable warnings on data errors.
  96         void DisableWarnings() { fDecoder.GetHandler().Warnings(kFALSE); }
  97         /// Set warnings flag to enable warnings on data errors.
  98         void EnableWarnings() { fDecoder.GetHandler().Warnings(kTRUE); }
  99
 100         /// Returns the "try to recover from errors" flag.
 101         Bool_t TryRecover() const { return Bool_t(fDecoder.TryRecover()); }
 102
 103         /// Sets the "try to recover from errors" flag.
 104         /// i.e. should the decoder try to recover from errors found in the
 105         /// payload headers.
 106         void TryRecover(Bool_t value) { fDecoder.TryRecover(bool(value)); }
 107
 108         /// Light weight interface class to the block header data.
 109         class AliBlockHeader
 110         {
 111         public:
 112                 /// Default constructor.
 113                 AliBlockHeader(
 114                                 AliDspHeader* dspArray = NULL,
 115                                 const AliMUONBlockHeaderStruct* header = NULL
 116                         )
 117                         : fNext(NULL), fDspCount(0), fFirstDsp(dspArray), fHeader(header)
 118                 {
 119                 }
 120
 121                 /// Implement shallow copying in the copy constructor.
 122                 AliBlockHeader(const AliBlockHeader& o) :
 123                         fNext(o.fNext), fDspCount(o.fDspCount), fFirstDsp(o.fFirstDsp), fHeader(o.fHeader)
 124                 {
 125                 }
 126
 127                 /// Implement shallow copying in the assignment operator.
 128                 AliBlockHeader& operator = (const AliBlockHeader& object)
 129                 {
 130                         memcpy(this, &object, sizeof(AliBlockHeader));
 131                         return *this;
 132                 }
 133
 134                 /// Default destructor.
 135                 ~AliBlockHeader() {};
 136
 137                 /// Return data key word for CRT header
 138                 Int_t   GetDataKey()        const {assert(fHeader != NULL); return fHeader->fDataKey;}
 139                 /// Return total length of block structure (w/o padding word)
 140                 Int_t   GetTotalLength()    const {assert(fHeader != NULL); return fHeader->fTotalLength;}
 141                 /// Return length of raw data
 142                 Int_t   GetLength()         const {assert(fHeader != NULL); return fHeader->fLength;}
 143                 /// Return Dsp id
 144                 Int_t   GetDspId()          const {assert(fHeader != NULL); return fHeader->fDSPId;}
 145                 /// Return L0 trigger word
 146                 Int_t   GetL0Trigger()      const {assert(fHeader != NULL); return fHeader->fL0Trigger;}
 147                 /// Return Bunch Crossing for mini-event id (see TDR chapter 8)
 148                 Int_t   GetMiniEventId()    const {assert(fHeader != NULL); return fHeader->fMiniEventId;}
 149                 /// Return Event Id in bunch crossing
 150                 Int_t   GetEventId1()       const {assert(fHeader != NULL); return fHeader->fEventId1;}
 151                 /// Return Event Id in orbit number
 152                 Int_t   GetEventId2()       const {assert(fHeader != NULL); return fHeader->fEventId2;}
 153
 154                 /// Return the header's raw data.
 155                 const AliMUONBlockHeaderStruct* GetHeader() const {return fHeader;}
 156
 157                 /// Return the next block header.
 158                 const AliBlockHeader* Next() const { return fNext; }
 159
 160                 /// Returns the first AliDspHeader class in this block.
 161                 const AliDspHeader* GetFirstDspHeader() const { return fFirstDsp; }
 162
 163                 /// Returns the number of DSPs within this block.
 164                 UInt_t GetDspCount() const { return fDspCount; }
 165
 166                 /// Return the i'th DSP in this block.
 167                 const AliDspHeader* GetDspHeader(UInt_t i) const
 168                 {
 169                         return i < fDspCount ? GetFirstDspHeader() + i : NULL;
 170                 }
 171
 172                 /// Sets the next block header.
 173                 void SetNext(const AliBlockHeader* next) { fNext = next; }
 174
 175                 /// Increments the DSP count.
 176                 void IncDspCount() { fDspCount++; };
 177
 178                 /// Print the contents of the header to screen.
 179                 void Print() const;
 180
 181         private:
 182
 183                 const AliBlockHeader* fNext;  ///< Pointer to next block.
 184                 UInt_t fDspCount;    ///< The number of AliDspHeader objects found in the array pointed to by fFirstDsp.
 185                 const AliDspHeader* fFirstDsp;  ///< The first DSP associated with this block.
 186                 const AliMUONBlockHeaderStruct*  fHeader;  ///< Pointer to header in DDL payload.
 187         };
 188
 189         /// Light weight interface class to the DSP header data.
 190         class AliDspHeader
 191         {
 192         public:
 193                 /// Default constructor.
 194                 AliDspHeader(
 195                                 const AliBlockHeader* block = NULL,
 196                                 const AliBusPatch* busPatchArray = NULL,
 197                                 const AliMUONDSPHeaderStruct* header = NULL
 198                         ) :
 199                         fBlock(block), fNext(NULL), fBusPatchCount(0),
 200                         fFirstBusPatch(busPatchArray), fHeader(header)
 201                 {
 202                 }
 203
 204                 /// Implement shallow copying in the copy constructor.
 205                 AliDspHeader(const AliDspHeader& o) :
 206                         fBlock(o.fBlock), fNext(o.fNext), fBusPatchCount(o.fBusPatchCount),
 207                         fFirstBusPatch(o.fFirstBusPatch), fHeader(o.fHeader)
 208                 {
 209                 }
 210
 211                 /// Implement shallow copying in the assignment operator.
 212                 AliDspHeader& operator = (const AliDspHeader& object)
 213                 {
 214                         memcpy(this, &object, sizeof(AliDspHeader));
 215                         return *this;
 216                 }
 217
 218                 /// Default destructor.
 219                 ~AliDspHeader() {};
 220
 221                 /// Return Data key word for FRT header
 222                 Int_t   GetDataKey()        const {assert(fHeader != NULL); return fHeader->fDataKey;}
 223                 /// Return total length of block structure
 224                 Int_t   GetTotalLength()    const {assert(fHeader != NULL); return fHeader->fTotalLength;}
 225                 /// Return length of raw data
 226                 Int_t   GetLength()         const {assert(fHeader != NULL); return fHeader->fLength;}
 227                 /// Return Dsp id
 228                 Int_t   GetDspId()          const {assert(fHeader != NULL); return fHeader->fDSPId;}
 229                 /// Return L1 accept in Block Structure (CRT)
 230                 Int_t   GetBlkL1ATrigger()  const {assert(fHeader != NULL); return fHeader->fBlkL1ATrigger;}
 231                 /// Return Mini Event Id in bunch crossing
 232                 Int_t   GetMiniEventId()    const {assert(fHeader != NULL); return fHeader->fMiniEventId;}
 233                 /// Return Number of L1 accept in DSP Structure (FRT)
 234                 Int_t   GetL1ATrigger()     const {assert(fHeader != NULL); return fHeader->fL1ATrigger;}
 235                 /// Return Number of L1 reject in DSP Structure (FRT)
 236                 Int_t   GetL1RTrigger()     const {assert(fHeader != NULL); return fHeader->fL1RTrigger;}
 237                 /// Return padding dummy word for 64 bits transfer
 238                 UInt_t  GetPaddingWord()    const {assert(fHeader != NULL); return fHeader->fPaddingWord;}
 239                 /// Return Error word
 240                 Int_t   GetErrorWord()      const {assert(fHeader != NULL); return fHeader->fErrorWord;}
 241
 242                 /// Return raw data of header
 243                 const AliMUONDSPHeaderStruct* GetHeader() const { return fHeader; }
 244
 245                 /// Return the parent block header.
 246                 const AliBlockHeader* GetBlockHeader() const { return fBlock; }
 247
 248                 /// Return the next DSP header.
 249                 const AliDspHeader* Next() const { return fNext; }
 250
 251                 /// Returns the first AliBusPatch class in this DSP.
 252                 const AliBusPatch* GetFirstBusPatch() const { return fFirstBusPatch; }
 253
 254                 /// Returns the number of bus patches within this DSP.
 255                 UInt_t GetBusPatchCount() const { return fBusPatchCount; }
 256
 257                 /// Return the i'th bus patch in this DSP.
 258                 const AliBusPatch* GetBusPatch(UInt_t i) const
 259                 {
 260                         return i < fBusPatchCount ? GetFirstBusPatch() + i : NULL;
 261                 }
 262
 263                 /// Sets the next DSP header.
 264                 void SetNext(const AliDspHeader* next) { fNext = next; }
 265
 266                 /// Increments the bus patch count.
 267                 void IncBusPatchCount() { fBusPatchCount++; };
 268
 269                 /// Print the contents of the header to screen.
 270                 void Print() const;
 271
 272         private:
 273
 274                 const AliBlockHeader* fBlock;  ///< Pointer to parent block structure.
 275                 const AliDspHeader* fNext;  ///< Pointer to next DSP.
 276                 UInt_t fBusPatchCount;    ///< The number of AliDspHeader objects found in the array pointed to by fFirstBusPatch
 277                 const AliBusPatch* fFirstBusPatch;  ///< The first bus patch of this DSP.
 278                 const AliMUONDSPHeaderStruct*  fHeader;  ///< Pointer to header in DDL payload.
 279         };
 280
 281         /// Light weight interface class to the bus patch data.
 282         class AliBusPatch
 283         {
 284         public:
 285                 /// Default constructor.
 286                 AliBusPatch(
 287                                 const AliDspHeader* dsp = NULL,
 288                                 const AliMUONBusPatchHeaderStruct* header = NULL,
 289                                 const UInt_t* data = NULL,
 290                                 const Bool_t* parityOk = NULL
 291                         ) :
 292                         fDSP(dsp),
 293                         fNext(NULL),
 294                         fHeader(header),
 295                         fData(data),
 296                         fParityOk(parityOk)
 297                 {
 298                 }
 299
 300                 /// Implement shallow copying in the copy constructor.
 301                 AliBusPatch(const AliBusPatch& o) :
 302                         fDSP(o.fDSP),
 303                         fNext(o.fNext),
 304                         fHeader(o.fHeader),
 305                         fData(o.fData),
 306                         fParityOk(o.fParityOk)
 307                 {
 308                 }
 309
 310                 /// Implement shallow copying in the assignment operator.
 311                 AliBusPatch& operator = (const AliBusPatch& object)
 312                 {
 313                         memcpy(this, &object, sizeof(AliBusPatch));
 314                         return *this;
 315                 }
 316
 317                 /// Default destructor.
 318                 ~AliBusPatch() {};
 319
 320                 /// Return Data key word for bus patch header.
 321                 Int_t   GetDataKey()     const {assert(fHeader != NULL); return fHeader->fDataKey;}
 322                 /// Return total length of buspatch structure
 323                 Int_t   GetTotalLength() const {assert(fHeader != NULL); return fHeader->fTotalLength;}
 324                 /// Return length of raw data
 325                 Int_t   GetLength()      const {assert(fHeader != NULL); return fHeader->fLength;}
 326                 /// Return bus patch id
 327                 Int_t   GetBusPatchId()  const {assert(fHeader != NULL); return fHeader->fBusPatchId;}
 328
 329                 /// Return raw data of header
 330                 const AliMUONBusPatchHeaderStruct* GetHeader() const {return fHeader;}
 331                 /// Return raw digit data
 332                 const UInt_t* GetData()  const {return fData;}
 333                 /// Returns the number of raw data words within this bus patch.
 334                 UInt_t GetDataCount() const { return (UInt_t)GetLength(); }
 335
 336                 /// Returns the parity bit of the n'th raw data word.
 337                 Char_t GetParity(UInt_t n) const
 338                 {
 339                         assert( fHeader != NULL && n < fHeader->fLength );
 340                         return (Char_t)(fData[n] >> 31) &  0x1;
 341                 }
 342
 343                 /// Returns the MANU ID of the n'th raw data word.
 344                 UShort_t GetManuId(UInt_t n) const
 345                 {
 346                         assert( fHeader != NULL && n < fHeader->fLength );
 347                         return (UShort_t)(fData[n] >> 18) &  0x7FF;
 348                 }
 349
 350                 /// Returns the channel ID of the n'th raw data word.
 351                 UChar_t GetChannelId(UInt_t n) const
 352                 {
 353                         assert( fHeader != NULL && n < fHeader->fLength );
 354                         return (Char_t)(fData[n] >> 12) & 0x3F;
 355                 }
 356
 357                 /// Returns the charge/signal of the n'th raw data word.
 358                 UShort_t GetCharge(UInt_t n) const
 359                 {
 360                         assert( fHeader != NULL && n < fHeader->fLength );
 361                         return (UShort_t)(fData[n] & 0xFFF);
 362                 }
 363
 364                 /// Returns the n'th raw data word.
 365                 UInt_t GetData(UInt_t n) const
 366                 {
 367                         assert( fHeader != NULL && n < fHeader->fLength );
 368                         return fData[n];
 369                 }
 370
 371                 /// Returns kTRUE if the parity of the n'th raw data word is OK
 372                 /// and kFALSE otherwise.
 373                 Bool_t IsParityOk(UInt_t n) const
 374                 {
 375                         assert( fHeader != NULL && n < fHeader->fLength );
 376                         return fParityOk[n];
 377                 }
 378
 379                 /// Unpacks and returns the fields of the n'th raw data word. kTRUE
 380                 /// is returned if the data word's parity was OK and kFALSE otherwise.
 381                 Bool_t GetData(UInt_t n, UShort_t& manuId, UChar_t& channelId, UShort_t& adc) const
 382                 {
 383                         assert( fHeader != NULL && n < fHeader->fLength );
 384                         AliMUONTrackerDDLDecoderEventHandler::UnpackADC(fData[n], manuId, channelId, adc);
 385                         return fParityOk[n];
 386                 }
 387
 388                 /// Return the parent block header.
 389                 const AliDspHeader* GetDspHeader() const { return fDSP; }
 390
 391                 /// Return the next bus patch header.
 392                 const AliBusPatch* Next() const { return fNext; }
 393
 394                 /// Sets the next bus patch.
 395                 void SetNext(const AliBusPatch* next) { fNext = next; }
 396
 397                 /// Print the contents of the bus patch to screen.
 398                 void Print(const Option_t* opt = "") const;
 399
 400         private:
 401
 402                 const AliDspHeader* fDSP;   ///< The DSP this bus patch belongs to.
 403                 const AliBusPatch* fNext;  ///< Next bus patch object in the DSP.
 404                 const AliMUONBusPatchHeaderStruct*  fHeader;  ///< Pointer to bus patch in DDL payload.
 405                 const UInt_t* fData;  ///< Pointer to the bus patch data.
 406                 const Bool_t* fParityOk;  ///< Array of flags indicating if the parity of the given data word in fData is good or not.
 407         };
 408
 409         /// Return the number of blocks in the DDL payload.
 410         UInt_t GetBlockCount() const
 411         {
 412                 return fDecoder.GetHandler().BlockCount();
 413         }
 414
 415         /// Return the first block header.
 416         const AliBlockHeader* GetFirstBlockHeader() const
 417         {
 418                 return fDecoder.GetHandler().BlockHeader(0);
 419         }
 420
 421         /// Return the i'th block header or NULL if not found.
 422         const AliBlockHeader* GetBlockHeader(UInt_t i) const
 423         {
 424                 return fDecoder.GetHandler().BlockHeader(i);
 425         }
 426
 427         /// Returns the number of DSPs for the given block number.
 428         UInt_t GetDspCount(UInt_t block) const
 429         {
 430                 const AliBlockHeader* b = GetBlockHeader(block);
 431                 return b != NULL ? b->GetDspCount() : 0;
 432         }
 433
 434         /// Returns the i'th DSP header for the given block number or NULL if not found.
 435         const AliDspHeader* GetDspHeader(UInt_t block, UInt_t i) const
 436         {
 437                 const AliBlockHeader* b = GetBlockHeader(block);
 438                 return b != NULL ? b->GetDspHeader(i) : NULL;
 439         }
 440
 441         /// Returns the number of bus patches for the given block and dsp number.
 442         UInt_t GetBusPatchCount(UInt_t block, UInt_t dsp) const
 443         {
 444                 const AliDspHeader* d = GetDspHeader(block, dsp);
 445                 return d != NULL ? d->GetBusPatchCount() : 0;
 446         }
 447
 448         /// Returns the i'th bus patch for the given block and dsp.
 449         const AliBusPatch* GetBusPatch(UInt_t block, UInt_t dsp, UInt_t i) const
 450         {
 451                 const AliDspHeader* d = GetDspHeader(block, dsp);
 452                 return d != NULL ? d->GetBusPatch(i) : NULL;
 453         }
 454
 455         /// Returns the current bus patch being decoded or NULL if none found.
 456         const AliBusPatch* CurrentBusPatch() const
 457         {
 458                 return (fCurrentBusPatch != fDecoder.GetHandler().EndOfBusPatch()) ?
 459                         fCurrentBusPatch : NULL;
 460         }
 461
 462         /// Returns the current DSP being decoded or NULL if none found.
 463         const AliDspHeader* CurrentDspHeader() const
 464         {
 465                 const AliBusPatch* busPatch = CurrentBusPatch();
 466                 return (busPatch != NULL) ? busPatch->GetDspHeader() : NULL;
 467         }
 468
 469         /// Returns the current block header being decoded or NULL if none found.
 470         const AliBlockHeader* CurrentBlockHeader() const
 471         {
 472                 const AliDspHeader* dsp = CurrentDspHeader();
 473                 return (dsp != NULL) ? dsp->GetBlockHeader() : NULL;
 474         }
 475
 476 private:
 477
 478         // Do not allow copying of this class.
 479         /// Not implemented
 480         AliMUONRawStreamTrackerHP(const AliMUONRawStreamTrackerHP& stream);
 481         /// Not implemented
 482         AliMUONRawStreamTrackerHP& operator = (const AliMUONRawStreamTrackerHP& stream);
 483
 484         /// This is the custom event handler (callback interface) class which
 485         /// unpacks raw data words and fills an internal buffer with decoded digits
 486         /// as they are decoded by the high performance decoder.
 487         /// Any errors are logged to the parent AliMUONVRawStreamTracker, so one
 488         /// must set this pointer appropriately before decoding and DDL payload.
 489         class AliDecoderEventHandler : public AliMUONTrackerDDLDecoderEventHandler
 490         {
 491         public:
 492
 493                 /// Default constructor.
 494                 AliDecoderEventHandler();
 495                 /// Default destructor.
 496                 virtual ~AliDecoderEventHandler();
 497
 498                 /// Sets the internal arrays based on the maximum number of structures allowed.
 499                 void SetMaxStructs(UInt_t maxBlocks, UInt_t maxDsps, UInt_t maxBusPatches);
 500
 501                 /// Sets the raw stream object which should be the parent of this class.
 502                 void SetRawStream(AliMUONVRawStreamTracker* rawStream) { fRawStream = rawStream; }
 503
 504                 /// Return the number of blocks found in the payload.
 505                 UInt_t BlockCount() const { return fBlockCount; };
 506
 507                 /// Return the i'th block structure.
 508                 const AliBlockHeader* BlockHeader(UInt_t i) const
 509                 {
 510                         return i < fBlockCount ? &fBlocks[i] : NULL;
 511                 }
 512
 513                 /// Return the first bus patch decoded.
 514                 const AliBusPatch* FirstBusPatch() const { return fBusPatches; }
 515
 516                 /// Returns the marker to the end of bus patches. i.e. one position past the last bus patch.
 517                 const AliBusPatch* EndOfBusPatch() const { return fEndOfBusPatches; }
 518
 519                 /// Returns the number of parity errors found in the DDL.
 520                 UInt_t ParityErrorCount() const { return fParityErrors; }
 521                 /// Returns the number of glitch errors found in the DDL.
 522                 UInt_t GlitchErrorCount() const { return fGlitchErrors; }
 523                 /// Returns the number of padding errors found in the DDL.
 524                 UInt_t PaddingErrorCount() const { return fPaddingErrors; }
 525
 526                 /// Returns the warnings flag.
 527                 Bool_t Warnings() const { return fWarnings; }
 528                 /// Sets the warnings flag.
 529                 void Warnings(Bool_t value) { fWarnings = value; }
 530
 531                 // The following methods are inherited from AliMUONTrackerDDLDecoderEventHandler:
 532
 533                 /// New buffer handler.
 534                 void OnNewBuffer(const void* buffer, UInt_t bufferSize);
 535
 536                 /// End of buffer handler marks the end of bus patches.
 537                 void OnEndOfBuffer(const void* /*buffer*/, UInt_t /*bufferSize*/)
 538                 {
 539                         fEndOfBusPatches = fCurrentBusPatch+1;
 540                 }
 541
 542                 /// New block handler is called by the decoder whenever a new block
 543                 /// structure is found. We just mark the new block and increment the
 544                 /// internal counter.
 545                 void OnNewBlock(const AliMUONBlockHeaderStruct* header, const void* /*data*/);
 546
 547                 /// New DSP handler is called by the decoder whenever a new DSP
 548                 /// structure is found. We just mark the DSP and increment the
 549                 /// appropriate counters.
 550                 void OnNewDSP(const AliMUONDSPHeaderStruct* header, const void* /*data*/);
 551
 552                 /// New bus patch handler.
 553                 /// This is called by the high performance decoder when a new bus patch
 554                 /// is found within the DDL payload.
 555                 void OnNewBusPatch(const AliMUONBusPatchHeaderStruct* header, const void* data);
 556
 557                 /// Raw data word handler.
 558                 void OnData(UInt_t /*data*/, bool parityError)
 559                 {
 560                         assert( fCurrentParityOkFlag < fParityOk + fMaxChannels );
 561                         *(++fCurrentParityOkFlag) = Bool_t(not parityError);
 562                 }
 563
 564                 /// Error handler.
 565                 void OnError(ErrorCode error, const void* location);
 566
 567         private:
 568
 569                 // Do not allow copying of this class.
 570                 /// Not implemented
 571                 AliDecoderEventHandler(const AliDecoderEventHandler& /*obj*/);
 572                 /// Not implemented
 573                 AliDecoderEventHandler& operator = (const AliDecoderEventHandler& /*obj*/);
 574
 575                 AliMUONVRawStreamTracker* fRawStream; //!< Pointer to the parent raw stream object.
 576                 const void* fBufferStart;   //!< Pointer to the start of the current DDL payload buffer.
 577                 UInt_t fBlockCount;  //!< Number of blocks filled in fBlocks.
 578                 AliBlockHeader* fBlocks;  //!< Array of blocks. [0..fMaxBlocks-1]
 579                 AliDspHeader* fDSPs;      //!< Array of DSPs. [0..fMaxDsps*fMaxBlocks-1]
 580                 AliBusPatch* fBusPatches; //!< Array of bus patches. [0..fMaxBusPatches*fMaxDsps*fMaxBlocks-1]
 581                 AliBusPatch* fEndOfBusPatches;  //!< Marks the last bus patch.
 582                 UInt_t fMaxChannels;   //!< Maximum number of elements that can be stored in fParityOk.
 583                 Bool_t* fParityOk;     //!< Array of flags for indicating if the parity is good for a raw data word.
 584                 AliBlockHeader* fCurrentBlock;  //!< Current block in fBlocks.
 585                 AliDspHeader* fCurrentDSP;      //!< Current DSP in fDSPs.
 586                 AliBusPatch* fCurrentBusPatch;  //!< Current bus patch in fBusPatches.
 587                 Bool_t* fCurrentParityOkFlag;  //!< Current parity flag to be set in fParityOk.
 588                 UInt_t fParityErrors;   //!< Number of parity errors found in DDL.
 589                 UInt_t fGlitchErrors;   //!< Number of glitch errors found in DDL.
 590                 UInt_t fPaddingErrors;  //!< Number of padding errors found in DDL.
 591                 Bool_t fWarnings;       //!< Flag indicating if we should generate a warning for errors.
 592         };
 593
 594         AliMUONTrackerDDLDecoder<AliDecoderEventHandler> fDecoder;  //!< The decoder for the DDL payload.
 595         Int_t fDDL;         //!< The current DDL number being handled.
 596         Int_t fBufferSize;  //!< This is the buffer size in bytes of fBuffer.
 597         UChar_t* fBuffer;   //!< This is the buffer in which we store the DDL payload read from AliRawReader.
 598         const AliBusPatch* fCurrentBusPatch;  //!< The current data word to return by Next().
 599         const UInt_t* fCurrentData;  //!< The current data word to return by Next().
 600         const UInt_t* fEndOfData;  //!< The last data word in the current bus patch.
 601         Bool_t fHadError;   //!< Flag indicating if there was a decoding error or not.
 602         Bool_t fDone;       //!< Flag indicating if the iteration is done or not.
 603
 604         ClassDef(AliMUONRawStreamTrackerHP, 0) // High performance decoder for reading MUON raw digits from tracking chamber DDL data.
 605 };
 606
 607 ////////////////////////////////////////////////////////////////////////////////
 608
 609 inline const AliMUONRawStreamTrackerHP::AliBusPatch* AliMUONRawStreamTrackerHP::Next()
 610 {
 611         /// Returns the next batch of decoded channel data.
 612         do {
 613                 if (fCurrentBusPatch != fDecoder.GetHandler().EndOfBusPatch())
 614                         return fCurrentBusPatch++;
 615         } while (NextDDL());
 616         return NULL;
 617 }
 618
 619 inline void AliMUONRawStreamTrackerHP::AliDecoderEventHandler::OnNewBlock(
 620                 const AliMUONBlockHeaderStruct* header, const void* /*data*/
 621         )
 622 {
 623         /// New block handler is called by the decoder whenever a new block
 624         /// structure is found. We just mark the new block and increment the
 625         /// internal counter.
 626
 627         assert( header != NULL );
 628         assert( fBlockCount < (UInt_t)fRawStream->GetMaxBlock() );
 629         // Link the block unless it is the first one.
 630         if (fBlockCount > 0) fCurrentBlock->SetNext(fCurrentBlock+1);
 631         *(++fCurrentBlock) = AliBlockHeader(fCurrentDSP+1, header);
 632         fBlockCount++;
 633 }
 634
 635 inline void AliMUONRawStreamTrackerHP::AliDecoderEventHandler::OnNewDSP(
 636                 const AliMUONDSPHeaderStruct* header, const void* /*data*/
 637         )
 638 {
 639         /// New DSP handler is called by the decoder whenever a new DSP
 640         /// structure is found. We just mark the DSP and increment the
 641         /// appropriate counters.
 642
 643         assert( header != NULL );
 644         assert( fCurrentBlock->GetDspCount() < (UInt_t)fRawStream->GetMaxDsp() );
 645         // Link the DSP unless it is the first one.
 646         if (fCurrentBlock->GetDspCount() > 0) fCurrentDSP->SetNext(fCurrentDSP+1);
 647         *(++fCurrentDSP) = AliDspHeader(fCurrentBlock, fCurrentBusPatch+1, header);
 648         fCurrentBlock->IncDspCount();
 649 }
 650
 651 inline void AliMUONRawStreamTrackerHP::AliDecoderEventHandler::OnNewBusPatch(
 652                 const AliMUONBusPatchHeaderStruct* header, const void* data
 653         )
 654 {
 655         /// New bus patch handler.
 656         /// This is called by the high performance decoder when a new bus patch
 657         /// is found within the DDL payload.
 658
 659         assert( header != NULL );
 660         assert( data != NULL );
 661         assert( fCurrentDSP->GetBusPatchCount() < (UInt_t)fRawStream->GetMaxBus() );
 662         // Link the bus patch unless it is the first one.
 663         if (fCurrentDSP->GetBusPatchCount() > 0) fCurrentBusPatch->SetNext(fCurrentBusPatch+1);
 664         *(++fCurrentBusPatch) = AliBusPatch(
 665                         fCurrentDSP,
 666                         header,
 667                         reinterpret_cast<const UInt_t*>(data),
 668                         fCurrentParityOkFlag+1
 669                 );
 670         fCurrentDSP->IncBusPatchCount();
 671 }
 672
 673 #endif  // ALIMUONRAWSTREAMTRACKERHP_H
 674