TriggerBitsMakerTool Class Reference

Obtains trigger bits from Navigation summary via getBits and (online) fills trigger bits in the HLTResultMT object. More...

#include <TriggerBitsMakerTool.h>

Inheritance diagram for TriggerBitsMakerTool:

Collaboration diagram for TriggerBitsMakerTool:

Public Member Functions
	TriggerBitsMakerTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~TriggerBitsMakerTool () override=default
virtual StatusCode	fill (HLT::HLTResultMT &resultToFill, const EventContext &ctx) const override
virtual StatusCode	getBits (boost::dynamic_bitset< uint32_t > &passRaw, boost::dynamic_bitset< uint32_t > &prescaled, const EventContext &ctx) const override
virtual StatusCode	initialize () override
virtual StatusCode	start () override

Private Types
using	ChainToBitMap = std::map< TrigCompositeUtils::DecisionID, uint32_t>

Private Member Functions
StatusCode	setBit (const TrigCompositeUtils::DecisionID chain, boost::dynamic_bitset< uint32_t > &resultToFill) const
	Set to 1 the bit correspinding to 'chain' in 'resultToFill'.
StatusCode	hashConsistencyCheck (const std::string &chain, const size_t hash) const
	Check that a chain's hash in the menu JSON (via python) agrees with the C++ implementation.
StatusCode	preInsertCheck (const std::string &chain, const uint32_t bit) const
	Check that no existing key maps to a given value and that the string is not empty.

