ATLAS Offline Software
TrigNavSlimmingMTAlg.cxx
Go to the documentation of this file.
1 
2 /*
3  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
4 */
5 
6 #include "TrigNavSlimmingMTAlg.h"
7 
9 
12 
13 using namespace TrigCompositeUtils;
14 
15 
16 // Particle Specialization
17 // We transiently interact via the xAOD::IParticle interface.
18 // There is code inside the TrigCompositeUtils::Decision to check
19 // at runtime if this inheritance is possible.
20 // But we copy into a xAOD::Particle object.
21 template<>
24  const std::string& edgeName) const
25 {
26 
27  if (not decision->hasObjectLink(edgeName, ClassID_traits<xAOD::IParticleContainer>::ID())) { // Note: IParticle
28  // Nothing to do
29  return StatusCode::SUCCESS;
30  }
31 
32  ElementLink<xAOD::IParticleContainer> currentEL = decision->objectLink<xAOD::IParticleContainer>(edgeName); // Note: IParticle
33 
34  if (!currentEL.isValid()) {
35  // 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
36  ATH_MSG_DEBUG("Unable to repack '" << edgeName << "' of container type xAOD::IParticleContainer for '"
37  << decision->name() << "' node, the link is invalid.");
38  ATH_MSG_DEBUG("Dump of DecisionObject: " << *decision);
39  return StatusCode::SUCCESS;
40  }
41 
42  if (not m_repackFeaturesExclusionList.empty()) {
43  // Check the feature's StoreGate key against the exclusion list. If it is on the list, then we don't repack the feature.
44  // We instead leave it pointing to its current online physics object. It is assumed that this online physics object will
45  // be kept in the DAOD via signature specific logic.
46  const std::string featureStoreGateKey = currentEL.dataID();
47  for (const std::string& exclusionEntry : m_repackFeaturesExclusionList) {
48  if (featureStoreGateKey == exclusionEntry) {
49  ATH_MSG_VERBOSE("Will not repack this feature " << currentEL.index() << " from " << currentEL.dataID() << ", as this container is on the exclusion list");
50  return StatusCode::SUCCESS;
51  }
52  }
53  }
54 
55  (**writeHandle).push_back( new xAOD::Particle() ); // Need to do this before performing the copy to assign with the Aux store
56 
57  const xAOD::IParticle* current = *currentEL;
58  xAOD::Particle* remapped = (**writeHandle).back();
59 
60  remapped->setP4( current->p4() );
61 
62  ElementLink<xAOD::ParticleContainer> remappedEL(**writeHandle, (**writeHandle).size()-1);
63  decision->setObjectLink<xAOD::ParticleContainer>(edgeName, remappedEL); // Overwrite the existing link
64 
65  ATH_MSG_VERBOSE("Repacked from index:" << currentEL.index() << " from key:" << currentEL.dataID()
66  << ", to index:" << remappedEL.index() << " to key:" << remappedEL.dataID());
67 
68  return StatusCode::SUCCESS;
69 }
70 
71 
72 // ROI Specialization.
73 // Not an xAOD object, can use a direct copy constructor.
74 template<>
77 {
78  // Specialization for ROIs, utilize copy constructor (no Aux store here)
79  (**writeHandle).push_back( new TrigRoiDescriptor(*object) );
80  return StatusCode::SUCCESS;
81 }
82 
83 
84 TrigNavSlimmingMTAlg::TrigNavSlimmingMTAlg(const std::string& name, ISvcLocator* pSvcLocator)
85  : AthReentrantAlgorithm(name, pSvcLocator)
86 {
87 }
88 
89 
91  ATH_CHECK( m_primaryInputCollection.initialize() );
92  ATH_CHECK( m_outputCollection.initialize() );
96 
97  const bool removeRoI = (std::find(m_edgesToDrop.begin(), m_edgesToDrop.end(), roiString()) != m_edgesToDrop.end());
98  const bool removeInitialRoI = (std::find(m_edgesToDrop.begin(), m_edgesToDrop.end(), initialRoIString()) != m_edgesToDrop.end());
99 
100  if (m_repackROIs and (removeRoI or removeInitialRoI)) {
101  ATH_MSG_WARNING("Possible miss-configuration. Cannot repack ROIs in the navigation slimming if they are being dropped");
102  }
103 
104  if (not m_trigDec.empty()) {
105  ATH_CHECK( m_trigDec.retrieve() );
106  }
107  for (const std::string& output : m_allOutputContainers) {
108  if (output == m_primaryInputCollection.key()) {
109  continue; // We do want to search for failed nodes in the primary input (it may already be merged)
110  }
111  // We don't want to search for failed nodes in other possible summary keys, we might read in the
112  // summary collection from another running instance (e.g. an AODSlim alg reading in the output of
113  // ESDSlim in a RAWtoALL job).
115  }
117  msg() << MSG::INFO << "Initialized. Will *not* inspect the following SG Keys: ";
118  for (const std::string& key : m_allOutputContainersSet) {
119  msg() << key << " ";
120  }
121  msg() << endmsg;
122  return StatusCode::SUCCESS;
123 }
124 
125 
126 StatusCode TrigNavSlimmingMTAlg::execute(const EventContext& ctx) const {
127 
128  // Prepare IO
130 
134  if (m_repackROIs) {
136  outputContainers.rois = &outputROIs;
137  }
138  if (m_repackFeatures) {
139  outputParticles = createAndStoreWithAux<xAOD::ParticleContainer, xAOD::ParticleAuxContainer>(m_outputRepackedFeaturesCollectionKey_Particle, ctx);
140  outputContainers.particles = &outputParticles;
141  }
142  if (m_repackMET) {
143  outputMETs = createAndStoreWithAux<xAOD::TrigMissingETContainer, xAOD::TrigMissingETAuxContainer>(m_outputRepackedFeaturesCollectionKey_MET, ctx);
144  outputContainers.mets = &outputMETs;
145  }
146 
148  outputContainers.nav = &outputNavigation;
149 
151  ATH_CHECK(primaryInputHandle.isValid());
152 
153  const Decision* terminusNode = TrigCompositeUtils::getTerminusNode(*primaryInputHandle);
154  if (!terminusNode) {
155  ATH_MSG_ERROR("Unable to locate the HLTPassRaw from the primary input navigation collection, size:" << primaryInputHandle->size());
156  return StatusCode::FAILURE;
157  }
158 
159  const Decision* expressTerminusNode = TrigCompositeUtils::getExpressTerminusNode(*primaryInputHandle);
160 
161  // Stage 1. Build a transient representation of the navigation graph.
162  TrigTimeStamp stage1;
163  NavGraph transientNavGraph;
164 
165  // We can optionally only keep data for a given set of chains. An empty set means to keep for all chains.
166  DecisionIDContainer chainIDs = {};
167  if (not m_chainsFilter.empty()) {
168  ATH_CHECK(fillChainIDs(chainIDs));
169  ATH_MSG_DEBUG("Supplied " << m_chainsFilter.size() << " chain patterns. This converts to " << chainIDs.size() << " DecisionIDs to be preserved.");
170  }
171  if (chainIDs.size() == 0) {
172  ATH_MSG_DEBUG("chainIDs size is zero. No HLT-chain based filtering of the navigation graph will be performed.");
173  }
174 
175  std::set<const Decision*> fullyExploredFrom;
176  // Note: We use the "internal" version of this call such that we maintain our own cache,
177  // as we may need to call this more than once if keepFailedBranches is true
179  nullptr, // 'Coming from' is nullptr for the first call of the recursive function
180  transientNavGraph,
181  fullyExploredFrom,
182  chainIDs,
183  /*enforce chainIDs on terminus node*/ true);
184 
185  ATH_MSG_DEBUG("Collated nodes from passing paths, now have " << transientNavGraph.nodes() << " nodes with " << transientNavGraph.edges() << " edges");
186 
187  // Stage 2. We can optionally include branches through the graph which were never accepted by any chain.
188  TrigTimeStamp stage2;
189  // These branches do not connect to the terminusNode, so we have to go hunting them explicitly.
190  // We need to pass in the evtStore as these nodes can be spread out over numerous collections.
191  // Like with the terminus node, we can restrict this search to only nodes which were rejected by certain chains.
192  // We also want to restrict the search to exclude the output collections of any other TrigNavSlimminMTAlg instances
193  // 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.
194  if (m_keepFailedBranches) {
195  std::vector<const Decision*> rejectedNodes = TrigCompositeUtils::getRejectedDecisionNodes(&*evtStore(), ctx, m_primaryInputCollection.key(), chainIDs, m_allOutputContainersSet);
196  for (const Decision* rejectedNode : rejectedNodes) {
197  // We do *not* enforce that a member of chainIDs must be present in the starting node (rejectedNode)
198  // specifically because we know that at least one of chainIDs was _rejected_ here, but is active in the rejected
199  // node's seeds.
201  nullptr, // 'Coming from' is nullptr for the first call of the recursive function
202  transientNavGraph,
203  fullyExploredFrom,
204  chainIDs,
205  /*enforce chainIDs on terminus node*/ false);
206  }
207  ATH_MSG_DEBUG("Collated nodes from failing paths, now have " << transientNavGraph.nodes() << " nodes with " << transientNavGraph.edges() << " edges");
208  }
209 
210  // Stage 3. Walk all paths through the graph. Flag for thinning.
211  TrigTimeStamp stage3;
212  // Final nodes includes the terminus node, plus any rejected nodes (if these were collated).
214 
215  if (msg().level() <= MSG::VERBOSE) {
216  ATH_MSG_VERBOSE("The navigation graph entering the slimming is:");
217  transientNavGraph.printAllPaths(msg(), MSG::VERBOSE);
218  }
219 
220  // Stage 4. Do the thinning. Re-wire removed nodes as we go.
221  TrigTimeStamp stage4;
222  const size_t nodesBefore = transientNavGraph.nodes();
223  const size_t edgesBefore = transientNavGraph.edges();
224  std::vector<const Decision*> thinnedInputNodes = transientNavGraph.thin();
225 
226  // TODO - thinnedInputNodes will be dropped, these may link to "features", "roi", or other objects in other containers.
227  // Need to let the slimming svc know that we no longer need the objects pointed to here, and hence they can be thinned.
228 
229  ATH_MSG_DEBUG("Trigger navigation graph thinning going from " << nodesBefore << " nodes with " << edgesBefore << " edges, to "
230  << transientNavGraph.nodes() << " nodes with " << transientNavGraph.edges() << " edges");
231 
232  if (msg().level() <= MSG::VERBOSE) {
233  ATH_MSG_VERBOSE("The navigation graph has been slimmed to the following paths:");
234  transientNavGraph.printAllPaths(msg(), MSG::VERBOSE);
235  }
236 
237  // Stage 5. Fill the transientNavGraph structure (with NavGraphNode* nodes) back into an xAOD::DecisionContainer (with xAOD::Decision* nodes).
238  TrigTimeStamp stage5;
239  IOCacheMap cache; // Used to keep a one-to-one relationship between the const input Decision* and the mutable output Decision*
240  // Do the terminus node first - such that it ends up at index 0 of the outputNavigation (fast to locate in the future)
241  Decision* terminusNodeOut = nullptr;
242  ATH_CHECK(inputToOutput(terminusNode, &terminusNodeOut, cache, outputContainers, chainIDs, ctx));
243  if (expressTerminusNode) {
244  // Do the express terminus node second - such that it ends up at index 1 of the outputNavigation (fast to locate in the future)
245  Decision* expressTerminusNodeOut = nullptr;
246  ATH_CHECK(inputToOutput(expressTerminusNode, &expressTerminusNodeOut, cache, outputContainers, chainIDs, ctx));
247  }
248  // Don't have to walk the graph here, just iterate through the set of (thinned) nodes.
249  // We won't end up with two terminus nodes because of this (it checks that the node hasn't already been processed)
250  const std::vector<NavGraphNode*> allNodes = transientNavGraph.allNodes();
251  for (const NavGraphNode* inputNode : allNodes) {
252  Decision* outputNode = nullptr;
253  ATH_CHECK(inputToOutput(inputNode->node(), &outputNode, cache, outputContainers, chainIDs, ctx));
254  // TODO - anything else to do here with outputNode? We cannot hook up its seeding yet, we may not yet have output nodes for all of its seeds.
255  }
256  // Now we have all of the new nodes in the output collection, can link them all up with their slimmed seeding relationships.
257  for (const NavGraphNode* inputNode : allNodes) {
258  ATH_CHECK(propagateSeedingRelation(inputNode, cache, ctx));
259  }
260 
261  // 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
262  // from the 'terminusNodeOut', more code would be needed to locate failing branches also in the output graph structure.
263  if (msg().level() <= MSG::VERBOSE && !m_keepFailedBranches) {
264  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)");
265  std::set<const Decision*> fullyExploredFromOut;
266  NavGraph transientNavGraphOut;
268  nullptr, // 'Coming from' is nullptr for the first call of the recursive function
269  transientNavGraphOut,
270  fullyExploredFromOut,
271  chainIDs,
272  /*enforce chainIDs on terminus node*/ true);
273  transientNavGraphOut.printAllPaths(msg(), MSG::VERBOSE);
274  }
275 
276  if (msg().level() <= MSG::DEBUG) {
277  ATH_MSG_DEBUG("Navigation slimming and thinning timings:");
278  ATH_MSG_DEBUG(" 1. Transient Graph of Passed Nodes = " << stage1.millisecondsDifference(stage2) << " ms");
279  ATH_MSG_DEBUG(" 2. Transient Graph of Failed Nodes = " << stage2.millisecondsDifference(stage3) << " ms");
280  ATH_MSG_DEBUG(" 3. Flag Transient Graph For Thinning = " << stage3.millisecondsDifference(stage4) << " ms");
281  ATH_MSG_DEBUG(" 4. Perform Transient Graph Thinning = " << stage4.millisecondsDifference(stage5) << " ms");
282  ATH_MSG_DEBUG(" 5. Write xAOD Graph = " << stage5.millisecondsSince() << " ms");
283  }
284 
285  return StatusCode::SUCCESS;
286 }
287 
288 std::vector<size_t> TrigNavSlimmingMTAlg::lookupHardCodedLegMultiplicities(const std::string& chain) const {
289  if (chain == "HLT_id_cosmicid_L1MU11_EMPTY") return std::vector<size_t>(1,1); // size = 1, value at index 0 = 1
290  return std::vector<size_t>();
291 }
292 
294  for (const std::string& filter : m_chainsFilter) {
295  // We do this as filter->chains stage as filter could be a regexp matching a large number of chains
296  const Trig::ChainGroup* cg = m_trigDec->getChainGroup(filter);
297  std::vector<std::string> chains = cg->getListOfTriggers();
298  for (const std::string& chain : chains) {
299  const TrigConf::HLTChain* hltChain = m_trigDec->ExperimentalAndExpertMethods().getChainConfigurationDetails(chain);
300  const HLT::Identifier chainID( hltChain->chain_name() );
301  chainIDs.insert( chainID.numeric() );
302  std::vector<size_t> legMultiplicites = hltChain->leg_multiplicities();
303  ATH_MSG_VERBOSE("Including " << chain << " and its " << legMultiplicites.size() << " legs in the trigger slimming output");
304  if (legMultiplicites.size() == 0) {
305  legMultiplicites = lookupHardCodedLegMultiplicities(chain);
306  if (legMultiplicites.size() == 0) {
307  ATH_MSG_ERROR("chain " << chainID << " has invalid configuration, no multiplicity data.");
308  return StatusCode::FAILURE;
309  }
310  }
311  if (legMultiplicites.size() > 1) {
312  // For multi-leg chains, the DecisionIDs are handled per leg.
313  // We don't care here exactly how many objects are required per leg, just that there are two-or-more legs
314  for (size_t legNumeral = 0; legNumeral < legMultiplicites.size(); ++legNumeral) {
315  const HLT::Identifier legID = TrigCompositeUtils::createLegName(chainID, legNumeral);
316  chainIDs.insert( legID.numeric() );
317  }
318  }
319  }
320  }
321  return StatusCode::SUCCESS;
322 }
323 
324 
328  IOCacheMap& cache,
330  const DecisionIDContainer& chainIDs,
331  const EventContext& ctx) const
332 {
333  IOCacheMap::const_iterator it = cache.find(input);
334  if (it != cache.end()) {
335  *output = it->second;
336  } else {
337  *output = newDecisionIn(outputContainers.nav->ptr(), input, input->name(), ctx);
341  cache[input] = *output;
342  }
343  return StatusCode::SUCCESS;
344 }
345 
346 
348  const TrigCompositeUtils::NavGraphNode* inputNode,
349  IOCacheMap& cache,
350  const EventContext& ctx) const
351 {
352  const Decision* inputDecision = inputNode->node(); // The incoming Decision objects, with links into the old graph
353  Decision* outputDecision = nullptr; // The outgoing Decision object, without graph links so far
354  {
355  IOCacheMap::const_iterator it = cache.find(inputDecision);
356  ATH_CHECK( it != cache.end() );
357  outputDecision = it->second;
358  }
359  for (const NavGraphNode* seed : inputNode->seeds()) {
360  const Decision* inputSeedDecision = seed->node(); // A Decision object the incoming Decision object links to (old graph)
361  const Decision* outputSeedDecision = nullptr; // The equivalent Decision Object in the slimmed outgoing graph
362  {
363  IOCacheMap::const_iterator it = cache.find(inputSeedDecision);
364  ATH_CHECK( it != cache.end() );
365  outputSeedDecision = it->second;
366  }
367  // Perform the linking only using nodes from the slimmed output graph
368  TrigCompositeUtils::linkToPrevious(outputDecision, outputSeedDecision, ctx);
369  }
370 
371  // Don't run this check for "HLTPassRaw", this node is expected to link back to every passing physics object.
372  // Hence there may be more than 'sensibleUpperBoundOnNLinks' in aggregate here.
373  if (m_runtimeValidation and outputDecision->name() != TrigCompositeUtils::summaryPassNodeName()) {
374  const size_t sensibleUpperBoundOnNLinks = 100;
375  const size_t maxUpperBoundOnNLinks = 500;
376  // Note: Only in the NavGraphNode do we have the two-way links to check how many children link back to this node
377  const bool bad_in = inputNode->children().size() > sensibleUpperBoundOnNLinks;
378  //Note: Here we check more than "seed" links. We pick up external links too like "feature"
379  const bool bad_out = outputDecision->linkColNames().size() > sensibleUpperBoundOnNLinks;
380  const bool vbad = inputNode->children().size() > maxUpperBoundOnNLinks or outputDecision->linkColNames().size() > maxUpperBoundOnNLinks;
381  if (bad_in) {
382  ATH_MSG_WARNING("Saving a Decision object with a very large number of INCOMING graph edges. Number of in-edges: " << inputNode->children().size());
383  }
384  if (bad_out) {
385  ATH_MSG_WARNING("Saving a Decision object with a very large number of OUTGOING graph edges. Number of out-edges: " << outputDecision->linkColNames().size());
386  }
387  if (bad_in or bad_out) {
388  ATH_MSG_WARNING("Comes from: " << TrigCompositeUtils::decisionToElementLink(inputDecision, ctx).dataID());
389  ATH_MSG_DEBUG("Output Decision: " << *outputDecision);
390  }
391  if (vbad) {
392  ATH_MSG_ERROR("More than " << maxUpperBoundOnNLinks << " links, printing an ERROR such that this gets promptly investigated and reduced.");
393  }
394  }
395  return StatusCode::SUCCESS;
396 }
397 
398 
402 {
403  // ElementLinks form the edges in the graph. Start by copying all of them over.
404 
405  output->copyAllLinksFrom( input );
406 
407  // Special behaviour to save additional disk space for keepOnlyFinalFeatures mode.
408  // In keepOnlyFinalFeatures we stop at the first hypoAlgNode, hence we will drop the preceding inputMakerNode, and all prior Steps in their entirety.
409  // This means we will also drop all "roi" edges, including the final ROI.
410  // 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.
411  // Note: If "roi" is listed in m_edgesToDrop then we will still immediately drop this new element link in the m_edgesToDrop loop below.
412  const std::vector<ElementLink<DecisionContainer>> seeds = input->objectCollectionLinks<DecisionContainer>(seedString());
413  const Decision* const firstParent = (seeds.size() ? *seeds.at(0) : nullptr);
415  input->name() == hypoAlgNodeName() &&
416  firstParent &&
417  firstParent->name() == inputMakerNodeName() &&
418  firstParent->hasObjectLink(roiString()))
419  {
420  output->copyLinkFrom( firstParent, roiString() );
421  }
422 
423  for (const std::string& toRemove : m_edgesToDrop) {
424  output->removeObjectLink(toRemove);
425  output->removeObjectCollectionLinks(toRemove);
426  // TODO - let the slimming svc know that we no longer need these objects
427  }
428 
429  // Do not propagate "seed" links - TrigNavSlimmingMTAlg will
430  // propagate these following additional logic
431  output->removeObjectCollectionLinks( seedString() );
432 
433  return StatusCode::SUCCESS;
434 }
435 
436 
440  const DecisionIDContainer& chainIDs) const
441 {
442 
443  // Get all DecisionIDs from the const input Decision*
444  DecisionIDContainer fromInput;
445  decisionIDs(input, fromInput);
446 
447  DecisionIDContainer toOutput;
448 
449  if (chainIDs.size()) {
450  // Applying ChainsFilter to the set of DecisionIDs
451  std::set_intersection(fromInput.begin(), fromInput.end(), chainIDs.begin(), chainIDs.end(),
452  std::inserter(toOutput, toOutput.begin()));
453  } else {
454  // Copying all DecisionIDs from input to output
455  toOutput.insert(fromInput.begin(), fromInput.end());
456  }
457 
458  // Set the DecisionIDs into the mutable output Decision*
459  insertDecisionIDs(toOutput, output);
460 
461  return StatusCode::SUCCESS;
462 }
463 
465  if (not msgLvl(MSG::DEBUG)) return;
468  if (link.isValid()) {
469  const xAOD::IParticle& l = **link;
470  ATH_MSG_DEBUG("IParticle repacking debug. " << when << " : "
471  << "(pt:" << l.pt() << ",eta:" << l.eta() << ",phi:" << l.phi() << ",m:" << l.m() << ",e:" << l.e() << ")"
472  << " from:" << link.dataID());
473  if (when == " After") ATH_MSG_DEBUG("--");
474  }
475  }
476 }
477 
478 
481  Outputs& outputContainers) const
482 {
483 
484  if (m_repackROIs) {
485  ATH_CHECK( doRepack<TrigRoiDescriptorCollection>(output, outputContainers.rois, roiString()) );
486  ATH_CHECK( doRepack<TrigRoiDescriptorCollection>(output, outputContainers.rois, initialRoIString()) );
487  }
488 
489  if (m_repackFeatures) {
490  // Debug printing. Look at the four-momentum of any feature before the repacking.
491  // Note: Transiently we interact with the IParticle interface.
493 
494  // Do any IParticle repacking
495  ATH_CHECK( doRepack<xAOD::ParticleContainer>(output, outputContainers.particles, featureString()) );
496  ATH_CHECK( doRepack<xAOD::ParticleContainer>(output, outputContainers.particles, "subfeature") );
497 
498  // Debug printing. Look at the four-momentum of any feature after the repacking (the stored link is re-written)
500  }
501 
502  // Some features do not support an IParticle interface. These need their own containers.
503  // TODO. Apply some thinning?
504  if (m_repackMET) {
505  ATH_CHECK( doRepack<xAOD::TrigMissingETContainer>(output, outputContainers.mets, featureString()) );
506  }
507 
508  return StatusCode::SUCCESS;
509 }
TrigCompositeUtils::featureString
const std::string & featureString()
Definition: TrigCompositeUtils.h:420
fillPileUpNoiseLumi.current
current
Definition: fillPileUpNoiseLumi.py:52
TrigNavSlimmingMTAlg::m_outputRepackedFeaturesCollectionKey_MET
SG::WriteHandleKey< xAOD::TrigMissingETContainer > m_outputRepackedFeaturesCollectionKey_MET
Definition: TrigNavSlimmingMTAlg.h:67
TrigNavSlimmingMTAlg::m_runtimeValidation
Gaudi::Property< bool > m_runtimeValidation
Definition: TrigNavSlimmingMTAlg.h:121
TrigNavSlimmingMTAlg::IOCacheMap
std::map< const TrigCompositeUtils::Decision *, TrigCompositeUtils::Decision * > IOCacheMap
Definition: TrigNavSlimmingMTAlg.h:42
TrigTimeStamp::millisecondsDifference
double millisecondsDifference(const TrigTimeStamp &other) const
Definition: TrigTimeStamp.cxx:11
TrigNavSlimmingMTAlg::execute
virtual StatusCode execute(const EventContext &ctx) const override
Definition: TrigNavSlimmingMTAlg.cxx:126
TrigNavSlimmingMTAlg::m_primaryInputCollection
SG::ReadHandleKey< xAOD::TrigCompositeContainer > m_primaryInputCollection
Definition: TrigNavSlimmingMTAlg.h:51
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
TrigNavSlimmingMTAlg::m_repackROIs
Gaudi::Property< bool > m_repackROIs
Definition: TrigNavSlimmingMTAlg.h:83
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
TrigNavSlimmingMTAlg::m_keepFailedBranches
Gaudi::Property< bool > m_keepFailedBranches
Definition: TrigNavSlimmingMTAlg.h:71
TrigConf::HLTChain::chain_name
const std::string & chain_name() const
Definition: TrigConfHLTData/TrigConfHLTData/HLTChain.h:73
HLT::Identifier::numeric
TrigCompositeUtils::DecisionID numeric() const
numeric ID
Definition: TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h:41
xAOD::TrigComposite_v1::objectLink
ElementLink< CONTAINER > objectLink(const std::string &name) const
Get the link with the requested name.
TrigCompositeUtils::newDecisionIn
Decision * newDecisionIn(DecisionContainer *dc, const std::string &name)
Helper method to create a Decision object, place it in the container and return a pointer to it.
Definition: TrigCompositeUtilsRoot.cxx:44
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
TrigNavSlimmingMTAlg::m_allOutputContainersSet
std::set< std::string > m_allOutputContainersSet
Processed form of m_allOutputContainers.
Definition: TrigNavSlimmingMTAlg.h:125
TrigCompositeUtils::NavGraphNode::seeds
const std::vector< NavGraphNode * > & seeds() const
Return a vector of const pointers to the Decision object nodes which this NavGraphNode seeds from.
Definition: NavGraph.cxx:46
TrigCompositeUtils::summaryPassNodeName
const std::string & summaryPassNodeName()
Definition: TrigCompositeUtils.h:429
xAOD::TrigComposite_v1::hasObjectLink
bool hasObjectLink(const std::string &name, const CLID clid=CLID_NULL) const
Check if a link to an object with a given name and type exists. CLID_NULL to not check type.
Definition: TrigComposite_v1.cxx:244
skel.it
it
Definition: skel.GENtoEVGEN.py:407
TrigCompositeUtils::insertDecisionIDs
void insertDecisionIDs(const Decision *src, Decision *dest)
Appends the decision IDs of src to the dest decision object.
Definition: TrigCompositeUtilsRoot.cxx:78
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
TrigCompositeUtils::NavGraph::allNodes
std::vector< NavGraphNode * > allNodes()
Get all nodes.
Definition: NavGraph.cxx:103
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:157
TrigRoiDescriptor
nope - should be used for standalone also, perhaps need to protect the class def bits #ifndef XAOD_AN...
Definition: TrigRoiDescriptor.h:56
TrigNavSlimmingMTAlg::m_repackFeatures
Gaudi::Property< bool > m_repackFeatures
Definition: TrigNavSlimmingMTAlg.h:91
TrigNavSlimmingMTAlg::m_edgesToDrop
Gaudi::Property< std::vector< std::string > > m_edgesToDrop
Definition: TrigNavSlimmingMTAlg.h:100
TrigCompositeUtils::NavGraph::printAllPaths
void printAllPaths(MsgStream &log, MSG::Level msgLevel=MSG::VERBOSE) const
Helper function.
Definition: NavGraph.cxx:165
TrigNavSlimmingMTAlg::lookupHardCodedLegMultiplicities
std::vector< size_t > lookupHardCodedLegMultiplicities(const std::string &chain) const
Supplemental leg multiplicity information to support MC20.
Definition: TrigNavSlimmingMTAlg.cxx:288
TrigNavSlimmingMTAlg.h
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
TrigConf::HLTChain
HLT chain configuration information.
Definition: TrigConfHLTData/TrigConfHLTData/HLTChain.h:35
TrigNavSlimmingMTAlg::doRepack
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...
TrigTimeStamp::millisecondsSince
double millisecondsSince() const
Definition: TrigTimeStamp.cxx:7
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
TrigCompositeUtils::NavGraph::edges
size_t edges() const
Definition: NavGraph.cxx:119
TrigCompositeUtils::createAndStore
SG::WriteHandle< DecisionContainer > createAndStore(const SG::WriteHandleKey< DecisionContainer > &key, const EventContext &ctx)
Creates and right away records the DecisionContainer with the key.
Definition: TrigCompositeUtilsRoot.cxx:28
TrigCompositeUtils::roiString
const std::string & roiString()
Definition: TrigCompositeUtils.h:418
TrigNavSlimmingMTAlg::m_outputCollection
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_outputCollection
Definition: TrigNavSlimmingMTAlg.h:55
TrigCompositeUtils::NavGraphNode::children
const std::vector< NavGraphNode * > & children() const
Return a vector of const pointers to the Decision object nodes which are the children of this NavGrap...
Definition: NavGraph.cxx:50
TrigConf::HLTChain::leg_multiplicities
const std::vector< size_t > & leg_multiplicities() const
Definition: TrigConfHLTData/TrigConfHLTData/HLTChain.h:83
ParticleAuxContainer.h
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:74
covarianceTool.filter
filter
Definition: covarianceTool.py:514
TrigNavSlimmingMTAlg::TrigNavSlimmingMTAlg
TrigNavSlimmingMTAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TrigNavSlimmingMTAlg.cxx:84
TrigCompositeUtils::getTerminusNode
const Decision * getTerminusNode(SG::ReadHandle< DecisionContainer > &container)
Definition: TrigCompositeUtilsRoot.cxx:258
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
TrigNavSlimmingMTAlg::m_outputRepackedFeaturesCollectionKey_Particle
SG::WriteHandleKey< xAOD::ParticleContainer > m_outputRepackedFeaturesCollectionKey_Particle
Definition: TrigNavSlimmingMTAlg.h:63
TrigCompositeUtils::NavGraph::nodes
size_t nodes() const
Definition: NavGraph.cxx:114
xAOD::Particle_v1::setP4
void setP4(const FourMom_t &vec)
Set the 4-vec.
Definition: Particle_v1.cxx:71
python.UpdateManyBadChannelIOVs.toRemove
tuple toRemove
Definition: UpdateManyBadChannelIOVs.py:86
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::TrigComposite_v1::setObjectLink
bool setObjectLink(const std::string &name, const ElementLink< CONTAINER > &link)
Set the link to an object.
TrigTimeStamp
utility class to measure time duration in AthenaMT The pattern when it is useful: AlgA tags the begin...
Definition: TrigTimeStamp.h:23
TrigCompositeUtils::getExpressTerminusNode
const Decision * getExpressTerminusNode(const DecisionContainer &container)
Returns the express-accept navigation node from a collection or nullptr if missing.
Definition: TrigCompositeUtilsRoot.cxx:266
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TrigNavSlimmingMTAlg::propagateSeedingRelation
StatusCode propagateSeedingRelation(const TrigCompositeUtils::NavGraphNode *inputNode, IOCacheMap &cache, const EventContext &ctx) const
Copy the subset of "seed" links which are present in the inputNode.
Definition: TrigNavSlimmingMTAlg.cxx:347
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:37
TrigNavSlimmingMTAlg::m_repackMET
Gaudi::Property< bool > m_repackMET
Definition: TrigNavSlimmingMTAlg.h:87
TrigCompositeUtils::createAndStoreNoAux
SG::WriteHandle< CONT > createAndStoreNoAux(const SG::WriteHandleKey< CONT > &key, const EventContext &ctx)
Creates and right away records the Container CONT with the key.
TrigCompositeUtils::NavGraph
Structure to hold a transient Directed Acyclic Graph (DAG) structure. NavGraph is populated from,...
Definition: NavGraph.h:111
TrigNavSlimmingMTAlg::m_chainsFilter
Gaudi::Property< std::vector< std::string > > m_chainsFilter
Definition: TrigNavSlimmingMTAlg.h:112
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TrigNavSlimmingMTAlg::m_allOutputContainers
Gaudi::Property< std::vector< std::string > > m_allOutputContainers
Definition: TrigNavSlimmingMTAlg.h:108
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:49
TrigCompositeUtils::initialRoIString
const std::string & initialRoIString()
Definition: TrigCompositeUtils.h:416
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
HLT::Identifier
Definition: TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h:19
xAOD::Particle_v1
Description of a generic particle.
Definition: Particle_v1.h:31
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
merge.output
output
Definition: merge.py:16
Trig::ChainGroup
Definition: ChainGroup.h:51
TrigNavSlimmingMTAlg::printIParticleRepackingDebug
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.
Definition: TrigNavSlimmingMTAlg.cxx:464
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
TrigCompositeUtils::NavGraphNode::node
const Decision * node() const
Return a const pointer to the Decision object node which this NavGraphNode is shadowing.
Definition: NavGraph.cxx:41
TrigNavSlimmingMTAlg::inputToOutput
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...
Definition: TrigNavSlimmingMTAlg.cxx:325
xAOD::TrigComposite_v1::linkColNames
const std::vector< std::string > & linkColNames() const
Raw access to the persistent link names.
TrigCompositeUtils::seedString
const std::string & seedString()
Definition: TrigCompositeUtils.h:421
TrigCompositeUtils::createLegName
HLT::Identifier createLegName(const HLT::Identifier &chainIdentifier, size_t counter)
Generate the HLT::Identifier which corresponds to a specific leg of a given chain.
Definition: TrigCompositeUtilsRoot.cxx:166
TrigNavSlimmingMTAlg::m_trigDec
PublicToolHandle< Trig::TrigDecisionTool > m_trigDec
Definition: TrigNavSlimmingMTAlg.h:117
TrigNavSlimmingMTAlg::m_outputRepackedROICollectionKey
SG::WriteHandleKey< TrigRoiDescriptorCollection > m_outputRepackedROICollectionKey
Definition: TrigNavSlimmingMTAlg.h:59
TrigCompositeUtils::getRejectedDecisionNodes
std::vector< const Decision * > getRejectedDecisionNodes([[maybe_unused]] const asg::EventStoreType *eventStore, const EventContext &ctx, const std::string &summaryCollectionKey, const DecisionIDContainer &ids, const std::set< std::string > &keysToIgnore)
Definition: TrigCompositeUtilsRoot.cxx:276
TrigCaloRecConfig.outputContainers
outputContainers
Definition: TrigCaloRecConfig.py:561
python.copyTCTOutput.chains
chains
Definition: copyTCTOutput.py:78
xAOD::TrigComposite_v1::name
const std::string & name() const
Get a human-readable name for the object.
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
TrigCompositeUtils::linkToPrevious
void linkToPrevious(Decision *d, const std::string &previousCollectionKey, size_t previousIndex)
Links to the previous object, location of previous 'seed' decision supplied by hand.
Definition: TrigCompositeUtilsRoot.cxx:140
TrigCompositeUtils::DecisionIDContainer
std::set< DecisionID > DecisionIDContainer
Definition: TrigComposite_v1.h:28
TrigNavSlimmingMTAlg::m_removeEmptySteps
Gaudi::Property< bool > m_removeEmptySteps
Definition: TrigNavSlimmingMTAlg.h:79
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
TrigCompositeUtils::NavGraphNode
Transient utility class to represent a node in a graph (m_decisionObject), and a vector of edges (m_f...
Definition: NavGraph.h:20
TrigCompositeUtils::hypoAlgNodeName
const std::string & hypoAlgNodeName()
Definition: TrigCompositeUtils.h:426
TrigNavSlimmingMTAlg::doRepackCopy
StatusCode doRepackCopy(const typename COLLECTION::base_value_type *object, SG::WriteHandle< COLLECTION > *writeHandle) const
Performs the xAOD Copy.
TrigNavSlimmingMTAlg::m_keepOnlyFinalFeatures
Gaudi::Property< bool > m_keepOnlyFinalFeatures
Definition: TrigNavSlimmingMTAlg.h:75
DEBUG
#define DEBUG
Definition: page_access.h:11
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
TrigCompositeUtils::decisionIDs
void decisionIDs(const Decision *d, DecisionIDContainer &destination)
Extracts DecisionIDs stored in the Decision object.
Definition: TrigCompositeUtilsRoot.cxx:65
TrigMissingETAuxContainer.h
TrigCompositeUtils::recursiveFlagForThinning
void recursiveFlagForThinning(NavGraph &graph, const bool keepOnlyFinalFeatures, const bool removeEmptySteps, const std::vector< std::string > &nodesToDrop)
Used by trigger navigation thinning.
Definition: TrigCompositeUtilsRoot.cxx:459
TrigCompositeUtils
Definition: Event/xAOD/xAODTrigger/xAODTrigger/TrigComposite.h:19
TrigNavSlimmingMTAlg::initialize
virtual StatusCode initialize() override
Definition: TrigNavSlimmingMTAlg.cxx:90
TrigRoiDescriptor
Athena::TPCnvVers::Current TrigRoiDescriptor
Definition: TrigSteeringEventTPCnv.cxx:68
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
TrigNavSlimmingMTAlg::propagateLinks
StatusCode propagateLinks(const TrigCompositeUtils::Decision *input, TrigCompositeUtils::Decision *output) const
Copy links (graph edges) from input to output.
Definition: TrigNavSlimmingMTAlg.cxx:399
Trig::ChainGroup::getListOfTriggers
std::vector< std::string > getListOfTriggers() const
Definition: ChainGroup.cxx:467
set_intersection
Set * set_intersection(Set *set1, Set *set2)
Perform an intersection of two sets.
TrigNavSlimmingMTAlg::repackLinks
StatusCode repackLinks(TrigCompositeUtils::Decision *output, Outputs &outputContainers) const
Repacks ElementLinks in the DecisionObject to point to compact output containers written by this alg.
Definition: TrigNavSlimmingMTAlg.cxx:479
TrigTimeStamp.h
TrigCompositeUtils::inputMakerNodeName
const std::string & inputMakerNodeName()
Definition: TrigCompositeUtils.h:425
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
TrigCompositeUtils::NavGraph::thin
std::vector< const Decision * > thin()
Perform thinning.
Definition: NavGraph.cxx:123
TrigNavSlimmingMTAlg::Outputs
Definition: TrigNavSlimmingMTAlg.h:44
TrigNavSlimmingMTAlg::propagateDecisionIDs
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.
Definition: TrigNavSlimmingMTAlg.cxx:437
TrigCompositeUtils::recursiveGetDecisionsInternal
void recursiveGetDecisionsInternal(const Decision *node, const Decision *comingFrom, NavGraph &navGraph, std::set< const Decision * > &fullyExploredFrom, const DecisionIDContainer &ids, const bool enforceDecisionOnNode)
Used by recursiveGetDecisions.
Definition: TrigCompositeUtilsRoot.cxx:407
TrigCompositeUtils::decisionToElementLink
ElementLink< DecisionContainer > decisionToElementLink(const Decision *d, const EventContext &ctx)
Takes a raw pointer to a Decision and returns an ElementLink to the Decision.
Definition: TrigCompositeUtilsRoot.cxx:123
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
TrigNavSlimmingMTAlg::m_nodesToDrop
Gaudi::Property< std::vector< std::string > > m_nodesToDrop
Definition: TrigNavSlimmingMTAlg.h:104
TrigNavSlimmingMTAlg::fillChainIDs
StatusCode fillChainIDs(TrigCompositeUtils::DecisionIDContainer &chainIDs) const
Convert the ChainsFilter into the set of chain-IDd and chain-leg-IDs which comprises all of the Decis...
Definition: TrigNavSlimmingMTAlg.cxx:293