TrigCompositeUtils Namespace Reference

Classes
class	AlgToChainTool
	Provide the reverse mapping: algorithm name to set of chain names. More...
class	Combinations
class	HasObject
	Prerequisite object usable with. More...
class	HasObjectCollection
	Prerequisite object usable with. More...
class	IPartCombItr
class	KFromNItr
	Iterates over all combinations of k values chosen from a range n. More...
struct	LinkInfo
	Helper to keep a Decision object, ElementLink and ActiveState (with respect to some requested ChainGroup) linked together (for convenience) More...
class	NavGraph
	Structure to hold a transient Directed Acyclic Graph (DAG) structure. More...
class	NavGraphNode
	Transient utility class to represent a node in a graph (m_decisionObject), and a vector of edges (m_filteredSeeds) to other nodes which are parents of this node. More...
class	ProductItr
	Iterates over all combinations of the provided input iterators. More...
struct	TypelessLinkInfo
	Helper to keep a Decision object, ElementLink and ActiveState (with respect to some requested ChainGroup) linked together (for convenience) This is the internal type erased version, a typed version also exists which is exposed by the public facing API. More...

Typedefs
typedef xAOD::TrigComposite	Decision
typedef xAOD::TrigCompositeAuxContainer	DecisionAuxContainer
typedef xAOD::TrigCompositeContainer	DecisionContainer
typedef unsigned int	DecisionID
typedef std::set< DecisionID >	DecisionIDContainer
using	sgkey_t = SG::sgkey_t
typedef SG::WriteHandle< DecisionContainer >	DecisionWriteHandle
	alias types, for readability and to simplify future evolution

Enumerations
enum	ActiveState { UNSET , ACTIVE , INACTIVE }
	Additional information returned by the TrigerDecisionTool's feature retrieval, contained within the LinkInfo. More...
enum class	FilterType { All , UniqueObjects , UniqueRoIs , UniqueInitialRoIs }

Functions
bool	uniqueObjects (const std::vector< LinkInfo< xAOD::IParticleContainer > > &links)
	Helper fucntion that returns true if no objects are repeated.
bool	uniqueInitialRoIs (const std::vector< LinkInfo< xAOD::IParticleContainer > > &links)
	Helper function that returns true if no objects share an initial RoI.
bool	uniqueRoIs (const std::vector< LinkInfo< xAOD::IParticleContainer > > &links)
	Helper function that returns true if no objects share a final RoI.
std::function< bool(const std::vector< LinkInfo< xAOD::IParticleContainer > > &)>	getFilter (FilterType filter)
	Get a lambda corresponding to the specified FilterType enum.
SG::WriteHandle< DecisionContainer >	createAndStore (const SG::WriteHandleKey< DecisionContainer > &key, const EventContext &ctx)
	Creates and right away records the DecisionContainer with the key.
void	createAndStore (SG::WriteHandle< DecisionContainer > &handle)
	Creates and right away records the DecisionContainer using the provided WriteHandle.
Decision *	newDecisionIn (DecisionContainer *dc, const std::string &name="")
	Helper method to create a Decision object, place it in the container and return a pointer to it.
Decision *	newDecisionIn (DecisionContainer *dc, const Decision *dOld, const std::string &name, const EventContext &ctx)
	Helper method to create a Decision object, place it in the container and return a pointer to it.
void	addDecisionID (DecisionID id, Decision *d)
	Appends the decision (given as ID) to the decision object.
void	decisionIDs (const Decision *d, DecisionIDContainer &id)
	Extracts DecisionIDs stored in the Decision object.
const std::vector< DecisionID > &	decisionIDs (const Decision *d)
	Another variant of the above method to access DecisionIDs stored in the Decision object, returns const accessor.
std::vector< DecisionID > &	decisionIDs (Decision *d)
	Another variant of the above method to access DecisionIDs stored in the Decision object, returns read/write accessor.
void	insertDecisionIDs (const Decision *src, Decision *dest)
	Appends the decision IDs of src to the dest decision object.
void	insertDecisionIDs (const DecisionIDContainer &src, Decision *dest)
	Appends the decision IDs of src to the dest decision object.
void	uniqueDecisionIDs (Decision *dest)
	Make unique list of decision IDs of dest Decision object.
bool	allFailed (const Decision *d)
	return true if there is no positive decision stored
bool	isAnyIDPassing (const Decision *d, const DecisionIDContainer &required)
	Checks if any of the DecisionIDs passed in arg required is availble in Decision object.
bool	passed (DecisionID id, const DecisionIDContainer &)
	checks if required decision ID is in the set of IDs in the container
ElementLink< DecisionContainer >	decisionToElementLink (const Decision *d, const EventContext &ctx)
	Takes a raw pointer to a Decision and returns an ElementLink to the Decision.
void	linkToPrevious (Decision *d, const std::string &previousCollectionKey, size_t previousIndex)
	Links to the previous object, location of previous 'seed' decision supplied by hand.
void	linkToPrevious (Decision *d, const Decision *dOld, const EventContext &ctx)
	Links to the previous object, 'seed' decision provided explicitly.
bool	hasLinkToPrevious (const Decision *d)
	checks if there is at least one 'seed' link to previous object
const std::vector< ElementLink< DecisionContainer > >	getLinkToPrevious (const Decision *)
	returns links to previous decision object 'seed'
bool	copyLinks (const Decision *src, Decision *dest)
	copy all links from src to dest TC objects
HLT::Identifier	createLegName (const HLT::Identifier &chainIdentifier, size_t counter)
	Generate the HLT::Identifier which corresponds to a specific leg of a given chain.
HLT::Identifier	createLegName (const std::string &name, size_t counter)
	Generate the HLT::Identifier which corresponds to a specific leg of a given chain.
HLT::Identifier	getIDFromLeg (const HLT::Identifier &legIdentifier)
	Generate the HLT::Identifier which corresponds to the chain name from the leg name.
int32_t	getIndexFromLeg (const HLT::Identifier &legIdentifier)
	Extract the numeric index of a leg identifier.
int32_t	getIndexFromLeg (const std::string &name)
	Extract the numeric index of a leg identifier.
std::pair< std::string, int32_t >	getNameAndIndexFromLeg (const std::string &name)
	Extract the name and numeric index of a leg identifier.
bool	isLegId (const HLT::Identifier &legIdentifier)
	Recognise whether the chain ID is a leg ID.
bool	isLegId (const std::string &name)
	Recognise whether the chain ID is a leg ID.
bool	isChainId (const HLT::Identifier &chainIdentifier)
	Recognise whether the HLT identifier corresponds to a whole chain.
bool	isChainId (const std::string &name)
	Recognise whether the HLT identifier corresponds to a whole chain.
const Decision *	find (const Decision *, const std::function< bool(const Decision *)> &filter)
	traverses Decision object links for another Decision object fulfilling the prerequisite specified by the filter
const Decision *	getTerminusNode (SG::ReadHandle< DecisionContainer > &container)
const Decision *	getTerminusNode (const DecisionContainer &container)
	Returns the terminus navigation node from a collection, assuming that the passed collection contains the terminus node.
const Decision *	getExpressTerminusNode (const DecisionContainer &container)
	Returns the express-accept navigation node from a collection or nullptr if missing.
const Decision *	getNodeByName (const DecisionContainer &container, const std::string &nodeName)
	Returns the navigation node with a given name from a collection or nullptr if missing.
std::vector< const Decision * >	getRejectedDecisionNodes (const asg::EventStoreType *eventStore, const EventContext &ctx, const std::string &summaryCollectionKey, const DecisionIDContainer &ids={}, const std::set< std::string > &keysToIgnore=std::set< std::string >())
	Query all DecisionCollections in the event store, locate all Decision nodes in the graph where an object failed selection for a given chain.
void	recursiveGetDecisionsInternal (const Decision *node, const Decision *comingFrom, NavGraph &navGraph, std::set< const Decision * > &fullyExploredFrom, const DecisionIDContainer &ids, const bool enforceDecisionOnNode)
	Used by recursiveGetDecisions.
void	recursiveGetDecisions (const Decision *node, NavGraph &navGraph, const DecisionIDContainer &ids={}, const bool enforceDecisionOnStartNode=true)
	Search back in time from "node" and locate all paths back through Decision objects for a given chain.
void	recursiveFlagForThinning (NavGraph &node, const bool keepOnlyFinalFeatures, const bool removeEmptySteps, const std::vector< std::string > &nodesToDrop)
	Used by trigger navigation thinning.
void	recursiveFlagForThinningInternal (NavGraphNode *node, bool modeKeep, std::set< NavGraphNode * > &fullyExploredFrom, const bool keepOnlyFinalFeatures, const bool removeEmptySteps, const std::vector< std::string > &nodesToDrop)
	Used by recursiveFlagForThinning.
bool	typelessFindLinks (const Decision *start, const std::string &linkName, std::vector< sgkey_t > &keyVec, std::vector< CLID > &clidVec, std::vector< Decision::index_type > &indexVec, std::vector< const Decision * > &sourceVec, const unsigned int behaviour=TrigDefs::allFeaturesOfType, std::set< const Decision * > *fullyExploredFrom=nullptr)
	search back the TC links for the object of type T linked to the one of TC (recursively) Returns the link data in a typeless way, as raw key, index and CLID values.
bool	typelessFindLinks (const NavGraphNode *start, const std::string &linkName, std::vector< sgkey_t > &key, std::vector< CLID > &clid, std::vector< Decision::index_type > &index, std::vector< const Decision * > &sourceVec, const unsigned int behaviour=TrigDefs::allFeaturesOfType, std::set< const Decision * > *fullyExploredFrom=nullptr)
	Version of typelessFindLinks which operates on a sub-graph (entered via the supplied NavGraphNode), rather than the whole navigation graph.
bool	typelessFindLinksCommonLinkCollection (const Decision *start, const std::string &linkName, std::vector< sgkey_t > &keyVec, std::vector< CLID > &clidVec, std::vector< Decision::index_type > &indexVec, std::vector< const Decision * > &sourceVec)
	Common functionality shared by both typelessFindLinks interfaces Returns true if at least one link was collected.
bool	typelessFindLink (const Decision *start, const std::string &linkName, sgkey_t &key, CLID &clid, Decision::index_type &index, const Decision *&source, const bool suppressMultipleLinksWarning=false)
	Perform a recursive search for ElementLinks of any time and name 'linkName', starting from Decision object 'start' Returns the link data in a typeless way, as raw key, index and CLID values.
bool	typelessFindLink (const NavGraph &subGraph, const std::string &linkName, sgkey_t &key, CLID &clid, Decision::index_type &index, const Decision *&source, const bool suppressMultipleLinksWarning=false)
	Version of typelessFindLink which operates on a sub-graph (described by the NavGraph), rather than the whole navigation graph.
