TrigNavSlimmingMTAlg Class Reference

Consumes a set of Run 3 trigger navigation collection(s), applies slimming/thinning, writes out a single output collection. More...

#include <TrigNavSlimmingMTAlg.h>

Inheritance diagram for TrigNavSlimmingMTAlg:

Collaboration diagram for TrigNavSlimmingMTAlg:

Classes
struct	Outputs
struct	CachedChainInfo
	Cached chain configuration from TrigDecisionTool (populated once on first event). More...

Public Member Functions
	TrigNavSlimmingMTAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
template<>
StatusCode	doRepack (TrigCompositeUtils::Decision *decision, SG::WriteHandle< xAOD::ParticleContainer > *writeHandle, const std::string &edgeName) const
template<>
StatusCode	doRepackCopy (const TrigRoiDescriptor *object, SG::WriteHandle< TrigRoiDescriptorCollection > *writeHandle) const
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef std::map< const TrigCompositeUtils::Decision *, TrigCompositeUtils::Decision * >	IOCacheMap
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	cacheChainInfo () const
	One-time cache of chain+leg IDs from TrigDecisionTool configuration.
StatusCode	createPresaledGraphNode (Outputs &outputContainers, const TrigCompositeUtils::DecisionIDContainer &chainIDs) const
	Creates a new graph node from scratch, populates it with the Chain IDs of all HLT chains which were not run in this event due to application of HLT prescales.
StatusCode	createL1GraphNodes (Outputs &outputContainers) const
	Creates two new graph node from scratch, populates it using the TriggerDecisionTool with the hash of the item names L1 items which passed before prescale and after veto.
StatusCode	inputToOutput (const TrigCompositeUtils::Decision *input, TrigCompositeUtils::Decision **output, IOCacheMap &cache, Outputs &outputContainers, const TrigCompositeUtils::DecisionIDContainer &chainIDs, const EventContext &ctx) const
	Map a const Decision object from an input collection to its equivalent in the output collection Where a new Decision object is required in the output collection, the propagateLinks function is applied.
StatusCode	propagateLinks (const TrigCompositeUtils::Decision *input, TrigCompositeUtils::Decision *output) const
	Copy links (graph edges) from input to output.
StatusCode	propagateDecisionIDs (const TrigCompositeUtils::Decision *input, TrigCompositeUtils::Decision *output, const TrigCompositeUtils::DecisionIDContainer &chainIDs) const
	Copy DecisionIDs (passing chains and passing chain-legs) from input to output.
StatusCode	propagateSeedingRelation (const TrigCompositeUtils::NavGraphNode *inputNode, IOCacheMap &cache, const EventContext &ctx) const
	Copy the subset of "seed" links which are present in the inputNode.
StatusCode	repackLinks (TrigCompositeUtils::Decision *output, Outputs &outputContainers) const
	Repacks ElementLinks in the DecisionObject to point to compact output containers written by this alg.
void	printIParticleRepackingDebug (const TrigCompositeUtils::Decision *output, const std::string &when) const
	Print debug information relating to the re-packing of feature links as Particle objects.
std::vector< size_t >	lookupHardCodedLegMultiplicities (const std::string &chain) const
	Supplemental leg multiplicity information to support MC20.
template<typename COLLECTION>
StatusCode	doRepack (TrigCompositeUtils::Decision *decision, SG::WriteHandle< COLLECTION > *writeHandle, const std::string &edgeName) const
	Look for an ElementLink<COLLECTION> with the given edge-name in 'decision', if found then make a copy of the linked object to the supplied writeHandle and update the link in 'decision' to point to this rewritten object.
template<typename COLLECTION>
StatusCode	doRepackCopy (const typename COLLECTION::base_value_type *object, SG::WriteHandle< COLLECTION > *writeHandle) const
	Performs the xAOD Copy.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< xAOD::TrigCompositeContainer >	m_primaryInputCollection
SG::WriteHandleKey< xAOD::TrigCompositeContainer >	m_outputCollection
SG::WriteHandleKey< TrigRoiDescriptorCollection >	m_outputRepackedROICollectionKey
SG::WriteHandleKey< xAOD::ParticleContainer >	m_outputRepackedFeaturesCollectionKey_Particle
SG::WriteHandleKey< xAOD::TrigMissingETContainer >	m_outputRepackedFeaturesCollectionKey_MET
Gaudi::Property< bool >	m_keepFailedBranches
Gaudi::Property< bool >	m_keepOnlyFinalFeatures
Gaudi::Property< bool >	m_removeEmptySteps
Gaudi::Property< bool >	m_propagatePrescaledNode
Gaudi::Property< bool >	m_propagateL1Nodes
Gaudi::Property< bool >	m_repackROIs
Gaudi::Property< bool >	m_repackMET
Gaudi::Property< bool >	m_repackFeatures
Gaudi::Property< std::vector< std::string > >	m_repackFeaturesExclusionList
Gaudi::Property< std::vector< std::string > >	m_edgesToDrop
Gaudi::Property< std::vector< std::string > >	m_nodesToDrop
Gaudi::Property< std::vector< std::string > >	m_allOutputContainers
Gaudi::Property< bool >	m_applyChainsFilterToSummaryNodes
Gaudi::Property< std::vector< std::string > >	m_chainsFilter
PublicToolHandle< Trig::TrigDecisionTool >	m_trigDec
Gaudi::Property< bool >	m_runtimeValidation
std::set< std::string >	m_allOutputContainersSet
	Processed form of m_allOutputContainers.
std::once_flag m_chainIDsCacheFlag	ATLAS_THREAD_SAFE
std::vector< CachedChainInfo > m_cachedChainInfo	ATLAS_THREAD_SAFE
bool m_chainIDsCacheOK	ATLAS_THREAD_SAFE {false}
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Consumes a set of Run 3 trigger navigation collection(s), applies slimming/thinning, writes out a single output collection.

Operations include:

• Keeping graph nodes which correspond to a particular set of chains. Good for small dAOD sizes.
• Keeping only the bottom of the graph, from the final "feature" onward. Good for physics analysis / trigger matching.
• Keeping failed branches. Used for trigger performance studies / T0 monitoring.
• Removing named nodes from the graph, ("F"ilter nodes are only used online).
• Removing named edges from the graph, ("view" edges are only used online).

Definition at line 37 of file TrigNavSlimmingMTAlg.h.

Member Typedef Documentation

IOCacheMap

typedef std::map<const TrigCompositeUtils::Decision*, TrigCompositeUtils::Decision*> TrigNavSlimmingMTAlg::IOCacheMap

private

Definition at line 45 of file TrigNavSlimmingMTAlg.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TrigNavSlimmingMTAlg()

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

Definition at line 84 of file TrigNavSlimmingMTAlg.cxx.

  : AthReentrantAlgorithm(name, pSvcLocator)
{
}

Member Function Documentation

cacheChainInfo()

StatusCode TrigNavSlimmingMTAlg::cacheChainInfo ( ) const

private

One-time cache of chain+leg IDs from TrigDecisionTool configuration.

Called once on first event via std::call_once.

