ATLAS Offline Software
Classes | Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Static Protected Attributes | Private Member Functions | Private Attributes | Static Private Attributes | Friends | List of all members
HLT::NavigationCore Class Reference

The NavigationCore class, adds on top of the TrigNavStructure the EDM read-only handling. More...

#include <NavigationCore.h>

Inheritance diagram for HLT::NavigationCore:
Collaboration diagram for HLT::NavigationCore:

Classes

struct  CSPair
 

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

 NavigationCore (const AthAlgTool &logger)
 constructor with parent AlgTool for printing More...
 
virtual ~NavigationCore ()=default
 
virtual void prepare ()
 prepapres the navigation for next event More...
 
virtual void reset (bool inFinalize=false)
 resets all the navigation, goes to the factory and asks to withdraw all produced objects More...
 
virtual bool serialize (std::vector< uint32_t > &output) const
 method serizlizes the navigation structure The structure is serrizlized in following order ... More...
 
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 More...
 
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
 
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 More...
 
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. More...
 
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 More...
 
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 More...
 
bool merge (const NavigationCore &l2)
 attemtps to merge two trees More...
 
void getAllOfType (const std::string &id, std::vector< HLT::TriggerElement * > &output, const bool activeOnly=true) const
 return trigger elements given the name of TEs More...
 
const AccessProxy * getAccessProxy () const
 gets the access proxy More...
 
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) More...
 
TriggerElement * getInitialNode ()
 gets initial node, if node is not there then it is created on fly More...
 
const TriggerElement * getInitialNode () const
 
TriggerElement * addRoINode (TriggerElement *initial)
 gets RoI node (attached to initial) More...
 
TriggerElement * addNode (TriggerElement *seed, unsigned int id)
 adds nodes seeded form the one given as an argument, More...
 
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 More...
 
void printASCIIArt (std::string &str, const TriggerElement *te=0, int offset=0) const
 pretty printing of the navigational structure (heavy) More...
 
bool serializeTEs (std::vector< uint32_t > &output) const
 method serizlizes the navigation structure More...
 
bool deserializeTEs (std::vector< uint32_t >::const_iterator &start, unsigned int totalSize)
 
TriggerElement::FeatureAccessHelper getFeature (const TriggerElement *te, class_id_type clid, const index_or_label_type &index_or_label) const
 typeless feature access metod More...
 
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. More...
 
void getAllRoIThresholdTEs (std::vector< TriggerElement * > &output) const
 The query returns a vector of all TriggerElements that represent a LVL1 RoI threshold. More...
 
void getAll (std::vector< TriggerElement * > &output, const bool activeOnly=true) const
 The query returning a collection of all TriggerElements. More...
 
std::vector< TriggerElement * > & getAllTEs ()
 access needed by slimming tools. More...
 
const std::vector< TriggerElement * > & getAllTEs () const
 access needed by slimming tools. More...
 
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. More...
 
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. More...
 
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. More...
 
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) More...
 
bool overlaps (const TriggerElement *t1, const TriggerElement *t2) const
 Check overlap between trigger elements (pointer equality or RoI overlap) More...
 
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. More...
 
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 More...
 
unsigned int copyAllFeatures (const TriggerElement *sourceTE, TriggerElement *destTE)
 gets all features from the sourceTE and copies a reference (FeatureAccessHelper) to the destTE More...
 
const BaseHolder * getHolder (const TriggerElement::FeatureAccessHelper &fea) const
 
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. More...
 
static uint32_t string2hash (const std::string &, const std::string &category="TE")
 convert strin g to hash. More...
 
static const std::vector< TriggerElement * > & getRoINodes (const TriggerElement *somenode)
 gets all RoI type nodes seeding indirectly this TriggerElement More...
 
static const std::vector< TriggerElement * > & getDirectPredecessors (const TriggerElement *te)
 returns list of direct predecessors (nodes seeding me) More...
 
static const std::vector< TriggerElement * > & getDirectSuccessors (const TriggerElement *te)
 returns list of direct predecessors (nodes I seed) More...
 
static const TriggerElement * getSuccessor (const TriggerElement *te, unsigned int id)
 returns successor of given type beeing seeded from this TE More...
 
static bool isInitialNode (const TriggerElement *te)
 queries if node is an initial one More...
 
static bool isRoINode (const TriggerElement *te)
 queries if node is an RoI type one More...
 
static bool isTerminalNode (const TriggerElement *te)
 queries if node is terminal (no more TriggerElement are seeded by it) More...
 
static bool haveCommonRoI (const TriggerElement *te1, const TriggerElement *te2)
 does this 2 share RoI More...
 
static bool haveDistinctRoI (const TriggerElement *te1, const TriggerElement *te2)
 inversion of haveCommonRoI More...
 
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 More...
 
static bool haveDistinctSeed (const TriggerElement *te1, const TriggerElement *te2)
 inversion of haveCommonSeed
More...
 
static bool increasingOrderByTEId (const TriggerElement *te1, const TriggerElement *te2)
 for sorting TriggerElements according to their id More...
 
static bool decreasingOrderByTEId (const TriggerElement *te1, const TriggerElement *te2)
 
static bool hasIdFromTheSet (const TriggerElement *te, std::vector< unsigned int > ids)
 simple helper More...
 
static bool isNotActive (const TriggerElement *te)
 helper for the STL More...
 
static bool isTopological (const TriggerElement *te)
 
static bool isCompatibleTree (const TriggerElement *te1, const TriggerElement *te2)
 check compatibility of 2 navigation structures More...
 

Protected Member Functions

bool createHolder (HLTNavDetails::IHolder *&holder, CLID clid, const std::string &label, uint16_t idx) const
 creates holder for type given by CLID More...
 
bool registerHolder (HLTNavDetails::IHolder *holder)
 
template<class T >
HLTNavDetails::Holder< T > * getHolder (const std::string &label, uint16_t suggestedIndex) const
 aware holder discovery, creates holder if needed More...
 
HLTNavDetails::IHolder * getHolder (CLID clid, uint16_t subTypeIndex) const
 as above but not type wise holder returned More...
 
HLTNavDetails::IHolder * getHolder (CLID clid, const std::string &label) const
 as above More...
 
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. More...
 
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) More...
 
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 More...
 
unsigned m_objectsIndexOffset
 small integer used to generate sub type index More...
 
ITrigHolderFactory * m_holderfactory
 
std::vector< std::string > m_classesToPayloadProperty
 list of classes::keys to be put to BS payload More...
 
std::vector< CSPair > m_classesToPayload
 classess are put to payload according to that priority list (CLID + key) More...
 
std::vector< std::string > m_classesToPayloadProperty_DSonly
 list of classes::keys to be put to DS payload More...
 
std::vector< CSPair > m_classesToPayload_DSonly
 classess are put to payload according to that priority list (CLID + key) More...
 
std::vector< std::string > m_classesFromPayloadIgnoreProperty
 list of classes::keys to ignore on deserialization More...
 
std::vector< std::string > m_classesToPreregisterProperty
 as above but for preregistration More...
 
std::vector< CSPair > m_classesToPreregister
 classes mentioned here will be put to SG irrespectively of thier presence in event More...
 

Static Protected Attributes

static const TriggerElement *m_unspecifiedTE ATLAS_THREAD_SAFE
 
static std::string m_unspecifiedLabel ATLAS_THREAD_SAFE
 

Private Member Functions

MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 
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

const AthAlgTool & m_logger
 
SG::SlotSpecificObj< TriggerElementFactory > m_factory
 factory of trigger elements (one per processing slot) More...
 
SG::SlotSpecificObj< TrigHolderStructure > m_holderstorage
 structure for feature holders (one per processing slot) More...
 

Static Private Attributes

static std::recursive_mutex s_rmutex
 

Friends

class ::TrigNavigationThinningSvc
 
struct HLT::TrigNavTools::SlimmingHelper
 
class ::TrigBStoxAODTool
 

Detailed Description

The NavigationCore class, adds on top of the TrigNavStructure the EDM read-only handling.

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 created nodes are given to user with all the navigational links prepared

  1. features attaching and retrieval (the retrieval is implemented by this class whilc the attachement only needed in athena is in the HLTNavgation tool)
    • 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

Documentation of EDM related upgrade:

  1. objects storage
    • all possible types are known at compile time (Scott's magic)
    • configured 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. there can be several of tracks collections depending on the reconstruction)

    • 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" uint16_t - it is used to save space in the creation of the link from TE to the feature

      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 (nothe that the association is not hardcoeded anywhere and can change from event to event. For that reason the association between the label and SubTypeIndex is recorded.)

  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 HLT_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
    • 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 (this has been lifted up actually)

Definition at line 96 of file NavigationCore.h.

Member Enumeration Documentation

◆ MemoryManagement

enum HLT::NavigationCore::MemoryManagement

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.

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

Constructor & Destructor Documentation

◆ NavigationCore()

NavigationCore::NavigationCore ( const AthAlgTool &  logger)

constructor with parent AlgTool for printing

Definition at line 35 of file NavigationCore.cxx.

36  : TrigNavStructure(),
37  m_serializerSvc(nullptr),
38  m_storeGate(nullptr),
39  m_objectsKeyPrefix("HLT"),
40  m_objectsIndexOffset(0),
41  m_holderfactory(nullptr),
42  m_logger(logger)
43 {
44 }

◆ ~NavigationCore()

virtual HLT::NavigationCore::~NavigationCore ( )
virtualdefault

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
seedsare all TriggerElements which seed newly created
idthe id to give for the created TriggerElement
ghostflag is saying that this TE is a light weight one, no features attaching to it is allowed
nofwdflag is saying that this TE will not be deactivated automatically in fwd deactivation process(rerunning)

