AliMUONRawStreamTrackerHP.h

Go to the documentation of this file.

#ifndef ALIMUONRAWSTREAMTRACKERHP_H
#define ALIMUONRAWSTREAMTRACKERHP_H
/* This file is property of and copyright by the ALICE HLT Project        *
 * ALICE Experiment at CERN, All rights reserved.                         *
 * See cxx source for full Copyright notice                               */

/* $Id$*/


#ifndef ROOT_TObject
#  include "TObject.h"
#endif
#include "AliMUONTrackerDDLDecoder.h"

#include <cstring>

class AliMUONDDLTracker;
class AliRawReader;
class AliMUONLogger;

class AliMUONRawStreamTrackerHP : public TObject
{
public:
  class AliDspHeader;
  class AliBusPatch;
  
  enum EDetailLevel
  {
    kLowErrorDetail,     
    kMediumErrorDetail,  
    kHighErrorDetail     
  };

  AliMUONRawStreamTrackerHP();
  
  AliMUONRawStreamTrackerHP(AliRawReader* rawReader);
  
  virtual ~AliMUONRawStreamTrackerHP();
  
  virtual AliRawReader* GetReader() { return fRawReader; }
  
  void SetReader(AliRawReader* reader) { fRawReader = reader; }
  
  virtual void First();
  
  virtual Bool_t NextDDL();
  
  virtual Bool_t IsDone() const;

  virtual Bool_t Next(Int_t& busPatchId,
          UShort_t& manuId, UChar_t& manuChannel,
          UShort_t& adc) { return Next(busPatchId,manuId,manuChannel,adc,kTRUE); }
  
  virtual Bool_t Next(Int_t& busPatchId,
                      UShort_t& manuId,
                      UChar_t& manuChannel,
                      UShort_t& adc,
                      Bool_t skipParityErrors);

  virtual AliMUONDDLTracker* GetDDLTracker() const;
  
  const AliBusPatch* Next();
  
  virtual Int_t GetMaxBlock() const { return (Int_t) fDecoder.MaxBlocks(); }
  virtual Int_t GetMaxDsp() const { return (Int_t) fDecoder.MaxDSPs(); }
  virtual Int_t GetMaxBus() const { return (Int_t) fDecoder.MaxBusPatches(); }
  
  virtual void SetMaxBlock(Int_t blk);
  virtual void SetMaxDsp(Int_t dsp);
  virtual void SetMaxBus(Int_t bus);
  
  virtual Int_t GetDDL() const { return fDDL - 1; }
  
  virtual Bool_t IsErrorMessage() const { return fHadError; }
  
  Int_t   GetParityErrors() const
  {
    return (Int_t) fDecoder.GetHandler().ParityErrorCount();
  }

  Int_t   GetGlitchErrors() const
  {
    return (Int_t) fDecoder.GetHandler().GlitchErrorCount();
  }

  Int_t   GetPaddingErrors() const
  {
    return (Int_t) fDecoder.GetHandler().PaddingErrorCount();
  }

  Int_t   GetTokenLostErrors() const
  {
    return (Int_t) fDecoder.GetHandler().TokenLostCount();
  }

  void DisableWarnings() { fWarnings = kFALSE; }
  void EnableWarnings() { fWarnings = kTRUE; }
  
  Bool_t IsWarningsEnabled() const { return fWarnings; }

  Bool_t TryRecover() const { return Bool_t(fDecoder.TryRecover()); }
  
  void TryRecover(Bool_t value) { fDecoder.TryRecover(bool(value)); }
  
  Bool_t AutoDetectTrailer() const { return Bool_t(fDecoder.AutoDetectTrailer()); }
  
  void AutoDetectTrailer(Bool_t value) { fDecoder.AutoDetectTrailer(bool(value)); }

  Bool_t CheckForTrailer() const { return Bool_t(fDecoder.CheckForTrailer()); }
  
  void CheckForTrailer(Bool_t value) { fDecoder.CheckForTrailer(bool(value)); }
  