Definition at line 348 of file TrigNavSlimmingMTAlg.cxx.

                                                      {
  for (const std::string& filter : m_chainsFilter) {
    // We do this as filter->chains stage as filter could be a regexp matching a large number of chains
    const Trig::ChainGroup* cg = m_trigDec->getChainGroup(filter);
    std::vector<std::string> chains = cg->getListOfTriggers();
    for (const std::string& chain : chains) {
      const TrigConf::HLTChain* hltChain = m_trigDec->ExperimentalAndExpertMethods().getChainConfigurationDetails(chain);
      const HLT::Identifier chainID( hltChain->chain_name() );
      CachedChainInfo info;
      info.chainID = chainID.numeric();
      std::vector<size_t> legMultiplicites = hltChain->leg_multiplicities();
      ATH_MSG_VERBOSE("Including " << chain << " and its " << legMultiplicites.size() << " legs in the trigger slimming output");
      if (legMultiplicites.size() == 0) {
        legMultiplicites = lookupHardCodedLegMultiplicities(chain);
        if (legMultiplicites.size() == 0) {
          ATH_MSG_ERROR("chain " << chainID << " has invalid configuration, no multiplicity data.");
          return StatusCode::FAILURE;
        }
      }
      if (legMultiplicites.size() > 1) {
        // For multi-leg chains, the DecisionIDs are handled per leg.
        // We don't care here exactly how many objects are required per leg, just that there are two-or-more legs
        for (size_t legNumeral = 0; legNumeral < legMultiplicites.size(); ++legNumeral) {
          const HLT::Identifier legID = TrigCompositeUtils::createLegName(chainID, legNumeral);
          info.legIDs.push_back( legID.numeric() );
        }
      }
      m_cachedChainInfo.push_back(std::move(info));
    }
  }
  ATH_MSG_DEBUG("Cached " << m_cachedChainInfo.size() << " chain configurations for " << m_chainsFilter.size() << " chain patterns.");
  return StatusCode::SUCCESS;
}

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

createL1GraphNodes()

StatusCode TrigNavSlimmingMTAlg::createL1GraphNodes ( Outputs & outputContainers ) const

private

Creates two new graph node from scratch, populates it using the TriggerDecisionTool with the hash of the item names L1 items which passed before prescale and after veto.

This makes available L1 trigger is-passed data in the same format as used for HLT navigation. This creates two nodes which were never made at P1 during Run 3.

Parameters

[out]

output

Pointer to the Decision object ptr in the output collection.

Definition at line 410 of file TrigNavSlimmingMTAlg.cxx.

                                                                                   {
  Decision* L1TBPNode = newDecisionIn(outputContainers.nav->ptr(), "L1TBP");
  Decision* L1TAVNode = newDecisionIn(outputContainers.nav->ptr(), "L1TAV");
  // Note - this is for offline use, there's no point in keeping TAP (trigger after prescale) as well as TAV
 
  const Trig::ChainGroup* cg = m_trigDec->getChainGroup("L1_.*|L0_.*"); // Note: Future proofing for Run 4
  std::vector<std::string> chains = cg->getListOfTriggers();
  const std::vector<unsigned int> bits = cg->isPassedBitsForEach();
  if (chains.size() != bits.size()) { 
    ATH_MSG_ERROR("Unexpected different sized chains and bits vectors");
    return StatusCode::FAILURE;
  }
 
  DecisionIDContainer TBPIDs, TAVIDs;
  for (size_t i = 0; i < bits.size(); ++i) {
    if (bits[i] & TrigDefs::L1_isPassedBeforePrescale) { TBPIDs.insert( HLT::Identifier(chains[i]).numeric() ); }
    if (bits[i] & TrigDefs::L1_isPassedAfterVeto)      { TAVIDs.insert( HLT::Identifier(chains[i]).numeric() ); }
  }
 
  TrigCompositeUtils::insertDecisionIDs(TBPIDs, L1TBPNode);
  TrigCompositeUtils::insertDecisionIDs(TAVIDs, L1TAVNode);
  ATH_MSG_INFO("Created new TAV node at index " << L1TAVNode->index() << " with " << TBPIDs.size() << " = " << TAVIDs.size() << " decisions\n" << *L1TAVNode );
  return StatusCode::SUCCESS;
}

createPresaledGraphNode()

StatusCode TrigNavSlimmingMTAlg::createPresaledGraphNode ( Outputs & outputContainers, const TrigCompositeUtils::DecisionIDContainer & chainIDs ) const

private

Creates a new graph node from scratch, populates it with the Chain IDs of all HLT chains which were not run in this event due to application of HLT prescales.

The data are read from the trigger bits using the TrigDecisionTool. This re-creates a node which is available at P1 in Run 3, but which was never persisted into the online slimmed navigation.

Parameters

[out]	output	Pointer to the Decision object ptr in the output collection.
[in]	chainIDs	DecisionIDs are used to filter the output DecisionObjects.

Definition at line 384 of file TrigNavSlimmingMTAlg.cxx.

                                                                                                                                              {
  Decision* prescaledNode = newDecisionIn(outputContainers.nav->ptr(), TrigCompositeUtils::summaryPrescaledNodeName());
 
  const Trig::ChainGroup* cg = m_trigDec->getChainGroup("HLT_.*|EF_.*");
  const std::vector<std::string> chains = cg->getListOfTriggers();
  const std::vector<unsigned int> bits = cg->isPassedBitsForEach();
  if (chains.size() != bits.size()) { 
    ATH_MSG_ERROR("Unexpected different sized chains and bits vectors");
    return StatusCode::FAILURE;
  }
 
  DecisionIDContainer prescaledIDs;
  for (size_t i = 0; i < bits.size(); ++i) {
    if (bits[i] & TrigDefs::EF_prescaled) { prescaledIDs.insert( HLT::Identifier(chains[i]).numeric() ); }
  }
 
  if (m_applyChainsFilterToSummaryNodes && chainIDs.size()) { // Then apply the filter
    std::erase_if(prescaledIDs, [&](int id) {
      return !chainIDs.contains(id); // Keep only elements in chainIDs
    });
  }
 
  TrigCompositeUtils::insertDecisionIDs(prescaledIDs, prescaledNode); // Copy the set of chains into the xAOD object
  return StatusCode::SUCCESS;
}

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

doRepack() [1/2]

template<typename COLLECTION>

StatusCode TrigNavSlimmingMTAlg::doRepack ( TrigCompositeUtils::Decision * decision, SG::WriteHandle< COLLECTION > * writeHandle, const std::string & edgeName ) const

private

Look for an ElementLink<COLLECTION> with the given edge-name in 'decision', if found then make a copy of the linked object to the supplied writeHandle and update the link in 'decision' to point to this rewritten object.

Parameters

[in]	decision	A mutable decision object we're outputting from the nav slimming
[in]	writeHandle	Mutable write handle where we can make a copy of the roi or feature.

doRepack() [2/2]

template<>

StatusCode TrigNavSlimmingMTAlg::doRepack	(	TrigCompositeUtils::Decision *	decision,
		SG::WriteHandle< xAOD::ParticleContainer > *	writeHandle,
		const std::string &	edgeName ) const

Definition at line 22 of file TrigNavSlimmingMTAlg.cxx.