Combinations	buildCombinations (const std::string &chainName, const std::vector< LinkInfo< xAOD::IParticleContainer > > &features, const std::vector< std::size_t > &legMultiplicities, const std::function< bool(const std::vector< LinkInfo< xAOD::IParticleContainer > > &)> &filter)
	Produce the combinations for a set of features.
Combinations	buildCombinations (const std::string &chainName, const std::vector< LinkInfo< xAOD::IParticleContainer > > &features, const std::vector< std::size_t > &legMultiplicities, FilterType filter=FilterType::UniqueObjects)
	Produce the combinations for a set of features.
Combinations	buildCombinations (const std::string &chainName, const std::vector< LinkInfo< xAOD::IParticleContainer > > &features, const TrigConf::HLTChain *chainInfo, const std::function< bool(const std::vector< LinkInfo< xAOD::IParticleContainer > > &)> &filter)
	Produce the combinations for a set of features.
Combinations	buildCombinations (const std::string &chainName, const std::vector< LinkInfo< xAOD::IParticleContainer > > &features, const TrigConf::HLTChain *chainInfo, FilterType filter=FilterType::UniqueObjects)
	Produce the combinations for a set of features.
std::string	dump (const Decision *tc, const std::function< std::string(const Decision *)> &printerFnc)
	Prints the Decision object including the linked seeds @warnign expensive call.
template<class CONT>
SG::WriteHandle< CONT >	createAndStoreNoAux (const SG::WriteHandleKey< CONT > &key, const EventContext &ctx)
	Creates and right away records the Container CONT with the key.
template<class CONT, class AUX>
SG::WriteHandle< CONT >	createAndStoreWithAux (const SG::WriteHandleKey< CONT > &key, const EventContext &ctx)
	Creates and right away records the Container CONT with the key.
template<typename T>
DecisionIDContainer	passedDecisionIDs (const Decision *d, const T &required)
	return DecisionIDs in Decision object that match the required ones
template<class CONTAINER>
void	filterLinkVectorByContainerKey (const std::string &containerSGKey, std::vector< ElementLink< CONTAINER > > &vector)
	DEPRECATED.
template<class CONTAINER>
const std::vector< LinkInfo< CONTAINER > >	recursiveGetFeaturesOfType (const NavGraph &navGraph, const std::string &containerSGKey="", const unsigned int behaviour=TrigDefs::lastFeatureOfType, const std::string &navElementLinkKey=featureString(), const DecisionIDContainer &chainIDs=DecisionIDContainer())
	DEPRECATED.
template<class CONTAINER>
void	recursiveGetFeaturesOfTypeInternal (std::vector< LinkInfo< CONTAINER > > &features, std::set< const NavGraphNode * > &fullyExploredFrom, const NavGraphNode *navGraphNode, const std::string &containerSGKey, const unsigned int behaviour, const std::string &navElementLinkKey, const DecisionIDContainer &chainIDs)
	DEPRECATED.
template<typename T>
LinkInfo< T >	findLink (const Decision *start, const std::string &linkName, const bool suppressMultipleLinksWarning=false)
	Perform a recursive search for ElementLinks of type T and name 'linkName', starting from Decision object 'start' For the case of multiple links, this function only returns the first one found.
template<typename T>
void	findLinks (const Decision *start, const std::string &linkName, std::vector< LinkInfo< T > > &links, unsigned int behaviour=TrigDefs::allFeaturesOfType, std::set< const xAOD::TrigComposite * > *fullyExploredFrom=nullptr)
	search back the TC links for the object of type T linked to the one of TC (recursively) Populates provided vector with all located links to T of the corresponding linkName.
template<typename T>
std::vector< LinkInfo< T > >	findLinks (const Decision *start, const std::string &linkName, unsigned int behaviour=TrigDefs::allFeaturesOfType)
	search back the TC links for the object of type T linked to the one of TC (recursively) This version returns a vector rather than requiring that one be passed to it.
Constant string literals used within the HLT
const std::string &	initialRoIString ()
const std::string &	initialRecRoIString ()
const std::string &	roiString ()
const std::string &	viewString ()
const std::string &	featureString ()
const std::string &	seedString ()
const std::string &	hltSeedingNodeName ()
const std::string &	filterNodeName ()
const std::string &	inputMakerNodeName ()
const std::string &	hypoAlgNodeName ()
const std::string &	comboHypoAlgNodeName ()
const std::string &	summaryFilterNodeName ()
const std::string &	summaryPassNodeName ()
const std::string &	summaryPassExpressNodeName ()
const std::string &	summaryPrescaledNodeName ()

Typedef Documentation

Decision

typedef xAOD::TrigComposite TrigCompositeUtils::Decision

Definition at line 20 of file Event/xAOD/xAODTrigger/xAODTrigger/TrigComposite.h.

DecisionAuxContainer

typedef xAOD::TrigCompositeAuxContainer TrigCompositeUtils::DecisionAuxContainer

Definition at line 20 of file TrigCompositeAuxContainer.h.

DecisionContainer

typedef xAOD::TrigCompositeContainer TrigCompositeUtils::DecisionContainer

Definition at line 21 of file Event/xAOD/xAODTrigger/xAODTrigger/TrigCompositeContainer.h.

DecisionID

typedef unsigned int TrigCompositeUtils::DecisionID

Definition at line 27 of file TrigComposite_v1.h.

DecisionIDContainer

typedef std::set<DecisionID> TrigCompositeUtils::DecisionIDContainer

Definition at line 28 of file TrigComposite_v1.h.

DecisionWriteHandle

typedef SG::WriteHandle<DecisionContainer> TrigCompositeUtils::DecisionWriteHandle

alias types, for readability and to simplify future evolution

Definition at line 50 of file TrigCompositeUtils.h.

sgkey_t

using TrigCompositeUtils::sgkey_t = SG::sgkey_t

Definition at line 44 of file TrigCompositeUtils.h.

Enumeration Type Documentation

ActiveState

enum TrigCompositeUtils::ActiveState

Additional information returned by the TrigerDecisionTool's feature retrieval, contained within the LinkInfo.

Enumerator
UNSET	Default property of state. Indicates that the creator of the LinkInfo did not supply this information
ACTIVE	The link was still active for one-or-more of the HLT Chains requested in the TDT.
INACTIVE	The link was inactive for all of the HLT Chains requested in the TDT. I.e. the object was rejected by these chains.

Definition at line 18 of file ActiveState.h.

                   {
    UNSET, 
    ACTIVE, 
    INACTIVE 
  };

FilterType

enum class TrigCompositeUtils::FilterType

strong

Enumerator
All	Allow all combinations.
UniqueObjects	Do not allow any repeated objects.
UniqueRoIs	Do not allow any two objects to share an RoI.
UniqueInitialRoIs	Do not allow any two objects to share an initial RoI.

Definition at line 21 of file IPartCombItr.h.

  {
    All,
    UniqueObjects,
    UniqueRoIs,
    UniqueInitialRoIs
  };

Function Documentation

addDecisionID()

void TrigCompositeUtils::addDecisionID	(	DecisionID	id,
		Decision *	d )

Appends the decision (given as ID) to the decision object.

Warning

Performing two decision insertions with the same ID consecutively results in the ID stored only once This helps solving multiple inserts in the combo hypo tools

Definition at line 59 of file TrigCompositeUtilsRoot.cxx.

                                                    {   
    std::vector<DecisionID>& decisions = readWriteAccessor( *d );
    if ( decisions.size() == 0 or decisions.back() != id) 
      decisions.push_back( id );
  }

allFailed()

bool TrigCompositeUtils::allFailed

(

const Decision *

d

)

return true if there is no positive decision stored

Definition at line 104 of file TrigCompositeUtilsRoot.cxx.

                                      {
    const std::vector<DecisionID>& decisions = readOnlyAccessor( *d );    
    return decisions.empty();
  }

buildCombinations() [1/4]

Combinations TrigCompositeUtils::buildCombinations	(	const std::string &	chainName,
		const std::vector< LinkInfo< xAOD::IParticleContainer > > &	features,
		const std::vector< std::size_t > &	legMultiplicities,
		const std::function< bool(const std::vector< LinkInfo< xAOD::IParticleContainer > > &)> &	filter )

Produce the combinations for a set of features.

Returns a TrigCompositeUtils::Combinations object that generates all valid combinations of features. This is a range object that returns on iterator which creates the combinations on the fly.

Parameters

[in]	chainName	The name of the chain
[in]	features	The IParticle features of the container
[in]	legMultiplicities	The multiplicity of each chain leg. If a leg will not produce an IParticle feature its multiplicity should be set to 0
[in]	filter	A function that returns true for all valid combinations

Definition at line 824 of file TrigCompositeUtilsRoot.cxx.

  {
    Combinations combinations(filter);
    combinations.reserve(legMultiplicities.size());
    if (legMultiplicities.size() == 1)
      combinations.addLeg(legMultiplicities.at(0), features);
    else
      for (std::size_t legIdx = 0; legIdx < legMultiplicities.size(); ++legIdx)
      {
        // Skip any that will not provide IParticle features
        if (legMultiplicities[legIdx] == 0)
          continue;
        HLT::Identifier legID = createLegName(chainName, legIdx);
        std::vector<LinkInfo<xAOD::IParticleContainer>> legFeatures;
        for (const LinkInfo<xAOD::IParticleContainer>& info : features) {
          if (info.decisions->contains(legID.numeric()))
            legFeatures.push_back(info);
        }
        combinations.addLeg(legMultiplicities.at(legIdx), std::move(legFeatures));
      }
    return combinations;
  }

buildCombinations() [2/4]

Combinations TrigCompositeUtils::buildCombinations	(	const std::string &	chainName,
		const std::vector< LinkInfo< xAOD::IParticleContainer > > &	features,
		const std::vector< std::size_t > &	legMultiplicities,
		FilterType	filter = FilterType::UniqueObjects )

Produce the combinations for a set of features.

Returns a TrigCompositeUtils::Combinations object that generates all valid combinations of features. This is a range object that returns on iterator which creates the combinations on the fly.

Parameters

[in]	chainName	The name of the chain
[in]	features	The IParticle features of the container
[in]	legMultiplicities	The multiplicity of each chain leg. If a leg will not produce an IParticle feature its multiplicity should be set to 0
[in]	filter	A FilterType enum describing how to filter valid combinations

Definition at line 852 of file TrigCompositeUtilsRoot.cxx.

  {
    return buildCombinations(chainName, features, legMultiplicities, getFilter(filter));
  }

