LVL1BS::JepRoiByteStreamV2Tool Class Reference

Tool to perform ROB fragments to JEM RoI and CMX RoI, and JEP RoI container to raw data conversions. More...

#include <JepRoiByteStreamV2Tool.h>

Inheritance diagram for LVL1BS::JepRoiByteStreamV2Tool:

Collaboration diagram for LVL1BS::JepRoiByteStreamV2Tool:

Public Member Functions
	JepRoiByteStreamV2Tool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~JepRoiByteStreamV2Tool ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
StatusCode	convert (const std::string &name, DataVector< LVL1::JEMTobRoI > *jeCollection) const
	Convert ROB fragments to JEM RoIs. More...
StatusCode	convert (const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::JEMTobRoI > *jeCollection) const
StatusCode	convert (const std::string &name, LVL1::CMXRoI *cmCollection) const
	Convert ROB fragments to CMX RoIs. More...
StatusCode	convert (const IROBDataProviderSvc::VROBFRAG &robFrags, LVL1::CMXRoI *cmCollection) const
StatusCode	convert (const LVL1::JEPRoIBSCollectionV2 *jep) const
	Convert JEP RoI Container to bytestream. More...
const std::vector< uint32_t > &	sourceIDs (const std::string &sgKey) const
	Return reference to vector with all possible Source Identifiers. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	AlgTool InterfaceID. More...

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef DataVector< LVL1::JEMTobRoI >	JemRoiCollection
typedef DataVector< LVL1::CMXEtSums >	CmxSumsCollection
typedef std::map< uint32_t, const LVL1::JEMTobRoI * >	JemRoiMap
typedef std::map< int, const LVL1::CMXEtSums * >	CmxSumsMap
typedef IROBDataProviderSvc::VROBFRAG::const_iterator	ROBIterator
typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType	ROBPointer
typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType	RODPointer
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	convertBs (const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::JEMTobRoI > *jeCollection, LVL1::CMXRoI *cmCollection) const
	Convert bytestream to given container type. More...
const LVL1::CMXEtSums *	findCmxSums (int crate, int source, const CmxSumsMap &cmxEtMap) const
	Find CMX energy sums for given crate, source. More...
std::vector< uint32_t >	makeSourceIDs (bool roiDaq) const
void	setupJemRoiMap (const JemRoiCollection *jeCollection, JemRoiMap &roiMap) const
	Set up JEM RoIs map. More...
void	setupCmxEtMap (const CmxSumsCollection *enCollection, CmxSumsMap &cmxEtMap) const
	Set up CMX energy sums map. More...
void	energySubBlockTypes (int source, CmxEnergySubBlock::SourceType &srcType, CmxEnergySubBlock::SumType &sumType, CmxEnergySubBlock::HitsType &hitType) const
	Get energy subBlock types from CMXEtSums source type. More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
ServiceHandle< IByteStreamCnvSvc >	m_byteStreamCnvSvc { this, "ByteStreamCnvSvc", "ByteStreamCnvSvc" }
ServiceHandle< IROBDataProviderSvc >	m_robDataProvider
ToolHandle< LVL1BS::L1CaloErrorByteStreamTool >	m_errorTool
	Property: Error collection tool. More...
int	m_crateOffsetHw
	Property: Hardware crate number offset. More...
int	m_crateOffsetSw
	Property: Software crate number offset. More...
int	m_version
	Property: Sub_block header version. More...
int	m_dataFormat
	Property: Data compression format. More...
const int	m_crates
	Number of crates. More...
const int	m_modules
	Number of JEM modules per crate. More...
const int	m_frames
	Number of RoI frames. More...
const int	m_maxRoiWords
	Number of CMX energy RoI words. More...
int	m_slinks
	Property: Number of slinks per crate when writing out bytestream. More...
int	m_crateMin
	Property: Minimum crate number when writing out bytestream. More...
int	m_crateMax
	Property: Maximum crate number when writing out bytestream. More...
std::vector< uint32_t >	m_sourceIDsProp
	Property: ROB source IDs. More...
std::vector< uint32_t >	m_sourceIDsRoIBProp
	Property: ROB source IDs for RoIB. More...
const eformat::SubDetector	m_subDetector
	Sub-detector type. More...
const L1CaloSrcIdMap	m_srcIdMap
	Source ID converter. More...
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Tool to perform ROB fragments to JEM RoI and CMX RoI, and JEP RoI container to raw data conversions.

Based on ROD document version X_xxx. <<== CHECK

Author

Peter Faulkner

Definition at line 50 of file JepRoiByteStreamV2Tool.h.

Member Typedef Documentation

CmxSumsCollection

typedef DataVector<LVL1::CMXEtSums> LVL1BS::JepRoiByteStreamV2Tool::CmxSumsCollection

private

Definition at line 86 of file JepRoiByteStreamV2Tool.h.

CmxSumsMap

typedef std::map<int, const LVL1::CMXEtSums*> LVL1BS::JepRoiByteStreamV2Tool::CmxSumsMap

private

Definition at line 88 of file JepRoiByteStreamV2Tool.h.

