#include <CacheGlobalMemory.h>

Inheritance diagram for Trig::CacheGlobalMemory:

Classes
class	AnyTypeDeleter

Public Member Functions
	CacheGlobalMemory ()=default
	~CacheGlobalMemory ()=default
const Trig::ChainGroup *	createChainGroup (const std::vector< std::string > &patterns, const std::string &alias="", TrigDefs::Group props=TrigDefs::Group::Default) const
	creates new chain group
void	update (const TrigConf::HLTChainList confChains, const TrigConf::CTPConfig ctp)
	Updates configuration of the chain groups (i.e.
const LVL1CTP::Lvl1Item *	item (const std::string &name) const
	CTP item from given name.
const LVL1CTP::Lvl1Item *	item (const TrigConf::TriggerItem &i) const
	CTP item from given config item.
const TrigConf::TriggerItem *	config_item (const std::string &name) const
	CTP config item from given name.
float	item_prescale (int ctpid) const
	Prescale for CPT item.
const HLT::Chain *	chain (const std::string &name) const
	HLT chain object from given name (0 pointer returned if no match)
const HLT::Chain *	chain (const TrigConf::HLTChain &chIt) const
	HLT chain object from given config chain.
const TrigConf::HLTChain *	config_chain (const std::string &name) const
	HLT config chain from given name.
const HLT::TrigNavStructure *	navigation () const
void	navigation (HLT::TrigNavStructure *nav)
	sets navigation object pointer
const Trig::ChainGroup *	getChainGroup (const std::vector< std::string > &triggerNames, TrigDefs::Group props) const
size_t	nChainGroups () const
const std::map< std::string, std::vector< std::string > > &	getStreams () const
bool	assert_decision () const
	checks if new event arrived with the decision Need to use before any call to CacheGlobalMemory.
void	reset_decision ()
	invalidate previously unpacked decision Needs to be called at the start of a new event.
void	setStore (asg::EventStoreType *store)
	Set the event store to be used by the object.
const asg::EventStoreType *	store () const
	Get the event store that the object is using.
void	setDecisionKeyPtr (SG::ReadHandleKey< xAOD::TrigDecision > *k)
void	setRun2NavigationKeyPtr (SG::ReadHandleKey< xAOD::TrigNavigation > *k)
void	setRun3NavigationKeyPtr (SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > *k)
const SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > &	getRun3NavigationKey () const
const SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > *	getRun3NavigationKeyPtr () const
void	setOldDecisionKeyPtr (SG::ReadHandleKey< TrigDec::TrigDecision > *k)
void	setOldEventInfoKeyPtr (SG::ReadHandleKey< EventInfo > *k)
const SG::ReadHandleKey< xAOD::TrigDecision > *	xAODTrigDecisionKey () const
template<class T>
void	deleteAtTheEndOfEvent (T t) const
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Private Types
typedef unsigned	CTPID
typedef unsigned	CHAIN_COUNTER
typedef std::unordered_map< std::string, const TrigConf::HLTChain * >	ChainHashMap_t

Private Member Functions
StatusCode	unpackDecision (const EventContext &ctx)
	unpacks whole trigger decision for the event
StatusCode	unpackNavigation ()
	unpacks HLT navigation structure (object access)
void	updateChainGroup (Trig::ChainGroup &chainGroup, TrigDefs::Group props=TrigDefs::Group::Default)
	unpacks everything that belongs to a ChainGroup

Private Attributes
const asg::EventStoreType *	m_store {nullptr}
	Pointer to the event store in use.
std::unique_ptr< IDecisionUnpacker > m_unpacker	ATLAS_THREAD_SAFE
	Trigger decision unpacker helper.
bool	m_decisionUnpacked {false}
	Was decision unpacked for this event?
bool	m_navigationUnpacked {false}
	Was navigation unpacked for this event?
HLT::TrigNavStructure *	m_navigation {nullptr}
	Navigation owned by CGM.
std::map< std::vector< std::string >, Trig::ChainGroup > m_chainGroups	ATLAS_THREAD_SAFE
	primary storage for chain groups
std::map< std::vector< std::string >, Trig::ChainGroup * > m_chainGroupsRef	ATLAS_THREAD_SAFE
	this map keeps the chain group more than once i.e.
std::unordered_map< std::string, const LVL1CTP::Lvl1Item * >	m_itemsByName
	items keyed by configuration name (chainging every event)
std::unordered_map< std::string, const HLT::Chain * >	m_l2chainsByName
	L2 chains keyed by chain name (chainging every event)
std::unordered_map< std::string, const HLT::Chain * >	m_efchainsByName
	L2 chains keyed by chain name (chainging every event)
std::map< CTPID, LVL1CTP::Lvl1Item >	m_itemsCache
	cache of all CTP items possible (given configuration)
std::map< CHAIN_COUNTER, HLT::Chain >	m_l2chainsCache
	cache of all L2 chains possible (given configuration)
std::map< CHAIN_COUNTER, HLT::Chain >	m_efchainsCache
	cache of all EF chains possible (given configuration)
std::map< std::string, std::vector< std::string > >	m_groups
	mapping from group to list of chains
std::map< std::string, std::vector< std::string > >	m_streams
	mapping from stream to list of chains
const TrigConf::ItemContainer *	m_confItems {nullptr}
	items configuration
const TrigConf::HLTChainList *	m_confChains {nullptr}
	all chains configuration
SG::ReadHandleKey< xAOD::TrigDecision > *	m_decisionKeyPtr {nullptr}
	Parent TDT's read handle key.
SG::ReadHandleKey< TrigDec::TrigDecision > *	m_oldDecisionKeyPtr {nullptr}
	Parent TDT's read handle key.
SG::ReadHandleKey< EventInfo > *	m_oldEventInfoKeyPtr {nullptr}
	Parent TDT's read handle key.
SG::ReadHandleKey< xAOD::TrigNavigation > *	m_run2NavigationKeyPtr {nullptr}
	Parent TDT's read handle key.
SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > *	m_run3NavigationKeyPtr {nullptr}
	Parent TDT's read handle key.
ChainHashMap_t	m_mConfChains
	map of conf chains
char	m_bgCode {0}
	the encoded bunchgroup information
AnyTypeDeleter m_deleteAtEndOfEvent	ATLAS_THREAD_SAFE
std::recursive_mutex	m_cgmMutex
	R3 MT protection only against –threads > 1.

Friends
class	DecisionAccess

Detailed Description

Definition at line 67 of file CacheGlobalMemory.h.

Member Typedef Documentation

◆ CHAIN_COUNTER

typedef unsigned Trig::CacheGlobalMemory::CHAIN_COUNTER

private

Definition at line 204 of file CacheGlobalMemory.h.

◆ ChainHashMap_t

typedef std::unordered_map<std::string, const TrigConf::HLTChain*> Trig::CacheGlobalMemory::ChainHashMap_t

private

Definition at line 225 of file CacheGlobalMemory.h.

◆ CTPID

typedef unsigned Trig::CacheGlobalMemory::CTPID

private

Definition at line 203 of file CacheGlobalMemory.h.

Constructor & Destructor Documentation

◆ CacheGlobalMemory()

Trig::CacheGlobalMemory::CacheGlobalMemory ( )

default

◆ ~CacheGlobalMemory()

Trig::CacheGlobalMemory::~CacheGlobalMemory ( )

default

Member Function Documentation

◆ assert_decision()

bool Trig::CacheGlobalMemory::assert_decision ( ) const

checks if new event arrived with the decision Need to use before any call to CacheGlobalMemory.

It is marked const since it is frequently called from const methods and is internally locked.

Returns: true if all went fine about decision, false otherwise

Definition at line 266 of file CacheGlobalMemory.cxx.

                                                  {
  std::lock_guard<std::recursive_mutex> lock(m_cgmMutex);
  ATH_MSG_VERBOSE("asserting decision with unpacker " << m_unpacker.get());
 
  // here we unpack the decision. Note: the navigation will be unpacked only on demand (see navigation())
  bool contains_xAOD_decision = false;
 
#ifndef XAOD_ANALYSIS // Full Athena
  bool is_l1result_configured = false;
  bool contains_decision = false;
  bool contains_old_event_info = false;
#endif
 
  const EventContext& context = Gaudi::Hive::currentContext();
  if(!m_unpacker){
    ATH_MSG_INFO("decision not set on first (?) assert. deciding how to unpack");
 
    //Lukas 26-06-2015: we're hard coding the configuration for now
    //but we have setters and getters for m_trigDecisionKey (as CGM datamemer)
    //so we could in the future use the ones set by the python configuration
    //we're hardcoding in order not to require python configuration changes
 
    if (!m_decisionKeyPtr->empty()) {
       SG::ReadHandle<xAOD::TrigDecision> decisionReadHandle = SG::makeHandle(*m_decisionKeyPtr, context);
      contains_xAOD_decision = decisionReadHandle.isValid();
    }
 
#ifndef XAOD_ANALYSIS // Full Athena
 
    if (!m_oldDecisionKeyPtr->empty()) {
      SG::ReadHandle<TrigDec::TrigDecision> oldDecisionReadHandle = SG::makeHandle(*m_oldDecisionKeyPtr, context);
      contains_decision = oldDecisionReadHandle.isValid();
      if (contains_decision) {
        is_l1result_configured = oldDecisionReadHandle->getL1Result().isConfigured();
      }
    }
 
    if (!m_oldEventInfoKeyPtr->empty()) {
      SG::ReadHandle<EventInfo> oldEventInfoHandle = SG::makeHandle(*m_oldEventInfoKeyPtr, context);
      contains_old_event_info = oldEventInfoHandle.isValid();
    }
 
    // January 2020: Note, switched the order here. DecisionUnpackerStandalone is given preference
    // over DecisionUnpackerAthena
    if ( contains_xAOD_decision ){
      ATH_MSG_INFO("SG contains xAOD decision, use DecisionUnpackerStandalone");
      m_unpacker = std::make_unique<DecisionUnpackerStandalone>
        (CxxUtils::as_const_ptr(m_decisionKeyPtr),
         CxxUtils::as_const_ptr(m_run2NavigationKeyPtr));
    }
    else if( is_l1result_configured ){
      ATH_MSG_INFO("SG contains AOD decision, use DecisionUnpackerAthena");
      m_unpacker = std::make_unique<DecisionUnpackerAthena>(CxxUtils::as_const_ptr(m_oldDecisionKeyPtr));
    }
    else if (contains_old_event_info) {
      ATH_MSG_INFO("SG contains NO(!) L1Result in the AOD TrigDecision, assuming also no HLTResult. Read from EventInfo");
      m_unpacker = std::make_unique<DecisionUnpackerEventInfo>(CxxUtils::as_const_ptr(m_oldEventInfoKeyPtr));
    }
#else
    if ( contains_xAOD_decision ){
      ATH_MSG_INFO("SG contains xAOD decision, use DecisionUnpackerStandalone");
      m_unpacker = std::make_unique<DecisionUnpackerStandalone>(m_decisionKeyPtr, m_run2NavigationKeyPtr);
    }
#endif
 
  }//if(!m_unpacker)
 
  // cppcheck-suppress duplicateCondition
  if(!m_unpacker){
    std::stringstream extra;
#ifndef XAOD_ANALYSIS // Full Athena
    extra << ". Looked for old TrigDec::TrigDecision? "
      << (m_oldDecisionKeyPtr->empty() ? "NO" : "YES")
      << ", has TrigDec::TrigDecision? "
      << (contains_decision ? "YES" : "NO")
      << ", TrigDec::TrigDecision has L1? "
      << (is_l1result_configured ? "YES" : "NO")
      << ". Looked for old EventInfo? "
      << (m_oldEventInfoKeyPtr->empty() ? "NO" : "YES")
      << ", has old EventInto? "
      << (contains_old_event_info ? "YES" : "NO");
#endif
    ATH_MSG_ERROR("No source of Trigger Decision in file. "
      << "(Looked for xAOD::TrigDecision? "
      << (m_decisionKeyPtr->empty() ? "NO" : "YES")
      << ", has xAOD::TrigDecision? "
      << (contains_xAOD_decision ? "YES" : "NO")
      << extra.str()
      << ". Check UseRun1DecisionFormat and UseOldEventInfoDecisionFormat flags if reading pre-xAOD or BS input).");
    throw std::runtime_error("Trig::CacheGlobalMemory::assert_decision(): No source of Trigger Decision in file.");
  }
 
  if( !m_decisionUnpacked ) {
    // this method is locked
    auto nc_this ATLAS_THREAD_SAFE = const_cast<Trig::CacheGlobalMemory*>(this);
    if( nc_this->unpackDecision(context).isFailure() ) {
      ATH_MSG_WARNING( "TrigDecion object incorrect (for chains)" );
    }
    else{
      ATH_MSG_VERBOSE("unpacked decision");
    }
  }
 
  return true;
}

◆ chain() [1/2]

const HLT::Chain * Trig::CacheGlobalMemory::chain ( const std::string & name ) const

HLT chain object from given name (0 pointer returned if no match)

Definition at line 201 of file CacheGlobalMemory.cxx.

                                                                        {
  std::lock_guard<std::recursive_mutex> lock(m_cgmMutex);
  auto i = m_efchainsByName.find(name);
  if (i != m_efchainsByName.end()) {
    return i->second;
  }
  i = m_l2chainsByName.find(name);
  if ( i != m_l2chainsByName.end() ) {
    return i->second;
  }
  return nullptr;
}

◆ chain() [2/2]

const HLT::Chain * Trig::CacheGlobalMemory::chain ( const TrigConf::HLTChain & chIt ) const

HLT chain object from given config chain.

Definition at line 214 of file CacheGlobalMemory.cxx.

                                                                             {
  return chain(ch.chain_name());
}

◆ config_chain()

const TrigConf::HLTChain * Trig::CacheGlobalMemory::config_chain ( const std::string & name ) const

HLT config chain from given name.

Definition at line 218 of file CacheGlobalMemory.cxx.

                                                                                       {
  ChainHashMap_t::const_iterator f = m_mConfChains.find(name);
  if ( f == m_mConfChains.end() ){
    return nullptr;
  }
  return f->second;
}

◆ config_item()

const TrigConf::TriggerItem * Trig::CacheGlobalMemory::config_item ( const std::string & name ) const

CTP config item from given name.

Definition at line 234 of file CacheGlobalMemory.cxx.

                                                                                         {
   TrigConf::ItemContainer::const_iterator f = find_if(m_confItems->begin(), m_confItems->end(), itemByName(name));
   if ( f == m_confItems->end() )
      return nullptr;
   return *f;
}

◆ createChainGroup()

const Trig::ChainGroup * Trig::CacheGlobalMemory::createChainGroup	(	const std::vector< std::string > &	patterns,
		const std::string &	alias = "",
		TrigDefs::Group	props = TrigDefs::Group::Default ) const

creates new chain group

Parameters

patterns	list of patterns i.e. regexes, if chain groups already exists it is just given back The chain group is considered to exist if the patterns are the same. Patterns are stored and made unique i.e. "EF_mu4", "EF_mu6" is the same as "EF_mu6", "EF_mu4". It is not the same though as "EF_mu.*" even if in particular case that would mean the same 2 chains.
alias	is the short human readable name for the triggers which are in the group i.e. myMuons
props	are additional properties for the chain group creation (e.g. disable regex parsing)

Definition at line 54 of file CacheGlobalMemory.cxx.

                                                                                             {
  // mutex in case this is called directly
  std::lock_guard<std::recursive_mutex> lock(m_cgmMutex);
  auto nc_this ATLAS_THREAD_SAFE = const_cast<Trig::CacheGlobalMemory*>(this);
 
  // create a proper key
  std::vector< std::string > key=Trig::keyWrap(triggerNames);
 
  auto [itr, inserted] = m_chainGroups.try_emplace (key, /*ChainGroup*/ key, *nc_this);
  if (inserted) {
    nc_this->updateChainGroup(itr->second, props);
    m_chainGroupsRef[key] = &(itr->second);
  }
  // this overwrites the pointer in the map each time in case the alias needs defining
  if (!alias.empty()) {
    std::vector< std::string > key_alias=Trig::keyWrap(Trig::convertStringToVector(alias));
    auto [alias_itr, alias_inserted] = m_chainGroupsRef.try_emplace (key_alias, &m_chainGroups.at(key));
    if (!alias_inserted && alias_itr->second!=m_chainGroupsRef[key]) {
        throw std::runtime_error("TrigDecisionTool: The alias "+alias+
                                 " already exists and cannot be overwritten.");
    }
  }
 
  return m_chainGroupsRef[key];
}

◆ deleteAtTheEndOfEvent()

template<class T>

void Trig::CacheGlobalMemory::deleteAtTheEndOfEvent ( T t ) const

inline

Definition at line 156 of file CacheGlobalMemory.h.

156{ m_deleteAtEndOfEvent.insert(t); }

◆ getChainGroup()

const Trig::ChainGroup * Trig::CacheGlobalMemory::getChainGroup	(	const std::vector< std::string > &	triggerNames,
		TrigDefs::Group	props ) const

Definition at line 83 of file CacheGlobalMemory.cxx.

{
  std::lock_guard<std::recursive_mutex> lock(m_cgmMutex);
  auto searchRes = m_chainGroupsRef.find(triggerNames);
 
  if ( searchRes != m_chainGroupsRef.end()) {
    return searchRes->second;
  }
  return createChainGroup(triggerNames, /*alias*/{}, props);
}

◆ getRun3NavigationKey()

const SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > & Trig::CacheGlobalMemory::getRun3NavigationKey ( ) const

inline

Definition at line 144 of file CacheGlobalMemory.h.

144{ return *m_run3NavigationKeyPtr; }

Trig::CacheGlobalMemory::m_run3NavigationKeyPtr

SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > * m_run3NavigationKeyPtr

Parent TDT's read handle key.

Definition CacheGlobalMemory.h:223

◆ getRun3NavigationKeyPtr()

const SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > * Trig::CacheGlobalMemory::getRun3NavigationKeyPtr ( ) const

inline

Definition at line 145 of file CacheGlobalMemory.h.

145{ return m_run3NavigationKeyPtr; }

◆ getStreams()

const std::map< std::string, std::vector< std::string > > & Trig::CacheGlobalMemory::getStreams ( ) const

inline

Definition at line 119 of file CacheGlobalMemory.h.

119{return m_streams;};

Trig::CacheGlobalMemory::m_streams

std::map< std::string, std::vector< std::string > > m_streams

mapping from stream to list of chains

Definition CacheGlobalMemory.h:210

◆ item() [1/2]

const LVL1CTP::Lvl1Item * Trig::CacheGlobalMemory::item ( const std::string & name ) const

CTP item from given name.

Definition at line 260 of file CacheGlobalMemory.cxx.

                                                                              {
  if ( m_itemsByName.find(name) != m_itemsByName.end())
     return m_itemsByName.find(name)->second;
   return nullptr;
}

◆ item() [2/2]

const LVL1CTP::Lvl1Item * Trig::CacheGlobalMemory::item ( const TrigConf::TriggerItem & i ) const

CTP item from given config item.

Definition at line 252 of file CacheGlobalMemory.cxx.

                                                                                     {
  return item(i.name());
    //   unsigned cntr = i.ctpId();
    //   if ( m_items.find(cntr) != m_items.end())
    //     return m_items.find(cntr)->second;
    //   return 0;
}

◆ item_prescale()

float Trig::CacheGlobalMemory::item_prescale ( int ctpid ) const

Prescale for CPT item.

Definition at line 241 of file CacheGlobalMemory.cxx.

                                                          {
  // Cannot be locked (CacheGlobalMemory::update > createChainGroup > ChainGroup::update > calculatePrescale > L1Prescale > CacheGlobalMemory::item_prescale)
  // find items in cache
  if ( m_itemsCache.count(ctpid) == 0 ) {
    ATH_MSG_ERROR( "item of CTP: " << ctpid
       << " is not present in the configuration" );
    return 0;
  }
  return m_itemsCache.find(ctpid)->second.prescaleFactor();
}

◆ msg() [1/2]

MsgStream & Trig::Logger::msg ( ) const

inlineinherited

Definition at line 29 of file Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Logger.h.

                           {
      if (s_logger) return s_logger->msg();
      else throw std::runtime_error("TrigDecisionTool Logger not initialized.");
    }

◆ msg() [2/2]

MsgStream & Trig::Logger::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 33 of file Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Logger.h.

33{ return msg() << lvl; }

Trig::Logger::msg

MsgStream & msg() const

Definition Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Logger.h:29

◆ msgLvl()

bool Trig::Logger::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 34 of file Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/Logger.h.

34{ return s_logger && s_logger->msgLvl(lvl); }

◆ navigation() [1/2]

const HLT::TrigNavStructure * Trig::CacheGlobalMemory::navigation ( ) const

inline

< gives back pointer to navigation object (unpacking if necessary)

Definition at line 104 of file CacheGlobalMemory.h.

                                                  {   
      if(!m_navigationUnpacked){
        // CGM is slot-specific and unpackNavigation is locked
        auto cgm ATLAS_THREAD_SAFE = const_cast<CacheGlobalMemory*>(this);
        if(cgm->unpackNavigation().isFailure()){
          ATH_MSG_WARNING("unpack Navigation failed");
        }
      }
      return m_navigation;
    }

◆ navigation() [2/2]

void Trig::CacheGlobalMemory::navigation ( HLT::TrigNavStructure * nav )

inline

sets navigation object pointer

Definition at line 114 of file CacheGlobalMemory.h.

◆ nChainGroups()

size_t Trig::CacheGlobalMemory::nChainGroups ( ) const

Definition at line 97 of file CacheGlobalMemory.cxx.

{
  std::lock_guard<std::recursive_mutex> lock(m_cgmMutex);
  return m_chainGroupsRef.size();
}

◆ reset_decision()

void Trig::CacheGlobalMemory::reset_decision ( )

invalidate previously unpacked decision Needs to be called at the start of a new event.

Definition at line 372 of file CacheGlobalMemory.cxx.

                                           {
  m_decisionUnpacked = false;
  m_navigationUnpacked = false;
}

◆ setDecisionKeyPtr()

void Trig::CacheGlobalMemory::setDecisionKeyPtr ( SG::ReadHandleKey< xAOD::TrigDecision > * k )

inline

Definition at line 141 of file CacheGlobalMemory.h.

141{ m_decisionKeyPtr = k; }

fitman.k

k

Definition fitman.py:528

◆ setOldDecisionKeyPtr()

void Trig::CacheGlobalMemory::setOldDecisionKeyPtr ( SG::ReadHandleKey< TrigDec::TrigDecision > * k )

inline

Definition at line 148 of file CacheGlobalMemory.h.

148{ m_oldDecisionKeyPtr = k; }

◆ setOldEventInfoKeyPtr()

void Trig::CacheGlobalMemory::setOldEventInfoKeyPtr ( SG::ReadHandleKey< EventInfo > * k )

inline

Definition at line 149 of file CacheGlobalMemory.h.

149{ m_oldEventInfoKeyPtr = k; }

◆ setRun2NavigationKeyPtr()

void Trig::CacheGlobalMemory::setRun2NavigationKeyPtr ( SG::ReadHandleKey< xAOD::TrigNavigation > * k )

inline

Definition at line 142 of file CacheGlobalMemory.h.

142{ m_run2NavigationKeyPtr = k; }

◆ setRun3NavigationKeyPtr()

void Trig::CacheGlobalMemory::setRun3NavigationKeyPtr ( SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer > * k )

inline

Definition at line 143 of file CacheGlobalMemory.h.

143{ m_run3NavigationKeyPtr = k; }

◆ setStore()

void Trig::CacheGlobalMemory::setStore ( asg::EventStoreType * store )

inline

Set the event store to be used by the object.

Definition at line 137 of file CacheGlobalMemory.h.

137{ m_store = store; }

Trig::CacheGlobalMemory::m_store

const asg::EventStoreType * m_store

Pointer to the event store in use.

Definition CacheGlobalMemory.h:184

Trig::CacheGlobalMemory::store

const asg::EventStoreType * store() const

Get the event store that the object is using.

Definition CacheGlobalMemory.h:139

◆ store()

const asg::EventStoreType * Trig::CacheGlobalMemory::store ( ) const

inline

Get the event store that the object is using.

Definition at line 139 of file CacheGlobalMemory.h.

139{ return m_store; }

◆ unpackDecision()

StatusCode Trig::CacheGlobalMemory::unpackDecision ( const EventContext & ctx )

private

unpacks whole trigger decision for the event

Definition at line 377 of file CacheGlobalMemory.cxx.

                                                                        {
  // locked already through assert_decision
 
  ATH_MSG_DEBUG("Unpacking TrigDecision");
  m_decisionUnpacked = true;
  m_deleteAtEndOfEvent.clear();
 
  bool unpackHLT = ( m_confChains != nullptr );
  ATH_CHECK( m_unpacker->unpackDecision( ctx, m_itemsByName, m_itemsCache,
          m_l2chainsByName, m_l2chainsCache,
          m_efchainsByName, m_efchainsCache,
          m_bgCode, unpackHLT ) );
  return StatusCode::SUCCESS;
}

◆ unpackNavigation()

StatusCode Trig::CacheGlobalMemory::unpackNavigation ( )

private

unpacks HLT navigation structure (object access)

Definition at line 393 of file CacheGlobalMemory.cxx.

                                                   {
  std::lock_guard<std::recursive_mutex> lock(m_cgmMutex);
 
  m_navigationUnpacked = true;
 
  // Navigation
  // protect from unpacking in case HLT was not run
  // (i.e. configuration chains are 0)
  if( m_confChains == nullptr ) {
    return StatusCode::SUCCESS;
  }
 
  // Failing to unpack the navigation is not a failure, as it may be missing
  // from the xAOD file:
  const EventContext& context = Gaudi::Hive::currentContext();
  if( ! m_unpacker->unpackNavigation( context, m_navigation ).isSuccess() ) {
    [[maybe_unused]] static std::atomic<bool> warningPrinted =
      [&]() { ATH_MSG_WARNING( "TrigNavigation unpacking failed" );
              return true; }();
  }
  // Return gracefully:
  return StatusCode::SUCCESS;
}

◆ update()

void Trig::CacheGlobalMemory::update	(	const TrigConf::HLTChainList *	confChains,
		const TrigConf::CTPConfig *	ctp )

Updates configuration of the chain groups (i.e.

regexes are reapplied to new set of chains)

Definition at line 109 of file CacheGlobalMemory.cxx.

                                                                   {
  std::lock_guard<std::recursive_mutex> lock(m_cgmMutex);
  ATH_MSG_DEBUG( "Updating configuration" );
  // store a global reference to the initial answer
  m_confChains = confChains;
  if ( !ctp ) {
    ATH_MSG_WARNING( "No LVL1 config, something went wrong, TDT will "
         "not attempt accessing HLT too" );
    m_confItems = nullptr;
    return;
  }
  m_confItems = &(ctp->menu().items());
 
  // rebuild all the caches with decision information
 
  //clear cache completely because underlying config objects might have changed
  m_itemsCache.clear();
 
  const std::vector<float>& prescales = ctp->prescaleSet().prescales_float();
  for(auto item : ctp->menu().items() ) {
     const auto ctpid = item->ctpId();
     m_itemsCache.try_emplace(ctpid,
                              /*LVL1CTP::Lvl1Item*/ item->name(), 0,
                              0, 0, 0, prescales[ctpid]);
     ATH_MSG_DEBUG( "new configuration for item" << item->name() );
  }
  ATH_MSG_DEBUG( "Updating configuration, done with L1" );
 
  //clear cache completely because underlying config objects might have changed
  m_l2chainsCache.clear();
  m_efchainsCache.clear();
  m_mConfChains.clear();
 
  if ( ! confChains ) {
    ATH_MSG_WARNING( "No chains in configuration, probably run w/o HLT" );
  } else {
 
    ATH_MSG_DEBUG("Updating Configuration chains. Number of conf chains: " << m_confChains->size());
 
    // updating internal map of conf chains (this map is only used for fast lookup)
    for(auto ch : *m_confChains) {
      m_mConfChains[ch->chain_name()] = ch;
    }
 
    // updating internal cache of HLT::Chains
    for(auto ch : *m_confChains) {
      //    std::cerr << "CacheGlobalMemory::update updating chain" << (*cChIt)->chain_name() << std::endl;
      int cntr = ch->chain_counter();
      if( ch->level()=="L2" ) {
        m_l2chainsCache.emplace(cntr, /*HLT::Chain*/ch);
      } else {//merged chains are stored in efchains
        m_efchainsCache.emplace(cntr, /*HLT::Chain*/ch);
      }
    }
    ATH_MSG_DEBUG( "Updating configuration, done with basic HLT based on "
       << m_confChains->size() << " configuration chains" );
 
 
    // code for the streams and pre-defined groups
    // -- assume that the groups and streams have all changed!!!
    m_groups.clear();
    m_streams.clear();
 
    for(auto ch : *m_confChains) {
      if (( ch->level() == "EF" || ch->level() == "HLT") && !ch->streams().empty() ) {
        ATH_MSG_DEBUG( "Stream: " << ch->chain_name() << " " << ch->streams().size() );
        for(auto stream : ch->streams()) {
          ATH_MSG(DEBUG) << " " << stream->stream();
          m_streams[stream->stream()].push_back(ch->chain_name());
        }
        ATH_MSG(DEBUG) << endmsg;
      }
      if ( ( ch->level() == "EF" || ch->level() == "HLT") && !ch->groups().empty() ) {
        ATH_MSG_DEBUG( "Groups: " << ch->chain_name() << " " << ch->groups().size() );
        for(auto& group : ch->groups()) {
          ATH_MSG(DEBUG) << " " << group;
          m_groups[group].push_back(ch->chain_name());
        }
        ATH_MSG(DEBUG) << endmsg;
      }
    }
  }
 
  // update all defined chainGroups
  for (auto& [key, group] : m_chainGroups) {
    updateChainGroup(group);
  }
  ATH_MSG_DEBUG( "Updating configuration done" );
}

◆ updateChainGroup()

void Trig::CacheGlobalMemory::updateChainGroup	(	Trig::ChainGroup &	chainGroup,
		TrigDefs::Group	props = TrigDefs::Group::Default )

private

unpacks everything that belongs to a ChainGroup

Definition at line 104 of file CacheGlobalMemory.cxx.

                                                                                            {
  chainGroup.update(m_confChains, m_confItems, props);
}

◆ xAODTrigDecisionKey()

const SG::ReadHandleKey< xAOD::TrigDecision > * Trig::CacheGlobalMemory::xAODTrigDecisionKey ( ) const

inline

Definition at line 152 of file CacheGlobalMemory.h.

152{ return m_decisionKeyPtr; }

◆ DecisionAccess

friend class DecisionAccess

friend

Definition at line 162 of file CacheGlobalMemory.h.

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/4]