buildCombinations() [3/4]

Combinations TrigCompositeUtils::buildCombinations	(	const std::string &	chainName,
		const std::vector< LinkInfo< xAOD::IParticleContainer > > &	features,
		const TrigConf::HLTChain *	chainInfo,
		const std::function< bool(const std::vector< LinkInfo< xAOD::IParticleContainer > > &)> &	filter )

Produce the combinations for a set of features.

Returns a TrigCompositeUtils::Combinations object that generates all valid combinations of features. This is a range object that returns on iterator which creates the combinations on the fly.

Note that if any legs of this chain do not have IParticle features this will not generate any combinations.

Parameters

[in]	chainName	The name of the chain
[in]	features	The IParticle features of the container
[in]	chainInfo	The chain info object read from the configuration
[in]	filter	A function that returns true for all valid combinations

Definition at line 861 of file TrigCompositeUtilsRoot.cxx.

  {
    return buildCombinations(chainName, features, chainInfo->leg_multiplicities(), filter);
  }

buildCombinations() [4/4]

Combinations TrigCompositeUtils::buildCombinations	(	const std::string &	chainName,
		const std::vector< LinkInfo< xAOD::IParticleContainer > > &	features,
		const TrigConf::HLTChain *	chainInfo,
		FilterType	filter = FilterType::UniqueObjects )

Produce the combinations for a set of features.

Returns a TrigCompositeUtils::Combinations object that generates all valid combinations of features. This is a range object that returns on iterator which creates the combinations on the fly.

Note that if any legs of this chain do not have IParticle features this will not generate any combinations.

Parameters

[in]	chainName	The name of the chain
[in]	features	The IParticle features of the container
[in]	chainInfo	The chain info object read from the configuration
[in]	filter	A FilterType enum describing how to filter valid combinations

Definition at line 870 of file TrigCompositeUtilsRoot.cxx.

  {
    return buildCombinations(chainName, features, chainInfo, getFilter(filter));
  }

comboHypoAlgNodeName()

const std::string & TrigCompositeUtils::comboHypoAlgNodeName ( )

inline

Definition at line 428 of file TrigCompositeUtils.h.

{ return Decision::s_comboHypoAlgNodeNameString; }

copyLinks()

bool TrigCompositeUtils::copyLinks	(	const Decision *	src,
		Decision *	dest )

copy all links from src to dest TC objects

Warning

if there are links already in the dest TC, the operation is not performed and false returned @ret true if success

Definition at line 162 of file TrigCompositeUtilsRoot.cxx.

                                                      {
    return dest->copyAllLinksFrom(src);
  }

createAndStore() [1/2]

SG::WriteHandle< DecisionContainer > TrigCompositeUtils::createAndStore	(	const SG::WriteHandleKey< DecisionContainer > &	key,
		const EventContext &	ctx )

Creates and right away records the DecisionContainer with the key.

Returns the WriteHandle.

Definition at line 28 of file TrigCompositeUtilsRoot.cxx.

                                                                                                                             {
    SG::WriteHandle<DecisionContainer> handle( key, ctx );
    auto data = std::make_unique<DecisionContainer>() ;
    auto aux = std::make_unique<DecisionAuxContainer>() ;
    data->setStore( aux.get() );
    handle.record( std::move( data ), std::move( aux )  ).ignore();
    return handle;
  }

createAndStore() [2/2]

void TrigCompositeUtils::createAndStore

(

SG::WriteHandle< DecisionContainer > &

handle

)

Creates and right away records the DecisionContainer using the provided WriteHandle.

Definition at line 37 of file TrigCompositeUtilsRoot.cxx.

                                                                  {
    auto data = std::make_unique<DecisionContainer>() ;
    auto aux = std::make_unique<DecisionAuxContainer>() ;
    data->setStore( aux.get() );
    handle.record( std::move( data ), std::move( aux )  ).ignore();
  }

createAndStoreNoAux()

template<class CONT>

SG::WriteHandle< CONT > TrigCompositeUtils::createAndStoreNoAux	(	const SG::WriteHandleKey< CONT > &	key,
		const EventContext &	ctx )

Creates and right away records the Container CONT with the key.

Returns the WriteHandle. No Aux store.

createAndStoreWithAux()

template<class CONT, class AUX>

SG::WriteHandle< CONT > TrigCompositeUtils::createAndStoreWithAux	(	const SG::WriteHandleKey< CONT > &	key,
		const EventContext &	ctx )

Creates and right away records the Container CONT with the key.

Returns the WriteHandle. With Aux store.

createLegName() [1/2]

HLT::Identifier TrigCompositeUtils::createLegName	(	const HLT::Identifier &	chainIdentifier,
		size_t	counter )

Generate the HLT::Identifier which corresponds to a specific leg of a given chain.

This can be queried for its DecisionID.

Parameters

chainIdentifier	The HLT::Identifier corresponding to the chain.
counter	The numeral of the leg.

Returns

HLT::Identifier corresponding to the specified leg. Call .numeric() on this to get the DecisionID.

Definition at line 166 of file TrigCompositeUtilsRoot.cxx.

                                                                                    {
    return createLegName( chainIdentifier.name(), counter );
  }

createLegName() [2/2]

HLT::Identifier TrigCompositeUtils::createLegName	(	const std::string &	name,
		size_t	counter )

Generate the HLT::Identifier which corresponds to a specific leg of a given chain.

This can be queried for its DecisionID.

Parameters

name	The chain name.
counter	The numeral of the leg.

Returns

HLT::Identifier corresponding to the specified leg. Call .numeric() on this to get the DecisionID.

Definition at line 170 of file TrigCompositeUtilsRoot.cxx.

                                                                     {
    if (!isChainId(name)) {
      throw std::runtime_error("TrigCompositeUtils::createLegName chainIdentifier '"+name+"' does not start with 'HLT_'");
    }
    if (counter > 999) {
      throw std::runtime_error("TrigCompositeUtils::createLegName Leg counters above 999 are invalid.");
    }
    return HLT::Identifier( std::format("leg{:0>3d}_{}", counter, name) );
  }

decisionIDs() [1/3]

const std::vector< DecisionID > & TrigCompositeUtils::decisionIDs

(

const Decision *

d

)

Another variant of the above method to access DecisionIDs stored in the Decision object, returns const accessor.

Warning

Operates on the underlying xAOD vector form rather than the DecisionContainer set form

Definition at line 70 of file TrigCompositeUtilsRoot.cxx.

                                                                {    
    return readOnlyAccessor( *d );    
  }

decisionIDs() [2/3]

void TrigCompositeUtils::decisionIDs	(	const Decision *	d,
		DecisionIDContainer &	destination )

Extracts DecisionIDs stored in the Decision object.

Definition at line 65 of file TrigCompositeUtilsRoot.cxx.

                                                                          {    
    const std::vector<DecisionID>& decisions = readOnlyAccessor( *d );    
    destination.insert( decisions.begin(), decisions.end() );
  }

decisionIDs() [3/3]

std::vector< DecisionID > & TrigCompositeUtils::decisionIDs

(

Decision *

d

)

Another variant of the above method to access DecisionIDs stored in the Decision object, returns read/write accessor.

Warning

Operates on the underlying xAOD vector form rather than the DecisionContainer set form

Definition at line 74 of file TrigCompositeUtilsRoot.cxx.

                                                    {
    return readWriteAccessor( *d );
  }

decisionToElementLink()

ElementLink< DecisionContainer > TrigCompositeUtils::decisionToElementLink	(	const Decision *	d,
		const EventContext &	ctx )

Takes a raw pointer to a Decision and returns an ElementLink to the Decision.

The Decision must already be in a container in SG.

Definition at line 123 of file TrigCompositeUtilsRoot.cxx.

                                                                                                   {
    const DecisionContainer* container = dynamic_cast<const DecisionContainer*>( d->container() );
    if( ! container ) {
      throw std::runtime_error("TrigCompositeUtils::convertToElementLink Using convertToElementLink(d) requires that the Decision d is already in a container");
    }
    return ElementLink<DecisionContainer>(*container, d->index(), ctx);
  }

dump()

std::string TrigCompositeUtils::dump	(	const Decision *	tc,
		const std::function< std::string(const Decision *)> &	printerFnc )

Prints the Decision object including the linked seeds @warnign expensive call.

Definition at line 880 of file TrigCompositeUtilsRoot.cxx.

                                                                                                     {
    std::string ret; 
    ret += printerFnc( tc );
    if ( hasLinkToPrevious(tc) ) {
      const std::vector<ElementLink<DecisionContainer>> seeds = getLinkToPrevious(tc);
      for (const ElementLink<DecisionContainer>& seedEL : seeds) {
        ret += " -> " + dump( *seedEL, printerFnc );
      }
    }
    return ret;
  }

featureString()

const std::string & TrigCompositeUtils::featureString ( )

inline

Definition at line 421 of file TrigCompositeUtils.h.

{ return Decision::s_featureString; }

filterLinkVectorByContainerKey()

template<class CONTAINER>

void TrigCompositeUtils::filterLinkVectorByContainerKey	(	const std::string &	containerSGKey,
		std::vector< ElementLink< CONTAINER > > &	vector )

DEPRECATED.

Removes ElementLinks from the supplied vector if they do not come from the specified collection (regex match).

Parameters

[in]	containerSGKey	The StoreGate key of the collection to match against. Passing "" performs no filtering.
[in,out]	vector	Mutable vector of ElementLinks on which to filter.

filterNodeName()

const std::string & TrigCompositeUtils::filterNodeName ( )

inline

Definition at line 425 of file TrigCompositeUtils.h.

{ return Decision::s_filterNodeNameString; }

find()

const Decision * TrigCompositeUtils::find	(	const Decision *	,
		const std::function< bool(const Decision *)> &	filter )

traverses Decision object links for another Decision object fulfilling the prerequisite specified by the filter

Returns

matching Decision object or nullptr

Definition at line 236 of file TrigCompositeUtilsRoot.cxx.

                                                                                                    {
    if ( filter( start ) ) return start;
 
    if ( hasLinkToPrevious(start) ) {
      const std::vector<ElementLink<DecisionContainer>> seeds = getLinkToPrevious(start);
      for (const ElementLink<DecisionContainer>& seedEL : seeds) {
        const Decision* result = find( *seedEL, filter );
        if (result) return result;
      }
    }
    
    return nullptr;
  }

findLink()

template<typename T>

LinkInfo< T > TrigCompositeUtils::findLink	(	const Decision *	start,
		const std::string &	linkName,
		const bool	suppressMultipleLinksWarning = false )

Perform a recursive search for ElementLinks of type T and name 'linkName', starting from Decision object 'start' For the case of multiple links, this function only returns the first one found.

