L1CaloUserHeader.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGT1CALOBYTESTREAM_L1CALOUSERHEADER_H
#define TRIGT1CALOBYTESTREAM_L1CALOUSERHEADER_H
 
#include <stdint.h>
 
namespace LVL1BS {

                                                    // Remove pre version 2 stuff ?
class L1CaloUserHeader {
 
 public:

   L1CaloUserHeader(uint32_t header = 0xf0000001);

   uint32_t header() const;

   int words()   const;
 
   //  Return triggered slice offsets
   int jepCmm()  const;
   int cpCmm()   const;
   int jem()     const;
   int cpm()     const;
   int ppmLut()  const;
   int ppmFadc() const;

   int lowerBound() const;
 
   //  Set triggered slice offsets
   void setJepCmm(int offset);
   void setCpCmm(int offset);
   void setJem(int offset);
   void setCpm(int offset);
   void setPpmLut(int offset);
   void setPpmFadc(int offset);

   void setLowerBound(int bound);

   void setVersion(int minorVersion);

   static bool isValid(uint32_t word);
 
 private:
   //  Packed word bit positions version 1
   static const int s_wordIdBit  = 28;
   static const int s_jepCmmBit  = 24;
   static const int s_cpCmmBit   = 20;
   static const int s_jemBit     = 16;
   static const int s_cpmBit     = 12;
   static const int s_ppmLutBit  = 8;
   static const int s_ppmFadcBit = 4;
   //  Packed word bit positions version 2 (no cmms)
   static const int s_lowerBoundBit = 20;
   static const int s_ppmLutBitV2   = 9;
   static const int s_ppmFadcBitV2  = 4;
   static const uint32_t s_mask  = 0xf;
   //  Version 2 masks
   static const uint32_t s_lowerBoundMask = 0xff;
   static const uint32_t s_ppmLutMaskV2   = 0x7;
   static const uint32_t s_ppmFadcMaskV2  = 0x1f;
   static const int s_version1 = 0x1001;
   uint32_t m_header;
   bool     m_version2;
 
};
 
inline uint32_t L1CaloUserHeader::header() const
{
  return m_header;
}
 
inline int L1CaloUserHeader::words() const
{
  return m_header & s_mask;
}
 
inline int L1CaloUserHeader::jepCmm() const
{
  return (m_version2) ? (m_header >> s_jemBit   ) & s_mask
                      : (m_header >> s_jepCmmBit) & s_mask;
}
 
inline int L1CaloUserHeader::cpCmm() const
{
  return (m_version2) ? (m_header >> s_cpmBit  ) & s_mask
                      : (m_header >> s_cpCmmBit) & s_mask;
}
 
inline int L1CaloUserHeader::jem() const
{
  return (m_header >> s_jemBit) & s_mask;
}
 
inline int L1CaloUserHeader::cpm() const
{
  return (m_header >> s_cpmBit) & s_mask;
}
 
inline int L1CaloUserHeader::ppmLut() const
{
  return (m_version2) ? (m_header >> s_ppmLutBitV2) & s_ppmLutMaskV2
                      : (m_header >> s_ppmLutBit  ) & s_mask;
}
 
inline int L1CaloUserHeader::ppmFadc() const
{
  return (m_version2) ? (m_header >> s_ppmFadcBitV2) & s_ppmFadcMaskV2
                      : (m_header >> s_ppmFadcBit  ) & s_mask;
}
 
inline int L1CaloUserHeader::lowerBound() const
{
  return (m_version2) ? (m_header >> s_lowerBoundBit) & s_lowerBoundMask
                      : 0;
}
 
inline void L1CaloUserHeader::setJepCmm(const int offset)
{
  if (!m_version2) m_header |= (s_mask & offset) << s_jepCmmBit;
}
 
inline void L1CaloUserHeader::setCpCmm(const int offset)
{
  if (!m_version2) m_header |= (s_mask & offset) << s_cpCmmBit;
}
 
inline void L1CaloUserHeader::setJem(const int offset)
{
  m_header |= (s_mask & offset) << s_jemBit;
}
 
inline void L1CaloUserHeader::setCpm(const int offset)
{
  m_header |= (s_mask & offset) << s_cpmBit;
}
 
inline void L1CaloUserHeader::setPpmLut(const int offset)
{
  m_header |= (m_version2) ? (s_ppmLutMaskV2 & offset) << s_ppmLutBitV2
                           : (s_mask         & offset) << s_ppmLutBit;
}
 
inline void L1CaloUserHeader::setPpmFadc(const int offset)
{
  m_header |= (m_version2) ? (s_ppmFadcMaskV2 & offset) << s_ppmFadcBitV2
                           : (s_mask          & offset) << s_ppmFadcBit;
}
 
inline void L1CaloUserHeader::setLowerBound(const int bound)
{
  if (m_version2) m_header |= (s_lowerBoundMask & bound) << s_lowerBoundBit;
}
 
inline void L1CaloUserHeader::setVersion(const int minorVersion)
{
  m_version2 = (minorVersion > s_version1);
}
 
} // end namespace
 
#endif