HLT::TrigNavStructure Class Reference

#include <TrigNavStructure.h>

Inheritance diagram for HLT::TrigNavStructure:

Collaboration diagram for HLT::TrigNavStructure:

Public Member Functions
virtual	~TrigNavStructure ()
virtual void	reset (bool inFinalize=false)
	resets all the navigation, goes to the factory and asks to withdraw all produced objects
TriggerElement *	getInitialNode ()
	gets initial node, if node is not there then it is created on fly
const TriggerElement *	getInitialNode () const
TriggerElement *	addRoINode (TriggerElement *initial)
	gets RoI node (attached to initial)
TriggerElement *	addNode (TriggerElement *seed, unsigned int id)
	adds nodes seeded form the one given as an argument,
TriggerElement *	addNode (std::vector< TriggerElement * > &seeds, unsigned int id, bool ghost=false, bool nofwd=false)
	adds node which is seeded from several other Needed by Topological algorithms
void	printASCIIArt (std::string &str, const TriggerElement *te=0, int offset=0) const
	pretty printing of the navigational structure (heavy)
bool	serializeTEs (std::vector< uint32_t > &output) const
	method serizlizes the navigation structure
bool	deserializeTEs (std::vector< uint32_t >::const_iterator &start, unsigned int totalSize)
virtual bool	serialize (std::vector< uint32_t > &) const =0
	method serizlizes entire navigation
virtual bool	deserialize (const std::vector< uint32_t > &)=0
TriggerElement::FeatureAccessHelper	getFeature (const TriggerElement *te, class_id_type clid, const index_or_label_type &index_or_label) const
	typeless feature access metod
TriggerElement::FeatureAccessHelper	getFeatureRecursively (const TriggerElement *startTE, class_id_type clid, const index_or_label_type &index_or_label, const TriggerElement *&sourceTE) const
	recursive search for features the function is similar to the above butif th features is not found at the startTE the search descends the structure of TEs until it is found.
void	getAllRoIThresholdTEs (std::vector< TriggerElement * > &output) const
	The query returns a vector of all TriggerElements that represent a LVL1 RoI threshold.
void	getAll (std::vector< TriggerElement * > &output, const bool activeOnly=true) const
	The query returning a collection of all TriggerElements.
std::vector< TriggerElement * > &	getAllTEs ()
	access needed by slimming tools.
const std::vector< TriggerElement * > &	getAllTEs () const
	access needed by slimming tools.
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.
unsigned int	countAllOfType (const te_id_type id, const bool activeOnly=true) const
	The query counting a collection of all TriggerElement of a given type.
bool	propagateDeactivation (const TrigNavStructure *nav)
	propagates deactivation of TE state This finction should be used after Trigger is rerurn on L2 and then the reruning on L2 is required.
bool	combine (std::vector< unsigned int > &types, std::vector< std::vector< TriggerElement * > > &output, unsigned int maxResults=1000, bool onlyActive=true)
	For Algorithms: return all the possible n-tuples of TE* objects (te0, te1..., ten)
bool	overlaps (const TriggerElement *t1, const TriggerElement *t2) const
	Check overlap between trigger elements (pointer equality or RoI overlap)
bool	overlaps (const TriggerElement *t1, const std::vector< TriggerElement * > &teVec) const
	Check overlap between a TE and a vector of TEs, using the method above.
bool	getTopologicallySpannedBy (const TriggerElement *te, const std::vector< unsigned int > &types, std::vector< const TriggerElement * > &children, const bool activeOnly=true) const
	gets the TEs whose predecessors were used to built a given topological TE
unsigned int	copyAllFeatures (const TriggerElement *sourceTE, TriggerElement *destTE)
	gets all features from the sourceTE and copies a reference (FeatureAccessHelper) to the destTE
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
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

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

Protected Member Functions
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
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)
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.
TriggerElementFactory &	getFactory ()
TrigHolderStructure &	getHolderStorage ()
std::recursive_mutex &	getMutex ()
const TriggerElementFactory &	getFactory () const
const TrigHolderStructure &	getHolderStorage () const
std::recursive_mutex &	getMutex () const

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

Private Attributes
SG::SlotSpecificObj< TriggerElementFactory >	m_factory
	factory of trigger elements (one per processing slot)
