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)
std::set< std::string >	getActiveChainsForAlg (const std::string &algorithmName, const EventContext &context) const
	Request set of active chains for given algorithm - dynamic lookup (navigation)
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.
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.
StatusCode	getAllChains (std::vector< TrigConf::Chain > &) const
	Request all chains from the menu.
StatusCode	getChainInfo (const EventContext &context, TrigCompositeUtils::DecisionID id, ChainInfo &info) const
	Retrieve chain information for gived chain id.
StatusCode	getAllActiveSequences (const EventContext &context, std::map< std::string, std::string > &algToSeq)
	Retrieve algorithms and their active sequences.
void	cacheSGKeys (const EventContext &context)
	Cache the StoreGate keys.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

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.
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.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
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 {}

AthAlgTool::AthAlgTool

AthAlgTool()

Default constructor:

◆ ~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_DEBUG("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 288 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()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	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());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & 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; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

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; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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_DEBUG("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 = getIDFromLeg(decId);
    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] = std::move(activeChains);
    }
 
    return StatusCode::SUCCESS;
}

◆ getDecisionFromStore()

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

private

Definition at line 274 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()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ 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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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

77{};

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

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

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

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ getActiveChainsForAlg()

◆ getAllActiveSequences()

◆ getAllChains()

◆ getChainInfo()

◆ getChainsForAlg()

◆ getChainsForAllAlgs()

◆ getDecisionFromStore()

◆ initialize()

◆ inputHandles()

◆ msg()

◆ 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