{
 
  if (not decision->hasObjectLink(edgeName, ClassID_traits<xAOD::IParticleContainer>::ID())) { // Note: IParticle
    // Nothing to do
    return StatusCode::SUCCESS;
  }
 
  ElementLink<xAOD::IParticleContainer> currentEL = decision->objectLink<xAOD::IParticleContainer>(edgeName); // Note: IParticle
 
  if (!currentEL.isValid()) {
    // TODO: Upgrade this first message to a WARNING once the TriggerAPI for Run3 is filtering on the chains whose final-features get saved into the DAOD_PHYS
    ATH_MSG_DEBUG("Unable to repack '" << edgeName << "' of container type xAOD::IParticleContainer for '"
      << decision->name() << "' node, the link is invalid.");
    ATH_MSG_DEBUG("Dump of DecisionObject: " << *decision);
    return StatusCode::SUCCESS;
  }
 
  if (not m_repackFeaturesExclusionList.empty()) {
    // Check the feature's StoreGate key against the exclusion list. If it is on the list, then we don't repack the feature.
    // We instead leave it pointing to its current online physics object. It is assumed that this online physics object will 
    // be kept in the DAOD via signature specific logic.
    const std::string featureStoreGateKey = currentEL.dataID();
    for (const std::string& exclusionEntry : m_repackFeaturesExclusionList) {
      if (featureStoreGateKey == exclusionEntry) {
        ATH_MSG_VERBOSE("Will not repack this feature " << currentEL.index() << " from " <<  currentEL.dataID() << ", as this container is on the exclusion list");
        return StatusCode::SUCCESS;
      }
    }
  }
 
  (**writeHandle).push_back( new xAOD::Particle() ); // Need to do this before performing the copy to assign with the Aux store
 
  const xAOD::IParticle* current = *currentEL;
  xAOD::Particle* remapped = (**writeHandle).back();
 
  remapped->setP4( current->p4() );
 
  ElementLink<xAOD::ParticleContainer> remappedEL(**writeHandle, (**writeHandle).size()-1);
  decision->setObjectLink<xAOD::ParticleContainer>(edgeName, remappedEL); // Overwrite the existing link
 
  ATH_MSG_VERBOSE("Repacked from index:" << currentEL.index() << " from key:" << currentEL.dataID() 
    << ", to index:" << remappedEL.index() << " to key:" << remappedEL.dataID());
 
  return StatusCode::SUCCESS;
}

doRepackCopy() [1/2]

template<>

StatusCode TrigNavSlimmingMTAlg::doRepackCopy	(	const TrigRoiDescriptor *	object,
		SG::WriteHandle< TrigRoiDescriptorCollection > *	writeHandle ) const

Definition at line 75 of file TrigNavSlimmingMTAlg.cxx.

{
  // Specialization for ROIs, utilize copy constructor (no Aux store here)
  (**writeHandle).push_back( new TrigRoiDescriptor(*object) );
  return StatusCode::SUCCESS;
}

doRepackCopy() [2/2]

template<typename COLLECTION>

StatusCode TrigNavSlimmingMTAlg::doRepackCopy ( const typename COLLECTION::base_value_type * object, SG::WriteHandle< COLLECTION > * writeHandle ) const

private

Performs the xAOD Copy.

Any non-xAOD collections will need to provide an explicit implementation of this function. For example, TrigRoiDescriptorCollection for example.

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode TrigNavSlimmingMTAlg::execute ( const EventContext & ctx ) const

overridevirtual