  class AliBlockHeader
  {
  public:
    AliBlockHeader(
        AliDspHeader* dspArray = NULL,
        const AliMUONBlockHeaderStruct* header = NULL
      )
      : fNext(NULL), fDspCount(0), fFirstDsp(dspArray), fHeader(header)
    {
    }
    
    AliBlockHeader(const AliBlockHeader& o) :
      fNext(o.fNext), fDspCount(o.fDspCount), fFirstDsp(o.fFirstDsp), fHeader(o.fHeader)
    {
    }
    
    AliBlockHeader& operator = (const AliBlockHeader& object)
    {
      memcpy(this, &object, sizeof(AliBlockHeader));
      return *this;
    }
  
    ~AliBlockHeader() {};
  
    Int_t   GetDataKey()        const {assert(fHeader != NULL); return fHeader->fDataKey;}
    Int_t   GetTotalLength()    const {assert(fHeader != NULL); return fHeader->fTotalLength;}
    Int_t   GetLength()         const {assert(fHeader != NULL); return fHeader->fLength;}
    Int_t   GetDspId()          const {assert(fHeader != NULL); return fHeader->fDSPId;}
    Int_t   GetL0Trigger()      const {assert(fHeader != NULL); return fHeader->fL0Trigger;}
    Int_t   GetMiniEventId()    const {assert(fHeader != NULL); return fHeader->fMiniEventId;}
    Int_t   GetEventId1()       const {assert(fHeader != NULL); return fHeader->fEventId1;}
    Int_t   GetEventId2()       const {assert(fHeader != NULL); return fHeader->fEventId2;}
  
    const AliMUONBlockHeaderStruct* GetHeader() const {return fHeader;}
    
    const AliBlockHeader* Next() const { return fNext; }
    
    const AliDspHeader* GetFirstDspHeader() const { return fFirstDsp; }
    
    UInt_t GetDspCount() const { return fDspCount; }
  
    const AliDspHeader* GetDspHeader(UInt_t i) const
    {
      return i < fDspCount ? GetFirstDspHeader() + i : NULL;
    }
    
    void SetNext(const AliBlockHeader* next) { fNext = next; }

    void IncDspCount() { fDspCount++; };
    
    void Print() const;
  
  private:
  
    const AliBlockHeader* fNext;  
    UInt_t fDspCount;    
    const AliDspHeader* fFirstDsp;  
    const AliMUONBlockHeaderStruct*  fHeader;  
  };
  
  class AliDspHeader
  {
  public:
    AliDspHeader(
        const AliBlockHeader* block = NULL,
        const AliBusPatch* busPatchArray = NULL,
        const AliMUONDSPHeaderStruct* header = NULL
      ) :
      fBlock(block), fNext(NULL), fBusPatchCount(0),
      fFirstBusPatch(busPatchArray), fHeader(header)
    {
    }
    
    AliDspHeader(const AliDspHeader& o) :
      fBlock(o.fBlock), fNext(o.fNext), fBusPatchCount(o.fBusPatchCount),
      fFirstBusPatch(o.fFirstBusPatch), fHeader(o.fHeader)
    {
    }
    
    AliDspHeader& operator = (const AliDspHeader& object)
    {
      memcpy(this, &object, sizeof(AliDspHeader));
      return *this;
    }
  
    ~AliDspHeader() {};
  
    Int_t   GetDataKey()        const {assert(fHeader != NULL); return fHeader->fDataKey;}
    Int_t   GetTotalLength()    const {assert(fHeader != NULL); return fHeader->fTotalLength;}
    Int_t   GetLength()         const {assert(fHeader != NULL); return fHeader->fLength;}
    Int_t   GetDspId()          const {assert(fHeader != NULL); return fHeader->fDSPId;}
    Int_t   GetBlkL1ATrigger()  const {assert(fHeader != NULL); return fHeader->fBlkL1ATrigger;}
    Int_t   GetMiniEventId()    const {assert(fHeader != NULL); return fHeader->fMiniEventId;}
    Int_t   GetL1ATrigger()     const {assert(fHeader != NULL); return fHeader->fL1ATrigger;}
    Int_t   GetL1RTrigger()     const {assert(fHeader != NULL); return fHeader->fL1RTrigger;}
    UInt_t  GetPaddingWord()    const {assert(fHeader != NULL); return fHeader->fPaddingWord;}
    Int_t   GetErrorWord()      const {assert(fHeader != NULL); return fHeader->fErrorWord;}
  
