ZdcL1CaloSubBlock.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGT1CALOBYTESTREAM_ZDCL1CALOSUBBLOCK_H
#define TRIGT1CALOBYTESTREAM_ZDCL1CALOSUBBLOCK_H
 
#include <stdint.h>
#include <vector>
 
#include "ByteStreamCnvSvcBase/FullEventAssembler.h"
 
// PAS 8/14/15 not needed for compilation
//#include "L1CaloSrcIdMap.h"
 
//namespace LVL1BS {
 
class ZdcL1CaloSubBlock {
 
 public:
   enum SubBlockWordType { HEADER, DATA, STATUS };
   enum DataFormats      { NEUTRAL = 0, UNCOMPRESSED = 1, COMPRESSED = 2,
                           SUPERCOMPRESSED = 3 };
   // Errors detected before unpacking
   enum DataErrorType    { ERROR_NONE, ERROR_DUPLICATE_ROB, ERROR_ROD_ID,
                           ERROR_ROD_NSTATUS, ERROR_USER_HEADER,
                           ERROR_MISSING_HEADER, ERROR_MISSING_SUBBLOCK,
               ERROR_CRATE_NUMBER, ERROR_MODULE_NUMBER,
               ERROR_SLICES, ERROR_DUPLICATE_DATA,
               ERROR_ROI_TYPE, ERROR_MAX };
   // Errors detected during unpacking
   enum UnpackErrorType  { UNPACK_NONE = ERROR_NONE, UNPACK_VERSION = ERROR_MAX,
                           UNPACK_FORMAT, UNPACK_COMPRESSION_VERSION,
               UNPACK_COMPRESSION_SLICES, UNPACK_DATA_TRUNCATED,
               UNPACK_EXCESS_DATA, UNPACK_SOURCE_ID,
               UNPACK_EXCESS_TOBS, UNPACK_DATA_ID };
 
   ZdcL1CaloSubBlock();
   ~ZdcL1CaloSubBlock();
 
   void clear();
 
   int dataWords()   const;
 
   void setHeader(int wordId, int version, int format, int seqno, int crate,
                  int module, int slices2, int slices1);
   
   //  Return unpacked header data
   int wordId()      const;
   int version()     const;
   int format()      const;
   int seqno()       const;
   int slice()       const;
   int crate()       const;
   int module()      const;
   int slices2()     const;
   int slices1()     const;
 
   //  Return unpacked error status data
   uint32_t failingBCN()     const;
   bool     glinkTimeout()   const;
   bool     glinkDown()      const;
   bool     upstreamError()  const;
   bool     daqOverflow()    const;
   bool     bcnMismatch()    const;
   bool     glinkProtocol()  const;
   bool     glinkParity()    const;
 
   uint32_t subStatus()      const;
 
   void setBunchCrossing(int bc);
   int  bunchCrossing()      const;
 
   // (OFFLINE_FRAGMENTS_NAMESPACE::PointerType = uint32_t*)
   OFFLINE_FRAGMENTS_NAMESPACE::PointerType read(
                      const OFFLINE_FRAGMENTS_NAMESPACE::PointerType beg,
                  const OFFLINE_FRAGMENTS_NAMESPACE::PointerType end);
 
   // (FullEventAssembler<L1CaloSrcIdMap>::RODDATA = vector<uint32_t>)
   // PAS 8/14/15 Not needed for compilation
   //void write(FullEventAssembler<L1CaloSrcIdMap>::RODDATA* theROD) const;
 
   void setStatus(uint32_t failingBCN, bool glinkTimeout, bool glinkDown,
                  bool upstreamError, bool daqOverflow, bool bcnMismatch,
          bool glinkProtocol, bool glinkParity);
 
   void setDaqOverflow(int bit = 1);
   void setGlinkParity(int bit = 1);
 
   static SubBlockWordType wordType(uint32_t word);
   static int wordId(uint32_t word);
   static int version(uint32_t word);
   static int format(uint32_t word);
   static int seqno(uint32_t word);
   static int module(uint32_t word);
 
   //  Unpacking error code.  Set by derived classes
   void     setUnpackErrorCode(int code);
   int      unpackErrorCode() const;
   std::string unpackErrorMsg() const;
 
   //  Packing utilities
   int      minBits(uint32_t datum) const;
   int      parityBit(int init, uint32_t datum, int nbits) const;
   void     packer(uint32_t datum, int nbits);
   void     packerFlush();
   void     setStreamed();
   uint32_t unpacker(int nbits);
   uint32_t unpacker(int nbits, int align);
   void     unpackerInit();
   bool     unpackerSuccess() const;
 
   //  Neutral format packing utilities
   void     packerNeutral(int pin, uint32_t datum, int nbits);
   void     packerNeutralParity(int pin);
   uint32_t unpackerNeutral(int pin, int nbits);
   bool     unpackerNeutralParityError(int pin);
   int      currentPinBit(int pin) const;
 