std::unique_ptr<IDecisionUnpacker> m_unpacker Trig::CacheGlobalMemory::ATLAS_THREAD_SAFE

mutableprivate

Trigger decision unpacker helper.

Definition at line 187 of file CacheGlobalMemory.h.

◆ ATLAS_THREAD_SAFE [2/4]

std::map< std::vector< std::string >, Trig::ChainGroup > m_chainGroups Trig::CacheGlobalMemory::ATLAS_THREAD_SAFE

mutableprivate

primary storage for chain groups

Definition at line 196 of file CacheGlobalMemory.h.

◆ ATLAS_THREAD_SAFE [3/4]

std::map< std::vector< std::string >, Trig::ChainGroup* > m_chainGroupsRef Trig::CacheGlobalMemory::ATLAS_THREAD_SAFE

mutableprivate

this map keeps the chain group more than once i.e.

when alias is given

Definition at line 197 of file CacheGlobalMemory.h.

◆ ATLAS_THREAD_SAFE [4/4]

AnyTypeDeleter m_deleteAtEndOfEvent Trig::CacheGlobalMemory::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 272 of file CacheGlobalMemory.h.

◆ m_bgCode

char Trig::CacheGlobalMemory::m_bgCode {0}

private

the encoded bunchgroup information

Definition at line 228 of file CacheGlobalMemory.h.