Definition at line 85 of file TrigNavStructure.cxx.

85  {
86  std::lock_guard<std::recursive_mutex> lock(getMutex());
87  TriggerElementFactory& factory = getFactory();
88 
89  TriggerElement* te = factory.produce(id, ghost, nofwd);
90 
91 
92  std::vector<TriggerElement* >::iterator it;
93  for ( it = seeds.begin(); it != seeds.end(); ++it ) {
94  // relate to it
95  TriggerElement* seednode = *it;
96  te->relate( seednode, TriggerElement::seededByRelation );
97  seednode->relate( te, TriggerElement::seedsRelation );
98  // add previous Features
99  te->getPreviousFeatures().insert(te->getPreviousFeatures().end(),
100  seednode->getPreviousFeatures().begin(),
101  seednode->getPreviousFeatures().end());
102 
103  // copy RoI relations
104  if ( isRoINode(seednode) ) {
105  te->relate( seednode, TriggerElement::sameRoIRelation );
106  seednode->relate( te, TriggerElement::sameRoIRelation );
107  } else {
108  std::vector<TriggerElement*>::const_iterator itbegin = seednode->getRelated( TriggerElement::sameRoIRelation ).begin();
109  std::vector<TriggerElement*>::const_iterator itend = seednode->getRelated( TriggerElement::sameRoIRelation ).end();
110 
111  for ( ; itbegin != itend; ++itbegin ) {
112  te->relate( *itbegin, TriggerElement::sameRoIRelation );
113  (*itbegin)->relate( te, TriggerElement::sameRoIRelation );
114  }
115  }
116  }
117  return te;
118 }

◆ addNode() [2/2]

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

adds nodes seeded form the one given as an argument,

Parameters
seeda TriggerElement which direct predecessor of newly created
idan id to give newly created TriggerElement

Definition at line 79 of file TrigNavStructure.cxx.

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

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

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.

58  {
59  std::lock_guard<std::recursive_mutex> lock(getMutex());
60  TriggerElementFactory& factory = getFactory();
61 
62  if ( isInitialNode(initial) ) {
63  TriggerElement* te = factory.produce(0);
64 
65  // build seeds, seeededBy relations
66  te->relate( initial, TriggerElement::seededByRelation );
67  initial->relate( te, TriggerElement::seedsRelation );
68  return te;
69  }
70  return 0;
71 }

◆ 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 582 of file TrigNavStructure.cxx.

585 {
586  // It should be empty anyways, but just in case...
587  output.clear();
588 
589  std::vector< std::vector<TriggerElement*> > input;
590  std::vector< std::vector<std::pair<unsigned int, unsigned int> > > newIdxs;
591 
592  for (std::vector<unsigned int>::iterator type = types.begin();
593  type != types.end(); ++type) {
594  // Use the previous iteration's output as the input for this one
595  std::vector< std::vector<TriggerElement*> > input = output;
596  std::vector< std::vector<std::pair<unsigned int, unsigned int> > > currentIdxs = newIdxs;
597 
598  // Remove the old n-tuples
599  output.clear();
600  newIdxs.clear();
601  // Re-populate output with the (n+1)-tuples. If error return false immediately...
602  if (not addOneLevel(input, currentIdxs, *type, output, newIdxs,
603  maxResults, onlyActive)) return false;
604  }
605 
606  return true;
607 }

◆ 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 736 of file TrigNavStructure.cxx.

737 {
738  unsigned int n_features = 0;
739  // push back all featureAccessHelpers from source to destiny TE
740  for ( std::vector< TriggerElement::FeatureAccessHelper >::const_iterator it = sourceTE->getFeatureAccessHelpers().begin();
741  it != sourceTE->getFeatureAccessHelpers().end(); ++it ) {
742  destTE->addFeature(*it);
743  n_features++;
744  }
745  return n_features;
746 
747 }

◆ 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 390 of file TrigNavStructure.cxx.

390  {
391  std::lock_guard<std::recursive_mutex> lock(getMutex());
392  const TriggerElementFactory& factory = getFactory();
393 
394  if ( activeOnly )
395  return factory.listOfProduced(id).size()
396  - count_if(factory.listOfProduced(id).begin(), factory.listOfProduced(id).end(), isNotActive);
397  //else
398  return factory.listOfProduced(id).size();
399 }

◆ createHolder()

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

creates holder for type given by CLID

Definition at line 365 of file NavigationCore.cxx.

365  {
366  ATH_MSG_DEBUG("createHolder: creating holder for CLID: " << clid << " label: " << label << " and index: " << index);
367  //reset holder
368  holder = 0;
369  auto baseholder = m_holderfactory->createHolder(clid,label, index);
370  if(!baseholder){
371  ATH_MSG_ERROR("createHolder: creation of holder for CLID: " << clid << " label: " << label << " and index: " << index << " failed");
372  }
373 
374  holder = dynamic_cast<IHolder*>(baseholder);
375 
376  if(!holder){
377  ATH_MSG_ERROR("createHolder: cast to IHolder* failed");
378  }
379 
380  return true;
381 }

◆ decreasingOrderByTEId()

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

Definition at line 489 of file TrigNavStructure.cxx.

489  {
490  return te1->getId() > te2->getId();
491 }

◆ deserialize()

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

Implements HLT::TrigNavStructure.

Definition at line 151 of file NavigationCore.cxx.

151  {
152  std::lock_guard<std::recursive_mutex> lock(getMutex());
153  TrigHolderStructure& holderstorage = getHolderStorage();
154 
155  std::vector<uint32_t>::const_iterator inputIt = input.begin();
156 
157  ATH_MSG_DEBUG("deserialize: deserializing input of size: " << input.size());
158 
159 
160  if (input.size()==0) {
161  ATH_MSG_WARNING("Cannot work on empty payload");
162  return false;
163  }
164  unsigned int version = *inputIt++; // ignore version
165 
166  ATH_MSG_DEBUG("deserialize: the serialized input has versions " << version);
167 
168  if ( version != 3 and version !=4 ) {
169  ATH_MSG_WARNING("No backward compatibility beyond version 3 possible; data was serialized with V: " << version
170  << " while we are in version 4");
171  return true;
172  }
173  ATH_MSG_DEBUG("deserialize: deserialization of Navigation version: " << version);
174 
175  unsigned int totalSize = *inputIt++; // total size
176  if ( totalSize != input.size() )
177  ATH_MSG_WARNING("deserialize: the navigation is truncated: " << input.size()
178  << " while should be: " << totalSize );
179 
180  if ( input.size() == 2 ) { // there was only space for version and size
181  ATH_MSG_WARNING("deserialize: the navigation is truncated badly, no recovery possible " );
182  return false;
183  }
184 
185  bool tesDeserializationStatus = deserializeTEs(inputIt,input.size());
186  ATH_MSG_DEBUG("deserialize: TEs structure unpacked, status: " << tesDeserializationStatus );
187 
188 
189  ATH_MSG_DEBUG("do we have holder payload? " << (inputIt != input.end()));
190 
191  // Keep track of blobs we've deserialized for each event.
192  struct DeserializedMemo
193  {
194  std::mutex m_mutex;
195  EventContext::ContextEvt_t m_evt;
196  std::unordered_map<uint64_t, std::shared_ptr<HLT::BaseHolder>> m_holders;
197  };
198  static SG::SlotSpecificObj<DeserializedMemo> memos ATLAS_THREAD_SAFE;
199 
200  const EventContext& ctx = Gaudi::Hive::currentContext();
201  DeserializedMemo& memo = *memos.get (ctx);
202  std::scoped_lock memolock (memo.m_mutex);
203  if (memo.m_evt != ctx.evt()) {
204  memo.m_holders.clear();
205  memo.m_evt = ctx.evt();
206  }
207 
208  // EOF TEs deserialization
209  // deserialize Features
210  std::vector<uint32_t>::const_iterator it = inputIt;
211  std::vector<uint32_t> blob;
212  while ( extractBlob(input, it, blob) ) {
213  // Skip this blob if we've already deserialized it.
214  // See ATLASRECTS-6278, ATEAM-734 and ATR-25282
215  uint64_t hash = CxxUtils::crc64 ((const char*)blob.data(),
216  blob.size()*sizeof(*blob.data()));
217 
218  auto& holder = memo.m_holders[hash]; // ref(!) to empty or existing holder pointer
219  if (! holder ) {
220  ATH_MSG_DEBUG("deserializing holder blob with size/hash " << blob.size() << "/" << hash);
221  holder = std::shared_ptr<HLT::BaseHolder>(m_holderfactory->fromSerialized(version,blob.begin(),blob.end()));
222  if (! holder ) continue; // error during deserialization
223  } else {
224  ATH_MSG_DEBUG("blob with size/hash " << blob.size() << "/" << hash
225  << " already deserialized; re-using holder");
226  }
227 
228  if(!holderstorage.registerHolder(holder)){
229  ATH_MSG_WARNING("deserialize: holder registration for holder with clid: " << holder->typeClid() << " and label: " << holder->label() << " failed.");
230  }
231  }
232  return true;
233 }

◆ deserializeTEs()

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

Definition at line 264 of file TrigNavStructure.cxx.

