LVL1BS::JepRoiByteStreamV1Tool Class Reference

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

#include <JepRoiByteStreamV1Tool.h>

Inheritance diagram for LVL1BS::JepRoiByteStreamV1Tool:

Collaboration diagram for LVL1BS::JepRoiByteStreamV1Tool:

Public Member Functions
	JepRoiByteStreamV1Tool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~JepRoiByteStreamV1Tool ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
StatusCode	convert (const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::JEMRoI > *jeCollection) const
	Convert ROB fragments to JEM RoIs. More...
StatusCode	convert (const IROBDataProviderSvc::VROBFRAG &robFrags, LVL1::CMMRoI *cmCollection) const
	Convert ROB fragments to CMM RoIs. More...
StatusCode	convert (const LVL1::JEPRoIBSCollectionV1 *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::JEMRoI >	JemRoiCollection
typedef DataVector< LVL1::CMMJetHits >	CmmHitsCollection
typedef DataVector< LVL1::CMMEtSums >	CmmSumsCollection
typedef std::map< uint32_t, const LVL1::JEMRoI * >	JemRoiMap
typedef std::map< int, const LVL1::CMMJetHits * >	CmmHitsMap
typedef std::map< int, const LVL1::CMMEtSums * >	CmmSumsMap
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::JEMRoI > *jeCollection, LVL1::CMMRoI *cmCollection) const
	Convert bytestream to given container type. More...
const LVL1::CMMJetHits *	findCmmHits (int crate, int dataID, const CmmHitsMap &cmmHitsMap) const
	Find CMM hits for given crate, data ID. More...
const LVL1::CMMEtSums *	findCmmSums (int crate, int dataID, const CmmSumsMap &cmmEtMap) const
	Find CMM energy sums for given crate, data ID. More...
std::vector< uint32_t >	makeSourceIDs (bool roiDaq) const
void	setupJemRoiMap (const JemRoiCollection *jeCollection, JemRoiMap &roiMap) const
	Set up JEM RoIs map. More...
void	setupCmmHitsMap (const CmmHitsCollection *hitCollection, CmmHitsMap &cmmHitsMap) const
	Set up CMM hits map. More...
void	setupCmmEtMap (const CmmSumsCollection *enCollection, CmmSumsMap &cmmEtMap) const
	Set up CMM energy sums map. 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< ByteStreamCnvSvc >	m_byteStreamCnvSvc { this, "ByteStreamCnvSvc", "ByteStreamCnvSvc" }
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...
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 CMM RoI, and JEP RoI container to raw data conversions.

Based on ROD document version 1_09h.

Author

Peter Faulkner

Definition at line 53 of file JepRoiByteStreamV1Tool.h.

Member Typedef Documentation

CmmHitsCollection

typedef DataVector<LVL1::CMMJetHits> LVL1BS::JepRoiByteStreamV1Tool::CmmHitsCollection

private

Definition at line 84 of file JepRoiByteStreamV1Tool.h.

CmmHitsMap

typedef std::map<int, const LVL1::CMMJetHits*> LVL1BS::JepRoiByteStreamV1Tool::CmmHitsMap

private

Definition at line 87 of file JepRoiByteStreamV1Tool.h.

CmmSumsCollection

typedef DataVector<LVL1::CMMEtSums> LVL1BS::JepRoiByteStreamV1Tool::CmmSumsCollection

private

Definition at line 85 of file JepRoiByteStreamV1Tool.h.

CmmSumsMap

typedef std::map<int, const LVL1::CMMEtSums*> LVL1BS::JepRoiByteStreamV1Tool::CmmSumsMap

private

Definition at line 88 of file JepRoiByteStreamV1Tool.h.

JemRoiCollection

typedef DataVector<LVL1::JEMRoI> LVL1BS::JepRoiByteStreamV1Tool::JemRoiCollection

private

Definition at line 83 of file JepRoiByteStreamV1Tool.h.

JemRoiMap