228{0};

◆ m_cgmMutex

std::recursive_mutex Trig::CacheGlobalMemory::m_cgmMutex

mutableprivate

R3 MT protection only against –threads > 1.

Needs refacotring...

Definition at line 274 of file CacheGlobalMemory.h.

◆ m_confChains

const TrigConf::HLTChainList* Trig::CacheGlobalMemory::m_confChains {nullptr}

private

all chains configuration

Definition at line 213 of file CacheGlobalMemory.h.

213{nullptr};

◆ m_confItems

const TrigConf::ItemContainer* Trig::CacheGlobalMemory::m_confItems {nullptr}

private

items configuration

Definition at line 212 of file CacheGlobalMemory.h.

212{nullptr};

◆ m_decisionKeyPtr

SG::ReadHandleKey<xAOD::TrigDecision>* Trig::CacheGlobalMemory::m_decisionKeyPtr {nullptr}

private

Parent TDT's read handle key.

Definition at line 215 of file CacheGlobalMemory.h.

215{nullptr};

◆ m_decisionUnpacked

bool Trig::CacheGlobalMemory::m_decisionUnpacked {false}

private

Was decision unpacked for this event?

Definition at line 189 of file CacheGlobalMemory.h.

189{false};

◆ m_efchainsByName

std::unordered_map<std::string, const HLT::Chain*> Trig::CacheGlobalMemory::m_efchainsByName