See also

findLinks

Parameters

[in]	start	the Decision Object from where recursive search should begin
[in]	linkName	the name of the ElementLink stored inside one or more DecisionObjects.
[in]	suppressMultipleLinksWarning	findLink will print a warning if more than one ElementLink is found, this can be silenced here.

Returns

LinkInfo A wrapper around an ElementLink and the location in the graph

findLinks() [1/2]

template<typename T>

void TrigCompositeUtils::findLinks	(	const Decision *	start,
		const std::string &	linkName,
		std::vector< LinkInfo< T > > &	links,
		unsigned int	behaviour = TrigDefs::allFeaturesOfType,
		std::set< const xAOD::TrigComposite * > *	fullyExploredFrom = nullptr )

search back the TC links for the object of type T linked to the one of TC (recursively) Populates provided vector with all located links to T of the corresponding linkName.

Parameters

[in]	start	the Decision Object from where recursive search should begin
[in]	linkName	the name of the ElementLink stored inside one or more DecisionObjects.
[in,out]	links	Reference to vector, this will be populated with the found links.
[in]	behavior	TrigDefs::allFeaturesOfType to explore all branches of the navigation graph all the way back to the HLTSeeding, or TrigDefs::lastFeatureOfType to exit early from each branch once a link has been located and collected. Optional OR with TrigDefs::fillDecisions to fill the decisions storage in LinkInfo.
[in,out]	fullyExploredFrom	Optional cache used by the recursive algorithm to avoid exploring each node multiple times.

findLinks() [2/2]

template<typename T>

std::vector< LinkInfo< T > > TrigCompositeUtils::findLinks	(	const Decision *	start,
		const std::string &	linkName,
		unsigned int	behaviour = TrigDefs::allFeaturesOfType )

search back the TC links for the object of type T linked to the one of TC (recursively) This version returns a vector rather than requiring that one be passed to it.

Parameters

[in]	start	the Decision Object from where recursive search should begin
[in]	linkName	the name of the ElementLink stored inside one or more DecisionObjects.
[in]	behaviour	TrigDefs::allFeaturesOfType to explore all branches of the navigation graph all the way back to the HLTSeeding, or TrigDefs::lastFeatureOfType to exit early from each branch once a link has been located and collected. Optional OR with TrigDefs::fillDecisions to fill the decisions storage in LinkInfo.

Returns

Vector with the found links.

getExpressTerminusNode()

const Decision * TrigCompositeUtils::getExpressTerminusNode

(

const DecisionContainer &

container

)

Returns the express-accept navigation node from a collection or nullptr if missing.

Parameters

[in]

container

Collection of navigation nodes

Returns

The express-accept node, or a nullptr if the node is not found

Definition at line 266 of file TrigCompositeUtilsRoot.cxx.

                                                                             {
    return getNodeByName(container, summaryPassExpressNodeName());
  }

getFilter()

std::function< bool(const std::vector< LinkInfo< xAOD::IParticleContainer > > &)> TrigCompositeUtils::getFilter

(

FilterType

filter

)

Get a lambda corresponding to the specified FilterType enum.

Definition at line 69 of file IPartCombItr.cxx.

  {
    switch (filter)
    {
    case FilterType::All:
      return [](const std::vector<LinkInfo<xAOD::IParticleContainer>> &) { return true; };
    case FilterType::UniqueObjects:
      return uniqueObjects;
    case FilterType::UniqueRoIs:
      return uniqueRoIs;
    default:
      throw std::runtime_error("Unhandled FilterType enum value!");
      return {};
    }
  }

getIDFromLeg()

HLT::Identifier TrigCompositeUtils::getIDFromLeg

(

const HLT::Identifier &

legIdentifier

)

Generate the HLT::Identifier which corresponds to the chain name from the leg name.

This can be queried for its DecisionID.

Parameters

legIdentifier

The HLT::Identifier corresponding to the specific leg.

Returns

HLT::Identifier corresponding to the chain. Call .numeric() on this to get the DecisionID.

Definition at line 180 of file TrigCompositeUtilsRoot.cxx.

                                                                 {
    const std::string& name = legIdentifier.name();
    if (isChainId(name)){
      return legIdentifier;
    } else if (isLegId(name)){
      return HLT::Identifier(name.substr(7));
    } else{
      throw std::runtime_error("TrigCompositeUtils::getIDFromLeg legIdentifier '"+name+"' does not start with 'HLT_' or 'leg' ");
    }
  }

getIndexFromLeg() [1/2]

int32_t TrigCompositeUtils::getIndexFromLeg

(

const HLT::Identifier &

legIdentifier

)

Extract the numeric index of a leg identifier.

Parameters

legIdentifier

The HLT::Identifier corresponding to the specific leg.

Returns

Index of the leg, e.g. leg002_HLT_mu50_L1MU20 would return 2. Returns -1 if not a leg identifier or 0 if a chain identifier.

Definition at line 191 of file TrigCompositeUtilsRoot.cxx.

                                                              {
    return getIndexFromLeg(legIdentifier.name());
  }

getIndexFromLeg() [2/2]

int32_t TrigCompositeUtils::getIndexFromLeg

(

const std::string &

name

)

Extract the numeric index of a leg identifier.

Parameters

name	The name of the HLT::Identifier corresponding to the specific leg.

Returns

Index of the leg, e.g. leg002_HLT_mu50_L1MU20 would return 2. Returns -1 if not a leg identifier or 0 if a chain identifier.

Definition at line 195 of file TrigCompositeUtilsRoot.cxx.

                                                 {
    int32_t id = 0;
    if (isChainId(name)){
      // pass
    } else if (isLegId(name)) {
      std::from_chars(name.data()+3, name.data()+6, id);
    } else {
      throw std::runtime_error("TrigCompositeUtils::getIndexFromLeg legIdentifier '"+name+"' does not start with 'HLT_' or 'leg' ");
    }
    return id;
  }

getLinkToPrevious()

const std::vector< ElementLink< DecisionContainer > > TrigCompositeUtils::getLinkToPrevious

(

const Decision *

d

)

returns links to previous decision object 'seed'

Definition at line 157 of file TrigCompositeUtilsRoot.cxx.

                                                                                         {
    return d->objectCollectionLinks<DecisionContainer>( seedString() );
  }

getNameAndIndexFromLeg()

std::pair< std::string, int32_t > TrigCompositeUtils::getNameAndIndexFromLeg

(

const std::string &

name

)

Extract the name and numeric index of a leg identifier.

Parameters

name	The name of the HLT::Identifier corresponding to the specific leg.

Returns

Name and index of the leg, e.g. leg002_HLT_mu50_L1MU20 would return {HLT_mu50_L1MU20, 2}. If not a leg, returns {chainName, 0}. Throws if neither leg nor chain.

Definition at line 207 of file TrigCompositeUtilsRoot.cxx.

                                                                            {
    int32_t id = 0;
    if (isChainId(name)) {
      return {name, id};
    } else if (isLegId(name)) {
      std::from_chars(name.data()+3, name.data()+6, id);
      return {name.substr(7), id};
    } else {
      throw std::runtime_error("TrigCompositeUtils::getIDFromLeg legIdentifier '"+name+"' does not start with 'HLT_' or 'leg' ");
    }
  }

getNodeByName()

const Decision * TrigCompositeUtils::getNodeByName	(	const DecisionContainer &	container,
		const std::string &	nodeName )

Returns the navigation node with a given name from a collection or nullptr if missing.

Parameters

[in]	container	Collection of navigation nodes
[in]	nodeName	The name of the node to find

Returns

The terminus node, or a nullptr if the node is not found

Definition at line 270 of file TrigCompositeUtilsRoot.cxx.

                                                                                               {
    const auto it = std::find_if(container.begin(), container.end(), [&nodeName](const Decision* d){return d->name()==nodeName;});
    if (it==container.end()) {return nullptr;}
    return *it;
  }

getRejectedDecisionNodes()

std::vector< const Decision * > TrigCompositeUtils::getRejectedDecisionNodes	(	const asg::EventStoreType *	eventStore,
		const EventContext &	ctx,
		const std::string &	summaryCollectionKey,
		const DecisionIDContainer &	ids = {},
		const std::set< std::string > &	keysToIgnore = std::set< std::string >() )

Query all DecisionCollections in the event store, locate all Decision nodes in the graph where an object failed selection for a given chain.

Parameters

[in]	eventStore	Pointer to event store within current event context
[in]	ctx	EventContext
[in]	summaryCollectionKey	The primary source of navigation data in the event (i.e the collection which contains the navigation terminus node).
[in]	ids	IDs of chain (if multi-leg chain, include all legs) to located failed decision nodes for. Passing an empty set returns all decision nodes which failed at least one chain.
[in]	keysToIgnore	Set of SG keys of containers which should not be explored by getRejectedDecisionNodes.

Returns

Vector of Decision nodes whose attached feature failed the trigger chain logic for chain with DecisionID id