JemRoiCollection

typedef DataVector<LVL1::JEMTobRoI> LVL1BS::JepRoiByteStreamV2Tool::JemRoiCollection

private

Definition at line 85 of file JepRoiByteStreamV2Tool.h.

JemRoiMap

typedef std::map<uint32_t, const LVL1::JEMTobRoI*> LVL1BS::JepRoiByteStreamV2Tool::JemRoiMap

private

Definition at line 87 of file JepRoiByteStreamV2Tool.h.

ROBIterator

typedef IROBDataProviderSvc::VROBFRAG::const_iterator LVL1BS::JepRoiByteStreamV2Tool::ROBIterator

private

Definition at line 89 of file JepRoiByteStreamV2Tool.h.

ROBPointer

typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType LVL1BS::JepRoiByteStreamV2Tool::ROBPointer

private

Definition at line 90 of file JepRoiByteStreamV2Tool.h.

RODPointer

typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType LVL1BS::JepRoiByteStreamV2Tool::RODPointer

private

Definition at line 91 of file JepRoiByteStreamV2Tool.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

JepRoiByteStreamV2Tool()

LVL1BS::JepRoiByteStreamV2Tool::JepRoiByteStreamV2Tool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 44 of file JepRoiByteStreamV2Tool.cxx.

  : AthAlgTool(type, name, parent),
    m_robDataProvider("ROBDataProviderSvc", name),
    m_errorTool("LVL1BS::L1CaloErrorByteStreamTool/L1CaloErrorByteStreamTool"),
    m_crates(2), m_modules(16), m_frames(8), m_maxRoiWords(6),
    m_subDetector (eformat::TDAQ_CALO_JET_PROC_ROI)
{
  declareInterface<JepRoiByteStreamV2Tool>(this);
 
  declareProperty("ErrorTool", m_errorTool,
                  "Tool to collect errors for monitoring");
  declareProperty("CrateOffsetHw",  m_crateOffsetHw = 12,
                  "Offset of JEP crate numbers in bytestream");
  declareProperty("CrateOffsetSw",  m_crateOffsetSw = 0,
                  "Offset of JEP crate numbers in RDOs");
 
  // Properties for reading bytestream only
  declareProperty("ROBSourceIDs",       m_sourceIDsProp,
                  "ROB fragment source identifiers");
  declareProperty("ROBSourceIDsRoIB",   m_sourceIDsRoIBProp,
                  "ROB fragment source identifiers");
 
  // Properties for writing bytestream only
  declareProperty("DataVersion",    m_version       = 2,                   //<<== CHECK
                  "Format version number in sub-block header");
  declareProperty("DataFormat",     m_dataFormat    = 1,
                  "Format identifier (0-1) in sub-block header");
  declareProperty("SlinksPerCrate", m_slinks        = 1,
                  "The number of S-Links per crate");
  declareProperty("CrateMin",       m_crateMin = 0,
                  "Minimum crate number, allows partial output");
  declareProperty("CrateMax",       m_crateMax = m_crates - 1,
                  "Maximum crate number, allows partial output");
 
}

~JepRoiByteStreamV2Tool()

LVL1BS::JepRoiByteStreamV2Tool::~JepRoiByteStreamV2Tool ( )

virtual

Definition at line 84 of file JepRoiByteStreamV2Tool.cxx.

{
}

Member Function Documentation

convert() [1/5]

StatusCode LVL1BS::JepRoiByteStreamV2Tool::convert	(	const IROBDataProviderSvc::VROBFRAG &	robFrags,
		DataVector< LVL1::JEMTobRoI > *	jeCollection
	)		const

Definition at line 122 of file JepRoiByteStreamV2Tool.cxx.

{
  return convertBs(robFrags, jeCollection, nullptr);
}

convert() [2/5]

StatusCode LVL1BS::JepRoiByteStreamV2Tool::convert	(	const IROBDataProviderSvc::VROBFRAG &	robFrags,
		LVL1::CMXRoI *	cmCollection
	)		const

Definition at line 143 of file JepRoiByteStreamV2Tool.cxx.

{
  return convertBs(robFrags, nullptr, cmCollection);
}

convert() [3/5]

StatusCode LVL1BS::JepRoiByteStreamV2Tool::convert

(

const LVL1::JEPRoIBSCollectionV2 *

jep

)

const

Convert JEP RoI Container to bytestream.

Definition at line 152 of file JepRoiByteStreamV2Tool.cxx.