typedef std::map<uint32_t, const LVL1::JEMRoI*> LVL1BS::JepRoiByteStreamV1Tool::JemRoiMap

private

Definition at line 86 of file JepRoiByteStreamV1Tool.h.

ROBIterator

typedef IROBDataProviderSvc::VROBFRAG::const_iterator LVL1BS::JepRoiByteStreamV1Tool::ROBIterator

private

Definition at line 89 of file JepRoiByteStreamV1Tool.h.

ROBPointer

typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType LVL1BS::JepRoiByteStreamV1Tool::ROBPointer

private

Definition at line 90 of file JepRoiByteStreamV1Tool.h.

RODPointer

typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType LVL1BS::JepRoiByteStreamV1Tool::RODPointer

private

Definition at line 91 of file JepRoiByteStreamV1Tool.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

JepRoiByteStreamV1Tool()

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

Definition at line 47 of file JepRoiByteStreamV1Tool.cxx.

  : AthAlgTool(type, name, parent),
    m_errorTool("LVL1BS::L1CaloErrorByteStreamTool/L1CaloErrorByteStreamTool"),
    m_crates(2), m_modules(16),
    m_subDetector (eformat::TDAQ_CALO_JET_PROC_ROI)
{
  declareInterface<JepRoiByteStreamV1Tool>(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       = 1,
                  "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");
 
}

~JepRoiByteStreamV1Tool()

LVL1BS::JepRoiByteStreamV1Tool::~JepRoiByteStreamV1Tool ( )

virtual

Definition at line 86 of file JepRoiByteStreamV1Tool.cxx.

{
}

Member Function Documentation

convert() [1/3]

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

Convert ROB fragments to JEM RoIs.

Definition at line 112 of file JepRoiByteStreamV1Tool.cxx.

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

convert() [2/3]

StatusCode LVL1BS::JepRoiByteStreamV1Tool::convert	(	const IROBDataProviderSvc::VROBFRAG &	robFrags,
		LVL1::CMMRoI *	cmCollection
	)		const

Convert ROB fragments to CMM RoIs.

Definition at line 121 of file JepRoiByteStreamV1Tool.cxx.

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

convert() [3/3]

StatusCode LVL1BS::JepRoiByteStreamV1Tool::convert

(

const LVL1::JEPRoIBSCollectionV1 *

jep

)

const

Convert JEP RoI Container to bytestream.

