Provide the reverse mapping: algorithm name to set of chain names. More...

#include <AlgToChainTool.h>

Inheritance diagram for TrigCompositeUtils::AlgToChainTool:

Collaboration diagram for TrigCompositeUtils::AlgToChainTool:

Classes
struct	ChainInfo

Public Member Functions
	AlgToChainTool (const std::string &type, const std::string &name, const IInterface *parent)

virtual	~AlgToChainTool ()

virtual StatusCode	initialize () override

virtual StatusCode	start () override

std::vector< std::string >	getChainsForAlg (const std::string &algorithmName) const
	Request set of chains for given algorithm - static lookup (menu) More...

std::set< std::string >	getActiveChainsForAlg (const std::string &algorithmName, const EventContext &context) const
	Request set of active chains for given algorithm - dynamic lookup (navigation) More...

StatusCode	getChainsForAllAlgs (const EventContext &context, std::map< std::string, std::set< std::string >> &algToChain) const
	Request set of chains for all algorithms in the menu. More...

std::set< TrigCompositeUtils::DecisionID >	retrieveActiveChains (const EventContext &context, const std::string &collectionName="") const
	Read the cached or non cached SG kays and request set of chains for given navigation collection. More...

StatusCode	getAllChains (std::vector< TrigConf::Chain > &) const
	Request all chains from the menu. More...

StatusCode	getChainInfo (const EventContext &context, TrigCompositeUtils::DecisionID id, ChainInfo &info) const
	Retrieve chain information for gived chain id. More...

StatusCode	getAllActiveSequences (const EventContext &context, std::map< std::string, std::string > &algToSeq)
	Retrieve algorithms and their active sequences. More...

void	cacheSGKeys (const EventContext &context)
	Cache the StoreGate keys. 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

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 ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
SG::ReadHandle< TrigCompositeUtils::DecisionContainer >	getDecisionFromStore (SmartIF< SGImplSvc > &eventStore, const std::string &key) const

std::string	createCollectionName (const std::string &sequenceName) const

std::vector< std::string >	readSGKeys (const EventContext &context) const
	Read the keys from StoreGate. More...

std::set< TrigCompositeUtils::DecisionID >	retrieveActiveChainsForKeys (const EventContext &context, const std::string &collectionName, const std::vector< std::string > &keys) const
	Request set of chains for given navigation collection and list of StoreGate keys. 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