    const AliMUONDSPHeaderStruct* GetHeader() const { return fHeader; }
    
    const AliBlockHeader* GetBlockHeader() const { return fBlock; }
    
    const AliDspHeader* Next() const { return fNext; }
    
    const AliBusPatch* GetFirstBusPatch() const { return fFirstBusPatch; }
    
    UInt_t GetBusPatchCount() const { return fBusPatchCount; }
  
    const AliBusPatch* GetBusPatch(UInt_t i) const
    {
      return i < fBusPatchCount ? GetFirstBusPatch() + i : NULL;
    }
  
    void SetNext(const AliDspHeader* next) { fNext = next; }

    void IncBusPatchCount() { fBusPatchCount++; };
    
    void Print() const;
  
  private:
  
    const AliBlockHeader* fBlock;  
    const AliDspHeader* fNext;  
    UInt_t fBusPatchCount;    
    const AliBusPatch* fFirstBusPatch;  
    const AliMUONDSPHeaderStruct*  fHeader;  
  };
  
  class AliBusPatch
  {
  public:
    AliBusPatch(
        const AliDspHeader* dsp = NULL,
        const AliMUONBusPatchHeaderStruct* header = NULL,
        const UInt_t* data = NULL,
        const Bool_t* parityOk = NULL
      ) :
      fDSP(dsp),
      fNext(NULL),
      fHeader(header),
      fData(data),
      fParityOk(parityOk)
    {
    }
    
    AliBusPatch(const AliBusPatch& o) :
      fDSP(o.fDSP),
      fNext(o.fNext),
      fHeader(o.fHeader),
      fData(o.fData),
      fParityOk(o.fParityOk)
    {
    }
    
    AliBusPatch& operator = (const AliBusPatch& object)
    {
      memcpy(this, &object, sizeof(AliBusPatch));
      return *this;
    }
  
    ~AliBusPatch() {};
    
    Int_t   GetDataKey()     const {assert(fHeader != NULL); return fHeader->fDataKey;}
    Int_t   GetTotalLength() const {assert(fHeader != NULL); return fHeader->fTotalLength;}
    Int_t   GetLength()      const {assert(fHeader != NULL); return fHeader->fLength;}
    Int_t   GetBusPatchId()  const {assert(fHeader != NULL); return fHeader->fBusPatchId;}

    const AliMUONBusPatchHeaderStruct* GetHeader() const {return fHeader;}
    const UInt_t* GetData()  const {return fData;}
    UInt_t GetDataCount() const { return (UInt_t)GetLength(); }

    Char_t GetParity(UInt_t n) const
    {
      assert( fHeader != NULL && n < fHeader->fLength );
      return (Char_t)(fData[n] >> 31) &  0x1;
    }
    
    UShort_t GetManuId(UInt_t n) const
    {
      assert( fHeader != NULL && n < fHeader->fLength );
      return (UShort_t)(fData[n] >> 18) &  0x7FF;
    }
    
    UChar_t GetChannelId(UInt_t n) const
    {
      assert( fHeader != NULL && n < fHeader->fLength );
      return (Char_t)(fData[n] >> 12) & 0x3F;
    }
    
    UShort_t GetCharge(UInt_t n) const
    {
      assert( fHeader != NULL && n < fHeader->fLength );
      return (UShort_t)(fData[n] & 0xFFF);
    }
    
    UInt_t GetData(UInt_t n) const
    {
      assert( fHeader != NULL && n < fHeader->fLength );
      return fData[n];
    }
    
    Bool_t IsParityOk(UInt_t n) const
    {
      assert( fHeader != NULL && n < fHeader->fLength );
      return fParityOk[n];
    }
    