Definition at line 276 of file TrigCompositeUtilsRoot.cxx.

                                           {
 
    // The following list contains all known summary store identifiers where the graph nodes are spread out over O(100s) or O(1000s)
    // of different SG collections. This is the raw output from running the trigger online.
    // When dealing with this, we need to query eventStore->keys in every event to obtain the full set of collections to process.
    static const std::unordered_set<std::string> knownDistributedSummaryStores{
      "HLTNav_Summary",
      "_HLTNav_Summary"
    };
 
    // The following list contains all known summary store identifiers where all nodes from the graph have been compactified / condensed
    // down into a single container. Here we just have to search this one container.
    static const std::unordered_set<std::string> knownCompactSummaryStores{"HLTNav_Summary_OnlineSlimmed",
      "HLTNav_Summary_ESDSlimmed",
      "HLTNav_Summary_AODSlimmed",
      "HLTNav_Summary_DAODSlimmed",
      "HLTNav_R2ToR3Summary"
    };
 
    std::vector<std::string> keys; // The SG keys we will be exploring to find rejected decision nodes
 
    if (knownDistributedSummaryStores.contains(summaryCollectionKey) or summaryCollectionKey.empty()) {
      
      // If we have a distributed store then we need to query SG to find all keys.
      // This should be a rare case now that we run compactification "online" (i.e. immediately after the trigger has executed) 
#ifndef XAOD_STANDALONE
      // The list of containers we need to read can change on a file-by-file basis (it depends on the SMK)
      // Hence we query SG for all collections rather than maintain a large and ever changing ReadHandleKeyArray
      eventStore->keys<DecisionContainer>(keys);
#else
      throw std::runtime_error("Cannot obtain rejected HLT features in AnalysisBase when reading from uncompactified navigation containers, run trigger navigation slimming first if you really need this.");
#endif
 
    } else if (knownCompactSummaryStores.contains(summaryCollectionKey)) {
 
      keys.push_back(summaryCollectionKey);
 
    } else {
 
      using namespace msgRejected;
      ANA_MSG_WARNING("getRejectedDecisionNodes has not been told about final collection " << summaryCollectionKey << " please update this function. Assuming that it is already compact.");
      // Safest to assume that this is a compact summary store
      keys.push_back(summaryCollectionKey);
 
    }
 
    std::vector<const Decision*> output; // The return vector of identified nodes where one of the chains in 'ids' was rejected
 
    // ReadHandleKey to be re-used in the loop to avoid repeated CLID lookups
    SG::ReadHandleKey<DecisionContainer> containerRHKey("temp");
    if (!containerRHKey.initialize().isSuccess()) {
      throw std::runtime_error("Cannot initialize ReadHandleKey for DecisionContainer");
    }
 
    // Loop over each DecisionContainer,
    for (const std::string& key : keys) {
      // Get and check this container
      if ( ! (key.starts_with( "HLTNav_") ||  key.starts_with("_HLTNav_")) ) {
        continue; // Only concerned about the decision containers which make up the navigation, they have name prefix of HLTNav (or _HLTNav for transient-only mode)
      }
      if (keysToIgnore.contains(key)) {
        continue; // Have been asked to not explore this SG container
      }
 
      // Create ReadHandle for this key
      containerRHKey = key;
      auto containerRH = SG::makeHandle(containerRHKey, ctx);
      if (!containerRH.isValid()) {
        throw std::runtime_error("Unable to retrieve " + key + " from event store.");
      }
 
      for (const Decision* d : *containerRH) {
        if ( not (d->name() == hypoAlgNodeName() or d->name() == comboHypoAlgNodeName()) ) {
          continue; // Only want Decision objects created by HypoAlgs or ComboHypoAlgs
        }
        const std::vector<ElementLink<DecisionContainer>> mySeeds = d->objectCollectionLinks<DecisionContainer>(seedString());
        if (mySeeds.empty()) {
          continue;
        }
        const bool allSeedsValid = std::all_of(mySeeds.begin(), mySeeds.end(), [](const ElementLink<DecisionContainer>& s) { return s.isValid(); });
        if (!allSeedsValid) {
          using namespace msgRejected;
          ANA_MSG_WARNING("A Decision object in " << key << " has invalid seeds. "
            << "The trigger navigation information is incomplete. Skipping this Decision object.");
          continue;
        }
 
        DecisionIDContainer activeChainsIntoThisDecision;
        decisionIDs(*mySeeds[0], activeChainsIntoThisDecision); // Get list of active chains from the first parent
        if (mySeeds.size() > 1) {
          for (size_t i = 1; i < mySeeds.size(); ++i) {
            // If there are more than one parent, we only want to keep the intersection of all of the seeds
            DecisionIDContainer moreActiveChains;
            decisionIDs(*mySeeds[i], moreActiveChains);
            DecisionIDContainer intersection;
            std::set_intersection(activeChainsIntoThisDecision.begin(), activeChainsIntoThisDecision.end(),
              moreActiveChains.begin(), moreActiveChains.end(),
              std::inserter(intersection, intersection.begin()));
            activeChainsIntoThisDecision = std::move(intersection); // Update the output to only be the intersection and continue to any other seeds
          }
        }
        // We now know what chains were active coming into this Decision (d) from ALL seeds
        // This is the logic required for each HypoTool to have activated and checked if its chain passes
        // So the size of activeChainsIntoThisDecision corresponds to the number of HypoTools which will have run
        // What do we care about? A chain, or all chains?
        DecisionIDContainer chainsToCheck;
        if (ids.empty()) { // We care about *all* chains
          chainsToCheck = activeChainsIntoThisDecision;
        } else { // We care about specified chains
          chainsToCheck = ids;
        }
        // We have found a rejected decision node *iff* a chainID to check is *not* present here
        // I.e. the HypoTool for the chain returned a NEGATIVE decision
        DecisionIDContainer activeChainsPassedByThisDecision;
        decisionIDs(d, activeChainsPassedByThisDecision);
        for (const DecisionID checkID : chainsToCheck) {
          if (not activeChainsPassedByThisDecision.contains(checkID) && // I was REJECTED here ...
              activeChainsIntoThisDecision.contains(checkID)) { // ... but PASSSED by all my inputs
            output.push_back(d);
            break;
          }
        }
      }
    }
    return output;
  }

getTerminusNode() [1/2]

const Decision * TrigCompositeUtils::getTerminusNode

(

const DecisionContainer &

container

)

Returns the terminus navigation node from a collection, assuming that the passed collection contains the terminus node.

Parameters

[in]

container

Collection of navigation nodes which contains the terminus node

Returns

The terminus node, or a nullptr if the node is not found

Definition at line 262 of file TrigCompositeUtilsRoot.cxx.

                                                                      {
    return getNodeByName(container, summaryPassNodeName());
  }

getTerminusNode() [2/2]

const Decision * TrigCompositeUtils::getTerminusNode

(

SG::ReadHandle< DecisionContainer > &

container

)

Definition at line 258 of file TrigCompositeUtilsRoot.cxx.

                                                                              {
    return getTerminusNode(*container);
  }

hasLinkToPrevious()

bool TrigCompositeUtils::hasLinkToPrevious

(

const Decision *

d

)

checks if there is at least one 'seed' link to previous object

Definition at line 153 of file TrigCompositeUtilsRoot.cxx.

                                              {
    return d->hasObjectCollectionLinks( seedString() );
  }

hltSeedingNodeName()

const std::string & TrigCompositeUtils::hltSeedingNodeName ( )

inline

Definition at line 424 of file TrigCompositeUtils.h.

{ return Decision::s_hltSeedingNodeNameString; }

hypoAlgNodeName()

const std::string & TrigCompositeUtils::hypoAlgNodeName ( )

inline

Definition at line 427 of file TrigCompositeUtils.h.

{ return Decision::s_hypoAlgNodeNameString; }

initialRecRoIString()

const std::string & TrigCompositeUtils::initialRecRoIString ( )

inline

Definition at line 418 of file TrigCompositeUtils.h.

{ return Decision::s_initialRecRoIString; }

initialRoIString()

const std::string & TrigCompositeUtils::initialRoIString ( )

inline

Definition at line 417 of file TrigCompositeUtils.h.

{ return Decision::s_initialRoIString; }

inputMakerNodeName()

const std::string & TrigCompositeUtils::inputMakerNodeName ( )

inline

Definition at line 426 of file TrigCompositeUtils.h.

{ return Decision::s_inputMakerNodeNameString; }

insertDecisionIDs() [1/2]

void TrigCompositeUtils::insertDecisionIDs	(	const Decision *	src,
		Decision *	dest )

Appends the decision IDs of src to the dest decision object.

Warning

Performing merging of IDs and solving the duples (via set) This helps when making copies of Decision obejcts

Definition at line 78 of file TrigCompositeUtilsRoot.cxx.

                                                              {
    DecisionIDContainer srcIds;
    decisionIDs( src, srcIds ); // Now stored in a set
    insertDecisionIDs( srcIds, dest);
  }

insertDecisionIDs() [2/2]

void TrigCompositeUtils::insertDecisionIDs	(	const DecisionIDContainer &	src,
		Decision *	dest )

Appends the decision IDs of src to the dest decision object.

Warning

Performing merging of IDs and solving the duples (via set)

Definition at line 84 of file TrigCompositeUtilsRoot.cxx.

                                                                           {
    DecisionIDContainer collateIDs;
    // Decision are xAOD objects backed by a std::vector
    // Here we use a std::set to de-duplicate IDs from src and dest before setting dest
    decisionIDs( dest, collateIDs ); // Set operation 1. Get from dest
    collateIDs.insert( src.begin(), src.end() ); // Set operation 2. Get from src
    std::vector<DecisionID>& vdest = decisionIDs( dest );
    // Clear and reserve target
    vdest.clear();
    vdest.reserve(collateIDs.size());
    // Copy from set to (ordered) vector
    vdest.insert( vdest.end(), collateIDs.begin(), collateIDs.end() );
  }

isAnyIDPassing()

bool TrigCompositeUtils::isAnyIDPassing	(	const Decision *	d,
		const DecisionIDContainer &	required )

Checks if any of the DecisionIDs passed in arg required is availble in Decision object.

Definition at line 109 of file TrigCompositeUtilsRoot.cxx.

                                                                                 {
    for ( DecisionID id : readOnlyAccessor( *d ) ) {
      if ( required.find( id ) != required.end() ) {
        return true;
      }
    }
    return false;
  }

isChainId() [1/2]

bool TrigCompositeUtils::isChainId

(

const HLT::Identifier &

chainIdentifier

)

Recognise whether the HLT identifier corresponds to a whole chain.

Parameters

chainIdentifier

The HLT::Identifier corresponding to the specific ID.

Returns

True if chain-ID, else false

Definition at line 227 of file TrigCompositeUtilsRoot.cxx.

                                                       {
    return isChainId(chainIdentifier.name());
  }

isChainId() [2/2]

bool TrigCompositeUtils::isChainId

(

const std::string &

name

)

Recognise whether the HLT identifier corresponds to a whole chain.

Parameters

name	The name of the HLT::Identifier corresponding to the specific ID.

Returns

True if chain-ID, else false

Definition at line 231 of file TrigCompositeUtilsRoot.cxx.

                                        {
    return name.starts_with("HLT_");
  }

isLegId() [1/2]

bool TrigCompositeUtils::isLegId

(

const HLT::Identifier &

legIdentifier

)

Recognise whether the chain ID is a leg ID.

Parameters

legIdentifier

The HLT::Identifier corresponding to the specific ID.

Returns

True if leg-ID, else false

Definition at line 219 of file TrigCompositeUtilsRoot.cxx.

                                                   {
    return isLegId(legIdentifier.name());
  }

isLegId() [2/2]

bool TrigCompositeUtils::isLegId

(

const std::string &

name

)

Recognise whether the chain ID is a leg ID.

Parameters

name	The name of the HLT::Identifier corresponding to the specific ID.

Returns

True if leg-ID, else false

Definition at line 223 of file TrigCompositeUtilsRoot.cxx.

                                      {
    return name.starts_with("leg");
  }

linkToPrevious() [1/2]

void TrigCompositeUtils::linkToPrevious	(	Decision *	d,
		const Decision *	dOld,
		const EventContext &	ctx )

Links to the previous object, 'seed' decision provided explicitly.

