AliMUONRawStreamTriggerHP.h

Go to the documentation of this file.

#ifndef ALIMUONRAWSTREAMTRIGGERHP_H
#define ALIMUONRAWSTREAMTRIGGERHP_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$ */

//  This provides a streamer interface to the high performance decoder which
//  is required for AliRoot.
//
//  Author Artur Szostak <artursz@iafrica.com>

#include "AliMUONVRawStreamTrigger.h"
#include "AliMUONTriggerDDLDecoder.h"
#include "TArrayS.h"

class AliMUONDDLTrigger;


class AliMUONRawStreamTriggerHP : public AliMUONVRawStreamTrigger
{
public:
  class AliLocalStruct;

  AliMUONRawStreamTriggerHP();
  AliMUONRawStreamTriggerHP(AliRawReader* rawReader);
  virtual ~AliMUONRawStreamTriggerHP();
  
  virtual void First();
  
  virtual Bool_t NextDDL();
  
  virtual Bool_t IsDone() const;
  
  virtual void AddErrorMessage() { };
  
  virtual Bool_t Next(UChar_t& id,   UChar_t& dec,     Bool_t& trigY,
                      UChar_t& yPos, UChar_t& sXDev,   UChar_t& xDev,
                      UChar_t& xPos, Bool_t& triggerY, Bool_t& triggerX,
                      TArrayS& xPattern, TArrayS& yPattern);
  
  virtual AliMUONDDLTrigger* GetDDLTrigger() const;
  
  const AliLocalStruct* Next();
  
  virtual Int_t GetMaxDDL() const { return fgkMaxDDL; }
  
  virtual Int_t GetMaxReg() const { return (Int_t) fDecoder.MaxRegionals(); }
  
  virtual void SetMaxReg(Int_t reg);
  
  virtual Int_t GetMaxLoc() const { return (Int_t) fDecoder.MaxLocals(); }
  
  virtual void SetMaxLoc(Int_t loc);
  
  virtual Int_t GetDDL() const { return fDDL - 1; }
  
  virtual Bool_t IsErrorMessage() const { return fHadError; }
  
  virtual void DisableWarnings() { fDecoder.GetHandler().Warnings(kFALSE); }
  virtual void EnableWarnings() { fDecoder.GetHandler().Warnings(kTRUE); }
  
  UInt_t GetDarcEoWErrors() const {return fDecoder.GetHandler().GetDarcEoWErrors();}
  
  UInt_t GetGlobalEoWErrors() const {return fDecoder.GetHandler().GetGlobalEoWErrors();}
  
  UInt_t GetRegEoWErrors() const {return fDecoder.GetHandler().GetRegEoWErrors();}
  
  UInt_t GetLocalEoWErrors() const {return fDecoder.GetHandler().GetLocalEoWErrors();}
  
  UInt_t NumberOfDarcEoWErrors() const { return fTotalNumberOfDarcEoWErrors; }
  
  UInt_t NumberOfGlobalEoWErrors() const { return fTotalNumberOfGlobalEoWErrors; }
  
  UInt_t NumberOfRegEoWErrors() const { return fTotalNumberOfRegEoWErrors; }
  
  UInt_t NumberOfLocalEoWErrors() const { return fTotalNumberOfLocalEoWErrors; }
  
  Bool_t HasDarcEoWError() const { return NumberOfDarcEoWErrors() > 0; }
  
  Bool_t HasGlobalEoWError() const { return NumberOfGlobalEoWErrors() > 0; }
  
  Bool_t HasRegEoWError() const { return NumberOfRegEoWErrors() > 0; }
  
  Bool_t HasLocalEoWError() const { return NumberOfLocalEoWErrors() > 0; }
  
  Bool_t TryRecover() const { return Bool_t(fDecoder.TryRecover()); }
  
  void TryRecover(Bool_t value) { fDecoder.TryRecover(bool(value)); }
  