private

L2 chains keyed by chain name (chainging every event)

Definition at line 201 of file CacheGlobalMemory.h.

◆ m_efchainsCache

std::map<CHAIN_COUNTER, HLT::Chain> Trig::CacheGlobalMemory::m_efchainsCache

private

cache of all EF chains possible (given configuration)

Definition at line 207 of file CacheGlobalMemory.h.

◆ m_groups

std::map<std::string, std::vector<std::string> > Trig::CacheGlobalMemory::m_groups

private

mapping from group to list of chains

Definition at line 209 of file CacheGlobalMemory.h.

◆ m_itemsByName

std::unordered_map<std::string, const LVL1CTP::Lvl1Item*> Trig::CacheGlobalMemory::m_itemsByName

private

items keyed by configuration name (chainging every event)

Definition at line 199 of file CacheGlobalMemory.h.

◆ m_itemsCache

std::map<CTPID, LVL1CTP::Lvl1Item> Trig::CacheGlobalMemory::m_itemsCache

private

cache of all CTP items possible (given configuration)

Definition at line 205 of file CacheGlobalMemory.h.

◆ m_l2chainsByName

std::unordered_map<std::string, const HLT::Chain*> Trig::CacheGlobalMemory::m_l2chainsByName

private

L2 chains keyed by chain name (chainging every event)