Definition at line 149 of file TrigCompositeUtilsRoot.cxx.

                                                                                    {
    d->addObjectCollectionLink(seedString(), decisionToElementLink(dOld, ctx));
  }

linkToPrevious() [2/2]

void TrigCompositeUtils::linkToPrevious	(	Decision *	d,
		const std::string &	previousCollectionKey,
		size_t	previousIndex )

Links to the previous object, location of previous 'seed' decision supplied by hand.

Definition at line 140 of file TrigCompositeUtilsRoot.cxx.

                                                                                                    {
    ElementLink<DecisionContainer> seed = ElementLink<DecisionContainer>( previousCollectionKey, previousIndex );
    if (!seed.isValid()) {
      throw std::runtime_error("TrigCompositeUtils::linkToPrevious Invalid Decision Link key or index provided");
    } else {
      d->addObjectCollectionLink(seedString(), seed);
    }
  }

newDecisionIn() [1/2]

Decision * TrigCompositeUtils::newDecisionIn	(	DecisionContainer *	dc,
		const Decision *	dOld,
		const std::string &	name,
		const EventContext &	ctx )

Helper method to create a Decision object, place it in the container and return a pointer to it.

RoI, view and feature links will be copied from the previous to the new decision and a "seed" link made between them

• the container in which to place the new Decision
• the previous decision to which the new one should be connected
• the name is assigned to the TC object Note that the supplied DecisionContainer must have been recorded in the event store.

Definition at line 53 of file TrigCompositeUtilsRoot.cxx.

                                                                                                                          {
    Decision* dNew =  newDecisionIn( dc, name );
    linkToPrevious(dNew, dOld, ctx); // Sets up link to 'seed' collection, points to dOld
    return dNew;
  }

newDecisionIn() [2/2]

Decision * TrigCompositeUtils::newDecisionIn	(	DecisionContainer *	dc,
		const std::string &	name = "" )

Helper method to create a Decision object, place it in the container and return a pointer to it.

This is to make this: auto d = newDecisionIn(output); instead of: auto d = new Decision; output->push_back(d); If provided, the name is assigned to the TC object Note that the supplied DecisionContainer must have been recorded in the event store.

Definition at line 44 of file TrigCompositeUtilsRoot.cxx.

                                                                          {
    Decision * x = new Decision;
    dc->push_back( x );
    if ( ! name.empty() ) {
      x->setName( name );
    }
    return x;
  }

passed()

bool TrigCompositeUtils::passed	(	DecisionID	id,
		const DecisionIDContainer &	idSet )

checks if required decision ID is in the set of IDs in the container

Definition at line 118 of file TrigCompositeUtilsRoot.cxx.

                                                                 {
    return idSet.find( id ) != idSet.end();
  }

passedDecisionIDs()

template<typename T>

DecisionIDContainer TrigCompositeUtils::passedDecisionIDs	(	const Decision *	d,
		const T &	required )

return DecisionIDs in Decision object that match the required ones

• required is a container of (values convertable to) DecisionIDs

recursiveFlagForThinning()

void TrigCompositeUtils::recursiveFlagForThinning	(	NavGraph &	node,
		const bool	keepOnlyFinalFeatures,
		const bool	removeEmptySteps,
		const std::vector< std::string > &	nodesToDrop )

Used by trigger navigation thinning.

Recursive function. Explore all possible paths back through the navigation graph from the given node. Flag nodes as "keep" during the exploration, nodes not flagged as "keep" will be thinned if thin() is called on the NavGraph.

Parameters

[in]	keepOnlyFinalFeatures	Set this to true for analysis-level slimming, when only trigger-matching is needed downstream.
[in]	nodesToDrop	Optional list of node names. Nodes whose name matches an entry in this list will never be flagged as "keep".

Definition at line 459 of file TrigCompositeUtilsRoot.cxx.

  {
    std::set<NavGraphNode*> fullyExploredFrom;
    for (NavGraphNode* finalNode : graph.finalNodes()) {
      recursiveFlagForThinningInternal(finalNode, /*modeKeep*/true, fullyExploredFrom, keepOnlyFinalFeatures, removeEmptySteps, nodesToDrop);
    }
  }

recursiveFlagForThinningInternal()

void TrigCompositeUtils::recursiveFlagForThinningInternal	(	NavGraphNode *	node,
		bool	modeKeep,
		std::set< NavGraphNode * > &	fullyExploredFrom,
		const bool	keepOnlyFinalFeatures,
		const bool	removeEmptySteps,
		const std::vector< std::string > &	nodesToDrop )

Used by recursiveFlagForThinning.

See also

recursiveFlagForThinning @paramp[inout] fullyExploredFrom Cache to avoid exploring graph branches more than once

Definition at line 471 of file TrigCompositeUtilsRoot.cxx.

  {
 
    // If modeKeep == true, then by default we are KEEPING the nodes as we walk up the navigation (towards L1),
    // otherwise by default we are THINNING the nodes
    bool keep = modeKeep;
 
    // The calls to node->node() here are going from the transient NavGraphNode 
    // to the underlying const Decision* from the input collection. Cache these in local stack vars for better readability.
 
    const Decision* const me = node->node();
    const Decision* const myFirstParent = (node->seeds().size() ? node->seeds().at(0)->node() : nullptr); 
    const Decision* const myFirstChild = (node->children().size() ? node->children().at(0)->node() : nullptr); 
 
    // KEEP Section: The following code blocks may override the modeKeep default by setting keep=True for this node.
 
    if (keepOnlyFinalFeatures) {
      // Check if we have reached the first feature
      if ( modeKeep == true && (me->hasObjectLink(featureString()) || me->hasObjectLink("subfeature")) ) {
        // Just to be explicit, we keep this node
        keep = true;
 
        // Special BLS case: The bphysics object is attached exceptionally at the ComboHypo.
        // We want to keep going up one more level in this case to get the Feature node too (we save the 4-vec of the BPhys and both of the muons/electrons)
        const bool specialBphysCase = (me->name() == comboHypoAlgNodeName());
 
        // Special R2->R3 case: We can get steps with dummy features, these feature links point back to the same node.
        // First check again the feature, with an addition requirement on the feature CLID. Then check if the feature points back to the node.
        const bool specialR2toR3Case = (me->hasObjectLink(featureString(), ClassID_traits<DecisionContainer>::ID()) && me->object<Decision>(featureString()) == me);
 
        // We change the default behaviour to be modeKeep = false (unless we want to explore up one more level for BLS's special case
        // or to the next feature for the R2->R3 special case) such that by default we start to NOT flag all the parent nodes to be kept
        if (!specialBphysCase && !specialR2toR3Case) {
          modeKeep = false;
        }
      }
    }
 
    // We always by default keep the initial node from the HLTSeeding, but this may be overridden below by nodesToDrop
    if (me->name() == hltSeedingNodeName()) {
      keep = true;
    }
 
    // DROP Section: The following code blocks may override both the current modeKeep default and the above KEEP section by setting keep=False for this node.
 
    // Check also against NodesToDrop
    for (const std::string& toDrop : nodesToDrop) {
      if (me->name() == toDrop) {
        keep = false;
        break;
      }
    }
 
    // Check against RemoveEmptySteps
    // The signature we look for here is a InputMaker node connected directly to a ComboHypo node 
    // The key thing to identify is NO intermediate Hypo node
    // This structure is created in Steps where some chain legs are running reconstruction, but other legs are idle - either due to
    // menu alignment, or due to the legs being of different length.
    // For passed chains, there is little point keeping these CH and IM nodes on the idle legs. So we have the option of slimming them here.
    // First for the ComboHypo ...
    if (removeEmptySteps && me->name() == comboHypoAlgNodeName() && myFirstParent && myFirstParent->name() == inputMakerNodeName()) {
      keep = false;
    }
    // ... and also for the InputMaker, with flipped logic.
    if (removeEmptySteps && me->name() == inputMakerNodeName() && myFirstChild && myFirstChild->name() == comboHypoAlgNodeName()) {
      keep = false;
    }
 
    // Check against RemoveEmptySteps
    // Check for the R2->R3 empty step case
    if (removeEmptySteps 
      && me->name() == hypoAlgNodeName()
      && me->hasObjectLink(featureString(), ClassID_traits<DecisionContainer>::ID())
      && me->object<Decision>(featureString()) == me)
    {
      keep = false;
    }
    // ... and also for the InputMaker
    if (removeEmptySteps 
      && me->name() == inputMakerNodeName()
      && myFirstChild
      && myFirstChild->name() == hypoAlgNodeName()
      && myFirstChild->hasObjectLink(featureString(), ClassID_traits<DecisionContainer>::ID())
      && myFirstChild->object<Decision>(featureString()) == myFirstChild)
    {
      keep = false;
    }
 
    // APPLICATION Section:
 
    if (keep) {
      node->keep(); // Inform the node that it should NOT be thinned away.
    }
 
    for (NavGraphNode* seed : node->seeds()) {
#if TRIGCOMPUTILS_ENABLE_EARLY_EXIT == 1
      // NOTE: This code block cuts short the recursive graph exploration for any node which has already been fully-explored-from.
      // 
      // If we are keeping final features, then processing each node exactly once is actually insufficient.
      // This is because we may reach a node, X, with a feature which is penultimate/generally-non-final for some chain, A,
      // but then later on we may follow Terminus->SummaryFilter->Hypothesis(X) for some chain, B, where this same
      // feature from X _is_ the final-feature for chain B. Here we would not process node X again as we have already dealt with it.
      // But we need to process it again as for chain B, modeKeep==true still and chain B wants to flag the node as keep().
      //
      // We only however need to force the exploration while we are in the mode where we are nominally keeping nodes (modeKeep == true).
      // Once we have switched to dropping nodes by default, we should be OK to once again skip over nodes which we already processed.
      // The only thing we should be keeping when modeKeep == false is the L1 node, any this is not dependent on path.
      //
      // See: ATR-28061
      bool allowEarlyExit = true;
      if (keepOnlyFinalFeatures) {
        allowEarlyExit = (modeKeep == false);
      }
      if (allowEarlyExit && fullyExploredFrom.count(seed) == 1) {
        // We have fully explored this branch
        continue;
      }
#endif
      // Recursively call all the way up the graph to the initial nodes from the HLTSeeding
      recursiveFlagForThinningInternal(seed, modeKeep, fullyExploredFrom, keepOnlyFinalFeatures, removeEmptySteps, nodesToDrop);
    }
 
    // Have fully explored down from this point
    fullyExploredFrom.insert(node);
  }

recursiveGetDecisions()

void TrigCompositeUtils::recursiveGetDecisions	(	const Decision *	node,
		NavGraph &	navGraph,
		const DecisionIDContainer &	ids = {},
		const bool	enforceDecisionOnStartNode = true )