    Bool_t GetData(UInt_t n, UShort_t& manuId, UChar_t& channelId, UShort_t& adc) const
    {
      assert( fHeader != NULL && n < fHeader->fLength );
      AliMUONTrackerDDLDecoderEventHandler::UnpackADC(fData[n], manuId, channelId, adc);
      return fParityOk[n];
    }
    
    const AliDspHeader* GetDspHeader() const { return fDSP; }
    
    const AliBusPatch* Next() const { return fNext; }
    
    void SetNext(const AliBusPatch* next) { fNext = next; }
    
    void Print(const Option_t* opt = "") const;
  
  private:
  
    const AliDspHeader* fDSP;   
    const AliBusPatch* fNext;  
    const AliMUONBusPatchHeaderStruct*  fHeader;  
    const UInt_t* fData;  
    const Bool_t* fParityOk;  
  };
  
  UInt_t GetBlockCount() const
  {
    return fDecoder.GetHandler().BlockCount();
  }
  
  const AliBlockHeader* GetFirstBlockHeader() const
  {
    return fDecoder.GetHandler().BlockHeader(0);
  }
  
  const AliBlockHeader* GetBlockHeader(UInt_t i) const
  {
    return fDecoder.GetHandler().BlockHeader(i);
  }
  
  UInt_t GetDspCount(UInt_t block) const
  {
    const AliBlockHeader* b = GetBlockHeader(block);
    return b != NULL ? b->GetDspCount() : 0;
  }
  
  const AliDspHeader* GetDspHeader(UInt_t block, UInt_t i) const
  {
    const AliBlockHeader* b = GetBlockHeader(block);
    return b != NULL ? b->GetDspHeader(i) : NULL;
  }
  
  UInt_t GetBusPatchCount(UInt_t block, UInt_t dsp) const
  {
    const AliDspHeader* d = GetDspHeader(block, dsp);
    return d != NULL ? d->GetBusPatchCount() : 0;
  }
  
  const AliBusPatch* GetBusPatch(UInt_t block, UInt_t dsp, UInt_t i) const
  {
    const AliDspHeader* d = GetDspHeader(block, dsp);
    return d != NULL ? d->GetBusPatch(i) : NULL;
  }

  const AliBusPatch* CurrentBusPatch() const
  {
    return (fkCurrentBusPatch != fDecoder.GetHandler().EndOfBusPatch()) ?
      fkCurrentBusPatch : NULL;
  }

  const AliDspHeader* CurrentDspHeader() const
  {
    const AliBusPatch* busPatch = CurrentBusPatch();
    return (busPatch != NULL) ? busPatch->GetDspHeader() : NULL;
  }

  const AliBlockHeader* CurrentBlockHeader() const
  {
    const AliDspHeader* dsp = CurrentDspHeader();
    return (dsp != NULL) ? dsp->GetBlockHeader() : NULL;
  }
  
  virtual void EnabbleErrorLogger() { EnableRawReaderErrorLogger(); }
  
  void EnableMUONErrorLogger() { fEnableMUONErrorLogger = kTRUE; }
  
  void DisableMUONErrorLogger() { fEnableMUONErrorLogger = kFALSE; }
  
  void EnableRawReaderErrorLogger() { fEnableRawReaderErrorLogger = kTRUE; }
  
  void DisableRawReaderErrorLogger() { fEnableRawReaderErrorLogger = kFALSE; }
  
  Bool_t IsMUONErrorLoggerEnabled() const { return fEnableMUONErrorLogger; }
  
  Bool_t IsRawReaderErrorLoggerEnabled() const { return fEnableRawReaderErrorLogger; }
  
  const AliMUONLogger* GetMUONErrorLogger() const { return fLogger; }
  
  AliMUONLogger* GetMUONErrorLogger() { return fLogger; }
  
  void SetMUONErrorLogger(AliMUONLogger* logger) { fLogger = logger; }
  
  EDetailLevel GetLoggingDetailLevel() const { return fDetailLevel; }
  
  void SetLoggingDetailLevel(EDetailLevel level) { fDetailLevel = level; }
  