  class AliHeader
  {
  public:
    AliHeader(
        UInt_t darcHeader = 0,
        const AliMUONDarcScalarsStruct* darcScalars = NULL,
        const AliMUONGlobalHeaderStruct* globalHeader = NULL,
        const AliMUONGlobalScalarsStruct* globalScalars = NULL
      ) :
      fDarcHeader(darcHeader), fDarcScalars(darcScalars),
      fGlobalHeader(globalHeader), fGlobalScalars(globalScalars)
    {
    }
    
    AliHeader(const AliHeader& o) :
      fDarcHeader(o.fDarcHeader), fDarcScalars(o.fDarcScalars),
      fGlobalHeader(o.fGlobalHeader), fGlobalScalars(o.fGlobalScalars)
    {
    }
    
    AliHeader& operator = (const AliHeader& object)
    {
      memcpy(this, &object, sizeof(AliHeader));
      return *this;
    }
  
    ~AliHeader() {};
    
    UInt_t   GetWord()               const {return GetDarcHeader();}
    UInt_t   GetGlobalInput(Int_t n) const {return fGlobalHeader->fInput[n];}
    UChar_t  GetGlobalOutput() const {return AliMUONTriggerDDLDecoderEventHandler::GetGlobalOutput(fGlobalHeader);}
    UShort_t GetGlobalConfig() const {return AliMUONTriggerDDLDecoderEventHandler::GetGlobalConfig(fGlobalHeader);}

    UChar_t GetEventType()  const {return AliMUONTriggerDDLDecoderEventHandler::GetDarcEventType(GetDarcHeader());}
    Bool_t IsPhysicsEvent() const {return GetEventType() == 0x1;}
    UChar_t GetDarcType()   const {return AliMUONTriggerDDLDecoderEventHandler::GetDarcType(GetDarcHeader());}
    UChar_t GetSerialNb()   const {return AliMUONTriggerDDLDecoderEventHandler::GetDarcSerialNb(GetDarcHeader());}
    UChar_t GetVersion()    const {return AliMUONTriggerDDLDecoderEventHandler::GetDarcVersion(GetDarcHeader());}
    Bool_t  GetVMETrig()    const {return AliMUONTriggerDDLDecoderEventHandler::GetDarcVMETrig(GetDarcHeader());}
    Bool_t  GetGlobalFlag() const {return AliMUONTriggerDDLDecoderEventHandler::GetDarcGlobalFlag(GetDarcHeader());}
    Bool_t  GetCTPTrig()    const {return AliMUONTriggerDDLDecoderEventHandler::GetDarcCTPTrig(GetDarcHeader());}
    Bool_t  GetDAQFlag()    const {return AliMUONTriggerDDLDecoderEventHandler::GetDarcDAQFlag(GetDarcHeader());}
    UChar_t GetRegPattern() const {return AliMUONTriggerDDLDecoderEventHandler::GetDarcRegPattern(GetDarcHeader());}
  
    // DARC get methods
    UInt_t  GetDarcL0R()   const {return (fDarcScalars != NULL) ? fDarcScalars->fL0R : 0;}
    UInt_t  GetDarcL1P()   const {return (fDarcScalars != NULL) ? fDarcScalars->fL1P : 0;}
    UInt_t  GetDarcL1S()   const {return (fDarcScalars != NULL) ? fDarcScalars->fL1S : 0;}
    UInt_t  GetDarcL2A()   const {return (fDarcScalars != NULL) ? fDarcScalars->fL2A : 0;}
    UInt_t  GetDarcL2R()   const {return (fDarcScalars != NULL) ? fDarcScalars->fL2R : 0;}
    UInt_t  GetDarcClock() const {return (fDarcScalars != NULL) ? fDarcScalars->fClk : 0;}
    UInt_t  GetDarcHold()  const {return (fDarcScalars != NULL) ? fDarcScalars->fHold : 0;}
    
    // global get methods
    UInt_t  GetGlobalL0()    const {return (fGlobalScalars != NULL) ? fGlobalScalars->fL0 : 0;}
    UInt_t  GetGlobalClock() const {return (fGlobalScalars != NULL) ? fGlobalScalars->fClk : 0;}
    const UInt_t* GetGlobalScaler()  const {return (fGlobalScalars != NULL) ? &fGlobalScalars->fScaler[0] : NULL;}
    UInt_t  GetGlobalHold()  const {return (fGlobalScalars != NULL) ? fGlobalScalars->fHold : 0;}
    UInt_t  GetGlobalSpare() const {return (fGlobalScalars != NULL) ? fGlobalScalars->fSpare : 0;}
    