Search back in time from "node" and locate all paths back through Decision objects for a given chain.

Parameters

[in]	node	The Decision object to start the search from. Typically this will be one of the terminus objects from the HLTNav_Summary.
[in,out]	navPaths	Holds a sub-graph of the full navigation graph, filtered by DecisionID. An already partially populated graph may be provided as input.
[in]	ids	Optional DecisionIDContainer of Chains / Chain-Legs to trace through the navigation. If omitted, no chain requirement will be applied.
[in]	enforceDecisionOnStartNode	If the check of DecisionID should be carried out on the start node. enforceDecisionOnStartNode should be true if navigating for a trigger which passed (e.g. starting from HLTPassRaw) enforceDecisionOnStartNode should be false if navigating for a trigger which failed but whose failing start node(s) were recovered via getRejectedDecisionNodes

Definition at line 446 of file TrigCompositeUtilsRoot.cxx.

                                           {
 
    std::set<const Decision*> fullyExploredFrom;
    // Note: we do not require navGraph to be an empty graph. We can extend it.
    recursiveGetDecisionsInternal(start, /*comingFrom*/nullptr, navGraph, fullyExploredFrom, ids, enforceDecisionOnStartNode);
    
    return;
  }

recursiveGetDecisionsInternal()

void TrigCompositeUtils::recursiveGetDecisionsInternal	(	const Decision *	node,
		const Decision *	comingFrom,
		NavGraph &	navGraph,
		std::set< const Decision * > &	fullyExploredFrom,
		const DecisionIDContainer &	ids,
		const bool	enforceDecisionOnNode )

Used by recursiveGetDecisions.

See also

recursiveGetDecisions

Parameters

comingFrom

The parent node which has a link in the navigation to this "node" @paramp[inout] fullyExploredFrom Cache to avoid exploring graph branches more than once

Definition at line 407 of file TrigCompositeUtilsRoot.cxx.

                                      {
 
    // Does this Decision satisfy the chain requirement?
    if (enforceDecisionOnNode && ids.size() != 0 && !isAnyIDPassing(node, ids)) {
      return; // Stop propagating down this leg. It does not concern the chain with DecisionID = id
    }
 
    // This Decision object is part of this path through the Navigation
    navGraph.addNode(node, comingFrom);
 
#if TRIGCOMPUTILS_ENABLE_EARLY_EXIT == 1
    // Note we have to do this check here (after calling addNode) rather than just before calling recursiveGetDecisionsInternal
    if (fullyExploredFrom.count(node) == 1) {
      // We have fully explored this branch
      return;
    }
#endif
    
    // Continue to the path(s) by looking at this Decision object's seed(s)
    if ( hasLinkToPrevious(node) ) {
      // Do the recursion
      for ( const ElementLink<DecisionContainer>& seed : getLinkToPrevious(node)) {
        const Decision* seedDecision = *(seed); // Dereference ElementLink
        // Sending true as final parameter for enforceDecisionOnStartNode as we are recursing away from the supplied start node
        recursiveGetDecisionsInternal(seedDecision, node, navGraph, fullyExploredFrom, ids, /*enforceDecisionOnNode*/ true);
      }
    }
 
    // Have fully explored down from this point
    fullyExploredFrom.insert(node);
 
    return;
  }

recursiveGetFeaturesOfType()

template<class CONTAINER>

const std::vector< LinkInfo< CONTAINER > > TrigCompositeUtils::recursiveGetFeaturesOfType	(	const NavGraph &	navGraph,
		const std::string &	containerSGKey = "",
		const unsigned int	behaviour = TrigDefs::lastFeatureOfType,
		const std::string &	navElementLinkKey = featureString(),
		const DecisionIDContainer &	chainIDs = DecisionIDContainer() )

DEPRECATED.

Extract features from the supplied navGraph (obtained through recursiveGetDecisions).

Parameters

[in]	navGraph	Sub-graph of the trigger navigation which is to be considered.
[in]	behavior	TrigDefs::allFeaturesOfType to explore all branches of the navigation graph all the way back to the HLTSeeding, or TrigDefs::lastFeatureOfType to exit early from each branch once a link has been located and collected. Optional OR with TrigDefs::fillDecisions to fill the decisions storage in LinkInfo.
[in]	featureName	Optional name of feature link as saved online. The "feature" link is enforced, others may have been added.
[in]	chains	Optional set of Chain IDs which features are being requested for. Used to set the ActiveState of returned LinkInfo objects.

Returns

Typed vector of LinkInfo. Each LinkInfo wraps an ElementLink to a feature and a pointer to the feature's Decision object in the navigation.

recursiveGetFeaturesOfTypeInternal()

template<class CONTAINER>

void TrigCompositeUtils::recursiveGetFeaturesOfTypeInternal	(	std::vector< LinkInfo< CONTAINER > > &	features,
		std::set< const NavGraphNode * > &	fullyExploredFrom,
		const NavGraphNode *	navGraphNode,
		const std::string &	containerSGKey,
		const unsigned int	behaviour,
		const std::string &	navElementLinkKey,
		const DecisionIDContainer &	chainIDs )

DEPRECATED.

See also

recursiveGetFeaturesOfType

Internal implementation called by recursiveGetFeaturesOfType, and by itself

Parameters

[in,out]	features	The ultimate return vector. New links are to be appended.
[in,out]	fullyExploredFrom	Cache of graph nodes which have been fully explored, and hence don't need exploring again should they show up.
[in]	navGraphNode	The current node in the navGraph which is being explored.

roiString()

const std::string & TrigCompositeUtils::roiString ( )

inline

Definition at line 419 of file TrigCompositeUtils.h.

{ return Decision::s_roiString; }

seedString()

const std::string & TrigCompositeUtils::seedString ( )

inline

Definition at line 422 of file TrigCompositeUtils.h.

{ return Decision::s_seedString; }

summaryFilterNodeName()

const std::string & TrigCompositeUtils::summaryFilterNodeName ( )

inline

Definition at line 429 of file TrigCompositeUtils.h.

{ return Decision::s_summaryFilterNodeNameString; }

summaryPassExpressNodeName()

const std::string & TrigCompositeUtils::summaryPassExpressNodeName ( )

inline

Definition at line 431 of file TrigCompositeUtils.h.

{ return Decision::s_summaryPassExpressNodeNameString; }

summaryPassNodeName()

const std::string & TrigCompositeUtils::summaryPassNodeName ( )

inline

Definition at line 430 of file TrigCompositeUtils.h.

{ return Decision::s_summaryPassNodeNameString; }

summaryPrescaledNodeName()

const std::string & TrigCompositeUtils::summaryPrescaledNodeName ( )

inline

Definition at line 432 of file TrigCompositeUtils.h.

{ return Decision::s_summaryPrescaledNodeNameString; }

typelessFindLink() [1/2]

bool TrigCompositeUtils::typelessFindLink	(	const Decision *	start,
		const std::string &	linkName,
		sgkey_t &	key,
		CLID &	clid,
		Decision::index_type &	index,
		const Decision *&	source,
		const bool	suppressMultipleLinksWarning = false )

Perform a recursive search for ElementLinks of any time and name 'linkName', starting from Decision object 'start' Returns the link data in a typeless way, as raw key, index and CLID values.

These may be reconstituted into a typed ElementLink. For the case of multiple links, this function only returns the first one found.

See also

findLinks

Parameters

[in]	start	the Decision Object from where recursive search should begin
[in]	linkName	the name of the ElementLink stored inside one or more DecisionObjects.
[out]	key	The storegate key (hash) of the located link's collection
[out]	clid	The class ID of the link's collection
[out]	index	The link's index inside its collection.
[out]	source	The link's originating Decision object.
[in]	suppressMultipleLinksWarning	findLink will print a warning if more than one ElementLink is found, this can be silenced here.

Returns

True if a link was located

Definition at line 747 of file TrigCompositeUtilsRoot.cxx.

  {
    using namespace msgFindLink;
    // We use findLink in cases where there is only one link to be found, or if there are multiple then we 
    // only want the most recent.
    // Hence we can supply TrigDefs::lastFeatureOfType.                                                         /--> parent3(link)
    // We can still have more then one link found if there is a branch in the navigation. E.g. start --> parent1 --> parent2(link)
    // If both parent2 and parent3 possessed an admissible ElementLink, then the warning below will trigger, and only one of the
    // links will be returned (whichever of parent2 or parent3 happened to be the first seed of parent1).
    std::vector<sgkey_t> keyVec;
    std::vector<CLID> clidVec;
    std::vector<Decision::index_type> indexVec;
    std::vector<const Decision*> sourceVec;
    std::set<const xAOD::TrigComposite*> fullyExploredFrom;
 
    const bool result = typelessFindLinks(start, linkName, keyVec, clidVec, indexVec, sourceVec, TrigDefs::lastFeatureOfType, &fullyExploredFrom);
    if (!result) {
      return false; // Nothing found
    }
 
    if (keyVec.size() > 1 && !suppressMultipleLinksWarning) {
      ANA_MSG_WARNING (keyVec.size() << " typeless links found for " << linkName
                       << " returning the first link, consider using findLinks.");
    }
    key = keyVec.at(0);
    clid = clidVec.at(0);
    index = indexVec.at(0);
    source = sourceVec.at(0);
    return true; 
  }

typelessFindLink() [2/2]

bool TrigCompositeUtils::typelessFindLink	(	const NavGraph &	subGraph,
		const std::string &	linkName,
		sgkey_t &	key,
		CLID &	clid,
		Decision::index_type &	index,
		const Decision *&	source,
		const bool	suppressMultipleLinksWarning = false )

Version of typelessFindLink which operates on a sub-graph (described by the NavGraph), rather than the whole navigation graph.

If the supplied NavGraph has more than one entry point, then all will be explored.

Definition at line 785 of file TrigCompositeUtilsRoot.cxx.

  {
    using namespace msgFindLink;
    // Note: This function should be the same as its predecessor, just using a NavGraph to start rather than a Decision*
    // As a result, it can search from more than one Decision* (the NavGraph may have more than one final node)
    // but it will still warn if this results in more than one link being located.
    std::vector<sgkey_t> keyVec;
    std::vector<uint32_t> clidVec;
    std::vector<Decision::index_type> indexVec;
    std::vector<const Decision*> sourceVec;
    std::set<const Decision*> fullyExploredFrom;
 
    bool result = false;
    for (const NavGraphNode* finalNode : subGraph.finalNodes()) {
      result |= typelessFindLinks(finalNode, linkName, keyVec, clidVec, indexVec, sourceVec, TrigDefs::lastFeatureOfType, &fullyExploredFrom);
    }
 
    if (!result) {
      return false; // Nothing found
    }
 
    if (keyVec.size() > 1 && !suppressMultipleLinksWarning) {
      ANA_MSG_WARNING (keyVec.size() << " typeless links found for " << linkName
                       << " returning the first link, consider using findLinks.");
    }
    key = keyVec.at(0);
    clid = clidVec.at(0);
    index = indexVec.at(0);
    source = sourceVec.at(0);
    return true; 
  }

