TrigNavigationThinningSvc Class Reference

The TrigNavigationThinningSvc is an athena tool used to slim the trigger Navigation structure in various ways. More...

#include <TrigNavigationThinningSvc.h>

Inheritance diagram for TrigNavigationThinningSvc:

Collaboration diagram for TrigNavigationThinningSvc:

Classes
struct	State
class	TriggerElementFind
	Used to compare pointers of TriggerElements. More...

Public Member Functions
	TrigNavigationThinningSvc (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	doSlimming (const EventContext &, std::vector< uint32_t > &slimmed_and_serialized) const override

Private Types
typedef StatusCode(TrigNavigationThinningSvc::*	Action) (const EventContext &ctx, State &state) const

Private Member Functions
StatusCode	lateFillConfiguration (State &state) const
	configures at the first event
StatusCode	drop (const EventContext &ctx, State &state) const
	clear the result of the slimming in the doSliming argument (vector<uint32_t>) Makes no sense to combine with other options
StatusCode	reload (const EventContext &ctx, State &state) const
	Reload the slimmed navigation in TDT so that all clients of current job see the chage.
StatusCode	restore (const EventContext &ctx, State &state) const
	Restore the original navigation structure.
StatusCode	save (const EventContext &ctx, State &state) const
	Save the result of the slimming in the doSlimming argument (vector<uint32_t>).
StatusCode	print (const EventContext &ctx, State &state) const
StatusCode	squeeze (const EventContext &ctx, State &state) const
	Remove intermediate TEs leaving very flat structure with event node, rois and terminals.
StatusCode	dropFeatures (const EventContext &ctx, State &state) const
	Removes references to features from the navigation structure.
StatusCode	dropRoIs (const EventContext &ctx, State &state) const
	Removes RoI nodes, rather aggressive option, should be use as one of last actions as it makes impossible to traverse the tree.
StatusCode	dropEmptyRoIs (const EventContext &ctx, State &state) const
	Removes RoI nodes, which do not seed anything.
StatusCode	dropFeatureless (const EventContext &ctx, State &state) const
	Removes TEs which have no features (combine wiht squeeze).
StatusCode	dropInactive ()
	Removes TEs which are inactive (rejected by hypothesis).
StatusCode	syncThinning (const EventContext &ctx, State &state) const
	reset indexes in the after the thinning
StatusCode	dropChains (const EventContext &ctx, State &state) const
	remove info not related to the specified chains
StatusCode	removeTriggerElement (State &state, HLT::TriggerElement *te, bool propagateFeatures=true) const
	Removes the passed trigger element from the navigation structure by removing all references to it in seeded and seeding TEs,.
StatusCode	removeGhostTriggerElements (HLT::TriggerElement *te=0)
	Removes all trigger elements with the flag ghost set to true from the navigation structure.
StatusCode	removeFeaturelessTriggerElements (State &state, HLT::TriggerElement *te=0)
	Removes all trigger elements with no features from the navigation structure.
StatusCode	recursivelyRemoveNodesFromNavigation (HLT::TriggerElement *te)
	Removes the passed te and all children from the navigation structure.
StatusCode	removeFeatures (State &state, const std::set< std::pair< CLID, uint16_t > > &doDelete) const
	This is a helper function for removeFeatures(HLT::NavigationCore*, ...).
StatusCode	retainFeatures (State &state, const std::set< std::pair< CLID, uint16_t > > &toRetain) const
	This is a helper function for removeFeatures(HLT::NavigationCore*, ...).
StatusCode	removeTriggerElementFromVector (HLT::TriggerElement *te, std::vector< HLT::TriggerElement * > &v) const
	Removes all instances of the supplied TriggerElement from the supplied vector.
bool	toBeIncluded (State &state, HLT::TriggerElement *te, std::vector< std::string > *inclusionList, std::vector< std::string > *exclusionList)
	Returns true if the TriggerElement should be included in the navigation tree and false if it should not be.
bool	toBeIncluded (State &state, HLT::TriggerElement *te, std::vector< HLT::TriggerElement * > *inclusionList, std::vector< HLT::TriggerElement * > *exclusionList)
StatusCode	propagateFeaturesToChildren (const HLT::TriggerElement *te) const
	Propagates the features on given TE to its children.

Private Attributes
ToolHandle< Trig::TrigDecisionTool >	m_trigDecisionTool
std::vector< std::string >	m_featureInclusionList
std::vector< std::string >	m_featureExclusionList
std::set< std::string >	m_featureKeepSet
	computed from above
std::set< std::string >	m_featureDropSet
	computed from above
std::vector< std::string >	m_actions
std::map< std::string, Action >	m_actionsMap
std::string	m_chainsRegex
bool	m_report
	TE operations verbosity flag.

Detailed Description

The TrigNavigationThinningSvc is an athena tool used to slim the trigger Navigation structure in various ways.

Author

Ben Smith bcsmi.nosp@m.th@f.nosp@m.as.ha.nosp@m.rvar.nosp@m.d.edu - Harvard University major rework Tomasz Bold

This tool allows users to slim the trigger Navigation structure, which is important when creating derived datasets, as the structure can grow very large (> 30k per event).

There are three main slimming operations that are implemented via this tool:

(a) TriggerElement squeezing: this removes all intermediate trigger elements (those which are not the initial node, an RoI node, or a terminal node)

(b) Feature Removal: this removes all links to the specified features from the trigger elements in the structure. Note that it does not remove the holder from the navigation structure.

(c) Remove the TEs related to certain chains

(d) Complete removal

and few other actions

All operations on the navigation are configured via the Actions property which specifies set of operations (and the order) with which they are executed in the slimming process. The main method to execute is doSlimming - the vector given as an argument is filled whti serialized and slimmed content of the navigation. !!! go back !!! we need to remove holders from slimmed navigation as they are becoming now the biggest

Definition at line 53 of file TrigNavigationThinningSvc.h.

Member Typedef Documentation

Action

typedef StatusCode(TrigNavigationThinningSvc::* TrigNavigationThinningSvc::Action) (const EventContext &ctx, State &state) const

private

Definition at line 90 of file TrigNavigationThinningSvc.h.

Constructor & Destructor Documentation

TrigNavigationThinningSvc()

TrigNavigationThinningSvc::TrigNavigationThinningSvc	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 30 of file TrigNavigationThinningSvc.cxx.

  : base_class(name, pSvcLocator), 
    m_trigDecisionTool("Trig::TrigDecisionTool/TrigDecisionTool")
{
  // job option configurable properties
  declareProperty("TrigDecisionTool", m_trigDecisionTool, "Tool handle to TDT/Navigation.");
  declareProperty("ChainsRegex", m_chainsRegex="", "Keep only information related to this chains");
  declareProperty("FeatureInclusionList", m_featureInclusionList, "This features will be kept. This setting overrules the FeatureExclusionList. Only list of types or type#key pairs are supported.");
  declareProperty("FeatureExclusionList", m_featureExclusionList, "This features will be dropeed. It can be specified as * meaning all, or as a list of typenames, or typename#key pairs.");
  declareProperty("ReportOperations", m_report=false, "Additional verbosity flag, when enabled the operations on trigger elements are reported (VERBOSE logging level)");
 
  m_actionsMap["Drop"]    = &TrigNavigationThinningSvc::drop;
  m_actionsMap["Reload"]  = &TrigNavigationThinningSvc::reload;
  m_actionsMap["Restore"] = &TrigNavigationThinningSvc::restore;
  m_actionsMap["Print"]   = &TrigNavigationThinningSvc::print;
  m_actionsMap["Save"]    = &TrigNavigationThinningSvc::save;
  m_actionsMap["Squeeze"]       = &TrigNavigationThinningSvc::squeeze;
  m_actionsMap["DropFeatures"]  = &TrigNavigationThinningSvc::dropFeatures;
  m_actionsMap["DropRoIs"]      = &TrigNavigationThinningSvc::dropRoIs;
  m_actionsMap["DropEmptyRoIs"] = &TrigNavigationThinningSvc::dropEmptyRoIs;
  m_actionsMap["DropFeatureless"] = &TrigNavigationThinningSvc::dropFeatureless;
  m_actionsMap["SyncThinning"]     = &TrigNavigationThinningSvc::syncThinning;
  m_actionsMap["DropChains"]     = &TrigNavigationThinningSvc::dropChains;
 
 
  std::string possibleActions;
  for ( auto a: m_actionsMap )
    possibleActions += a.first +" ";
  declareProperty("Actions", m_actions, "Operations which need to be done on the navigation"+possibleActions);
}

Member Function Documentation

doSlimming()

StatusCode TrigNavigationThinningSvc::doSlimming ( const EventContext & ctx, std::vector< uint32_t > & slimmed_and_serialized ) const

overridevirtual

Definition at line 286 of file TrigNavigationThinningSvc.cxx.

                                                                                                     {
 
  ATH_MSG_DEBUG(name() << " is obtaining the TrigNavigationThinningSvc lock in slot " << ctx.slot() << " for event " << ctx.eventID().event_number() );
  std::lock_guard<std::mutex> lock(TrigNavigationThinningSvcMutex::s_mutex);
 
  // grab the navigation
  auto navAccess = m_trigDecisionTool->ExperimentalAndExpertMethods();
  // protected by above lock
  HLT::NavigationCore *cnav ATLAS_THREAD_SAFE = const_cast<HLT::NavigationCore*>(navAccess.getNavigation());
 
  if(cnav == 0) {
    ATH_MSG_WARNING ( "Could not get navigation from Trigger Decision Tool" );
    ATH_MSG_WARNING ( "Navigation will not be slimmed in this event" );
    ATH_MSG_DEBUG(name() << " is releasing the TrigNavigationThinningSvc lock");
    return StatusCode::SUCCESS;
  }
    
  State state (ctx, *cnav, slimmed_and_serialized);
  CHECK( lateFillConfiguration(state) );
  {
    state.originalNavigation.clear();
    std::vector<uint32_t> cuts;
    cnav->serialize(state.originalNavigation, cuts);
  }
 
  for ( auto& action: m_actions ) {
    ATH_MSG_DEBUG("Applying action " << action << " on the navigation ");
    auto ifunc = m_actionsMap.find (action);
    if (ifunc != m_actionsMap.end()) {
      auto function = ifunc->second;
      CHECK( (this->*function)(ctx, state) );
    }
  }
  ATH_MSG_DEBUG(name() << " is releasing the TrigNavigationThinningSvc lock");
  return StatusCode::SUCCESS;
}

drop()

StatusCode TrigNavigationThinningSvc::drop ( const EventContext & ctx, State & state ) const

private

clear the result of the slimming in the doSliming argument (vector<uint32_t>) Makes no sense to combine with other options

Definition at line 122 of file TrigNavigationThinningSvc.cxx.

{
  state.destinationNavigation.clear();
  ATH_MSG_DEBUG ( "Navigation dropped entirely" );
  return StatusCode::SUCCESS;
}

dropChains()

StatusCode TrigNavigationThinningSvc::dropChains ( const EventContext & ctx, State & state ) const

private

remove info not related to the specified chains

Definition at line 266 of file TrigNavigationThinningSvc.cxx.

                                                                                          {
  if ( m_chainsRegex.empty() ) {
    return StatusCode::SUCCESS;
  }
  // now run over the tree and drop alle TEs except RoIs and intial which are not in the TEs to protect
  for ( auto te: state.navigation.getAllTEs() ) {
    if ( state.navigation.isInitialNode(te)
     or state.navigation.isRoINode(te) ) {
      continue;
    }
    if ( state.tesToProtect.find(te->getId()) == state.tesToProtect.end() ) {
      CHECK( removeTriggerElement(state, te));
    }
  }
  return StatusCode::SUCCESS;
}

dropEmptyRoIs()

StatusCode TrigNavigationThinningSvc::dropEmptyRoIs ( const EventContext & ctx, State & state ) const

private

Removes RoI nodes, which do not seed anything.

Definition at line 248 of file TrigNavigationThinningSvc.cxx.

                                                                                             {
  for ( auto te: state.navigation.getAllTEs() ) {
    if ( state.navigation.isRoINode(te) 
     and te->getRelated(TriggerElement::seedsRelation).empty() )
      CHECK( removeTriggerElement(state, te) );
  }
  return StatusCode::SUCCESS;  
}

dropFeatureless()

StatusCode TrigNavigationThinningSvc::dropFeatureless ( const EventContext & ctx, State & state ) const

private

Removes TEs which have no features (combine wiht squeeze).

Definition at line 257 of file TrigNavigationThinningSvc.cxx.

                                                                                               {
  for ( auto te: state.navigation.getAllTEs() ) {
    if ( te->getFeatureAccessHelpers().empty() )
      CHECK( removeTriggerElement(state, te) );
  }  
  return StatusCode::SUCCESS;  
}

dropFeatures()

StatusCode TrigNavigationThinningSvc::dropFeatures ( const EventContext & ctx, State & state ) const

private

Removes references to features from the navigation structure.

Features are specified via the inclusion and exclusion lists. If the inclusion list is specified, only elements on that list are included (the exclusion list is ignored). If the inclusion list is NULL or empty, then all elements except those on the exclusion list are included.

Definition at line 184 of file TrigNavigationThinningSvc.cxx.

{
  // turn the inclusion and exclusion lists into set of pairs <CLID, SubTypeIndex> of this collections which needs to be dropped
  // in fact this a bit waste of time that we reclaulate this each time, but, one can imagine slimming events from different runs/configurations
  // but then we sould have to check some configuration in data (i.e. SMK in the HLTResult, and recompute m_deletedFeatures only if it changes)
  std::set<std::pair<CLID, uint16_t> > toDelete;
  std::set<std::pair<CLID, uint16_t> > toRetain;
 
  std::lock_guard<std::recursive_mutex> lock(state.navigation.getMutex());
 
  const auto& holders = state.navigation.getHolderStorage().getAllHolders<HLTNavDetails::IHolder>();
  if ( holders.empty() ) {  // to prevent issues as in ATR-25282
    ATH_MSG_ERROR("The navigation does not contain any features. This is likely a configuration problem.");
    return StatusCode::FAILURE;
  }
 
  for( auto h : holders ) {
    if(!h) { // check if h is null
      ATH_MSG_WARNING("holder.second is null pointer; skipping...");
      continue;
    }
    //ATH_MSG_VERBOSE("Checking what to do with " 
    //            << h->collectionName()+"#"+h->key());
    // check if this needs to be kept
    if ( not m_featureKeepSet.empty() ) {
      if (  m_featureKeepSet.count(h->collectionName())
        || m_featureKeepSet.count(h->key()) ) {
    toRetain.insert(std::make_pair(h->typeClid(), h->subTypeIndex() ));
    ATH_MSG_DEBUG("will be keeping references associated to: " << h->collectionName()<<"#"<<h->key() << " clid: " << h->typeClid() );
      } 
    }
    // check if this needs to be dropped
    if ( not m_featureDropSet.empty() ) {
      if ( m_featureDropSet.count(h->collectionName()) 
       || m_featureDropSet.count(h->key()) ) {
    toDelete.insert(std::make_pair(h->typeClid(), h->subTypeIndex() ));
    ATH_MSG_DEBUG("will be dropping references associated to: " << h->collectionName()<<"#"<<h->key() );
      }
    }
  }     
  
 
  if ( not toRetain.empty() )
    return retainFeatures(state, toRetain);
  if ( not toDelete.empty() )
    return removeFeatures(state, toDelete);
 
  // now that we've removed them from the tree, we need to remove them from
  // the navigation structure as well.  We do this by finding the holders that
  // match the deleted labels and removing them.
  // to be implemented !!!
 
  return StatusCode::SUCCESS;  
}

dropInactive()

StatusCode TrigNavigationThinningSvc::dropInactive ( )

private

Removes TEs which are inactive (rejected by hypothesis).

dropRoIs()

StatusCode TrigNavigationThinningSvc::dropRoIs ( const EventContext & ctx, State & state ) const

private

Removes RoI nodes, rather aggressive option, should be use as one of last actions as it makes impossible to traverse the tree.

Nonetheless the tree can be to some extent usable in the analysis i.e. when no TEs traversing is really needed

Definition at line 240 of file TrigNavigationThinningSvc.cxx.

                                                                                        {
  for ( auto te: state.navigation.getAllTEs() ) {
    if ( state.navigation.isRoINode(te) )
      CHECK( removeTriggerElement(state, te) );
  }
  return StatusCode::SUCCESS;  
}

finalize()

StatusCode TrigNavigationThinningSvc::finalize ( )

overridevirtual

Definition at line 326 of file TrigNavigationThinningSvc.cxx.

                                               {
  return StatusCode::SUCCESS;
}

initialize()

StatusCode TrigNavigationThinningSvc::initialize ( )

overridevirtual

Definition at line 69 of file TrigNavigationThinningSvc.cxx.

                                                 {
 
  ATH_MSG_DEBUG( "TrigNavigationThinningSvc::initialize()" << name() );
 
  m_checkToolDeps = false;
 
  // load the required tools
  if( not m_trigDecisionTool.empty() ) {
    if ( m_trigDecisionTool.retrieve().isFailure() ) {
      ATH_MSG_FATAL ( "Unable to retrieve the TrigDecisionTool!" );
      ATH_MSG_FATAL ( "Please check your job options file" );
      return StatusCode::FAILURE;
    }
    ATH_MSG_INFO ( "Successfully retrieved the TrigDecisionTool!" );
  }
  else {
    ATH_MSG_FATAL ( "Could not retrieve the TrigDecisionTool as it was not specified!" );
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG ( "Leaving TrigNavigationThinningSvc::Initialize" );
  // make sure that the inclusions/exclusions are self consistent i.e. they can not be sued at the same time
  if ( m_featureExclusionList.size() and m_featureInclusionList.size() ) {
    ATH_MSG_ERROR( "Can't use the features inclusion and exclusion lists at the same time.");
    return StatusCode::FAILURE;
  }
 
  m_featureKeepSet.insert( m_featureInclusionList.begin(), m_featureInclusionList.end() );
  m_featureDropSet.insert( m_featureExclusionList.begin(), m_featureExclusionList.end() );
  if ( m_featureKeepSet.size() or m_featureDropSet.size() ) {
    ATH_MSG_DEBUG("Configured features removeal keep:" <<  m_featureInclusionList
           << " drop: " << m_featureExclusionList );
  } else {
    if ( find(m_actions.begin(), m_actions.end(), "DropFeatures") != m_actions.end() ) {      
      ATH_MSG_FATAL("Dropping features is demanded but neither inclusion and exclusion lists are set");
      return StatusCode::FAILURE;
    }    
  }
 
 
 
  // verify if all actions are possible 
  for ( auto& action: m_actions) {
    if ( m_actionsMap.find(action) == m_actionsMap.end()) {
      ATH_MSG_FATAL("Action not implemented (check for typo) " << action << " possible " << m_actions);
      return StatusCode::FAILURE;
    }
  }  
  return StatusCode::SUCCESS;
}

lateFillConfiguration()

StatusCode TrigNavigationThinningSvc::lateFillConfiguration ( State & state ) const

private

configures at the first event

Definition at line 333 of file TrigNavigationThinningSvc.cxx.

                                                                   {
  // remember the configured chain names, as they will be useful later  
  // ??? Originally, this was done once and cached in the tool.
  //     If this takes too long, consider storing it in the detector store.
  auto chainGroup = m_trigDecisionTool->getChainGroup(m_chainsRegex);
  ATH_MSG_DEBUG("Will keep information related to this chains" << chainGroup->getListOfTriggers());
  auto confTEs = chainGroup->getHLTTriggerElements();
  for ( auto& vec: confTEs) {
    for ( auto confTEPtr: vec) {
      state.tesToProtect.insert(confTEPtr->id());
    }
  }
  return StatusCode::SUCCESS;
}

print()

StatusCode TrigNavigationThinningSvc::print ( const EventContext & ctx, State & state ) const

private

Definition at line 163 of file TrigNavigationThinningSvc.cxx.

                                                                                     {
  ATH_MSG_DEBUG ( "Navigation printout \n" << state.navigation );
  return StatusCode::SUCCESS;
}

propagateFeaturesToChildren()

StatusCode TrigNavigationThinningSvc::propagateFeaturesToChildren ( const HLT::TriggerElement * te ) const

private

Propagates the features on given TE to its children.

Definition at line 597 of file TrigNavigationThinningSvc.cxx.

                                                                                     {
 
  if ( not te )
    return StatusCode::SUCCESS;
 
  const std::vector<TriggerElement::FeatureAccessHelper>& features = te->getFeatureAccessHelpers() ;
 
  const std::vector<TriggerElement*> children = te->getRelated(TriggerElement::seedsRelation);
  for( auto ch: children ) {
    if ( m_report ) ATH_MSG_VERBOSE("Propagating features to child: " << ch << " " << ch->getId() );
    // add the parents features to the front of the child features list features list
    // skip this FEAs which are anyway to be discarded
    for( auto& fea: features ) {
      if ( fea.forget() ) 
    continue;
      if ( m_report ){
    std::stringstream ss;
    ss << fea;
    ATH_MSG_VERBOSE("Propagating feature " << ss.str() );
      }
      ch->getFeatureAccessHelpers().insert(ch->getFeatureAccessHelpers().begin(), fea );
    }     
    //    te->getFeatureAccessHelpers().insert((*iter)->getFeatureAccessHelpers().begin(), features.begin(), features.end());
  }
  return StatusCode::SUCCESS;
}

recursivelyRemoveNodesFromNavigation()

StatusCode TrigNavigationThinningSvc::recursivelyRemoveNodesFromNavigation ( HLT::TriggerElement * te )

private

Removes the passed te and all children from the navigation structure.

reload()

StatusCode TrigNavigationThinningSvc::reload ( const EventContext & ctx, State & state ) const

private

Reload the slimmed navigation in TDT so that all clients of current job see the chage.

Definition at line 130 of file TrigNavigationThinningSvc.cxx.

{
  state.destinationNavigation.clear();
  std::vector<unsigned int> cuts;
  std::vector<uint32_t> temp;
  state.navigation.serialize(temp, cuts);
  state.navigation.reset();
  state.navigation.prepare();
  state.navigation.deserialize(temp);
  ATH_MSG_DEBUG ( "Reloaded the navigation content in TDT (all clients will see reduced navigation content) ..." );
  return StatusCode::SUCCESS;
}

removeFeaturelessTriggerElements()

StatusCode TrigNavigationThinningSvc::removeFeaturelessTriggerElements ( State & state, HLT::TriggerElement * te = 0 )

private

Removes all trigger elements with no features from the navigation structure.

Definition at line 467 of file TrigNavigationThinningSvc.cxx.

                                                                              {
  ATH_MSG_DEBUG ( "Running the adjustIndicesAfterThinning" );
 
  for ( auto te: state.navigation.getAllTEs() ) {
    size_t featuresCount = std::count_if(te->getFeatureAccessHelpers().begin(), 
                     te->getFeatureAccessHelpers().end(), 
                     [](const TriggerElement::FeatureAccessHelper& fea){ return fea.forget(); }
                     );
    if( featuresCount == 0 ) {
      CHECK( removeTriggerElement( state, te, false ) );      
    } 
  }
  return StatusCode::SUCCESS;
}

removeFeatures()

StatusCode TrigNavigationThinningSvc::removeFeatures ( State & state, const std::set< std::pair< CLID, uint16_t > > & doDelete ) const

private

This is a helper function for removeFeatures(HLT::NavigationCore*, ...).

Note that that function should be instead, because it not only removes the features from the tree, but also cleans them up within the navigation structure.

Definition at line 420 of file TrigNavigationThinningSvc.cxx.

                                                                                                             {
  // we have the following problem:
  // (a) features are stored as a vector where order can possibly matter
  // (b) its very time consuming to delete items from the middle of a vector
  // (c) a large fraction of elements will not have any features deleted
  //
  // To handle this, we're going to build an array that keeps track of
  // whether an element needs be deleted.  If none do, nothing gets changed.
  // If some do, we build a new vector and copy it over.  This prevents
  // the big time sink from deleting elements in the middle of a vector. 
  
  // another option would be to build a new vector when using inclusion
  // lists and remove elements when using exclusion lists
  ATH_MSG_DEBUG("Will remove " << toDelete.size()<< " feature type/key");
  using namespace HLT; 
   for (auto te: state.navigation.getAllTEs()) {
    for ( auto& fea: te->getFeatureAccessHelpers() ) {
      if ( toDelete.find( std::make_pair(fea.getCLID(), fea.getIndex().subTypeIndex()) ) != toDelete.end() )    
    fea.setForget(true); // when we mark this then the serialization of TEs will simpley skip this one, easy, no
    }
  }
   // get back here
   // get rid of the holders themselves
      //m_navigation->m_featuresByIndex[ h->typeClid() ].erase( h->subTypeIndex() ); // Erasing an element of the map we're looping over
   //m_navigation->m_featuresByLabel.at( h->typeClid() ).erase( h->label() ); // Use new C++11 map accessor (does bounds check)
   //      delete holder.second;
 
  return StatusCode::SUCCESS;
}

removeGhostTriggerElements()

StatusCode TrigNavigationThinningSvc::removeGhostTriggerElements ( HLT::TriggerElement * te = 0 )

private

Removes all trigger elements with the flag ghost set to true from the navigation structure.

removeTriggerElement()

StatusCode TrigNavigationThinningSvc::removeTriggerElement ( State & state, HLT::TriggerElement * te, bool propagateFeatures = true ) const

private

Removes the passed trigger element from the navigation structure by removing all references to it in seeded and seeding TEs,.

Parameters

propagateFeatures

decides if features need to be moved to children TEs

Definition at line 348 of file TrigNavigationThinningSvc.cxx.

                                                                                         {
  // refuse to remove the initial node
  if(state.navigation.isInitialNode(te)) {
    return StatusCode::SUCCESS;
  }
  if ( m_report )  ATH_MSG_VERBOSE("Removing TE of ID: " << te->getId() );
  
  // mark the element as transient to prevent it from being serialized
  te->setTransient();
 
 
  // propagate the features to its children
  if ( propagateFeatures )
    CHECK( propagateFeaturesToChildren(te) );
 
 
 
  if ( m_report )  ATH_MSG_VERBOSE("Removeing TE of ID: " << te->getId() << " removing same RoI relations" );
  // for those in the same RoI, we need only remove the relationship from ones who are related
  const std::vector<TriggerElement*>& sameRoI = te->getRelated(TriggerElement::sameRoIRelation);
 
  for( auto nodeInRoI : sameRoI ) {
    if ( m_report )  ATH_MSG_VERBOSE("Removeing TE of ID: " << te->getId() << " bypassing same RoI relation " );
    // get the relations, and remove the ones that point to te
    std::vector<TriggerElement*>& relations = nodeInRoI->m_relations[ TriggerElement::sameRoIRelation ];
    CHECK( removeTriggerElementFromVector (te, relations) );
  }
 
  // for those who te is seededBy, we need to remove the seeds relation, and propagate it down
  // (if te is not terminal)
 
  std::vector<TriggerElement*> seededBy = te->m_relations[TriggerElement::seededByRelation];
 
  for(auto seededByNode:  seededBy ) {
 
    // get the relations and remove the ones that point to te
    std::vector<TriggerElement*>& relations = seededByNode->m_relations[ TriggerElement::seedsRelation ];
    CHECK( removeTriggerElementFromVector (te, relations) );
    
    
 
    // now add all the nodes te seeds onto the node we just removed the seeds relation from
    if(!state.navigation.isTerminalNode(te))
      seededByNode->relate( te->m_relations[ TriggerElement::seedsRelation ], TriggerElement::seedsRelation );
  }
 
  // for those who te seeds, we need to remove the seededBy relation, and propagate it up
  // (if te is not the inital node - hey, you never know!)
 
  std::vector<TriggerElement*>& seeds = te->m_relations[TriggerElement::seedsRelation];
 
  for( auto seedsNode: seeds ) {
 
    // get the relations and remove the ones that point to te
    std::vector<TriggerElement*>& relations = seedsNode->m_relations[ TriggerElement::seededByRelation ];
    CHECK ( removeTriggerElementFromVector(te, relations) );
 
    // now add all the nodes te seeds onto the node we just removed the seeds relation from
    if(!state.navigation.isInitialNode(te))
      seedsNode->relate( te->m_relations[ TriggerElement::seededByRelation ], TriggerElement::seededByRelation );
  }
 
  return StatusCode::SUCCESS;
}

removeTriggerElementFromVector()

StatusCode TrigNavigationThinningSvc::removeTriggerElementFromVector ( HLT::TriggerElement * te, std::vector< HLT::TriggerElement * > & v ) const

private

Removes all instances of the supplied TriggerElement from the supplied vector.

Returns the number of elements removed.

Definition at line 488 of file TrigNavigationThinningSvc.cxx.

                                                                                                                            {
    
  if( v.empty())
    return StatusCode::SUCCESS;
  
  std::vector<TriggerElement*>::iterator newend = std::remove( v.begin(), v.end(), te);
  v.erase(newend, v.end());
  
  return StatusCode::SUCCESS;
}

restore()

StatusCode TrigNavigationThinningSvc::restore ( const EventContext & ctx, State & state ) const

private

Restore the original navigation structure.

Definition at line 152 of file TrigNavigationThinningSvc.cxx.

{
  state.navigation.reset();
  state.navigation.prepare();
  state.navigation.deserialize(state.originalNavigation);
  ATH_MSG_DEBUG ( "Restored the original navigation" );
  return StatusCode::SUCCESS;
}

retainFeatures()

StatusCode TrigNavigationThinningSvc::retainFeatures ( State & state, const std::set< std::pair< CLID, uint16_t > > & toRetain ) const

private

This is a helper function for removeFeatures(HLT::NavigationCore*, ...).

Either this or the above is caled depending which of the sets is smaller

Warning

this is a bit more agresive as it cleans up the navigation from transient objects

Definition at line 452 of file TrigNavigationThinningSvc.cxx.

                                                                                                             {
  ATH_MSG_DEBUG("Will retain " << toRetain.size()<< " feature type/key");
  using namespace HLT; 
   for (auto te: state.navigation.getAllTEs()) {
    for ( auto& fea: te->getFeatureAccessHelpers() ) {
      if ( toRetain.find( std::make_pair(fea.getCLID(), fea.getIndex().subTypeIndex()) ) == toRetain.end() )    
    fea.setForget(true); // when we mark this then the serialization of TEs will simpley skip this one, easy, no
    }
  }
  return StatusCode::SUCCESS;
  
}

save()

StatusCode TrigNavigationThinningSvc::save ( const EventContext & ctx, State & state ) const

private

Save the result of the slimming in the doSlimming argument (vector<uint32_t>).

Definition at line 144 of file TrigNavigationThinningSvc.cxx.

                                                                                    {
  std::vector<unsigned int> cuts;
  state.navigation.serialize(state.destinationNavigation, cuts);
  ATH_MSG_DEBUG ( "Saved the slimmed navigation" );
  return StatusCode::SUCCESS;
}

squeeze()

StatusCode TrigNavigationThinningSvc::squeeze ( const EventContext & ctx, State & state ) const

private

Remove intermediate TEs leaving very flat structure with event node, rois and terminals.

Definition at line 168 of file TrigNavigationThinningSvc.cxx.

                                                                                       {
  for ( auto te: state.navigation.getAllTEs() ) {
    if ( state.navigation.isInitialNode(te) 
     or state.navigation.isRoINode(te) 
     or state.navigation.isTerminalNode(te) 
     or state.tesToProtect.find(te->getId()) != state.tesToProtect.end())
      continue;
    //    if ( te->getId() == 4032407525 ) m_report = true;
    CHECK( removeTriggerElement(state, te) );
    //    m_report = false;
  }
 
  return StatusCode::SUCCESS;
}

syncThinning()

StatusCode TrigNavigationThinningSvc::syncThinning ( const EventContext & ctx, State & state ) const

private

reset indexes in the after the thinning

Definition at line 738 of file TrigNavigationThinningSvc.cxx.

                                                                                              {
  ATH_MSG_DEBUG ( "Running the syncThinning" );
 
  std::lock_guard<std::recursive_mutex> lock(state.navigation.getMutex());
 
  const auto& holders = state.navigation.getHolderStorage().getAllHolders<HLTNavDetails::IHolder>();
  if ( holders.empty() ) {  // to prevent issues as in ATR-25282
    ATH_MSG_ERROR("The navigation does not contain any features. This is likely a configuration problem.");
    return StatusCode::FAILURE;
  }
 
  for(auto holder : holders) {
    const IProxyDict* ipd = Atlas::getExtendedEventContext(ctx).proxy();
    if ( not ipd->proxy(holder->containerClid(), holder->label() ) ) {
      ATH_MSG_DEBUG("Skipping feature missing in the store: " << holder->label());
      continue;
    }
      holder->syncWithSG();
      const SG::ThinningDecisionBase* dec =
        SG::getThinningDecision (ctx, holder->label());
      if ( dec  )  {
    ATH_MSG_DEBUG ( "Thinning occured for this container" << *holder <<", going to ajust the indices" );
    // ThinningDecisionBase::index method returns the valid new index for unslimmed object and an invalid index ThinningDecisionBase::RemovedIndex for the ones that were removed
    // The way to calulate new indexes for the ranges describing ROIs (X,Y) is to count the number valid indexes from X to 0 and from Y to 0
    // This would be quite inefficient so we need to make a vector wiht new indexes
    // this vector in the end will be of size equal to the original collection and at position X will have new values.
    // Hoever the difficulty is that we are not able to obtain the size of the collection and we need to build this vector as we meet the indexs during 
    // the scan of TEs. 
    // Since this is quite tricky code it is outsourced to a helper class IndexRecalculator.
    
    IndexRecalculator recalculator( dec );
    // now we need to go over the TEs
    for ( const auto& te: state.navigation.getAllTEs() ) {
      for ( auto& fea: te->getFeatureAccessHelpers() ) {
        if ( fea.getCLID() == holder->typeClid() 
         and fea.getIndex().subTypeIndex() == holder->subTypeIndex() ) {
          uint32_t begin = fea.getIndex().objectsBegin();
          uint32_t end   = fea.getIndex().objectsEnd();
          uint32_t newEnd = recalculator.getNewIndex(end);
          uint32_t newBegin = recalculator.getNewIndex(begin);
 
          HLT::TriggerElement::ObjectIndex& idx ATLAS_THREAD_SAFE = const_cast<HLT::TriggerElement::ObjectIndex&>(fea.getIndex());
          idx.updateBeginAndEnd(newBegin, newEnd);
          //ATH_MSG_DEBUG( "Indices changed to " << newBegin << " " << newEnd);
 
        }     
      }
    }
 
      } // if thinning occures 
      else {
    //  ATH_MSG_DEBUG("Thinning did not occure on the " << * holder );
      }
  } // holder loop
  return StatusCode::SUCCESS;
}

toBeIncluded() [1/2]

bool TrigNavigationThinningSvc::toBeIncluded ( State & state, HLT::TriggerElement * te, std::vector< HLT::TriggerElement * > * inclusionList, std::vector< HLT::TriggerElement * > * exclusionList )

private

Definition at line 549 of file TrigNavigationThinningSvc.cxx.

                                                                                        {
 
  if(!te)
    return false;
 
  // this function never allows inital nodes or RoI nodes to be removed
  if( state.navigation.isInitialNode(te) || state.navigation.isRoINode(te) )
    return true;
 
  // if the inclusion list exists, then we use that
  // If its on the inclusion list, its kept for sure
  // If its on the exclusion list, its only kept if
  // its not on the inclusion list.
  if(inclusionList && inclusionList->size() > 0) {
    
    // check if the element is in the list
    if(std::find_if(inclusionList->begin(), inclusionList->end(), 
            TriggerElementFind(te)) != inclusionList->end())
      return true;
    // now, check if its in the exclusion list
    if(exclusionList && std::find_if(exclusionList->begin(), exclusionList->end(),
                     TriggerElementFind(te)) != exclusionList->end())
      return false;
    // if its on neither list, keep it
    return true;
  }
 
  // if we get here, then there's no inclusionList, so we need to use the exclusion list
 
  // check if it exists - if it doesn't, pass everything
  if(!exclusionList || exclusionList->size() == 0)
    return true;
 
  // check if the te belongs to the exclusion list
  if(std::find_if(exclusionList->begin(), exclusionList->end(), 
          TriggerElementFind(te)) != exclusionList->end()) {
    return false;
  }
 
  // if we've made it here, its passed the exclusion list and so should be included
  return true;
 
}

toBeIncluded() [2/2]

bool TrigNavigationThinningSvc::toBeIncluded ( State & state, HLT::TriggerElement * te, std::vector< std::string > * inclusionList, std::vector< std::string > * exclusionList )

private

Returns true if the TriggerElement should be included in the navigation tree and false if it should not be.

Definition at line 499 of file TrigNavigationThinningSvc.cxx.

                                                                                                                       {
 
  // if the inclusion list exists, then we use that
  if(inclusionList && inclusionList->size() > 0) {
 
    // check if the trigger element has a feature that is included in the list
    int onExclusionList = 0;
    for(std::vector< TriggerElement::FeatureAccessHelper >::const_iterator iter =
      te->getFeatureAccessHelpers().begin();
        iter != te->getFeatureAccessHelpers().end(); ++iter) {
      // grab the label and check if it was found in the inclusion list
      if(std::find(inclusionList->begin(), inclusionList->end(), SlimmingHelper::getLabel(state.navigation, *iter )) != inclusionList->end())
        return true;
      // now find if its in the exclusion list
      if(exclusionList && std::find(exclusionList->begin(), exclusionList->end(), 
                    SlimmingHelper::getLabel( state.navigation, *iter )) != exclusionList->end())
        onExclusionList = 1;
    }
 
    // if it has a feature on the exclusion list, and none on the inclusion list,
    // it should be excluded
    if(onExclusionList)
      return false;
 
    // we've gone through the feature list, and nothing was on the exclusion list,
    // so we should keep it
    return true;
  }
 
  // if we get here, then there's no inclusionList, so we need to use the exclusion list
 
  // check if it exists - if it doesn't, pass everything
  if(!exclusionList || exclusionList->size() == 0)
    return true;
 
  for(std::vector< TriggerElement::FeatureAccessHelper >::const_iterator iter = 
    te->getFeatureAccessHelpers().begin();
      iter != te->getFeatureAccessHelpers().end(); ++iter) {
    // grab the label and check if it was found in the exclusion list
    if(std::find(exclusionList->begin(), exclusionList->end(), SlimmingHelper::getLabel(state.navigation, *iter )) != exclusionList->end())
      return false;
  }
 
  // if we've made it here, its passed the exclusion list and so should be included
  return true;
 
}

Member Data Documentation

m_actions

std::vector<std::string> TrigNavigationThinningSvc::m_actions

private

Definition at line 89 of file TrigNavigationThinningSvc.h.

m_actionsMap

std::map<std::string, Action> TrigNavigationThinningSvc::m_actionsMap

private

Definition at line 91 of file TrigNavigationThinningSvc.h.

m_chainsRegex

std::string TrigNavigationThinningSvc::m_chainsRegex

private

Definition at line 92 of file TrigNavigationThinningSvc.h.

m_featureDropSet

std::set<std::string> TrigNavigationThinningSvc::m_featureDropSet

private

computed from above

Definition at line 71 of file TrigNavigationThinningSvc.h.

m_featureExclusionList

std::vector<std::string> TrigNavigationThinningSvc::m_featureExclusionList

private

Definition at line 69 of file TrigNavigationThinningSvc.h.

m_featureInclusionList

std::vector<std::string> TrigNavigationThinningSvc::m_featureInclusionList

private

Definition at line 68 of file TrigNavigationThinningSvc.h.

m_featureKeepSet

std::set<std::string> TrigNavigationThinningSvc::m_featureKeepSet

private

computed from above

Definition at line 70 of file TrigNavigationThinningSvc.h.

m_report

bool TrigNavigationThinningSvc::m_report

private

TE operations verbosity flag.

Definition at line 95 of file TrigNavigationThinningSvc.h.

m_trigDecisionTool

ToolHandle<Trig::TrigDecisionTool> TrigNavigationThinningSvc::m_trigDecisionTool

private

Definition at line 66 of file TrigNavigationThinningSvc.h.

---

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

• TrigNavigationThinningSvc.h
• TrigNavigationThinningSvc.cxx