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. NavGraph is populated from, and forms a sub-graph over the full Run 3 trigger navigation graph in a single event. Requirements on specific chains, and the specification of allowable graph entry-points are considered in the construction of the NavGraph sub-graph. Once one of these sub-graphs is fully populated to a given specification, it is searched by the feature-retrieval code to find features. 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...

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

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

Functions
bool	uniqueObjects (const std::vector< LinkInfo< xAOD::IParticleContainer >> &links)
	Helper fucntion that returns true if no objects are repeated. More...
bool	uniqueInitialRoIs (const std::vector< LinkInfo< xAOD::IParticleContainer >> &links)
	Helper function that returns true if no objects share an initial RoI. More...
bool	uniqueRoIs (const std::vector< LinkInfo< xAOD::IParticleContainer >> &links)
	Helper function that returns true if no objects share a final RoI. More...
std::function< bool(const std::vector< LinkInfo< xAOD::IParticleContainer >> &)>	getFilter (FilterType filter)
	Get a lambda corresponding to the specified FilterType enum. More...
SG::WriteHandle< DecisionContainer >	createAndStore (const SG::WriteHandleKey< DecisionContainer > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
	Creates and right away records the DecisionContainer with the key. More...
void	createAndStore (SG::WriteHandle< DecisionContainer > &handle)
	Creates and right away records the DecisionContainer using the provided WriteHandle. More...
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. More...
Decision *	newDecisionIn (DecisionContainer *dc, const Decision *dOld, const std::string &name="", const EventContext &ctx=Gaudi::Hive::currentContext())
	Helper method to create a Decision object, place it in the container and return a pointer to it. More...
void	addDecisionID (DecisionID id, Decision *d)
	Appends the decision (given as ID) to the decision object. More...
void	decisionIDs (const Decision *d, DecisionIDContainer &id)
	Extracts DecisionIDs stored in the Decision object. More...
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. More...
std::vector< DecisionID > &	decisionIDs (Decision *d)
	Another variant of the above method to access DecisionIDs stored in the Decision object, returns read/write accessor. More...
void	insertDecisionIDs (const Decision *src, Decision *dest)
	Appends the decision IDs of src to the dest decision object. More...
void	insertDecisionIDs (const DecisionIDContainer &src, Decision *dest)
	Appends the decision IDs of src to the dest decision object. More...
void	uniqueDecisionIDs (Decision *dest)
	Make unique list of decision IDs of dest Decision object. More...
bool	allFailed (const Decision *d)
	return true if there is no positive decision stored More...
bool	isAnyIDPassing (const Decision *d, const DecisionIDContainer &required)
	Checks if any of the DecisionIDs passed in arg required is availble in Decision object. More...
bool	passed (DecisionID id, const DecisionIDContainer &)
	checks if required decision ID is in the set of IDs in the container More...
ElementLink< DecisionContainer >	decisionToElementLink (const Decision *d, const EventContext &ctx=Gaudi::Hive::currentContext())
	Takes a raw pointer to a Decision and returns an ElementLink to the Decision. More...
void	linkToPrevious (Decision *d, const std::string &previousCollectionKey, size_t previousIndex)
	Links to the previous object, location of previous 'seed' decision supplied by hand. More...
void	linkToPrevious (Decision *d, const Decision *dOld, const EventContext &ctx=Gaudi::Hive::currentContext())
	Links to the previous object, 'seed' decision provided explicitly. More...
bool	hasLinkToPrevious (const Decision *d)
	checks if there is at least one 'seed' link to previous object More...
const std::vector< ElementLink< DecisionContainer > >	getLinkToPrevious (const Decision *)
	returns links to previous decision object 'seed' More...
bool	copyLinks (const Decision *src, Decision *dest)
	copy all links from src to dest TC objects More...
HLT::Identifier	createLegName (const HLT::Identifier &chainIdentifier, size_t counter)
	Generate the HLT::Identifier which corresponds to a specific leg of a given chain. More...
HLT::Identifier	getIDFromLeg (const HLT::Identifier &legIdentifier)
	Generate the HLT::Identifier which corresponds to the chain name from the leg name. More...
int32_t	getIndexFromLeg (const HLT::Identifier &legIdentifier)
	Extract the numeric index of a leg identifier. More...
int32_t	getIndexFromLeg (const std::string &name)
	Extract the numeric index of a leg identifier. More...
bool	isLegId (const HLT::Identifier &legIdentifier)
	Recognise whether the chain ID is a leg ID. More...
bool	isLegId (const std::string &name)
	Recognise whether the chain ID is a leg ID. More...
bool	isChainId (const HLT::Identifier &chainIdentifier)
	Recognise whether the HLT identifier corresponds to a whole chain. More...
bool	isChainId (const std::string &name)
	Recognise whether the HLT identifier corresponds to a whole chain. More...
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 More...
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. More...
const Decision *	getExpressTerminusNode (const DecisionContainer &container)
	Returns the express-accept navigation node from a collection or nullptr if missing. More...
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. More...
std::vector< const Decision * >	getRejectedDecisionNodes (const asg::EventStoreType *eventStore, 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. More...
void	recursiveGetDecisionsInternal (const Decision *node, const Decision *comingFrom, NavGraph &navGraph, std::set< const Decision * > &fullyExploredFrom, const DecisionIDContainer &ids, const bool enforceDecisionOnNode)
	Used by recursiveGetDecisions. More...
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. More...
void	recursiveFlagForThinning (NavGraph &node, const bool keepOnlyFinalFeatures, const bool removeEmptySteps, const std::vector< std::string > &nodesToDrop)
	Used by trigger navigation thinning. More...
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. More...
bool	typelessFindLinks (const Decision *start, const std::string &linkName, std::vector< sgkey_t > &keyVec, std::vector< uint32_t > &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. More...
bool	typelessFindLinks (const NavGraphNode *start, const std::string &linkName, std::vector< sgkey_t > &key, std::vector< uint32_t > &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. More...
bool	typelessFindLinksCommonLinkCollection (const Decision *start, const std::string &linkName, std::vector< sgkey_t > &keyVec, std::vector< uint32_t > &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. More...
bool	typelessFindLink (const Decision *start, const std::string &linkName, sgkey_t &key, uint32_t &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. More...
bool	typelessFindLink (const NavGraph &subGraph, const std::string &linkName, sgkey_t &key, uint32_t &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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
template<class CONT >
SG::WriteHandle< CONT >	createAndStoreNoAux (const SG::WriteHandleKey< CONT > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
	Creates and right away records the Container CONT with the key. More...
template<class CONT , class AUX >
SG::WriteHandle< CONT >	createAndStoreWithAux (const SG::WriteHandleKey< CONT > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
	Creates and right away records the Container CONT with the key. More...
template<typename T >
DecisionIDContainer	passedDecisionIDs (const Decision *d, const T &required)
	return DecisionIDs in Decision object that match the required ones More...
template<class CONTAINER >
void	filterLinkVectorByContainerKey (const std::string &containerSGKey, std::vector< ElementLink< CONTAINER >> &vector)
	Removes ElementLinks from the supplied vector if they do not come from the specified collection (sub-string match). More...
template<class CONTAINER >
const std::vector< LinkInfo< CONTAINER > >	recursiveGetFeaturesOfType (const NavGraph &navGraph, const std::string &containerSGKey="", const bool lastFeatureOfType=true, const std::string &navElementLinkKey=featureString(), const DecisionIDContainer &chainIDs=DecisionIDContainer())
	Extract features from the supplied linkVector (obtained through recursiveGetDecisions). More...
template<class CONTAINER >
void	recursiveGetFeaturesOfTypeInternal (std::vector< LinkInfo< CONTAINER > > &features, std::set< const NavGraphNode * > &fullyExploredFrom, const NavGraphNode *navGraphNode, const std::string &containerSGKey, const bool lastFeatureOfType, const std::string &navElementLinkKey, const DecisionIDContainer &chainIDs)
	Internal implimentation called by recursiveGetFeaturesOfType, and by itself. More...
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. More...
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. More...
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. More...

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 51 of file TrigCompositeUtils.h.

sgkey_t

using TrigCompositeUtils::sgkey_t = typedef SG::sgkey_t

Definition at line 45 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 LinkInfo.h.

                   {
    UNSET, 
    ACTIVE, 
    INACTIVE 
  };

FilterType

enum 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 61 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 103 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 800 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(HLT::Identifier(chainName), legIdx);
        std::vector<LinkInfo<xAOD::IParticleContainer>> legFeatures;
        for (const LinkInfo<xAOD::IParticleContainer>& info : features)
          if (passed(legID.numeric(), info.decisions))
            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 827 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 836 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 845 of file TrigCompositeUtilsRoot.cxx.

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

comboHypoAlgNodeName()

const std::string & TrigCompositeUtils::comboHypoAlgNodeName

(

)

Definition at line 908 of file TrigCompositeUtilsRoot.cxx.

                                         {
    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 161 of file TrigCompositeUtilsRoot.cxx.

                                                      {
    return dest->copyAllLinksFrom(src);
  }

createAndStore() [1/2]

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

Creates and right away records the DecisionContainer with the key.

Returns the WriteHandle. If possible provide the context that comes via an argument to execute otherwise it will default to looking it up which is slower.

Definition at line 30 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 39 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 = Gaudi::Hive::currentContext()
	)

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

Returns the WriteHandle. No Aux store. If possible provide the context that comes via an argument to execute otherwise it will default to looking it up which is slower.

createAndStoreWithAux()

template<class CONT , class AUX >

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

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

Returns the WriteHandle. With Aux store. If possible provide the context that comes via an argument to execute otherwise it will default to looking it up which is slower.

createLegName()

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.

                                                                                    {
    const std::string& name = chainIdentifier.name();
    if (!isChainId(name)) {
      throw std::runtime_error("TrigCompositeUtils::createLegName chainIdentifier '"+chainIdentifier.name()+"' does not start 'HLT_'");
    }
    if (counter > 999) {
      throw std::runtime_error("TrigCompositeUtils::createLegName Leg counters above 999 are invalid.");
    }
    std::stringstream legStringStream;
    legStringStream << "leg" << std::setfill('0') << std::setw(3) << counter << "_" << name;
    return HLT::Identifier( legStringStream.str() );
  }

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 72 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 67 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 76 of file TrigCompositeUtilsRoot.cxx.

                                                    {
    return readWriteAccessor( *d );
  }

decisionToElementLink()

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

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 122 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 855 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

(

)

Definition at line 884 of file TrigCompositeUtilsRoot.cxx.

                                   {
    return Decision::s_featureString;
  }

filterLinkVectorByContainerKey()

template<class CONTAINER >

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

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

Parameters

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

filterNodeName()

const std::string & TrigCompositeUtils::filterNodeName

(

)

Definition at line 896 of file TrigCompositeUtilsRoot.cxx.

                                   {
    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 221 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]	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.
[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.

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

                                                 {
    if (isChainId(name)){
      return 0;
    } else if (!isLegId(name)) {
      return -1;
    }
    return std::stoi( name.substr(3,3) ); 
  }

getLinkToPrevious()

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

(

const Decision *

d

)

returns links to previous decision object 'seed'

Definition at line 156 of file TrigCompositeUtilsRoot.cxx.

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

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 255 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 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]	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 261 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::vector<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::vector<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 (std::find(knownDistributedSummaryStores.cbegin(), knownDistributedSummaryStores.cend(), summaryCollectionKey) != knownDistributedSummaryStores.end() or summaryCollectionKey == "") {
      
      // 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(static_cast<CLID>( ClassID_traits< DecisionContainer >::ID() ), keys);
#else
      eventStore->event(); // Avoid unused warning
      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 (std::find(knownCompactSummaryStores.cbegin(), knownCompactSummaryStores.cend(), summaryCollectionKey) != knownCompactSummaryStores.end()) {
 
      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
 
    // 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.count(key) == 1) {
        continue; // Have been asked to not explore this SG container
      }
      SG::ReadHandle<DecisionContainer> containerRH(key);
      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.size() == 0) {
          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.at(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.at(i)), moreActiveChains);
            DecisionIDContainer intersection;
            std::set_intersection(activeChainsIntoThisDecision.begin(), activeChainsIntoThisDecision.end(),
              moreActiveChains.begin(), moreActiveChains.end(),
              std::inserter(intersection, intersection.begin()));
            activeChainsIntoThisDecision = 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.size() == 0) { // 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 (activeChainsPassedByThisDecision.find(checkID) == activeChainsPassedByThisDecision.end() && // I was REJECTED here ...
              activeChainsIntoThisDecision.count(checkID) == 1) { // ... 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 247 of file TrigCompositeUtilsRoot.cxx.

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

getTerminusNode() [2/2]

const Decision * TrigCompositeUtils::getTerminusNode

(

SG::ReadHandle< DecisionContainer > &

container

)

Definition at line 243 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 152 of file TrigCompositeUtilsRoot.cxx.

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

hltSeedingNodeName()

const std::string & TrigCompositeUtils::hltSeedingNodeName

(

)

Definition at line 892 of file TrigCompositeUtilsRoot.cxx.

                                       {
    return Decision::s_hltSeedingNodeNameString;
  }

hypoAlgNodeName()

const std::string & TrigCompositeUtils::hypoAlgNodeName

(

)

Definition at line 904 of file TrigCompositeUtilsRoot.cxx.

                                    {
    return Decision::s_hypoAlgNodeNameString;
  }

initialRecRoIString()

const std::string & TrigCompositeUtils::initialRecRoIString

(

)

Definition at line 872 of file TrigCompositeUtilsRoot.cxx.

                                         {
    return Decision::s_initialRecRoIString;
  }

initialRoIString()

const std::string & TrigCompositeUtils::initialRoIString

(

)

Definition at line 868 of file TrigCompositeUtilsRoot.cxx.

                                      {
    return Decision::s_initialRoIString;
  }

inputMakerNodeName()

const std::string & TrigCompositeUtils::inputMakerNodeName

(

)

Definition at line 900 of file TrigCompositeUtilsRoot.cxx.

                                       {
    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 80 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 86 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
    decisionIDs( dest ).clear(); // Clear target
    // Copy from set to (ordered) vector
    decisionIDs( dest ).insert( decisionIDs(dest).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 108 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 212 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 216 of file TrigCompositeUtilsRoot.cxx.

                                        {
    return (name.rfind("HLT_", 0) != std::string::npos);
  }

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 204 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 208 of file TrigCompositeUtilsRoot.cxx.

                                      {
    return (name.rfind("leg", 0) != std::string::npos);
  }

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 148 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 139 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 = Gaudi::Hive::currentContext()
	)

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 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 55 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. If possible provide the context that comes via an argument to execute otherwise it will default to looking it up which is slower.

Definition at line 46 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 117 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 435 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 447 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()) ) {
        // 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 422 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 383 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 bool	lastFeatureOfType = true,
		const std::string &	navElementLinkKey = featureString(),
		const DecisionIDContainer &	chainIDs = DecisionIDContainer()
	)

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

Parameters

[in]	navPaths	Sub-graph of the trigger navigation which is to be considered.
[in]	lastFeatureOfType	True for TrigDefs::lastFeatureOfType. stops at the first feature (of the correct type) found per path through the navigation.
[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 bool	lastFeatureOfType,
		const std::string &	navElementLinkKey,
		const DecisionIDContainer &	chainIDs
	)

Internal implimentation called by recursiveGetFeaturesOfType, and by itself.

See also

recursiveGetFeaturesOfType

Parameters

[in,out]	features	The untimate 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

(

)

Definition at line 876 of file TrigCompositeUtilsRoot.cxx.

                               {
    return Decision::s_roiString;
  }

seedString()

const std::string & TrigCompositeUtils::seedString

(

)

Definition at line 888 of file TrigCompositeUtilsRoot.cxx.

                                {
    return Decision::s_seedString;
  }

summaryFilterNodeName()

const std::string & TrigCompositeUtils::summaryFilterNodeName

(

)

Definition at line 912 of file TrigCompositeUtilsRoot.cxx.

                                          {
    return Decision::s_summaryFilterNodeNameString;
  }

summaryPassExpressNodeName()

const std::string & TrigCompositeUtils::summaryPassExpressNodeName

(

)

Definition at line 920 of file TrigCompositeUtilsRoot.cxx.

                                               {
    return Decision::s_summaryPassExpressNodeNameString;
  }

summaryPassNodeName()

const std::string & TrigCompositeUtils::summaryPassNodeName

(

)

Definition at line 916 of file TrigCompositeUtilsRoot.cxx.

                                        {
    return Decision::s_summaryPassNodeNameString;
  }

summaryPrescaledNodeName()

const std::string & TrigCompositeUtils::summaryPrescaledNodeName

(

)

Definition at line 924 of file TrigCompositeUtilsRoot.cxx.

                                             {
    return Decision::s_summaryPrescaledNodeNameString;
  }

typelessFindLink() [1/2]

bool TrigCompositeUtils::typelessFindLink	(	const Decision *	start,
		const std::string &	linkName,
		sgkey_t &	key,
		uint32_t &	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 723 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<uint32_t> 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,
		uint32_t &	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 761 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< uint32_t > &	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]	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.
[in,out]	fullyExploredFrom	Optional cache used by the recursive algorithm to avoid exploring each node multiple times.

Definition at line 579 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< uint32_t > &	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 625 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< uint32_t > &	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 673 of file TrigCompositeUtilsRoot.cxx.

  {
    bool found = false;
    std::vector<sgkey_t> tmpKeyVec;
    std::vector<uint32_t> 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};
      uint32_t 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 uint32_t tmpKey = tmpKeyVec.at(tmpi);
      const uint32_t 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 97 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

(

)

Definition at line 880 of file TrigCompositeUtilsRoot.cxx.

                                {
    return Decision::s_viewString;
  }