Private Attributes
SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer >	m_finalChainDecisions
SG::ReadHandleKey< TrigConf::HLTMenu >	m_HLTMenuKey {this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu", "HLT Menu"}
Gaudi::Property< std::map< std::string, uint32_t > >	m_extraChainToBit
ChainToBitMap	m_mapping
	Mapping of each chain's hash ID to its chain counter.
uint32_t	m_largestBit {0}
	Largest chain counter hence largest bit needed to be stored in result bitmap.

Detailed Description

Obtains trigger bits from Navigation summary via getBits and (online) fills trigger bits in the HLTResultMT object.

Definition at line 18 of file TriggerBitsMakerTool.h.

Member Typedef Documentation

ChainToBitMap

using TriggerBitsMakerTool::ChainToBitMap = std::map< TrigCompositeUtils::DecisionID, uint32_t>

private

Definition at line 57 of file TriggerBitsMakerTool.h.

Constructor & Destructor Documentation

TriggerBitsMakerTool()

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

Definition at line 11 of file TriggerBitsMakerTool.cxx.

                                                                                                                 :
  base_class(type, name, parent){}

~TriggerBitsMakerTool()

virtual TriggerBitsMakerTool::~TriggerBitsMakerTool ( )

overridevirtualdefault

Member Function Documentation

fill()

StatusCode TriggerBitsMakerTool::fill ( HLT::HLTResultMT & resultToFill, const EventContext & ctx ) const

overridevirtual

Definition at line 136 of file TriggerBitsMakerTool.cxx.

                                                                                                   {
 
  {
    boost::dynamic_bitset<uint32_t> passRaw;
    boost::dynamic_bitset<uint32_t> prescaled;
 
    ATH_CHECK(getBits(passRaw, prescaled, ctx));
    resultToFill.setHltBits(passRaw, prescaled);
  }
 
  if ( msgLvl( MSG::DEBUG ) ) {
    const boost::dynamic_bitset<uint32_t>& passRawBits = resultToFill.getHltPassRawBits();
    std::vector<uint32_t> bitsTemp(passRawBits.num_blocks());
    boost::to_block_range(passRawBits, bitsTemp.begin());
    ATH_MSG_VERBOSE("HLT result now has " << bitsTemp.size() << " words with HLT pass raw bits:");
    for (const auto& w : bitsTemp) ATH_MSG_VERBOSE("0x" << MSG::hex << w << MSG::dec);
    //
    const boost::dynamic_bitset<uint32_t>& prescaleBits = resultToFill.getHltPrescaledBits();
    boost::to_block_range(prescaleBits, bitsTemp.begin());
    ATH_MSG_VERBOSE("HLT result now has " << bitsTemp.size() << " words with HLT prescale bits:");
    for (const auto& w : bitsTemp) ATH_MSG_VERBOSE("0x" << MSG::hex << w << MSG::dec);
    //
    const std::vector<uint32_t>& words = resultToFill.getHltBitsAsWords();
    ATH_MSG_DEBUG("HLT result now has " << words.size() << " words with the final trigger bits:");
    for (const uint32_t w : words) ATH_MSG_DEBUG("0x" << MSG::hex << w << MSG::dec);
  }
 
  return StatusCode::SUCCESS;
 
}

getBits()

StatusCode TriggerBitsMakerTool::getBits ( boost::dynamic_bitset< uint32_t > & passRaw, boost::dynamic_bitset< uint32_t > & prescaled, const EventContext & ctx ) const

overridevirtual

< The chains which returned a positive decision

< The chains which did not run due to being prescaled out

Definition at line 76 of file TriggerBitsMakerTool.cxx.

{
  using namespace TrigCompositeUtils;
 
  passRaw.clear();
  prescaled.clear();
 
  auto chainsHandle = SG::makeHandle(m_finalChainDecisions, ctx);
  if (!chainsHandle.isValid()) {
    SmartIF<IAlgExecStateSvc> aess = svcLoc()->service<IAlgExecStateSvc>("AlgExecStateSvc", false);
    if (aess.isValid() && aess->eventStatus(ctx) != EventStatus::Success) {
      ATH_MSG_WARNING("Failed event, " << m_finalChainDecisions.key() << " is unavailable. Skipping trigger bits making.");
      return StatusCode::SUCCESS;
    }
    ATH_MSG_ERROR("Unable to read in the " << m_finalChainDecisions.key() << " from the DecisionSummaryMakerAlg");
    return StatusCode::FAILURE;
  }
 
  passRaw.resize(m_largestBit + 1);
  prescaled.resize(m_largestBit + 1);
 
  const Decision* HLTPassRaw = nullptr;
  const Decision* HLTPrescaled = nullptr;
 
  DecisionIDContainer passRawIDs; 
  DecisionIDContainer prescaledIDs; 
 
  // Read the sets of chain IDs
  for (const Decision* decisionObject : *chainsHandle) {
    // Collect all decisions (IDs of passed/prescaled chains) from named decisionObjects
    if (decisionObject->name() == TrigCompositeUtils::summaryPassNodeName()) {
      HLTPassRaw = decisionObject;
    } else if (decisionObject->name() == TrigCompositeUtils::summaryPrescaledNodeName()) {
      HLTPrescaled = decisionObject;
    }
    if (HLTPassRaw != nullptr && HLTPrescaled != nullptr) {
      break;
    }
  }
 
  ATH_CHECK(HLTPassRaw != nullptr);
  ATH_CHECK(HLTPrescaled != nullptr);
 
  decisionIDs(HLTPassRaw, passRawIDs);
  decisionIDs(HLTPrescaled, prescaledIDs);
 
  for ( DecisionID chain: passRawIDs ) {
    ATH_CHECK(setBit(chain, passRaw));
  }
 
  for ( DecisionID chain: prescaledIDs ) {
    ATH_CHECK(setBit(chain, prescaled));
  }
 
  return StatusCode::SUCCESS;
 
}

hashConsistencyCheck()

StatusCode TriggerBitsMakerTool::hashConsistencyCheck ( const std::string & chain, const size_t hash ) const

private

Check that a chain's hash in the menu JSON (via python) agrees with the C++ implementation.

Definition at line 50 of file TriggerBitsMakerTool.cxx.

                                                                                                     {
  if (HLT::Identifier( chain ).numeric() != hash) {
    ATH_MSG_ERROR("Inconsistent hashes found for chain:" << chain << ", from Python:" << hash
      << ", from C++:" << HLT::Identifier( chain ).numeric());
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

initialize()

StatusCode TriggerBitsMakerTool::initialize ( )

overridevirtual

Definition at line 14 of file TriggerBitsMakerTool.cxx.

                                            {
 
  ATH_CHECK( m_finalChainDecisions.initialize() );
  ATH_CHECK( m_HLTMenuKey.initialize() );
 
  return StatusCode::SUCCESS;
}

preInsertCheck()

StatusCode TriggerBitsMakerTool::preInsertCheck ( const std::string & chain, const uint32_t bit ) const

private

Check that no existing key maps to a given value and that the string is not empty.

Definition at line 59 of file TriggerBitsMakerTool.cxx.

                                                                                                {
  const auto checkIt = std::find_if(
    m_mapping.begin(), m_mapping.end(),
    [&](const std::pair<TrigCompositeUtils::DecisionID, uint32_t>& m) { return m.second == bit; }
  );
  if (checkIt != m_mapping.end()) {
    ATH_MSG_ERROR( "Multiple chains " << HLT::Identifier(checkIt->first) 
      << " and " << chain << " are both configured with ChainCounter:" << bit);
    return StatusCode::FAILURE;
  }
  if (chain.empty()) {
    ATH_MSG_ERROR( "Trying to register an empty string as a Chain." );
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

setBit()

StatusCode TriggerBitsMakerTool::setBit ( const TrigCompositeUtils::DecisionID chain, boost::dynamic_bitset< uint32_t > & resultToFill ) const

private

Set to 1 the bit correspinding to 'chain' in 'resultToFill'.

Definition at line 167 of file TriggerBitsMakerTool.cxx.

{
  // Ignore per-leg IDs, only use chain-IDs
  if (TrigCompositeUtils::isLegId(HLT::Identifier(chain)) ) {
    return StatusCode::SUCCESS;
  }
 
  auto mappingIter = m_mapping.find( chain );
  // each chain has to have the counter
  if( mappingIter == m_mapping.end() ) {
    ATH_MSG_ERROR("Each chain has to have the bit/counter associated whereas the " << HLT::Identifier( chain ) << " does not" );
    return StatusCode::FAILURE;
  }
  const int chainBitPosition = mappingIter->second;
  ATH_MSG_DEBUG("Setting bit " << chainBitPosition << " corresponding to chain "<< HLT::Identifier(chain));
  if (resultToFill.test(chainBitPosition)) {
    ATH_MSG_WARNING(HLT::Identifier(chain) << " is setting its trigger bit " << chainBitPosition << " more than once");
  }
  resultToFill.set(chainBitPosition);
  return StatusCode::SUCCESS;
}

start()

StatusCode TriggerBitsMakerTool::start ( )

overridevirtual

Definition at line 22 of file TriggerBitsMakerTool.cxx.

                                       {
  SG::ReadHandle<TrigConf::HLTMenu>  hltMenuHandle = SG::makeHandle( m_HLTMenuKey );
  ATH_CHECK( hltMenuHandle.isValid() );
  ATH_MSG_INFO("Configuring from " << m_HLTMenuKey << " with " << hltMenuHandle->size() << " chains");
 
  m_mapping.clear();
  m_largestBit = 0;
  for (const TrigConf::Chain& ch : *hltMenuHandle) {
    ATH_MSG_DEBUG( "Chain " << ch.name() << " will flip " << ch.counter() <<  " bit" );
    ATH_CHECK(preInsertCheck(ch.name(), ch.counter()));
    ATH_CHECK(hashConsistencyCheck(ch.name(), ch.namehash()));
    m_mapping[ HLT::Identifier( ch.name() ).numeric() ] = ch.counter();
    m_largestBit = std::max(m_largestBit, ch.counter());
  }
 
  // This block allows extra mappings to be supplied by python, e.g. for testing purposes
  for (const auto& chainAndBit: m_extraChainToBit ) {
    struct { std::string chain; uint32_t bit; } conf { chainAndBit.first, chainAndBit.second };    
    ATH_MSG_DEBUG( "Extra Chain " << conf.chain << " will flip  " << conf.bit <<  " bit" );
    ATH_CHECK(preInsertCheck(conf.chain, conf.bit));
    m_mapping[ HLT::Identifier( conf.chain ).numeric() ] = conf.bit;
    m_largestBit = std::max(m_largestBit, conf.bit);
  }
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_extraChainToBit

Gaudi::Property<std::map<std::string, uint32_t> > TriggerBitsMakerTool::m_extraChainToBit

private

Initial value:

{ this, "ExtraChainToBit", {},
    "Special case and testing purposes hard-coded chain-to-bit mappings to use in addition to those from the HLT menu."}

Definition at line 54 of file TriggerBitsMakerTool.h.

                                                               { this, "ExtraChainToBit", {},
    "Special case and testing purposes hard-coded chain-to-bit mappings to use in addition to those from the HLT menu."};

m_finalChainDecisions

SG::ReadHandleKey<TrigCompositeUtils::DecisionContainer> TriggerBitsMakerTool::m_finalChainDecisions

private

Initial value:

{ this, "ChainDecisions", "HLTNav_Summary",
    "Container with final chain decisions"  }

Definition at line 49 of file TriggerBitsMakerTool.h.

                                                                             { this, "ChainDecisions", "HLTNav_Summary",
    "Container with final chain decisions"  };

m_HLTMenuKey

SG::ReadHandleKey<TrigConf::HLTMenu> TriggerBitsMakerTool::m_HLTMenuKey {this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu", "HLT Menu"}

private

Definition at line 52 of file TriggerBitsMakerTool.h.

{this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu", "HLT Menu"};

m_largestBit

uint32_t TriggerBitsMakerTool::m_largestBit {0}

private

Largest chain counter hence largest bit needed to be stored in result bitmap.

Definition at line 60 of file TriggerBitsMakerTool.h.

{0}; 

m_mapping

ChainToBitMap TriggerBitsMakerTool::m_mapping

private

Mapping of each chain's hash ID to its chain counter.

Definition at line 58 of file TriggerBitsMakerTool.h.

---

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

• TriggerBitsMakerTool.h
• TriggerBitsMakerTool.cxx