  UInt_t NumberOfGlitchErrors() const { return fTotalNumberOfGlitchErrors; }
  
  UInt_t NumberOfPaddingErrors() const { return fTotalNumberOfPaddingErrors; }
  
  UInt_t NumberOfParityErrors() const { return fTotalNumberOfParityErrors; }
  
  UInt_t NumberOfTokenLostErrors() const { return fTotalNumberOfTokenLostErrors; }
  
  Bool_t HasGlitchError() const { return NumberOfGlitchErrors() > 0; }
  
  Bool_t HasPaddingError() const { return NumberOfPaddingErrors() > 0; }
  
  Bool_t HasParityError() const { return NumberOfParityErrors() > 0; }
  
  Bool_t HasTokenLostError() const { return NumberOfTokenLostErrors() > 0; }

private:

  // Do not allow copying of this class.
  AliMUONRawStreamTrackerHP(const AliMUONRawStreamTrackerHP& stream);
  AliMUONRawStreamTrackerHP& operator = (const AliMUONRawStreamTrackerHP& stream);
  
  Int_t GetMaxDDL() const { return fgkMaxDDL; }
  
  virtual void Swap(UInt_t* buffer, Int_t size) const;
  
  class AliDecoderEventHandler : public AliMUONTrackerDDLDecoderEventHandler
  {
  public:
  
    AliDecoderEventHandler();
    virtual ~AliDecoderEventHandler();
    
    void SetMaxStructs(UInt_t maxBlocks, UInt_t maxDsps, UInt_t maxBusPatches);
    
    void SetRawStream(AliMUONRawStreamTrackerHP* rawStream) { fRawStream = rawStream; }
    
    UInt_t BlockCount() const { return fBlockCount; };
    
    const AliBlockHeader* BlockHeader(UInt_t i) const
    {
      return i < fBlockCount ? &fBlocks[i] : NULL;
    }

    const AliBusPatch* FirstBusPatch() const { return fBusPatches; }

    const AliBusPatch* EndOfBusPatch() const { return fEndOfBusPatches; }

    UInt_t ParityErrorCount() const { return fParityErrors; }
    UInt_t GlitchErrorCount() const { return fGlitchErrors; }
    UInt_t PaddingErrorCount() const { return fPaddingErrors; }
    UInt_t TokenLostCount() const { return fTokenLostErrors; }
    
    // The following methods are inherited from AliMUONTrackerDDLDecoderEventHandler:
    
    void OnNewBuffer(const void* buffer, UInt_t bufferSize);

    void OnEndOfBuffer(const void* /*buffer*/, UInt_t /*bufferSize*/)
    {
      fEndOfBusPatches = fCurrentBusPatch+1;
    }
    
    void OnNewBlock(const AliMUONBlockHeaderStruct* header, const void* /*data*/);
    
    void OnNewDSP(const AliMUONDSPHeaderStruct* header, const void* /*data*/);
    
    void OnNewBusPatch(const AliMUONBusPatchHeaderStruct* header, const void* data);
    
    void OnData(UInt_t /*data*/, bool parityError)
    {
      assert( fCurrentParityOkFlag < fParityOk + fMaxChannels );
      *(++fCurrentParityOkFlag) = Bool_t(not parityError);
    }
    
    void OnError(ErrorCode error, const void* location);
  
  private:
  
    // Do not allow copying of this class.
    AliDecoderEventHandler(const AliDecoderEventHandler& /*obj*/);
    AliDecoderEventHandler& operator = (const AliDecoderEventHandler& /*obj*/);

    AliMUONRawStreamTrackerHP* fRawStream; 
    const void* fBufferStart;   
    UInt_t fBlockCount;  
    AliBlockHeader* fBlocks;  
    AliDspHeader* fDSPs;      
    AliBusPatch* fBusPatches; 
    AliBusPatch* fEndOfBusPatches;  
    UInt_t fMaxChannels;   
    Bool_t* fParityOk;     
    AliBlockHeader* fCurrentBlock;  
    AliDspHeader* fCurrentDSP;      
    AliBusPatch* fCurrentBusPatch;  
    Bool_t* fCurrentParityOkFlag;  
    UInt_t fParityErrors;   
    UInt_t fGlitchErrors;   
    UInt_t fPaddingErrors;  
    UInt_t fTokenLostErrors;  
    UInt_t fMaxBlocks; 
    UInt_t fMaxDsps; 
    UInt_t fMaxBusPatches; 
  };