Definition at line 126 of file TrigNavSlimmingMTAlg.cxx.

                                                                      {
 
  // Prepare IO
  Outputs outputContainers;
 
  SG::WriteHandle<TrigRoiDescriptorCollection> outputROIs;
  SG::WriteHandle<xAOD::ParticleContainer> outputParticles; 
  SG::WriteHandle<xAOD::TrigMissingETContainer> outputMETs;
  if (m_repackROIs) {
    outputROIs = createAndStoreNoAux(m_outputRepackedROICollectionKey, ctx);
    outputContainers.rois = &outputROIs;
  }
  if (m_repackFeatures) {
    outputParticles = createAndStoreWithAux<xAOD::ParticleContainer, xAOD::ParticleAuxContainer>(m_outputRepackedFeaturesCollectionKey_Particle, ctx);
    outputContainers.particles = &outputParticles;
  }
  if (m_repackMET) {
    outputMETs = createAndStoreWithAux<xAOD::TrigMissingETContainer, xAOD::TrigMissingETAuxContainer>(m_outputRepackedFeaturesCollectionKey_MET, ctx);
    outputContainers.mets = &outputMETs;
  }
 
  SG::WriteHandle<DecisionContainer> outputNavigation = createAndStore(m_outputCollection, ctx);
  outputContainers.nav = &outputNavigation;
 
  SG::ReadHandle<DecisionContainer> primaryInputHandle = SG::ReadHandle(m_primaryInputCollection, ctx);
  ATH_CHECK(primaryInputHandle.isValid());
 
  const Decision* terminusNode = TrigCompositeUtils::getTerminusNode(*primaryInputHandle);
  if (!terminusNode) {
    ATH_MSG_ERROR("Unable to locate the HLTPassRaw from the primary input navigation collection, size:" << primaryInputHandle->size());
    return StatusCode::FAILURE;
  }
 
  // Stage 1. Build a transient representation of the navigation graph.
  TrigTimeStamp stage1;
  NavGraph transientNavGraph;
 
  // We can optionally only keep data for a given set of chains. An empty set means to keep for all chains.
  DecisionIDContainer chainIDs = {};
  if (not m_chainsFilter.empty()) {
    // Cache chain configuration from TDT once — the chain group resolution,
    // trigger listing, and config lookups are static and need not be repeated per event.
    std::call_once(m_chainIDsCacheFlag, [this]{
      m_chainIDsCacheOK = cacheChainInfo().isSuccess();
    });
    if (!m_chainIDsCacheOK) {
      ATH_MSG_ERROR("Failed to cache chain configuration from TrigDecisionTool");
      return StatusCode::FAILURE;
    }
 
    // Per-event: optionally filter cached chains to only those passing this event
    DecisionIDContainer passingChains;
    if (not m_keepFailedBranches) {
      TrigCompositeUtils::decisionIDs(terminusNode, passingChains);
    }
 
    for (const auto& info : m_cachedChainInfo) {
      if (!passingChains.empty() && !passingChains.contains(info.chainID)) {
        continue; // Optional additional filter on passing chains in this specific event
      }
      chainIDs.insert(info.chainID);
      for (const auto& legID : info.legIDs) {
        chainIDs.insert(legID);
      }
    }
 
    ATH_MSG_DEBUG("Supplied " << m_chainsFilter.size() << " chain patterns. This converts to " << chainIDs.size() << " DecisionIDs to be preserved.");
    if (chainIDs.empty()) {
      // No chains are in the filter. We should reject everything. But an empty set is interpreted as keep-all. So we need to add a dummy entry.
      chainIDs.insert( HLT::Identifier("HLT_dummy").numeric() );
    }
  } else {
    ATH_MSG_DEBUG("No HLT-chain based filtering of the navigation graph will be performed.");
  }
 
  std::set<const Decision*> fullyExploredFrom;
  // Note: We use the "internal" version of this call such that we maintain our own cache, 
  // as we may need to call this more than once if keepFailedBranches is true
  TrigCompositeUtils::recursiveGetDecisionsInternal(terminusNode, 
    nullptr, // 'Coming from' is nullptr for the first call of the recursive function
    transientNavGraph,
    fullyExploredFrom, 
    chainIDs, 
    /*enforce chainIDs on terminus node*/ true);
 
  ATH_MSG_DEBUG("Collated nodes from passing paths, now have " << transientNavGraph.nodes() << " nodes with " << transientNavGraph.edges() << " edges");
 
  // Stage 2. We can optionally include branches through the graph which were never accepted by any chain.
  TrigTimeStamp stage2;
  // These branches do not connect to the terminusNode, so we have to go hunting them explicitly.
  // We need to pass in the evtStore as these nodes can be spread out over numerous collections.
  // Like with the terminus node, we can restrict this search to only nodes which were rejected by certain chains.
  // We also want to restrict the search to exclude the output collections of any other TrigNavSlimminMTAlg instances
  // and let the function know what the primary input collection is - from the name of this we can tell if we need to search one or many containers.
  if (m_keepFailedBranches) {
    std::vector<const Decision*> rejectedNodes = TrigCompositeUtils::getRejectedDecisionNodes(&*evtStore(), ctx, m_primaryInputCollection.key(), chainIDs, m_allOutputContainersSet);
    for (const Decision* rejectedNode : rejectedNodes) {
      // We do *not* enforce that a member of chainIDs must be present in the starting node (rejectedNode)
      // specifically because we know that at least one of chainIDs was _rejected_ here, but is active in the rejected
      // node's seeds.
      TrigCompositeUtils::recursiveGetDecisionsInternal(rejectedNode, 
        nullptr, // 'Coming from' is nullptr for the first call of the recursive function
        transientNavGraph,
        fullyExploredFrom, 
        chainIDs, 
        /*enforce chainIDs on terminus node*/ false);
    }
    ATH_MSG_DEBUG("Collated nodes from failing paths, now have " << transientNavGraph.nodes() << " nodes with " << transientNavGraph.edges() << " edges");
  }
 
  // Stage 3. Walk all paths through the graph. Flag for thinning.
  TrigTimeStamp stage3;
  // Final nodes includes the terminus node, plus any rejected nodes (if these were collated).
  TrigCompositeUtils::recursiveFlagForThinning(transientNavGraph, m_keepOnlyFinalFeatures, m_removeEmptySteps, m_nodesToDrop);
 
  if (msg().level() <= MSG::VERBOSE) {
    ATH_MSG_VERBOSE("The navigation graph entering the slimming is:");
    transientNavGraph.printAllPaths(msg(), MSG::VERBOSE);
  }
 
  // Stage 4. Do the thinning. Re-wire removed nodes as we go.
  TrigTimeStamp stage4;
  const size_t nodesBefore = transientNavGraph.nodes();
  const size_t edgesBefore = transientNavGraph.edges();
  std::vector<const Decision*> thinnedInputNodes = transientNavGraph.thin();
 
  // TODO - thinnedInputNodes will be dropped, these may link to "features", "roi", or other objects in other containers.
  // Need to let the slimming svc know that we no longer need the objects pointed to here, and hence they can be thinned.
 
  ATH_MSG_DEBUG("Trigger navigation graph thinning going from " << nodesBefore << " nodes with " << edgesBefore << " edges, to "
    << transientNavGraph.nodes() << " nodes with " << transientNavGraph.edges() << " edges");
 
  if (msg().level() <= MSG::VERBOSE) {
    ATH_MSG_VERBOSE("The navigation graph has been slimmed to the following paths:");
    transientNavGraph.printAllPaths(msg(), MSG::VERBOSE);
  }
 
  // Stage 5. Fill the transientNavGraph structure (with NavGraphNode* nodes) back into an xAOD::DecisionContainer (with xAOD::Decision* nodes).
  TrigTimeStamp stage5;
  IOCacheMap cache; // Used to keep a one-to-one relationship between the const input Decision* and the mutable output Decision*
 
  // Do the terminus node first - such that it ends up at index 0 of the outputNavigation (fast to locate in the future)
  Decision* terminusNodeOut = nullptr;
  const DecisionIDContainer emptySet = {};
  ATH_CHECK(inputToOutput(terminusNode, &terminusNodeOut, cache, outputContainers, (m_applyChainsFilterToSummaryNodes ? chainIDs : emptySet), ctx));
 
  const Decision* expressTerminusNode = TrigCompositeUtils::getExpressTerminusNode(*primaryInputHandle);
  if (expressTerminusNode) {
    // Do the express terminus node second - such that it ends up at index 1 of the outputNavigation (fast to locate in the future)
    Decision* expressTerminusNodeOut = nullptr;
    ATH_CHECK(inputToOutput(expressTerminusNode, &expressTerminusNodeOut, cache, outputContainers, (m_applyChainsFilterToSummaryNodes ? chainIDs : emptySet), ctx));
  }
 
  if (m_propagatePrescaledNode) {
    // Prescaled summary node might come third, it is optional.
    const Decision* prescaledNode = TrigCompositeUtils::getNodeByName(*primaryInputHandle, TrigCompositeUtils::summaryPrescaledNodeName());
    if (prescaledNode) { // We can propagate it directly (potential for Run 4)
      Decision* prescaleNodeOut = nullptr;
      ATH_CHECK(inputToOutput(prescaledNode, &prescaleNodeOut, cache, outputContainers, (m_applyChainsFilterToSummaryNodes ? chainIDs : emptySet), ctx));
    } else { // We can re-create this from the trigger bits
      ATH_CHECK(createPresaledGraphNode(outputContainers, (m_applyChainsFilterToSummaryNodes ? chainIDs : emptySet)));
    }
  }
 
  if (m_propagateL1Nodes) {
    // L1 summary nodes are also optional.
    const Decision* L1TBPNode = TrigCompositeUtils::getNodeByName(*primaryInputHandle, "L1TBP"); // TODO - upgrade to static string constants if we use this in production.
    const Decision* L1TAVNode = TrigCompositeUtils::getNodeByName(*primaryInputHandle, "L1TAV");
    if (L1TBPNode && L1TAVNode) {
      Decision* L1TBPNodeOut = nullptr;
      Decision* L1TAVNodeOut = nullptr;
      ATH_CHECK(inputToOutput(L1TBPNode, &L1TBPNodeOut, cache, outputContainers, {}, ctx)); // No chain filtering, these are L1 items
      ATH_CHECK(inputToOutput(L1TAVNode, &L1TAVNodeOut, cache, outputContainers, {}, ctx));
    } else {
      ATH_CHECK(createL1GraphNodes(outputContainers));
    }
  }
 
  // Don't have to walk the graph here, just iterate through the set of (thinned) nodes.
  // We won't end up with two terminus nodes because of this (it checks that the node hasn't already been processed)
  const std::vector<NavGraphNode*> allNodes = transientNavGraph.allNodes();
  for (const NavGraphNode* inputNode : allNodes) {
    Decision* outputNode = nullptr;
    ATH_CHECK(inputToOutput(inputNode->node(), &outputNode, cache, outputContainers, chainIDs, ctx));
  }
  // Now we have all of the new nodes in the output collection, can link them all up with their slimmed seeding relationships.
  for (const NavGraphNode* inputNode : allNodes) {
    ATH_CHECK(propagateSeedingRelation(inputNode, cache, ctx));
  }
 
  // We can perform an additional check on the output graph, we put a veto on the m_keepFailedBranches option as we are currently just exploring
  // from the 'terminusNodeOut', more code would be needed to locate failing branches also in the output graph structure.
  if (msg().level() <= MSG::VERBOSE && !m_keepFailedBranches) {
    ATH_MSG_VERBOSE("The output navigation graph looks like this (output terminus node search only, converted back into a NavGraph one final time for printing)");
    std::set<const Decision*> fullyExploredFromOut;
    NavGraph transientNavGraphOut;
    TrigCompositeUtils::recursiveGetDecisionsInternal(terminusNodeOut, 
      nullptr, // 'Coming from' is nullptr for the first call of the recursive function
      transientNavGraphOut,
      fullyExploredFromOut, 
      chainIDs, 
      /*enforce chainIDs on terminus node*/ true);
    transientNavGraphOut.printAllPaths(msg(), MSG::VERBOSE);
  }
 
  if (msg().level() <= MSG::DEBUG) {
    ATH_MSG_DEBUG("Navigation slimming and thinning timings:");
    ATH_MSG_DEBUG("  1. Transient Graph of Passed Nodes = " << stage1.millisecondsDifference(stage2) << " ms");
    ATH_MSG_DEBUG("  2. Transient Graph of Failed Nodes = " << stage2.millisecondsDifference(stage3) << " ms");
    ATH_MSG_DEBUG("  3. Flag Transient Graph For Thinning = " << stage3.millisecondsDifference(stage4) << " ms");
    ATH_MSG_DEBUG("  4. Perform Transient Graph Thinning = " << stage4.millisecondsDifference(stage5) << " ms");
    ATH_MSG_DEBUG("  5. Write xAOD Graph = " << stage5.millisecondsSince() << " ms");
  }
 
  return StatusCode::SUCCESS;  
}

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

