ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
ComboHypo Class Reference

#include <ComboHypo.h>

Inheritance diagram for ComboHypo:
Collaboration diagram for ComboHypo:

Public Member Functions

 ComboHypo (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~ComboHypo () override
 
virtual StatusCode initialize () override
 
virtual StatusCode execute (const EventContext &context) const override
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
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. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

const SG::ReadHandleKeyArray< TrigCompositeUtils::DecisionContainer > & decisionsInput () const
 
const SG::WriteHandleKeyArray< TrigCompositeUtils::DecisionContainer > & decisionsOutput () const
 
const Combo::MultiplicityReqMaptriggerMultiplicityMap () const
 
const Combo::LegMaplegToInputCollectionMap () const
 
ToolHandleArray< ComboHypoToolBase > & hypoTools ()
 
const ToolHandleArray< ComboHypoToolBase > & hypoTools () const
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
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. More...
 

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

StatusCode copyDecisions (const Combo::LegDecisionsMap &passingLegs, const EventContext &context) const
 iterates over the inputs and for every object (no filtering) crates output object linked to input moving the decisions that are mentioned in the passing set More...
 
StatusCode extractFeatureAndRoI (const HLT::Identifier &chainLegId, const ElementLink< TrigCompositeUtils::DecisionContainer > &EL, SG::sgkey_t &featureKey, TrigCompositeUtils::Decision::index_type &featureIndex, SG::sgkey_t &roiKey, TrigCompositeUtils::Decision::index_type &roiIndex, bool &roiFullscan, bool &objectRequestsNoMultiplicityCheck, SG::SGKeyMap< std::set< uint32_t >> &priorFeaturesMap) const
 For a given Decision node from a HypoAlg, extracts type-less identification data on the node's Feature and seeding ROI. More...
 
StatusCode fillDecisionsMap (Combo::LegDecisionsMap &dmap, const EventContext &context) const
 iterates over all inputs, associating inputs to legs More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

SG::ReadHandleKeyArray< TrigCompositeUtils::DecisionContainerm_inputs { this, "HypoInputDecisions", {}, "Input Decisions" }
 
SG::WriteHandleKeyArray< TrigCompositeUtils::DecisionContainerm_outputs { this, "HypoOutputDecisions", {}, "Output Decisions" }
 
Gaudi::Property< bool > m_requireUniqueROI
 
Gaudi::Property< Combo::MultiplicityReqMapm_multiplicitiesReqMap
 
Gaudi::Property< Combo::LegMapm_legToInputCollectionMap
 
Gaudi::Property< bool > m_checkMultiplicityMap
 
ToolHandleArray< ComboHypoToolBasem_hypoTools {this, "ComboHypoTools", {}, "Tools to perform selection"}
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

hypotheses required only counting (multiplicity requirements)

Warning
while configuring it the order of specified multiplicities has to match order of input decision containers i.e. if feed with: electronDecisions muonDecisions jetDecisions the multiplicity specification like this: "HLT_4e10_2mu7_j100" : [ 4, 2, 1 ] will apply respectively requirement of 4, 2, 1 positive decisions in electron, muon and jet inputs the leg specification like this: "HLT_4e10_2mu7_j100" : [ 0, 1, 2 ], where the names of legs are leg000, leg001, and leg002.

Definition at line 31 of file ComboHypo.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ComboHypo()

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

Definition at line 13 of file ComboHypo.cxx.

14 : ::AthReentrantAlgorithm(name, pSvcLocator)
15 {}

◆ ~ComboHypo()

ComboHypo::~ComboHypo ( )
overridevirtual

Definition at line 18 of file ComboHypo.cxx.

19 {}

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality
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.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ copyDecisions()

StatusCode ComboHypo::copyDecisions ( const Combo::LegDecisionsMap passingLegs,
const EventContext &  context 
) const
private

iterates over the inputs and for every object (no filtering) crates output object linked to input moving the decisions that are mentioned in the passing set

Definition at line 86 of file ComboHypo.cxx.

86  {
87  DecisionIDContainer passing;
88  for (auto const& element : passingLegs) {
89  passing.insert(element.first);
90  }
91 
92  ATH_MSG_DEBUG( "Copying "<<passing.size()<<" positive decision IDs to outputs");
93 
94  for ( size_t input_counter = 0; input_counter < m_inputs.size(); ++input_counter ) {
95  // new output decisions
96  SG::WriteHandle<DecisionContainer> outputHandle = createAndStore(m_outputs.at(input_counter), context );
97  auto outDecisions = outputHandle.ptr();
98  auto inputHandle = SG::makeHandle( m_inputs.at(input_counter), context );
99  if ( inputHandle.isValid() ) {
100 
101  for (const Decision* inputDecision : *inputHandle) {
102  auto thisEL = TrigCompositeUtils::decisionToElementLink(inputDecision, context);
103 
104  // from all positive decision in the input only the ones that survived counting are passed over
105  const DecisionIDContainer& common = passedDecisionIDs(inputDecision, passing);
106 
107  // check if this EL is in the combination map for the passing decIDs:
108  ATH_MSG_DEBUG("Searching this element in the map: ("<<thisEL.dataID() << " , " << thisEL.index()<<")");
109  DecisionIDContainer finalIds;
110  for (const DecisionID c : common){
111  const HLT::Identifier cID = HLT::Identifier(c);
112  // add the decID only if this candidate passed the combination selection
113  const std::vector<ElementLink<DecisionContainer>>& Comb=passingLegs.at(c);
114  if(std::find(Comb.begin(), Comb.end(), thisEL) == Comb.end()) {
115  continue;
116  }
117  ATH_MSG_DEBUG(" Adding "<< cID <<" because EL is found in the passingLegs map");
118  finalIds.insert( cID.numeric() ); // all Ids used by the Filter, including legs
119  if (TrigCompositeUtils::isLegId ( cID )){
120  const HLT::Identifier mainChain = TrigCompositeUtils::getIDFromLeg( cID );
121  finalIds.insert( mainChain.numeric() );
122  ATH_MSG_DEBUG(" Adding "<< mainChain <<" consequently");
123  }
124  }
125 
126  Decision* newDec = newDecisionIn( outDecisions, inputDecision, comboHypoAlgNodeName(), context );
127  ATH_MSG_DEBUG("New decision (Container Index:" << input_counter << ", Element Index:"<< newDec->index() <<") has "
128  << (TrigCompositeUtils::findLink<TrigRoiDescriptorCollection>(newDec, initialRoIString())).isValid()
129  << " valid initialRoI, "<< TrigCompositeUtils::getLinkToPrevious(newDec).size() <<" previous decisions and "<<finalIds.size()<<" decision IDs") ;
130  insertDecisionIDs( finalIds, newDec );
131 
132  }
133  }
134 
135  if (msgLvl(MSG::DEBUG)) {
136  ATH_MSG_DEBUG("Output Handle " << m_outputs.at(input_counter).key() << " with " << outputHandle->size() <<" Decision objects");
137  for (const Decision* d : *outputHandle){
138  DecisionIDContainer objDecisions;
139  decisionIDs( d, objDecisions );
140  ATH_MSG_DEBUG(" Decision object #" << d->index() << " with " << objDecisions.size()<<" positive decision IDs");
141  for (const TrigCompositeUtils::DecisionID id : objDecisions ) {
142  ATH_MSG_DEBUG(" --- Passes: " << HLT::Identifier( id ));
143  }
144  }
145  }
146  }
147 
148  return StatusCode::SUCCESS;
149 }

◆ decisionsInput()

const SG::ReadHandleKeyArray<TrigCompositeUtils::DecisionContainer>& ComboHypo::decisionsInput ( ) const
inlineprotected

Definition at line 41 of file ComboHypo.h.

41 { return m_inputs; }

◆ decisionsOutput()

const SG::WriteHandleKeyArray<TrigCompositeUtils::DecisionContainer>& ComboHypo::decisionsOutput ( ) const
inlineprotected

Definition at line 42 of file ComboHypo.h.

42 { return m_outputs; }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

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

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase hndl,
const std::string &  doc,
const SG::VarHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey hndl,
const std::string &  doc,
const SG::VarHandleKeyType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType  
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

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

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode ComboHypo::execute ( const EventContext &  context) const
overridevirtual

< Keeps track per leg of the hash of the objects passing the leg

< We allow Jets or a FullScan ROI to pass any multiplicity. So we may have to magic up some unique hashes. Counting integers work fine.

< If this grows greater than one then we have to start culling features from legs

< If the hash is used in multiple legs, which leg can least afford to lose it?

< How many features the leg at keepLegIndex can afford to lose before it starts to fail its multiplicity requirement.

Reimplemented in TrigMultiTrkComboHypo, TrigBmumuxComboHypo, and TrigBmuxComboHypo.

Definition at line 152 of file ComboHypo.cxx.

152  {
153  ATH_MSG_DEBUG( "Executing " << name() << "..." );
154 
155  // it maps decidionID to the combinations (list of dec object) that passed that ID
157  ATH_CHECK( fillDecisionsMap( dmap, context ) );
158 
159  //this is added for saving good combinations for the hypocombo tools
160  Combo::LegDecisionsMap passingLegs;
161 
162 
163  // loop over all chains in the mult-map
164  for ( const auto& [chainName, multiplicityPerLeg] : m_multiplicitiesReqMap ) {
165  const HLT::Identifier chainId = HLT::Identifier(chainName);
166  const DecisionID requiredDecisionID = chainId.numeric();
167 
168  DecisionIDContainer allDecisionIds;
169  allDecisionIds.insert(requiredDecisionID);
170 
171  bool overallDecision = true;
172 
173  std::vector< SG::SGKeySet > legFeatureHashes;
174  legFeatureHashes.resize( multiplicityPerLeg.size() );
175  SG::sgkey_t passthroughCounter = 0;
176 
177  Combo::LegDecisionsMap thisChainCombMap;
178 
179  // This map records the history for any given feature.
180  // E.g. for a key corresponding to a 4th Step muon, the entries in the payload std::set will be the 3rd step, 2nd step and 1st step
181  // features from within the same ROI.
182  //
183  // Using this information the combo hypo is able to deduce that a 4th-step-muon and its prior 2nd-step-muon should not be considered as two distinct candidates.
184  //
185  // Such a check is needed when implementing tag-and-probe style chains as when performing the probe processing we will be comparing 1st, 2nd, 3rd,. etc.
186  // step features on the probe leg to final-step features on the tag leg.
187  SG::SGKeyMap<std::set<uint32_t>> priorFeaturesMap;
188 
189  // Check multiplicity of each leg of this chain
190  for ( size_t legIndex = 0; legIndex < multiplicityPerLeg.size(); ++legIndex ) {
191  const size_t requiredMultiplicity = multiplicityPerLeg.at( legIndex );
192 
193  HLT::Identifier legId = chainId;
194  // If there is only one leg, then we just use the chain's name.
195  if (multiplicityPerLeg.size() > 1) {
196  ATH_MSG_DEBUG(chainId << " has multiplicityPerLeg.size() > 1, so we use legXXX_HLT_YYY, instead of HLT_YYY");
197  legId = TrigCompositeUtils::createLegName(chainName, legIndex);
198  }
199 
200  const DecisionID requiredDecisionIDLeg = legId.numeric();
201  ATH_MSG_DEBUG("Container " << legIndex << ", looking at leg : " << legId );
202 
203  Combo::LegDecisionsMap::const_iterator it = dmap.find(requiredDecisionIDLeg);
204  if ( it == dmap.end() ) {
205  continue;
206  }
207 
208  // Check the total number of decision objects we have available on this leg from which to satisfy its multiplicity requirement
209  const size_t nLegDecisionObjects = it->second.size();
210 
211  ATH_MSG_DEBUG( "Will attempt to meet the required multiplicity of " << requiredMultiplicity << " for leg " << legId
212  << " with " << nLegDecisionObjects << " Decision Objects in leg " << legIndex << " of " << legId);
213 
214  // We extract unique passing features on the leg, if there are no features yet - then the L1 ROI is used as a fall-back feature
215  // A special behaviour is that if this fall-back activates, and the L1 ROI is a full-scan ROI, then the leg is assumed valid.
216  // This is regardless of whether or not other legs also use the same FS ROI. Regardless of if the leg's required multiplicity.
217  // This keeps the leg alive until the actual FS reconstruction may occur. At which point, the following ComboHypo will begin
218  // to cut on the actual reconstructed physics objects.
219  //
220  // The behaviour may also be kept even after we have started to process a leg through HypoAlgs. This is done by the HypoAlg
221  // setting the "feature" to be the same as the initialRoI. The initialRoI must still be a FullScan ROI for this to work.
222  //
223  // Finally, the same behaviour may also be triggered by the HypoAlg adding an an int32_t decoration called "noCombo" with value 1
224  // to the Decision Object.
225 
226  for (const ElementLink<DecisionContainer>& dEL : it->second){
227  SG::sgkey_t featureKey = 0; // The container hash of the DecisionObject's most-recent feature, and its initial ROI
228  SG::sgkey_t roiKey = 0;
229  Decision::index_type featureIndex = 0, roiIndex = 0; // The container index of the DecisionObject's most-recent feature, and its initial ROI
230  bool roiIsFullscan = false; // Will be set to true if the DecisionObject's initial ROI is flagged as FullScan
231  bool objectRequestsNoMultiplicityCheck = false; // Will be set to true if the object has been flagged as independently satisfying all requirements on a leg
232  ATH_CHECK( extractFeatureAndRoI(it->first, dEL, featureKey, featureIndex, roiKey, roiIndex, roiIsFullscan, objectRequestsNoMultiplicityCheck, priorFeaturesMap) );
233  const bool theFeatureIsTheROI = (SG::sgkeyEqual (featureKey, roiKey) and featureIndex == roiIndex); // The user explicitly set the feature === the RoI
234  const bool thereIsNoFeatureYet = (featureKey == 0 and roiKey != 0); // The leg has not yet started to process
235  if (objectRequestsNoMultiplicityCheck or (roiIsFullscan and (theFeatureIsTheROI or thereIsNoFeatureYet))) {
236  // This passthroughCounter integer is being to generate unique "hash" values to allow Jets or FS ROI to meet the multiplicity requirements of this leg
237  for (size_t i = 0; i < requiredMultiplicity; ++i) {
238  legFeatureHashes.at( legIndex ).insert( ++passthroughCounter );
239  ATH_MSG_DEBUG(" -- Add feature hash '" << passthroughCounter << "' to leg " << legIndex
240  << ". (Note: unique passing hash generated from " << (objectRequestsNoMultiplicityCheck ? "an object requesting NO multiplicity checks" : "an FullScan ROI") << ")");
241  }
242  } else {
243  const SG::sgkey_t uniquenessHash = (featureKey != 0 ? (featureKey + featureIndex) : (roiKey + roiIndex));
244  legFeatureHashes.at( legIndex ).insert( uniquenessHash );
245  ATH_MSG_DEBUG(" -- Add feature hash '" << uniquenessHash << "' to leg " << legIndex << ".");
246  }
247  }
248 
249  // save combinations of all legs for the tools
250  thisChainCombMap.insert (*it);
251  allDecisionIds.insert(requiredDecisionIDLeg);
252 
253  } // end loop over legIndex
254 
255  // Up-cast any features which are actually earlier-step versions of other features (see priorFeaturesMap above)
256  // to be considered as equivalent to the later step version, note that this is for combo uniqueness comparison purposes only.
257  for (SG::SGKeySet& legHashes : legFeatureHashes) {
258  // We will continue to up-cast a single feature at a time in each leg's set of features, until no more upcast opportunities are available.
259  size_t emergencyBreak = 0;
260  while (true) {
261  bool somethingChanged = false;
262  for (const SG::sgkey_t legHash : legHashes) {
263  for (auto const& [key, payloadSet] : priorFeaturesMap) {
264  if (payloadSet.count(legHash) == 1) {
265  ATH_MSG_DEBUG("Feature hash=" << legHash << " identified as a prior feature of hash=" << key
266  << ", we will up-cast this hash to the later version for ComboHypo uniqueness comparison purposes.");
267  legHashes.erase(legHash);
268  legHashes.insert(key);
269  // CAUTION we have mutated a set we're iterating over. We must now break out of the loop over legHashes. This requires two breaks.
270  // This also lets the upcast cascade, i.e. what we insert as 'key' here could trigger another up-cast when considered as 'legHash' in the next iteration of the while(true) loop.
271  somethingChanged = true;
272  break;
273  }
274  } // End inner for loop (over priorFeaturesMap)
275  if (somethingChanged) {
276  break; // Break out of the outer loop when something changes, this avoids a continued invalid iteration over a mutated container.
277  }
278  } // End outer for loop (over legHashes)
279  if (!somethingChanged or ++emergencyBreak == 500) {
280  if (emergencyBreak == 500) {
281  ATH_MSG_WARNING("ComboHypo emergency loop break activated!");
282  }
283  break; // Break out of the while(true) loop when all elements of legHashes have been checked and none were upcast
284  }
285  }
286  } // Loop over the different legs
287 
288  // Remove any duplicated features which are shared between legs.
289  // Keep the feature only in the leg which can afford to lose the least number of object, given its multiplicity requirement.
290  // FIXME: The order in which we iterate over allFeatureHashes can
291  // affect the trigger results. But OK not to use SGKeySet here,
292  // since any duplicates will already have been removed
293  // in legFeatureHashes.
294  std::set<SG::sgkey_t> allFeatureHashes;
295  for (const SG::SGKeySet& legHashes : legFeatureHashes) {
296  allFeatureHashes.insert(legHashes.begin(), legHashes.end());
297  }
298  for (const SG::sgkey_t featureHash : allFeatureHashes) {
299  size_t legsWithHash = 0;
300  size_t keepLegIndex = 0;
301  int32_t keepLegMargin = std::numeric_limits<int32_t>::max();
302  for (size_t legIndex = 0; legIndex < multiplicityPerLeg.size(); ++legIndex) {
303  if (legFeatureHashes.at(legIndex).count(featureHash) == 0) {
304  continue;
305  }
306  ++legsWithHash;
307  const int32_t requiredMultiplicity = multiplicityPerLeg.at(legIndex);
308  const int32_t currentMultiplicity = legFeatureHashes.at(legIndex).size();
309  const int32_t safetyMargin = currentMultiplicity - requiredMultiplicity; // Signed, if -ve then the chain has already been failed by the leg at legIndex
310  if (safetyMargin < keepLegMargin) {
311  keepLegMargin = safetyMargin;
312  keepLegIndex = legIndex;
313  }
314  }
315  if (legsWithHash == 1) {
316  continue;
317  }
318  // If a feature is found on multiple legs, then remove it from all but the leg which can afford to lose it the least
319  for (size_t legIndex = 0; legIndex < multiplicityPerLeg.size(); ++legIndex) {
320  if (legIndex == keepLegIndex) {
321  ATH_MSG_DEBUG("Keeping feature hash '" << featureHash << "', on leg " << legIndex << ". This leg can least afford to lose it. "
322  << "Leg has " << legFeatureHashes.at(legIndex).size()
323  << " features, and a multiplicity requirement of " << multiplicityPerLeg.at(legIndex));
324  continue;
325  }
326  if (legFeatureHashes.at(legIndex).erase(featureHash)) {
327  ATH_MSG_DEBUG("Removed duplicate feature hash '" << featureHash << "', from leg " << legIndex << ". Leg now has " << legFeatureHashes.at(legIndex).size()
328  << " remaining features, and a multiplicity requirement of " << multiplicityPerLeg.at(legIndex));
329  }
330  }
331  }
332 
333  //check that the multiplicity of unique features is high enough
334  for (size_t legIndex = 0; legIndex < multiplicityPerLeg.size(); ++legIndex) {
335  const size_t requiredMultiplicity = multiplicityPerLeg.at(legIndex);
336  const size_t currentMultiplicity = legFeatureHashes.at(legIndex).size();
337  if (currentMultiplicity < requiredMultiplicity) {
338  ATH_MSG_DEBUG("Leg " << legIndex << " fails multiplicity check. Required unique features:" << requiredMultiplicity << ", found unique features: " << currentMultiplicity);
339  overallDecision = false;
340  break;
341  }
342  }
343 
344  //Overall chain decision
345  ATH_MSG_DEBUG( "Chain " << chainId << ( overallDecision ? " is accepted" : " is rejected") <<" after multiplicity requirements" );
346  if ( overallDecision == true ) {
347  for (auto decID: allDecisionIds) {
348  // saving the good combinations
349  passingLegs.insert (thisChainCombMap.begin(), thisChainCombMap.end());
350  ATH_MSG_DEBUG(" Passing " << HLT::Identifier(decID)<<" after multiplicity test");
351  }
352  }
353  }
354 
355  if (passingLegs.size()!=0){
356  // launching the tools:
358  for ( auto& tool: m_hypoTools ) {
359  ATH_MSG_DEBUG( "Calling tool "<<tool->name());
360  ATH_CHECK( tool->decide( passingLegs, context ) );
361  }
362  }
363 
364  // this is only for debug:
365  if (msgLvl(MSG::DEBUG)){
366  for (auto const& [id, decisions] : passingLegs) {
367  ATH_MSG_DEBUG("" << (decisions.empty() ? "failing " : "passing "+std::to_string(decisions.size())+" decisions ") << id );
368  }
369  }
370 
371  // need to pass all combinations, since not all element pass the decID
372  ATH_CHECK( copyDecisions( passingLegs, context ) );
373 
374  return StatusCode::SUCCESS;
375 }

◆ extractFeatureAndRoI()

StatusCode ComboHypo::extractFeatureAndRoI ( const HLT::Identifier chainLegId,
const ElementLink< TrigCompositeUtils::DecisionContainer > &  EL,
SG::sgkey_t featureKey,
TrigCompositeUtils::Decision::index_type featureIndex,
SG::sgkey_t roiKey,
TrigCompositeUtils::Decision::index_type roiIndex,
bool &  roiFullscan,
bool &  objectRequestsNoMultiplicityCheck,
SG::SGKeyMap< std::set< uint32_t >> &  priorFeaturesMap 
) const
private

For a given Decision node from a HypoAlg, extracts type-less identification data on the node's Feature and seeding ROI.

Parameters
[in]chainLegIdThe HLT::Identifer of the chain (leg) we're extracting features for.
[in]ELThe Decision node from the HypoAlg, expected to have a "feature" link attached to it. Expected to be able to locate a "initialRoI" in its history if RequireUniqueROI=True.
[out]featureKeyType-less SG Key hash of the collection hosting the Decision node's feature .
[out]featureIndexIndex inside the featureKey collection.
[out]roiKeyType-less SG Key hash of the collection hosting the Decision node's initial ROI collection.
[out]roiIndexIndex inside the roiKey collection.
[out]roiIsFullscanFlag indicating if the located initial ROI has the FullScan flag enabled. Triggers special behaviour allowing the ROI to satisfy arbitrary multiplicities in an arbitrary number of legs.
[out]objectRequestsNoMultiplicityCheckFlag indicating of the DecisionObject requested not be included in the multiplicity computation. Triggers special behaviour allowing the DecisionObject to satisfy arbitrary multiplicities in an arbitrary number of legs.
[in,out]priorFeaturesMapData structure collating for a given feature (key) what the prior features were integrated over all previous steps (value set).

Definition at line 378 of file ComboHypo.cxx.

387 {
388  // Return collections for the findLinks call.
389  // While we will be focusing on the most recent feature, for tag-and-probe we need to keep a record of the features from the prior steps too.
390 
391  // Construct a sub-graph following just this leg back through the nav
392  DecisionIDContainer chainLegIdSet = {chainLegId.numeric()};
394  recursiveGetDecisions((*dEL), subGraph, chainLegIdSet, /*enforceDecisionOnStartNode =*/ true);
395 
396  if (subGraph.finalNodes().size() != 1) {
397  ATH_MSG_ERROR("We are only expecting to search from a single navigation node in extractFeatureAndRoI");
398  return StatusCode::FAILURE;
399  }
400  const NavGraphNode* start = *(subGraph.finalNodes().begin());
401 
402  std::vector<SG::sgkey_t> keys;
403  std::vector<uint32_t> clids; // We don't care about the class ID. This part gets ignored.
404  std::vector<Decision::index_type> indicies;
405  std::vector<const Decision*> sources;
406 
407  std::set<const Decision*> fullyExploredFrom; // This is a cache which typelessFindLinks will use to avoid re-visiting already explored regions of the graph
408  // Note: This call to typelessFindLinks is exploring from a NavGraphNode* rather than a Decision*,
409  // this indicates that the search is restricted to a sub-graph (specifically, only following one chain-leg)
410  const bool foundFeature = typelessFindLinks(start, featureString(), keys, clids, indicies, sources, TrigDefs::allFeaturesOfType, &fullyExploredFrom);
411 
412  const Decision* featureSource = nullptr;
413  // The "most recent" feature (from the step just run) is the one we find first. Hence it's at index 0
414  if (foundFeature) {
415  featureKey = keys.at(0);
416  featureIndex = indicies.at(0);
417  featureSource = sources.at(0);
418  }
419 
420  objectRequestsNoMultiplicityCheck = (featureSource and featureSource->hasDetail<int32_t>("noCombo") and featureSource->getDetail<int32_t>("noCombo") == 1);
421 
422  if (foundFeature and priorFeaturesMap.count(featureKey + featureIndex) == 0) {
423  const std::string* key_str = evtStore()->keyToString(featureKey);
424  ATH_MSG_DEBUG("Note: Will use feature hash " << featureKey + featureIndex << ", for " << (key_str ? *key_str : "UNKNOWN") << " index=" << featureIndex);
425  // Use the deep-search data to look further back than .at(0)
426  // Here's where we keep the record of the features in previous steps. Step ordering is unimportant, we can use a set.
427  if (keys.size() > 1) {
428  for (size_t i = 1; i < keys.size(); ++i) { // Skip the 1st entry, this will be equal to featureKey and featureIndex from typelessFindLink above.
429  // featureKey + featureIndex should be considered as equivalent to a per-feature hash (featureKey is a real hash, featureIndex is an offset index)
430  if (featureKey + featureIndex == keys.at(i) + indicies.at(i)) {
431  continue; // Do not add the case where a feature is re-attached to more than one step.
432  }
433  priorFeaturesMap[featureKey + featureIndex].insert(keys.at(i) + indicies.at(i));
434  }
435  } else { // Exactly one feature. Make a note of this by inserting an empty set, such that we don't do this search again.
436  priorFeaturesMap.insert( std::pair<uint32_t, std::set<uint32_t>>(featureKey + featureIndex, std::set<uint32_t>()) );
437  }
438  }
439 
440  // Try and get seeding ROI data too.
441  uint32_t roiClid{0}; // Unused
442  const Decision* roiSource{nullptr}; // Unused
443  const bool foundROI = typelessFindLink(subGraph, initialRoIString(), roiKey, roiClid, roiIndex, roiSource);
444  if (foundROI) {
445  ElementLink<TrigRoiDescriptorCollection> roiEL(roiKey, roiIndex);
446  ATH_CHECK( roiEL.isValid() );
447  roiIsFullscan = (*(roiEL))->isFullscan();
448  if (!foundFeature) {
449  const std::string* roi_str = evtStore()->keyToString(roiKey);
450  ATH_MSG_DEBUG("Note: Located fallback-ROI, if used this will have feature hash =" << roiKey + roiIndex << ", for " << (roi_str ? *roi_str : "UNKNOWN") << " index=" << roiIndex);
451  }
452  }
453 
454  if (!foundFeature && !foundROI) {
455  ATH_MSG_WARNING("Did not find the feature or initialRoI for " << dEL.dataID() << " index " << dEL.index());
456  }
457 
458  return StatusCode::SUCCESS;
459 }

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

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

◆ fillDecisionsMap()

StatusCode ComboHypo::fillDecisionsMap ( Combo::LegDecisionsMap dmap,
const EventContext &  context 
) const
private

iterates over all inputs, associating inputs to legs

Definition at line 462 of file ComboHypo.cxx.

462  {
463  for ( size_t inputContainerIndex = 0; inputContainerIndex < m_inputs.size(); ++inputContainerIndex ) {
464  auto inputHandle = SG::makeHandle( m_inputs.at(inputContainerIndex), context );
465  if ( !inputHandle.isValid() ) {
466  ATH_MSG_ERROR( "No input ReadHandle from " << inputHandle.key() );
467  return StatusCode::FAILURE;
468  }
469  ATH_MSG_DEBUG( "-- Found ReadHandle from " << inputHandle.key() <<" with "<< inputHandle->size() << " elements:" );
470  for ( const Decision* decision : *inputHandle ) {
471  ATH_MSG_DEBUG( "-- -- Input Decision #"<< decision->index() <<" with "<< decisionIDs( decision ).size() << " active IDs. Populating the multiplicity map:" );
472  for ( const DecisionID id: decisionIDs( decision ) ) {
473 
474  // Handles regular and multi-leg case
475  const auto& [chainName, chainLeg] = getNameAndIndexFromLeg(HLT::Identifier(id).name());
476 
477  // We need to check if we are configured to accept DecisionObjects passing 'chainName' ...
478  Combo::LegMap::const_iterator it = m_legToInputCollectionMap.find(chainName);
479  if (it == m_legToInputCollectionMap.end()) {
480  ATH_MSG_VERBOSE("-- -- -- Ignoring the DecsionID " << id << " on leg " << chainLeg << " as it does not correspond to any of the " << m_legToInputCollectionMap.size() << " chains this Alg is processing.");
481  continue;
482  }
483 
484  // ... and if so we need to further check that we are accepting passing IDs for chainLeg on the current inputContainerIndex
485  const std::vector<int>& legToInputCollectionIndex = it->second;
486  const size_t requiredInputContainerIndex = static_cast<size_t>(legToInputCollectionIndex.at(chainLeg));
487  if (requiredInputContainerIndex != inputContainerIndex) {
488  ATH_MSG_VERBOSE("-- -- -- Ignoring the DecisionID " << id << " on leg " << chainLeg << " as we are only permitted to accept passing objects on leg #" << chainLeg << " of " << chainName
489  << " which come from input collection index " << requiredInputContainerIndex << " (which is " << m_inputs.at(requiredInputContainerIndex).key() << ")"
490  << ". Not the current index " << inputContainerIndex << " (which is " << m_inputs.at(inputContainerIndex).key() << ")");
491  continue;
492  }
493 
494  ATH_MSG_DEBUG( " ++++ " << HLT::Identifier( id ) );
495  dmap[id].push_back( TrigCompositeUtils::decisionToElementLink(decision, context) );
496  }
497  }
498  }
499 
500  if (msgLvl(MSG::DEBUG)){
501  ATH_MSG_DEBUG( "Decision map filled :" );
502  size_t legCount = 0;
503  for (const auto& entry: dmap){
504  ATH_MSG_DEBUG("leg ["<<legCount<<"]: ");
505  const std::vector<ElementLink<DecisionContainer>>& decisions = entry.second;
506  ATH_MSG_DEBUG(" ++++ " << HLT::Identifier( entry.first ) <<" Number Decisions: "<< decisions.size());
508  ATH_MSG_DEBUG(" Decision: (ContainerKey:"<<d.dataID()<<", DecisionElementIndex:"<<d.index()<<")");
509  }
510  legCount++;
511  }
512  }
513 
514 
515  return StatusCode::SUCCESS;
516 }