typelessFindLinks() [1/2]

bool TrigCompositeUtils::typelessFindLinks	(	const Decision *	start,
		const std::string &	linkName,
		std::vector< sgkey_t > &	keyVec,
		std::vector< CLID > &	clidVec,
		std::vector< Decision::index_type > &	indexVec,
		std::vector< const Decision * > &	sourceVec,
		const unsigned int	behaviour = TrigDefs::allFeaturesOfType,
		std::set< const Decision * > *	fullyExploredFrom = nullptr )

search back the TC links for the object of type T linked to the one of TC (recursively) Returns the link data in a typeless way, as raw key, index and CLID values.

These may be reconstituted into a typed ElementLink. Populates provided vectors with all located links of the corresponding linkName.

Parameters

[in]	start	the Decision Object from where recursive search should begin
[in]	linkName	the name of the ElementLink stored inside one or more DecisionObjects.
[in,out]	keyVec	The return vector of the storegate key (hash) of the located link's collection
[in,out]	clidVec	The return vector of the class ID of the link's collection
[in,out]	indexVec	The return vector of the link's index inside its collection.
[in,out]	sourceVec	The return vector of the link's originating Decision object.
[in]	behavior	TrigDefs::allFeaturesOfType to explore all branches of the navigation graph all the way back to the HLTSeeding, or TrigDefs::lastFeatureOfType to exit early from each branch once a link has been located and collected.
[in,out]	fullyExploredFrom	Optional cache used by the recursive algorithm to avoid exploring each node multiple times.

Definition at line 603 of file TrigCompositeUtilsRoot.cxx.

  {
    using namespace msgFindLink;
 
    // As the append vectors are user-supplied, perform some input validation. 
    if (keyVec.size() != clidVec.size() or clidVec.size() != indexVec.size()) {
      ANA_MSG_WARNING("In typelessFindLinks, keyVec, clidVec, indexVec must all be the same size. Instead have:"
        << keyVec.size() << ", " << clidVec.size()  << ", " << indexVec.size());
      return false;
    }
 
    // Locate named links. Both collections of links and individual links are supported.
    bool found = typelessFindLinksCommonLinkCollection(start, linkName, keyVec, clidVec, indexVec, sourceVec);
   
    // Early exit
    if (found && (behaviour & TrigDefs::lastFeatureOfType)) {
      return true;
    }
    // If not Early Exit, then recurse
    for (const ElementLink<DecisionContainer>& seed : getLinkToPrevious(start)) {
#if TRIGCOMPUTILS_ENABLE_EARLY_EXIT == 1
      if (fullyExploredFrom != nullptr) {
        // We only need to recursively explore back from each node in the graph once.
        // We can keep a record of nodes which we have already explored, these we can safely skip over.
        if (fullyExploredFrom->count(*seed) == 1) {
          continue; 
        }
      }
#endif
      found |= typelessFindLinks(*seed, linkName, keyVec, clidVec, indexVec, sourceVec, behaviour, fullyExploredFrom);
    }
    // Fully explored this node
    if (fullyExploredFrom != nullptr) {
      fullyExploredFrom->insert(start);
    }
    return found;
  }

typelessFindLinks() [2/2]

bool TrigCompositeUtils::typelessFindLinks	(	const NavGraphNode *	start,
		const std::string &	linkName,
		std::vector< sgkey_t > &	keyVec,
		std::vector< CLID > &	clidVec,
		std::vector< Decision::index_type > &	indexVec,
		std::vector< const Decision * > &	sourceVec,
		const unsigned int	behaviour,
		std::set< const Decision * > *	fullyExploredFrom )

Version of typelessFindLinks which operates on a sub-graph (entered via the supplied NavGraphNode), rather than the whole navigation graph.

Definition at line 649 of file TrigCompositeUtilsRoot.cxx.

  {
    using namespace msgFindLink;
 
    // As the append vectors are user-supplied, perform some input validation. 
    if (keyVec.size() != clidVec.size() or clidVec.size() != indexVec.size()) {
      ANA_MSG_WARNING("In typelessFindLinks, keyVec, clidVec, indexVec must all be the same size. Instead have:"
        << keyVec.size() << ", " << clidVec.size()  << ", " << indexVec.size());
      return false;
    }
 
    const Decision* start_decisionObject = start->node(); 
    // Locate named links. Both collections of links and individual links are supported.
    bool found = typelessFindLinksCommonLinkCollection(start_decisionObject, linkName, keyVec, clidVec, indexVec, sourceVec);
 
    // Early exit
    if (found && (behaviour & TrigDefs::lastFeatureOfType)) {
      return true;
    }
    // If not Early Exit, then recurse
    for (const NavGraphNode* seed : start->seeds()) {
#if TRIGCOMPUTILS_ENABLE_EARLY_EXIT == 1
      if (fullyExploredFrom != nullptr) {
        // We only need to recursively explore back from each node in the graph once.
        // We can keep a record of nodes which we have already explored, these we can safely skip over.
        const Decision* seed_decisionObject = seed->node(); 
        if (fullyExploredFrom->count(seed_decisionObject) == 1) {
          continue; 
        }
      }
#endif
      found |= typelessFindLinks(seed, linkName, keyVec, clidVec, indexVec, sourceVec, behaviour, fullyExploredFrom);
    }
    // Fully explored this node
    if (fullyExploredFrom != nullptr) {
      fullyExploredFrom->insert(start_decisionObject);
    }
    return found;
  }

typelessFindLinksCommonLinkCollection()

bool TrigCompositeUtils::typelessFindLinksCommonLinkCollection	(	const Decision *	start,
		const std::string &	linkName,
		std::vector< sgkey_t > &	keyVec,
		std::vector< CLID > &	clidVec,
		std::vector< Decision::index_type > &	indexVec,
		std::vector< const Decision * > &	sourceVec )

Common functionality shared by both typelessFindLinks interfaces Returns true if at least one link was collected.

Definition at line 697 of file TrigCompositeUtilsRoot.cxx.

  {
    bool found = false;
    std::vector<sgkey_t> tmpKeyVec;
    std::vector<CLID> tmpClidVec;
    std::vector<Decision::index_type> tmpIndexVec;
    if (start->hasObjectCollectionLinks(linkName)) {
      found = start->typelessGetObjectCollectionLinks(linkName, tmpKeyVec, tmpClidVec, tmpIndexVec);
    }
    if (start->hasObjectLink(linkName)) {
      sgkey_t tmpKey{0};
      CLID tmpClid{0};
      Decision::index_type tmpIndex{0};
      found |= start->typelessGetObjectLink(linkName, tmpKey, tmpClid, tmpIndex);
      tmpKeyVec.push_back(tmpKey);
      tmpClidVec.push_back(tmpClid);
      tmpIndexVec.push_back(tmpIndex);
    }
    // De-duplicate
    for (size_t tmpi = 0; tmpi < tmpKeyVec.size(); ++tmpi) {
      bool alreadyAdded = false;
      const sgkey_t tmpKey = tmpKeyVec.at(tmpi);
      const CLID tmpClid = tmpClidVec.at(tmpi);
      const Decision::index_type tmpIndex = tmpIndexVec.at(tmpi);
      for (size_t veci = 0; veci < keyVec.size(); ++veci) {
        if (SG::sgkeyEqual (keyVec.at(veci), tmpKey)
          and clidVec.at(veci) == tmpClid
          and indexVec.at(veci) == tmpIndex)
        {
          alreadyAdded = true;
          break;
        }
      }
      if (!alreadyAdded) {
        keyVec.push_back( tmpKey );
        clidVec.push_back( tmpClid );
        indexVec.push_back( tmpIndex );
        sourceVec.push_back( start );
      }
    }
    return found;
  }

uniqueDecisionIDs()

void TrigCompositeUtils::uniqueDecisionIDs

(

Decision *

dest

)

Make unique list of decision IDs of dest Decision object.

Warning

Use vector->set->vector This helps solving multiple inserts of the Decision obejcts

Definition at line 98 of file TrigCompositeUtilsRoot.cxx.

                                         {
    // Re-use above insertDecisionIDs method.
    // This implicitly performs de-duplication
    return insertDecisionIDs(dest, dest);
  }

uniqueInitialRoIs()

bool TrigCompositeUtils::uniqueInitialRoIs

(

const std::vector< LinkInfo< xAOD::IParticleContainer > > &

links

)

Helper function that returns true if no objects share an initial RoI.

Definition at line 43 of file IPartCombItr.cxx.

  {
    std::set<std::pair<uint32_t, uint32_t>> seen;
    for (const auto &info : links)
    {
      LinkInfo<TrigRoiDescriptorCollection> roi = findLink<TrigRoiDescriptorCollection>(info.source, initialRoIString());
      if (!seen.insert(std::make_pair(roi.link.persKey(), roi.link.persIndex())).second)
        // Insert returns false if that item already exists in it
        return false;
    }
    return true;
  }

uniqueObjects()

bool TrigCompositeUtils::uniqueObjects

(

const std::vector< LinkInfo< xAOD::IParticleContainer > > &

links

)

Helper fucntion that returns true if no objects are repeated.

Definition at line 34 of file IPartCombItr.cxx.

  {
    std::set<const xAOD::IParticle *> seen;
    for (const auto &info : links)
      if (!seen.insert(*info.link).second)
        return false;
    return true;
  }

uniqueRoIs()

bool TrigCompositeUtils::uniqueRoIs

(

const std::vector< LinkInfo< xAOD::IParticleContainer > > &

links

)

Helper function that returns true if no objects share a final RoI.

Definition at line 56 of file IPartCombItr.cxx.

  {
    std::set<std::pair<uint32_t, uint32_t>> seen;
    for (const auto &info : links)
    {
      LinkInfo<TrigRoiDescriptorCollection> roi = findLink<TrigRoiDescriptorCollection>(info.source, "roi");
      if (!seen.insert(std::make_pair(roi.link.persKey(), roi.link.persIndex())).second)
        // Insert returns false if that item already exists in it
        return false;
    }
    return true;
  }

viewString()

const std::string & TrigCompositeUtils::viewString ( )

inline

Definition at line 420 of file TrigCompositeUtils.h.

{ return Decision::s_viewString; }