initialize()

StatusCode TrigNavSlimmingMTAlg::initialize ( )

overridevirtual

Definition at line 90 of file TrigNavSlimmingMTAlg.cxx.

                                            {
  ATH_CHECK( m_primaryInputCollection.initialize() );
  ATH_CHECK( m_outputCollection.initialize() );
  ATH_CHECK( m_outputRepackedROICollectionKey.initialize(m_repackROIs) );
  ATH_CHECK( m_outputRepackedFeaturesCollectionKey_Particle.initialize(m_repackFeatures) );
  ATH_CHECK( m_outputRepackedFeaturesCollectionKey_MET.initialize(m_repackFeatures) );
 
  const bool removeRoI = (std::find(m_edgesToDrop.begin(), m_edgesToDrop.end(), roiString()) != m_edgesToDrop.end());
  const bool removeInitialRoI = (std::find(m_edgesToDrop.begin(), m_edgesToDrop.end(), initialRoIString()) != m_edgesToDrop.end());
 
  if (m_repackROIs and (removeRoI or removeInitialRoI)) {
    ATH_MSG_WARNING("Possible miss-configuration. Cannot repack ROIs in the navigation slimming if they are being dropped");
  }
 
  if (not m_trigDec.empty()) {
    ATH_CHECK( m_trigDec.retrieve() );
  }
  for (const std::string& output : m_allOutputContainers) {
    if (output == m_primaryInputCollection.key()) {
      continue; // We do want to search for failed nodes in the primary input (it may already be merged)
    }
    // We don't want to search for failed nodes in other possible summary keys, we might read in the 
    // summary collection from another running instance (e.g. an AODSlim alg reading in the output of
    // ESDSlim in a RAWtoALL job).
    m_allOutputContainersSet.insert(output);
  }
  m_allOutputContainersSet.insert(m_outputCollection.key());
  msg() << MSG::INFO << "Initialized. Will *not* inspect the following SG Keys: ";
  for (const std::string& key : m_allOutputContainersSet) {
    msg() << key << " ";
  }
  msg() << endmsg;
  return StatusCode::SUCCESS;
}

inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

inputToOutput()

StatusCode TrigNavSlimmingMTAlg::inputToOutput ( const TrigCompositeUtils::Decision * input, TrigCompositeUtils::Decision ** output, IOCacheMap & cache, Outputs & outputContainers, const TrigCompositeUtils::DecisionIDContainer & chainIDs, const EventContext & ctx ) const

private

Map a const Decision object from an input collection to its equivalent in the output collection Where a new Decision object is required in the output collection, the propagateLinks function is applied.

Parameters

[in]	input	The const Decision object from a input collection.
[out]	output	Pointer to the Decision object ptr in the output collection.
[in,out]	cache	Cached mapping of input->output objects. Cached output is returned if present.
[in,out]	outputContainers	The write handles, contains the nav write handle which should own any new Decision objects which need to be created.
[in]	chainIDs	DecisionIDs which should propagate from input to output DecisionObjects.
[in]	ctx	Event context.

Definition at line 436 of file TrigNavSlimmingMTAlg.cxx.

{
  IOCacheMap::const_iterator it = cache.find(input);
  if (it != cache.end()) {
    *output = it->second;
  } else {
    *output = newDecisionIn(outputContainers.nav->ptr(), input, input->name(), ctx);
    ATH_CHECK(propagateLinks(input, *output));
    ATH_CHECK(propagateDecisionIDs(input, *output, chainIDs));
    ATH_CHECK(repackLinks(*output, outputContainers));
    cache[input] = *output;
  }
  return StatusCode::SUCCESS;
}

isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

lookupHardCodedLegMultiplicities()

std::vector< size_t > TrigNavSlimmingMTAlg::lookupHardCodedLegMultiplicities ( const std::string & chain ) const

private

Supplemental leg multiplicity information to support MC20.

Definition at line 343 of file TrigNavSlimmingMTAlg.cxx.

                                                                                                     {
  if (chain == "HLT_id_cosmicid_L1MU11_EMPTY") return std::vector<size_t>(1,1); // size = 1, value at index 0 = 1
  return std::vector<size_t>();
}

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

printIParticleRepackingDebug()

void TrigNavSlimmingMTAlg::printIParticleRepackingDebug ( const TrigCompositeUtils::Decision * output, const std::string & when ) const

private

Print debug information relating to the re-packing of feature links as Particle objects.

Definition at line 574 of file TrigNavSlimmingMTAlg.cxx.

                                                                                                                             {
  if (not msgLvl(MSG::DEBUG)) return;
  if (output->hasObjectLink(featureString(), ClassID_traits<xAOD::IParticleContainer>::ID())) {
    ElementLink<xAOD::IParticleContainer> link = output->objectLink<xAOD::IParticleContainer>(featureString());
    if (link.isValid()) {
      const xAOD::IParticle& l = **link;
      ATH_MSG_DEBUG("IParticle repacking debug. " << when << " : " 
        << "(pt:" << l.pt() << ",eta:" << l.eta() << ",phi:" << l.phi() << ",m:" << l.m() << ",e:" << l.e() << ")"
        << " from:" << link.dataID());
      if (when == " After") ATH_MSG_DEBUG("--");
    }
  }
}

propagateDecisionIDs()

StatusCode TrigNavSlimmingMTAlg::propagateDecisionIDs ( const TrigCompositeUtils::Decision * input, TrigCompositeUtils::Decision * output, const TrigCompositeUtils::DecisionIDContainer & chainIDs ) const

private

Copy DecisionIDs (passing chains and passing chain-legs) from input to output.

Applies the ChainsFilter.

Parameters