Definition at line 200 of file CacheGlobalMemory.h.

◆ m_l2chainsCache

std::map<CHAIN_COUNTER, HLT::Chain> Trig::CacheGlobalMemory::m_l2chainsCache

private

cache of all L2 chains possible (given configuration)

Definition at line 206 of file CacheGlobalMemory.h.

◆ m_mConfChains

ChainHashMap_t Trig::CacheGlobalMemory::m_mConfChains

private

map of conf chains

Definition at line 226 of file CacheGlobalMemory.h.

◆ m_navigation

HLT::TrigNavStructure* Trig::CacheGlobalMemory::m_navigation {nullptr}

private

Navigation owned by CGM.

Definition at line 193 of file CacheGlobalMemory.h.

193{nullptr};

◆ m_navigationUnpacked

bool Trig::CacheGlobalMemory::m_navigationUnpacked {false}

private

Was navigation unpacked for this event?

Definition at line 190 of file CacheGlobalMemory.h.

190{false};

◆ m_oldDecisionKeyPtr

SG::ReadHandleKey<TrigDec::TrigDecision>* Trig::CacheGlobalMemory::m_oldDecisionKeyPtr {nullptr}

private

Parent TDT's read handle key.

Definition at line 218 of file CacheGlobalMemory.h.

218{nullptr};