{
  const bool debug = msgLvl(MSG::DEBUG);
  if (debug) msg(MSG::DEBUG);
 
  // Get the event assembler
  FullEventAssembler<L1CaloSrcIdMap>* fea = nullptr;
  ATH_CHECK( m_byteStreamCnvSvc->getFullEventAssembler (fea,
                                                        "JepRoiByteStreamV2") );
  const uint16_t minorVersion = m_srcIdMap.minorVersion();
  fea->setRodMinorVersion(minorVersion);
 
  // Pointer to ROD data vector
 
  FullEventAssembler<L1CaloSrcIdMap>::RODDATA* theROD = 0;
 
  // Sub-block for neutral format
  JemRoiSubBlockV2 subBlock;
 
  // Set up the container maps
 
  const bool neutralFormat = m_dataFormat == L1CaloSubBlock::NEUTRAL;
 
  // JEM RoI map
  JemRoiMap roiMap;
  setupJemRoiMap(jep->JemRoi(), roiMap);
  JemRoiMap::const_iterator mapIter    = roiMap.begin();
  JemRoiMap::const_iterator mapIterEnd = roiMap.end();
 
  // CMX energy sums map
  CmxSumsMap cmxEtMap;
  if (neutralFormat) {
    setupCmxEtMap(jep->CmxSums(), cmxEtMap);
  }
 
  // Loop over JEM RoI data
 
  const int modulesPerSlink = m_modules / m_slinks;
  for (int crate = m_crateMin; crate <= m_crateMax; ++crate) {
    const int hwCrate = crate + m_crateOffsetHw;
 
    for (int module = 0; module < m_modules; ++module) {
 
      // Pack required number of modules per slink
 
      if (module % modulesPerSlink == 0) {
        const int daqOrRoi = 1;
        const int slink = module / modulesPerSlink;
        if (debug) {
          msg() << "Treating crate " << hwCrate
                << " slink " << slink << endmsg
                << "Data Version/Format: " << m_version
                << " " << m_dataFormat << endmsg;
        }
        const uint32_t rodIdJem = m_srcIdMap.getRodID(hwCrate, slink, daqOrRoi,
                                  m_subDetector);
        theROD = fea->getRodData(rodIdJem);
        if (neutralFormat) {
          const L1CaloUserHeader userHeader;
          theROD->push_back(userHeader.header());
        }
      }
      if (debug) msg() << "JEM Module " << module << endmsg;
      if (!theROD) break; // for coverity, shouldn't happen
 
      // Create a sub-block (Neutral format only)
 
      if (neutralFormat) {
        subBlock.clear();
        subBlock.setRoiHeader(m_version, hwCrate, module);
      }
 
      // Find JEM RoIs for this module
 
      for (; mapIter != mapIterEnd; ++mapIter) {
        const LVL1::JEMTobRoI* const roi = mapIter->second;
        if (roi->crate() < crate)  continue;
        if (roi->crate() > crate)  break;
        if (roi->jem()   < module) continue;
        if (roi->jem()   > module) break;
        if (roi->energyLarge() || roi->energySmall()) {
          if (neutralFormat) subBlock.fillRoi(*roi);
          else theROD->push_back(roi->roiWord());
        }
      }
 
      // Pack and write the sub-block
 
      if (neutralFormat) {
        if ( !subBlock.pack()) {
          msg(MSG::ERROR) << "JEM RoI sub-block packing failed" << endmsg;
          return StatusCode::FAILURE;
        }
        if (debug) {
          msg() << "JEM RoI sub-block data words: "
                << subBlock.dataWords() << endmsg;
        }
        subBlock.write(theROD);
      }
    }
    if (!theROD) break; // for coverity, shouldn't happen
 
    // Append CMX RoIs to last S-Link of the system crate
 
    if (crate != m_crates - 1) continue;
 
    // Create sub-blocks for Neutral format
 
    if (neutralFormat) {
      const int timeslices = 1;
      const int slice = 0;
 
      // CMX-Energy
 
      CmxEnergySubBlock subBlock;
      const int cmxEnergyVersion = 3;                                      //<<== CHECK
      subBlock.setCmxHeader(cmxEnergyVersion, m_dataFormat, slice, hwCrate,
                            CmxSubBlock::SYSTEM, CmxSubBlock::CMX_ENERGY,
                            CmxSubBlock::LEFT, timeslices);
      int maxSource = static_cast<int>(LVL1::CMXEtSums::MAX_SOURCE);
      for (int source = 0; source < maxSource; ++source) {
        const LVL1::CMXEtSums* const sums = findCmxSums(crate, source, cmxEtMap);
        if ( sums ) {
          const unsigned int ex = sums->Ex();
          const unsigned int ey = sums->Ey();
          const unsigned int et = sums->Et();
          const int exErr = sums->ExError();
          const int eyErr = sums->EyError();
          const int etErr = sums->EtError();
          if (source < m_modules) {
            subBlock.setSubsums(slice, source, ex, ey, et, exErr, eyErr, etErr);
          } else {
            CmxEnergySubBlock::SourceType srcType = CmxEnergySubBlock::MAX_SOURCE_TYPE;
            CmxEnergySubBlock::SumType    sumType = CmxEnergySubBlock::MAX_SUM_TYPE;
            CmxEnergySubBlock::HitsType   hitType = CmxEnergySubBlock::MAX_HITS_TYPE;
            energySubBlockTypes(source, srcType, sumType, hitType);
            if (srcType != CmxEnergySubBlock::MAX_SOURCE_TYPE) {
              subBlock.setSubsums(slice, srcType, sumType, ex, ey, et,
                                  exErr, eyErr, etErr);
            } else if (hitType != CmxEnergySubBlock::MAX_HITS_TYPE) {
              subBlock.setEtHits(slice, hitType, sumType, et);
            }
          }
        }
      }
      if ( !subBlock.pack()) {
        msg(MSG::ERROR) << "CMX-Energy sub-block packing failed" << endmsg;
        return StatusCode::FAILURE;
      }
      if (debug) {
        msg() << "CMX-Energy sub-block data words: "
              << subBlock.dataWords() << endmsg;
      }
      subBlock.write(theROD);
 
    } else {
 
      // Standard format
 
      const LVL1::CMXRoI* const roi = jep->CmxRoi();
      if ( roi ) {
        // CMX-Energy RoIs are not zero-supressed unless all are zero
        for (int word = 0; word < m_maxRoiWords; ++word) {
          theROD->push_back(roi->roiWord(word));
        }
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

convert() [4/5]

StatusCode LVL1BS::JepRoiByteStreamV2Tool::convert	(	const std::string &	name,
		DataVector< LVL1::JEMTobRoI > *	jeCollection
	)		const

Convert ROB fragments to JEM RoIs.

Definition at line 110 of file JepRoiByteStreamV2Tool.cxx.

{
 const std::vector<uint32_t>& vID(sourceIDs(sgKey));
  // // get ROB fragments
  IROBDataProviderSvc::VROBFRAG robFrags;
  m_robDataProvider->getROBData(Gaudi::Hive::currentContext(), vID, robFrags, "JepRoiByteStreamV2Tool");
  ATH_MSG_DEBUG("Number of ROB fragments:" << robFrags.size());
  return convert(robFrags, collection);
}

convert() [5/5]

StatusCode LVL1BS::JepRoiByteStreamV2Tool::convert	(	const std::string &	name,
		LVL1::CMXRoI *	cmCollection
	)		const

Convert ROB fragments to CMX RoIs.

Definition at line 131 of file JepRoiByteStreamV2Tool.cxx.

{
  const std::vector<uint32_t>& vID(sourceIDs(sgKey));
  // // get ROB fragments
  IROBDataProviderSvc::VROBFRAG robFrags;
  m_robDataProvider->getROBData(Gaudi::Hive::currentContext(), vID, robFrags, "JepRoiByteStreamV2Tool");
  ATH_MSG_DEBUG("Number of ROB fragments:" << robFrags.size());
  return convert(robFrags, cmCollection);
}

convertBs()

StatusCode LVL1BS::JepRoiByteStreamV2Tool::convertBs ( const IROBDataProviderSvc::VROBFRAG &  robFrags, DataVector< LVL1::JEMTobRoI > *  jeCollection, LVL1::CMXRoI *  cmCollection  ) const

private

Convert bytestream to given container type.

Definition at line 381 of file JepRoiByteStreamV2Tool.cxx.

{
  const bool debug = msgLvl(MSG::DEBUG);
  if (debug) msg(MSG::DEBUG);
 
  // Loop over ROB fragments
 
  int robCount = 0;
  std::set<uint32_t> dupCheck;
  std::set<uint32_t> dupRoiCheck;
  ROBIterator rob    = robFrags.begin();
  ROBIterator robEnd = robFrags.end();
  for (; rob != robEnd; ++rob) {
 
    if (debug) {
      ++robCount;
      msg() << "Treating ROB fragment " << robCount << endmsg;
    }
 
    // Skip fragments with ROB status errors
 
    uint32_t robid = (*rob)->source_id();
    if ((*rob)->nstatus() > 0) {
      ROBPointer robData;
      (*rob)->status(robData);
      if (*robData != 0) {
        m_errorTool->robError(robid, *robData);
        if (debug) msg() << "ROB status error - skipping fragment" << endmsg;
        continue;
      }
    }
 
    // Skip duplicate fragments
 
    if (!dupCheck.insert(robid).second) {
      m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_DUPLICATE_ROB);
      if (debug) msg() << "Skipping duplicate ROB fragment" << endmsg;
      continue;
    }
 
    // Unpack ROD data (slinks)
 
    RODPointer payloadBeg;
    RODPointer payload;
    RODPointer payloadEnd;
    (*rob)->rod_data(payloadBeg);
    payloadEnd = payloadBeg + (*rob)->rod_ndata();
    payload = payloadBeg;
    if (payload == payloadEnd) {
      if (debug) msg() << "ROB fragment empty" << endmsg;
      continue;
    }
 
    // Check identifier
    const uint32_t sourceID = (*rob)->rod_source_id();
    if (m_srcIdMap.getRobID(sourceID) != robid           ||
        m_srcIdMap.subDet(sourceID)   != m_subDetector   ||
        m_srcIdMap.daqOrRoi(sourceID) != 1               ||
        (m_srcIdMap.slink(sourceID) != 0 && m_srcIdMap.slink(sourceID) != 2) ||
        m_srcIdMap.crate(sourceID)    <  m_crateOffsetHw ||
        m_srcIdMap.crate(sourceID)    >= m_crateOffsetHw + m_crates) {
      m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_ROD_ID);
      if (debug) {
        msg() << "Wrong source identifier in data: "
              << MSG::hex << sourceID << MSG::dec << endmsg;
      }
      continue;
    }
 
    // Check minor version
    const int minorVersion = (*rob)->rod_version() & 0xffff;
    if (minorVersion <= m_srcIdMap.minorVersionPreLS1()) {
      if (debug) msg() << "Skipping pre-LS1 data" << endmsg;
      continue;
    }
    const int rodCrate = m_srcIdMap.crate(sourceID);
    if (debug) {
      msg() << "Treating crate " << rodCrate
            << " slink " << m_srcIdMap.slink(sourceID) << endmsg;
    }
 
    // First word may be User Header
    if (L1CaloUserHeader::isValid(*payload)) {
      L1CaloUserHeader userHeader(*payload);
      userHeader.setVersion(minorVersion);
      const int headerWords = userHeader.words();
      if (headerWords != 1) {
        m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_USER_HEADER);
        if (debug) msg() << "Unexpected number of user header words: "
                           << headerWords << endmsg;
        continue;
      }
      for (int i = 0; i < headerWords; ++i) ++payload;
    }
 
    // Loop over sub-blocks if there are any
 
    unsigned int rodErr = L1CaloSubBlock::ERROR_NONE;
    while (payload != payloadEnd) {
 
      if (L1CaloSubBlock::wordType(*payload) == L1CaloSubBlock::HEADER) {
        const int slice = 0;
        if (CmxSubBlock::cmxBlock(*payload)) {
          // CMXs
          if (CmxSubBlock::cmxType(*payload) == CmxSubBlock::CMX_ENERGY) {
            CmxEnergySubBlock subBlock;
            payload = subBlock.read(payload, payloadEnd);
            if (cmCollection != nullptr) {
              if (subBlock.dataWords() && !subBlock.unpack()) {
                if (debug) {
                  std::string errMsg(subBlock.unpackErrorMsg());
                  msg() << "CMX-Energy sub-block unpacking failed: "
                        << errMsg << endmsg;
                }
                rodErr = subBlock.unpackErrorCode();
                break;
              }
              const LVL1::CMXRoI roi(
                subBlock.energy(slice, CmxEnergySubBlock::TOTAL,
                                CmxEnergySubBlock::STANDARD,
                                CmxEnergySubBlock::ENERGY_EX),
                subBlock.energy(slice, CmxEnergySubBlock::TOTAL,
                                CmxEnergySubBlock::STANDARD,
                                CmxEnergySubBlock::ENERGY_EY),
                subBlock.energy(slice, CmxEnergySubBlock::TOTAL,
                                CmxEnergySubBlock::STANDARD,
                                CmxEnergySubBlock::ENERGY_ET),
                subBlock.error(slice, CmxEnergySubBlock::TOTAL,
                               CmxEnergySubBlock::STANDARD,
                               CmxEnergySubBlock::ENERGY_EX),
                subBlock.error(slice, CmxEnergySubBlock::TOTAL,
                               CmxEnergySubBlock::STANDARD,
                               CmxEnergySubBlock::ENERGY_EY),
                subBlock.error(slice, CmxEnergySubBlock::TOTAL,
                               CmxEnergySubBlock::STANDARD,
                               CmxEnergySubBlock::ENERGY_ET),
                subBlock.hits(slice, CmxEnergySubBlock::SUM_ET,
                              CmxEnergySubBlock::STANDARD),
                subBlock.hits(slice, CmxEnergySubBlock::MISSING_ET,
                              CmxEnergySubBlock::STANDARD),
                subBlock.hits(slice, CmxEnergySubBlock::MISSING_ET_SIG,
                              CmxEnergySubBlock::STANDARD),
                subBlock.energy(slice, CmxEnergySubBlock::TOTAL,
                                CmxEnergySubBlock::RESTRICTED_WEIGHTED,
                                CmxEnergySubBlock::ENERGY_EX),
                subBlock.energy(slice, CmxEnergySubBlock::TOTAL,
                                CmxEnergySubBlock::RESTRICTED_WEIGHTED,
                                CmxEnergySubBlock::ENERGY_EY),
                subBlock.energy(slice, CmxEnergySubBlock::TOTAL,
                                CmxEnergySubBlock::RESTRICTED_WEIGHTED,
                                CmxEnergySubBlock::ENERGY_ET),
                subBlock.error(slice, CmxEnergySubBlock::TOTAL,
                               CmxEnergySubBlock::RESTRICTED_WEIGHTED,
                               CmxEnergySubBlock::ENERGY_EX),
                subBlock.error(slice, CmxEnergySubBlock::TOTAL,
                               CmxEnergySubBlock::RESTRICTED_WEIGHTED,
                               CmxEnergySubBlock::ENERGY_EY),
                subBlock.error(slice, CmxEnergySubBlock::TOTAL,
                               CmxEnergySubBlock::RESTRICTED_WEIGHTED,
                               CmxEnergySubBlock::ENERGY_ET),
                subBlock.hits(slice, CmxEnergySubBlock::SUM_ET,
                              CmxEnergySubBlock::RESTRICTED_WEIGHTED),
                subBlock.hits(slice, CmxEnergySubBlock::MISSING_ET,
                              CmxEnergySubBlock::RESTRICTED_WEIGHTED));
              for (int word = 0; word < m_maxRoiWords; ++word) {
                cmCollection->setRoiWord(roi.roiWord(word));
              }
            }
          }
        } else {
          // JEM RoI
          JemRoiSubBlockV2 subBlock;
          payload = subBlock.read(payload, payloadEnd);
          if (jeCollection != nullptr) {
            if (subBlock.dataWords() && !subBlock.unpack()) {
              if (debug) {
                std::string errMsg(subBlock.unpackErrorMsg());
                msg() << "JEM RoI sub-block unpacking failed: "
                      << errMsg << endmsg;
              }
              rodErr = subBlock.unpackErrorCode();
              break;
            }
            for (int frame = 0; frame < m_frames; ++frame) {
              const LVL1::JEMTobRoI roi = subBlock.roi(frame);
              if (roi.energyLarge() || roi.energySmall()) {
                jeCollection->push_back(new LVL1::JEMTobRoI(roi));
              }
            }
          }
        }
      } else {
        // Just RoI word
        LVL1::JEMTobRoI jroi;
        LVL1::CMXRoI croi;
        if (jroi.setRoiWord(*payload)) {
          if (jeCollection != nullptr) {
            if (jroi.crate() != rodCrate - m_crateOffsetHw) {
              if (debug) msg() << "Inconsistent RoI crate number: "
                                 << jroi.crate() << endmsg;
              rodErr = L1CaloSubBlock::ERROR_CRATE_NUMBER;
              break;
            }
            const uint32_t location = (*payload) & 0xfff80000;
            if (dupRoiCheck.insert(location).second) {
              if (jroi.energyLarge() || jroi.energySmall()) {
                jeCollection->push_back(new LVL1::JEMTobRoI(*payload));
              }
            } else {
              if (debug) msg() << "Duplicate RoI word "
                                 << MSG::hex << *payload << MSG::dec << endmsg;
              rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
              break;
            }
          }
        } else if (croi.setRoiWord(*payload)) {
          if (cmCollection != nullptr) {
            const uint32_t roiType = (*payload) & 0xfc000000;
   
            if (dupRoiCheck.insert(roiType).second) {
              cmCollection->setRoiWord(*payload);
            } else {
              if (debug) msg() << "Duplicate RoI word "
                                 << MSG::hex << *payload << MSG::dec << endmsg;
              rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
              break;
            }
          }
        } else {
          if (debug) msg() << "Invalid RoI word "
                             << MSG::hex << *payload << MSG::dec << endmsg;
          rodErr = L1CaloSubBlock::ERROR_ROI_TYPE;
          break;
        }
        ++payload;
      }
    }
    if (rodErr != L1CaloSubBlock::ERROR_NONE)
      m_errorTool->rodError(robid, rodErr);
  }
 
  return StatusCode::SUCCESS;
}

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                 {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

energySubBlockTypes()

void LVL1BS::JepRoiByteStreamV2Tool::energySubBlockTypes ( int  source, CmxEnergySubBlock::SourceType &  srcType, CmxEnergySubBlock::SumType &  sumType, CmxEnergySubBlock::HitsType &  hitType  ) const

private

Get energy subBlock types from CMXEtSums source type.

Definition at line 680 of file JepRoiByteStreamV2Tool.cxx.

{
  switch (source) {
  case LVL1::CMXEtSums::REMOTE_STANDARD:
    srcType = CmxEnergySubBlock::REMOTE;
    sumType = CmxEnergySubBlock::STANDARD;
    break;
  case LVL1::CMXEtSums::REMOTE_RESTRICTED:
    srcType = CmxEnergySubBlock::REMOTE;
    sumType = CmxEnergySubBlock::RESTRICTED_WEIGHTED;
    break;
  case LVL1::CMXEtSums::LOCAL_STANDARD:
    srcType = CmxEnergySubBlock::LOCAL;
    sumType = CmxEnergySubBlock::STANDARD;
    break;
  case LVL1::CMXEtSums::LOCAL_RESTRICTED:
    srcType = CmxEnergySubBlock::LOCAL;
    sumType = CmxEnergySubBlock::RESTRICTED_WEIGHTED;
    break;
  case LVL1::CMXEtSums::TOTAL_STANDARD:
    srcType = CmxEnergySubBlock::TOTAL;
    sumType = CmxEnergySubBlock::STANDARD;
    break;
  case LVL1::CMXEtSums::TOTAL_RESTRICTED:
    srcType = CmxEnergySubBlock::TOTAL;
    sumType = CmxEnergySubBlock::RESTRICTED_WEIGHTED;
    break;
  case LVL1::CMXEtSums::SUM_ET_STANDARD:
    hitType = CmxEnergySubBlock::SUM_ET;
    sumType = CmxEnergySubBlock::STANDARD;
    break;
  case LVL1::CMXEtSums::SUM_ET_RESTRICTED:
    hitType = CmxEnergySubBlock::SUM_ET;
    sumType = CmxEnergySubBlock::RESTRICTED_WEIGHTED;
    break;
  case LVL1::CMXEtSums::MISSING_ET_STANDARD:
    hitType = CmxEnergySubBlock::MISSING_ET;
    sumType = CmxEnergySubBlock::STANDARD;
    break;
  case LVL1::CMXEtSums::MISSING_ET_RESTRICTED:
    hitType = CmxEnergySubBlock::MISSING_ET;
    sumType = CmxEnergySubBlock::RESTRICTED_WEIGHTED;
    break;
  case LVL1::CMXEtSums::MISSING_ET_SIG_STANDARD:
    hitType = CmxEnergySubBlock::MISSING_ET_SIG;
    sumType = CmxEnergySubBlock::STANDARD;
    break;
  default:
    break;
  }
}

evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

finalize()

StatusCode LVL1BS::JepRoiByteStreamV2Tool::finalize ( )

overridevirtual

Definition at line 103 of file JepRoiByteStreamV2Tool.cxx.

{
  return StatusCode::SUCCESS;
}

findCmxSums()

const LVL1::CMXEtSums * LVL1BS::JepRoiByteStreamV2Tool::findCmxSums ( int  crate, int  source, const CmxSumsMap &  cmxEtMap  ) const

private

Find CMX energy sums for given crate, source.

Definition at line 630 of file JepRoiByteStreamV2Tool.cxx.

{
  const LVL1::CMXEtSums* sums = 0;
  CmxSumsMap::const_iterator mapIter;
  mapIter = cmxEtMap.find(crate * 100 + source);
  if (mapIter != cmxEtMap.end()) sums = mapIter->second;
  return sums;
}

initialize()

StatusCode LVL1BS::JepRoiByteStreamV2Tool::initialize ( )

overridevirtual

Definition at line 91 of file JepRoiByteStreamV2Tool.cxx.

{
  ATH_MSG_INFO ("Initializing " << name());
 
  ATH_CHECK( m_errorTool.retrieve() );
  ATH_CHECK( m_byteStreamCnvSvc.retrieve() );
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & LVL1BS::JepRoiByteStreamV2Tool::interfaceID ( )

static

AlgTool InterfaceID.

Definition at line 37 of file JepRoiByteStreamV2Tool.cxx.

{
  return IID_IJepRoiByteStreamV2Tool;
}

makeSourceIDs()

std::vector< uint32_t > LVL1BS::JepRoiByteStreamV2Tool::makeSourceIDs ( bool  roiDaq ) const

private

Definition at line 327 of file JepRoiByteStreamV2Tool.cxx.

{
  std::vector<uint32_t> sourceIDs;
 
  if (roiDaq) {
    sourceIDs = m_sourceIDsProp;
  }
  else {
    sourceIDs = m_sourceIDsRoIBProp;
  }
 
  if (sourceIDs.empty()) {
        const int maxCrates = m_crates + m_crateOffsetHw;
        const int maxSlinks = m_srcIdMap.maxSlinks();
        for (int hwCrate = m_crateOffsetHw; hwCrate < maxCrates; ++hwCrate)
        {
            for (int slink = 0; slink < maxSlinks; ++slink)
            {
                const int daqOrRoi = 1;
                const uint32_t rodId = m_srcIdMap.getRodID(hwCrate, slink, daqOrRoi,
                                       m_subDetector);
                const uint32_t robId = m_srcIdMap.getRobID(rodId);
                if (roiDaq)
                {
                    if (slink < 2) sourceIDs.push_back(robId);
                }
                else if (slink >= 2) sourceIDs.push_back(robId);
            }
        }
 
  }
  return sourceIDs;
}

msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setupCmxEtMap()

void LVL1BS::JepRoiByteStreamV2Tool::setupCmxEtMap ( const CmxSumsCollection *  enCollection, CmxSumsMap &  cmxEtMap  ) const

private

Set up CMX energy sums map.

Definition at line 661 of file JepRoiByteStreamV2Tool.cxx.

{
  cmxEtMap.clear();
  if (etCollection) {
    CmxSumsCollection::const_iterator pos  = etCollection->begin();
    CmxSumsCollection::const_iterator pose = etCollection->end();
    for (; pos != pose; ++pos) {
      const LVL1::CMXEtSums* const sums = *pos;
      const int crate = sums->crate() - m_crateOffsetSw;
      const int key   = crate * 100 + sums->source();
      cmxEtMap.insert(std::make_pair(key, sums));
    }
  }
}

setupJemRoiMap()

void LVL1BS::JepRoiByteStreamV2Tool::setupJemRoiMap ( const JemRoiCollection *  jeCollection, JemRoiMap &  roiMap  ) const

private

Set up JEM RoIs map.

Definition at line 643 of file JepRoiByteStreamV2Tool.cxx.

{
  roiMap.clear();
  if (jeCollection) {
    JemRoiCollection::const_iterator pos  = jeCollection->begin();
    JemRoiCollection::const_iterator pose = jeCollection->end();
    for (; pos != pose; ++pos) {
      const LVL1::JEMTobRoI* const roi = *pos;
      const uint32_t key = roi->roiWord();
      roiMap.insert(std::make_pair(key, roi));
    }
  }
}

sourceIDs()

const std::vector< uint32_t > & LVL1BS::JepRoiByteStreamV2Tool::sourceIDs

(

const std::string &

sgKey

)

const

Return reference to vector with all possible Source Identifiers.

Definition at line 361 of file JepRoiByteStreamV2Tool.cxx.

{
  const std::string flag("RoIB");
  const std::string::size_type pos = sgKey.find(flag);
  const bool roiDaq =
    (pos == std::string::npos || pos != sgKey.length() - flag.length());
 
  if (roiDaq) {
    static const std::vector<uint32_t> sourceIDs = makeSourceIDs(roiDaq);
    return sourceIDs;
  }
  else {
    static const std::vector<uint32_t> sourceIDsRoIB = makeSourceIDs(roiDaq);
    return sourceIDsRoIB;
  }
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_byteStreamCnvSvc

ServiceHandle<IByteStreamCnvSvc> LVL1BS::JepRoiByteStreamV2Tool::m_byteStreamCnvSvc { this, "ByteStreamCnvSvc", "ByteStreamCnvSvc" }

private

Definition at line 82 of file JepRoiByteStreamV2Tool.h.

m_crateMax

int LVL1BS::JepRoiByteStreamV2Tool::m_crateMax

private

Property: Maximum crate number when writing out bytestream.

Definition at line 142 of file JepRoiByteStreamV2Tool.h.

m_crateMin

int LVL1BS::JepRoiByteStreamV2Tool::m_crateMin

private

Property: Minimum crate number when writing out bytestream.

Definition at line 140 of file JepRoiByteStreamV2Tool.h.

m_crateOffsetHw

int LVL1BS::JepRoiByteStreamV2Tool::m_crateOffsetHw

private

Property: Hardware crate number offset.

Definition at line 122 of file JepRoiByteStreamV2Tool.h.

m_crateOffsetSw

int LVL1BS::JepRoiByteStreamV2Tool::m_crateOffsetSw

private

Property: Software crate number offset.

Definition at line 124 of file JepRoiByteStreamV2Tool.h.

m_crates

const int LVL1BS::JepRoiByteStreamV2Tool::m_crates

private

Number of crates.

Definition at line 130 of file JepRoiByteStreamV2Tool.h.

m_dataFormat

int LVL1BS::JepRoiByteStreamV2Tool::m_dataFormat

private

Property: Data compression format.

Definition at line 128 of file JepRoiByteStreamV2Tool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_errorTool

ToolHandle<LVL1BS::L1CaloErrorByteStreamTool> LVL1BS::JepRoiByteStreamV2Tool::m_errorTool

private

Property: Error collection tool.

Definition at line 100 of file JepRoiByteStreamV2Tool.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_frames

const int LVL1BS::JepRoiByteStreamV2Tool::m_frames

private

Number of RoI frames.

Definition at line 134 of file JepRoiByteStreamV2Tool.h.

m_maxRoiWords

const int LVL1BS::JepRoiByteStreamV2Tool::m_maxRoiWords

private

Number of CMX energy RoI words.

Definition at line 136 of file JepRoiByteStreamV2Tool.h.

m_modules

const int LVL1BS::JepRoiByteStreamV2Tool::m_modules

private

Number of JEM modules per crate.

Definition at line 132 of file JepRoiByteStreamV2Tool.h.

m_robDataProvider

ServiceHandle<IROBDataProviderSvc> LVL1BS::JepRoiByteStreamV2Tool::m_robDataProvider

private

Definition at line 98 of file JepRoiByteStreamV2Tool.h.

m_slinks

int LVL1BS::JepRoiByteStreamV2Tool::m_slinks

private

Property: Number of slinks per crate when writing out bytestream.

Definition at line 138 of file JepRoiByteStreamV2Tool.h.

m_sourceIDsProp

std::vector<uint32_t> LVL1BS::JepRoiByteStreamV2Tool::m_sourceIDsProp

private

Property: ROB source IDs.

Definition at line 144 of file JepRoiByteStreamV2Tool.h.

m_sourceIDsRoIBProp

std::vector<uint32_t> LVL1BS::JepRoiByteStreamV2Tool::m_sourceIDsRoIBProp

private

Property: ROB source IDs for RoIB.

Definition at line 146 of file JepRoiByteStreamV2Tool.h.

m_srcIdMap

const L1CaloSrcIdMap LVL1BS::JepRoiByteStreamV2Tool::m_srcIdMap

private

Source ID converter.

Definition at line 150 of file JepRoiByteStreamV2Tool.h.

m_subDetector

const eformat::SubDetector LVL1BS::JepRoiByteStreamV2Tool::m_subDetector

private

Sub-detector type.

Definition at line 148 of file JepRoiByteStreamV2Tool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_version

int LVL1BS::JepRoiByteStreamV2Tool::m_version

private

Property: Sub_block header version.

Definition at line 126 of file JepRoiByteStreamV2Tool.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• JepRoiByteStreamV2Tool.h
• JepRoiByteStreamV2Tool.cxx