SG::ReadHandleKey< TrigConf::HLTMenu >	m_HLTMenuKey { this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu", "HLT Menu" }

std::map< std::string, std::vector< TrigConf::Chain > >	m_sequencerToChainMap

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

std::vector< std::string >	m_cachedEventStoreKeys

uint64_t	m_cachedEventID

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

Provide the reverse mapping: algorithm name to set of chain names.

Definition at line 26 of file AlgToChainTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ AlgToChainTool()

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

Definition at line 9 of file AlgToChainTool.cxx.

12 : AthAlgTool (type, name, parent)

13 {}

◆ ~AlgToChainTool()

TrigCompositeUtils::AlgToChainTool::~AlgToChainTool ( )

virtual

Definition at line 16 of file AlgToChainTool.cxx.

16 {}

Member Function Documentation

◆ cacheSGKeys()

void TrigCompositeUtils::AlgToChainTool::cacheSGKeys ( const EventContext & context )

Cache the StoreGate keys.

Definition at line 150 of file AlgToChainTool.cxx.

                                                                               {
     if (m_cachedEventID != context.eventID().event_number()){
         ATH_MSG_INFO("Caching the event store keys for event " << context.eventID().event_number());
         m_cachedEventStoreKeys = readSGKeys(context);
         m_cachedEventID = context.eventID().event_number();
     }
 }

◆ createCollectionName()

std::string TrigCompositeUtils::AlgToChainTool::createCollectionName ( const std::string & sequenceName ) const

private

Definition at line 292 of file AlgToChainTool.cxx.

                                                                                                    {
     std::string filterName = "HLTNav_F" + sequenceName + "__";
  
     if (filterName.find("Trig") != std::string::npos){
         filterName.replace(filterName.find("Trig"), 4, "");
     }
  
     return filterName;
 }

◆ 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.

95 { 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.

85 { 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.

90 { 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

◆ getActiveChainsForAlg()

std::set< std::string > TrigCompositeUtils::AlgToChainTool::getActiveChainsForAlg	(	const std::string &	algorithmName,
		const EventContext &	context
	)		const

Request set of active chains for given algorithm - dynamic lookup (navigation)

Definition at line 90 of file AlgToChainTool.cxx.

                                                                                                                                            {
  
     std::set<std::string> allActiveChains;
     try {
         for ( const std::string& sequenceName : m_algToSequencersMap.at(algorithmName) ) {
  
             std::string filterName = createCollectionName(sequenceName);
             std::set<TrigCompositeUtils::DecisionID> activeChainsInSequence = retrieveActiveChains(context, filterName);
  
             for ( const TrigCompositeUtils::DecisionID& id : activeChainsInSequence ) {
                 allActiveChains.insert( HLT::Identifier(id).name() );
             }
         }
  
     } catch ( const std::out_of_range & ex ) {
         ATH_MSG_DEBUG ( "Algorithm " << algorithmName << " is not part of the menu!" );
     }
  
     return allActiveChains;
 }

◆ getAllActiveSequences()

StatusCode TrigCompositeUtils::AlgToChainTool::getAllActiveSequences	(	const EventContext &	context,
		std::map< std::string, std::string > &	algToSeq
	)

Retrieve algorithms and their active sequences.

Definition at line 112 of file AlgToChainTool.cxx.

                                                                                                                                        {
  
     // Retrieve EventStore and keys if not cached
     IProxyDict* storeProxy = Atlas::getExtendedEventContext(context).proxy();
     SmartIF<SGImplSvc> eventStore (storeProxy);
     if (m_cachedEventID != context.eventID().event_number()){
         ATH_MSG_INFO("Caching the event store keys for event " << context.eventID().event_number());
         eventStore->keys(static_cast<CLID>( ClassID_traits<TrigCompositeUtils::DecisionContainer>::ID() ), m_cachedEventStoreKeys);
         m_cachedEventID = context.eventID().event_number();
     }
  
     SG::ReadHandle<TrigConf::HLTMenu>  hltMenuHandle = SG::makeHandle( m_HLTMenuKey, context );
     ATH_CHECK( hltMenuHandle.isValid() );
     for (const auto& sequence : hltMenuHandle->sequencers()) {
         std::string filterName = createCollectionName(sequence.first);
  
         // Optimize
         auto foundKey = std::find_if(m_cachedEventStoreKeys.begin(), m_cachedEventStoreKeys.end(), [&](const std::string& key) {
             return key.starts_with( filterName);
         });
  
         if (foundKey != m_cachedEventStoreKeys.end() ){
             // Check if sequence passed - if at least one DecisionObject was produced
             for ( const TrigCompositeUtils::Decision* d : *getDecisionFromStore(eventStore, *foundKey) ) {
                 if (!d->decisions().empty()){
                     // Save algorithm to active sequence mapping
                     for (const std::string& alg : sequence.second) {
                         algToSeq[alg.substr(alg.find('/') + 1, alg.size())] = sequence.first;
                     }
                     break;
                 }
             }
         }
     }
  
     return StatusCode::SUCCESS;
 }

◆ getAllChains()

StatusCode TrigCompositeUtils::AlgToChainTool::getAllChains ( std::vector< TrigConf::Chain > & chainNames ) const

Request all chains from the menu.

Definition at line 57 of file AlgToChainTool.cxx.

                                                                                                     {
     SG::ReadHandle<TrigConf::HLTMenu>  hltMenuHandle = SG::makeHandle( m_HLTMenuKey );
     ATH_CHECK( hltMenuHandle.isValid() );
  
     for ( const TrigConf::Chain& chain : *hltMenuHandle ) {
         chainNames.push_back(chain);
     }
     return StatusCode::SUCCESS;
 }

◆ getChainInfo()

StatusCode TrigCompositeUtils::AlgToChainTool::getChainInfo	(	const EventContext &	context,
		TrigCompositeUtils::DecisionID	id,
		ChainInfo &	info
	)		const

Retrieve chain information for gived chain id.

Definition at line 239 of file AlgToChainTool.cxx.

                                                                                                                                                 {
     SG::ReadHandle<TrigConf::HLTMenu>  hltMenuHandle = SG::makeHandle( m_HLTMenuKey, context );
     ATH_CHECK( hltMenuHandle.isValid() );
  
     HLT::Identifier id = HLT::Identifier(decId);
     if (TrigCompositeUtils::isLegId(id)){
         id = getIDFromLeg(id);
     }
  
     info.id = id;
  
     // Find chain with given id
     TrigConf::HLTMenu::const_iterator chain = std::find_if(hltMenuHandle->begin(), hltMenuHandle->end(), 
         [&id](const TrigConf::Chain& c) {return c.namehash() == id;}
     );
  
     if(chain == hltMenuHandle->end()){
         ATH_MSG_WARNING("Chain " << id << " not found in the menu!");
         info.name = id.name();
         return StatusCode::SUCCESS;
     }
  
     info.name = (*chain).name();
     info.groups = (*chain).groups();
  
     // Check if chain passed - is in HLTPassRaw collection
     IProxyDict* storeProxy = Atlas::getExtendedEventContext(context).proxy();
     SmartIF<SGImplSvc> eventStore (storeProxy);
     SG::ReadHandle<TrigCompositeUtils::DecisionContainer> dc = getDecisionFromStore(eventStore, "HLTNav_Summary");
  
     const TrigCompositeUtils::Decision* passRaw = TrigCompositeUtils::getTerminusNode(dc);
     TrigCompositeUtils::DecisionIDContainer chainsID;
     TrigCompositeUtils::decisionIDs( passRaw, chainsID );
     info.isPassRaw = std::find(chainsID.begin(), chainsID.end(), id) != chainsID.end();
  
     return StatusCode::SUCCESS;
 }

◆ getChainsForAlg()

std::vector< std::string > TrigCompositeUtils::AlgToChainTool::getChainsForAlg ( const std::string & algorithmName ) const

Request set of chains for given algorithm - static lookup (menu)

Definition at line 68 of file AlgToChainTool.cxx.

                                                                                                            {
     std::vector<std::string> result;
  
     try {
         for ( const std::string& sequencer : m_algToSequencersMap.at(algorithmName) ) {
             try {
                 for (const TrigConf::Chain& chain : m_sequencerToChainMap.at(sequencer)){
                     result.push_back(chain.name());
                 }
             }
             catch ( const std::out_of_range & ex ) {
                 ATH_MSG_DEBUG ( "Sequence " << sequencer << " is not part of the menu!" );             
             }
         }
     } catch ( const std::out_of_range & ex ) {
         ATH_MSG_DEBUG ( "Algorithm " << algorithmName << " is not part of the menu!" );
     }
  
     return result;
 }

◆ getChainsForAllAlgs()

StatusCode TrigCompositeUtils::AlgToChainTool::getChainsForAllAlgs	(	const EventContext &	context,
		std::map< std::string, std::set< std::string >> &	algToChain
	)		const

Request set of chains for all algorithms in the menu.

Definition at line 212 of file AlgToChainTool.cxx.

                                                                                                                                                     {
  
     // Look for chains which were active for any of the algorithms of the sequence
     std::map<std::string, std::set<TrigCompositeUtils::DecisionID>> seqToActiveChains;
     for (const auto& sequence : m_sequencerToChainMap) {
         // Look for associated filters names with the sequence
         std::string filterName = createCollectionName(sequence.first);
         seqToActiveChains[sequence.first] = retrieveActiveChains(context, filterName);
     }
  
     for (const auto& algSeqPair : m_algToSequencersMap){
         std::set<std::string> activeChains;
         for (const std::string& sequenceName : algSeqPair.second){
             // Save all active chains per sequences that algorithm was executed
             for (TrigCompositeUtils::DecisionID chainId : seqToActiveChains.at(sequenceName)){
                 activeChains.insert(HLT::Identifier(chainId).name());
             }
         }
  
         algToChain[algSeqPair.first] = activeChains;
     }
  
     return StatusCode::SUCCESS;
 }

◆ getDecisionFromStore()

SG::ReadHandle< TrigCompositeUtils::DecisionContainer > TrigCompositeUtils::AlgToChainTool::getDecisionFromStore	(	SmartIF< SGImplSvc > &	eventStore,
		const std::string &	key
	)		const

private

Definition at line 278 of file AlgToChainTool.cxx.

                                                                                                                                                                    {
     SG::DataProxy* dp = eventStore->proxy(
         static_cast<CLID>(ClassID_traits<TrigCompositeUtils::DecisionContainer>::ID()), key, true);
  
     SG::ReadHandle<TrigCompositeUtils::DecisionContainer> dc (dp);
     if ( !dc.isValid() ) {            
         ATH_MSG_WARNING("Failed to retrieve " << key << " from event store.");            
         return SG::ReadHandle<TrigCompositeUtils::DecisionContainer>();        
     }
  
     return dc;
 }

◆ initialize()

StatusCode TrigCompositeUtils::AlgToChainTool::initialize ( )

overridevirtual

Definition at line 19 of file AlgToChainTool.cxx.

                                                         {
     ATH_CHECK( m_HLTMenuKey.initialize() );
  
     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.

◆ 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.

◆ readSGKeys()

std::vector< std::string > TrigCompositeUtils::AlgToChainTool::readSGKeys ( const EventContext & context ) const

private

Read the keys from StoreGate.

Definition at line 158 of file AlgToChainTool.cxx.

                                                                                                    {
     std::vector<std::string> keys;
     IProxyDict* storeProxy = Atlas::getExtendedEventContext(context).proxy();
     SmartIF<SGImplSvc> eventStore (storeProxy);
     eventStore->keys(static_cast<CLID>( ClassID_traits<TrigCompositeUtils::DecisionContainer>::ID() ), keys);
     return keys;
 }

◆ 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();
   }

◆ retrieveActiveChains()

std::set< TrigCompositeUtils::DecisionID > TrigCompositeUtils::AlgToChainTool::retrieveActiveChains	(	const EventContext &	context,
		const std::string &	collectionName = `""`
	)		const

Read the cached or non cached SG kays and request set of chains for given navigation collection.

Definition at line 166 of file AlgToChainTool.cxx.

                                                                                                                                                               {
     
     if (m_cachedEventID == context.eventID().event_number()) {
         return retrieveActiveChainsForKeys(context, collectionName, m_cachedEventStoreKeys);
     } else {
         const std::vector<std::string> keys = readSGKeys(context);
         return retrieveActiveChainsForKeys(context, collectionName, keys);
     }
 }

◆ retrieveActiveChainsForKeys()

std::set< TrigCompositeUtils::DecisionID > TrigCompositeUtils::AlgToChainTool::retrieveActiveChainsForKeys	(	const EventContext &	context,
		const std::string &	collectionName,
		const std::vector< std::string > &	keys
	)		const

private

Request set of chains for given navigation collection and list of StoreGate keys.

Definition at line 177 of file AlgToChainTool.cxx.

                                                                                                                                                                                                        {
     std::set<TrigCompositeUtils::DecisionID> activeChainsID;
  
     // Retrieve EventStore and keys if not cached
     IProxyDict* storeProxy = Atlas::getExtendedEventContext(context).proxy();
     SmartIF<SGImplSvc> eventStore (storeProxy);
  
     // Retrieve active chains name hashes
     for ( const std::string& key : keys ) {
  
         // Look for given collection
         if ( !collectionName.empty() && (!key.starts_with( collectionName)) ){
             continue;
         }
  
         // Get data from any nav collection
         if( collectionName.empty() && (!key.starts_with( "HLTNav") || key == "HLTNav_Summary") ) {
             continue;
         }
  
         for ( const TrigCompositeUtils::Decision* d : *getDecisionFromStore(eventStore, key) ) {
             TrigCompositeUtils::DecisionIDContainer chainsID;
             TrigCompositeUtils::decisionIDs( d, chainsID );
  
             // Save the active chains IDs
             for (TrigCompositeUtils::DecisionID id : chainsID){
                 activeChainsID.insert(TrigCompositeUtils::getIDFromLeg(id));
             }
         }
     }
  
     return activeChainsID;
 }

◆ start()

StatusCode TrigCompositeUtils::AlgToChainTool::start ( )

overridevirtual

Definition at line 26 of file AlgToChainTool.cxx.

                                                    {
     SG::ReadHandle<TrigConf::HLTMenu>  hltMenuHandle = SG::makeHandle( m_HLTMenuKey );
     ATH_CHECK( hltMenuHandle.isValid() );
     m_sequencerToChainMap.clear();
     m_algToSequencersMap.clear();
  
     // Fill the maps
     for ( const TrigConf::Chain& chain : *hltMenuHandle ) {
         for ( const std::string& sequencer : chain.sequencers() ) {
             // Skip empty steps = empty sequencers in the list
             if (sequencer.empty()) continue;
             m_sequencerToChainMap[sequencer].push_back(chain);
         }
     }
  
     for ( const auto& sequencer : hltMenuHandle->sequencers() ) {
         for ( const std::string& algorithm : sequencer.second ) {
             // PassFilter is for empty steps - will never be associated with a chain
             if (algorithm.starts_with( "PassFilter")) continue;
  
             // Save just second part of algorithm ex. RoRSeqFilter/FFastCaloElectron -> FFastCaloElectron
             m_algToSequencersMap[algorithm.substr(algorithm.find('/') + 1)]
                 .push_back(sequencer.first);
         }
     }
  
     m_cachedEventID = 0; // Revet the cache identifier
  
     return StatusCode::SUCCESS;
 }

◆ 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_algToSequencersMap

std::map<std::string, std::vector<std::string> > TrigCompositeUtils::AlgToChainTool::m_algToSequencersMap

private

Definition at line 74 of file AlgToChainTool.h.

◆ m_cachedEventID

uint64_t TrigCompositeUtils::AlgToChainTool::m_cachedEventID

private

Definition at line 77 of file AlgToChainTool.h.

◆ m_cachedEventStoreKeys

std::vector<std::string> TrigCompositeUtils::AlgToChainTool::m_cachedEventStoreKeys

private

Definition at line 76 of file AlgToChainTool.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_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_HLTMenuKey

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

private

Definition at line 71 of file AlgToChainTool.h.

◆ m_sequencerToChainMap

std::map<std::string, std::vector<TrigConf::Chain> > TrigCompositeUtils::AlgToChainTool::m_sequencerToChainMap

private

Definition at line 73 of file AlgToChainTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.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:

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ AlgToChainTool()

◆ ~AlgToChainTool()

Member Function Documentation

◆ cacheSGKeys()

◆ createCollectionName()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ getActiveChainsForAlg()

◆ getAllActiveSequences()

◆ getAllChains()

◆ getChainInfo()

◆ getChainsForAlg()

◆ getChainsForAllAlgs()

◆ getDecisionFromStore()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ readSGKeys()

◆ renounce()

◆ renounceArray()

◆ retrieveActiveChains()

◆ retrieveActiveChainsForKeys()

◆ start()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_algToSequencersMap

◆ m_cachedEventID

◆ m_cachedEventStoreKeys

◆ m_detStore

◆ m_evtStore

◆ m_HLTMenuKey

◆ m_sequencerToChainMap

◆ m_varHandleArraysDeclared

◆ m_vhka