◆ m_oldEventInfoKeyPtr

SG::ReadHandleKey<EventInfo>* Trig::CacheGlobalMemory::m_oldEventInfoKeyPtr {nullptr}

private

Parent TDT's read handle key.

Definition at line 219 of file CacheGlobalMemory.h.

219{nullptr};

◆ m_run2NavigationKeyPtr

SG::ReadHandleKey<xAOD::TrigNavigation>* Trig::CacheGlobalMemory::m_run2NavigationKeyPtr {nullptr}

private

Parent TDT's read handle key.

Definition at line 222 of file CacheGlobalMemory.h.

222{nullptr};

◆ m_run3NavigationKeyPtr

SG::ReadHandleKey<TrigCompositeUtils::DecisionContainer>* Trig::CacheGlobalMemory::m_run3NavigationKeyPtr {nullptr}

private

Parent TDT's read handle key.

Definition at line 223 of file CacheGlobalMemory.h.

223{nullptr};

◆ m_store

const asg::EventStoreType* Trig::CacheGlobalMemory::m_store {nullptr}

private

Pointer to the event store in use.

Definition at line 184 of file CacheGlobalMemory.h.

184{nullptr};

◆ m_streams

std::map<std::string, std::vector<std::string> > Trig::CacheGlobalMemory::m_streams