[in]	input	The Decision object to copy from.
[out]	output	The Decision object to copy to.
[in]	chainIDs	DecisionIDs which should propagate from input to output DecisionObjects.

Definition at line 548 of file TrigNavSlimmingMTAlg.cxx.

{
 
  // Get all DecisionIDs from the const input Decision*
  DecisionIDContainer fromInput;
  decisionIDs(input, fromInput);
 
  DecisionIDContainer toOutput;
  if ( chainIDs.size() ) {
    // Applying ChainsFilter to the set of DecisionIDs
    std::set_intersection(fromInput.begin(), fromInput.end(), chainIDs.begin(), chainIDs.end(),
      std::inserter(toOutput, toOutput.begin()));
  } else {
    // Copying all DecisionIDs from input to output
    toOutput.insert(fromInput.begin(), fromInput.end());
  }
 
  // Set the DecisionIDs into the mutable output Decision* 
  insertDecisionIDs(toOutput, output);
 
  return StatusCode::SUCCESS;
}

propagateLinks()

StatusCode TrigNavSlimmingMTAlg::propagateLinks ( const TrigCompositeUtils::Decision * input, TrigCompositeUtils::Decision * output ) const

private

Copy links (graph edges) from input to output.

Applies the EdgesToDrop thinning. Note: Does not copy "seed" links which form the underlying graph structure.

Parameters

[in]	input	The Decision object to copy from.
[out]	output	The Decision object to copy to.

Definition at line 510 of file TrigNavSlimmingMTAlg.cxx.

{
  // ElementLinks form the edges in the graph. Start by copying all of them over.
 
  output->copyAllLinksFrom( input );
 
  // Special behavior to save additional disk space for keepOnlyFinalFeatures mode.
  // In keepOnlyFinalFeatures we stop at the first hypoAlgNode, hence we will drop the preceding inputMakerNode, and all prior Steps in their entirety.
  // This means we will also drop all "roi" edges, including the final ROI.
  // We may want to keep this final "roi", and so to do this we can copy it down one level (away from L1) to live in the hypoAlgNode along side the "feature" link.
  // Note: If "roi" is listed in m_edgesToDrop then we will still immediately drop this new element link in the m_edgesToDrop loop below. 
  const std::vector<ElementLink<DecisionContainer>> seeds = input->objectCollectionLinks<DecisionContainer>(seedString());
  const Decision* const firstParent = (seeds.size() ? *seeds.at(0) : nullptr);
  if (m_keepOnlyFinalFeatures &&
      input->name() == hypoAlgNodeName() &&
      firstParent &&
      firstParent->name() == inputMakerNodeName() &&
      firstParent->hasObjectLink(roiString()))
  {
    output->copyLinkFrom( firstParent, roiString() );
  }
 
  for (const std::string& toRemove : m_edgesToDrop) {
    output->removeObjectLink(toRemove);
    output->removeObjectCollectionLinks(toRemove);
    // TODO - let the slimming svc know that we no longer need these objects
  }
 
  // Do not propagate "seed" links - TrigNavSlimmingMTAlg will 
  // propagate these following additional logic
  output->removeObjectCollectionLinks( seedString() );
 
  return StatusCode::SUCCESS;
}

propagateSeedingRelation()

StatusCode TrigNavSlimmingMTAlg::propagateSeedingRelation ( const TrigCompositeUtils::NavGraphNode * inputNode, IOCacheMap & cache, const EventContext & ctx ) const

private

Copy the subset of "seed" links which are present in the inputNode.

This function uses the IOCacheMap to perform all linking only against the mutable Decision objects which form the slimmed and thinned navigation. It must only be called after inputToOutput has been used to create all of the output Decision objects.

Parameters

[in]	inputNode	The thinned transient NavGraphNode which only now has seed links which we want to keep
[in,out]	cache	Cached mapping of input->output objects.
[in]	ctx	Event context.

Definition at line 458 of file TrigNavSlimmingMTAlg.cxx.

{
  const Decision* inputDecision = inputNode->node(); // The incoming Decision objects, with links into the old graph 
  Decision* outputDecision = nullptr; // The outgoing Decision object, without graph links so far
  {
    IOCacheMap::const_iterator it = cache.find(inputDecision);
    ATH_CHECK( it != cache.end() );
    outputDecision = it->second;
  }
  for (const NavGraphNode* seed : inputNode->seeds()) {
    const Decision* inputSeedDecision = seed->node(); // A Decision object the incoming Decision object links to (old graph)
    const Decision* outputSeedDecision = nullptr; // The equivalent Decision Object in the slimmed outgoing graph
    {
      IOCacheMap::const_iterator it = cache.find(inputSeedDecision);
      ATH_CHECK( it != cache.end() );
      outputSeedDecision = it->second;
    }
    // Perform the linking only using nodes from the slimmed output graph
    TrigCompositeUtils::linkToPrevious(outputDecision, outputSeedDecision, ctx);
  }
 
  // Don't run this check for "HLTPassRaw", this node is expected to link back to every passing physics object. 
  // Hence there may be more than 'sensibleUpperBoundOnNLinks' in aggregate here.
  if (m_runtimeValidation and outputDecision->name() != TrigCompositeUtils::summaryPassNodeName()) { 
    const size_t sensibleUpperBoundOnNLinks = 100;
    const size_t maxUpperBoundOnNLinks = 500;
    // Note: Only in the NavGraphNode do we have the two-way links to check how many children link back to this node
    const bool bad_in = inputNode->children().size() > sensibleUpperBoundOnNLinks; 
    //Note: Here we check more than "seed" links. We pick up external links too like "feature"
    const bool bad_out = outputDecision->linkColNames().size() > sensibleUpperBoundOnNLinks; 
    const bool vbad = inputNode->children().size() > maxUpperBoundOnNLinks or outputDecision->linkColNames().size() > maxUpperBoundOnNLinks;
    if (bad_in) {
      ATH_MSG_WARNING("Saving a Decision object with a very large number of INCOMING graph edges. Number of in-edges: " << inputNode->children().size());
    }
    if (bad_out) {
      ATH_MSG_WARNING("Saving a Decision object with a very large number of OUTGOING graph edges. Number of out-edges: " << outputDecision->linkColNames().size());
    }
    if (bad_in or bad_out) {
      ATH_MSG_WARNING("Comes from: " << TrigCompositeUtils::decisionToElementLink(inputDecision, ctx).dataID());
      ATH_MSG_DEBUG("Output Decision: " << *outputDecision);
    }
    if (vbad) {
      ATH_MSG_ERROR("More than " << maxUpperBoundOnNLinks << " links, printing an ERROR such that this gets promptly investigated and reduced.");
    }
  }
  return StatusCode::SUCCESS;
}

renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

repackLinks()

StatusCode TrigNavSlimmingMTAlg::repackLinks ( TrigCompositeUtils::Decision * output, Outputs & outputContainers ) const

private

Repacks ElementLinks in the DecisionObject to point to compact output containers written by this alg.

Parameters

[in]	decision	A mutable decision object we're outputting from the nav slimming
[in]	outputContainers	The mutable write handles, in these we will make a copy of the rois or features we repack.

Definition at line 589 of file TrigNavSlimmingMTAlg.cxx.