264  {
265  std::lock_guard<std::recursive_mutex> lock(getMutex());
266  TriggerElementFactory& factory = getFactory();
267 
268  factory.reset();
269 
270  std::vector<uint32_t>::const_iterator& inputIt = start;
271  const size_t payloadSize = *inputIt++;
272 
273  if ( totalSize < payloadSize ) { // not all TEs were recorded
274  std::cerr << "size of the navigation payload smaller than the one required to save TEs. " << totalSize << " < " << payloadSize << std::endl;
275  return false;
276  }
277 
278 
279  const unsigned int size = *inputIt++; // size in terms of number of TEs
280  TriggerElement* previous = 0;
281  std::map<uint16_t, TriggerElement* > keys;
282 
283  for ( unsigned int i = 0; i < size; ++i ) {
284  // create new TE
285  TriggerElement* te = factory.produce(TriggerElement::enquireId(inputIt)); //
286  te->deserialize(inputIt, keys, previous);
287  previous = te;
288  // keys table for deserialization of other TEs
289  keys[i] = te;
290  }
291 
292  if ( not factory.empty() ) {
293  // rebuild sameRoI relations (this can't be done by TEs deserialization)
294  TriggerElement* initialNode = getInitialNode();
295  std::vector<TriggerElement*>::const_iterator roiTEit;
296  for ( roiTEit = getDirectSuccessors(initialNode).begin();
297  roiTEit != getDirectSuccessors(initialNode).end(); ++roiTEit ) {
298  fillSameRoIRelation((*roiTEit), (*roiTEit));
299  }
300  } // else this is empty structure, but this shoudl not bother us as it is may well be valid case
301 
302  return true;
303 }

◆ extractBlob()

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

Definition at line 60 of file NavigationCore.cxx.

60  {
61  blob.clear();
62  if ( it == input.end() )
63  return false;
64 
65  unsigned sizeOfBlob = *it;
66  std::vector<uint32_t>::const_iterator begin = it;
67  ++begin;
68  std::vector<uint32_t>::const_iterator end = it;
69  ++end;
70  advance(end, sizeOfBlob);
71  if ( end <= input.end()) {
72  blob.reserve(end-begin);
73  blob.insert(blob.end(), begin, end);
74  it = end; // update iterator
75  return true;
76  }
77  return false; // failed to get blob
78 }

◆ featureLink2Object()

template<class T >
const T* HLT::NavigationCore::featureLink2Object ( const TrigFeatureLink &  ) const

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

307  {
308  if ( ! isRoINode(te) ) {
309  te->relate(roi, TriggerElement::sameRoIRelation);
310  roi->relate(te, TriggerElement::sameRoIRelation);
311  }
312  if ( isTerminalNode(te) )
313  return;
314  else { // traverse all sub nodes
315  std::vector<TriggerElement*>::const_iterator it;
316  for ( it = getDirectSuccessors(te).begin(); it != getDirectSuccessors(te).end(); ++it ) {
317  fillSameRoIRelation(roi, *it);
318  }
319  }
320 }

◆ getAccessProxy()

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

gets the access proxy

Definition at line 337 of file NavigationCore.h.

337  {
338  return m_storeGate;
339  }

◆ 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 363 of file TrigNavStructure.cxx.

363  {
364  std::lock_guard<std::recursive_mutex> lock(getMutex());
365  const TriggerElementFactory& factory = getFactory();
366 
367  if ( not factory.listOfProduced().empty() ) {
368  std::back_insert_iterator<std::vector<TriggerElement*> > outputIt( output );
369  if (activeOnly)
370  remove_copy_if ( factory.listOfProduced().begin(), factory.listOfProduced().end(), outputIt, isNotActive );
371  else
372  copy ( factory.listOfProduced().begin(), factory.listOfProduced().end(), outputIt );
373  }
374 }

◆ getAllFeatures()

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

gets all features of type T atachedd to whichever TE

Parameters
featuresvector of pointers to features to which will be filled up
labelthe label for a given feature
labelslist 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

return trigger elements given the name of TEs

Definition at line 401 of file NavigationCore.cxx.

402  {
403  if ( id == "" )
404  return getAll(output, activeOnly);
405 
406  return TrigNavStructure::getAllOfType( string2hash(id, "TE"), output, activeOnly);
407 }

◆ 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
idname of TE, if "" given all TEs are returned

Definition at line 344 of file TrigNavStructure.cxx.

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

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

329 {
330  const TriggerElement* initNode = getInitialNode();
331  // get first layer of TEs representing the RoIs themselves (not the thresholds!)
332  const std::vector<TriggerElement*>& rois = getDirectSuccessors(initNode);
333  for ( std::vector<TriggerElement*>::const_iterator roi_te = rois.begin();
334  roi_te != rois.end(); ++roi_te) {
335  // get threshold-like TEs:
336  const std::vector<TriggerElement*>& tes = getDirectSuccessors( (const TriggerElement*)(*roi_te) );
337  std::vector<TriggerElement*>::const_iterator te = tes.begin();
338  for ( ; te != tes.end(); ++te) {
339  output.push_back( *te );
340  }
341  }
342 }

◆ getAllTEs() [1/2]

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

access needed by slimming tools.

Definition at line 376 of file TrigNavStructure.cxx.

376  {
377  std::lock_guard<std::recursive_mutex> lock(getMutex());
378  TriggerElementFactory& factory = getFactory();
379 
380  return factory.listOfProduced();
381 }

◆ getAllTEs() [2/2]

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

access needed by slimming tools.

Definition at line 383 of file TrigNavStructure.cxx.

383  {
384  std::lock_guard<std::recursive_mutex> lock(getMutex());
385  const TriggerElementFactory& factory = getFactory();
386 
387  return factory.listOfProduced();
388 }

◆ getDirectPredecessors()

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

returns list of direct predecessors (nodes seeding me)

Parameters
teTriggerElement to query
Returns
collection of TriggerElements (if empty then node is initial)

Definition at line 120 of file TrigNavStructure.cxx.

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

◆ getDirectSuccessors()

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

returns list of direct predecessors (nodes I seed)

Parameters
teTriggerElement to query
Returns
collection of TriggerElements (if empty then node is terminal)

Definition at line 124 of file TrigNavStructure.cxx.

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

◆ getFactory() [1/2]

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

Definition at line 369 of file TrigNavStructure.h.

369 { return *m_factory; }

◆ getFactory() [2/2]

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

Definition at line 373 of file TrigNavStructure.h.

373 { return *m_factory; }