SG::SlotSpecificObj< TrigHolderStructure >	m_holderstorage
	structure for feature holders (one per processing slot)

Static Private Attributes
static std::recursive_mutex	s_rmutex

Detailed Description

Definition at line 40 of file TrigNavStructure.h.

Constructor & Destructor Documentation

~TrigNavStructure()

TrigNavStructure::~TrigNavStructure ( )

virtual

Definition at line 30 of file TrigNavStructure.cxx.

                                    {
  for (auto& factory : m_factory) factory.reset();
}

Member Function Documentation

addNode() [1/2]

TriggerElement * TrigNavStructure::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

Parameters

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

Definition at line 85 of file TrigNavStructure.cxx.

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

addNode() [2/2]

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

adds nodes seeded form the one given as an argument,

Parameters

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

Definition at line 79 of file TrigNavStructure.cxx.

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

addOneLevel()

bool TrigNavStructure::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.

Definition at line 608 of file TrigNavStructure.cxx.

{
  // Get the list of TEs of the desired type from the event
  std::vector<TriggerElement*> newTEs;
  getAllOfType(type, newTEs, onlyActive);
 
  if (currentCombs.size() == 0) {
 
 
    for (unsigned int j = 0; j < newTEs.size(); j++) {
 
      std::vector<TriggerElement*> cbs;
      cbs.push_back(newTEs[j]);
      newCombs.push_back(std::move(cbs));
 
      // Do the same for the auxiliary data
      std::vector<std::pair<unsigned int, unsigned int> > ti;
      ti.emplace_back(type, j);
      newIdxs.push_back(std::move(ti));
    }
    return 1;
  }
 
  // Loop over existing combinations, adding the newTEs one by one
  for (unsigned int i = 0; i < currentCombs.size(); i++) {
 
    // Get the current combinations
    std::vector<TriggerElement*>& comb = currentCombs[i];
 
    // Get the auxiliary data that stores the type and index of each TE.
    // "index" is the index of the TE in the vector of TEs returned by getallOfType - it
    // is assumed to stay the same between calls of addOneLevel within the same combine() call
    std::vector<std::pair<unsigned int, unsigned int> >& ti = currentIdxs[i];
 
    // The auxiliary data is used to avoid double-counting: we make sure that if multiple
    // TEs of the same type appear in the n-tuple, they are always such that
    // their indices in the getAllOfType vector increases with position in the n-tuple.
    // I.E if we have TEs (e0, m1, e1, e2) and e0, e1 and e2 are of the same type,
    // we only take the combination such that e0 comes before e1 and e1 before e2 in
    // the getAllOfType vector of "e".
 
    // To implement this, go through the auxiliary data first and get the index
    // of the last TE of the current type that is already in the ntuple:
    int first = 0;
 
    for (unsigned int j = comb.size(); j > 0; j--)
      if (ti[j - 1].first == type) {
        first = ti[j - 1].second;
        break;
      }
 
    // Now instead of considering all the TEs in newTEs, only loop over those with
    // index > first.
 
    for (unsigned int j = first + 1; j < newTEs.size(); j++) {
 
      TriggerElement* te = newTEs[j];
 
      // Continue if the TE overlaps with any of the TEs in the existing combination
      if (overlaps(te, comb)) continue;
 
      // Add the new TE to the current combination
      comb.push_back(te);
 
      // Add the current combination to the list for the next level
      newCombs.push_back(comb);
 
      // Restore the current combination for the next iteration
      comb.pop_back();
 
      // Do the same for the auxiliary data
      ti.push_back(std::pair<unsigned int, unsigned int>(type, j));
      newIdxs.push_back(ti);
      ti.pop_back();
 
      // If the limit is exceeded, return immediately.
      if (maxResults > 0 && newCombs.size() >= maxResults) {
        return true;
      }
    }
  }
 
  return true;
}

addRoINode()

TriggerElement * TrigNavStructure::addRoINode

(

TriggerElement *

initial

)

gets RoI node (attached to initial)

Definition at line 58 of file TrigNavStructure.cxx.

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

combine()

bool TrigNavStructure::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)

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

Definition at line 580 of file TrigNavStructure.cxx.

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

copyAllFeatures()

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

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

Parameters

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

Returns

number of features that were copied

Definition at line 734 of file TrigNavStructure.cxx.

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