{
  
  if (m_repackROIs) {
    ATH_CHECK( doRepack<TrigRoiDescriptorCollection>(output, outputContainers.rois, roiString()) );
    ATH_CHECK( doRepack<TrigRoiDescriptorCollection>(output, outputContainers.rois, initialRoIString()) );
  }
 
  if (m_repackFeatures) {
    // Debug printing. Look at the four-momentum of any feature before the repacking.
    // Note: Transiently we interact with the IParticle interface.
    printIParticleRepackingDebug(output, "Before");
 
    // Do any IParticle repacking
    ATH_CHECK( doRepack<xAOD::ParticleContainer>(output, outputContainers.particles, featureString()) );
    ATH_CHECK( doRepack<xAOD::ParticleContainer>(output, outputContainers.particles, "subfeature") );
 
    // Debug printing. Look at the four-momentum of any feature after the repacking (the stored link is re-written)
    printIParticleRepackingDebug(output, " After");
  }
 
  // Some features do not support an IParticle interface. These need their own containers.
  // TODO. Apply some thinning?
  if (m_repackMET) {
    ATH_CHECK( doRepack<xAOD::TrigMissingETContainer>(output, outputContainers.mets, featureString()) );
  }
 
  return StatusCode::SUCCESS;
}

setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

ATLAS_THREAD_SAFE [1/3]

bool m_chainIDsCacheOK TrigNavSlimmingMTAlg::ATLAS_THREAD_SAFE {false}

mutableprivate

Definition at line 152 of file TrigNavSlimmingMTAlg.h.

{false}; // protected by m_chainIDsCacheFlag

ATLAS_THREAD_SAFE [2/3]

std::vector<CachedChainInfo> m_cachedChainInfo TrigNavSlimmingMTAlg::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 151 of file TrigNavSlimmingMTAlg.h.

ATLAS_THREAD_SAFE [3/3]

std::once_flag m_chainIDsCacheFlag TrigNavSlimmingMTAlg::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 150 of file TrigNavSlimmingMTAlg.h.

m_allOutputContainers

Gaudi::Property<std::vector<std::string> > TrigNavSlimmingMTAlg::m_allOutputContainers

private

Initial value:

{
    this, "AllOutputContainers", {},
    "List of SG keys of all possible output containers at differing verbosity. Used to stop different instances of the alg interfering with each other."}

Definition at line 119 of file TrigNavSlimmingMTAlg.h.

                                                           {
    this, "AllOutputContainers", {},
    "List of SG keys of all possible output containers at differing verbosity. Used to stop different instances of the alg interfering with each other."};

m_allOutputContainersSet

std::set<std::string> TrigNavSlimmingMTAlg::m_allOutputContainersSet

private

Processed form of m_allOutputContainers.

Definition at line 141 of file TrigNavSlimmingMTAlg.h.

m_applyChainsFilterToSummaryNodes

Gaudi::Property<bool> TrigNavSlimmingMTAlg::m_applyChainsFilterToSummaryNodes

private

Initial value:

{
    this, "ApplyChainsFilterToSummaryNodes", true,
    "If the ChainsFilter (if supplied) should be applied to the terminus, express terminus and prescaled nodes. "
    "If set to false, the trigger decision for any chain may be obtained from the navigation at the expense of additional file size."}

Definition at line 123 of file TrigNavSlimmingMTAlg.h.

                                                       {
    this, "ApplyChainsFilterToSummaryNodes", true,
    "If the ChainsFilter (if supplied) should be applied to the terminus, express terminus and prescaled nodes. "
    "If set to false, the trigger decision for any chain may be obtained from the navigation at the expense of additional file size."};

m_chainsFilter

Gaudi::Property<std::vector<std::string> > TrigNavSlimmingMTAlg::m_chainsFilter

private

Initial value:

{
    this, "ChainsFilter", {},
    "Optional list of HLT chains. If provided, only navigation data corresponding to these chains will be kept. "
    "Matching multiple chains via regular expressions is supported."}

Definition at line 128 of file TrigNavSlimmingMTAlg.h.

                                                    {
    this, "ChainsFilter", {},
    "Optional list of HLT chains. If provided, only navigation data corresponding to these chains will be kept. "
    "Matching multiple chains via regular expressions is supported."};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_edgesToDrop

Gaudi::Property<std::vector<std::string> > TrigNavSlimmingMTAlg::m_edgesToDrop

private

Initial value:

{
    this, "EdgesToDrop", {"view"},
    "Any edges within the set of names will be dropped as part of the thinning"}