◆ filterPassed()

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

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

96  {
97  return execState( ctx ).filterPassed();
98  }

◆ hypoTools() [1/2]

ToolHandleArray<ComboHypoToolBase>& ComboHypo::hypoTools ( )
inlineprotected

Definition at line 45 of file ComboHypo.h.

45 { return m_hypoTools; }

◆ hypoTools() [2/2]

const ToolHandleArray<ComboHypoToolBase>& ComboHypo::hypoTools ( ) const
inlineprotected

Definition at line 46 of file ComboHypo.h.

46 { return m_hypoTools; }

◆ initialize()

StatusCode ComboHypo::initialize ( )
overridevirtual

Reimplemented in TrigMultiTrkComboHypo, TrigBmumuxComboHypo, and TrigBmuxComboHypo.

Definition at line 22 of file ComboHypo.cxx.

22  {
23 
24  ATH_CHECK( m_outputs.initialize() );
25  ATH_CHECK( m_inputs.initialize() );
26  ATH_CHECK( m_inputs.size() == m_outputs.size() );
27 
28  if (m_hypoTools.size()>0) {
29  ATH_CHECK(m_hypoTools.retrieve());
30  }
31 
32  for (auto& tool: m_hypoTools ) {
33  ATH_CHECK(tool->setLegMultiplicity(m_multiplicitiesReqMap));
34  }
35 
36  // find max inputs size
37  auto maxMultEl = std::max_element( m_multiplicitiesReqMap.begin(), m_multiplicitiesReqMap.end(),
38  []( const Combo::MultiplicityReqMap::value_type& a, const Combo::MultiplicityReqMap::value_type& b ){
39  return a.second.size() < b.second.size();
40  });
41 
42  const size_t maxMult = maxMultEl->second.size();
43 
44  if (msgLvl(MSG::DEBUG)){
45  ATH_MSG_DEBUG( "with these inputs:");
46  for (const auto& inp : m_inputs) {
47  ATH_MSG_DEBUG("-- "<< inp.key());
48  }
49  ATH_MSG_DEBUG( "with this multiplicity map:");
50  for ( const auto& m : m_multiplicitiesReqMap ) {
51  ATH_MSG_DEBUG("-- " << m.first
52  << " multiplicities: " << m.second
53  <<", input-collection-indicies: " << m_legToInputCollectionMap[m.first]);
54  }
55  }
56 
57  ATH_CHECK( m_multiplicitiesReqMap.size() != 0 );
58 
59  bool errorOccured = false;
61  for ( const auto& [key, value] : m_multiplicitiesReqMap ) {
62  // Check the size of the multiplicities-required-per-leg vector is the same as the input-collection-index-per-leg vector
63  Combo::LegMap::const_iterator it_input = m_legToInputCollectionMap.find(key);
64  if (it_input == m_legToInputCollectionMap.end()) {
65  ATH_MSG_ERROR(key << " was not registered in the LegToInputCollectionMap");
66  errorOccured = true;
67  } else if (value.size() != it_input->second.size()) {
68  ATH_MSG_ERROR("Inconsistent configuration vector sizes for " << key << " Multiplicities Required size:" << value.size()
69  << ", Input Collections Index size:" << it_input->second.size());
70  errorOccured = true;
71  }
72  // TimM Jult 21: What is this check doing?
73  if ( value.size() > maxMult ) {
74  errorOccured = true;
75  ATH_MSG_ERROR( "Chain " << key
76  << " configured with input multiplicity " << value.size() << " like this: " << value
77  << " which is lower than for this chain " << maxMultEl->first << " " << maxMult);
78  }
79  }
80  }
81 
82  return ( errorOccured ? StatusCode::FAILURE : StatusCode::SUCCESS );
83 }

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