countAllOfType()

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

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

Definition at line 388 of file TrigNavStructure.cxx.

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

decreasingOrderByTEId()

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

static

Definition at line 487 of file TrigNavStructure.cxx.

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

deserialize()

virtual bool HLT::TrigNavStructure::deserialize ( const std::vector< uint32_t > & )

pure virtual

Implemented in HLT::NavigationCore, and HLT::StandaloneNavigation.

deserializeTEs()

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

Definition at line 264 of file TrigNavStructure.cxx.

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

fillSameRoIRelation()

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

protected

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

Warning

should be called for each RoI like node

Definition at line 307 of file TrigNavStructure.cxx.

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

getAll()

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

The query returning a collection of all TriggerElements.

Definition at line 361 of file TrigNavStructure.cxx.

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

getAllOfType()

void TrigNavStructure::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.

Parameters

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

Definition at line 342 of file TrigNavStructure.cxx.

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

getAllRoIThresholdTEs()

void TrigNavStructure::getAllRoIThresholdTEs

(

std::vector< TriggerElement * > &

output

)

const

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

Definition at line 328 of file TrigNavStructure.cxx.

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

getAllTEs() [1/2]

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

(

)

access needed by slimming tools.

Definition at line 374 of file TrigNavStructure.cxx.

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

getAllTEs() [2/2]

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

(

)

const

access needed by slimming tools.

Definition at line 381 of file TrigNavStructure.cxx.

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

getDirectPredecessors()

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

static

returns list of direct predecessors (nodes seeding me)

Parameters

te	TriggerElement to query

Returns

collection of TriggerElements (if empty then node is initial)

Definition at line 120 of file TrigNavStructure.cxx.

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

getDirectSuccessors()

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

static

returns list of direct predecessors (nodes I seed)

Parameters

te	TriggerElement to query

Returns

collection of TriggerElements (if empty then node is terminal)

Definition at line 124 of file TrigNavStructure.cxx.

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

getFactory() [1/2]

TriggerElementFactory & HLT::TrigNavStructure::getFactory ( )

inlineprotected

Definition at line 369 of file TrigNavStructure.h.

{ return *m_factory; }

getFactory() [2/2]

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

inlineprotected

Definition at line 373 of file TrigNavStructure.h.

{ return *m_factory; }

getFeature()

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

typeless feature access metod

Parameters

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

See also

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

Returns

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

Definition at line 781 of file TrigNavStructure.cxx.

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

getFeatureAccessors()

bool TrigNavStructure::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

Reimplemented in HLT::NavigationCore.

Definition at line 840 of file TrigNavStructure.cxx.

                                                       {
 
  bool singleTEstatus = getFeatureAccessorsSingleTE(te,clid,index_or_label,only_single_feature,features,source,sourcelabel);
 
   if(!singleTEstatus){
     // MLOG(WARNING) << "getFeatureAccessorsSingleTE() returned false" << endmsg;
   }
 
 
 
  if ( ! travel_backward_recursively ) {
    return true;
  }
 
  // stop digging deeper if this is an RoI node already
  if ( isRoINode(te) ) {
    return true;
  }
 
  // return if a feature(s) is/are found
  if ( ! features.empty() ) {
    return true;
  }
 
  // recurse deeper
  bool recursion_status = true;
  for( TriggerElement* predecessor: getDirectPredecessors(te) ) {
     
    TriggerElement::FeatureVec features_in_branch;
 
    recursion_status = recursion_status && getFeatureAccessors( predecessor, clid, index_or_label,
                                                                only_single_feature, features_in_branch,
                                                                travel_backward_recursively,
                                                                source, sourcelabel);
    features.insert(features.end(),  features_in_branch.begin(), features_in_branch.end());
  }
    
  if ( only_single_feature &&  ( features.size() > 1 || recursion_status == false) ) {
    // MLOG(DEBUG) << "getFeatureAccessors: looking for object of CLID: " << clid
    //             << " label: \"" << label << "\"" << " found several objects matching criteria while can only return back one, this is ambiguous" << endmsg;
      
    if ( getDirectPredecessors(te).size() > 1 ) // mark bifurcation point as to where one can start again
      source = te;
 
    return false;
  }
  return true;
}

getFeatureAccessorsSingleTE()