Definition at line 130 of file JepRoiByteStreamV1Tool.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,
                                                        "JepRoiByteStreamV1") );
  const uint16_t minorVersion = m_srcIdMap.minorVersionPreLS1();
  fea->setRodMinorVersion(minorVersion);
 
  // Pointer to ROD data vector
 
  FullEventAssembler<L1CaloSrcIdMap>::RODDATA* theROD = 0;
 
  // Sub-block for neutral format
  JemRoiSubBlockV1 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();
 
  // CMM hits map
  CmmHitsMap cmmHitsMap;
  // CMM energy sums map
  CmmSumsMap cmmEtMap;
  if (neutralFormat) {
    setupCmmHitsMap(jep->CmmHits(), cmmHitsMap);
    setupCmmEtMap(jep->CmmSums(), cmmEtMap);
  }
 
  // 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::JEMRoI* 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->hits() || roi->error()) {
          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 CMM 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;
 
      // CMM-Energy
 
      CmmEnergySubBlock enBlock;
      const int cmmEnergyVersion = 2; // with Missing-ET-Sig
      enBlock.setCmmHeader(cmmEnergyVersion, m_dataFormat, slice, hwCrate,
                           CmmSubBlock::SYSTEM, CmmSubBlock::CMM_ENERGY,
                           CmmSubBlock::LEFT, timeslices);
      int maxDataID = static_cast<int>(LVL1::CMMEtSums::MAXID);
      for (int dataID = 0; dataID < maxDataID; ++dataID) {
        int source = dataID;
        if (dataID >= m_modules) {
          switch (dataID) {
          case LVL1::CMMEtSums::LOCAL:
            source = CmmEnergySubBlock::LOCAL;
            break;
          case LVL1::CMMEtSums::REMOTE:
            source = CmmEnergySubBlock::REMOTE;
            break;
          case LVL1::CMMEtSums::TOTAL:
            source = CmmEnergySubBlock::TOTAL;
            break;
          case LVL1::CMMEtSums::MISSING_ET_MAP:
          case LVL1::CMMEtSums::SUM_ET_MAP:
          case LVL1::CMMEtSums::MISSING_ET_SIG_MAP:
            break;
          default:
            continue;
          }
        }
        const LVL1::CMMEtSums* const sums = findCmmSums(crate, dataID, cmmEtMap);
        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 (dataID == LVL1::CMMEtSums::MISSING_ET_MAP) {
            enBlock.setMissingEtHits(slice, et);
          } else if (dataID == LVL1::CMMEtSums::SUM_ET_MAP) {
            enBlock.setSumEtHits(slice, et);
          } else if (dataID == LVL1::CMMEtSums::MISSING_ET_SIG_MAP) {
            enBlock.setMissingEtSigHits(slice, et);
          } else {
            enBlock.setSubsums(slice, source, ex, ey, et, exErr, eyErr, etErr);
          }
        }
      }
      if ( !enBlock.pack()) {
        msg(MSG::ERROR) << "CMM-Energy sub-block packing failed" << endmsg;
        return StatusCode::FAILURE;
      }
      if (debug) {
        msg() << "CMM-Energy sub-block data words: "
              << enBlock.dataWords() << endmsg;
      }
      enBlock.write(theROD);
 
      // CMM-Jet
 
      CmmJetSubBlock jetBlock;
      jetBlock.setCmmHeader(m_version, m_dataFormat, slice, hwCrate,
                            CmmSubBlock::SYSTEM, CmmSubBlock::CMM_JET,
                            CmmSubBlock::RIGHT, timeslices);
      maxDataID = static_cast<int>(LVL1::CMMJetHits::MAXID);
      for (int dataID = 0; dataID < maxDataID; ++dataID) {
        int source = dataID;
        if (dataID >= m_modules) {
          // coverity[mixed_enums : FALSE]
          // coverity[switch_on_enum : FALSE]
          // coverity[first_enum_type : FALSE]
          switch (dataID) {
          case LVL1::CMMJetHits::LOCAL_MAIN:
            source = CmmJetSubBlock::LOCAL_MAIN;
            break;
          case LVL1::CMMJetHits::REMOTE_MAIN:
            source = CmmJetSubBlock::REMOTE_MAIN;
            break;
          case LVL1::CMMJetHits::TOTAL_MAIN:
            source = CmmJetSubBlock::TOTAL_MAIN;
            break;
          case LVL1::CMMJetHits::LOCAL_FORWARD:
            source = CmmJetSubBlock::LOCAL_FORWARD;
            break;
          case LVL1::CMMJetHits::REMOTE_FORWARD:
            source = CmmJetSubBlock::REMOTE_FORWARD;
            break;
          case LVL1::CMMJetHits::TOTAL_FORWARD:
            source = CmmJetSubBlock::TOTAL_FORWARD;
            break;
          case LVL1::CMMJetHits::ET_MAP:
            break;
          default:
            continue;
          }
        }
        const LVL1::CMMJetHits* const ch = findCmmHits(crate, dataID, cmmHitsMap);
        if ( ch ) {
          const unsigned int hits = ch->Hits();
          const int          errs = ch->Error();
          if (dataID == LVL1::CMMJetHits::ET_MAP) {
            jetBlock.setJetEtMap(slice, hits);
          } else {
            jetBlock.setJetHits(slice, source, hits, errs);
          }
        }
      }
      if ( !jetBlock.pack()) {
        msg(MSG::ERROR) << "CMM-Jet sub-block packing failed" << endmsg;
        return StatusCode::FAILURE;
      }
      if (debug) {
        msg() << "CMM-Jet sub-block data words: "
              << jetBlock.dataWords() << endmsg;
      }
      jetBlock.write(theROD);
 
    } else {
 
      // Standard format
 
      const LVL1::CMMRoI* const roi = jep->CmmRoi();
      if ( roi ) {
        // Make sure word IDs are correct
        const LVL1::CMMRoI roid(roi->jetEtHits(), roi->sumEtHits(),
                                roi->missingEtHits(), roi->missingEtSigHits(),
                                roi->ex(), roi->ey(), roi->et(),
                                roi->jetEtError(), roi->sumEtError(),
                                roi->missingEtError(), roi->missingEtSigError(),
                                roi->exError(), roi->eyError(), roi->etError());
        if (roid.jetEtHits() || roid.jetEtError()) {
          theROD->push_back(roid.jetEtRoiWord());
        }
        // CMM-Energy RoIs are not zero-supressed unless all are zero
        if (roid.sumEtHits() || roid.missingEtHits() ||
            roid.missingEtSigHits() || roid.ex() || roid.ey() || roid.et() ||
            roid.sumEtError() || roid.missingEtError() ||
            roid.missingEtSigError() || roid.exError() || roid.eyError() ||
            roid.etError()) {
          theROD->push_back(roid.energyRoiWord0());
          theROD->push_back(roid.energyRoiWord1());
          theROD->push_back(roid.energyRoiWord2());
        }
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

convertBs()

StatusCode LVL1BS::JepRoiByteStreamV1Tool::convertBs ( const IROBDataProviderSvc::VROBFRAG &  robFrags, DataVector< LVL1::JEMRoI > *  jeCollection, LVL1::CMMRoI *  cmCollection  ) const

private

Convert bytestream to given container type.

Definition at line 452 of file JepRoiByteStreamV1Tool.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 post-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 (CmmSubBlock::cmmBlock(*payload)) {
          // CMMs
          if (CmmSubBlock::cmmType(*payload) == CmmSubBlock::CMM_JET) {
            CmmJetSubBlock subBlock;
            payload = subBlock.read(payload, payloadEnd);
            if (cmCollection != nullptr) {
              if (subBlock.dataWords() && !subBlock.unpack()) {
                if (debug) {
                  std::string errMsg(subBlock.unpackErrorMsg());
                  msg() << "CMM-Jet sub-block unpacking failed: "
                        << errMsg << endmsg;
                }
                rodErr = subBlock.unpackErrorCode();
                break;
              }
              const LVL1::CMMRoI roi(subBlock.jetEtMap(slice),
                                     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
              cmCollection->setRoiWord(roi.jetEtRoiWord());
            }
          } else {
            CmmEnergySubBlock subBlock;
            payload = subBlock.read(payload, payloadEnd);
            if (cmCollection != nullptr) {
              if (subBlock.dataWords() && !subBlock.unpack()) {
                if (debug) {
                  std::string errMsg(subBlock.unpackErrorMsg());
                  msg() << "CMM-Energy sub-block unpacking failed: "
                        << errMsg << endmsg;
                }
                rodErr = subBlock.unpackErrorCode();
                break;
              }
              const LVL1::CMMRoI roi(0, subBlock.sumEtHits(slice),
                                     subBlock.missingEtHits(slice),
                                     subBlock.missingEtSigHits(slice),
                                     subBlock.ex(slice, CmmEnergySubBlock::TOTAL),
                                     subBlock.ey(slice, CmmEnergySubBlock::TOTAL),
                                     subBlock.et(slice, CmmEnergySubBlock::TOTAL),
                                     0, 0, 0, 0,
                                     subBlock.exError(slice, CmmEnergySubBlock::TOTAL),
                                     subBlock.eyError(slice, CmmEnergySubBlock::TOTAL),
                                     subBlock.etError(slice, CmmEnergySubBlock::TOTAL));
              cmCollection->setRoiWord(roi.energyRoiWord0());
              cmCollection->setRoiWord(roi.energyRoiWord1());
              cmCollection->setRoiWord(roi.energyRoiWord2());
            }
          }
        } else {
          // JEM RoI
          JemRoiSubBlockV1 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 < 8; ++frame) {
              for (int forward = 0; forward < 2; ++forward) {
                const LVL1::JEMRoI roi = subBlock.roi(frame, forward);
                if (roi.hits() || roi.error()) {
                  jeCollection->push_back(new LVL1::JEMRoI(roi));
                }
              }
            }
          }
        }
      } else {
        // Just RoI word
        LVL1::JEMRoI jroi;
        LVL1::CMMRoI 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) & 0xfffc0000;
            if (dupRoiCheck.insert(location).second) {
              if (jroi.hits() || jroi.error()) {
                jeCollection->push_back(new LVL1::JEMRoI(*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) {
            uint32_t roiType = (*payload) & 0xf0000000;
            if ((roiType & 0xe0000000) == 0xa0000000) roiType = 0xa0000000;
            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; }

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::JepRoiByteStreamV1Tool::finalize ( )

overridevirtual

Definition at line 105 of file JepRoiByteStreamV1Tool.cxx.

{
  return StatusCode::SUCCESS;
}

findCmmHits()

const LVL1::CMMJetHits * LVL1BS::JepRoiByteStreamV1Tool::findCmmHits ( int  crate, int  dataID, const CmmHitsMap &  cmmHitsMap  ) const

private

Find CMM hits for given crate, data ID.

Definition at line 683 of file JepRoiByteStreamV1Tool.cxx.

{
  const LVL1::CMMJetHits* hits = 0;
  CmmHitsMap::const_iterator mapIter;
  mapIter = cmmHitsMap.find(crate * 100 + dataID);
  if (mapIter != cmmHitsMap.end()) hits = mapIter->second;
  return hits;
}

findCmmSums()

const LVL1::CMMEtSums * LVL1BS::JepRoiByteStreamV1Tool::findCmmSums ( int  crate, int  dataID, const CmmSumsMap &  cmmEtMap  ) const

private

Find CMM energy sums for given crate, data ID.

Definition at line 696 of file JepRoiByteStreamV1Tool.cxx.

{
  const LVL1::CMMEtSums* sums = 0;
  CmmSumsMap::const_iterator mapIter;
  mapIter = cmmEtMap.find(crate * 100 + dataID);
  if (mapIter != cmmEtMap.end()) sums = mapIter->second;
  return sums;
}

initialize()

StatusCode LVL1BS::JepRoiByteStreamV1Tool::initialize ( )

overridevirtual

Definition at line 93 of file JepRoiByteStreamV1Tool.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::JepRoiByteStreamV1Tool::interfaceID ( )

static

AlgTool InterfaceID.

Definition at line 40 of file JepRoiByteStreamV1Tool.cxx.

{
  return IID_IJepRoiByteStreamV1Tool;
}

makeSourceIDs()

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

private

Definition at line 398 of file JepRoiByteStreamV1Tool.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();
  }

setupCmmEtMap()

void LVL1BS::JepRoiByteStreamV1Tool::setupCmmEtMap ( const CmmSumsCollection *  enCollection, CmmSumsMap &  cmmEtMap  ) const

private

Set up CMM energy sums map.

Definition at line 746 of file JepRoiByteStreamV1Tool.cxx.

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

setupCmmHitsMap()

void LVL1BS::JepRoiByteStreamV1Tool::setupCmmHitsMap ( const CmmHitsCollection *  hitCollection, CmmHitsMap &  cmmHitsMap  ) const

private

Set up CMM hits map.

Definition at line 727 of file JepRoiByteStreamV1Tool.cxx.

{
  cmmHitsMap.clear();
  if (hitCollection) {
    CmmHitsCollection::const_iterator pos  = hitCollection->begin();
    CmmHitsCollection::const_iterator pose = hitCollection->end();
    for (; pos != pose; ++pos) {
      const LVL1::CMMJetHits* const hits = *pos;
      const int crate = hits->crate() - m_crateOffsetSw;
      const int key   = crate * 100 + hits->dataID();
      cmmHitsMap.insert(std::make_pair(key, hits));
    }
  }
}

setupJemRoiMap()

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

private

Set up JEM RoIs map.

Definition at line 709 of file JepRoiByteStreamV1Tool.cxx.

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

sourceIDs()

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

(

const std::string &

sgKey

)

const

Return reference to vector with all possible Source Identifiers.

Definition at line 432 of file JepRoiByteStreamV1Tool.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<ByteStreamCnvSvc> LVL1BS::JepRoiByteStreamV1Tool::m_byteStreamCnvSvc { this, "ByteStreamCnvSvc", "ByteStreamCnvSvc" }

private

Definition at line 80 of file JepRoiByteStreamV1Tool.h.

m_crateMax

int LVL1BS::JepRoiByteStreamV1Tool::m_crateMax

private

Property: Maximum crate number when writing out bytestream.

Definition at line 137 of file JepRoiByteStreamV1Tool.h.

m_crateMin

int LVL1BS::JepRoiByteStreamV1Tool::m_crateMin

private

Property: Minimum crate number when writing out bytestream.

Definition at line 135 of file JepRoiByteStreamV1Tool.h.

m_crateOffsetHw

int LVL1BS::JepRoiByteStreamV1Tool::m_crateOffsetHw

private

Property: Hardware crate number offset.

Definition at line 121 of file JepRoiByteStreamV1Tool.h.

m_crateOffsetSw

int LVL1BS::JepRoiByteStreamV1Tool::m_crateOffsetSw

private

Property: Software crate number offset.

Definition at line 123 of file JepRoiByteStreamV1Tool.h.

m_crates

const int LVL1BS::JepRoiByteStreamV1Tool::m_crates

private

Number of crates.

Definition at line 129 of file JepRoiByteStreamV1Tool.h.

m_dataFormat

int LVL1BS::JepRoiByteStreamV1Tool::m_dataFormat

private

Property: Data compression format.

Definition at line 127 of file JepRoiByteStreamV1Tool.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::JepRoiByteStreamV1Tool::m_errorTool

private

Property: Error collection tool.

Definition at line 99 of file JepRoiByteStreamV1Tool.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_modules

const int LVL1BS::JepRoiByteStreamV1Tool::m_modules

private

Number of JEM modules per crate.

Definition at line 131 of file JepRoiByteStreamV1Tool.h.

m_slinks

int LVL1BS::JepRoiByteStreamV1Tool::m_slinks

private

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

Definition at line 133 of file JepRoiByteStreamV1Tool.h.

m_sourceIDsProp

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

private

Property: ROB source IDs.

Definition at line 139 of file JepRoiByteStreamV1Tool.h.

m_sourceIDsRoIBProp

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

private

Property: ROB source IDs for RoIB.

Definition at line 141 of file JepRoiByteStreamV1Tool.h.

m_srcIdMap

const L1CaloSrcIdMap LVL1BS::JepRoiByteStreamV1Tool::m_srcIdMap

private

Source ID converter.

Definition at line 145 of file JepRoiByteStreamV1Tool.h.

m_subDetector

const eformat::SubDetector LVL1BS::JepRoiByteStreamV1Tool::m_subDetector

private

Sub-detector type.

Definition at line 143 of file JepRoiByteStreamV1Tool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_version

int LVL1BS::JepRoiByteStreamV1Tool::m_version

private

Property: Sub_block header version.

Definition at line 125 of file JepRoiByteStreamV1Tool.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:

• JepRoiByteStreamV1Tool.h
• JepRoiByteStreamV1Tool.cxx