  AliRawReader* fRawReader; 
  AliMUONLogger* fLogger; 
  EDetailLevel fDetailLevel;  
  Bool_t fEnableMUONErrorLogger; 
  Bool_t fEnableRawReaderErrorLogger; 
  Bool_t fWarnings;       
  AliMUONTrackerDDLDecoder<AliDecoderEventHandler> fDecoder;  
  Int_t fDDL;         
  Int_t fBufferSize;  
  UChar_t* fBuffer;   
  const AliBusPatch* fkCurrentBusPatch;  
  const UInt_t* fkCurrentData;  
  const UInt_t* fkEndOfData;  
  Bool_t fHadError;   
  Bool_t fDone;       
  mutable AliMUONDDLTracker* fDDLObject; 
  UInt_t fTotalNumberOfGlitchErrors; 
  UInt_t fTotalNumberOfParityErrors; 
  UInt_t fTotalNumberOfPaddingErrors; 
  UInt_t fTotalNumberOfTokenLostErrors; 
  
  static const Int_t fgkMaxDDL; 

  ClassDef(AliMUONRawStreamTrackerHP, 0) // High performance decoder for reading MUON raw digits from tracking chamber DDL data.
};


inline const AliMUONRawStreamTrackerHP::AliBusPatch* AliMUONRawStreamTrackerHP::Next()
{
  if (fkCurrentBusPatch == NULL) return NULL;
  do {
    if (fkCurrentBusPatch != fDecoder.GetHandler().EndOfBusPatch())
      return fkCurrentBusPatch++;
  } while (NextDDL());
  return NULL;
}

inline void AliMUONRawStreamTrackerHP::AliDecoderEventHandler::OnNewBlock(
    const AliMUONBlockHeaderStruct* header, const void* /*data*/
  )
{

  assert( header != NULL );
  assert( fBlockCount < fMaxBlocks );
  // Link the block unless it is the first one.
  if (fBlockCount > 0) fCurrentBlock->SetNext(fCurrentBlock+1);
  *(++fCurrentBlock) = AliBlockHeader(fCurrentDSP+1, header);
  fBlockCount++;
}

inline void AliMUONRawStreamTrackerHP::AliDecoderEventHandler::OnNewDSP(
    const AliMUONDSPHeaderStruct* header, const void* /*data*/
  )
{
  
  assert( header != NULL );
  assert( fCurrentBlock->GetDspCount() < fMaxDsps );
  // Link the DSP unless it is the first one.
  if (fCurrentBlock->GetDspCount() > 0) fCurrentDSP->SetNext(fCurrentDSP+1);
  *(++fCurrentDSP) = AliDspHeader(fCurrentBlock, fCurrentBusPatch+1, header);
  fCurrentBlock->IncDspCount();
}

inline void AliMUONRawStreamTrackerHP::AliDecoderEventHandler::OnNewBusPatch(
    const AliMUONBusPatchHeaderStruct* header, const void* data
  )
{

  assert( header != NULL );
  assert( data != NULL );
  assert( fCurrentDSP->GetBusPatchCount() < fMaxBusPatches );
  // Link the bus patch unless it is the first one. 
  if (fCurrentDSP->GetBusPatchCount() > 0) fCurrentBusPatch->SetNext(fCurrentBusPatch+1);
  *(++fCurrentBusPatch) = AliBusPatch(
      fCurrentDSP,
      header,
      reinterpret_cast<const UInt_t*>(data),
      fCurrentParityOkFlag+1
    );
  fCurrentDSP->IncBusPatchCount();
}

#endif  // ALIMUONRAWSTREAMTRACKERHP_H