bool TrigNavStructure::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

protectedvirtual

Reimplemented in HLT::NavigationCore.

Definition at line 808 of file TrigNavStructure.cxx.

                                                           {
 
  // ATH_MSG_VERBOSE("getFeatureAccessorsSingleTE: looking for:" << (only_single_feature ? "one object" : "many objects" ) << " of CLID: " << clid
  //          << " label: \"" << label << "\"" << " starting from TE: " << te->getId());
 
  int size = te->getFeatureAccessHelpers().size();
  
  // loop the feature access helper in order depending of type of request (i.e. if single featyure needed then loop from back, if all then loop from the front)
  for ( int it = ( only_single_feature ? size-1 : 0 ); it != (only_single_feature ? -1 : size ); only_single_feature ? it--: it++ ) {
    auto& fea = te->getFeatureAccessHelpers().at(it);
    //ATH_MSG_VERBOSE("getFeatureAccessors: in a loop over FeatureAccessHelpers got ObjectIndex " << fea);
 
    if(matchFeature(fea,clid,index_or_label)){
      sourcelabel = label(clid,fea.getIndex().subTypeIndex());
      source = te;
      features.push_back(fea);
 
      // ATH_MSG_DEBUG("getFeatureAccessors: matching feature found in te: " << *te << " index: " << fea);
      // now the ending (depends on the "single" flag)
      if ( only_single_feature )
    break;
    }
  } // end of loop over feature access helpers of this TE
  
  return true;
}

getFeatureRecursively()

TriggerElement::FeatureAccessHelper TrigNavStructure::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.

It stops on RoI nodes.

Parameters

sourceTE

is the TE where the feature was found

Definition at line 795 of file TrigNavStructure.cxx.

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

getHolder()

const BaseHolder * TrigNavStructure::getHolder

(

const TriggerElement::FeatureAccessHelper &

fea

)

const

Definition at line 921 of file TrigNavStructure.cxx.

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

getHolderStorage() [1/2]

TrigHolderStructure & HLT::TrigNavStructure::getHolderStorage ( )

inlineprotected

Definition at line 370 of file TrigNavStructure.h.

{ return *m_holderstorage; }

getHolderStorage() [2/2]

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

inlineprotected

Definition at line 374 of file TrigNavStructure.h.

{ return *m_holderstorage; }

getInitialNode() [1/2]

TriggerElement * TrigNavStructure::getInitialNode

(

)

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

Definition at line 39 of file TrigNavStructure.cxx.

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

getInitialNode() [2/2]

const TriggerElement * TrigNavStructure::getInitialNode

(

)

const

Definition at line 48 of file TrigNavStructure.cxx.

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

getMutex() [1/2]

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

inlineprotected

Definition at line 371 of file TrigNavStructure.h.

{ return s_rmutex; }

getMutex() [2/2]

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

inlineprotected

Definition at line 375 of file TrigNavStructure.h.

{ return s_rmutex; }

getRoINodes()

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

static

gets all RoI type nodes seeding indirectly this TriggerElement

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

Warning

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

Definition at line 73 of file TrigNavStructure.cxx.

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

getSuccessor()

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

static

returns successor of given type beeing seeded from this TE

Parameters

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

Returns

TriggerElement pointer which can be 0

Warning

the implementation is recursive

Definition at line 129 of file TrigNavStructure.cxx.

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

getTopologicallySpannedBy()

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

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

Parameters

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

Definition at line 712 of file TrigNavStructure.cxx.

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

hasIdFromTheSet()

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

static

simple helper

Definition at line 491 of file TrigNavStructure.cxx.

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

haveAllCommonRoIs()

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

static

Definition at line 447 of file TrigNavStructure.cxx.

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

haveCommonRoI()

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

static

does this 2 share RoI

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

Warning

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

Returns

true if there is at least one common RoI

Definition at line 414 of file TrigNavStructure.cxx.

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

haveCommonSeed()

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

static

checks that there is any common predecessor of two TriggerElements

Warning

See comments on haveCommonRoI. The same applies.

Definition at line 459 of file TrigNavStructure.cxx.

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

haveDistinctRoI()

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

static

inversion of haveCommonRoI

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

Definition at line 442 of file TrigNavStructure.cxx.

                                                                                             {
  return ! haveCommonRoI(te1, te2);
}