    Bool_t DarcIsDefaultType() const {return GetDarcType() == AliMUONTriggerDDLDecoder<AliMUONTriggerDDLDecoderEventHandler>::DarcDefaultType();}
    Bool_t DarcIsVadohrType()  const {return GetDarcType() == AliMUONTriggerDDLDecoder<AliMUONTriggerDDLDecoderEventHandler>::DarcVadorhType();}
    
    UInt_t GetDarcHeader() const {return fDarcHeader;}
    
    const AliMUONDarcScalarsStruct* GetDarcScalars() const {return fDarcScalars;}
    
    const AliMUONGlobalHeaderStruct* GetGlobalHeader() const {return fGlobalHeader;}
    
    const AliMUONGlobalScalarsStruct* GetGlobalScalars() const {return fGlobalScalars;}
    
    void Print() const;
  
  private:
  
    UInt_t fDarcHeader;  
    const AliMUONDarcScalarsStruct* fDarcScalars;  
    const AliMUONGlobalHeaderStruct* fGlobalHeader;  
    const AliMUONGlobalScalarsStruct* fGlobalScalars;  
  };
  
  class AliRegionalHeader
  {
  public:
    AliRegionalHeader(
        const AliLocalStruct* localsArray = NULL,
        const AliMUONRegionalHeaderStruct* header = NULL,
        const AliMUONRegionalScalarsStruct* scalars = NULL
      ) :
      fNext(NULL), fLocalsCount(0), fFirstLocal(localsArray),
      fHeader(header), fScalars(scalars)
    {
    }
    
    AliRegionalHeader(const AliRegionalHeader& o) :
      fNext(o.fNext), fLocalsCount(o.fLocalsCount),
      fFirstLocal(o.fFirstLocal), fHeader(o.fHeader),
      fScalars(o.fScalars)
    {
    }
    
    AliRegionalHeader& operator = (const AliRegionalHeader& object)
    {
      memcpy(this, &object, sizeof(AliRegionalHeader));
      return *this;
    }
    
    ~AliRegionalHeader() {};
    