◆ isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

52 {
53  // Reentrant algorithms are clonable.
54  return true;
55 }

◆ legToInputCollectionMap()

const Combo::LegMap& ComboHypo::legToInputCollectionMap ( ) const
inlineprotected

Definition at line 44 of file ComboHypo.h.

44 { return m_legToInputCollectionMap.value(); }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

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

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

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

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

364  {
365  handlesArray.renounce();
366  }

◆ setFilterPassed()

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

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100  {
101  execState( ctx ).setFilterPassed( state );
102  }

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

77 {
78  return BaseAlg::sysExecute (ctx);
79 }

◆ 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 InputMakerBase, and HypoBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

107  {
109 
110  if (sc.isFailure()) {
111  return sc;
112  }
113 
114  ServiceHandle<ICondSvc> cs("CondSvc",name());
115  for (auto h : outputHandles()) {
116  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
117  // do this inside the loop so we don't create the CondSvc until needed
118  if ( cs.retrieve().isFailure() ) {
119  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
120  return StatusCode::SUCCESS;
121  }
122  if (cs->regHandle(this,*h).isFailure()) {
123  sc = StatusCode::FAILURE;
124  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
125  << " with CondSvc");
126  }
127  }
128  }
129  return sc;
130 }

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

◆ triggerMultiplicityMap()

