CTPUnpackingTool Class Reference

#include <CTPUnpackingTool.h>

Inheritance diagram for CTPUnpackingTool:

Collaboration diagram for CTPUnpackingTool:

Public Member Functions
	CTPUnpackingTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	decode (const EventContext &ctx, const ROIB::RoIBResult &roib, HLT::IDVec &enabledChains) const override
	Fills the list of chains that should be activated in a given event (note HLT prescaling happens at a later stage)
virtual StatusCode	initialize () override
virtual StatusCode	start () override
virtual StatusCode	passBeforePrescaleSelection (const ROIB::RoIBResult *roib, const std::vector< std::string > &l1ItemNames, bool &pass) const override
virtual bool	isEmulated () const override

Protected Attributes
std::unordered_map< int, HLT::IDVec >	m_ctpToChain
Gaudi::Property< bool >	m_forceEnable
ToolHandle< GenericMonitoringTool >	m_monTool {this, "MonTool", "", "Monitoring tool"}

Static Protected Attributes
static constexpr int	s_CTPIDForUnseededChains = -1

Private Attributes
SG::ReadHandleKey< TrigConf::HLTMenu >	m_HLTMenuKey
SG::ReadHandleKey< TrigConf::L1Menu >	m_L1MenuKey
SG::ReadHandleKey< xAOD::CTPResult >	m_ctpResultKey
Gaudi::Property< bool >	m_useTBPBit
Gaudi::Property< bool >	m_useEDMxAOD
std::map< std::string, size_t >	m_itemNametoCTPIDMap

Detailed Description

Definition at line 17 of file CTPUnpackingTool.h.

Constructor & Destructor Documentation

CTPUnpackingTool()

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

Definition at line 16 of file CTPUnpackingTool.cxx.

  : CTPUnpackingToolBase(type, name, parent) {}

Member Function Documentation

decode()

StatusCode CTPUnpackingTool::decode ( const EventContext & ctx, const ROIB::RoIBResult & roib, HLT::IDVec & enabledChains ) const

overridevirtual

Fills the list of chains that should be activated in a given event (note HLT prescaling happens at a later stage)

Reimplemented from CTPUnpackingToolBase.

Definition at line 94 of file CTPUnpackingTool.cxx.

                                                                                                                         {
  auto nItems = Monitored::Scalar( "Items", 0 );
  auto nChains = Monitored::Scalar( "Chains", 0 );
 
  std::vector<uint32_t> ctpBits;
  if (m_useEDMxAOD) { // Need to make sure you can pick up the correct CTPResult in StoreGate
 
    // Retrieve xAOD::CTPResult object
    SG::ReadHandle<xAOD::CTPResult> ctpRes{ m_ctpResultKey, ctx };
    if (!ctpRes.isValid()) {
      ATH_MSG_ERROR("Failed to retrieve CTPResult with key " << m_ctpResultKey.key());
      return StatusCode::FAILURE;
    };
 
    // Get the appropriate trigger bits for L1A bunch
    ctpBits = m_useTBPBit ? ctpRes->getTBPWords() : ctpRes->getTAVWords();
 
  }
  else {
 
    // Get appropriate trigger bits from ROIB::CTPResult object in RoIBResult object
    auto rois = m_useTBPBit ? roib.cTPResult().TBP() : roib.cTPResult().TAV();
    ctpBits.reserve(rois.size());
 
    // Trigger bits stored in vector of ROIB::CTPRoI objects (which are just uint32_t), need to convert to a vector of type uint32_t
    std::transform(rois.begin(), rois.end(), std::back_inserter(ctpBits), [](const ROIB::CTPRoI& roi){ return roi.roIWord(); });
 
  }
  const size_t bitsSize = ctpBits.size();
  constexpr static size_t wordSize{32};
 
  for ( size_t wordCounter = 0; wordCounter < bitsSize; ++wordCounter ) {
    for ( size_t bitCounter = 0;  bitCounter < wordSize; ++bitCounter ) {
      const size_t ctpIndex = wordSize*wordCounter + bitCounter;
      const bool decision = ( ctpBits[wordCounter] & ((uint32_t)1 << bitCounter) ) > 0;
 
      if ( decision or m_forceEnable ) {
        if ( decision ) {
          nItems = nItems + 1;
          ATH_MSG_DEBUG("L1 item " << ctpIndex << " active, enabling chains "
                        << (m_forceEnable ? " due to the forceEnable flag" : " due to the seed"));
        }
 
        auto itr = m_ctpToChain.find( ctpIndex );
        if ( itr != m_ctpToChain.end() ) {
          enabledChains.insert( enabledChains.end(), itr->second.begin(), itr->second.end() );
        }
      }
    }
  }
  // the unseeded chains are always enabled at this stage
  const auto itr = m_ctpToChain.find( s_CTPIDForUnseededChains );
  if ( itr != m_ctpToChain.cend() ) {
    enabledChains.insert( enabledChains.end(), itr->second.begin(), itr->second.end());
  }
 
  nChains = enabledChains.size();
  for ( auto chain: enabledChains ) {
    ATH_MSG_DEBUG( "Enabling chain: " << chain );
  }
  if ( nItems == 0 ) {
    ATH_MSG_ERROR( "All CTP bits were disabled, this event should not have shown here" );
    return StatusCode::FAILURE;
  }
  Monitored::Group( m_monTool, nItems, nChains );
  return StatusCode::SUCCESS;
}