    UInt_t   GetDarcWord()     const {return fHeader->fDarcWord;}
    UInt_t   GetWord()         const {return fHeader->fWord;}
    UInt_t   GetInput(Int_t n) const {assert(n < 2); return fHeader->fInput[n];}
    UShort_t GetL0()           const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalL0(fHeader);}
    UShort_t GetMask()         const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalMask(fHeader);}
    
    //word: phys type:1, reset: 6, serialNb:5, Id:4, version: 8, regional output:8
    //true for phys, false for soft
    Bool_t    GetRegPhysFlag() const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalPhysFlag(fHeader);}
    UChar_t   GetResetNb()     const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalResetNb(fHeader);}
    UChar_t   GetSerialNb()    const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalSerialNb(fHeader);}
    UChar_t   GetId()          const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalId(fHeader);}
    UChar_t   GetVersion()     const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalVersion(fHeader);}
    UChar_t   GetOutput()      const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalOutput(fHeader);}
    
    //Darc Status: error:10, #fpag:3, MBZ:3, phys type:1, present:1, not_full:1
    // not_empty:1, L2Rej:1, L2Acc:1, L1:1, L0:1, #evt:4, busy:4
    UShort_t GetErrorBits()       const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalErrorBits(fHeader);}
    UChar_t  GetFPGANumber()      const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalFPGANumber(fHeader);}
    Bool_t   GetDarcPhysFlag()    const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalDarcPhysFlag(fHeader);}
    Bool_t   GetPresentFlag()     const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalPresentFlag(fHeader);}
    Bool_t   GetRamNotFullFlag()  const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalRamNotFullFlag(fHeader);}
    Bool_t   GetRamNotEmptyFlag() const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalRamNotEmptyFlag(fHeader);}
    Bool_t   GetL2RejStatus()     const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalL2RejStatus(fHeader);}
    Bool_t   GetL2AccStatus()     const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalL2AccStatus(fHeader);}
    Bool_t   GetL1Status()        const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalL1Status(fHeader);}
    Bool_t   GetL0Status()        const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalL0Status(fHeader);}
    UChar_t  GetEventInRam()      const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalEventInRam(fHeader);}
    UChar_t  GetBusy()            const {return AliMUONTriggerDDLDecoderEventHandler::GetRegionalBusy(fHeader);}
    
    // scalar methods
    UInt_t  GetClock()        const {return (fScalars != NULL) ? fScalars->fClk : 0;}
    const UInt_t* GetScaler() const {return (fScalars != NULL) ? &fScalars->fScaler[0] : NULL;}
    UInt_t  GetHold()         const {return (fScalars != NULL) ? fScalars->fHold : 0;}
    
    const AliMUONRegionalHeaderStruct* GetHeader() const { return fHeader; }
    
    const AliMUONRegionalScalarsStruct* GetScalars() const { return fScalars; }
    
    const AliRegionalHeader* Next() const { return fNext; }
    
    const AliLocalStruct* GetFirstLocalStruct() const { return fFirstLocal; }
    
    UInt_t GetLocalStructCount() const { return fLocalsCount; }
  
    const AliLocalStruct* GetLocalStruct(UInt_t i) const
    {
      return i < fLocalsCount ? GetFirstLocalStruct() + i : NULL;
    }
  
    void SetNext(const AliRegionalHeader* next) { fNext = next; }

    void IncLocalStructCount() { fLocalsCount++; };
    
    void Print() const;
  
  private:
  
    const AliRegionalHeader* fNext;  
    UInt_t fLocalsCount;  
    const AliLocalStruct* fFirstLocal;  
    const AliMUONRegionalHeaderStruct* fHeader;  
    const AliMUONRegionalScalarsStruct* fScalars;  
  };
  
  class AliLocalStruct
  {
  public:
    AliLocalStruct(
        const AliRegionalHeader* regionalHeader = NULL,
        const AliMUONLocalInfoStruct* localStruct = NULL,
        const AliMUONLocalScalarsStruct* scalars = NULL
      ) :
      fRegional(regionalHeader), fNext(NULL),
      fLocalStruct(localStruct), fScalars(scalars),
      fCalculatedId(0)
    {
    }
    
    AliLocalStruct(const AliLocalStruct& o) :
      fRegional(o.fRegional), fNext(o.fNext),
      fLocalStruct(o.fLocalStruct), fScalars(o.fScalars),
      fCalculatedId(o.fCalculatedId)
    {
    }
    
    AliLocalStruct& operator = (const AliLocalStruct& object)
    {
      memcpy(this, &object, sizeof(AliLocalStruct));
      return *this;
    }
  
    ~AliLocalStruct() {};
    
    UInt_t GetData(Int_t n) const
    {
      assert(n < 5);
      return (reinterpret_cast<const UInt_t*>(fLocalStruct))[n];
    }
  
    UShort_t GetX2() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalX2(fLocalStruct);}
    UShort_t GetX1() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalX1(fLocalStruct);}
    UShort_t GetX4() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalX4(fLocalStruct);}
    UShort_t GetX3() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalX3(fLocalStruct);}
  
    UShort_t GetY2() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalY2(fLocalStruct);}
    UShort_t GetY1() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalY1(fLocalStruct);}
    UShort_t GetY4() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalY4(fLocalStruct);}
    UShort_t GetY3() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalY3(fLocalStruct);}
    
    void GetXPattern(TArrayS& array) const
    {
      Short_t vec[4] = {static_cast<Short_t>(GetX1()), static_cast<Short_t>(GetX2()), static_cast<Short_t>(GetX3()), static_cast<Short_t>(GetX4())};
      array.Set(4, vec);
    }
  
    void GetYPattern(TArrayS& array) const
    {
      Short_t vec[4] = {static_cast<Short_t>(GetY1()), static_cast<Short_t>(GetY2()), static_cast<Short_t>(GetY3()), static_cast<Short_t>(GetY4())};
      array.Set(4, vec);
    }
  
    UChar_t GetId() const {return fgOverrideId ? fCalculatedId : AliMUONTriggerDDLDecoderEventHandler::GetLocalId(fLocalStruct);}
    UChar_t GetDec() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalDec(fLocalStruct);}
    Bool_t GetTrigY() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalTrigY(fLocalStruct);}
    Bool_t GetTriggerY() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalTriggerY(fLocalStruct);}
    UChar_t GetYPos() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalYPos(fLocalStruct);}
    Bool_t GetSXDev() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalSXDev(fLocalStruct);}
    UChar_t GetXDev() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalXDev(fLocalStruct);}
    Bool_t GetTriggerX() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalTriggerX(fLocalStruct);}
    UChar_t GetXPos() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalXPos(fLocalStruct);}
    UChar_t GetLpt() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalLpt(fLocalStruct);}
    UChar_t GetHpt() const {return AliMUONTriggerDDLDecoderEventHandler::GetLocalHpt(fLocalStruct);}
    
    // Scaler methods
    UInt_t  GetL0()      const {return (fScalars != NULL) ? fScalars->fL0 : 0;}
    UInt_t  GetHold()    const {return (fScalars != NULL) ? fScalars->fHold : 0;}
    UInt_t  GetClock()   const {return (fScalars != NULL) ? fScalars->fClk : 0;}
    
    UShort_t GetSwitch() const
    {
      return (fScalars != NULL) ?
        AliMUONTriggerDDLDecoderEventHandler::GetLocalSwitch(fScalars) : 0;
    }
    
    UChar_t GetComptXY() const
    {
      return (fScalars != NULL) ?
        AliMUONTriggerDDLDecoderEventHandler::GetLocalComptXY(fScalars) : 0;
    }
  
    UShort_t GetXY1(Int_t n) const
    {
      return (fScalars != NULL) ?
        AliMUONTriggerDDLDecoderEventHandler::GetLocalXY1(fScalars, n) : 0;
    }
  
    UShort_t GetXY2(Int_t n) const
    {
      return (fScalars != NULL) ?
        AliMUONTriggerDDLDecoderEventHandler::GetLocalXY2(fScalars, n) : 0;
    }
  
    UShort_t GetXY3(Int_t n) const
    {
      return (fScalars != NULL) ?
        AliMUONTriggerDDLDecoderEventHandler::GetLocalXY3(fScalars, n) : 0;
    }
  
    UShort_t GetXY4(Int_t n) const
    {
      return (fScalars != NULL) ?
        AliMUONTriggerDDLDecoderEventHandler::GetLocalXY4(fScalars, n) : 0;
    }

    const AliMUONLocalInfoStruct* GetData() const {return fLocalStruct;}
    
    const AliMUONLocalScalarsStruct* GetScalars() const {return fScalars;}
    
    const AliRegionalHeader* GetRegionalHeader() const { return fRegional; }
    
    const AliLocalStruct* Next() const { return fNext; }
    
    void SetNext(const AliLocalStruct* next) { fNext = next; }
  
    void SetCalculatedId(UChar_t id) { fCalculatedId = id; }
    
    void Print() const;
    
    static bool GetOverrideIdFlag() { return fgOverrideId; }
    
    static void SetOverrideIdFlag(bool value) { fgOverrideId = value; }
  
  private:
  
    const AliRegionalHeader* fRegional;  
    const AliLocalStruct* fNext;  
    const AliMUONLocalInfoStruct* fLocalStruct;  
    const AliMUONLocalScalarsStruct* fScalars;  
    UChar_t fCalculatedId;  
    static bool fgOverrideId; 
  };
  
  const AliHeader* GetHeaders() const { return fDecoder.GetHandler().GetHeaders(); }
  
  UInt_t GetRegionalHeaderCount() const
  {
    return fDecoder.GetHandler().RegionalHeaderCount();
  }
  
  const AliRegionalHeader* GetFirstRegionalHeader() const
  {
    return fDecoder.GetHandler().RegionalHeader(0);
  }
  
  const AliRegionalHeader* GetRegionalHeader(UInt_t i) const
  {
    return fDecoder.GetHandler().RegionalHeader(i);
  }
  
  UInt_t GetLocalStructCount(UInt_t reg) const
  {
    const AliRegionalHeader* r = GetRegionalHeader(reg);
    return r != NULL ? r->GetLocalStructCount() : 0;
  }
  
  const AliLocalStruct* GetLocalStruct(UInt_t reg, UInt_t i) const
  {
    const AliRegionalHeader* r = GetRegionalHeader(reg);
    return r != NULL ? r->GetLocalStruct(i) : NULL;
  }

  const AliLocalStruct* CurrentLocalStruct() const
  {
    return (fkCurrentLocalStruct != fDecoder.GetHandler().EndOfLocalStructs()) ?
      fkCurrentLocalStruct : NULL;
  }

  const AliRegionalHeader* CurrentRegionalHeader() const
  {
    const AliLocalStruct* local = CurrentLocalStruct();
    return (local != NULL) ? local->GetRegionalHeader() : NULL;
  }
  