◆ getFeature() [1/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
tethe TE from which the search should be done
clidthe class ID of searched type
subfeature 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 783 of file TrigNavStructure.cxx.

783  {
784 
785 
786  TriggerElement::FeatureVec features;
787  bool single = true; bool recursively = false;
788  bool status = getFeatureAccessors(te, clid,index_or_label,single,features,recursively);
789 
790  if(status && !features.empty()){
791  return features.front();
792  }
793  return TriggerElement::FeatureAccessHelper(); // not found
794 }

◆ getFeature() [2/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

◆ getFeature() [3/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

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

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
teis TriggerElement at which searching starts
clidis ClassID of type which is searched for
labelis 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_featureif true means we are looking for only one last object (i.e. imagine several object of the same type attached to TE)
featuresvector of FeatureAccessHelper objects to fill up
travel_backward_recursivelyif true will doe actual travering TriggerElement structure to find objects, if false search will stop at the TriggerElement te
sourceTriggerElement where the object was found (or query stopped)
sourcelabelis 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.

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

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

Reimplemented from HLT::TrigNavStructure.

Definition at line 421 of file NavigationCore.cxx.

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

◆ 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
sourceTEis the TE where the feature was found

Definition at line 797 of file TrigNavStructure.cxx.

798  {
799 
800  TriggerElement::FeatureVec features;
801  bool single = true; bool recursively = true;
802  bool status = getFeatureAccessors(startTE, clid,index_or_label,single,features,recursively,sourceTE);
803 
804  if(status && !features.empty()){
805  return features.front();
806  }
807  return TriggerElement::FeatureAccessHelper(); // not found
808 }

◆ 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

retrieve features attached to given TriggerElement

Parameters
teTriggerElement from retrieve
featuresis collection to be feed
labelfor additional marking of this feature
labelslist 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

retrieve features attached to the RoIs seeding this TriggerElement

Parameters
teTriggerElement from which start
featuresis collection to be feed
labelfor additional marking of this feature
Returns
false if error enountered, true if no error encountered
Parameters
labelslist 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

◆ getHolder() [1/5]

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

as above

Definition at line 390 of file NavigationCore.cxx.

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

◆ getHolder() [2/5]

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

as above but not type wise holder returned

Definition at line 383 of file NavigationCore.cxx.

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

◆ getHolder() [3/5]

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

aware holder discovery, creates holder if needed

◆ getHolder() [4/5]

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

Definition at line 923 of file TrigNavStructure.cxx.

923  {
924  std::lock_guard<std::recursive_mutex> lock(getMutex());
925  const TrigHolderStructure& holderstorage = getHolderStorage();
926 
927  return holderstorage.getHolderForFeature(fea);
928 }

◆ getHolder() [5/5]

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

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

◆ getHolderStorage() [1/2]

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

Definition at line 370 of file TrigNavStructure.h.

370 { return *m_holderstorage; }

◆ getHolderStorage() [2/2]

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

Definition at line 374 of file TrigNavStructure.h.

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

39  {
40  std::lock_guard<std::recursive_mutex> lock(getMutex());
41  TriggerElementFactory& factory = getFactory();
42 
43  if ( factory.empty() )
44  factory.produce(0);
45  return factory.listOfProduced().front();
46 }

◆ getInitialNode() [2/2]

const TriggerElement * TrigNavStructure::getInitialNode ( ) const
inherited

Definition at line 48 of file TrigNavStructure.cxx.

48  {
49  std::lock_guard<std::recursive_mutex> lock(getMutex());
50  const TriggerElementFactory& factory = getFactory();
51 
52  if ( not factory.empty() )
53  return factory.listOfProduced().front();
54  return 0;
55 }

◆ getMutex() [1/2]

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

Definition at line 371 of file TrigNavStructure.h.

371 { return s_rmutex; }

◆ getMutex() [2/2]

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

Definition at line 375 of file TrigNavStructure.h.

375 { return s_rmutex; }

◆ 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

◆ 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

◆ 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

◆ 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

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
teTriggerElement from which to start
featuresis vector to be filled up
labelfor additional marking of this feature
labelslist 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

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

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

◆ getSuccessor()

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

returns successor of given type beeing seeded from this TE

Parameters
teTriggerElement to query
idthe 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.

129  {
130  if ( te->getId() == id )
131  return te;
132  std::vector<TriggerElement*>::const_iterator it;
133  const TriggerElement* found(0);
134  for ( it = TrigNavStructure::getDirectSuccessors(te).begin() ; it != TrigNavStructure::getDirectSuccessors(te).end() ; ++it ) {
135  found = getSuccessor(*it, id);
136  if (found)
137  break;
138  }
139  return found;
140 }

◆ 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
tetopological TE from which to start
typesvector of types to search for
childsvector of retrieved TEs; empty in case some of the required TEs cannot be found or are not active (see the activeOnly parameter)
activeOnlyoptional parameter specifying whether inactive TEs should be discarded from the search; true by default

Definition at line 714 of file TrigNavStructure.cxx.

715  {
716  if ( getDirectPredecessors(te).size() != types.size() ) {
717  return false;
718  }
719 
720  for ( unsigned i = 0 ; i < types.size(); ++i ) {
721  const TriggerElement* child = getSuccessor( getDirectPredecessors(te)[i], types[i]);
722  if(child!=0) {
723  if(activeOnly && !child->getActiveState()) {
724  children.clear();
725  return true;
726  }
727  children.push_back(child);
728  } else {
729  children.clear();
730  return true;
731  }
732  }
733  return true;
734 }

◆ hasIdFromTheSet()

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

simple helper

Definition at line 493 of file TrigNavStructure.cxx.

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

◆ haveAllCommonRoIs()

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

Definition at line 449 of file TrigNavStructure.cxx.

449  {
450  std::vector<TriggerElement*> vecRoINodes1 = getRoINodes(te1);
451  std::vector<TriggerElement*> vecRoINodes2 = getRoINodes(te2);
452  sort(vecRoINodes1.begin(), vecRoINodes1.end());
453  sort(vecRoINodes2.begin(), vecRoINodes2.end());
454  return vecRoINodes1 == vecRoINodes2;
455 }

◆ 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 416 of file TrigNavStructure.cxx.

416  {
417  std::vector<const TriggerElement*> vecRoINodes;
418 
419  if ( isRoINode(te1) ) {
420  vecRoINodes.push_back(te1);
421  } else {
422  std::back_insert_iterator<std::vector<const TriggerElement*> > outputIt( vecRoINodes );
423  copy(te1->getRelated(TriggerElement::sameRoIRelation).begin(), te1->getRelated(TriggerElement::sameRoIRelation).end(), outputIt);
424  }
425  if ( isRoINode(te2) ) {
426  vecRoINodes.push_back(te2);
427  } else {
428  std::back_insert_iterator<std::vector<const TriggerElement*> > outputIt( vecRoINodes );
429  copy(te2->getRelated(TriggerElement::sameRoIRelation).begin(), te2->getRelated(TriggerElement::sameRoIRelation).end(), outputIt);
430  }
431  // sort (by pointers, it is OK do not be scared)
432  sort(vecRoINodes.begin(), vecRoINodes.end());
433 
434  std::vector<const TriggerElement*>::const_iterator it;
435  it = adjacent_find(vecRoINodes.begin(), vecRoINodes.end());
436 
437  if ( it == vecRoINodes.end() )
438  return false;
439 
440  return true;
441 }

◆ 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 461 of file TrigNavStructure.cxx.

461  {
462  std::vector<const TriggerElement*> vecRoINodes;
463  std::back_insert_iterator<std::vector<const TriggerElement*> > outputIt( vecRoINodes );
464 
465  copy(te1->getRelated(TriggerElement::seededByRelation).begin(),
466  te1->getRelated(TriggerElement::seededByRelation).end(), outputIt);
467 
468  copy(te2->getRelated(TriggerElement::seededByRelation).begin(),
469  te2->getRelated(TriggerElement::seededByRelation).end(), outputIt);
470 
471  // sort (by pointers, it is OK do not be scared) & uniq
472  sort(vecRoINodes.begin(), vecRoINodes.end());
473 
474  std::vector<const TriggerElement*>::iterator it;
475  it = adjacent_find(vecRoINodes.begin(), vecRoINodes.end());
476  if ( it == vecRoINodes.end() ) // after uniquing we still are
477  return false;
478  return true;
479 }

◆ 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 444 of file TrigNavStructure.cxx.

444  {
445  return ! haveCommonRoI(te1, te2);
446 }

◆ haveDistinctSeed()

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

inversion of haveCommonSeed

Definition at line 481 of file TrigNavStructure.cxx.

481  {
482  return ! haveCommonSeed(te1, te2);
483 }

◆ 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 485 of file TrigNavStructure.cxx.

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

◆ 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 526 of file TrigNavStructure.cxx.

526  {
527  using namespace std;
528  if ( te1->getId() != te2->getId() ) {
529  return false; // distinc Id
530  }
531 
532  if ( ( isTerminalNode(te1) && isTerminalNode(te2) ) )
533  return true; // no more checks needs to be done
534  else if ( isTerminalNode(te1) || isTerminalNode(te2) )
535  return false; // one of both is terminal while another is not (case when both are terminal is covered above)
536 
537  // continue subchecks otherwise (both nonterminal)
538 
539  // folow seeds otherwise
540  if ( te1->getRelated(TriggerElement::seedsRelation).size() != te2->getRelated(TriggerElement::seedsRelation).size() )
541  return false;
542 
543  std::vector<TriggerElement*>::const_iterator seededByTe1 = te1->getRelated(TriggerElement::seedsRelation).begin();
544  std::vector<TriggerElement*>::const_iterator seededByTe2 = te2->getRelated(TriggerElement::seedsRelation).begin();
545 
546  for ( ; seededByTe1 != te1->getRelated(TriggerElement::seedsRelation).end(); ++seededByTe1, ++seededByTe2 ) {
547  if (isCompatibleTree(*seededByTe1, *seededByTe2) == false) // grrr,wrrr recursive call here
548  return false;
549  }
550  // there I should probably check as well the Features attached to the TEs
551 
552  return true;
553 }

◆ isInitialNode()

bool TrigNavStructure::isInitialNode ( const TriggerElement *  te)
staticinherited

queries if node is an initial one

Parameters
tenode to be queried
Returns
true if passed node is initial

Definition at line 501 of file TrigNavStructure.cxx.

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

◆ isNotActive()

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

helper for the STL

Definition at line 257 of file TrigNavStructure.h.

257 { return !te->getActiveState(); }

◆ isRoINode()

bool TrigNavStructure::isRoINode ( const TriggerElement *  te)
staticinherited

queries if node is an RoI type one

Parameters
tenode to be queried
Returns
true if passed node is RoI type

Definition at line 507 of file TrigNavStructure.cxx.

507  {
508  if ( te->getRelated( TriggerElement::seededByRelation ).empty() ) // this s initial node
509  return false;
510 
511  TriggerElement* whoSeedsMe = *(te->getRelated( TriggerElement::seededByRelation ).begin());
512  if ( isInitialNode(whoSeedsMe) )
513  return true;
514  return false;
515 }

◆ isTerminalNode()

bool TrigNavStructure::isTerminalNode ( const TriggerElement *  te)
staticinherited

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

Parameters
tenode to be queried
Returns
true if passed node is terminal

Definition at line 517 of file TrigNavStructure.cxx.

517  {
518  if ( te->getRelated( TriggerElement::seedsRelation ).empty() )
519  return true;
520  return false;
521 }

◆ isTopological()

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

Definition at line 259 of file TrigNavStructure.h.

259 { 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 775 of file TrigNavStructure.cxx.

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

◆ 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 898 of file TrigNavStructure.cxx.

898  {
899  //we always require the CLID to match
900  if(fea.getCLID() != clid) return false;
901 
902  if(index_or_label.index() == 0){
903  //subtype index case: if argument is invalid_sub_index we always match, else require exact match
904  auto index = std::get<sub_index_type>(index_or_label) ;
905  return (index == invalid_sub_index || index == fea.getIndex().subTypeIndex());
906  }
907 
908  if(index_or_label.index() == 1){
909  //label case: if argument is "" we always match, else require exact match (via)
910  auto label = std::get<std::string>(index_or_label);
911  if(label.empty()){
912  return true;
913  }
914  label = (label == "!") ? "" : label;
915  auto sub = subType(clid,label);
916  if(sub == invalid_sub_index) return false;
917  return matchFeature(fea,clid,sub);
918  }
919  return false;
920 }

◆ merge()

bool NavigationCore::merge ( const NavigationCore &  l2)

attemtps to merge two trees

Definition at line 235 of file NavigationCore.cxx.

235  {
236  std::lock_guard<std::recursive_mutex> l2lock(l2.getMutex());
237  const TrigHolderStructure& l2Holderstorage = l2.getHolderStorage();
238 
239  // we need to pick the holders which are at L2 and move them to EF
240  for(auto l2holder : l2Holderstorage.getAllHolders<IHolder>()){
241  ATH_MSG_DEBUG("will add holder " << *l2holder);
242  std::string label(l2holder->label());
243  IHolder* efholder = getHolder(l2holder->typeClid(), label);
244  if ( efholder != 0 ) {
245  if ( (efholder->label() != l2holder->label())
246  || (efholder->subTypeIndex() != l2holder->subTypeIndex()) ) {
247 
248  ATH_MSG_DEBUG("fixing bug for " << *efholder);
249  // bug which we need to fix (some week of data in autumn 2008)
250  // we have to delete current holder
251  // and replace it by L2 one
252  //
253  // efholder->setSubTypeIndex(l2holder->subTypeIndex());
254 
255  ATH_MSG_DEBUG("after fixing " << *efholder);
256  }
257  } else {
258  ATH_MSG_DEBUG("cloning the holder from L2 " << *l2holder);
259 
260  bool status = createHolder(efholder, l2holder->typeClid(),l2holder->label(), l2holder->subTypeIndex());
261  if(!status){
262  ATH_MSG_WARNING("in merge could not create EF holder");
263  }
264 
265  //not sure if there is any possibility for this case but check anyways -Lukas
266  if(efholder->key()!=l2holder->key()){
267  ATH_MSG_WARNING("in merge the created EF holder has different SG access key than L2 holder we tried to copy");
268  }
269 
270  registerHolder(efholder);
271  }
272  }
273  return true;
274 }

◆ msg() [1/2]

MsgStream& HLT::NavigationCore::msg ( ) const
inlineprivate

Definition at line 409 of file NavigationCore.h.

409 { return m_logger.msg(); }

◆ msg() [2/2]

MsgStream& HLT::NavigationCore::msg ( const MSG::Level  lvl) const
inlineprivate

Definition at line 410 of file NavigationCore.h.

410 { return msg() << lvl; }

◆ msgLvl()

bool HLT::NavigationCore::msgLvl ( const MSG::Level  lvl) const
inlineprivate

Definition at line 411 of file NavigationCore.h.

411 { return msg().level() <= lvl; }

◆ nextSubTypeIndex()

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

Definition at line 287 of file NavigationCore.cxx.

287  {
288  std::lock_guard<std::recursive_mutex> lock(getMutex());
289  const TrigHolderStructure& holderstorage = getHolderStorage();
290 
291  auto holders = holderstorage.getHoldersOfClid(clid);
292 
293  if ( holders.empty() )
294  return m_objectsIndexOffset;
295 
296  std::vector<sub_index_type> sub_indices(holders.size());
297  std::transform(holders.begin(), holders.end(), sub_indices.begin(),
298  [](BaseHolder* h) -> sub_index_type { return h->subTypeIndex(); });
299 
300  return (*std::max_element(sub_indices.begin(),sub_indices.end()))+1;
301 }

◆ object2FeatureLink() [1/2]

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

◆ 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

◆ 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 700 of file TrigNavStructure.cxx.

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

◆ 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 707 of file TrigNavStructure.cxx.

707  {
708  if (te1 == te2) return true;
709  if (haveCommonRoI(te1, te2)) return true;
710 
711  return false;
712 }

◆ prepare()

void NavigationCore::prepare ( )
virtual

prepapres the navigation for next event

Definition at line 335 of file NavigationCore.cxx.

335  {
336  if ( msgLvl(MSG::VERBOSE) ) {
337  for ( const auto& [clid, holder] : HLT::TypeMaps::holders() ) {
338  ATH_MSG_VERBOSE("NavigationCore::prepare Compile time known types : " << *holder);
339  }
340  }
341 
342  ATH_MSG_VERBOSE("NavigationCore::prepare Preregistering objects #:" << m_classesToPreregister.size());
343 
344  // populate structure with "must have" features
345  for ( const CSPair& conf : m_classesToPreregister ) {
346  CLID clid = conf.first;
347  std::string label = conf.second;
348  if ( prepareOneHolder(clid, label) == 0 ) {
349  ATH_MSG_WARNING("NavigationCore::prepare failed preparing the holder for CLID: " << clid << " and label " << label);
350  }
351  }
352  ATH_MSG_DEBUG("NavigationCore::prepare Navigation structure prepared for next event");
353 }

◆ prepareOneHolder()

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

Definition at line 303 of file NavigationCore.cxx.

303  {
304 
305  ATH_MSG_VERBOSE("NavigationCore::prepare preregistering objects of clid: " << clid << " label: " << label);
306  IHolder *holder = getHolder(clid, label);
307  if ( holder ) {
308  ATH_MSG_VERBOSE("NavigationCore::prepare preregistering objects not executed as it already exists " << *holder);
309  return holder;
310  }
311 
312  uint16_t index = nextSubTypeIndex(clid, label);
313  ATH_MSG_VERBOSE("NavigationCore::prepare creating handler for type (CLID): " << clid
314  << " label: " << label << " index: " << index);
315 
316  if ( !createHolder(holder, clid, label, index) ) {
317  ATH_MSG_INFO("NavigationCore::prepare Can't create storage for objects of CLID: " << clid << " as it is requested by configuration");
318  return nullptr;
319  }
320 
321  ATH_MSG_VERBOSE("Holder created, registering " << holder << " " << *holder);
322 
323  if ( !registerHolder(holder) ) {
324  ATH_MSG_WARNING("Holder registration failed " << holder << " " << *holder);
325  return nullptr;
326  }
327  if ( !holder->syncWithSG() ) {
328  ATH_MSG_WARNING("Holder SG sync failed" << holder << " " << *holder);
329  return nullptr;
330  }
331 
332  return holder;
333 }

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

152  {
153  using namespace std;
154  const TriggerElement* initialNode = getInitialNode();
155  if ( initialNode == 0 )
156  return;
157 
158  std::lock_guard<std::recursive_mutex> lock(getMutex());
159  const TriggerElementFactory& factory = getFactory();
160 
161 
162  if ( !te )
163  te = initialNode;
164 
165  if ( te == initialNode ) {
166  // loop over all TEs which are not seeded by anything but are not initial nodes
167  const std::vector< TriggerElement* >& allTEs = factory.listOfProduced();
168  std::vector< TriggerElement* >::const_iterator allIt;
169  for (allIt = allTEs.begin(); allIt != allTEs.end(); ++allIt) {
170  if ((*allIt)->getRelated(TriggerElement::seededByRelation).size() == 0 && *allIt != getInitialNode() )
171  printASCIIArt(str, *allIt);
172  }
173  }
174 
175  ostringstream ss;
176  // pretty print
177  for ( int i=0; i < offset; i++ ) {
178  ss << "| ";
179  //cout << " ";
180  }
181  ss << "\\_";
182 
183  ss << "id:" << dec << te->getId() << ";"
184  << "active:" <<(te->getActiveState() ? "1" : "0" ) << ";"
185  << "error:" <<(te->getErrorState() ? "1" : "0" ) << ";"
186  << "ptr:" << hex << te << ";"
187  << "#seeds:" << dec << te->getRelated(TriggerElement::seedsRelation).size() << ",";
188  // add all ptrs
189  std::vector<TriggerElement*>::const_iterator seedIt;
190  for ( seedIt = getDirectSuccessors(te).begin(); seedIt != getDirectSuccessors(te).end(); ++seedIt ) {
191  ss << *seedIt <<" ";
192  }
193 
194  ss << "#seededBy:" << dec << te->getRelated(TriggerElement::seededByRelation).size() << ";"
195  << "#RoI:" << dec << te->getRelated(TriggerElement::sameRoIRelation).size() << ";"
196  << "#features:" << te->getFeatureAccessHelpers().size() << ";";
197  for ( auto& fea: te->getFeatureAccessHelpers() ) {
198  ss << fea;
199  }
200  ss << std::endl;
201 
202  std::string str2;
203  str2 = ss.str();
204  str += str2;
205 
206  if ( ! isTerminalNode(te) ) {
207  std::vector < TriggerElement* >::const_iterator it = te->getRelated( TriggerElement::seedsRelation ).begin();
208  std::vector < TriggerElement* >::const_iterator itEnd = te->getRelated( TriggerElement::seedsRelation ).end();
209  for ( ; it != itEnd; ++it ) {
210  std::string str2;
211  printASCIIArt(str, *it, offset+1);
212  str += str2;
213  }
214  }
215 }

◆ 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
navis 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 557 of file TrigNavStructure.cxx.

557  {
558  std::lock_guard<std::recursive_mutex> lock(getMutex());
559  TriggerElementFactory& factory = getFactory();
560  const TriggerElementFactory& oldFactory = nav->getFactory();
561 
562 
563  // basic checks first
564  if ( oldFactory.listOfProduced().size() > factory.listOfProduced().size() )
565  return false;
566 
567  std::vector< TriggerElement* >::const_iterator old = oldFactory.listOfProduced().begin();
568  std::vector< TriggerElement* >::iterator me = factory.listOfProduced().begin();
569  // int i = 0;
570  do {
571  (*me)->setActiveState((*old)->getActiveState());
572  ++me;
573  ++old;
574  } while ( old != oldFactory.listOfProduced().end() );
575  return true;
576 }

◆ registerFeatureContainer()

template<class T , class C >
static void HLT::NavigationCore::registerFeatureContainer ( )
static

Specialized by type and container for this type.

◆ registerHolder()

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

Definition at line 355 of file NavigationCore.cxx.

355  {
356  std::lock_guard<std::recursive_mutex> lock(getMutex());
357  TrigHolderStructure& holderstorage = getHolderStorage();
358 
359  auto shared_holder = std::shared_ptr<HLT::BaseHolder>(holder);
360  holderstorage.registerHolder(shared_holder);
361  ATH_MSG_DEBUG("registerHolder for OK " << *holder);
362  return true;
363 }

◆ reset()

void NavigationCore::reset ( bool  inFinalize = false)
virtual

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.

281  {
282  TrigNavStructure::reset(inFinalize);
283 
284  ATH_MSG_DEBUG("Navigation reset done");
285 }

◆ serialize() [1/3]

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

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
outputvector to place the result
cutsare 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.

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

◆ serialize() [2/3]

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

Definition at line 86 of file NavigationCore.cxx.

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

◆ 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

Definition at line 92 of file NavigationCore.cxx.

92  {
93  std::vector<uint32_t> holderdata;
94  std::vector<unsigned int> holderblobsizes;
95 
96  std::lock_guard<std::recursive_mutex> lock(getMutex());
97  const TrigHolderStructure& holderstorage = getHolderStorage();
98 
99  bool status = false;
100  if ( m_classesToPayload.empty() ) { // this is offline case
101  status = serializeHoldersWithoutPayload(holderstorage.getAllHolders<IHolder>(),holderdata, holderblobsizes, clid_name);
102  } else { // this is online case when list of classes to payload is not empty
103  status = serializeHoldersWithPayload(m_classesToPayload,holderdata,holderblobsizes,clid_name);
104  }
105 
106  if(!status){
107  ATH_MSG_WARNING("holder serialization failed");
108  return false;
109  }
110 
111  status = serializeWithHolderSection(holderdata,holderblobsizes,output,cuts,clid_name);
112 
113  if(!status){
114  ATH_MSG_WARNING("full serialization failed");
115  return false;
116  }
117 
118  ATH_MSG_DEBUG("total size of serialized navigation: " << output.size());
119 
120  return true;
121 }

◆ 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

Definition at line 123 of file NavigationCore.cxx.

123  {
124  std::vector<uint32_t> holderdata;
125  std::vector<unsigned int> holderblobsizes;
126 
127  bool status = serializeHoldersWithPayload(m_classesToPayload_DSonly,holderdata,holderblobsizes,clid_name);
128  if(!status){
129  ATH_MSG_WARNING("holder serialization failed");
130  return false;
131  }
132 
133  status = serializeWithHolderSection(holderdata,holderblobsizes,output,cuts,clid_name);
134  if(!status){
135  ATH_MSG_WARNING("full serialization failed");
136  return false;
137  }
138 
139  ATH_MSG_DEBUG("total size of serialized navigation (DS only): " << output.size());
140 
141  return true;
142 }

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

Definition at line 502 of file NavigationCore.cxx.

502  {
503  for(auto& holder : holders){
504  ATH_MSG_DEBUG("serialization of feature: " << holder->typeClid() << " label: " << holder->label()
505  << " size of payload: " << output.size());
506 
507  std::vector<uint32_t> holderblob;
508  bool status = holder->serialize(holderblob);
509  if(!status){
510  ATH_MSG_WARNING("problem serializing holder: " << *holder);
511  return false;
512  }
513  output.push_back(holderblob.size()); //leading bit indicates size
514  output.insert(output.end(),holderblob.begin(),holderblob.end());
515 
516  holderblobsizes.push_back(1+holderblob.size()); //one for leading size bit
517  clid_name.push_back(std::pair < CLID, std::string> (holder->typeClid(), holder->label()));
518  }
519  return true;
520 }

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

Definition at line 468 of file NavigationCore.cxx.

470  {
471 
472  ATH_MSG_DEBUG("serialization: number of classes to payload: " << payload.size());
473  for ( auto& cl : payload) {
474  ATH_MSG_DEBUG("serialization (ordered) of featue attempting : " << cl.first << " " << cl.second);
475 
476  IHolder *holder = getHolder(cl.first,cl.second);
477  if ( ! holder ) {
478  ATH_MSG_DEBUG("serialization (ordered) of feature skipped, nothing know on this objects" );
479  continue;
480  }
481  ATH_MSG_DEBUG("serialization (ordered) of feature: " << holder->typeClid() << " label: " << holder->label()
482  << " size of payload up to now: " << output.size());
483 
484  std::vector<uint32_t> holderblob;
485  size_t payloadsize = 0;
486  bool status = holder->serializeWithPayload(cl.sel,holderblob,payloadsize);
487  if(!status){
488  ATH_MSG_WARNING("problem serializing holder: " << *holder);
489  return false;
490  }
491 
492  output.push_back(holderblob.size()); //leading bit indicates size
493  output.insert(output.end(),holderblob.begin(),holderblob.end());
494 
495  holderblobsizes.push_back(1+holderblob.size()); //one for leading size bit
496  clid_name.push_back(std::pair < CLID, std::string> (holder->typeClid(), holder->label()));
497  }
498 
499  return true;
500 }

◆ serializeTEs()

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

method serizlizes the navigation structure

Parameters
outputvector 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.

217  {
218  std::lock_guard<std::recursive_mutex> lock(getMutex());
219  const TriggerElementFactory& factory = getFactory();
220 
221  ::HLTNavDetails::FillSize fs(output);
222 
223  const std::vector<TriggerElement*>& fullList = factory.listOfProduced();
224  std::vector<TriggerElement*> all;
225  all.reserve(fullList.size());
226 
227  for(std::vector<TriggerElement*>::const_iterator iter = fullList.begin(); iter != fullList.end(); ++iter) {
228  if(! (*iter)->transient() ) {
229  all.push_back( *iter );
230  }
231  }
232 
233  // reserve space (in order to be efficient it should not be resized any more, this can be studied probably later to find optimum)
234  output.reserve(10*all.size());
235 
236  // SERIALZE NAVIGATION STRUCTURE
237  // size (measured in elements)
238  output.push_back(all.size());
239 
240  // helper keys
241  std::map<TriggerElement*, uint16_t> keys;
242 
243  const TriggerElement* previous = 0;
244  std::vector<TriggerElement*>::const_iterator it;
245  uint16_t indexForTe = 0;
246  for ( it = all.begin(); it != all.end(); ++it ) {
247  // first we stream pointer as it (this is already an unique key for this TE)
248  // output.push_back((unsigned int)(*it));
249  (*it)->serialize(output, keys, previous);
250  previous = *it;
251  keys[*it] = indexForTe;
252  indexForTe++;
253  }
254 
255  return true;
256 }

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

Definition at line 436 of file NavigationCore.cxx.

437  {
438  cuts.clear();
439  // clid_name.clear(); Don't reset this vector here since the vector is not remade. Otherwise datascouting stops working.
440 
441  unsigned int version=4;
442  ATH_MSG_DEBUG("NavigationCore::serialize: serializing with version " << version);
443 
444  output.push_back(version);
445 
446  unsigned int totalSizeIndex = output.size();
447  output.push_back(0); // reserve one word (accessible under the index totalSize), it is 0 if there was truncation here
448  // and != output.size() if truncation using cuts
449 
450  cuts.push_back(output.size()); // mark a cut place
451 
452  bool tesSerializationStatus = serializeTEs(output);
453 
454  ATH_MSG_DEBUG("serializes: TE serialization status: " << tesSerializationStatus << " size: " << output.size());
455 
456  cuts.push_back(output.size()); // mark a cut place
457 
458  output.insert(output.end(),holderdata.begin(),holderdata.end());
459 
460  for(auto hc : holderblobsizes){cuts.push_back(cuts.back()+hc);}
461 
462  output[totalSizeIndex] = output.size();
463 
464  ATH_MSG_DEBUG("serialization done");
465  return true;
466 }

◆ string2hash()

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

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.

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

◆ subType()

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

Definition at line 768 of file TrigNavStructure.cxx.

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

Friends And Related Function Documentation

◆ ::TrigBStoxAODTool

friend class ::TrigBStoxAODTool
friend

Definition at line 99 of file NavigationCore.h.

◆ ::TrigNavigationThinningSvc

friend class ::TrigNavigationThinningSvc
friend

Definition at line 97 of file NavigationCore.h.

◆ HLT::TrigNavTools::SlimmingHelper

friend struct HLT::TrigNavTools::SlimmingHelper
friend

Definition at line 98 of file NavigationCore.h.

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
protected

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
protected

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
protected

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
protected

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
protected

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
protected

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
protected

as above but for preregistration

Definition at line 396 of file NavigationCore.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_holderfactory

ITrigHolderFactory* HLT::NavigationCore::m_holderfactory
protected

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
private

Definition at line 406 of file NavigationCore.h.

◆ m_objectsIndexOffset

unsigned HLT::NavigationCore::m_objectsIndexOffset
protected

small integer used to generate sub type index

Definition at line 372 of file NavigationCore.h.

◆ m_objectsKeyPrefix

std::string HLT::NavigationCore::m_objectsKeyPrefix
protected

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

Definition at line 371 of file NavigationCore.h.

◆ m_serializerSvc

IConversionSvc* HLT::NavigationCore::m_serializerSvc
protected

Definition at line 369 of file NavigationCore.h.

◆ m_storeGate

StoreGateSvc* HLT::NavigationCore::m_storeGate
protected

Definition at line 370 of file NavigationCore.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:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
HLT::TriggerElement::addFeature
void addFeature(class_id_type clid, const ObjectIndex &index, bool forget=false)
add helper for new feature
Definition: TrigNavStructure/Root/TriggerElement.cxx:37
HLT::NavigationCore::prepareOneHolder
HLTNavDetails::IHolder * prepareOneHolder(CLID clid, const std::string &label)
Definition: NavigationCore.cxx:303
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
HLT::TrigNavStructure::getAll
void getAll(std::vector< TriggerElement * > &output, const bool activeOnly=true) const
The query returning a collection of all TriggerElements.
Definition: TrigNavStructure.cxx:363
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
HLTNavDetails::IHolder::label
const std::string & label() const
returns the label of objects stores by this holder
Definition: Holder.h:85
HLT::TrigNavStructure::getAllOfType
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.
Definition: TrigNavStructure.cxx:344
HLT::TrigNavStructure::label
std::string label(class_id_type clid, const index_or_label_type &sti_or_label) const
Definition: TrigNavStructure.cxx:775
HLT::NavigationCore::m_objectsKeyPrefix
std::string m_objectsKeyPrefix
property setting prefix which is to be given to all trigger EDM objects
Definition: NavigationCore.h:371
HLT::TrigNavStructure::isRoINode
static bool isRoINode(const TriggerElement *te)
queries if node is an RoI type one
Definition: TrigNavStructure.cxx:507
HLT::NavigationCore::msg
MsgStream & msg() const
Definition: NavigationCore.h:409
HLT::NavigationCore::m_objectsIndexOffset
unsigned m_objectsIndexOffset
small integer used to generate sub type index
Definition: NavigationCore.h:372
HLT::TrigNavStructure::s_rmutex
static std::recursive_mutex s_rmutex
Definition: TrigNavStructure.h:385
HLT::TriggerElement::seedsRelation
@ seedsRelation
what TEs I am seeding
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:118
index
Definition: index.py:1
HLT::TriggerElementFactory::listOfProduced
const std::vector< TriggerElement * > & listOfProduced() const
Definition: TriggerElementFactory.h:36
BeamSpot::mutex
std::mutex mutex
Definition: InDetBeamSpotVertex.cxx:18
HLT::TrigNavStructure::printASCIIArt
void printASCIIArt(std::string &str, const TriggerElement *te=0, int offset=0) const
pretty printing of the navigational structure (heavy)
Definition: TrigNavStructure.cxx:152
HLT::NavigationCore::extractBlob
bool extractBlob(const std::vector< uint32_t > &input, std::vector< uint32_t >::const_iterator &it, std::vector< uint32_t > &blob) const
Definition: NavigationCore.cxx:60
HLT::TrigHolderStructure
Definition: TrigHolderStructure.h:21
HLT::TriggerElement::FeatureVec
std::vector< FeatureAccessHelper > FeatureVec
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:233
HLT::TrigNavStructure::getMutex
std::recursive_mutex & getMutex()
Definition: TrigNavStructure.h:371
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:14
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
skel.it
it
Definition: skel.GENtoEVGEN.py:396
HLT::TriggerElement::getId
te_id_type getId() const
reset internals.
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:43
Cut::all
@ all
Definition: SUSYToolsAlg.cxx:67
HLT::TriggerElement::FeatureAccessHelper::getCLID
class_id_type getCLID() const
Class ID of object.
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:208
HLT::TrigNavStructure::isTerminalNode
static bool isTerminalNode(const TriggerElement *te)
queries if node is terminal (no more TriggerElement are seeded by it)
Definition: TrigNavStructure.cxx:517
HLT::TypeMaps::holders
static const CLIDtoHolderMap & holders()
Definition: TypeMaps.h:30
HLT::TriggerElement::getActiveState
bool getActiveState() const
get state of the TriggerElement
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:48
HLT::TrigNavStructure::m_holderstorage
SG::SlotSpecificObj< TrigHolderStructure > m_holderstorage
structure for feature holders (one per processing slot)
Definition: TrigNavStructure.h:383
HLT::TrigNavStructure::getFeatureAccessorsSingleTE
virtual bool getFeatureAccessorsSingleTE(const TriggerElement *te, class_id_type clid, const index_or_label_type &index_or_label, bool only_single_feature, TriggerElement::FeatureVec &features, const TriggerElement *&source, std::string &sourcelabel) const
Definition: TrigNavStructure.cxx:810
HLT::TrigNavStructure::reset
virtual void reset(bool inFinalize=false)
resets all the navigation, goes to the factory and asks to withdraw all produced objects
Definition: TrigNavStructure.cxx:756
HLT::NavigationCore::string2hash
static uint32_t string2hash(const std::string &, const std::string &category="TE")
convert strin g to hash.
Definition: NavigationCore.cxx:397
HLT::TriggerElement::getErrorState
bool getErrorState() const
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:65
HLT::TrigHolderStructure::getHoldersOfClid
std::vector< HolderType * > getHoldersOfClid(class_id_type clid) const
Definition: TrigHolderStructure.h:51
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
HLT::NavigationCore::ObjectInStoreGate
@ ObjectInStoreGate
Definition: NavigationCore.h:157
HLT::TrigNavStructure
Definition: TrigNavStructure.h:40
HLT::NavigationCore::ObjectCreatedByNew
@ ObjectCreatedByNew
Definition: NavigationCore.h:157
HLT::NavigationCore::createHolder
bool createHolder(HLTNavDetails::IHolder *&holder, CLID clid, const std::string &label, uint16_t idx) const
creates holder for type given by CLID
Definition: NavigationCore.cxx:365
HLT::TrigHolderStructure::registerHolder
bool registerHolder(const std::shared_ptr< BaseHolder > &holder)
Definition: TrigHolderStructure.cxx:34
HLT::TrigNavStructure::getFeatureAccessors
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
Definition: TrigNavStructure.cxx:842
std::sort
void sort(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:554
HLT::TriggerElement::seededByRelation
@ seededByRelation
what TEs are seeding me
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:119
HLT::TrigNavStructure::getInitialNode
TriggerElement * getInitialNode()
gets initial node, if node is not there then it is created on fly
Definition: TrigNavStructure.cxx:39
HLT::TrigNavStructure::haveCommonSeed
static bool haveCommonSeed(const TriggerElement *te1, const TriggerElement *te2)
checks that there is any common predecessor of two TriggerElements
Definition: TrigNavStructure.cxx:461
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
HLT::TriggerElement::getRelated
const std::vector< TriggerElement * > & getRelated(Relation rel) const
returns reference to the likns to other TriggerElements related by relation r
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:127
HLT::TrigNavStructure::haveCommonRoI
static bool haveCommonRoI(const TriggerElement *te1, const TriggerElement *te2)
does this 2 share RoI
Definition: TrigNavStructure.cxx:416
HLT::NavigationCore::getHolder
HLTNavDetails::Holder< T > * getHolder(uint16_t subTypeIndex) const
as above but does not create holder on demand (return 0 if not found)
HLTNavDetails::IHolder::syncWithSG
virtual bool syncWithSG(SG::OwnershipPolicy policy=SG::OWN_ELEMENTS)=0
HLT::TrigNavStructure::getFactory
TriggerElementFactory & getFactory()
Definition: TrigNavStructure.h:369
HLT::TrigNavStructure::getDirectSuccessors
static const std::vector< TriggerElement * > & getDirectSuccessors(const TriggerElement *te)
returns list of direct predecessors (nodes I seed)
Definition: TrigNavStructure.cxx:124
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
HLT::TrigNavStructure::m_factory
SG::SlotSpecificObj< TriggerElementFactory > m_factory
factory of trigger elements (one per processing slot)
Definition: TrigNavStructure.h:382
HLT::TriggerElement::ObjectIndex::subTypeIndex
sub_index_type subTypeIndex() const
to get collection index
Definition: TrigNavStructure/Root/TriggerElement.cxx:247
HLT::NavigationCore::m_classesToPayload
std::vector< CSPair > m_classesToPayload
classess are put to payload according to that priority list (CLID + key)
Definition: NavigationCore.h:389
python.ConfigurableDb.conf
def conf
Definition: ConfigurableDb.py:282
SG::SlotSpecificObj
Maintain a set of objects, one per slot.
Definition: AthenaKernel/AthenaKernel/SlotSpecificObj.h:70
skel.l2
l2
Definition: skel.GENtoEVGEN.py:399
HLT::TrigNavStructure::deserializeTEs
bool deserializeTEs(std::vector< uint32_t >::const_iterator &start, unsigned int totalSize)
Definition: TrigNavStructure.cxx:264
HLT::NavigationCore::serializeHoldersWithPayload
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
Definition: NavigationCore.cxx:468
HLTNavDetails::FillSize
Definition: TrigNavStructure.h:26
HLT::TrigNavStructure::serializeTEs
bool serializeTEs(std::vector< uint32_t > &output) const
method serizlizes the navigation structure
Definition: TrigNavStructure.cxx:217
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
HLT::TriggerElement::sameRoIRelation
@ sameRoIRelation
equilateral relation of all TEs rooted in one RoI
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:117
HLT::TrigNavStructure::getDirectPredecessors
static const std::vector< TriggerElement * > & getDirectPredecessors(const TriggerElement *te)
returns list of direct predecessors (nodes seeding me)
Definition: TrigNavStructure.cxx:120
TrigConf::HLTUtils::string2hash
static HLTHash string2hash(const std::string &, const std::string &category="TE")
hash function translating TE names into identifiers
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:88
HLT::TrigHolderStructure::getHolderForFeature
HolderType * getHolderForFeature(const TriggerElement::FeatureAccessHelper &fea) const
Definition: TrigHolderStructure.h:35
lumiFormat.i
int i
Definition: lumiFormat.py:85
HLT::NavigationCore::m_holderfactory
ITrigHolderFactory * m_holderfactory
Definition: NavigationCore.h:375
h
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ReweightUtils.category
category
Definition: ReweightUtils.py:15
HLT::TriggerElement
TriggerElement is the basic ingreedient of the interface between HLT algorithms and the navigation It...
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:27
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
HLT::TriggerElement::relate
void relate(TriggerElement *te, Relation r)
reates given TE to other TE
Definition: TrigNavStructure/Root/TriggerElement.cxx:86
plotBeamSpotVert.cuts
string cuts
Definition: plotBeamSpotVert.py:93
HLT::TrigNavStructure::ATLAS_THREAD_SAFE
static const TriggerElement *m_unspecifiedTE ATLAS_THREAD_SAFE
Definition: TrigNavStructure.h:377
HLT::TrigNavStructure::subType
sub_index_type subType(class_id_type clid, const index_or_label_type &sti_or_label) const
Definition: TrigNavStructure.cxx:768
HLT::NavigationCore::nextSubTypeIndex
uint16_t nextSubTypeIndex(CLID clid, const std::string &label) const
Definition: NavigationCore.cxx:287
EL::Detail::ManagerStep::initial
@ initial
this is just the initial step we do, nothing really happens here
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
HLT::TrigNavStructure::getHolderStorage
TrigHolderStructure & getHolderStorage()
Definition: TrigNavStructure.h:370
HLT::BaseHolder
Definition: BaseHolder.h:14
HLT::TriggerElement::enquireId
static unsigned int enquireId(std::vector< uint32_t >::const_iterator &inputIt)
Definition: TrigNavStructure/Root/TriggerElement.cxx:111
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
HLT::NavigationCore::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: NavigationCore.h:411
HLT::sub_index_type
uint16_t sub_index_type
Definition: Trigger/TrigEvent/TrigNavStructure/Root/Types.h:9
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
CxxUtils::crc64
uint64_t crc64(const CRCTable &table, const char *data, size_t data_len)
Find the CRC-64 of a string,.
Definition: crc64.cxx:696
HLT::NavigationCore::m_serializerSvc
IConversionSvc * m_serializerSvc
Definition: NavigationCore.h:369
merge.output
output
Definition: merge.py:17
HLT::TrigNavStructure::getSuccessor
static const TriggerElement * getSuccessor(const TriggerElement *te, unsigned int id)
returns successor of given type beeing seeded from this TE
Definition: TrigNavStructure.cxx:129
HLT::TriggerElementFactory
The factory of TriggerElements Creation in controlled way.
Definition: TriggerElementFactory.h:28
python.root_lsr_rank.types
types
Definition: root_lsr_rank.py:35
HLT::NavigationCore::serializeWithHolderSection
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
Definition: NavigationCore.cxx:436
python.subdetectors.mmg.ids
ids
Definition: mmg.py:8
HLT::NavigationCore::m_storeGate
StoreGateSvc * m_storeGate
Definition: NavigationCore.h:370
HLT::TrigNavStructure::overlaps
bool overlaps(const TriggerElement *t1, const TriggerElement *t2) const
Check overlap between trigger elements (pointer equality or RoI overlap)
Definition: TrigNavStructure.cxx:707
HLT::TriggerElementFactory::reset
void reset()
Definition: TriggerElementFactory.cxx:28
HLT::TrigNavStructure::isCompatibleTree
static bool isCompatibleTree(const TriggerElement *te1, const TriggerElement *te2)
check compatibility of 2 navigation structures
Definition: TrigNavStructure.cxx:526
HLT::ITrigHolderFactory::createHolder
virtual BaseHolder * createHolder(class_id_type clid, const std::string &label, sub_index_type index) const =0
PixelModuleFeMask_create_db.payload
string payload
Definition: PixelModuleFeMask_create_db.py:69
HLT::TrigNavStructure::getRoINodes
static const std::vector< TriggerElement * > & getRoINodes(const TriggerElement *somenode)
gets all RoI type nodes seeding indirectly this TriggerElement
Definition: TrigNavStructure.cxx:73
HLT::NavigationCore::m_classesToPreregister
std::vector< CSPair > m_classesToPreregister
classes mentioned here will be put to SG irrespectively of thier presence in event
Definition: NavigationCore.h:397
HLT::NavigationCore::serialize
virtual bool serialize(std::vector< uint32_t > &output) const
method serizlizes the navigation structure The structure is serrizlized in following order ....
Definition: NavigationCore.cxx:81
get_generator_info.version
version
Definition: get_generator_info.py:33
HLT::TrigNavStructure::isInitialNode
static bool isInitialNode(const TriggerElement *te)
queries if node is an initial one
Definition: TrigNavStructure.cxx:501
HLT::TriggerElement::FeatureAccessHelper::getIndex
const ObjectIndex & getIndex() const
index in the external ojects array
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:209
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
HLT::TrigNavStructure::fillSameRoIRelation
void fillSameRoIRelation(TriggerElement *roi, TriggerElement *te)
rebuilds the sameRoIRelation between trigger elements (used internally by deserialize)
Definition: TrigNavStructure.cxx:307
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
HLTNavDetails::IHolder::typeClid
virtual CLID typeClid() const =0
returns the CLID of objects stores by this holder
CSV_InDetExporter.old
old
Definition: CSV_InDetExporter.py:145
HLT::TriggerElement::FeatureAccessHelper
the FeatureAccessHelper is a class used to keep track of features attached to this TE.
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:192
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
HLTNavDetails::IHolder
Definition: Holder.h:58
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
HLTNavDetails::IHolder::subTypeIndex
uint16_t subTypeIndex() const
returns the index (short number used when linking object to the TE) of objects stores by this holder
Definition: Holder.h:111
TriggerTest.rois
rois
Definition: TriggerTest.py:23
HLT::TrigHolderStructure::getSubTypeIndex
sub_index_type getSubTypeIndex(class_id_type clid, const index_or_label_type &stiOrLabel) const
Definition: TrigHolderStructure.h:63
AthCommonMsg::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
HLT::NavigationCore::registerHolder
bool registerHolder(HLTNavDetails::IHolder *holder)
Definition: NavigationCore.cxx:355
Herwig7_QED_EvtGen_ll.fs
dictionary fs
Definition: Herwig7_QED_EvtGen_ll.py:17
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
python.DecayParser.children
children
Definition: DecayParser.py:32
HLT::TriggerElement::getFeatureAccessHelpers
const std::vector< FeatureAccessHelper > & getFeatureAccessHelpers() const
returns all features which ara attached to this TE
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:238
copySelective.source
string source
Definition: copySelective.py:32
str
Definition: BTagTrackIpAccessor.cxx:11
python.copyTCTOutput.totalSize
totalSize
Definition: copyTCTOutput.py:93
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
merge.status
status
Definition: merge.py:17
HLT::TriggerElement::deserialize
void deserialize(std::vector< uint32_t >::const_iterator &inputIt, const std::map< uint16_t, TriggerElement * > &keys, const TriggerElement *previous)
deserialization
Definition: TrigNavStructure/Root/TriggerElement.cxx:182
HLT::ITrigHolderFactory::fromSerialized
virtual BaseHolder * fromSerialized(int version, const std::vector< uint32_t >::const_iterator &start, const std::vector< uint32_t >::const_iterator &end)=0
HLT::TrigHolderStructure::getAllHolders
std::vector< HolderType * > getAllHolders() const
Definition: TrigHolderStructure.h:40
calibdata.copy
bool copy
Definition: calibdata.py:27
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
HLT::TrigNavStructure::addNode
TriggerElement * addNode(TriggerElement *seed, unsigned int id)
adds nodes seeded form the one given as an argument,
Definition: TrigNavStructure.cxx:79
HLTNavDetails::IHolder::key
virtual const std::string & key() const =0
returns the containers StoreGate key
HLT::NavigationCore::m_classesToPayload_DSonly
std::vector< CSPair > m_classesToPayload_DSonly
classess are put to payload according to that priority list (CLID + key)
Definition: NavigationCore.h:392
HLT::TriggerElementFactory::empty
bool empty() const
Definition: TriggerElementFactory.cxx:24
HLT::TrigNavStructure::addOneLevel
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.
Definition: TrigNavStructure.cxx:610
HLT::TrigNavStructure::isNotActive
static bool isNotActive(const TriggerElement *te)
helper for the STL
Definition: TrigNavStructure.h:257
HLT::TrigHolderStructure::getHolder
HolderType * getHolder(class_id_type clid, const std::variant< sub_index_type, std::string > &stiOrLabel) const
Definition: TrigHolderStructure.h:30
HLT::TrigNavStructure::matchFeature
bool matchFeature(const TriggerElement::FeatureAccessHelper &fea, class_id_type clid, const index_or_label_type &index_or_label) const
Definition: TrigNavStructure.cxx:898
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:26
HLT::NavigationCore::ObjectToStoreGate
@ ObjectToStoreGate
Definition: NavigationCore.h:157
HLT::TriggerElementFactory::produce
TriggerElement * produce(unsigned int id, bool ghost=false, bool nofwd=false)
Definition: TriggerElementFactory.cxx:16
python.iconfTool.gui.pad.logger
logger
Definition: pad.py:14
HLT::TriggerElement::getPreviousFeatures
const std::vector< FeatureAccessHelper > & getPreviousFeatures() const
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:251
CaloCondBlobAlgs_fillNoiseFromASCII.blob
blob
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:96
HLT::NavigationCore::serializeHoldersWithoutPayload
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
Definition: NavigationCore.cxx:502
HLT::NavigationCore::m_logger
const AthAlgTool & m_logger
Definition: NavigationCore.h:406
HLT::TrigHolderStructure::getLabel
std::string getLabel(class_id_type clid, const index_or_label_type &stiOrLabel) const
Definition: TrigHolderStructure.h:78
Trk::previous
@ previous
Definition: BinningData.h:32
HLTNavDetails::IHolder::serializeWithPayload
bool serializeWithPayload(const xAOD::AuxSelection &sel, std::vector< uint32_t > &output, size_t &payloadsize)
serializes this Holder including payload
Definition: Holder.cxx:79
Generated on Thu Nov 7 2024 22:14:54 for ATLAS Offline Software by   doxygen 1.8.18