initialize()

StatusCode CTPUnpackingTool::initialize ( )

overridevirtual

Reimplemented from CTPUnpackingToolBase.

Definition at line 22 of file CTPUnpackingTool.cxx.

                                        {
  ATH_CHECK( m_L1MenuKey.initialize() );
  ATH_CHECK( m_HLTMenuKey.initialize() );
  ATH_CHECK( m_ctpResultKey.initialize( m_useEDMxAOD ) );
 
 
  ATH_CHECK( CTPUnpackingToolBase::initialize() );
 
  return StatusCode::SUCCESS;
}

isEmulated()

virtual bool CTPUnpackingToolBase::isEmulated ( ) const

inlineoverridevirtualinherited

Reimplemented in CTPUnpackingEmulationTool.

Definition at line 41 of file CTPUnpackingToolBase.h.

{return false;}

passBeforePrescaleSelection()

StatusCode CTPUnpackingTool::passBeforePrescaleSelection ( const ROIB::RoIBResult * roib, const std::vector< std::string > & l1ItemNames, bool & pass ) const

overridevirtual

Reimplemented from CTPUnpackingToolBase.

Definition at line 163 of file CTPUnpackingTool.cxx.

                                                                           {
 
  pass = false;
 
  const auto ctpBits = roib->cTPResult().TBP();
 
  for (const std::string& l1name : l1ItemNames) {
    try {
      // Retrieve before prescale decision
      const size_t ctpId = m_itemNametoCTPIDMap.at(l1name);
      const size_t bitCounter = ctpId % 32;
      const size_t wordCounter = ctpId / 32;
 
      const bool decision = (ctpBits[wordCounter].roIWord() & ((uint32_t)1 << bitCounter)) > 0;
 
      pass = (pass || decision);
    }
    catch (const std::exception& e) {
      ATH_MSG_ERROR ( l1name << " is not part of L1Menu!" );
      return StatusCode::FAILURE;
    }
  }
 
  return StatusCode::SUCCESS;
}

start()

StatusCode CTPUnpackingTool::start ( )

overridevirtual