private:
  AliMUONRawStreamTriggerHP(const AliMUONRawStreamTriggerHP& stream);
  AliMUONRawStreamTriggerHP& operator = (const AliMUONRawStreamTriggerHP& stream);
  
  
  class AliDecoderEventHandler : public AliMUONTriggerDDLDecoderEventHandler
  {
  public:
  
    AliDecoderEventHandler();
    virtual ~AliDecoderEventHandler();
    
    void SetMaxStructs(UInt_t maxRegionals, UInt_t maxLocals);
    
    void SetRawStream(AliMUONVRawStreamTrigger* rawStream) { fRawStream = rawStream; }
    
    const AliHeader* GetHeaders() const { return &fHeaders; }
    
    UInt_t RegionalHeaderCount() const { return fRegionalsCount; }
    
    const AliRegionalHeader* RegionalHeader(UInt_t i) const
    {
      return i < fRegionalsCount ? &fRegionals[i] : NULL;
    }
    
    const AliLocalStruct* FirstLocalStruct() const { return fLocals; }
    
    const AliLocalStruct* EndOfLocalStructs() const { return fEndOfLocals; }
    
    UInt_t GetDarcEoWErrors() const {return fDarcEoWErrors;}
    
    UInt_t GetGlobalEoWErrors() const {return fGlobalEoWErrors;}
    
    UInt_t GetRegEoWErrors() const {return fRegEoWErrors;}
    
    UInt_t GetLocalEoWErrors() const {return fLocalEoWErrors;}

    Bool_t Warnings() const { return fWarnings; }
    void Warnings(Bool_t value) { fWarnings = value; }
    
    // The following methods are inherited from AliMUONTriggerDDLDecoderEventHandler:
    
    void OnNewBuffer(const void* buffer, UInt_t bufferSize);

    void OnEndOfBuffer(const void* /*buffer*/, UInt_t /*bufferSize*/)
    {
      fEndOfLocals = fCurrentLocal+1;
    }
    
    void OnDarcHeader(UInt_t header,
                      const AliMUONDarcScalarsStruct* scalars,
                      const void* /*data*/)
    {
      fDarcHeader = header;
      fDarcScalars = scalars;
    }
    
    void OnGlobalHeader(const AliMUONGlobalHeaderStruct* header,
                        const AliMUONGlobalScalarsStruct* scalars,
                        const void* /*data*/)
    {
      fHeaders = AliHeader(fDarcHeader, fDarcScalars, header, scalars);
    }
    
    void OnNewRegionalStructV2(UInt_t iReg,
                               const AliMUONRegionalHeaderStruct* header,
                               const AliMUONRegionalScalarsStruct* scalars,
                               const void* data);
    
    void OnLocalStructV2(UInt_t iLoc,
                         const AliMUONLocalInfoStruct* localStruct,
                         const AliMUONLocalScalarsStruct* scalars);
    
    void OnError(ErrorCode error, const void* location);
  
  private:
  
    // Do not allow copying of this class.
    AliDecoderEventHandler(const AliDecoderEventHandler& /*obj*/);
    AliDecoderEventHandler& operator = (const AliDecoderEventHandler& /*obj*/);

    AliMUONVRawStreamTrigger* fRawStream; 
    const void* fBufferStart;   
    UInt_t fDarcHeader; 
    const AliMUONDarcScalarsStruct* fDarcScalars; 
    AliHeader fHeaders;  
    UInt_t fRegionalsCount; 
    AliRegionalHeader* fRegionals;  
    AliLocalStruct* fLocals; 
    AliLocalStruct* fEndOfLocals; 
    AliRegionalHeader* fCurrentRegional; 
    AliLocalStruct* fCurrentLocal; 
    UInt_t fDarcEoWErrors;    
    UInt_t fGlobalEoWErrors;  
    UInt_t fRegEoWErrors;     
    UInt_t fLocalEoWErrors;   
    Bool_t fWarnings;       
    
    static const AliMUONRegionalHeaderStruct fgkEmptyHeader;  
  };
  
  AliMUONTriggerDDLDecoder<AliDecoderEventHandler> fDecoder;  
  Int_t fDDL;         
  Int_t fBufferSize;  
  UChar_t* fBuffer;   
  const AliLocalStruct* fkCurrentLocalStruct;  
  Bool_t fHadError;   
  Bool_t fDone;       
  mutable AliMUONDDLTrigger* fDDLObject; 
  UInt_t fTotalNumberOfDarcEoWErrors; 
  UInt_t fTotalNumberOfGlobalEoWErrors; 
  UInt_t fTotalNumberOfRegEoWErrors; 
  UInt_t fTotalNumberOfLocalEoWErrors; 
  
  static const Int_t  fgkMaxDDL;     
  
  ClassDef(AliMUONRawStreamTriggerHP, 0)  // Higher performance decoder class for MUON trigger rawdata.
};