haveDistinctSeed()

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

static

inversion of haveCommonSeed

Definition at line 479 of file TrigNavStructure.cxx.

                                                                                               {
  return ! haveCommonSeed(te1, te2);
}

increasingOrderByTEId()

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

static

for sorting TriggerElements according to their id

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

Definition at line 483 of file TrigNavStructure.cxx.

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

isCompatibleTree()

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

static

check compatibility of 2 navigation structures

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

Definition at line 524 of file TrigNavStructure.cxx.

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

isInitialNode()

bool TrigNavStructure::isInitialNode ( const TriggerElement * te )

static

queries if node is an initial one

Parameters

te	node to be queried

Returns

true if passed node is initial

Definition at line 499 of file TrigNavStructure.cxx.

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

isNotActive()

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

inlinestatic

helper for the STL

Definition at line 257 of file TrigNavStructure.h.

{ return !te->getActiveState(); }

isRoINode()

bool TrigNavStructure::isRoINode ( const TriggerElement * te )

static

queries if node is an RoI type one

Parameters

te	node to be queried

Returns

true if passed node is RoI type

Definition at line 505 of file TrigNavStructure.cxx.

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

isTerminalNode()

bool TrigNavStructure::isTerminalNode ( const TriggerElement * te )

static

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

Parameters

te	node to be queried

Returns

true if passed node is terminal

Definition at line 515 of file TrigNavStructure.cxx.

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

isTopological()

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

inlinestatic

Definition at line 259 of file TrigNavStructure.h.

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

label()

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

Definition at line 773 of file TrigNavStructure.cxx.

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

matchFeature()

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

protected

Definition at line 896 of file TrigNavStructure.cxx.

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

overlaps() [1/2]

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

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

Definition at line 698 of file TrigNavStructure.cxx.

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

overlaps() [2/2]

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

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

Definition at line 705 of file TrigNavStructure.cxx.

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

printASCIIArt()

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

pretty printing of the navigational structure (heavy)

Definition at line 152 of file TrigNavStructure.cxx.

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

propagateDeactivation()

bool TrigNavStructure::propagateDeactivation

(

const TrigNavStructure *

nav

)

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

The deactivated lines must be propagated ahead.

Parameters

nav	is navigation which was reprocessed (additional branches deactivated)

Returns

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

Definition at line 555 of file TrigNavStructure.cxx.

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

reset()

void TrigNavStructure::reset ( bool inFinalize = false )

virtual

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

Reimplemented in HLT::NavigationCore.

Definition at line 754 of file TrigNavStructure.cxx.

                                            {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  if (inFinalize) {
    for (auto& factory : m_factory) factory.reset();
    for (auto& holder : m_holderstorage) holder.reset();
  } else {
    getFactory().reset();
    getHolderStorage().reset();
  }
}

serialize()

virtual bool HLT::TrigNavStructure::serialize ( std::vector< uint32_t > & ) const

pure virtual

method serizlizes entire navigation

Parameters

output

vector to place the result

Returns

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

Implemented in HLT::NavigationCore, and HLT::StandaloneNavigation.

serializeTEs()

bool TrigNavStructure::serializeTEs

(

std::vector< uint32_t > &

output

)

const

method serizlizes the navigation structure

Parameters

output

vector to place the result

Returns

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

Definition at line 217 of file TrigNavStructure.cxx.

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

subType()

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

Definition at line 766 of file TrigNavStructure.cxx.

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

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

const TriggerElement* m_unspecifiedTE HLT::TrigNavStructure::ATLAS_THREAD_SAFE

staticprotected

Definition at line 377 of file TrigNavStructure.h.

ATLAS_THREAD_SAFE [2/2]

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

staticprotected

Definition at line 378 of file TrigNavStructure.h.

m_factory

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

private

factory of trigger elements (one per processing slot)

Definition at line 382 of file TrigNavStructure.h.

m_holderstorage

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

private

structure for feature holders (one per processing slot)

Definition at line 383 of file TrigNavStructure.h.

s_rmutex

std::recursive_mutex TrigNavStructure::s_rmutex

staticprivate

Definition at line 385 of file TrigNavStructure.h.

---

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

• TrigNavStructure.h
• TrigNavStructure.cxx