private

mapping from stream to list of chains

Definition at line 210 of file CacheGlobalMemory.h.

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

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ CHAIN_COUNTER

◆ ChainHashMap_t

◆ CTPID

Constructor & Destructor Documentation

◆ CacheGlobalMemory()

◆ ~CacheGlobalMemory()

Member Function Documentation

◆ assert_decision()

◆ chain() [1/2]

◆ chain() [2/2]

◆ config_chain()

◆ config_item()

◆ createChainGroup()

◆ deleteAtTheEndOfEvent()

◆ getChainGroup()

◆ getRun3NavigationKey()

◆ getRun3NavigationKeyPtr()

◆ getStreams()

◆ item() [1/2]

◆ item() [2/2]

◆ item_prescale()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ navigation() [1/2]

◆ navigation() [2/2]

◆ nChainGroups()

◆ reset_decision()

◆ setDecisionKeyPtr()

◆ setOldDecisionKeyPtr()

◆ setOldEventInfoKeyPtr()

◆ setRun2NavigationKeyPtr()

◆ setRun3NavigationKeyPtr()

◆ setStore()

◆ store()

◆ unpackDecision()

◆ unpackNavigation()

◆ update()

◆ updateChainGroup()

◆ xAODTrigDecisionKey()

Friends And Related Symbol Documentation

◆ DecisionAccess

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/4]

◆ ATLAS_THREAD_SAFE [2/4]

◆ ATLAS_THREAD_SAFE [3/4]

◆ ATLAS_THREAD_SAFE [4/4]

◆ m_bgCode

◆ m_cgmMutex

◆ m_confChains

◆ m_confItems

◆ m_decisionKeyPtr

◆ m_decisionUnpacked

◆ m_efchainsByName

◆ m_efchainsCache

◆ m_groups

◆ m_itemsByName

◆ m_itemsCache

◆ m_l2chainsByName

◆ m_l2chainsCache

◆ m_mConfChains

◆ m_navigation

◆ m_navigationUnpacked

◆ m_oldDecisionKeyPtr

◆ m_oldEventInfoKeyPtr

◆ m_run2NavigationKeyPtr

◆ m_run3NavigationKeyPtr

◆ m_store

◆ m_streams