Definition at line 34 of file CTPUnpackingTool.cxx.

                                   {
  ATH_MSG_INFO( "Updating CTP bits decoding configuration");
 
  // iterate over all items and obtain the CPT ID for each item. Then, package that in the map: name -> CTP ID
  ATH_MSG_INFO( "start(): use new L1 trigger menu" );  
  // Cleanup in case there was a stop/start transition
  m_itemNametoCTPIDMap.clear();
  m_ctpToChain.clear();
 
  auto l1menu = SG::makeHandle( m_L1MenuKey );
  if( l1menu.isValid() ) {
    for ( const TrigConf::L1Item & item:   *l1menu ) {
      m_itemNametoCTPIDMap[item.name()] = item.ctpId();
    }
  } else {
    ATH_MSG_ERROR( "TrigConf::L1Menu does not exist" );
  }
  
  auto addIfItemExists = [&]( const std::string& itemName, HLT::Identifier id, bool warningOnly = false ) -> StatusCode {
    if ( m_itemNametoCTPIDMap.find( itemName ) != m_itemNametoCTPIDMap.end() ) {
      m_ctpToChain[ m_itemNametoCTPIDMap[itemName] ].push_back( id );
      return StatusCode::SUCCESS;
    }
    if( warningOnly ) {
       // this code should be removed after the L1 menu is migrated to the new json version
       ATH_MSG_WARNING(itemName << " used to seed the chain " << id <<" not in the configuration ");
       return StatusCode::SUCCESS;
    }
    ATH_MSG_ERROR(itemName << " used to seed the chain " << id <<" not in the configuration ");
    return StatusCode::FAILURE;
  };
 
  SG::ReadHandle<TrigConf::HLTMenu>  hltMenuHandle = SG::makeHandle( m_HLTMenuKey );
  ATH_CHECK( hltMenuHandle.isValid() );
  for ( const TrigConf::Chain& chain: *hltMenuHandle ) {
    HLT::Identifier chainID{ chain.name() };
    if ( chain.l1item().empty() ) { // unseeded chain
      m_ctpToChain[ s_CTPIDForUnseededChains ].push_back( chainID );
    } else if ( chain.l1item().find(',') != std::string::npos ) { // OR seeds
 
      std::vector<std::string> items;
      boost::split(items, chain.l1item(), [](char c){return c == ',';});
      for ( const std::string& i: items ) {
         ATH_CHECK( addIfItemExists( i, chainID, true ) );
      }
    } else { // regular chain
      ATH_CHECK( addIfItemExists( chain.l1item(), chainID ) );
    }
  }
 
  for ( const auto& ctpIDtoChain: m_ctpToChain ) {
    for ( auto chain: ctpIDtoChain.second ) {
      ATH_MSG_DEBUG( "CTP seed of " << ctpIDtoChain.first << " enables chains " << chain );
    }
  }
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_ctpResultKey

SG::ReadHandleKey<xAOD::CTPResult> CTPUnpackingTool::m_ctpResultKey

private

Initial value:

{
    this, "CTPResult", "StoreGateSvc+CTPResult", "CTP Result"}

Definition at line 44 of file CTPUnpackingTool.h.

                                                {
    this, "CTPResult", "StoreGateSvc+CTPResult", "CTP Result"};

m_ctpToChain

std::unordered_map<int, HLT::IDVec> CTPUnpackingToolBase::m_ctpToChain

protectedinherited

Definition at line 46 of file CTPUnpackingToolBase.h.

m_forceEnable

Gaudi::Property<bool> CTPUnpackingToolBase::m_forceEnable

protectedinherited

Initial value:

{
    this, "ForceEnableAllChains", false, "Enables all chains in each event, testing mode"}

Definition at line 48 of file CTPUnpackingToolBase.h.

                                   {
    this, "ForceEnableAllChains", false, "Enables all chains in each event, testing mode"};

m_HLTMenuKey

SG::ReadHandleKey<TrigConf::HLTMenu> CTPUnpackingTool::m_HLTMenuKey

private

Initial value:

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

Definition at line 39 of file CTPUnpackingTool.h.

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

m_itemNametoCTPIDMap

std::map<std::string, size_t> CTPUnpackingTool::m_itemNametoCTPIDMap

private

Definition at line 55 of file CTPUnpackingTool.h.

m_L1MenuKey

SG::ReadHandleKey<TrigConf::L1Menu> CTPUnpackingTool::m_L1MenuKey

private

Initial value:

{
    this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu"}

Definition at line 41 of file CTPUnpackingTool.h.

                                              {
    this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu"};

m_monTool

ToolHandle<GenericMonitoringTool> CTPUnpackingToolBase::m_monTool {this, "MonTool", "", "Monitoring tool"}

protectedinherited

Definition at line 51 of file CTPUnpackingToolBase.h.

{this, "MonTool", "", "Monitoring tool"};

m_useEDMxAOD

Gaudi::Property<bool> CTPUnpackingTool::m_useEDMxAOD

private

Initial value:

{
    this, "UseEDMxAOD", false,
    "When true, use xAOD::CTPResult object when decoding instead of relying on ROIB::RoIBResult for CTP words"}

Definition at line 51 of file CTPUnpackingTool.h.

                                  {
    this, "UseEDMxAOD", false,
    "When true, use xAOD::CTPResult object when decoding instead of relying on ROIB::RoIBResult for CTP words"};

m_useTBPBit

Gaudi::Property<bool> CTPUnpackingTool::m_useTBPBit

private

Initial value:

{
    this, "UseTBPBits", false,
    "When true, use Trigger Before Prescale bits instead of Trigger After Veto (for testing only)"}

Definition at line 47 of file CTPUnpackingTool.h.

                                 {
    this, "UseTBPBits", false,
    "When true, use Trigger Before Prescale bits instead of Trigger After Veto (for testing only)"};

s_CTPIDForUnseededChains

int CTPUnpackingToolBase::s_CTPIDForUnseededChains = -1

staticconstexprprotectedinherited

Definition at line 45 of file CTPUnpackingToolBase.h.

---

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

• CTPUnpackingTool.h
• CTPUnpackingTool.cxx