inline const AliMUONRawStreamTriggerHP::AliLocalStruct* AliMUONRawStreamTriggerHP::Next()
{

  do {
    if (fkCurrentLocalStruct != fDecoder.GetHandler().EndOfLocalStructs())
      return fkCurrentLocalStruct++;
  } while (NextDDL());
  return NULL;
}


inline void AliMUONRawStreamTriggerHP::AliDecoderEventHandler::OnNewRegionalStructV2(
    UInt_t iReg,
    const AliMUONRegionalHeaderStruct* header,
    const AliMUONRegionalScalarsStruct* scalars,
    const void* /*data*/
  )
{
  
  assert( header != NULL );
  assert( iReg < fRegionalsCount );
  
  fCurrentRegional = fRegionals+iReg;
  *fCurrentRegional = AliRegionalHeader(fCurrentLocal+1, header, scalars);
  
  // Link to the next regional structure unless this is the last one.
  if (iReg+1 < fRegionalsCount)
  {
    fCurrentRegional->SetNext(fCurrentRegional+1);
  }
}


inline void AliMUONRawStreamTriggerHP::AliDecoderEventHandler::OnLocalStructV2(
    UInt_t iLoc,
    const AliMUONLocalInfoStruct* localStruct,
    const AliMUONLocalScalarsStruct* scalars
  )
{

  assert( localStruct != NULL );
  assert( fCurrentLocal != NULL );
  assert( fCurrentRegional != NULL );
  assert( fCurrentRegional->GetLocalStructCount() < (UInt_t)fRawStream->GetMaxLoc() );
  
  // Link the previous local structure unless it is the first one. 
  if (fCurrentRegional->GetLocalStructCount() > 0)
  {
    fCurrentLocal->SetNext(fCurrentLocal+1);
  }
  
  fCurrentLocal++;
  *fCurrentLocal = AliLocalStruct(fCurrentRegional, localStruct, scalars);
  fCurrentLocal->SetCalculatedId(iLoc);
  fCurrentRegional->IncLocalStructCount();
}

#endif // ALIMUONRAWSTREAMTRIGGERHP_H