 private:
   //  Constants.
   //  Header and status ID
   static const int      s_headerBit        = 30;
   static const int      s_statusBit        = 28;
   static const uint32_t s_headerMask       = 0x3;
   static const uint32_t s_statusMask       = 0x1;
   static const uint32_t s_headerVal        = 0x3;
   static const uint32_t s_statusVal        = 0x1;
   //  First non-PPM crate
   static const int      s_ppmCrates        = 8;
   //  Header word data positions and masks
   static const int      s_wordIdBit        = 28;
   static const int      s_versionBit       = 25;
   static const int      s_formatBit        = 22;
   static const int      s_seqnoBit         = 16;
   static const int      s_crateBit         = 12;
   static const int      s_moduleBit        = 8;
   static const int      s_slices2Bit       = 3;
   static const int      s_slices1Bit       = 0;
   static const uint32_t s_wordIdMask       = 0xf;
   static const uint32_t s_versionMask      = 0x7;
   static const uint32_t s_formatMask       = 0x7;
   static const uint32_t s_seqnoMask        = 0x3f;
   static const uint32_t s_crateMask        = 0xf;
   static const uint32_t s_moduleMask       = 0xf;
   static const uint32_t s_slices2Mask      = 0x1f;
   static const uint32_t s_slices1Mask      = 0x7;
   //  Status word data positions and masks
   static const int      s_failingBcnBit    = 22;
   static const int      s_glinkTimeoutBit  = 7;
   static const int      s_glinkDownBit     = 6;
   static const int      s_upstreamErrorBit = 4;
   static const int      s_daqOverflowBit   = 3;
   static const int      s_bcnMismatchBit   = 2;
   static const int      s_glinkProtocolBit = 1;
   static const int      s_glinkParityBit   = 0;
   static const uint32_t s_failingBcnMask   = 0x3f;
   //  Packing word sizes and masks
   static const int      s_maxWordBits      = 32;
   static const int      s_maxStreamedBits  = 31;
   static const uint32_t s_maxWordMask      = 0xffffffff;
   static const uint32_t s_maxStreamedMask  = 0x7fffffff;
   //  Neutral packing
   static const int      s_maxPins          = 20;
   static const uint32_t s_glinkDavSet      = 0x400000;
 
   uint32_t m_header;
   uint32_t m_trailer;
   int m_bunchCrossing;
   int m_unpackError;
   //  Used for bit-packing
   uint32_t m_bitword;
   int      m_currentBit;
   int      m_maxBits;
   uint32_t m_maxMask;
   bool     m_unpackerFlag;
   std::vector<uint32_t>::const_iterator m_dataPos;
   std::vector<uint32_t>::const_iterator m_dataPosEnd;
   //  Used for neutral bit packing
   std::vector<int> m_currentPinBit;
   std::vector<int> m_oddParity;
   int      m_dataWords;
   std::vector<uint32_t> m_data;
   std::vector<uint32_t> m_unpackingMasks;
 
};
 
inline int ZdcL1CaloSubBlock::dataWords() const
{
  return m_dataWords;
}
 
inline int ZdcL1CaloSubBlock::wordId() const
{
  return (m_header >> s_wordIdBit) & s_wordIdMask;
}
 
inline int ZdcL1CaloSubBlock::version() const
{
  return (m_header >> s_versionBit) & s_versionMask;
}
 
inline int ZdcL1CaloSubBlock::format() const
{
  return (m_header >> s_formatBit) & s_formatMask;
}
 
inline int ZdcL1CaloSubBlock::seqno() const
{
  return (m_header >> s_seqnoBit) & s_seqnoMask;
}
 
inline int ZdcL1CaloSubBlock::slice() const
{
  return seqno();
}
 
inline int ZdcL1CaloSubBlock::crate() const
{
  return (m_header >> s_crateBit) & s_crateMask;
}
 
inline int ZdcL1CaloSubBlock::module() const
{
  return (m_header >> s_moduleBit) & s_moduleMask;
}
 
inline int ZdcL1CaloSubBlock::slices2() const
{
  return (m_header >> s_slices2Bit) & s_slices2Mask;
}
 
inline int ZdcL1CaloSubBlock::slices1() const
{
  return (m_header >> s_slices1Bit) & s_slices1Mask;
}
 
inline uint32_t ZdcL1CaloSubBlock::failingBCN() const
{
  return (m_trailer >> s_failingBcnBit) & s_failingBcnMask;
}
 
inline bool ZdcL1CaloSubBlock::glinkTimeout() const
{
  return m_trailer & (0x1 << s_glinkTimeoutBit);
}
 
inline bool ZdcL1CaloSubBlock::glinkDown() const
{
  return m_trailer & (0x1 << s_glinkDownBit);
}
 
inline bool ZdcL1CaloSubBlock::upstreamError() const
{
  return m_trailer & (0x1 << s_upstreamErrorBit);
}
 
inline bool ZdcL1CaloSubBlock::daqOverflow() const
{
  return m_trailer & (0x1 << s_daqOverflowBit);
}
 
inline bool ZdcL1CaloSubBlock::bcnMismatch() const
{
  return m_trailer & (0x1 << s_bcnMismatchBit);
}
 
inline bool ZdcL1CaloSubBlock::glinkProtocol() const
{
  return m_trailer & (0x1 << s_glinkProtocolBit);
}
 
inline bool ZdcL1CaloSubBlock::glinkParity() const
{
  return m_trailer & (0x1 << s_glinkParityBit);
}
 
inline uint32_t ZdcL1CaloSubBlock::subStatus() const
{
  return m_trailer;
}
 
inline void ZdcL1CaloSubBlock::setBunchCrossing(const int bc)
{
  if (bc) m_bunchCrossing = bc;
}
 
inline int ZdcL1CaloSubBlock::bunchCrossing() const
{
  return m_bunchCrossing;
}
 
inline void ZdcL1CaloSubBlock::setUnpackErrorCode(const int code)
{
  m_unpackError = code;
}
 
inline int ZdcL1CaloSubBlock::unpackErrorCode() const
{
  return m_unpackError;
}
 
inline void ZdcL1CaloSubBlock::setStreamed()
{
  m_maxBits = s_maxStreamedBits;
  m_maxMask = s_maxStreamedMask;
}
 
inline bool ZdcL1CaloSubBlock::unpackerSuccess() const
{
  return m_unpackerFlag;
}
 
inline int ZdcL1CaloSubBlock::currentPinBit(int pin) const
{
  return m_currentPinBit[pin];
}
 
//} // end namespace
 
#endif