const Combo::MultiplicityReqMap& ComboHypo::triggerMultiplicityMap ( ) const
inlineprotected

Definition at line 43 of file ComboHypo.h.

43 { return m_multiplicitiesReqMap.value(); }

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_checkMultiplicityMap

Gaudi::Property<bool> ComboHypo::m_checkMultiplicityMap
private
Initial value:
{ this, "CheckMultiplicityMap", true,
"Perform a consistency check of the MultiplicitiesMap"}

Definition at line 64 of file ComboHypo.h.

◆ 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_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_hypoTools

ToolHandleArray< ComboHypoToolBase > ComboHypo::m_hypoTools {this, "ComboHypoTools", {}, "Tools to perform selection"}
private

Definition at line 106 of file ComboHypo.h.

◆ m_inputs

SG::ReadHandleKeyArray<TrigCompositeUtils::DecisionContainer> ComboHypo::m_inputs { this, "HypoInputDecisions", {}, "Input Decisions" }
private

Definition at line 50 of file ComboHypo.h.

◆ m_legToInputCollectionMap

Gaudi::Property< Combo::LegMap > ComboHypo::m_legToInputCollectionMap
private
Initial value:
{this, "LegToInputCollectionMap", {},
"Map from the chain name to the per-leg index in this algorithm's ReadHandleKeyArray which should be used as the source of incoming Decision Objects on the leg.",
"mapMergeNoReplace<std::string, std::vector<int>>"}