Definition at line 111 of file TrigNavSlimmingMTAlg.h.

                                                   {
    this, "EdgesToDrop", {"view"},
    "Any edges within the set of names will be dropped as part of the thinning"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_keepFailedBranches

Gaudi::Property<bool> TrigNavSlimmingMTAlg::m_keepFailedBranches

private

Initial value:

{
    this, "KeepFailedBranched", true,
    "Keep nodes which are in branches of the graph which fail selection for all triggers, these are used by T0 monitoring."}

Definition at line 74 of file TrigNavSlimmingMTAlg.h.

                                          {
    this, "KeepFailedBranched", true,
    "Keep nodes which are in branches of the graph which fail selection for all triggers, these are used by T0 monitoring."};

m_keepOnlyFinalFeatures

Gaudi::Property<bool> TrigNavSlimmingMTAlg::m_keepOnlyFinalFeatures

private

Initial value:

{
    this, "KeepOnlyFinalFeatures", false,
    "Keeps only the final features which accepted a chain. Fine for analysis-use."}

Definition at line 78 of file TrigNavSlimmingMTAlg.h.

                                             {
    this, "KeepOnlyFinalFeatures", false,
    "Keeps only the final features which accepted a chain. Fine for analysis-use."};

m_nodesToDrop

Gaudi::Property<std::vector<std::string> > TrigNavSlimmingMTAlg::m_nodesToDrop

private

Initial value:

{
    this, "NodesToDrop", {"F"},
    "Any nodes within the set of names will be dropped as part of the thinning and the navigation re-wired around them"}

Definition at line 115 of file TrigNavSlimmingMTAlg.h.

                                                   {
    this, "NodesToDrop", {"F"},
    "Any nodes within the set of names will be dropped as part of the thinning and the navigation re-wired around them"};

m_outputCollection

SG::WriteHandleKey<xAOD::TrigCompositeContainer> TrigNavSlimmingMTAlg::m_outputCollection

private

Initial value:

{
    this, "OutputCollection", "HLTNav_Summary_ESDSlimmed",
    "Single output collection containing the slimmed navigation nodes."}

Definition at line 58 of file TrigNavSlimmingMTAlg.h.

                                                                 {
    this, "OutputCollection", "HLTNav_Summary_ESDSlimmed",
    "Single output collection containing the slimmed navigation nodes."};

m_outputRepackedFeaturesCollectionKey_MET

SG::WriteHandleKey<xAOD::TrigMissingETContainer> TrigNavSlimmingMTAlg::m_outputRepackedFeaturesCollectionKey_MET

private

Initial value:

{
    this, "RepackFeaturesOutputCollection_MET", "HLTNav_RepackedFeatures_MET",
    "Single output collection containing any repacked IParticle features (use with RepackFeatures)."}

Definition at line 70 of file TrigNavSlimmingMTAlg.h.

                                                                                        {
    this, "RepackFeaturesOutputCollection_MET", "HLTNav_RepackedFeatures_MET",
    "Single output collection containing any repacked IParticle features (use with RepackFeatures)."};

m_outputRepackedFeaturesCollectionKey_Particle

SG::WriteHandleKey<xAOD::ParticleContainer> TrigNavSlimmingMTAlg::m_outputRepackedFeaturesCollectionKey_Particle

private

Initial value:

{
    this, "RepackFeaturesOutputCollection_Particle", "HLTNav_RepackedFeatures_Particle",
    "Single output collection containing any repacked Particle features (use with RepackFeatures)."}

Definition at line 66 of file TrigNavSlimmingMTAlg.h.

                                                                                        {
    this, "RepackFeaturesOutputCollection_Particle", "HLTNav_RepackedFeatures_Particle",
    "Single output collection containing any repacked Particle features (use with RepackFeatures)."};

m_outputRepackedROICollectionKey

SG::WriteHandleKey<TrigRoiDescriptorCollection> TrigNavSlimmingMTAlg::m_outputRepackedROICollectionKey

private

Initial value:

{
    this, "RepackROIsOutputCollection", "HLTNav_RepackedROIs",
    "Single output collection containing any repacked ROIs (use with RepackROIs)."}

Definition at line 62 of file TrigNavSlimmingMTAlg.h.

                                                                                {
    this, "RepackROIsOutputCollection", "HLTNav_RepackedROIs",
    "Single output collection containing any repacked ROIs (use with RepackROIs)."};

m_primaryInputCollection

SG::ReadHandleKey<xAOD::TrigCompositeContainer> TrigNavSlimmingMTAlg::m_primaryInputCollection

private

Initial value:

{
    this, "PrimaryInputCollection", "HLTNav_Summary",
    "Input collection containing the HLTPassRaw terminus node of the navigation."}

Definition at line 54 of file TrigNavSlimmingMTAlg.h.

                                                                      {
    this, "PrimaryInputCollection", "HLTNav_Summary",
    "Input collection containing the HLTPassRaw terminus node of the navigation."};

m_propagateL1Nodes

Gaudi::Property<bool> TrigNavSlimmingMTAlg::m_propagateL1Nodes

private

Initial value:

{
    this, "PropagateL1Nodes", false,
    "Copies the 'L1TAP' and 'L1TAV' nodes (if they exists) from the input to output navigation collection. If they do not exist, they can be re-created from the xAOD::TriggerDecision"}

Definition at line 90 of file TrigNavSlimmingMTAlg.h.

                                        {
    this, "PropagateL1Nodes", false,
    "Copies the 'L1TAP' and 'L1TAV' nodes (if they exists) from the input to output navigation collection. If they do not exist, they can be re-created from the xAOD::TriggerDecision"};

m_propagatePrescaledNode

Gaudi::Property<bool> TrigNavSlimmingMTAlg::m_propagatePrescaledNode

private

Initial value:

{
    this, "PropagatePrescaledNode", false,
    "Copies the 'HLTPrescaled' node (if it exists) from the input to output navigation collection. If it does not exist, it can be re-created from the xAOD::TriggerDecision"}

Definition at line 86 of file TrigNavSlimmingMTAlg.h.

                                              {
    this, "PropagatePrescaledNode", false,
    "Copies the 'HLTPrescaled' node (if it exists) from the input to output navigation collection. If it does not exist, it can be re-created from the xAOD::TriggerDecision"};

m_removeEmptySteps

Gaudi::Property<bool> TrigNavSlimmingMTAlg::m_removeEmptySteps

private

Initial value:

{
    this, "RemoveEmptySteps", false,
    "Slim away ComboHypo->InputMaker empty step pairs which come from parallel chain alignment (special case: keep if C.H. adds a feature, e.g. BLS). Fine for analysis-use."}

Definition at line 82 of file TrigNavSlimmingMTAlg.h.

                                        {
    this, "RemoveEmptySteps", false,
    "Slim away ComboHypo->InputMaker empty step pairs which come from parallel chain alignment (special case: keep if C.H. adds a feature, e.g. BLS). Fine for analysis-use."};

m_repackFeatures

Gaudi::Property<bool> TrigNavSlimmingMTAlg::m_repackFeatures

private

Initial value:

{
    this, "RepackFeatures", false,
    "Re-pack the target of all 'feature' edges into a small number of containers (WriteHandle defined above)"}

Definition at line 102 of file TrigNavSlimmingMTAlg.h.

                                      {
    this, "RepackFeatures", false,
    "Re-pack the target of all 'feature' edges into a small number of containers (WriteHandle defined above)"};

m_repackFeaturesExclusionList

Gaudi::Property<std::vector<std::string> > TrigNavSlimmingMTAlg::m_repackFeaturesExclusionList

private

Initial value:

{
    this, "RepackFeaturesExclusionList", {},
    "Optional list of StoreGate key strings. If strings are provided and RepackFeatures is true, then 'feature' edges  "
    "whose StoreGate key is an exact match to an entry on the supplied list will not be re-packed and will be left unchanged"}

Definition at line 106 of file TrigNavSlimmingMTAlg.h.

                                                                   {
    this, "RepackFeaturesExclusionList", {},
    "Optional list of StoreGate key strings. If strings are provided and RepackFeatures is true, then 'feature' edges  "
    "whose StoreGate key is an exact match to an entry on the supplied list will not be re-packed and will be left unchanged"};

m_repackMET

Gaudi::Property<bool> TrigNavSlimmingMTAlg::m_repackMET

private

Initial value:

{
    this, "RepackMET", false,
    "Re-pack the target of all 'feature' edges to xAOD::TrigMissingET objects into a single container (WriteHandle defined above)"}

Definition at line 98 of file TrigNavSlimmingMTAlg.h.

                                 {
    this, "RepackMET", false,
    "Re-pack the target of all 'feature' edges to xAOD::TrigMissingET objects into a single container (WriteHandle defined above)"};

m_repackROIs

Gaudi::Property<bool> TrigNavSlimmingMTAlg::m_repackROIs

private

Initial value:

{
    this, "RepackROIs", false,
    "Re-pack the target of all 'roi' and 'initialRoI' edges into a single container (WriteHandle defined above)"}

Definition at line 94 of file TrigNavSlimmingMTAlg.h.

                                  {
    this, "RepackROIs", false,
    "Re-pack the target of all 'roi' and 'initialRoI' edges into a single container (WriteHandle defined above)"};

m_runtimeValidation

Gaudi::Property<bool> TrigNavSlimmingMTAlg::m_runtimeValidation

private

Initial value:

{
    this, "RuntimeValidation", false,
    "Perform additional validation checks on the navigation, and print WARNINGs if anything out of the ordinary is found."}

Definition at line 137 of file TrigNavSlimmingMTAlg.h.

                                         {
    this, "RuntimeValidation", false,
    "Perform additional validation checks on the navigation, and print WARNINGs if anything out of the ordinary is found."};

m_trigDec

PublicToolHandle<Trig::TrigDecisionTool> TrigNavSlimmingMTAlg::m_trigDec

private

Initial value:

{
    this, "TrigDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool",
    "Trigger Decision Tool, used to apply the ChainsFilter"}

Definition at line 133 of file TrigNavSlimmingMTAlg.h.

                                                  {
    this, "TrigDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool",
    "Trigger Decision Tool, used to apply the ChainsFilter"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• TrigNavSlimmingMTAlg.h
• TrigNavSlimmingMTAlg.cxx