HLT::Navigation Class Reference

The Navigation class, organizes TriggerElements into the tree structure. More...

#include <Navigation.h>

Inheritance diagram for HLT::Navigation:

Collaboration diagram for HLT::Navigation:

Public Types
enum	MemoryManagement { ObjectInStoreGate = 1 , ObjectToStoreGate = 2 , ObjectCreatedByNew = 3 }
	defines 3 possible origins of the objects which are attached to TEs This should be used like this: More...

Public Member Functions
	Navigation (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~Navigation ()
virtual StatusCode	initialize () override
template<class T>
bool	attachFeature (TriggerElement *te, const T *feature, MemoryManagement, std::string &key, const std::string &label="")
	attaches feature to given TriggerElement
template<class T>
bool	attachFeature (TriggerElement *te, const ConstDataVector< T > *feature, MemoryManagement, std::string &key, const std::string &label="")
template<class T>
bool	associateExternalCollection (const std::string &label)
template<class T>
bool	findOwners (const T *obj, std::vector< const TriggerElement * > &owners, unsigned int id=0)
	find all TriggerElements which have this object attached given feature
template<class T>
const std::string	getNextKey (const std::string &label="")
	Get the next key for a given object.
template<class T>
const std::string	getUniqueKey (const std::string &label="")
	Get a unique key (not in the usual series) for a given object.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
virtual void	prepare ()
	prepapres the navigation for next event
virtual void	reset (bool inFinalize=false)
	resets all the navigation, goes to the factory and asks to withdraw all produced objects
virtual bool	serialize (std::vector< uint32_t > &output) const
	method serizlizes the navigation structure The structure is serrizlized in following order ...
bool	serialize (std::vector< uint32_t > &output, std::vector< unsigned int > &cuts) const
bool	serialize (std::vector< uint32_t > &output, std::vector< unsigned int > &cuts, std::vector< std::pair< CLID, std::string > > &clid_name) const
bool	serialize_DSonly (std::vector< uint32_t > &output, std::vector< unsigned int > &cuts, std::vector< std::pair< CLID, std::string > > &clid_name) const
bool	deserialize (const std::vector< uint32_t > &input)
template<class T>
bool	getFeatures (const TriggerElement *te, std::vector< const T * > &features, const std::string &label="", std::map< const T *, std::string > *labels=0) const
	retrieve features attached to given TriggerElement
template<class T>
bool	getFeature (const TriggerElement *te, const T *&features, const std::string &label="", std::string &sourcelabel=::HLT::TrigNavStructure::m_unspecifiedLabel) const
template<class T>
bool	getFeature (const TriggerElement *te, const ConstDataVector< T > *&features, const std::string &label="", std::string &sourcelabel=::HLT::TrigNavStructure::m_unspecifiedLabel) const
TriggerElement::FeatureAccessHelper	getFeature (const TriggerElement *te, class_id_type clid, const index_or_label_type &index_or_label) const
	typeless feature access metod
template<class T>
const T *	featureLink2Object (const TrigFeatureLink &) const
template<class T>
TrigFeatureLink	object2FeatureLink (const TriggerElement *te, const std::string &label, const T *obj) const
template<class C>
TrigFeatureLink	object2FeatureLink (const TriggerElement *te, const std::string &label, const typename Container2Object< C >::type *obj, const C *container) const
template<class C, class T>
bool	getFeaturesLinks (const TriggerElement *te, ElementLinkVector< C > &links, const std::string &label="") const
template<class T>
bool	getRecentFeatures (const TriggerElement *te, std::vector< const T * > &features, const std::string &label="", std::map< const T *, std::string > *labels=0) const
	retrieve features attached to given TriggerElement or its predecessors the algorithm will go recursively to all predecessors and once the feature is found attached to given TE returns all features (of this type and label) attached to this TE
template<class T>
bool	getRecentFeature (const TriggerElement *te, const T *&feature, const std::string &label="", const TriggerElement *&source=::HLT::TrigNavStructure::m_unspecifiedTE, std::string &sourcelabel=::HLT::TrigNavStructure::m_unspecifiedLabel) const
template<class LinkType>
bool	getRecentFeatureDataOrElementLink (const TriggerElement *te, LinkType &link, const std::string &label="", const TriggerElement *&source=::HLT::TrigNavStructure::m_unspecifiedTE, std::string &sourcelabel=::HLT::TrigNavStructure::m_unspecifiedLabel) const
template<class C, class T>
bool	getRecentFeaturesLinks (const TriggerElement *te, ElementLinkVector< C > &links, const std::string &label="") const
template<class C, class T>
bool	getRecentFeatureLink (const TriggerElement *te, ElementLink< C > &link, const std::string &label="", const TriggerElement *&source=::HLT::TrigNavStructure::m_unspecifiedTE, std::string &sourcelabel=::HLT::TrigNavStructure::m_unspecifiedLabel) const
virtual bool	getFeatureAccessors (const TriggerElement *te, class_id_type clid, const index_or_label_type &index_or_label, bool only_single_feature, TriggerElement::FeatureVec &features, bool travel_backward_recursively, const TriggerElement *&source=m_unspecifiedTE, std::string &sourcelabel=m_unspecifiedLabel) const
	retrieve features accessors according to the requrements This method is actually workhorse for all above.
virtual bool	getFeatureAccessorsSingleTE (const TriggerElement *te, CLID clid, const index_or_label_type &index_or_label, bool only_single_feature, TriggerElement::FeatureVec &features, const TriggerElement *&source=::HLT::TrigNavStructure::m_unspecifiedTE, std::string &sourcelabel=::HLT::TrigNavStructure::m_unspecifiedLabel) const
template<class T>
bool	getFeaturesInRoI (const TriggerElement *te, std::vector< const T * > &features, const std::string &label="", std::map< const T *, std::string > *labels=0) const
	retrieve features attached to the RoIs seeding this TriggerElement
template<class C, class T>
bool	getAllFeatures (ElementLinkVector< C > &features, const std::string &label="") const
	gets all features of type T atachedd to whichever TE
bool	merge (const NavigationCore &l2)
	attemtps to merge two trees
void	getAllOfType (const std::string &id, std::vector< HLT::TriggerElement * > &output, const bool activeOnly=true) const
	return trigger elements given the name of TEs
void	getAllOfType (const te_id_type id, std::vector< TriggerElement * > &output, const bool activeOnly=true) const
	The query returning a collection of all TriggerElements if name is given.
const AccessProxy *	getAccessProxy () const
	gets the access proxy
template<class T>
HLTNavDetails::Holder< T > *	getHolder (uint16_t subTypeIndex) const
	as above but does not create holder on demand (return 0 if not found)
const BaseHolder *	getHolder (const TriggerElement::FeatureAccessHelper &fea) const
TriggerElement *	getInitialNode ()
	gets initial node, if node is not there then it is created on fly
const TriggerElement *	getInitialNode () const
TriggerElement *	addRoINode (TriggerElement *initial)
	gets RoI node (attached to initial)
TriggerElement *	addNode (TriggerElement *seed, unsigned int id)
	adds nodes seeded form the one given as an argument,
TriggerElement *	addNode (std::vector< TriggerElement * > &seeds, unsigned int id, bool ghost=false, bool nofwd=false)
	adds node which is seeded from several other Needed by Topological algorithms
void	printASCIIArt (std::string &str, const TriggerElement *te=0, int offset=0) const
	pretty printing of the navigational structure (heavy)
bool	serializeTEs (std::vector< uint32_t > &output) const
	method serizlizes the navigation structure
bool	deserializeTEs (std::vector< uint32_t >::const_iterator &start, unsigned int totalSize)
TriggerElement::FeatureAccessHelper	getFeatureRecursively (const TriggerElement *startTE, class_id_type clid, const index_or_label_type &index_or_label, const TriggerElement *&sourceTE) const
	recursive search for features the function is similar to the above butif th features is not found at the startTE the search descends the structure of TEs until it is found.
void	getAllRoIThresholdTEs (std::vector< TriggerElement * > &output) const
	The query returns a vector of all TriggerElements that represent a LVL1 RoI threshold.
void	getAll (std::vector< TriggerElement * > &output, const bool activeOnly=true) const
	The query returning a collection of all TriggerElements.
std::vector< TriggerElement * > &	getAllTEs ()
	access needed by slimming tools.
const std::vector< TriggerElement * > &	getAllTEs () const
	access needed by slimming tools.
unsigned int	countAllOfType (const te_id_type id, const bool activeOnly=true) const
	The query counting a collection of all TriggerElement of a given type.
bool	propagateDeactivation (const TrigNavStructure *nav)
	propagates deactivation of TE state This finction should be used after Trigger is rerurn on L2 and then the reruning on L2 is required.
bool	combine (std::vector< unsigned int > &types, std::vector< std::vector< TriggerElement * > > &output, unsigned int maxResults=1000, bool onlyActive=true)
	For Algorithms: return all the possible n-tuples of TE* objects (te0, te1..., ten)
bool	overlaps (const TriggerElement *t1, const TriggerElement *t2) const
	Check overlap between trigger elements (pointer equality or RoI overlap)
bool	overlaps (const TriggerElement *t1, const std::vector< TriggerElement * > &teVec) const
	Check overlap between a TE and a vector of TEs, using the method above.
bool	getTopologicallySpannedBy (const TriggerElement *te, const std::vector< unsigned int > &types, std::vector< const TriggerElement * > &children, const bool activeOnly=true) const
	gets the TEs whose predecessors were used to built a given topological TE
unsigned int	copyAllFeatures (const TriggerElement *sourceTE, TriggerElement *destTE)
	gets all features from the sourceTE and copies a reference (FeatureAccessHelper) to the destTE
sub_index_type	subType (class_id_type clid, const index_or_label_type &sti_or_label) const
std::string	label (class_id_type clid, const index_or_label_type &sti_or_label) const

Static Public Member Functions
template<class T, class C>
static void	registerFeatureContainer ()
	Specialized by type and container for this type.
static uint32_t	string2hash (const std::string &, const std::string &category="TE")
	convert strin g to hash.
static const std::vector< TriggerElement * > &	getRoINodes (const TriggerElement *somenode)
	gets all RoI type nodes seeding indirectly this TriggerElement
static const std::vector< TriggerElement * > &	getDirectPredecessors (const TriggerElement *te)
	returns list of direct predecessors (nodes seeding me)
static const std::vector< TriggerElement * > &	getDirectSuccessors (const TriggerElement *te)
	returns list of direct predecessors (nodes I seed)
static const TriggerElement *	getSuccessor (const TriggerElement *te, unsigned int id)
	returns successor of given type beeing seeded from this TE
static bool	isInitialNode (const TriggerElement *te)
	queries if node is an initial one
static bool	isRoINode (const TriggerElement *te)
	queries if node is an RoI type one
static bool	isTerminalNode (const TriggerElement *te)
	queries if node is terminal (no more TriggerElement are seeded by it)
static bool	haveCommonRoI (const TriggerElement *te1, const TriggerElement *te2)
	does this 2 share RoI
static bool	haveDistinctRoI (const TriggerElement *te1, const TriggerElement *te2)
	inversion of haveCommonRoI
static bool	haveAllCommonRoIs (const HLT::TriggerElement *te1, const HLT::TriggerElement *te2)
static bool	haveCommonSeed (const TriggerElement *te1, const TriggerElement *te2)
	checks that there is any common predecessor of two TriggerElements
static bool	haveDistinctSeed (const TriggerElement *te1, const TriggerElement *te2)
	inversion of haveCommonSeed
static bool	increasingOrderByTEId (const TriggerElement *te1, const TriggerElement *te2)
	for sorting TriggerElements according to their id
static bool	decreasingOrderByTEId (const TriggerElement *te1, const TriggerElement *te2)
static bool	hasIdFromTheSet (const TriggerElement *te, std::vector< unsigned int > ids)
	simple helper
static bool	isNotActive (const TriggerElement *te)
	helper for the STL
static bool	isTopological (const TriggerElement *te)
static bool	isCompatibleTree (const TriggerElement *te1, const TriggerElement *te2)
	check compatibility of 2 navigation structures

Protected Member Functions
	Navigation ()
	Navigation (const Navigation &)
Navigation &	operator= (const Navigation &)
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.
template<class T>
HLTNavDetails::Holder< T > *	getHolder (const std::string &label, uint16_t suggestedIndex) const
	aware holder discovery, creates holder if needed
HLTNavDetails::IHolder *	getHolder (CLID clid, uint16_t subTypeIndex) const
	as above but not type wise holder returned
HLTNavDetails::IHolder *	getHolder (CLID clid, const std::string &label) const
	as above
bool	createHolder (HLTNavDetails::IHolder *&holder, CLID clid, const std::string &label, uint16_t idx) const
	creates holder for type given by CLID
bool	registerHolder (HLTNavDetails::IHolder *holder)
bool	addOneLevel (std::vector< std::vector< TriggerElement * > > &currentCombs, std::vector< std::vector< std::pair< unsigned int, unsigned int > > > &currentIdxs, unsigned int type, std::vector< std::vector< TriggerElement * > > &newCombs, std::vector< std::vector< std::pair< unsigned int, unsigned int > > > &newIdxs, unsigned int maxResults=1000, bool onlyActive=1)
	Helper method for "combine": add one "level" of multiplicity to the results.
uint16_t	nextSubTypeIndex (CLID clid, const std::string &label) const
bool	extractBlob (const std::vector< uint32_t > &input, std::vector< uint32_t >::const_iterator &it, std::vector< uint32_t > &blob) const
bool	matchFeature (const TriggerElement::FeatureAccessHelper &fea, class_id_type clid, const index_or_label_type &index_or_label) const
void	fillSameRoIRelation (TriggerElement *roi, TriggerElement *te)
	rebuilds the sameRoIRelation between trigger elements (used internally by deserialize)
TriggerElementFactory &	getFactory ()
const TriggerElementFactory &	getFactory () const
TrigHolderStructure &	getHolderStorage ()
const TrigHolderStructure &	getHolderStorage () const
std::recursive_mutex &	getMutex ()
std::recursive_mutex &	getMutex () const

Protected Attributes
IConversionSvc *	m_serializerSvc
StoreGateSvc *	m_storeGate
std::string	m_objectsKeyPrefix
	property setting prefix which is to be given to all trigger EDM objects
unsigned	m_objectsIndexOffset
	small integer used to generate sub type index
ITrigHolderFactory *	m_holderfactory
std::vector< std::string >	m_classesToPayloadProperty
	list of classes#keys to be put to BS payload
std::vector< CSPair >	m_classesToPayload
	classess are put to payload according to that priority list (CLID + key)
std::vector< std::string >	m_classesToPayloadProperty_DSonly
	list of classes#keys to be put to DS payload
std::vector< CSPair >	m_classesToPayload_DSonly
	classess are put to payload according to that priority list (CLID + key)
std::vector< std::string >	m_classesFromPayloadIgnoreProperty
	list of classes#keys to ignore on deserialization
std::vector< std::string >	m_classesToPreregisterProperty
	as above but for preregistration
std::vector< CSPair >	m_classesToPreregister
	classes mentioned here will be put to SG irrespectively of thier presence in event

Static Protected Attributes
static const TriggerElement *m_unspecifiedTE	ATLAS_THREAD_SAFE
static std::string m_unspecifiedLabel	ATLAS_THREAD_SAFE

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	classKey2CLIDKey (const std::vector< std::string > &property, std::vector< CSPair > &decoded)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>
HLTNavDetails::IHolder *	prepareOneHolder (CLID clid, const std::string &label)
bool	serializeWithHolderSection (const std::vector< uint32_t > &holderdata, const std::vector< unsigned int > &holderblobsizes, std::vector< uint32_t > &output, std::vector< unsigned int > &cuts, std::vector< std::pair< CLID, std::string > > &clid_name) const
bool	serializeHoldersWithoutPayload (const std::vector< HLTNavDetails::IHolder * > &holders, std::vector< uint32_t > &output, std::vector< uint32_t > &holderblobsizes, std::vector< std::pair< CLID, std::string > > &clid_name) const
bool	serializeHoldersWithPayload (const std::vector< CSPair > &payload, std::vector< uint32_t > &output, std::vector< uint32_t > &holderblobsizes, std::vector< std::pair< CLID, std::string > > &clid_name) const

Private Attributes
ServiceHandle< IConversionSvc >	m_serializerServiceHandle
ServiceHandle< IClassIDSvc >	m_clidSvc
Gaudi::Property< std::vector< std::string > >	m_dlls {this, "Dlls", {}, "Libraries to load (with trigger EDM)", "OrderedSet<T>"}
FullHolderFactory	m_fullholderfactory
bool	m_readonly
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared
const AthAlgTool &	m_logger
SG::SlotSpecificObj< TriggerElementFactory >	m_factory
	factory of trigger elements (one per processing slot)
SG::SlotSpecificObj< TrigHolderStructure >	m_holderstorage
	structure for feature holders (one per processing slot)

Static Private Attributes
static std::recursive_mutex	s_rmutex

Detailed Description

The Navigation class, organizes TriggerElements into the tree structure.

Author

Tomasz Bold Tomas.nosp@m.z.Bo.nosp@m.ld@ce.nosp@m.rn.c.nosp@m.h - U. of California - Irvine

Till Eifert Till..nosp@m.Eife.nosp@m.rt@ce.nosp@m.rn.c.nosp@m.h - U. of Geneva, Switzerland

Nicolas Berger Nicol.nosp@m.as.B.nosp@m.erger.nosp@m.@cer.nosp@m.n.ch - CERN

Lukas Heinrich lukas.nosp@m..hei.nosp@m.nrich.nosp@m.@cer.nosp@m.n.ch - NYU

The class is providing an interface to the whole navigation. The internal ingredients of the navigation which are TriggerElements are well hidden. All operations on the navigation structure are possible only via trick class. This operations are basically:

1. creation of TriggerElements
   • creation of the initial (root) node
   • creation of RoI nodes (one per RoI, also for secondary RoIs)
   • creation of normal nodes (seed by one TriggerElement)
   • creation of normal nodes suitable for topological selection (being seed by 2 TriggerElements)

The created nodes are given to user with all the navigational links prepared

1. features attaching and retrieval
   • attaching feature to node
   • attaching feature to RoI node ( therefore all TE originating from node can use it )
   • attaching feature to initial (root) node for global (event wide) features
   • retrieval of features attached to given node
   • retrieval of features attached to given node or any predecessor (back to an initial node)
   • retrieval of features attached to given node or any predecessor (traversing back to an initial node)
   • retrieval of recent feature attached to given node or any predecessor (traversing back to an initial node)
   • retrieval of features attached to RoI nodes of given TriggerElement
   • retrieval of features attached to initial (root) node

1. queering methods
   • simple queries (isInitial, isTerminal, isRoI)
   • more complicated queries for 2 TriggerElements (if they share RoI etc)
   • global comparison for 2 navigation structures (needed up to the moment only for validation of serialization)
   • query for all TriggerElements of a given type Queries are designed to be usable with STL algorithms.

Documentation of EDM related upgrade:

1. objects storage
   • all possible types are known at compile time (Scott's magic)
   • some collections are placed in the SG always independently of the event content
   • there can be more collection of given type (one for each user label i.e. number of tracks collections)
   • if in navigation config this is given: TrigVertexCollection#HLTAutoKey_T2HistoPrmVtx --> then DataVector<TrigVertexCollection> of label "HLTAutoKey_T2HistoPrmVtx" is placed in the SG in every event
   • if in config only type is mentioned TrigVertexCollection#HLTAutoKey ---> then DataVector<TrigVertexCollection> of label HLTAutoKey is placed in SG for each event
   • if nothing is mentioned in config the DataVector<TrigVertexCollection> labeled at runtime depending on user labels will be placed in SG (one per label)

   • the object of given type are then organized then as follows: there is many collections of given type per event (each for one label) this collections are accessible by label or "SubTypeIndex" second is to keep the TE -> feature link unchanged if we remove obe of collection during slimming or we simply not record it

     Is is like this collection of type T |XXXXXXX| label: ID subTypeIndex: 0 collection of type T |XXXX| label: MS subTypeIndex: 1 collection of type T |XXXXXXXXXXXXX| label: Muons subTypeIndex: 2 collection of type T |XXXXXXXX| label: Calo subTypeIndex: 3

2. the features <-> TE link
   • Features are located in supercontainers DataVector<TrigVertexCollection>
   • each label yields in one supercontainer (the unlabeled objects are in the container with HLTAutoKey_ label)
   • The link to object in the TE is composed out of 2 numbers CLID, and index
   • index (from above) is composed out of 2 parts collection coordinate and second is coordinate within collection
   • this way we do not need to touch TE serialization/desetialization
   • collection index and inter-collection index are uint16_t word which means we are limited to 65000 collections of given type and same number of objects in each sub collection

Definition at line 100 of file Navigation.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

MemoryManagement

enum HLT::NavigationCore::MemoryManagement

inherited

defines 3 possible origins of the objects which are attached to TEs This should be used like this:

1. All the objects which are produced out of blue using "new" operator should be attached with ObjectCreatedByNew switch. This objects may also go to SG depending on configuration.
2. All objects which needs to be registered in the StoreGate should be registered using switch "ObjectToStoreGate" which tells basically thet SG take control over the cleanup. All objects registered like this will for sure go to SG.
3. the switch "ObjectInStoreGate" should be used for objects which are already in SG. (i.e. put there by offline reco. tools).

Enumerator
ObjectInStoreGate
ObjectToStoreGate
ObjectCreatedByNew

Definition at line 157 of file NavigationCore.h.

{ ObjectInStoreGate = 1, ObjectToStoreGate = 2, ObjectCreatedByNew = 3 };

Constructor & Destructor Documentation

Navigation() [1/3]

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

Definition at line 18 of file Navigation.cxx.

  : AthAlgTool(type, name, parent),
    NavigationCore(static_cast<AthAlgTool&>(*this)),
    m_serializerServiceHandle("TrigSerializeCnvSvc", name),
    m_clidSvc("ClassIDSvc", name),
    m_fullholderfactory(m_objectsKeyPrefix)
{
 
  declareProperty("ClassesToPayload", m_classesToPayloadProperty,
                  "List of classes which need to be serialized together with the Navigation.");
 
  declareProperty("ClassesToPayload_DSonly", m_classesToPayloadProperty_DSonly,
                  "List of classes which need to be serialized together with the Navigation (Only in DataScouting collection).");
 
  declareProperty("ClassesFromPayloadIgnore", m_classesFromPayloadIgnoreProperty,
                  "List of classes (Type[#Key]) to ignore on deserialization of the Navigation.");
 
  declareProperty("ClassesToPreregister", m_classesToPreregisterProperty,
                  "List of classes which need to be put in SG independently if they appear in event.");
 
  declareProperty("ObjectsKeyPrefix", m_objectsKeyPrefix="HLT", "The prefix which all Trigger EDM objects will get, by default it is HLT");
  declareProperty("ObjectsIndexOffset", m_objectsIndexOffset=0, "The offset with which the objects idx is be shifted.");
  declareProperty("ReadonlyHolders", m_readonly = false, "read only flag for holders (cannot create new feature containers");
}

~Navigation()

Navigation::~Navigation ( )

virtual

Definition at line 44 of file Navigation.cxx.

                        {
}

Navigation() [2/3]

HLT::Navigation::Navigation ( )

protected

Navigation() [3/3]

HLT::Navigation::Navigation ( const Navigation & )

protected

Member Function Documentation

addNode() [1/2]

TriggerElement * TrigNavStructure::addNode ( std::vector< TriggerElement * > & seeds, unsigned int id, bool ghost = false, bool nofwd = false )

inherited

adds node which is seeded from several other Needed by Topological algorithms

Parameters

seeds	are all TriggerElements which seed newly created
id	the id to give for the created TriggerElement
ghost	flag is saying that this TE is a light weight one, no features attaching to it is allowed
nofwd	flag is saying that this TE will not be deactivated automatically in fwd deactivation process(rerunning)

Definition at line 85 of file TrigNavStructure.cxx.

                                                                                                                        {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  TriggerElementFactory& factory = getFactory();
 
  TriggerElement* te = factory.produce(id, ghost, nofwd);
 
 
  std::vector<TriggerElement* >::iterator it;
  for ( it = seeds.begin(); it != seeds.end(); ++it ) {
    // relate to it
    TriggerElement* seednode = *it;
    te->relate( seednode, TriggerElement::seededByRelation );
    seednode->relate( te, TriggerElement::seedsRelation );
    // add previous Features
    te->getPreviousFeatures().insert(te->getPreviousFeatures().end(),
                                     seednode->getPreviousFeatures().begin(),
                                     seednode->getPreviousFeatures().end());
 
    // copy RoI relations
    if ( isRoINode(seednode) ) {
      te->relate( seednode, TriggerElement::sameRoIRelation );
      seednode->relate( te, TriggerElement::sameRoIRelation );
    } else {
      std::vector<TriggerElement*>::const_iterator itbegin = seednode->getRelated( TriggerElement::sameRoIRelation ).begin();
      std::vector<TriggerElement*>::const_iterator itend   = seednode->getRelated( TriggerElement::sameRoIRelation ).end();
 
      for (  ; itbegin != itend; ++itbegin ) {
        te->relate( *itbegin, TriggerElement::sameRoIRelation );
        (*itbegin)->relate( te, TriggerElement::sameRoIRelation );
      }
    }
  }
  return te;
}

addNode() [2/2]

TriggerElement * TrigNavStructure::addNode ( TriggerElement * seed, unsigned int id )

inherited

adds nodes seeded form the one given as an argument,

Parameters

seed	a TriggerElement which direct predecessor of newly created
id	an id to give newly created TriggerElement

Definition at line 79 of file TrigNavStructure.cxx.

                                                                                     {
  std::vector<TriggerElement*> list;
  list.push_back(seednode);
  return addNode(list, id);
}

addOneLevel()

bool HLT::NavigationCore::addOneLevel ( std::vector< std::vector< TriggerElement * > > & currentCombs, std::vector< std::vector< std::pair< unsigned int, unsigned int > > > & currentIdxs, unsigned int type, std::vector< std::vector< TriggerElement * > > & newCombs, std::vector< std::vector< std::pair< unsigned int, unsigned int > > > & newIdxs, unsigned int maxResults = 1000, bool onlyActive = 1 )

protectedinherited

Helper method for "combine": add one "level" of multiplicity to the results.

addRoINode()

TriggerElement * TrigNavStructure::addRoINode ( TriggerElement * initial )

inherited

gets RoI node (attached to initial)

Definition at line 58 of file TrigNavStructure.cxx.

                                                                      {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  TriggerElementFactory& factory = getFactory();
 
  if ( isInitialNode(initial)  ) {
    TriggerElement* te = factory.produce(0);
 
    // build seeds, seeededBy relations
    te->relate( initial, TriggerElement::seededByRelation );
    initial->relate( te, TriggerElement::seedsRelation );
    return te;
  }
  return 0;
}

associateExternalCollection()

template<class T>

bool HLT::Navigation::associateExternalCollection

(

const std::string &

label

)

attachFeature() [1/2]

template<class T>

bool HLT::Navigation::attachFeature	(	TriggerElement *	te,
		const ConstDataVector< T > *	feature,
		MemoryManagement	,
		std::string &	key,
		const std::string &	label = "" )

attachFeature() [2/2]

template<class T>

bool HLT::Navigation::attachFeature	(	TriggerElement *	te,
		const T *	feature,
		MemoryManagement	,
		std::string &	key,
		const std::string &	label = "" )

attaches feature to given TriggerElement

Parameters

te	TriggerElement to which attach feature
feature	is feature ptr to attach
key	is filled up by the key used to put into SG (if not SG is involved then untouched)
label	for additional marking of this feature

Returns

false if error enountered, true if no error encountered if this feature is on the list of classes to be serialized by reference then it is put into the SG (using SG->record)

classKey2CLIDKey()

StatusCode Navigation::classKey2CLIDKey ( const std::vector< std::string > & property, std::vector< CSPair > & decoded )

private

Definition at line 114 of file Navigation.cxx.

                                                          {
  // translate Class names into CLID numbers
 
  for ( const std::string& cname : property ) {
    CLID clid{0};
    std::string key;
    std::string type;
 
    if ( cname.find('#') != std::string::npos ) {
      type = cname.substr(0, cname.find('#') );
      key  = cname.substr(cname.find('#')+1 );
    } else {
      type = cname;
      key = "";
    }
 
    if ( m_clidSvc->getIDOfTypeName(type, clid).isFailure() ) {
      ATH_MSG_ERROR("Unable to get CLID for class: " << cname);
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_DEBUG("Recognized CLID : " << type << " and key: " << key);
 
    xAOD::AuxSelection sel;
 
    // anything after a dot is a list of dynamic Aux attributes, separated by dots
    size_t dotpos = key.find('.');
    if( dotpos == std::string::npos ) {
      // If no explicit selection, we want to select nothing (this is a
      // difference from the offline logic).  But an empty selection list
      // in AuxSelection means to accept everything.  So add a dummy name
      // that shouldn't match anything.
      const char* dummyName = "__dummyThatShouldNotMatch";
      [[maybe_unused]]
      static const SG::AuxElement::Accessor<int> dummyVar (dummyName);
      static const std::set<std::string> dummySet { dummyName };
      sel.selectAux (dummySet);
    }
    else {
      std::string aux_attr = key.substr(dotpos+1);
      key.erase (dotpos, std::string::npos);
 
      typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
      boost::char_separator<char> sep(".");
      tokenizer tokens (aux_attr, sep);
      sel.selectAux (std::set<std::string> (tokens.begin(), tokens.end()));
    }
 
    decoded.emplace_back (clid, key, std::move (sel));
  }
  return StatusCode::SUCCESS;
}

combine()

bool TrigNavStructure::combine ( std::vector< unsigned int > & types, std::vector< std::vector< TriggerElement * > > & output, unsigned int maxResults = 1000, bool onlyActive = true )

inherited

For Algorithms: return all the possible n-tuples of TE* objects (te0, te1..., ten)

such that te0.id() == types[0], te1.id() == types[1]... In the case where ids appear multiple times, n-tuple permutations are counted only once. (so if te0.id() == te1.id(), (te0, te1) will appear but not (te1, te0)) "output" is populated with all the poClassID_traits<T>::ID();ssible combinations of this type. if "activeOnly" is true, only active trigger elements are used. The list is truncated at maxResults if maxResults > 0.

Definition at line 580 of file TrigNavStructure.cxx.

{
  // It should be empty anyways, but just in case...
  output.clear();
 
  std::vector< std::vector<TriggerElement*> > input;
  std::vector< std::vector<std::pair<unsigned int, unsigned int> > >  newIdxs;
 
  for (std::vector<unsigned int>::iterator type = types.begin();
       type !=  types.end(); ++type) {
    // Use the previous iteration's output as the input for this one
    std::vector< std::vector<TriggerElement*> > input = output;
    std::vector< std::vector<std::pair<unsigned int, unsigned int> > >  currentIdxs = newIdxs;
 
    // Remove the old n-tuples
    output.clear();
    newIdxs.clear();
    // Re-populate output with the (n+1)-tuples. If error return false immediately...
    if (not addOneLevel(input, currentIdxs, *type, output, newIdxs,
            maxResults, onlyActive)) return false;
  }
 
  return true;
}

copyAllFeatures()

unsigned int TrigNavStructure::copyAllFeatures ( const TriggerElement * sourceTE, TriggerElement * destTE )

inherited

gets all features from the sourceTE and copies a reference (FeatureAccessHelper) to the destTE

Parameters

sourceTE	(source) TriggerElement holding features
destTE	(destiny) TriggerElement: copy feature references here

Returns

number of features that were copied

Definition at line 734 of file TrigNavStructure.cxx.

{
  unsigned int n_features = 0;
  // push back all featureAccessHelpers from source to destiny TE
  for ( std::vector< TriggerElement::FeatureAccessHelper >::const_iterator it = sourceTE->getFeatureAccessHelpers().begin();
        it != sourceTE->getFeatureAccessHelpers().end(); ++it ) {
    destTE->addFeature(*it);
    n_features++;
  }
  return n_features;
 
}

countAllOfType()

unsigned int TrigNavStructure::countAllOfType ( const te_id_type id, const bool activeOnly = true ) const

inherited

The query counting a collection of all TriggerElement of a given type.

Definition at line 388 of file TrigNavStructure.cxx.

                                                                                                {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TriggerElementFactory& factory = getFactory();
 
  if ( activeOnly )
    return factory.listOfProduced(id).size()
      - count_if(factory.listOfProduced(id).begin(), factory.listOfProduced(id).end(), isNotActive);
  //else
  return factory.listOfProduced(id).size();
}

createHolder()

bool NavigationCore::createHolder ( HLTNavDetails::IHolder *& holder, CLID clid, const std::string & label, uint16_t idx ) const

protectedinherited

creates holder for type given by CLID

Definition at line 365 of file NavigationCore.cxx.

                                                                                                             {
  ATH_MSG_DEBUG("createHolder: creating holder for CLID: " << clid  << " label: " << label << " and index: " << index);
  //reset holder
  holder = 0;
  auto baseholder = m_holderfactory->createHolder(clid,label, index);
  if(!baseholder){
    ATH_MSG_ERROR("createHolder: creation of holder for CLID: " << clid  << " label: " << label << " and index: " << index << " failed");
  }
 
  holder = dynamic_cast<IHolder*>(baseholder);
  
  if(!holder){
    ATH_MSG_ERROR("createHolder: cast to IHolder* failed");
  }
 
  return true;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

decreasingOrderByTEId()

bool TrigNavStructure::decreasingOrderByTEId ( const TriggerElement * te1, const TriggerElement * te2 )

staticinherited

Definition at line 487 of file TrigNavStructure.cxx.

                                                                                                  {
  return te1->getId() > te2->getId();
}

deserialize()

bool NavigationCore::deserialize ( const std::vector< uint32_t > & input )

virtualinherited

Implements HLT::TrigNavStructure.

Definition at line 151 of file NavigationCore.cxx.

                                                                   {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  TrigHolderStructure& holderstorage = getHolderStorage();
 
  std::vector<uint32_t>::const_iterator inputIt = input.begin();
 
  ATH_MSG_DEBUG("deserialize: deserializing input of size:  " << input.size());
 
 
  if (input.size()==0) {
    ATH_MSG_WARNING("Cannot work on empty payload");
    return false;
  }
  unsigned int  version = *inputIt++; // ignore version
 
  ATH_MSG_DEBUG("deserialize: the serialized input has versions " << version);
 
  if ( version != 3 and version !=4  ) {
    ATH_MSG_WARNING("No backward compatibility beyond version 3 possible; data was serialized with V: " << version
                << " while we are in version 4");
    return true;
  }
  ATH_MSG_DEBUG("deserialize: deserialization of Navigation version: " << version);
 
  unsigned int totalSize =  *inputIt++; // total size
  if ( totalSize != input.size() )
    ATH_MSG_WARNING("deserialize: the navigation is truncated: " << input.size()
                  << " while should be: " << totalSize );
 
  if ( input.size() == 2 ) { // there was only space for version and size
    ATH_MSG_WARNING("deserialize: the navigation is truncated badly, no recovery possible " );
    return false;
  }
 
  bool tesDeserializationStatus = deserializeTEs(inputIt,input.size());
  ATH_MSG_DEBUG("deserialize: TEs structure unpacked, status: " << tesDeserializationStatus );
 
 
  ATH_MSG_DEBUG("do we have holder payload? " << (inputIt != input.end()));
 
  // Keep track of blobs we've deserialized for each event.
  struct DeserializedMemo
  {
    std::mutex m_mutex;
    EventContext::ContextEvt_t m_evt;
    std::unordered_map<uint64_t, std::shared_ptr<HLT::BaseHolder>> m_holders;
  };
  static SG::SlotSpecificObj<DeserializedMemo> memos ATLAS_THREAD_SAFE;
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  DeserializedMemo& memo = *memos.get (ctx);
  std::scoped_lock memolock (memo.m_mutex);
  if (memo.m_evt != ctx.evt()) {
    memo.m_holders.clear();
    memo.m_evt = ctx.evt();
  }
  
  // EOF TEs deserialization
  // deserialize Features
  std::vector<uint32_t>::const_iterator it  = inputIt; 
  std::vector<uint32_t> blob;
  while ( extractBlob(input, it, blob) ) {
    // Skip this blob if we've already deserialized it.
    // See ATLASRECTS-6278, ATEAM-734 and ATR-25282
    uint64_t hash = CxxUtils::crc64 (reinterpret_cast<const char*>(blob.data()),
                                     blob.size()*sizeof(*blob.data()));
 
    auto& holder = memo.m_holders[hash]; // ref(!) to empty or existing holder pointer
    if (! holder ) {
      ATH_MSG_DEBUG("deserializing holder blob with size/hash " << blob.size() << "/" << hash);
      holder = std::shared_ptr<HLT::BaseHolder>(m_holderfactory->fromSerialized(version,blob.begin(),blob.end()));
      if (! holder ) continue;   // error during deserialization
    } else {
      ATH_MSG_DEBUG("blob with size/hash " << blob.size() << "/" << hash
                  << " already deserialized; re-using holder");
    }
 
    if(!holderstorage.registerHolder(holder)){
      ATH_MSG_WARNING("deserialize: holder registration for holder with clid: " << holder->typeClid() << " and label: " << holder->label() << " failed.");
    }
  }
  return true;
}

deserializeTEs()

bool TrigNavStructure::deserializeTEs ( std::vector< uint32_t >::const_iterator & start, unsigned int totalSize )

inherited

Definition at line 264 of file TrigNavStructure.cxx.

                                                                                                      {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  TriggerElementFactory& factory = getFactory();
 
  factory.reset();
  
  std::vector<uint32_t>::const_iterator& inputIt = start;
  const size_t payloadSize = *inputIt++; 
  
  if ( totalSize < payloadSize ) { // not all TEs were recorded
    std::cerr << "size of the navigation payload smaller than the one required to save TEs. " << totalSize << " < " << payloadSize << std::endl;
    return false;
  }
 
  
  const unsigned int size = *inputIt++; // size in terms of number of TEs
  TriggerElement* previous = 0;
  std::map<uint16_t, TriggerElement* > keys;
  
  for ( unsigned int i = 0; i < size; ++i ) {
    // create new TE
    TriggerElement* te = factory.produce(TriggerElement::enquireId(inputIt)); //
    te->deserialize(inputIt, keys, previous);
    previous = te;
    // keys table for deserialization of other TEs
    keys[i] = te;
  }
  
  if ( not factory.empty() ) {
    // rebuild  sameRoI relations (this can't be done by TEs deserialization)
    TriggerElement* initialNode = getInitialNode();
    std::vector<TriggerElement*>::const_iterator roiTEit;
    for ( roiTEit = getDirectSuccessors(initialNode).begin(); 
      roiTEit != getDirectSuccessors(initialNode).end(); ++roiTEit ) {
      fillSameRoIRelation((*roiTEit), (*roiTEit));
    }
  } // else this is empty structure, but this shoudl not bother us as it is may well be valid case
  
  return true;
}

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extractBlob()

bool NavigationCore::extractBlob ( const std::vector< uint32_t > & input, std::vector< uint32_t >::const_iterator & it, std::vector< uint32_t > & blob ) const

protectedinherited

Definition at line 60 of file NavigationCore.cxx.

                                                                                                                                         {
  blob.clear();
  if ( it == input.end() )
    return false;
 
  unsigned sizeOfBlob = *it;
  std::vector<uint32_t>::const_iterator begin = it;
  ++begin;
  std::vector<uint32_t>::const_iterator end   = it;
  ++end;
  advance(end, sizeOfBlob);
  if ( end <= input.end()) {
    blob.reserve(end-begin);
    blob.insert(blob.end(), begin, end);
    it = end; // update iterator
    return true;
  }
  return false; // failed to get blob
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

featureLink2Object()

template<class T>

const T * HLT::NavigationCore::featureLink2Object ( const TrigFeatureLink & ) const

inherited

fillSameRoIRelation()

void TrigNavStructure::fillSameRoIRelation ( TriggerElement * roi, TriggerElement * te )

protectedinherited

rebuilds the sameRoIRelation between trigger elements (used internally by deserialize)

Warning

should be called for each RoI like node

Definition at line 307 of file TrigNavStructure.cxx.

                                                                                     {
  if ( ! isRoINode(te) ) {
    te->relate(roi, TriggerElement::sameRoIRelation);
    roi->relate(te, TriggerElement::sameRoIRelation);
  }
  if ( isTerminalNode(te) )
    return;
  else { // traverse all sub nodes
    std::vector<TriggerElement*>::const_iterator it;
    for ( it = getDirectSuccessors(te).begin(); it != getDirectSuccessors(te).end(); ++it ) {
      fillSameRoIRelation(roi, *it);
    }
  }
}

findOwners()

template<class T>

bool HLT::Navigation::findOwners	(	const T *	obj,
		std::vector< const TriggerElement * > &	owners,
		unsigned int	id = 0 )

find all TriggerElements which have this object attached given feature

Warning

This search is costly since all TEs needs to be searched for. It can be significantly improved if search is limited to TEs with given ID

Parameters

obj	is a pointer to object of interest
owners	is a vector of TEs which will be filled by all owners of the feature
id	the id of TEs which should be inspected

Returns

true if no error was encountered, this does not mean that object is found, false if data access error occured

getAccessProxy()

const AccessProxy * HLT::NavigationCore::getAccessProxy ( ) const

inlineinherited

gets the access proxy

Definition at line 337 of file NavigationCore.h.

                                              {
      return m_storeGate;
    }

getAll()

void TrigNavStructure::getAll ( std::vector< TriggerElement * > & output, const bool activeOnly = true ) const

inherited

The query returning a collection of all TriggerElements.

Definition at line 361 of file TrigNavStructure.cxx.

                                                                                                 {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TriggerElementFactory& factory = getFactory();
 
  if ( not factory.listOfProduced().empty() ) {
    std::back_insert_iterator<std::vector<TriggerElement*> > outputIt( output );
    if (activeOnly)
      remove_copy_if ( factory.listOfProduced().begin(), factory.listOfProduced().end(), outputIt, isNotActive );
    else
      copy ( factory.listOfProduced().begin(), factory.listOfProduced().end(), outputIt ); 
  }
}

getAllFeatures()

template<class C, class T>

bool HLT::NavigationCore::getAllFeatures ( ElementLinkVector< C > & features, const std::string & label = "" ) const

inherited

gets all features of type T atachedd to whichever TE

Parameters

features	vector of pointers to features to which will be filled up
label	the label for a given feature
labels	list of all features of this type already in place and thier labels (of not specified) faster query

Returns

true if no errors encountered

getAllOfType() [1/2]

void NavigationCore::getAllOfType ( const std::string & id, std::vector< HLT::TriggerElement * > & output, const bool activeOnly = true ) const

inherited

return trigger elements given the name of TEs

Definition at line 401 of file NavigationCore.cxx.

                                                                 {
  if ( id == "" )
    return getAll(output, activeOnly);
  
  return TrigNavStructure::getAllOfType( string2hash(id, "TE"), output, activeOnly);
}

getAllOfType() [2/2]

void TrigNavStructure::getAllOfType ( const te_id_type id, std::vector< TriggerElement * > & output, const bool activeOnly = true ) const

inherited

The query returning a collection of all TriggerElements if name is given.

Parameters

id	name of TE, if "" given all TEs are returned

Definition at line 201 of file TrigNavStructure.cxx.

                                                   {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TriggerElementFactory& factory = getFactory();
 
  if ( not factory.listOfProduced(id).empty() ) {
    std::back_insert_iterator<std::vector<TriggerElement*> > outputIt( output );
 
    // 2 cases: only active ones, and all
    // one can consider sorting the TEs according to the activation status and then assume that collection is sorted
    // the same functor can be used as in copy_if
    if (activeOnly)
      remove_copy_if ( factory.listOfProduced(id).begin(), factory.listOfProduced(id).end(), outputIt, isNotActive );
    else
      copy ( factory.listOfProduced(id).begin(), factory.listOfProduced(id).end(), outputIt );
  }
}

getAllRoIThresholdTEs()

void TrigNavStructure::getAllRoIThresholdTEs ( std::vector< TriggerElement * > & output ) const

inherited

The query returns a vector of all TriggerElements that represent a LVL1 RoI threshold.

Definition at line 328 of file TrigNavStructure.cxx.

{
  const TriggerElement* initNode = getInitialNode();
  // get first layer of TEs representing the RoIs themselves (not the thresholds!)
  const std::vector<TriggerElement*>& rois = getDirectSuccessors(initNode);
  for ( const TriggerElement* roi_te : rois ) {
    // get threshold-like TEs:
    const std::vector<TriggerElement*>& tes = getDirectSuccessors( roi_te );
    for (TriggerElement* te : tes) {
      output.push_back( te );
    }
  }
}

getAllTEs() [1/2]

std::vector< TriggerElement * > & TrigNavStructure::getAllTEs ( )

inherited

access needed by slimming tools.

Definition at line 374 of file TrigNavStructure.cxx.

                                                        { 
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  TriggerElementFactory& factory = getFactory();
 
  return factory.listOfProduced();
} 

getAllTEs() [2/2]

const std::vector< TriggerElement * > & TrigNavStructure::getAllTEs ( ) const

inherited

access needed by slimming tools.

Definition at line 381 of file TrigNavStructure.cxx.

                                                                    { 
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TriggerElementFactory& factory = getFactory();
 
  return factory.listOfProduced();
} 

getDirectPredecessors()

const std::vector< TriggerElement * > & TrigNavStructure::getDirectPredecessors ( const TriggerElement * te )

staticinherited

returns list of direct predecessors (nodes seeding me)

Parameters

te	TriggerElement to query

Returns

collection of TriggerElements (if empty then node is initial)

Definition at line 120 of file TrigNavStructure.cxx.

                                                                                                   {
  return te->getRelated(TriggerElement::seededByRelation);
}

getDirectSuccessors()

const std::vector< TriggerElement * > & TrigNavStructure::getDirectSuccessors ( const TriggerElement * te )

staticinherited

returns list of direct predecessors (nodes I seed)

Parameters

te	TriggerElement to query

Returns

collection of TriggerElements (if empty then node is terminal)

Definition at line 124 of file TrigNavStructure.cxx.

                                                                                                {
  return te->getRelated(TriggerElement::seedsRelation);
}

getFactory() [1/2]

TriggerElementFactory & HLT::TrigNavStructure::getFactory ( )

inlineprotectedinherited

Definition at line 369 of file TrigNavStructure.h.

{ return *m_factory; }

getFactory() [2/2]

const TriggerElementFactory & HLT::TrigNavStructure::getFactory ( ) const

inlineprotectedinherited

Definition at line 373 of file TrigNavStructure.h.

{ return *m_factory; }

getFeature() [1/3]

template<class T>

bool HLT::NavigationCore::getFeature ( const TriggerElement * te, const ConstDataVector< T > *& features, const std::string & label = "", std::string & sourcelabel = ::HLT::TrigNavStructure::m_unspecifiedLabel ) const

inherited

getFeature() [2/3]

template<class T>

bool HLT::NavigationCore::getFeature ( const TriggerElement * te, const T *& features, const std::string & label = "", std::string & sourcelabel = ::HLT::TrigNavStructure::m_unspecifiedLabel ) const

inherited

getFeature() [3/3]

TriggerElement::FeatureAccessHelper TrigNavStructure::getFeature ( const TriggerElement * te, class_id_type clid, const index_or_label_type & index_or_label ) const

inherited

typeless feature access metod

Parameters

te	the TE from which the search should be done
clid	the class ID of searched type
sub	feature sub index (

See also

TriggerElement::ObjectIndex), if invalid_sub_type is passed then it is neglected

Returns

invalid FeatureAccessHelper is returned if nothng is found, else valid one

Definition at line 781 of file TrigNavStructure.cxx.

                                                                                                                                                            {
 
 
  TriggerElement::FeatureVec features;
  bool single = true; bool recursively = false;
  bool status = getFeatureAccessors(te, clid,index_or_label,single,features,recursively);
 
  if(status && !features.empty()){
    return features.front();
  }
  return TriggerElement::FeatureAccessHelper(); // not found
}

getFeatureAccessors()

bool NavigationCore::getFeatureAccessors ( const TriggerElement * te, class_id_type clid, const index_or_label_type & index_or_label, bool only_single_feature, TriggerElement::FeatureVec & features, bool travel_backward_recursively, const TriggerElement *& source = m_unspecifiedTE, std::string & sourcelabel = m_unspecifiedLabel ) const

virtualinherited

retrieve features accessors according to the requrements This method is actually workhorse for all above.

I.e. the TEs structure traversing happens inside it.

Parameters

te	is TriggerElement at which searching starts
clid	is ClassID of type which is searched for
label	is object label (as used by attachFeature), empty lables (i.e. == "") means any label, nonempty label means exact matching, and noverlty label == "!" means we are specifically looking for empty label
only_single_feature	if true means we are looking for only one last object (i.e. imagine several object of the same type attached to TE)
features	vector of FeatureAccessHelper objects to fill up
travel_backward_recursively	if true will doe actual travering TriggerElement structure to find objects, if false search will stop at the TriggerElement te
source	TriggerElement where the object was found (or query stopped)
sourcelabel	is labels which the object had (useful when calling this routine with empty label)

Reimplemented from HLT::TrigNavStructure.

Definition at line 410 of file NavigationCore.cxx.

                                                    {
  
  return TrigNavStructure::getFeatureAccessors(te,clid,index_or_label,only_single_feature,features,travel_backward_recursively,source,sourcelabel);
} 

getFeatureAccessorsSingleTE()

bool NavigationCore::getFeatureAccessorsSingleTE ( const TriggerElement * te, CLID clid, const index_or_label_type & index_or_label, bool only_single_feature, TriggerElement::FeatureVec & features, const TriggerElement *& source = ::HLT::TrigNavStructure::m_unspecifiedTE, std::string & sourcelabel = ::HLT::TrigNavStructure::m_unspecifiedLabel ) const

virtualinherited

Reimplemented from HLT::TrigNavStructure.

Definition at line 421 of file NavigationCore.cxx.

                                                         {
 
  bool status = TrigNavStructure::getFeatureAccessorsSingleTE(te,clid,index_or_label,only_single_feature,features,source,sourcelabel);
  
  //if query was via subindex we don't cache the query (no support yet)
  if(index_or_label.index() == 0) return status;
  
  return status;
}

getFeatureRecursively()

TriggerElement::FeatureAccessHelper TrigNavStructure::getFeatureRecursively ( const TriggerElement * startTE, class_id_type clid, const index_or_label_type & index_or_label, const TriggerElement *& sourceTE ) const

inherited

recursive search for features the function is similar to the above butif th features is not found at the startTE the search descends the structure of TEs until it is found.

It stops on RoI nodes.

Parameters

sourceTE

is the TE where the feature was found

Definition at line 795 of file TrigNavStructure.cxx.

                                                                                                                          {  
 
  TriggerElement::FeatureVec features;
  bool single = true; bool recursively = true;
  bool status = getFeatureAccessors(startTE, clid,index_or_label,single,features,recursively,sourceTE);
 
  if(status && !features.empty()){
    return features.front();
  }
  return TriggerElement::FeatureAccessHelper(); // not found
}

getFeatures()

template<class T>

bool HLT::NavigationCore::getFeatures ( const TriggerElement * te, std::vector< const T * > & features, const std::string & label = "", std::map< const T *, std::string > * labels = 0 ) const

inherited

retrieve features attached to given TriggerElement

Parameters

te	TriggerElement from retrieve
features	is collection to be feed
label	for additional marking of this feature
labels	list of all features of this type already in place and thier labels

Returns

false if error enountered, true if no error encountered

Warning

No error (return true) does not mean that features were found, therefore what has to be checked is ... returned bool and size of features vector (if it has grew).

getFeaturesInRoI()

template<class T>

bool HLT::NavigationCore::getFeaturesInRoI ( const TriggerElement * te, std::vector< const T * > & features, const std::string & label = "", std::map< const T *, std::string > * labels = 0 ) const

inherited

retrieve features attached to the RoIs seeding this TriggerElement

Parameters

te	TriggerElement from which start
features	is collection to be feed
label	for additional marking of this feature

Returns

false if error enountered, true if no error encountered

Parameters

labels

list of all features of this type already in place and thier labels (of not specified) faster query

Warning

No error (return true) does not mean that features were found, therefore what has to be checked is ... returned bool and size of features vector (if it has grew).

getFeaturesLinks()

template<class C, class T>

bool HLT::NavigationCore::getFeaturesLinks ( const TriggerElement * te, ElementLinkVector< C > & links, const std::string & label = "" ) const

inherited

getHolder() [1/5]

IHolder * NavigationCore::getHolder ( CLID clid, const std::string & label ) const

protectedinherited

as above

Definition at line 390 of file NavigationCore.cxx.

                                                                          {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TrigHolderStructure& holderstorage = getHolderStorage();
 
  return holderstorage.getHolder<IHolder>(clid, label);
}

getHolder() [2/5]

IHolder * NavigationCore::getHolder ( CLID clid, uint16_t subTypeIndex ) const

protectedinherited

as above but not type wise holder returned

Definition at line 383 of file NavigationCore.cxx.

                                                                         {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TrigHolderStructure& holderstorage = getHolderStorage();
 
  return holderstorage.getHolder<IHolder>(clid, subTypeIndex);
}

getHolder() [3/5]

template<class T>

HLTNavDetails::Holder< T > * HLT::NavigationCore::getHolder ( const std::string & label, uint16_t suggestedIndex ) const

protectedinherited

aware holder discovery, creates holder if needed

getHolder() [4/5]

template<class T>

HLTNavDetails::Holder< T > * HLT::NavigationCore::getHolder ( uint16_t subTypeIndex ) const

inherited

as above but does not create holder on demand (return 0 if not found)

getHolder() [5/5]

const BaseHolder * TrigNavStructure::getHolder ( const TriggerElement::FeatureAccessHelper & fea ) const

inherited

Definition at line 921 of file TrigNavStructure.cxx.

                                                                                                { 
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TrigHolderStructure& holderstorage = getHolderStorage();
 
  return holderstorage.getHolderForFeature(fea);
}

getHolderStorage() [1/2]

TrigHolderStructure & HLT::TrigNavStructure::getHolderStorage ( )

inlineprotectedinherited

Definition at line 370 of file TrigNavStructure.h.

{ return *m_holderstorage; }

getHolderStorage() [2/2]

const TrigHolderStructure & HLT::TrigNavStructure::getHolderStorage ( ) const

inlineprotectedinherited

Definition at line 374 of file TrigNavStructure.h.

{ return *m_holderstorage; }

getInitialNode() [1/2]

TriggerElement * TrigNavStructure::getInitialNode ( )

inherited

gets initial node, if node is not there then it is created on fly

Definition at line 39 of file TrigNavStructure.cxx.

                                                 {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  TriggerElementFactory& factory = getFactory();
 
  if ( factory.empty() )
    factory.produce(0);
  return factory.listOfProduced().front();
}

getInitialNode() [2/2]

const TriggerElement * TrigNavStructure::getInitialNode ( ) const

inherited

Definition at line 48 of file TrigNavStructure.cxx.

                                                             {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TriggerElementFactory& factory = getFactory();
 
  if ( not factory.empty() )
    return factory.listOfProduced().front();
  return 0;
}

getMutex() [1/2]

std::recursive_mutex & HLT::TrigNavStructure::getMutex ( )

inlineprotectedinherited

Definition at line 371 of file TrigNavStructure.h.

{ return s_rmutex; }

getMutex() [2/2]

std::recursive_mutex & HLT::TrigNavStructure::getMutex ( ) const

inlineprotectedinherited

Definition at line 375 of file TrigNavStructure.h.

{ return s_rmutex; }

getNextKey()

template<class T>

const std::string HLT::Navigation::getNextKey

(

const std::string &

label = ""

)

Get the next key for a given object.

getRecentFeature()

template<class T>

bool HLT::NavigationCore::getRecentFeature ( const TriggerElement * te, const T *& feature, const std::string & label = "", const TriggerElement *& source = ::HLT::TrigNavStructure::m_unspecifiedTE, std::string & sourcelabel = ::HLT::TrigNavStructure::m_unspecifiedLabel ) const

inherited

getRecentFeatureDataOrElementLink()

template<class LinkType>

bool HLT::NavigationCore::getRecentFeatureDataOrElementLink ( const TriggerElement * te, LinkType & link, const std::string & label = "", const TriggerElement *& source = ::HLT::TrigNavStructure::m_unspecifiedTE, std::string & sourcelabel = ::HLT::TrigNavStructure::m_unspecifiedLabel ) const

inherited

getRecentFeatureLink()

template<class C, class T>

bool HLT::NavigationCore::getRecentFeatureLink ( const TriggerElement * te, ElementLink< C > & link, const std::string & label = "", const TriggerElement *& source = ::HLT::TrigNavStructure::m_unspecifiedTE, std::string & sourcelabel = ::HLT::TrigNavStructure::m_unspecifiedLabel ) const

inherited

getRecentFeatures()

template<class T>

bool HLT::NavigationCore::getRecentFeatures ( const TriggerElement * te, std::vector< const T * > & features, const std::string & label = "", std::map< const T *, std::string > * labels = 0 ) const

inherited

retrieve features attached to given TriggerElement or its predecessors the algorithm will go recursively to all predecessors and once the feature is found attached to given TE returns all features (of this type and label) attached to this TE

Parameters

te	TriggerElement from which to start
features	is vector to be filled up
label	for additional marking of this feature
labels	list of all features of this type already in place and thier labels (of not specified) faster query

Returns

false if error enountered, true if no error encountered

Warning

No error (return true) does not mean that features were found, therefore what has to be checked is ... returned bool and feature ptr != 0;

getRecentFeaturesLinks()

template<class C, class T>

bool HLT::NavigationCore::getRecentFeaturesLinks ( const TriggerElement * te, ElementLinkVector< C > & links, const std::string & label = "" ) const

inherited

getRoINodes()

const std::vector< TriggerElement * > & TrigNavStructure::getRoINodes ( const TriggerElement * somenode )

staticinherited

gets all RoI type nodes seeding indirectly this TriggerElement

For getting all RoI nodes one can call getDirectrSuccessors(getIntialNode()

Warning

If this method is called for RoI node then it returns all TEs originating from it

Definition at line 73 of file TrigNavStructure.cxx.

                                                                                                {
  return somenode->getRelated(TriggerElement::sameRoIRelation);
}

getSuccessor()

const TriggerElement * TrigNavStructure::getSuccessor ( const TriggerElement * te, unsigned int id )

staticinherited

returns successor of given type beeing seeded from this TE

Parameters

te	TriggerElement to query
id	the id of the successor TreiggerElement to find

Returns

TriggerElement pointer which can be 0

Warning

the implementation is recursive

Definition at line 129 of file TrigNavStructure.cxx.

                                                                                                {
  if ( te->getId() == id )
    return te;
  std::vector<TriggerElement*>::const_iterator it;
  const TriggerElement* found(0);
  for ( it = TrigNavStructure::getDirectSuccessors(te).begin() ; it !=  TrigNavStructure::getDirectSuccessors(te).end() ; ++it ) {
    found = getSuccessor(*it, id);
    if (found)
      break;
  }
  return found;
}

getTopologicallySpannedBy()

bool TrigNavStructure::getTopologicallySpannedBy ( const TriggerElement * te, const std::vector< unsigned int > & types, std::vector< const TriggerElement * > & children, const bool activeOnly = true ) const

inherited

gets the TEs whose predecessors were used to built a given topological TE

Parameters

te	topological TE from which to start
types	vector of types to search for
childs	vector of retrieved TEs; empty in case some of the required TEs cannot be found or are not active (see the activeOnly parameter)
activeOnly	optional parameter specifying whether inactive TEs should be discarded from the search; true by default

Definition at line 712 of file TrigNavStructure.cxx.

                                                                                                                          {
  if ( getDirectPredecessors(te).size() != types.size() ) {
    return false;
  }
 
  for ( unsigned i = 0 ; i < types.size(); ++i ) {
    const TriggerElement* child = getSuccessor( getDirectPredecessors(te)[i], types[i]);
    if(child!=0) {
      if(activeOnly && !child->getActiveState()) {
        children.clear();
        return true;
      }
      children.push_back(child);
    } else {
      children.clear();
      return true;
    }
  }
  return true;
}

getUniqueKey()

template<class T>

const std::string HLT::Navigation::getUniqueKey

(

const std::string &

label = ""

)

Get a unique key (not in the usual series) for a given object.

hasIdFromTheSet()

bool TrigNavStructure::hasIdFromTheSet ( const TriggerElement * te, std::vector< unsigned int > ids )

staticinherited

simple helper

Definition at line 491 of file TrigNavStructure.cxx.

                                                                                               {
  if ( find(ids.begin(), ids.end(), te->getId()) != ids.end() )
    return true;
  return false;
}

haveAllCommonRoIs()

bool TrigNavStructure::haveAllCommonRoIs ( const HLT::TriggerElement * te1, const HLT::TriggerElement * te2 )

staticinherited

Definition at line 447 of file TrigNavStructure.cxx.

                                                                                                {
  std::vector<TriggerElement*> vecRoINodes1 = getRoINodes(te1);
  std::vector<TriggerElement*> vecRoINodes2 = getRoINodes(te2);
  sort(vecRoINodes1.begin(), vecRoINodes1.end());
  sort(vecRoINodes2.begin(), vecRoINodes2.end());
  return vecRoINodes1 == vecRoINodes2;
}

haveCommonRoI()

bool TrigNavStructure::haveCommonRoI ( const TriggerElement * te1, const TriggerElement * te2 )

staticinherited

does this 2 share RoI

RoI node itself can be passed, then it will tell if a given TriggerElement is originating in this RoI for simple TriggerElement it is a bit overkill since it assumed that the number of RoIs can be any

Warning

this algorithm should not be used by sort or unique STL algorithms. Comparing algorithms are required to be "Strict weak ordering" i.e.return false if comparing x and x and if x < y and y < z then x < z (transitivity). Sort algorithm will simply misbehave (crash trying to access objects under address 0)

Returns

true if there is at least one common RoI

Definition at line 414 of file TrigNavStructure.cxx.

                                                                                           {
  std::vector<const TriggerElement*> vecRoINodes;
 
  if ( isRoINode(te1) ) {
    vecRoINodes.push_back(te1);
  } else {
    std::back_insert_iterator<std::vector<const TriggerElement*> > outputIt( vecRoINodes );
    copy(te1->getRelated(TriggerElement::sameRoIRelation).begin(), te1->getRelated(TriggerElement::sameRoIRelation).end(),  outputIt);
  }
  if ( isRoINode(te2) ) {
    vecRoINodes.push_back(te2);
  } else {
    std::back_insert_iterator<std::vector<const TriggerElement*> > outputIt( vecRoINodes );
    copy(te2->getRelated(TriggerElement::sameRoIRelation).begin(), te2->getRelated(TriggerElement::sameRoIRelation).end(),  outputIt);
  }
  // sort (by pointers, it is OK do not be scared)
  sort(vecRoINodes.begin(), vecRoINodes.end());
 
  std::vector<const TriggerElement*>::const_iterator it;
  it = adjacent_find(vecRoINodes.begin(), vecRoINodes.end());
 
  if ( it == vecRoINodes.end() )
    return false;
  
  return true;
}

haveCommonSeed()

bool TrigNavStructure::haveCommonSeed ( const TriggerElement * te1, const TriggerElement * te2 )

staticinherited

checks that there is any common predecessor of two TriggerElements

Warning

See comments on haveCommonRoI. The same applies.

Definition at line 459 of file TrigNavStructure.cxx.

                                                                                             {
  std::vector<const TriggerElement*> vecRoINodes;
  std::back_insert_iterator<std::vector<const TriggerElement*> > outputIt( vecRoINodes );
 
  copy(te1->getRelated(TriggerElement::seededByRelation).begin(),
       te1->getRelated(TriggerElement::seededByRelation).end(),  outputIt);
 
  copy(te2->getRelated(TriggerElement::seededByRelation).begin(),
       te2->getRelated(TriggerElement::seededByRelation).end(),  outputIt);
 
  // sort (by pointers, it is OK do not be scared)  & uniq
  sort(vecRoINodes.begin(), vecRoINodes.end());
 
  std::vector<const TriggerElement*>::iterator it;
  it = adjacent_find(vecRoINodes.begin(), vecRoINodes.end());
  if ( it == vecRoINodes.end() ) // after uniquing we still are
    return false;
  return true;
}

haveDistinctRoI()

bool TrigNavStructure::haveDistinctRoI ( const TriggerElement * te1, const TriggerElement * te2 )

staticinherited

inversion of haveCommonRoI

But notice it is more suitable for SLT sort etc. since for comparison 2 identical objects it returns false. However the transitivity can't be guaranteed.

Definition at line 442 of file TrigNavStructure.cxx.

                                                                                             {
  return ! haveCommonRoI(te1, te2);
}

haveDistinctSeed()

bool TrigNavStructure::haveDistinctSeed ( const TriggerElement * te1, const TriggerElement * te2 )

staticinherited

inversion of haveCommonSeed

Definition at line 479 of file TrigNavStructure.cxx.

                                                                                               {
  return ! haveCommonSeed(te1, te2);
}

increasingOrderByTEId()

bool TrigNavStructure::increasingOrderByTEId ( const TriggerElement * te1, const TriggerElement * te2 )

staticinherited

for sorting TriggerElements according to their id

Note that this methods are not complementary. (It is required to be usable for STL algorithms.)

Definition at line 483 of file TrigNavStructure.cxx.

                                                                                                  {
  return te1->getId() < te2->getId();
}

initialize()

StatusCode Navigation::initialize ( )

overridevirtual

Definition at line 48 of file Navigation.cxx.

                                  {
 
  // initialize some pointers of our base class
  //m_log = &msg();
  m_storeGate = evtStore().operator->();
 
  ATH_CHECK( m_serializerServiceHandle.retrieve() );
  m_serializerSvc = m_serializerServiceHandle.operator->();
 
  m_fullholderfactory.prepare(m_storeGate, m_serializerSvc, m_readonly);
  m_holderfactory = &m_fullholderfactory;
 
  ATH_CHECK(m_clidSvc.retrieve());
 
  // payload def
  ATH_CHECK( classKey2CLIDKey(m_classesToPayloadProperty,  m_classesToPayload) );
  ATH_CHECK( classKey2CLIDKey(m_classesToPayloadProperty_DSonly,  m_classesToPayload_DSonly) );
 
  // ignored classes
  std::vector<CSPair> ignore;
  ATH_CHECK( classKey2CLIDKey(m_classesFromPayloadIgnoreProperty, ignore) );
  if ( !ignore.empty() ) {
    ATH_MSG_INFO( "Ignoring " << m_classesFromPayloadIgnoreProperty << " during deserialization");
  }
  for (const auto& c : ignore) {
    ATH_MSG_DEBUG("Ignoring CLID " << c.first << (c.second.empty() ? "" : " with label "+c.second) <<
                 " during deserialization");
    m_fullholderfactory.addClassToIgnore(c.first, c.second);
  }
 
  // initialize converters
  for (const CSPair& p : m_classesToPayload) {
    const CLID cl = p.first;
    StatusCode stmp = m_serializerSvc->addConverter(cl);
    if (stmp.isFailure())
      ATH_MSG_WARNING("Initialization of a converter for CLID=" << cl << " failed");
  }
 
  // preregistration def
  ATH_CHECK( classKey2CLIDKey(m_classesToPreregisterProperty,  m_classesToPreregister) );
 
  // print out registered holders
  if ( msgLvl(MSG::VERBOSE) ) {
    for (const auto& [clid, holder] : HLT::TypeMaps::holders()) {
      if (holder==nullptr)
        ATH_MSG_ERROR("static type information not intialized. Holder is null pointer");
      else
        ATH_MSG_VERBOSE(*holder);
    }
  }
 
  // load libraries
  for ( const std::string& dll : m_dlls ) {
    System::ImageHandle handle = 0;
    if ( System::loadDynamicLib( dll, &handle)  != 1 )
      ATH_MSG_WARNING("failed to load " << dll);
    else
      ATH_MSG_DEBUG("forcibly loaded library " << dll);
  }
 
  ATH_MSG_DEBUG(" successfully initialized Navigation");
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isCompatibleTree()

bool TrigNavStructure::isCompatibleTree ( const TriggerElement * te1, const TriggerElement * te2 )

staticinherited

check compatibility of 2 navigation structures

This what is checked is only the id of trigger elements whether they are having the same place in the navigation structure; have identical subtrees (check is recursive)

Definition at line 524 of file TrigNavStructure.cxx.

                                                                                              {
  using namespace std;
  if ( te1->getId() != te2->getId() ) {
    return false; // distinc Id
  }
 
  if ( ( isTerminalNode(te1) && isTerminalNode(te2) ) )
    return true;  // no more checks needs to be done
  else if (  isTerminalNode(te1) || isTerminalNode(te2)  )
    return false; // one of both is terminal while another is not (case when both are terminal is covered above)
 
  // continue subchecks otherwise (both nonterminal)
 
  // folow seeds otherwise
  if ( te1->getRelated(TriggerElement::seedsRelation).size() !=  te2->getRelated(TriggerElement::seedsRelation).size() )
    return false;
 
  std::vector<TriggerElement*>::const_iterator seededByTe1 = te1->getRelated(TriggerElement::seedsRelation).begin();
  std::vector<TriggerElement*>::const_iterator seededByTe2 = te2->getRelated(TriggerElement::seedsRelation).begin();
 
  for ( ; seededByTe1 != te1->getRelated(TriggerElement::seedsRelation).end(); ++seededByTe1, ++seededByTe2 ) {
    if (isCompatibleTree(*seededByTe1, *seededByTe2) == false) // grrr,wrrr recursive call here
      return false;
  }
  // there I should probably check as well the Features attached to the TEs
 
  return true;
}

isInitialNode()

bool TrigNavStructure::isInitialNode ( const TriggerElement * te )

staticinherited

queries if node is an initial one

Parameters

te	node to be queried

Returns

true if passed node is initial

Definition at line 499 of file TrigNavStructure.cxx.

                                                               {
  if ( te->getRelated(TriggerElement::seededByRelation).empty() and te->getId() == 0 )
    return true;
  return false;
}

isNotActive()

bool HLT::TrigNavStructure::isNotActive ( const TriggerElement * te )

inlinestaticinherited

helper for the STL

Definition at line 257 of file TrigNavStructure.h.

{ return !te->getActiveState(); }

isRoINode()

bool TrigNavStructure::isRoINode ( const TriggerElement * te )

staticinherited

queries if node is an RoI type one

Parameters

te	node to be queried

Returns

true if passed node is RoI type

Definition at line 505 of file TrigNavStructure.cxx.

                                                            {
  if ( te->getRelated( TriggerElement::seededByRelation ).empty() ) // this s initial node
    return false;
 
  TriggerElement* whoSeedsMe = *(te->getRelated( TriggerElement::seededByRelation ).begin());
  if ( isInitialNode(whoSeedsMe) )
    return true;
  return false;
}

isTerminalNode()

bool TrigNavStructure::isTerminalNode ( const TriggerElement * te )

staticinherited

queries if node is terminal (no more TriggerElement are seeded by it)

Parameters

te	node to be queried

Returns

true if passed node is terminal

Definition at line 515 of file TrigNavStructure.cxx.

                                                                {
  if ( te->getRelated( TriggerElement::seedsRelation ).empty()  )
    return true;
  return false;
}

isTopological()

bool HLT::TrigNavStructure::isTopological ( const TriggerElement * te )

inlinestaticinherited

Definition at line 259 of file TrigNavStructure.h.

{ return (getDirectPredecessors(te).size() > 1 ? true : false); }

label()

std::string TrigNavStructure::label ( class_id_type clid, const index_or_label_type & sti_or_label ) const

inherited

Definition at line 773 of file TrigNavStructure.cxx.

                                                                                                   {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TrigHolderStructure& holderstorage = getHolderStorage();
 
  return holderstorage.getLabel(clid,sti_or_label);
}

matchFeature()

bool TrigNavStructure::matchFeature ( const TriggerElement::FeatureAccessHelper & fea, class_id_type clid, const index_or_label_type & index_or_label ) const

protectedinherited

Definition at line 896 of file TrigNavStructure.cxx.

                                                                                                                                                     {
  //we always require the CLID to match
  if(fea.getCLID() != clid) return false;
 
  if(index_or_label.index() == 0){
    //subtype index case: if argument is invalid_sub_index we always match, else require exact match
    auto index = std::get<sub_index_type>(index_or_label) ;
    return (index == invalid_sub_index || index == fea.getIndex().subTypeIndex());
  }
 
  if(index_or_label.index() == 1){
    //label case: if argument is "" we always match, else require exact match (via)
    auto label = std::get<std::string>(index_or_label);
    if(label.empty()){
      return true;
    }
    label = (label == "!") ? "" : label;
    auto sub = subType(clid,label);
    if(sub == invalid_sub_index) return false;
    return matchFeature(fea,clid,sub);
  }
  return false;
}

merge()

bool NavigationCore::merge ( const NavigationCore & l2 )

inherited

attemtps to merge two trees

Definition at line 235 of file NavigationCore.cxx.

                                                   {
  std::lock_guard<std::recursive_mutex> l2lock(l2.getMutex());
  const TrigHolderStructure& l2Holderstorage = l2.getHolderStorage();
 
  // we need to pick the holders which are at L2 and move them to EF
  for(auto l2holder : l2Holderstorage.getAllHolders<IHolder>()){
    ATH_MSG_DEBUG("will add holder " << *l2holder);
    std::string label(l2holder->label());
    IHolder* efholder = getHolder(l2holder->typeClid(), label);
    if ( efholder != 0 ) {
      if ( (efholder->label() != l2holder->label())
       || (efholder->subTypeIndex() != l2holder->subTypeIndex()) ) {
    
        ATH_MSG_DEBUG("fixing bug for " << *efholder);
        // bug which we need to fix (some week of data in autumn 2008)
        // we have to delete current holder
        // and replace it by L2 one
        //
        // efholder->setSubTypeIndex(l2holder->subTypeIndex());
    
        ATH_MSG_DEBUG("after fixing   " << *efholder);
      }
    } else {
      ATH_MSG_DEBUG("cloning the holder from L2 " << *l2holder);
 
      bool status = createHolder(efholder, l2holder->typeClid(),l2holder->label(), l2holder->subTypeIndex());
      if(!status){
        ATH_MSG_WARNING("in merge could not create EF holder");
      }
      
      //not sure if there is any possibility for this case but check anyways -Lukas
      if(efholder->key()!=l2holder->key()){
        ATH_MSG_WARNING("in merge the created EF holder has different SG access key than L2 holder we tried to copy");
      }
      
      registerHolder(efholder);
    }
  }
  return true;
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

nextSubTypeIndex()

uint16_t NavigationCore::nextSubTypeIndex ( CLID clid, const std::string & label ) const

protectedinherited

Definition at line 287 of file NavigationCore.cxx.

                                                                             {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TrigHolderStructure& holderstorage = getHolderStorage();
 
  auto holders = holderstorage.getHoldersOfClid(clid);
 
  if ( holders.empty() )
    return m_objectsIndexOffset;
 
  std::vector<sub_index_type> sub_indices(holders.size());
  std::transform(holders.begin(), holders.end(), sub_indices.begin(),
         [](BaseHolder* h) -> sub_index_type { return h->subTypeIndex(); });
 
  return (*std::max_element(sub_indices.begin(),sub_indices.end()))+1;
}

object2FeatureLink() [1/2]

template<class T>

TrigFeatureLink HLT::NavigationCore::object2FeatureLink ( const TriggerElement * te, const std::string & label, const T * obj ) const

inherited

object2FeatureLink() [2/2]

template<class C>

TrigFeatureLink HLT::NavigationCore::object2FeatureLink ( const TriggerElement * te, const std::string & label, const typename Container2Object< C >::type * obj, const C * container ) const

inherited

operator=()

Navigation & HLT::Navigation::operator= ( const Navigation & )

protected

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

overlaps() [1/2]

bool TrigNavStructure::overlaps ( const TriggerElement * t1, const std::vector< TriggerElement * > & teVec ) const

inherited

Check overlap between a TE and a vector of TEs, using the method above.

Definition at line 698 of file TrigNavStructure.cxx.

                                                                                                        {
  for (std::vector<TriggerElement*>::const_iterator te2 = teVec.begin(); te2 !=  teVec.end(); ++te2)
    if (overlaps(te1, *te2)) return true;
 
  return false;
}

overlaps() [2/2]

bool TrigNavStructure::overlaps ( const TriggerElement * t1, const TriggerElement * t2 ) const

inherited

Check overlap between trigger elements (pointer equality or RoI overlap)

Definition at line 705 of file TrigNavStructure.cxx.

                                                                                          {
  if (te1 == te2) return true;
  if (haveCommonRoI(te1, te2)) return true;
 
  return false;
}

prepare()

void NavigationCore::prepare ( )

virtualinherited

prepapres the navigation for next event

Definition at line 335 of file NavigationCore.cxx.

                             {
  if ( msgLvl(MSG::VERBOSE) ) {
    for ( const auto& [clid, holder] : HLT::TypeMaps::holders() ) {
      ATH_MSG_VERBOSE("NavigationCore::prepare Compile time known types : " << *holder);
    }
  }
  
  ATH_MSG_VERBOSE("NavigationCore::prepare Preregistering objects #:" <<  m_classesToPreregister.size());
 
  // populate structure with "must have" features
  for ( const CSPair& conf : m_classesToPreregister ) {
    CLID clid = conf.first;
    std::string label  = conf.second;
    if ( prepareOneHolder(clid, label) == 0 ) {
      ATH_MSG_WARNING("NavigationCore::prepare failed preparing the holder for CLID: " << clid << " and label " << label);
    }
  }
  ATH_MSG_DEBUG("NavigationCore::prepare Navigation structure prepared for next event");
}

prepareOneHolder()

HLTNavDetails::IHolder * NavigationCore::prepareOneHolder ( CLID clid, const std::string & label )

privateinherited

Definition at line 303 of file NavigationCore.cxx.

                                                                                        {
 
  ATH_MSG_VERBOSE("NavigationCore::prepare preregistering objects of clid: " << clid << " label: " << label);
  IHolder *holder = getHolder(clid, label);
  if ( holder ) {    
    ATH_MSG_VERBOSE("NavigationCore::prepare preregistering objects  not executed as it already exists " << *holder);
    return holder;
  }
  
  uint16_t index =  nextSubTypeIndex(clid, label);
  ATH_MSG_VERBOSE("NavigationCore::prepare creating handler for type (CLID): " << clid
                  << " label: " << label << " index: " << index);
  
  if ( !createHolder(holder, clid, label, index) ) {
    ATH_MSG_INFO("NavigationCore::prepare Can't create storage for objects of CLID: " << clid << " as it is requested by configuration");
    return nullptr;
  }
 
  ATH_MSG_VERBOSE("Holder created, registering " << holder << " " << *holder);
 
  if ( !registerHolder(holder) ) {
    ATH_MSG_WARNING("Holder registration failed " << holder << " " << *holder);
    return nullptr;
  }
  if ( !holder->syncWithSG() ) {
    ATH_MSG_WARNING("Holder SG sync failed" << holder << " " << *holder);
    return nullptr;
  }
  
  return holder;
}

printASCIIArt()

void TrigNavStructure::printASCIIArt ( std::string & str, const TriggerElement * te = 0, int offset = 0 ) const

inherited

pretty printing of the navigational structure (heavy)

Definition at line 152 of file TrigNavStructure.cxx.

                                                                                                {
  using namespace std;
  const TriggerElement* initialNode = getInitialNode();
  if ( initialNode == 0 )
    return;
 
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TriggerElementFactory& factory = getFactory();
 
 
  if ( !te )
    te = initialNode;
 
  if ( te == initialNode ) {
    // loop over all TEs which are not seeded by anything but are not initial nodes
    const std::vector< TriggerElement* >& allTEs = factory.listOfProduced();
    std::vector< TriggerElement* >::const_iterator allIt;
    for (allIt = allTEs.begin(); allIt != allTEs.end(); ++allIt) {
      if ((*allIt)->getRelated(TriggerElement::seededByRelation).size() == 0 && *allIt != getInitialNode() )
        printASCIIArt(str, *allIt);
    }
  }
 
  ostringstream ss;
  // pretty print
  for ( int i=0; i < offset; i++ ) {
    ss << "| ";
    //cout << "  ";
  }
  ss << "\\_";
 
  ss << "id:" << dec << te->getId() << ";"
     << "active:" <<(te->getActiveState() ? "1" : "0" ) << ";"
     << "error:" <<(te->getErrorState() ? "1" : "0" ) << ";"
     << "ptr:" << hex << te << ";"
     << "#seeds:" << dec << te->getRelated(TriggerElement::seedsRelation).size() << ",";
  // add all ptrs
  std::vector<TriggerElement*>::const_iterator seedIt;
  for ( seedIt = getDirectSuccessors(te).begin();  seedIt != getDirectSuccessors(te).end(); ++seedIt ) {
    ss << *seedIt <<" ";
  }
 
  ss << "#seededBy:" << dec << te->getRelated(TriggerElement::seededByRelation).size() << ";"
     << "#RoI:" << dec << te->getRelated(TriggerElement::sameRoIRelation).size()  << ";"
     << "#features:" << te->getFeatureAccessHelpers().size() << ";";
  for ( auto& fea: te->getFeatureAccessHelpers() ) {
    ss << fea;
  }
  ss << std::endl;
 
  std::string str2;
  str2 = ss.str();
  str += str2;
 
  if ( ! isTerminalNode(te) ) {
    std::vector < TriggerElement* >::const_iterator it = te->getRelated( TriggerElement::seedsRelation ).begin();
    std::vector < TriggerElement* >::const_iterator itEnd   = te->getRelated( TriggerElement::seedsRelation ).end();
    for (  ; it != itEnd; ++it ) {
      std::string str2;
      printASCIIArt(str, *it, offset+1);
      str += str2;
    }
  }
}

propagateDeactivation()

bool TrigNavStructure::propagateDeactivation ( const TrigNavStructure * nav )

inherited

propagates deactivation of TE state This finction should be used after Trigger is rerurn on L2 and then the reruning on L2 is required.

The deactivated lines must be propagated ahead.

Parameters

nav	is navigation which was reprocessed (additional branches deactivated)

Returns

true is all went fine, false in case it is spoted that the 2 navigation structures were not initially same

Definition at line 555 of file TrigNavStructure.cxx.

                                                                        {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  TriggerElementFactory& factory = getFactory();
  const TriggerElementFactory& oldFactory = nav->getFactory();
 
 
  // basic checks first
  if (  oldFactory.listOfProduced().size() > factory.listOfProduced().size() )
    return false;
 
  std::vector< TriggerElement* >::const_iterator old = oldFactory.listOfProduced().begin();
  std::vector< TriggerElement* >::iterator me = factory.listOfProduced().begin();
  //  int i = 0;
  do {
    (*me)->setActiveState((*old)->getActiveState());
    ++me;
    ++old;
  } while ( old != oldFactory.listOfProduced().end() );
  return true;
}

registerFeatureContainer()

template<class T, class C>

void HLT::NavigationCore::registerFeatureContainer ( )

staticinherited

Specialized by type and container for this type.

registerHolder()

bool NavigationCore::registerHolder ( HLTNavDetails::IHolder * holder )

protectedinherited

Definition at line 355 of file NavigationCore.cxx.

                                                   {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  TrigHolderStructure& holderstorage = getHolderStorage();
 
  auto shared_holder = std::shared_ptr<HLT::BaseHolder>(holder);
  holderstorage.registerHolder(shared_holder);
  ATH_MSG_DEBUG("registerHolder for OK " << *holder);
  return true;
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

reset()

void NavigationCore::reset ( bool inFinalize = false )

virtualinherited

resets all the navigation, goes to the factory and asks to withdraw all produced objects

Reimplemented from HLT::TrigNavStructure.

Definition at line 281 of file NavigationCore.cxx.

                                          {
  TrigNavStructure::reset(inFinalize);
 
  ATH_MSG_DEBUG("Navigation reset done");
}

serialize() [1/3]

bool NavigationCore::serialize ( std::vector< uint32_t > & output ) const

virtualinherited

method serizlizes the navigation structure The structure is serrizlized in following order ...

1. TEs(together with links)
2. features in accordane to the lists given in property ClassesToPayload

The truncation mechainsm. The parameter space should be given to the method. No more space than that will be ever taken. But since the actuall space limitation is not known at the time whrn this call happens additional list of safe to cut places is returned. One may ask why no tonly this cuts. ... Answer is follwing. If the event is huge then giving this rought limit would make procedure faster since not all features will be serialized. Otherwice they would be serialized and then thrown away, which is waste of CPU. For safe operation one can easilly make space huge (like 2MB) and not care. But for online such tuning can be considered. Space can be given as a property.

Parameters

output	vector to place the result
cuts	are indexes where one can safely cut the navigation

Returns

if true then OK if false then truncated because of missing space - if output.size() != 0 if false and output.size() == 0 internal error

Implements HLT::TrigNavStructure.

Definition at line 81 of file NavigationCore.cxx.

                                                                 {
  std::vector<unsigned int> cuts;
  return serialize(output,cuts);
}

serialize() [2/3]

bool NavigationCore::serialize ( std::vector< uint32_t > & output, std::vector< unsigned int > & cuts ) const

inherited

Definition at line 86 of file NavigationCore.cxx.

                                                                                                 {
  std::vector<std::pair<CLID, std::string> > clid_name;
  clid_name.clear();
  return serialize(output, cuts, clid_name);
}

serialize() [3/3]

bool NavigationCore::serialize ( std::vector< uint32_t > & output, std::vector< unsigned int > & cuts, std::vector< std::pair< CLID, std::string > > & clid_name ) const

inherited

Definition at line 92 of file NavigationCore.cxx.

                                                                                                                                                  {
  std::vector<uint32_t> holderdata;
  std::vector<unsigned int> holderblobsizes;
 
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TrigHolderStructure& holderstorage = getHolderStorage();
 
  bool status = false;
  if ( m_classesToPayload.empty() ) { // this is offline case
    status = serializeHoldersWithoutPayload(holderstorage.getAllHolders<IHolder>(),holderdata, holderblobsizes, clid_name);
  } else { // this is online case when list of classes to payload is not empty
    status = serializeHoldersWithPayload(m_classesToPayload,holderdata,holderblobsizes,clid_name);
  }
 
  if(!status){
    ATH_MSG_WARNING("holder serialization failed");
    return false;
  }
  
  status = serializeWithHolderSection(holderdata,holderblobsizes,output,cuts,clid_name);
 
  if(!status){
    ATH_MSG_WARNING("full serialization failed");
    return false;
  }
 
  ATH_MSG_DEBUG("total size of serialized navigation: " << output.size());
 
  return true;
}

serialize_DSonly()

bool NavigationCore::serialize_DSonly ( std::vector< uint32_t > & output, std::vector< unsigned int > & cuts, std::vector< std::pair< CLID, std::string > > & clid_name ) const

inherited

Definition at line 123 of file NavigationCore.cxx.

                                                                                                                                                         {
  std::vector<uint32_t> holderdata;
  std::vector<unsigned int> holderblobsizes;
 
  bool status = serializeHoldersWithPayload(m_classesToPayload_DSonly,holderdata,holderblobsizes,clid_name);
  if(!status){
    ATH_MSG_WARNING("holder serialization failed");
    return false;
  }
 
  status = serializeWithHolderSection(holderdata,holderblobsizes,output,cuts,clid_name);
  if(!status){
    ATH_MSG_WARNING("full serialization failed");
    return false;
  }
  
  ATH_MSG_DEBUG("total size of serialized navigation (DS only): " << output.size());
 
  return true;
}

serializeHoldersWithoutPayload()

bool NavigationCore::serializeHoldersWithoutPayload ( const std::vector< HLTNavDetails::IHolder * > & holders, std::vector< uint32_t > & output, std::vector< uint32_t > & holderblobsizes, std::vector< std::pair< CLID, std::string > > & clid_name ) const

privateinherited

Definition at line 502 of file NavigationCore.cxx.

                                                                                                                                                                                                                {
  for(auto& holder : holders){
    ATH_MSG_DEBUG("serialization of feature: " << holder->typeClid() << " label: " << holder->label()
        << " size of payload: " << output.size());
    
    std::vector<uint32_t> holderblob;
    bool status = holder->serialize(holderblob);
    if(!status){
      ATH_MSG_WARNING("problem serializing holder: " << *holder);
      return false;
    }
    output.push_back(holderblob.size()); //leading bit indicates size
    output.insert(output.end(),holderblob.begin(),holderblob.end());
    
    holderblobsizes.push_back(1+holderblob.size()); //one for leading size bit 
    clid_name.push_back(std::pair < CLID, std::string> (holder->typeClid(), holder->label()));
  }
  return true;
}

serializeHoldersWithPayload()

bool NavigationCore::serializeHoldersWithPayload ( const std::vector< CSPair > & payload, std::vector< uint32_t > & output, std::vector< uint32_t > & holderblobsizes, std::vector< std::pair< CLID, std::string > > & clid_name ) const

privateinherited

Definition at line 468 of file NavigationCore.cxx.

                                                                                {
 
  ATH_MSG_DEBUG("serialization: number of classes to payload: " << payload.size());
  for ( auto& cl :  payload) {
    ATH_MSG_DEBUG("serialization (ordered) of featue attempting : " <<  cl.first << " " <<  cl.second);
    
    IHolder *holder = getHolder(cl.first,cl.second);
    if ( ! holder ) {
      ATH_MSG_DEBUG("serialization (ordered) of feature skipped, nothing know on this objects" );
      continue;
    }
    ATH_MSG_DEBUG("serialization (ordered) of feature: " << holder->typeClid() << " label: " << holder->label()
        << " size of payload up to now: " << output.size());
    
    std::vector<uint32_t> holderblob;
    size_t payloadsize = 0;
    bool status = holder->serializeWithPayload(cl.sel,holderblob,payloadsize);
    if(!status){
      ATH_MSG_WARNING("problem serializing holder: " << *holder);
      return false;
    }
 
    output.push_back(holderblob.size()); //leading bit indicates size
    output.insert(output.end(),holderblob.begin(),holderblob.end());
    
    holderblobsizes.push_back(1+holderblob.size()); //one for leading size bit 
    clid_name.push_back(std::pair < CLID, std::string> (holder->typeClid(), holder->label()));
  }
 
  return true;
}

serializeTEs()

bool TrigNavStructure::serializeTEs ( std::vector< uint32_t > & output ) const

inherited

method serizlizes the navigation structure

Parameters

output

vector to place the result

Returns

if true then OK else some sort of failure happened (likely badly truncated structure)

Definition at line 217 of file TrigNavStructure.cxx.

                                                                       {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TriggerElementFactory& factory = getFactory();
 
  ::HLTNavDetails::FillSize fs(output);
 
  const std::vector<TriggerElement*>& fullList =  factory.listOfProduced();
  std::vector<TriggerElement*> all;
  all.reserve(fullList.size());
 
  for(std::vector<TriggerElement*>::const_iterator iter = fullList.begin(); iter != fullList.end(); ++iter) {
    if(! (*iter)->transient() ) {
      all.push_back( *iter );
    }
  }
 
  // reserve space (in order to be efficient it should not be resized any more, this can be studied probably later to find optimum)
  output.reserve(10*all.size());
 
  // SERIALZE NAVIGATION STRUCTURE
  // size (measured in elements)
  output.push_back(all.size());
 
  // helper keys
  std::map<TriggerElement*, uint16_t> keys;
 
  const TriggerElement* previous = 0;
  std::vector<TriggerElement*>::const_iterator it;
  uint16_t indexForTe = 0;
  for ( it = all.begin(); it != all.end(); ++it ) {
    // first we stream pointer as it (this is already an unique key for this TE)
    //    output.push_back((unsigned int)(*it));
    (*it)->serialize(output, keys, previous);
    previous = *it;
    keys[*it] =  indexForTe;
    indexForTe++;
  }
 
  return true;
}

serializeWithHolderSection()

bool NavigationCore::serializeWithHolderSection ( const std::vector< uint32_t > & holderdata, const std::vector< unsigned int > & holderblobsizes, std::vector< uint32_t > & output, std::vector< unsigned int > & cuts, std::vector< std::pair< CLID, std::string > > & clid_name ) const

privateinherited

Definition at line 436 of file NavigationCore.cxx.

                                                                                                                              {
  cuts.clear();
  // clid_name.clear(); Don't reset this vector here since the vector is not remade. Otherwise datascouting stops working.
 
  unsigned int version=4;
  ATH_MSG_DEBUG("NavigationCore::serialize: serializing with version " << version);
 
  output.push_back(version);
 
  unsigned int totalSizeIndex = output.size();
  output.push_back(0); // reserve one word (accessible under the index totalSize), it is 0 if there was truncation here
                       // and != output.size() if truncation using cuts
 
  cuts.push_back(output.size()); // mark a cut place
 
  bool tesSerializationStatus = serializeTEs(output);
 
  ATH_MSG_DEBUG("serializes: TE serialization status: " << tesSerializationStatus << " size: " << output.size());
 
  cuts.push_back(output.size()); // mark a cut place
 
  output.insert(output.end(),holderdata.begin(),holderdata.end());
 
  for(auto hc : holderblobsizes){cuts.push_back(cuts.back()+hc);}
 
  output[totalSizeIndex] = output.size();
 
  ATH_MSG_DEBUG("serialization done");
  return true;
}

string2hash()

uint32_t NavigationCore::string2hash ( const std::string & s, const std::string & category = "TE" )

staticinherited

convert strin g to hash.

This is just making the function available, since there is no dict for TrigConf::HLTUtils

Definition at line 397 of file NavigationCore.cxx.

                                                                                    {
  return TrigConf::HLTUtils::string2hash(s, category);
}

subType()

sub_index_type TrigNavStructure::subType ( class_id_type clid, const index_or_label_type & sti_or_label ) const

inherited

Definition at line 766 of file TrigNavStructure.cxx.

                                                                                                          {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TrigHolderStructure& holderstorage = getHolderStorage();
 
  return holderstorage.getSubTypeIndex(clid,sti_or_label);
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

const TriggerElement* m_unspecifiedTE HLT::TrigNavStructure::ATLAS_THREAD_SAFE

staticprotectedinherited

Definition at line 377 of file TrigNavStructure.h.

ATLAS_THREAD_SAFE [2/2]

std::string m_unspecifiedLabel HLT::TrigNavStructure::ATLAS_THREAD_SAFE

staticprotectedinherited

Definition at line 378 of file TrigNavStructure.h.

m_classesFromPayloadIgnoreProperty

std::vector<std::string> HLT::NavigationCore::m_classesFromPayloadIgnoreProperty

protectedinherited

list of classes#keys to ignore on deserialization

Definition at line 394 of file NavigationCore.h.

m_classesToPayload

std::vector<CSPair> HLT::NavigationCore::m_classesToPayload

protectedinherited

classess are put to payload according to that priority list (CLID + key)

Definition at line 389 of file NavigationCore.h.

m_classesToPayload_DSonly

std::vector<CSPair> HLT::NavigationCore::m_classesToPayload_DSonly

protectedinherited

classess are put to payload according to that priority list (CLID + key)

Definition at line 392 of file NavigationCore.h.

m_classesToPayloadProperty

std::vector<std::string> HLT::NavigationCore::m_classesToPayloadProperty

protectedinherited

list of classes#keys to be put to BS payload

Definition at line 388 of file NavigationCore.h.

m_classesToPayloadProperty_DSonly

std::vector<std::string> HLT::NavigationCore::m_classesToPayloadProperty_DSonly

protectedinherited

list of classes#keys to be put to DS payload

Definition at line 391 of file NavigationCore.h.

m_classesToPreregister

std::vector<CSPair> HLT::NavigationCore::m_classesToPreregister

protectedinherited

classes mentioned here will be put to SG irrespectively of thier presence in event

Definition at line 397 of file NavigationCore.h.

m_classesToPreregisterProperty

std::vector<std::string> HLT::NavigationCore::m_classesToPreregisterProperty

protectedinherited

as above but for preregistration

Definition at line 396 of file NavigationCore.h.

m_clidSvc

ServiceHandle<IClassIDSvc> HLT::Navigation::m_clidSvc

private

Definition at line 168 of file Navigation.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_dlls

Gaudi::Property<std::vector<std::string> > HLT::Navigation::m_dlls {this, "Dlls", {}, "Libraries to load (with trigger EDM)", "OrderedSet<T>"}

private

Definition at line 169 of file Navigation.h.

{this, "Dlls", {}, "Libraries to load (with trigger EDM)", "OrderedSet<T>"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_factory

SG::SlotSpecificObj<TriggerElementFactory> HLT::TrigNavStructure::m_factory

privateinherited

factory of trigger elements (one per processing slot)

Definition at line 382 of file TrigNavStructure.h.

m_fullholderfactory

FullHolderFactory HLT::Navigation::m_fullholderfactory

private

Definition at line 170 of file Navigation.h.

m_holderfactory

ITrigHolderFactory* HLT::NavigationCore::m_holderfactory

protectedinherited

Definition at line 375 of file NavigationCore.h.

m_holderstorage

SG::SlotSpecificObj<TrigHolderStructure> HLT::TrigNavStructure::m_holderstorage

privateinherited

structure for feature holders (one per processing slot)

Definition at line 383 of file TrigNavStructure.h.

m_logger

const AthAlgTool& HLT::NavigationCore::m_logger

privateinherited

Definition at line 406 of file NavigationCore.h.

m_objectsIndexOffset

unsigned HLT::NavigationCore::m_objectsIndexOffset

protectedinherited

small integer used to generate sub type index

Definition at line 372 of file NavigationCore.h.

m_objectsKeyPrefix

std::string HLT::NavigationCore::m_objectsKeyPrefix

protectedinherited

property setting prefix which is to be given to all trigger EDM objects

Definition at line 371 of file NavigationCore.h.

m_readonly

bool HLT::Navigation::m_readonly

private

Definition at line 171 of file Navigation.h.

m_serializerServiceHandle

ServiceHandle<IConversionSvc> HLT::Navigation::m_serializerServiceHandle

private

Definition at line 167 of file Navigation.h.

m_serializerSvc

IConversionSvc* HLT::NavigationCore::m_serializerSvc

protectedinherited

Definition at line 369 of file NavigationCore.h.

m_storeGate

StoreGateSvc* HLT::NavigationCore::m_storeGate

protectedinherited

Definition at line 370 of file NavigationCore.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

s_rmutex

std::recursive_mutex TrigNavStructure::s_rmutex

staticprivateinherited

Definition at line 385 of file TrigNavStructure.h.

---

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

• Navigation.h
• Navigation.cxx