Definition at line 60 of file ComboHypo.h.

◆ m_multiplicitiesReqMap

Gaudi::Property< Combo::MultiplicityReqMap > ComboHypo::m_multiplicitiesReqMap
private
Initial value:
{this, "MultiplicitiesMap", {},
"Map from the chain name to multiplicities required at each input",
"mapMergeNoReplace<std::string, std::vector<int>>"}

Definition at line 56 of file ComboHypo.h.

◆ m_outputs

SG::WriteHandleKeyArray<TrigCompositeUtils::DecisionContainer> ComboHypo::m_outputs { this, "HypoOutputDecisions", {}, "Output Decisions" }
private

Definition at line 51 of file ComboHypo.h.

◆ m_requireUniqueROI

Gaudi::Property<bool> ComboHypo::m_requireUniqueROI
private
Initial value:
{this, "RequireUniqueROI", false,
"Require each Feature in each leg of the combination to come from a unique L1 seeding ROI."}

Definition at line 53 of file ComboHypo.h.

◆ 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:
ComboHypo::m_multiplicitiesReqMap
Gaudi::Property< Combo::MultiplicityReqMap > m_multiplicitiesReqMap
Definition: ComboHypo.h:56
ComboHypo::extractFeatureAndRoI
StatusCode extractFeatureAndRoI(const HLT::Identifier &chainLegId, const ElementLink< TrigCompositeUtils::DecisionContainer > &EL, SG::sgkey_t &featureKey, TrigCompositeUtils::Decision::index_type &featureIndex, SG::sgkey_t &roiKey, TrigCompositeUtils::Decision::index_type &roiIndex, bool &roiFullscan, bool &objectRequestsNoMultiplicityCheck, SG::SGKeyMap< std::set< uint32_t >> &priorFeaturesMap) const
For a given Decision node from a HypoAlg, extracts type-less identification data on the node's Featur...
Definition: ComboHypo.cxx:378
ComboHypo::copyDecisions
StatusCode copyDecisions(const Combo::LegDecisionsMap &passingLegs, const EventContext &context) const
iterates over the inputs and for every object (no filtering) crates output object linked to input mov...
Definition: ComboHypo.cxx:86
TrigCompositeUtils::DecisionID
unsigned int DecisionID
Definition: TrigComposite_v1.h:27
TrigCompositeUtils::recursiveGetDecisions
void recursiveGetDecisions(const Decision *start, NavGraph &navGraph, const DecisionIDContainer &ids, const bool enforceDecisionOnStartNode)
Search back in time from "node" and locate all paths back through Decision objects for a given chain.
Definition: TrigCompositeUtilsRoot.cxx:436
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
HLT::Identifier::numeric
TrigCompositeUtils::DecisionID numeric() const
numeric ID
Definition: TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h:41
ComboHypo::fillDecisionsMap
StatusCode fillDecisionsMap(Combo::LegDecisionsMap &dmap, const EventContext &context) const
iterates over all inputs, associating inputs to legs
Definition: ComboHypo.cxx:462
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
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:43
hist_file_dump.d
d
Definition: hist_file_dump.py:142
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
TrigCompositeUtils::NavGraph::finalNodes
const std::vector< NavGraphNode * > & finalNodes() const
Get all final nodes.
Definition: NavGraph.cxx:99
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:13
AthCommonDataStore::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 > renounce(T &h)
Definition: AthCommonDataStore.h:380
skel.it
it
Definition: skel.GENtoEVGEN.py:407
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
TrigCompositeUtils::insertDecisionIDs
void insertDecisionIDs(const Decision *src, Decision *dest)
Appends the decision IDs of src to the dest decision object.
Definition: TrigCompositeUtilsRoot.cxx:77
TrigCompositeUtils::passedDecisionIDs
DecisionIDContainer passedDecisionIDs(const Decision *d, const T &required)
return DecisionIDs in Decision object that match the required ones
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
athena.value
value
Definition: athena.py:124
xAOD::TrigComposite_v1::hasDetail
bool hasDetail(const std::string &name) const
Check if a given type of detail is available.
TrigCompositeUtils::comboHypoAlgNodeName
const std::string & comboHypoAlgNodeName()
Definition: TrigCompositeUtilsRoot.cxx:922
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
isValid
bool isValid(const T &p)
Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
Definition: AtlasPID.h:867
Combo::LegDecisionsMap
std::map< TrigCompositeUtils::DecisionID, std::vector< ElementLink< TrigCompositeUtils::DecisionContainer > > > LegDecisionsMap
LegDecisionsMap For a given chain leg key, this map holds all Decision Objects which are active on th...
Definition: IComboHypoTool.h:28
TrigCompositeUtils::getNameAndIndexFromLeg
std::pair< std::string, int32_t > getNameAndIndexFromLeg(const std::string &name)
Extract the name and numeric index of a leg identifier.
Definition: TrigCompositeUtilsRoot.cxx:206
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:27
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:74
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
lumiFormat.i
int i
Definition: lumiFormat.py:85
TrigCompositeUtils::initialRoIString
const std::string & initialRoIString()
Definition: TrigCompositeUtilsRoot.cxx:882
TrigCompositeUtils::getLinkToPrevious
const std::vector< ElementLink< DecisionContainer > > getLinkToPrevious(const Decision *d)
returns links to previous decision object 'seed'
Definition: TrigCompositeUtilsRoot.cxx:156
TrigCompositeUtils::typelessFindLinks
bool typelessFindLinks(const Decision *start, const std::string &linkName, std::vector< sgkey_t > &keyVec, std::vector< uint32_t > &clidVec, std::vector< Decision::index_type > &indexVec, std::vector< const Decision * > &sourceVec, const unsigned int behaviour, std::set< const Decision * > *fullyExploredFrom)
search back the TC links for the object of type T linked to the one of TC (recursively) Returns the l...
Definition: TrigCompositeUtilsRoot.cxx:593
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SG::WriteHandle::ptr
pointer_type ptr()
Dereference the pointer.
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
ComboHypo::m_hypoTools
ToolHandleArray< ComboHypoToolBase > m_hypoTools
Definition: ComboHypo.h:106
TrigCompositeUtils::NavGraph
Structure to hold a transient Directed Acyclic Graph (DAG) structure. NavGraph is populated from,...
Definition: NavGraph.h:111
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
ComboHypo::m_outputs
SG::WriteHandleKeyArray< TrigCompositeUtils::DecisionContainer > m_outputs
Definition: ComboHypo.h:51
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:52
SG::AuxElement::index
size_t index() const
Return the index of this element within its container.
HLT::Identifier
Definition: TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h:19
xAOD::decisions
decisions
Definition: TrigComposite_v1.cxx:101
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
TrigCompositeUtils::featureString
const std::string & featureString()
Definition: TrigCompositeUtilsRoot.cxx:898
GetAllXsec.entry
list entry
Definition: GetAllXsec.py:132
ComboHypo::m_legToInputCollectionMap
Gaudi::Property< Combo::LegMap > m_legToInputCollectionMap
Definition: ComboHypo.h:60
SG::SGKeySet
std::unordered_set< sgkey_t > SGKeySet
A set of sgkey_t values.
Definition: CxxUtils/CxxUtils/sgkey_t.h:97
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:452
xAOD::TrigComposite_v1::index_type
uint32_t index_type
Definition: TrigComposite_v1.h:56
SG::sgkey_t
uint32_t sgkey_t
Type used for hashed StoreGate key+CLID pairs.
Definition: CxxUtils/CxxUtils/sgkey_t.h:32
ComboHypo::m_inputs
SG::ReadHandleKeyArray< TrigCompositeUtils::DecisionContainer > m_inputs
Definition: ComboHypo.h:50
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:165
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
TrigCompositeUtils::isLegId
bool isLegId(const HLT::Identifier &legIdentifier)
Recognise whether the chain ID is a leg ID.
Definition: TrigCompositeUtilsRoot.cxx:218
a
TList * a
Definition: liststreamerinfos.cxx:10
TrigCompositeUtils::DecisionIDContainer
std::set< DecisionID > DecisionIDContainer
Definition: TrigComposite_v1.h:28
h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
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
DEBUG
#define DEBUG
Definition: page_access.h:11
SG::SGKeyMap
std::unordered_map< sgkey_t, T > SGKeyMap
A map using sgkey_t as a key.
Definition: CxxUtils/CxxUtils/sgkey_t.h:93
python.TriggerAPI.TriggerAPISession.chainName
chainName
Definition: TriggerAPISession.py:426
TrigCompositeUtils::decisionIDs
void decisionIDs(const Decision *d, DecisionIDContainer &destination)
Extracts DecisionIDs stored in the Decision object.
Definition: TrigCompositeUtilsRoot.cxx:64
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
TrigCompositeUtils::getIDFromLeg
HLT::Identifier getIDFromLeg(const HLT::Identifier &legIdentifier)
Generate the HLT::Identifier which corresponds to the chain name from the leg name.
Definition: TrigCompositeUtilsRoot.cxx:179
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
JetTools::FFJetAllowedMassDefEnum::Comb
@ Comb
Track Assisted.
xAOD::TrigComposite_v1::getDetail
bool getDetail(const std::string &name, TYPE &value) const
Get an TYPE detail from the object.
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
python.compressB64.c
def c
Definition: compressB64.py:93
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
SG::sgkeyEqual
constexpr bool sgkeyEqual(const sgkey_t a, const sgkey_t b)
Compare two sgkeys for equality.
Definition: CxxUtils/CxxUtils/sgkey_t.h:39
fitman.k
k
Definition: fitman.py:528
common
Definition: common.py:1
python.SystemOfUnits.m
float m
Definition: SystemOfUnits.py:106
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:122
ServiceHandle< ICondSvc >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
TrigCompositeUtils::typelessFindLink
bool typelessFindLink(const Decision *start, const std::string &linkName, sgkey_t &key, uint32_t &clid, Decision::index_type &index, const Decision *&source, const bool suppressMultipleLinksWarning)
Perform a recursive search for ElementLinks of any time and name 'linkName', starting from Decision o...
Definition: TrigCompositeUtilsRoot.cxx:737
ComboHypo::m_checkMultiplicityMap
Gaudi::Property< bool > m_checkMultiplicityMap
Definition: ComboHypo.h:64