ATLAS Offline Software
Classes | Public Member Functions | Private Member Functions | Private Attributes | List of all members
HLTEDMCreator Class Reference

Tool capable of creating collections missing (early rejection) after HLT processing. It declares output handles for all possible collections produced by the trigger. More...

#include <HLTEDMCreator.h>

Inheritance diagram for HLTEDMCreator:
Collaboration diagram for HLTEDMCreator:

Classes

struct  ConstHandlesGroup
 
struct  HandlesGroup
 

Public Member Functions

 HLTEDMCreator (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual ~HLTEDMCreator () override=default
 
virtual StatusCode createOutput (const EventContext &context) const override
 
virtual StatusCode initialize () override
 

Private Member Functions

 HLTEDMCreator ()
 
 DEF_KEY (TrigRoiDescriptorCollection)
 
 DEF_XAOD_KEY (TrigCompositeContainer)
 
 DEF_XAOD_KEY (TrigEMClusterContainer)
 
 DEF_XAOD_KEY (TrigCaloClusterContainer)
 
 DEF_XAOD_KEY (TrigRingerRingsContainer)
 
 DEF_XAOD_KEY (TrigElectronContainer)
 
 DEF_XAOD_KEY (ElectronContainer)
 
 DEF_XAOD_KEY (PhotonContainer)
 
 DEF_XAOD_KEY (TrigPhotonContainer)
 
 DEF_XAOD_KEY (TrackParticleContainer)
 
 DEF_XAOD_KEY (TrigMissingETContainer)
 
 DEF_XAOD_KEY (L2StandAloneMuonContainer)
 
 DEF_XAOD_KEY (L2CombinedMuonContainer)
 
 DEF_XAOD_KEY (L2IsoMuonContainer)
 
 DEF_XAOD_KEY (MuonContainer)
 
 DEF_XAOD_KEY (TauJetContainer)
 
 DEF_XAOD_KEY (TauTrackContainer)
 
 DEF_XAOD_KEY (CaloClusterContainer)
 
 DEF_XAOD_KEY (JetContainer)
 
 DEF_XAOD_KEY (VertexContainer)
 
 DEF_XAOD_KEY (BTaggingContainer)
 
 DEF_XAOD_KEY (BTagVertexContainer)
 
 DEF_XAOD_KEY (TrigBphysContainer)
 
 DEF_XAOD_KEY (TrigT2MbtsBitsContainer)
 
 DEF_XAOD_KEY (HIEventShapeContainer)
 
 DEF_XAOD_KEY (TrigRNNOutputContainer)
 
 DEF_XAOD_KEY (AFPSiHitsClusterContainer)
 
 DEF_XAOD_KEY (AFPTrackContainer)
 
 DEF_XAOD_KEY (AFPToFTrackContainer)
 
 DEF_XAOD_KEY (AFPProtonContainer)
 
 DEF_XAOD_KEY (AFPVertexContainer)
 
 DEF_XAOD_KEY (eFexEMRoIContainer)
 
 DEF_XAOD_KEY (eFexTauRoIContainer)
 
 DEF_XAOD_KEY (jFexTauRoIContainer)
 
 DEF_XAOD_KEY (jFexFwdElRoIContainer)
 
 DEF_XAOD_KEY (jFexSRJetRoIContainer)
 
 DEF_XAOD_KEY (jFexLRJetRoIContainer)
 
 DEF_XAOD_KEY (jFexMETRoIContainer)
 
 DEF_XAOD_KEY (jFexSumETRoIContainer)
 
 DEF_XAOD_KEY (gFexJetRoIContainer)
 
 DEF_XAOD_KEY (gFexGlobalRoIContainer)
 
 DEF_XAOD_KEY (MuonRoIContainer)
 
 DEF_XAOD_KEY_SHALLOW (JetContainer)
 
 DEF_XAOD_KEY_SHALLOW (CaloClusterContainer)
 
template<typename T >
StatusCode initHandles (const HandlesGroup< T > &handles)
 Init related handles. More...
 
template<typename T >
StatusCode initAuxKey (const std::vector< SG::VarHandleKey * > &keys)
 Register AuxStore keys for the given keys. More...
 
StatusCode fixLinks () const
 
template<typename T , typename STORE , typename G , typename M >
StatusCode createIfMissing (const EventContext &context, const ConstHandlesGroup< T > &handles, G &generator, M merger) const
 
template<typename T >
StatusCode viewsMerge (ViewContainer const &views, const SG::ReadHandleKey< T > &inViewKey, EventContext const &context, T &output) const
 
template<typename T >
StatusCode noMerge (ViewContainer const &views, const SG::ReadHandleKey< T > &inViewKey, EventContext const &context, T &output) const
 

Private Attributes

Gaudi::Property< std::vector< std::string > > m_fixLinks { this, "FixLinks", {}, "Which keys of the TrigCompositeContainer WriteHandleKeyArray might need to have their (e.g. feature) element links re-mapped outside of views"}
 
SG::WriteDecorHandleKeyArray< xAOD::TrigCompositeContainer, std::vector< SG::sgkey_t > > m_remapLinkColKeys { this, "DoNotSet_RemapLinkColKeys", {}, "Do not set, it is configured accordingly to FixLinks & TC output property"}
 
SG::WriteDecorHandleKeyArray< xAOD::TrigCompositeContainer, std::vector< xAOD::TrigComposite::index_type > > m_remapLinkColIndices { this, "DoNotSet_RemapLinkColIndices", {}, "Do not set, it is configured accordingly to FixLinks & TC output property"}
 
Gaudi::Property< bool > m_dumpSGBefore { this, "dumpSGBefore", false, "Dump SG content before the merging"}
 
Gaudi::Property< bool > m_dumpSGAfter { this, "dumpSGAfter", false, "Dump SG content after the merging"}
 

Detailed Description

Tool capable of creating collections missing (early rejection) after HLT processing. It declares output handles for all possible collections produced by the trigger.

to add more classes follow these steps: 1) add EDM pkg in CMakeLists 2) add includes in this file 3) add DEF_*_KEY here 4) initialise it in initialize method (in cxx file) 5) add create in the createOutput 6) test

Definition at line 127 of file HLTEDMCreator.h.

Constructor & Destructor Documentation

◆ HLTEDMCreator() [1/2]

HLTEDMCreator::HLTEDMCreator ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 13 of file HLTEDMCreator.cxx.

16  : base_class( type, name, parent ) {}

◆ ~HLTEDMCreator()

virtual HLTEDMCreator::~HLTEDMCreator ( )
overridevirtualdefault

◆ HLTEDMCreator() [2/2]

HLTEDMCreator::HLTEDMCreator ( )
private

Member Function Documentation

◆ createIfMissing()

template<typename T , typename STORE , typename G , typename M >
StatusCode HLTEDMCreator::createIfMissing ( const EventContext &  context,
const ConstHandlesGroup< T > &  handles,
G generator,
merger 
) const
private

Definition at line 297 of file HLTEDMCreator.cxx.

297  {
298 
299  for (size_t i = 0; i < handles.out.size(); ++i) {
300  SG::WriteHandleKey<T> writeHandleKey = handles.out.at(i);
301 
302  if ( handles.views.empty() ) { // no merging will be needed
303  // Note: This is correct. We are testing if we can read, and if we cannot then we write.
304  // What we write will either be a dummy (empty) container, or be populated from N in-View collections.
305  SG::ReadHandle<T> readHandle( writeHandleKey.key() );
306  if ( readHandle.isValid() ) {
307  ATH_MSG_VERBOSE( writeHandleKey.key() << " is already present" );
308  generator.create(false, false);
309 
310  // For xAOD types we need to ensure there is an Aux store. This can happen if the
311  // Aux store gets truncated for collections marked with "allowTruncation".
312  // The TriggerEDMDeserialiserAlg will already have created a DataLink to the Aux store
313  // for the interface container. Now we just need to create an empty Aux store.
314  if constexpr (!std::is_void_v<STORE>) {
315  SG::ReadHandle<STORE> readAuxHandle( writeHandleKey.key() + "Aux." );
316  if ( !readAuxHandle.isValid() ) {
317  SG::WriteHandle<STORE> writeAuxHandle( writeHandleKey.key() + "Aux." );
318  ATH_MSG_DEBUG("Creating missing Aux store for " << writeHandleKey.key());
319  ATH_CHECK( writeAuxHandle.record(std::make_unique<STORE>()) );
320  }
321  }
322  } else {
323  ATH_MSG_DEBUG( writeHandleKey.key() << " is missing, creating it" );
324  generator.create(true, true);
325  }
326 
327  } else {
328  // there are views, we assume that in the main store collection of given type#name is absent, else it will not work anyways
329  // simplest case, only one set of views is handled first
330  // below is handled the cases when the configuration of output keys is for example: A A B C C C D D E
331  // which means the first two collections come from first two views and because the names are the same they should end up in the same output collection
332  // thefore generators need to instructed to:
333  // - create new collection when a new name is handled (or for the first key)
334  // - and record when it is last identical name in the row (or it is last handled collection)
335  if ( handles.out.size() == 1 ) {
336  generator.create(true, true);
337  } else {
338  const bool doCreate = i == 0 or handles.out.at(i-1).key() != handles.out.at(i).key();
339  const bool doRecord = i == handles.out.size()-1 or handles.out.at(i+1).key() != handles.out.at(i).key();
340  ATH_MSG_DEBUG( "Instructing generator " << (doCreate ? "to" : "NOT TO") << " create collection and " << (doRecord ? "to" : "NOT TO") << " record collection in this iteration");
341  generator.create(doCreate, doRecord);
342  }
343 
344  SG::ReadHandleKey<ViewContainer> viewsReadHandleKey = handles.views.at(i);
345  ATH_MSG_DEBUG("Will be trying to merge from the " << viewsReadHandleKey.key() << " view container into that output");
346 
347  auto viewsHandle = SG::makeHandle( viewsReadHandleKey, context );
348  if ( viewsHandle.isValid() ) {
349  SG::ReadHandleKey<T> inViewReadHandleKey = handles.in.at(i);
350  ATH_MSG_DEBUG("Will be merging from " << viewsHandle->size() << " views using in-view key " << inViewReadHandleKey.key() );
351  ATH_CHECK( (this->*merger)( *viewsHandle, inViewReadHandleKey , context, *generator.data.get() ) );
352  } else {
353  ATH_MSG_DEBUG("Views " << viewsReadHandleKey.key() << " are missing. Will leave " << writeHandleKey.key() << " output collection empty.");
354  }
355 
356  // Also consider probe variants of each EventView.
357  // Not every container will have a corresponding set of (typically) lower-pT probe ROIs, but it's safer to always test.
358  static const std::string probe_suffix = "_probe";
359  const std::string viewsReadHandleKeyProbe = viewsReadHandleKey.key() + probe_suffix;
360  ATH_MSG_VERBOSE("Will try to merge from the " << viewsReadHandleKeyProbe << " view container into that output");
361 
362  // Falling back to direct SG access here to avoid uninitiated key errors. This is safe to do in the context of the Trigger ControlFlow.
363  // I.e. if this collection is to exist in this event, then it is guaranteed to have been produced prior to this alg executing.
364  const ViewContainer* viewsContainer_probe = nullptr;
365  if (evtStore()->contains<ViewContainer>(viewsReadHandleKeyProbe)) {
366  ATH_CHECK(evtStore()->retrieve(viewsContainer_probe, viewsReadHandleKeyProbe));
367  }
368  if ( viewsContainer_probe ) {
369  SG::ReadHandleKey<T> inViewReadHandleKey = handles.in.at(i);
370  ATH_MSG_DEBUG("Will be merging from " << viewsContainer_probe->size() << " probe views using in-view key " << inViewReadHandleKey.key() );
371  ATH_CHECK( (this->*merger)( *viewsContainer_probe, inViewReadHandleKey , context, *generator.data.get() ) );
372  } else {
373  ATH_MSG_VERBOSE("Probe views " << viewsReadHandleKeyProbe << " are missing.");
374  }
375 
376  }
377 
378  auto writeHandle = SG::makeHandle( writeHandleKey, context );
379  ATH_CHECK( generator.record( writeHandle ) );
380  }
381 
382  return StatusCode::SUCCESS;
383 }

◆ createOutput()

StatusCode HLTEDMCreator::createOutput ( const EventContext &  context) const
overridevirtual

Definition at line 387 of file HLTEDMCreator.cxx.

387  {
388  ATH_MSG_DEBUG("Confirming / Creating this tool's output");
389  if ( m_dumpSGBefore )
390  ATH_MSG_DEBUG( evtStore()->dump() );
391 
392 #define CREATE(__TYPE) \
393  { \
394  plainGenerator<__TYPE> generator; \
395  ATH_CHECK( (createIfMissing<__TYPE, void>( context, ConstHandlesGroup<__TYPE>( m_##__TYPE, m_##__TYPE##InViews, m_##__TYPE##Views ), generator, &HLTEDMCreator::noMerge<__TYPE>)) ); \
396  }
397 
399 
400 #undef CREATE
401 
402 #define CREATE_XAOD(__TYPE, __STORE_TYPE) \
403  { \
404  xAODGenerator<xAOD::__TYPE, xAOD::__STORE_TYPE> generator; \
405  ATH_CHECK( (createIfMissing<xAOD::__TYPE, xAOD::__STORE_TYPE>( context, ConstHandlesGroup<xAOD::__TYPE>( m_##__TYPE, m_##__TYPE##InViews, m_##__TYPE##Views ), generator, &HLTEDMCreator::viewsMerge<xAOD::__TYPE>)) ); \
406  }
407 
408 
419 
426  CREATE_XAOD( CaloClusterContainer, CaloClusterTrigAuxContainer ); // NOTE: Difference in interface and aux
440 
441  // Phase-I L1 RoIs EDM
453 
454  // After view collections are merged, need to update collection links
455  ATH_CHECK( fixLinks() );
456 
457 #undef CREATE_XAOD
458 
459  // special cases
460  #define CREATE_SHALLOW(__TYPE) \
461  { \
462  for ( size_t index = 0; index < m_##__TYPE##ShallowCopy.size(); ++index ){ \
463  auto readHandle = SG::makeHandle<xAOD::__TYPE> ( m_##__TYPE##ShallowCopy[index], context ); \
464  if ( not readHandle.isValid() ) { \
465  ATH_MSG_DEBUG( "Creating missing "#__TYPE"ShallowCopy " << m_##__TYPE##ShallowCopy[index].key() ); \
466  auto writeHandle = SG::makeHandle( m_##__TYPE##ShallowCopyOut[index], context ); \
467  ATH_CHECK( writeHandle.record( std::make_unique<xAOD::__TYPE>(), std::make_unique<xAOD::ShallowAuxContainer>() )); \
468  } else { \
469  ATH_MSG_DEBUG( #__TYPE"ShallowCopy " << m_##__TYPE##ShallowCopyOut[index].key() << " present in the event, done nothing"); \
470  } \
471  } \
472  }
473 
476 
477  #undef CREATE_SHALLOW
478 
479  if ( m_dumpSGAfter )
480  ATH_MSG_DEBUG( evtStore()->dump() );
481 
482  ATH_MSG_DEBUG("Done");
483  return StatusCode::SUCCESS;
484 }

◆ DEF_KEY()

HLTEDMCreator::DEF_KEY ( TrigRoiDescriptorCollection  )
private

◆ DEF_XAOD_KEY() [1/41]

HLTEDMCreator::DEF_XAOD_KEY ( AFPProtonContainer  )
private

◆ DEF_XAOD_KEY() [2/41]

HLTEDMCreator::DEF_XAOD_KEY ( AFPSiHitsClusterContainer  )
private

◆ DEF_XAOD_KEY() [3/41]

HLTEDMCreator::DEF_XAOD_KEY ( AFPToFTrackContainer  )
private

◆ DEF_XAOD_KEY() [4/41]

HLTEDMCreator::DEF_XAOD_KEY ( AFPTrackContainer  )
private

◆ DEF_XAOD_KEY() [5/41]

HLTEDMCreator::DEF_XAOD_KEY ( AFPVertexContainer  )
private

◆ DEF_XAOD_KEY() [6/41]

HLTEDMCreator::DEF_XAOD_KEY ( BTaggingContainer  )
private

◆ DEF_XAOD_KEY() [7/41]

HLTEDMCreator::DEF_XAOD_KEY ( BTagVertexContainer  )
private

◆ DEF_XAOD_KEY() [8/41]

HLTEDMCreator::DEF_XAOD_KEY ( CaloClusterContainer  )
private

◆ DEF_XAOD_KEY() [9/41]

HLTEDMCreator::DEF_XAOD_KEY ( eFexEMRoIContainer  )
private

◆ DEF_XAOD_KEY() [10/41]

HLTEDMCreator::DEF_XAOD_KEY ( eFexTauRoIContainer  )
private

◆ DEF_XAOD_KEY() [11/41]

HLTEDMCreator::DEF_XAOD_KEY ( ElectronContainer  )
private

◆ DEF_XAOD_KEY() [12/41]

HLTEDMCreator::DEF_XAOD_KEY ( gFexGlobalRoIContainer  )
private

◆ DEF_XAOD_KEY() [13/41]

HLTEDMCreator::DEF_XAOD_KEY ( gFexJetRoIContainer  )
private

◆ DEF_XAOD_KEY() [14/41]

HLTEDMCreator::DEF_XAOD_KEY ( HIEventShapeContainer  )
private

◆ DEF_XAOD_KEY() [15/41]

HLTEDMCreator::DEF_XAOD_KEY ( JetContainer  )
private

◆ DEF_XAOD_KEY() [16/41]

HLTEDMCreator::DEF_XAOD_KEY ( jFexFwdElRoIContainer  )
private

◆ DEF_XAOD_KEY() [17/41]

HLTEDMCreator::DEF_XAOD_KEY ( jFexLRJetRoIContainer  )
private

◆ DEF_XAOD_KEY() [18/41]

HLTEDMCreator::DEF_XAOD_KEY ( jFexMETRoIContainer  )
private

◆ DEF_XAOD_KEY() [19/41]

HLTEDMCreator::DEF_XAOD_KEY ( jFexSRJetRoIContainer  )
private

◆ DEF_XAOD_KEY() [20/41]

HLTEDMCreator::DEF_XAOD_KEY ( jFexSumETRoIContainer  )
private

◆ DEF_XAOD_KEY() [21/41]

HLTEDMCreator::DEF_XAOD_KEY ( jFexTauRoIContainer  )
private

◆ DEF_XAOD_KEY() [22/41]

HLTEDMCreator::DEF_XAOD_KEY ( L2CombinedMuonContainer  )
private

◆ DEF_XAOD_KEY() [23/41]

HLTEDMCreator::DEF_XAOD_KEY ( L2IsoMuonContainer  )
private

◆ DEF_XAOD_KEY() [24/41]

HLTEDMCreator::DEF_XAOD_KEY ( L2StandAloneMuonContainer  )
private

◆ DEF_XAOD_KEY() [25/41]

HLTEDMCreator::DEF_XAOD_KEY ( MuonContainer  )
private

◆ DEF_XAOD_KEY() [26/41]

HLTEDMCreator::DEF_XAOD_KEY ( MuonRoIContainer  )
private

◆ DEF_XAOD_KEY() [27/41]

HLTEDMCreator::DEF_XAOD_KEY ( PhotonContainer  )
private

◆ DEF_XAOD_KEY() [28/41]

HLTEDMCreator::DEF_XAOD_KEY ( TauJetContainer  )
private

◆ DEF_XAOD_KEY() [29/41]

HLTEDMCreator::DEF_XAOD_KEY ( TauTrackContainer  )
private

◆ DEF_XAOD_KEY() [30/41]

HLTEDMCreator::DEF_XAOD_KEY ( TrackParticleContainer  )
private

◆ DEF_XAOD_KEY() [31/41]

HLTEDMCreator::DEF_XAOD_KEY ( TrigBphysContainer  )
private

◆ DEF_XAOD_KEY() [32/41]

HLTEDMCreator::DEF_XAOD_KEY ( TrigCaloClusterContainer  )
private

◆ DEF_XAOD_KEY() [33/41]

HLTEDMCreator::DEF_XAOD_KEY ( TrigCompositeContainer  )
private

◆ DEF_XAOD_KEY() [34/41]

HLTEDMCreator::DEF_XAOD_KEY ( TrigElectronContainer  )
private

◆ DEF_XAOD_KEY() [35/41]

HLTEDMCreator::DEF_XAOD_KEY ( TrigEMClusterContainer  )
private

◆ DEF_XAOD_KEY() [36/41]

HLTEDMCreator::DEF_XAOD_KEY ( TrigMissingETContainer  )
private

◆ DEF_XAOD_KEY() [37/41]

HLTEDMCreator::DEF_XAOD_KEY ( TrigPhotonContainer  )
private

◆ DEF_XAOD_KEY() [38/41]

HLTEDMCreator::DEF_XAOD_KEY ( TrigRingerRingsContainer  )
private

◆ DEF_XAOD_KEY() [39/41]

HLTEDMCreator::DEF_XAOD_KEY ( TrigRNNOutputContainer  )
private

◆ DEF_XAOD_KEY() [40/41]

HLTEDMCreator::DEF_XAOD_KEY ( TrigT2MbtsBitsContainer  )
private

◆ DEF_XAOD_KEY() [41/41]

HLTEDMCreator::DEF_XAOD_KEY ( VertexContainer  )
private

◆ DEF_XAOD_KEY_SHALLOW() [1/2]

HLTEDMCreator::DEF_XAOD_KEY_SHALLOW ( CaloClusterContainer  )
private

◆ DEF_XAOD_KEY_SHALLOW() [2/2]

HLTEDMCreator::DEF_XAOD_KEY_SHALLOW ( JetContainer  )
private

◆ fixLinks()

StatusCode HLTEDMCreator::fixLinks ( ) const
private

Definition at line 213 of file HLTEDMCreator.cxx.

213  {
214  if ( m_fixLinks.value().empty() ) {
215  ATH_MSG_DEBUG("fixLinks: No collections defined for this tool");
216  return StatusCode::SUCCESS;
217  }
218 
219  ATH_MSG_DEBUG("fixLinks called for " << m_fixLinks.size() << " of " << m_TrigCompositeContainer.size() << " collections");
220 
221  // Do the remapping
222  int writeHandleArrayIndex = -1;
223  for ( const auto& writeHandleKey: m_TrigCompositeContainer ) {
224  // Check if we are re-mapping this handle
225  const bool doFixLinks = std::any_of(m_fixLinks.begin(), m_fixLinks.end(), [&](const std::string& s) { return s == writeHandleKey.key(); } );
226  if ( not doFixLinks ) {
227  ATH_MSG_DEBUG("Not requested to fix TrigComposite ElementLinks for " << writeHandleKey.key());
228  continue;
229  }
230 
231  // Only increment this index for the sub-set of the TrigComposite collections that we are fixing. Mirror the initialize() logic.
232  ++writeHandleArrayIndex;
233 
234  ATH_MSG_DEBUG("Fixing links: confirm collection is there: " << writeHandleKey.key() << ", write handle array index: " << writeHandleArrayIndex);
235  SG::ReadHandle<xAOD::TrigCompositeContainer> readHandle( writeHandleKey.key() );
236  if ( not readHandle.isValid() ) { // object missing, this is now an error as we should have literally just created it
237  ATH_MSG_ERROR(" Collection is not present. " << writeHandleKey.key() << " should have been created by createIfMissing.");
238  return StatusCode::FAILURE;
239  }
240 
241  ATH_MSG_DEBUG("Collection exists with size " << readHandle->size() << " Decision objects" );
242  ATH_MSG_DEBUG("Adding decorations: " << m_remapLinkColKeys.at( writeHandleArrayIndex ).key() << " and " << m_remapLinkColIndices.at( writeHandleArrayIndex ).key() );
243 
246 
247  // Examine each input TC
248  int decisionObjectIndex = -1;
249  for ( auto inputDecision : *( readHandle.cptr() ) ) {
250  ++decisionObjectIndex;
251 
252  // Retrieve the link information for remapping
253  std::vector< SG::sgkey_t > remappedKeys = inputDecision->linkColKeys(); // Vec copy
254  std::vector< xAOD::TrigComposite::index_type > remappedIndexes = inputDecision->linkColIndices(); // Vec copy
255 
256  // Search the linked collections for remapping
257  size_t const collectionTotal = inputDecision->linkColNames().size();
258  ATH_MSG_DEBUG(" Decision object #" << decisionObjectIndex << " has " << collectionTotal << " links");
259  for ( size_t elementLinkIndex = 0; elementLinkIndex < collectionTotal; ++elementLinkIndex ) {
260 
261  // Load ElementLink identifiers (except for CLID)
262  std::string const collectionName = inputDecision->linkColNames().at(elementLinkIndex);
263  SG::sgkey_t const collectionKey = remappedKeys.at(elementLinkIndex); //Note: This is the existing before-remap key
264  std::string const keyString = *( evtStore()->keyToString( collectionKey ) );
265  xAOD::TrigComposite::index_type const collectionIndex = remappedIndexes.at(elementLinkIndex); //Note: This is the existing before-remap index
266 
267  // Check for remapping in a merge
268  SG::sgkey_t newKey = 0;
269  size_t newIndex = 0;
270  bool isRemapped = evtStore()->tryELRemap( collectionKey, collectionIndex, newKey, newIndex);
271  if ( isRemapped ) {
272 
273  ATH_MSG_DEBUG( " Remap link [" << collectionName <<"] from " << keyString << " to " << *( evtStore()->keyToString( newKey ) ) << ", from index " << collectionIndex << " to index " << newIndex );
274  remappedKeys[ elementLinkIndex ] = newKey;
275  remappedIndexes[ elementLinkIndex ] = newIndex;
276 
277  } else {
278 
279  ATH_MSG_DEBUG( " StoreGate did not remap link [" << collectionName << "] from " << keyString << " index " << collectionIndex );
280 
281  }
282 
283  }
284 
285  // Save the remaps
286  keyDecor( *inputDecision ) = remappedKeys;
287  indexDecor( *inputDecision ) = remappedIndexes;
288 
289  }
290  }
291 
292  return StatusCode::SUCCESS;
293 }

◆ initAuxKey()

template<typename T >
StatusCode HLTEDMCreator::initAuxKey ( const std::vector< SG::VarHandleKey * > &  keys)
private

Register AuxStore keys for the given keys.

This is required to avoid hash collisions (ATR-26386).

Definition at line 39 of file HLTEDMCreator.cxx.

39  {
40  // Register Aux keys for all handles to avoid hash collisions (ATR-26386).
41  for (const SG::VarHandleKey* k : keys) {
42  SG::WriteHandleKey<T> auxkey(k->key()+"Aux.");
43  ATH_CHECK( auxkey.initialize() );
44  }
45  return StatusCode::SUCCESS;
46 }

◆ initHandles()

template<typename T >
StatusCode HLTEDMCreator::initHandles ( const HandlesGroup< T > &  handles)
private

Init related handles.

Fails when they are setup inconsistently: the only allowed setup is: views and in empty - then out can be of any length - this is mode to fill missing containers views and in not empty, have to be the same size - out has to be 1 - this mode is for merging from several views into one output if merging from several views into several separate output containers is required another instance of that tool can be setup

Definition at line 19 of file HLTEDMCreator.cxx.

19  {
20  ATH_CHECK( handles.out.initialize() );
21  renounceArray( handles.out );
22  ATH_CHECK( handles.in.initialize() );
23  renounceArray( handles.in );
24  ATH_CHECK( handles.views.initialize() );
25  renounceArray( handles.views );
26 
27  // the case w/o reading from views, both views handles and collection in views should be empty
28  if ( handles.views.empty() ) {
29  ATH_CHECK( handles.in.empty() );
30  } else {
31  // the case with views, for every output we expect an input View and an input collection inside that View
32  ATH_CHECK( handles.out.size() == handles.in.size() );
33  ATH_CHECK( handles.in.size() == handles.views.size() );
34  }
35  return StatusCode::SUCCESS;
36 }

◆ initialize()

StatusCode HLTEDMCreator::initialize ( )
overridevirtual

Definition at line 49 of file HLTEDMCreator.cxx.

50 {
51  if ( m_fixLinks.size() > 0 ) {
52  // Confirm that m_fixLinks is a sub-set of m_TrigCompositeContainer
53  for (const std::string& entry : m_fixLinks) {
54  const bool found = std::any_of(m_TrigCompositeContainer.begin(),
55  m_TrigCompositeContainer.end(), [&](const auto& writeHandleKey) { return writeHandleKey.key() == entry; } );
56  if (!found) {
57  ATH_MSG_ERROR("FixLinks contains the entry " << entry << ", however this is not one of this EDMCreator tool's managed TrigCompositeContainers.");
58  ATH_MSG_ERROR("Configure FixLinks to be a sub-set of TrigCompositeContainer");
59  return StatusCode::FAILURE;
60  }
61  }
62  // Set up the write decorate handles to hold the remapped data
63  for ( const auto& writeHandleKey: m_TrigCompositeContainer ) {
64  const bool doFixLinks = std::any_of(m_fixLinks.begin(), m_fixLinks.end(), [&](const std::string& s) { return s == writeHandleKey.key(); } );
65  if (doFixLinks) {
66  // This writeHandleKey is being included in the element link remapping
67  m_remapLinkColKeys.emplace_back( writeHandleKey.key()+".remap_linkColKeys" );
68  m_remapLinkColIndices.emplace_back( writeHandleKey.key()+".remap_linkColIndices" );
69  }
70  }
71  ATH_CHECK( m_remapLinkColKeys.initialize() ) ;
72  renounceArray( m_remapLinkColKeys ); // This is not strictly necessary however, since we have many of these collection and no consumer for it we can spare scheduler headache renouncing them
73  ATH_CHECK( m_remapLinkColIndices.initialize() );
74  renounceArray( m_remapLinkColIndices );
75  }
76 
77  // this section has to appear after the above initialisation of DecorHandles, else the renounce of TrigComposite does not work as expected
78 
79 #define INIT(__TYPE) \
80  ATH_CHECK( initHandles( HandlesGroup<__TYPE>( m_##__TYPE, m_##__TYPE##InViews, m_##__TYPE##Views ) ) );
81 
82 #define INIT_XAOD(__TYPE, __STORE_TYPE) \
83  ATH_CHECK( initHandles( HandlesGroup<xAOD::__TYPE>( m_##__TYPE, m_##__TYPE##InViews, m_##__TYPE##Views ) ) ); \
84  ATH_CHECK( initAuxKey<xAOD::__STORE_TYPE>( m_##__TYPE.keys() ) );
85 
88 
98 
110  INIT_XAOD( CaloClusterContainer, CaloClusterTrigAuxContainer ); // NOTE: Difference in interface and aux
119 
120  // Phase-I L1 RoIs EDM
132 
133 #undef INIT
134 #undef INIT_XAOD
135 
136 #define INIT_SHALLOW(__TYPE) \
137  ATH_CHECK( m_##__TYPE##ShallowCopy.initialize() ); \
138  renounceArray( m_##__TYPE##ShallowCopy ); \
139  for ( auto k: m_##__TYPE##ShallowCopy ) \
140  m_##__TYPE##ShallowCopyOut.push_back(k.key()); \
141  ATH_CHECK( m_##__TYPE##ShallowCopyOut.initialize() ); \
142  renounceArray( m_##__TYPE##ShallowCopyOut )
143 
146 
147 #undef INIT_SHALLOW
148 
149  return StatusCode::SUCCESS;
150 }

◆ noMerge()

template<typename T >
StatusCode HLTEDMCreator::noMerge ( ViewContainer const views,
const SG::ReadHandleKey< T > &  inViewKey,
EventContext const context,
T &  output 
) const
private

Definition at line 192 of file HLTEDMCreator.cxx.

193  {
194  // if we are called it means views merging is requested but Type T does not support it (i.e. missing copy c'tor)
195  return StatusCode::FAILURE;
196 
197 }

◆ viewsMerge()

template<typename T >
StatusCode HLTEDMCreator::viewsMerge ( ViewContainer const views,
const SG::ReadHandleKey< T > &  inViewKey,
EventContext const context,
T &  output 
) const
private

Definition at line 200 of file HLTEDMCreator.cxx.

201  {
202 
203  using type_in_container = typename T::base_value_type;
204  StoreGateSvc* sg = evtStore().operator->(); // why the get() method is returing a null ptr is a puzzle, we have to use this ugly call to operator instead of it
205  ATH_CHECK( sg != nullptr );
206  ViewHelper::ViewMerger merger( sg, msg() );
207  ATH_CHECK( merger.mergeViewCollection<type_in_container>( views, inViewKey, context, output ) );
208 
209  return StatusCode::SUCCESS;
210 }

Member Data Documentation

◆ m_dumpSGAfter

Gaudi::Property<bool> HLTEDMCreator::m_dumpSGAfter { this, "dumpSGAfter", false, "Dump SG content after the merging"}
private

Definition at line 146 of file HLTEDMCreator.h.

◆ m_dumpSGBefore

Gaudi::Property<bool> HLTEDMCreator::m_dumpSGBefore { this, "dumpSGBefore", false, "Dump SG content before the merging"}
private

Definition at line 145 of file HLTEDMCreator.h.

◆ m_fixLinks

Gaudi::Property<std::vector<std::string> > HLTEDMCreator::m_fixLinks { this, "FixLinks", {}, "Which keys of the TrigCompositeContainer WriteHandleKeyArray might need to have their (e.g. feature) element links re-mapped outside of views"}
private

Definition at line 141 of file HLTEDMCreator.h.

◆ m_remapLinkColIndices

SG::WriteDecorHandleKeyArray<xAOD::TrigCompositeContainer, std::vector<xAOD::TrigComposite::index_type> > HLTEDMCreator::m_remapLinkColIndices { this, "DoNotSet_RemapLinkColIndices", {}, "Do not set, it is configured accordingly to FixLinks & TC output property"}
private

Definition at line 143 of file HLTEDMCreator.h.

◆ m_remapLinkColKeys

SG::WriteDecorHandleKeyArray<xAOD::TrigCompositeContainer, std::vector<SG::sgkey_t> > HLTEDMCreator::m_remapLinkColKeys { this, "DoNotSet_RemapLinkColKeys", {}, "Do not set, it is configured accordingly to FixLinks & TC output property"}
private

Definition at line 142 of file HLTEDMCreator.h.


The documentation for this class was generated from the following files:
HLTEDMCreator::m_fixLinks
Gaudi::Property< std::vector< std::string > > m_fixLinks
Definition: HLTEDMCreator.h:141
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::AFPToFTrackContainer
AFPToFTrackContainer_v1 AFPToFTrackContainer
Definition: AFPToFTrackContainer.h:12
xAOD::AFPProtonContainer
AFPProtonContainer_v1 AFPProtonContainer
Definition: AFPProtonContainer.h:11
HLTEDMCreator::m_dumpSGBefore
Gaudi::Property< bool > m_dumpSGBefore
Definition: HLTEDMCreator.h:145
HLTEDMCreator::m_remapLinkColKeys
SG::WriteDecorHandleKeyArray< xAOD::TrigCompositeContainer, std::vector< SG::sgkey_t > > m_remapLinkColKeys
Definition: HLTEDMCreator.h:142
xAOD::TrigElectronAuxContainer
TrigElectronAuxContainer_v1 TrigElectronAuxContainer
Declare the latest version of the auxiliary container.
Definition: TrigElectronAuxContainer.h:16
xAOD::AFPVertexContainer
AFPVertexContainer_v1 AFPVertexContainer
Definition: AFPVertexContainer.h:12
INIT
#define INIT(__TYPE)
xAOD::BTaggingAuxContainer
BTaggingAuxContainer_v2 BTaggingAuxContainer
Definition of the current BTagging auxiliary container.
Definition: BTaggingAuxContainer.h:22
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
xAOD::jFexTauRoIContainer
jFexTauRoIContainer_v1 jFexTauRoIContainer
Definition: jFexTauRoIContainer.h:13
xAOD::jFexSumETRoIContainer
jFexSumETRoIContainer_v1 jFexSumETRoIContainer
Definition: jFexSumETRoIContainer.h:13
xAOD::HIEventShapeAuxContainer
HIEventShapeAuxContainer_v2 HIEventShapeAuxContainer
Define the latest version of the auxiliary container.
Definition: HIEventShapeAuxContainer.h:16
xAOD::TauTrackContainer
TauTrackContainer_v1 TauTrackContainer
Definition of the current TauTrack container version.
Definition: TauTrackContainer.h:16
xAOD::MuonContainer
MuonContainer_v1 MuonContainer
Definition of the current "Muon container version".
Definition: Event/xAOD/xAODMuon/xAODMuon/MuonContainer.h:14
xAOD::JetAuxContainer
JetAuxContainer_v1 JetAuxContainer
Definition of the current jet auxiliary container.
Definition: JetAuxContainer.h:22
AthCUDAExamples::TrackParticleContainer
vecmem::edm::container< TrackParticleInterface, vecmem::edm::type::vector< float >, vecmem::edm::type::vector< float >, vecmem::edm::type::vector< float > > TrackParticleContainer
SoA, GPU friendly TrackParticleContainer.
Definition: Control/AthenaExamples/AthExCUDA/src/TrackParticleContainer.h:46
xAOD::BTagVertexContainer
BTagVertexContainer_v1 BTagVertexContainer
Definition of the current "BTagging container version".
Definition: BTagVertexContainer.h:17
xAOD::TauJetAuxContainer
TauJetAuxContainer_v3 TauJetAuxContainer
Definition of the current taujet auxiliary container.
Definition: TauJetAuxContainer.h:22
xAOD::jFexSRJetRoIContainer
jFexSRJetRoIContainer_v1 jFexSRJetRoIContainer
Definition: jFexSRJetRoIContainer.h:13
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
CaloClusterContainer
Storable container for CaloCluster.
Definition: Calorimeter/CaloEvent/CaloEvent/CaloClusterContainer.h:37
CREATE_XAOD
#define CREATE_XAOD(__TYPE, __STORE_TYPE)
xAOD::jFexMETRoIContainer
jFexMETRoIContainer_v1 jFexMETRoIContainer
Definition: jFexMETRoIContainer.h:13
xAOD::jFexLRJetRoIContainer
jFexLRJetRoIContainer_v1 jFexLRJetRoIContainer
Definition: jFexLRJetRoIContainer.h:13
HLTEDMCreator::fixLinks
StatusCode fixLinks() const
Definition: HLTEDMCreator.cxx:213
xAOD::TrackParticleAuxContainer
TrackParticleAuxContainer_v5 TrackParticleAuxContainer
Definition of the current TrackParticle auxiliary container.
Definition: TrackParticleAuxContainer.h:19
xAOD::jFexFwdElRoIContainer
jFexFwdElRoIContainer_v1 jFexFwdElRoIContainer
Definition: jFexFwdElRoIContainer.h:13
xAOD::gFexJetRoIContainer
gFexJetRoIContainer_v1 gFexJetRoIContainer
Definition: gFexJetRoIContainer.h:15
TrigMissingETContainer
Definition: Trigger/TrigEvent/TrigMissingEtEvent/TrigMissingEtEvent/TrigMissingETContainer.h:12
xAOD::eFexTauRoIContainer
eFexTauRoIContainer_v1 eFexTauRoIContainer
Definition: eFexTauRoIContainer.h:15
xAOD::PhotonAuxContainer
PhotonAuxContainer_v3 PhotonAuxContainer
Definition of the current photon auxiliary container.
Definition: PhotonAuxContainer.h:22
xAOD::TrigEMClusterAuxContainer
TrigEMClusterAuxContainer_v2 TrigEMClusterAuxContainer
Define the latest version of the trigger EM cluster auxiliary container.
Definition: TrigEMClusterAuxContainer.h:16
xAOD::eFexEMRoIAuxContainer
eFexEMRoIAuxContainer_v1 eFexEMRoIAuxContainer
Definition: eFexEMRoIAuxContainer.h:15
xAOD::jFexSumETRoIAuxContainer
jFexSumETRoIAuxContainer_v1 jFexSumETRoIAuxContainer
Definition: jFexSumETRoIAuxContainer.h:12
xAOD::MuonRoIAuxContainer
MuonRoIAuxContainer_v1 MuonRoIAuxContainer
Definition: MuonRoIAuxContainer.h:15
xAOD::TrigCompositeAuxContainer
TrigCompositeAuxContainer_v2 TrigCompositeAuxContainer
Declare the latest version of the container.
Definition: TrigCompositeAuxContainer.h:16
HLTEDMCreator::m_remapLinkColIndices
SG::WriteDecorHandleKeyArray< xAOD::TrigCompositeContainer, std::vector< xAOD::TrigComposite::index_type > > m_remapLinkColIndices
Definition: HLTEDMCreator.h:143
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
SG::ReadHandleKey< ViewContainer >
xAOD::TrigRingerRingsContainer
TrigRingerRingsContainer_v2 TrigRingerRingsContainer
Define the latest version of the TrigRingerRingsContainer class.
Definition: TrigRingerRingsContainer.h:16
TrigEMClusterContainer
Container from TrigEMCluster type objects.
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigEMClusterContainer.h:32
xAOD::AFPTrackAuxContainer
AFPTrackAuxContainer_v2 AFPTrackAuxContainer
Definition: AFPTrackAuxContainer.h:12
xAOD::VertexContainer
VertexContainer_v1 VertexContainer
Definition of the current "Vertex container version".
Definition: VertexContainer.h:14
xAOD::L2StandAloneMuonAuxContainer
L2StandAloneMuonAuxContainer_v2 L2StandAloneMuonAuxContainer
Define the latest version of the muon SA auxiliary container.
Definition: L2StandAloneMuonAuxContainer.h:16
xAOD::TrigT2MbtsBitsAuxContainer
TrigT2MbtsBitsAuxContainer_v1 TrigT2MbtsBitsAuxContainer
Definition: TrigT2MbtsBitsAuxContainer.h:11
PhotonContainer
Definition: Reconstruction/egamma/egammaEvent/egammaEvent/PhotonContainer.h:30
xAOD::jFexSRJetRoIAuxContainer
jFexSRJetRoIAuxContainer_v1 jFexSRJetRoIAuxContainer
Definition: jFexSRJetRoIAuxContainer.h:12
xAOD::TrigRingerRingsAuxContainer
TrigRingerRingsAuxContainer_v2 TrigRingerRingsAuxContainer
Define the latest version of the TrigRingerRings class.
Definition: TrigRingerRingsAuxContainer.h:17
xAOD::TrigPhotonAuxContainer
TrigPhotonAuxContainer_v1 TrigPhotonAuxContainer
Declare the latest version of the photon auxiliary container.
Definition: TrigPhotonAuxContainer.h:16
run_Egamma1_LArStrip_Fex.dump
dump
Definition: run_Egamma1_LArStrip_Fex.py:88
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
StoreGateSvc
The Athena Transient Store API.
Definition: StoreGateSvc.h:125
xAOD::TauTrackAuxContainer
TauTrackAuxContainer_v1 TauTrackAuxContainer
Definition: TauTrackAuxContainer.h:14
TrigT2MbtsBitsContainer
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigT2MbtsBitsContainer.h:13
TrigCompositeContainer
Container from TrigComposite type objects.
Definition: Trigger/TrigEvent/TrigCombinedEvent/TrigCombinedEvent/TrigCompositeContainer.h:25
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::AFPSiHitsClusterAuxContainer
AFPSiHitsClusterAuxContainer_v1 AFPSiHitsClusterAuxContainer
Definition: AFPSiHitsClusterAuxContainer.h:12
SG::WriteHandleKey
Property holding a SG store/key/clid from which a WriteHandle is made.
Definition: StoreGate/StoreGate/WriteHandleKey.h:40
HLTEDMCreator::m_dumpSGAfter
Gaudi::Property< bool > m_dumpSGAfter
Definition: HLTEDMCreator.h:146
xAOD::BTaggingContainer
BTaggingContainer_v1 BTaggingContainer
Definition of the current "BTagging container version".
Definition: BTaggingContainer.h:17
xAOD::VertexAuxContainer
VertexAuxContainer_v1 VertexAuxContainer
Definition of the current jet auxiliary container.
Definition: VertexAuxContainer.h:19
TrigRNNOutputContainer
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigRNNOutputContainer.h:13
lumiFormat.i
int i
Definition: lumiFormat.py:85
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::AFPVertexAuxContainer
AFPVertexAuxContainer_v1 AFPVertexAuxContainer
Definition: AFPVertexAuxContainer.h:12
xAOD::L2StandAloneMuonContainer
L2StandAloneMuonContainer_v2 L2StandAloneMuonContainer
Define the latest version of the muon SA container.
Definition: L2StandAloneMuonContainer.h:17
CREATE_SHALLOW
#define CREATE_SHALLOW(__TYPE)
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:100
xAOD::jFexTauRoIAuxContainer
jFexTauRoIAuxContainer_v1 jFexTauRoIAuxContainer
Definition: jFexTauRoIAuxContainer.h:12
xAOD::BTagVertexAuxContainer
BTagVertexAuxContainer_v1 BTagVertexAuxContainer
Definition of the current BTagging auxiliary container.
Definition: BTagVertexAuxContainer.h:22
test_pyathena.parent
parent
Definition: test_pyathena.py:15
xAOD::jFexLRJetRoIAuxContainer
jFexLRJetRoIAuxContainer_v1 jFexLRJetRoIAuxContainer
Definition: jFexLRJetRoIAuxContainer.h:12
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::TrigMissingETAuxContainer
TrigMissingETAuxContainer_v1 TrigMissingETAuxContainer
Define the most recent version of the AuxContainer for the TrigMissingET object(s).
Definition: TrigMissingETAuxContainer.h:12
xAOD::L2IsoMuonAuxContainer
L2IsoMuonAuxContainer_v1 L2IsoMuonAuxContainer
Define the latest version of the muon Iso auxiliary container.
Definition: L2IsoMuonAuxContainer.h:14
xAOD::ElectronAuxContainer
ElectronAuxContainer_v3 ElectronAuxContainer
Definition of the current electron auxiliary container.
Definition: ElectronAuxContainer.h:22
merge.output
output
Definition: merge.py:17
xAOD::jFexMETRoIAuxContainer
jFexMETRoIAuxContainer_v1 jFexMETRoIAuxContainer
Definition: jFexMETRoIAuxContainer.h:12
xAOD::TrigBphysAuxContainer
TrigBphysAuxContainer_v1 TrigBphysAuxContainer
Definition: TrigBphysAuxContainer.h:12
GetAllXsec.entry
list entry
Definition: GetAllXsec.py:132
xAOD::gFexGlobalRoIContainer
gFexGlobalRoIContainer_v1 gFexGlobalRoIContainer
Definition: gFexGlobalRoIContainer.h:15
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
ViewContainer::size
size_t size() const
Definition: View.h:175
xAOD::TauJetContainer
TauJetContainer_v3 TauJetContainer
Definition of the current "taujet container version".
Definition: Event/xAOD/xAODTau/xAODTau/TauJetContainer.h:17
xAOD::eFexTauRoIAuxContainer
eFexTauRoIAuxContainer_v1 eFexTauRoIAuxContainer
Definition: eFexTauRoIAuxContainer.h:14
xAOD::TrigComposite_v1::index_type
uint32_t index_type
Definition: TrigComposite_v1.h:56
INIT_XAOD
#define INIT_XAOD(__TYPE, __STORE_TYPE)
SG::sgkey_t
uint32_t sgkey_t
Type used for hashed StoreGate key+CLID pairs.
Definition: CxxUtils/CxxUtils/sgkey_t.h:32
xAOD::TrigBphysContainer
TrigBphysContainer_v1 TrigBphysContainer
Definition: TrigBphysContainer.h:12
SG::VarHandleKey
A property holding a SG store/key/clid from which a VarHandle is made.
Definition: StoreGate/StoreGate/VarHandleKey.h:62
xAOD::TrigCaloClusterAuxContainer
TrigCaloClusterAuxContainer_v1 TrigCaloClusterAuxContainer
Define the latest version of the trigger calorimeter cluster auxiliary container.
Definition: TrigCaloClusterAuxContainer.h:16
TrigPhotonContainer
File: TrigPhotonContainer.h.
Definition: Trigger/TrigEvent/TrigParticle/TrigParticle/TrigPhotonContainer.h:32
INIT_SHALLOW
#define INIT_SHALLOW(__TYPE)
xAOD::jFexFwdElRoIAuxContainer
jFexFwdElRoIAuxContainer_v1 jFexFwdElRoIAuxContainer
Definition: jFexFwdElRoIAuxContainer.h:12
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
mc.generator
generator
Configure Herwig7 These are the commands corresponding to what would go into the regular Herwig infil...
Definition: mc.MGH7_FxFx_H71-DEFAULT_test.py:18
xAOD::L2CombinedMuonContainer
L2CombinedMuonContainer_v1 L2CombinedMuonContainer
Define the latest version of the muon CB container.
Definition: L2CombinedMuonContainer.h:15
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
xAOD::CaloClusterTrigAuxContainer
CaloClusterTrigAuxContainer_v1 CaloClusterTrigAuxContainer
Define the latest version of the calorimeter cluster auxiliary container.
Definition: CaloClusterTrigAuxContainer.h:16
TrigRoiDescriptorCollection
Definition: TrigRoiDescriptorCollection.h:21
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
ElectronContainer
Definition: Reconstruction/egamma/egammaEvent/egammaEvent/ElectronContainer.h:32
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
ViewHelper::ViewMerger
Definition: ViewHelper.h:135
xAOD::JetContainer
JetContainer_v1 JetContainer
Definition of the current "jet container version".
Definition: JetContainer.h:17
xAOD::HIEventShapeContainer
HIEventShapeContainer_v2 HIEventShapeContainer
Define the latest version of the container.
Definition: HIEventShapeContainer.h:17
TrigElectronContainer
File: TrigElectronContainer.h.
Definition: Trigger/TrigEvent/TrigParticle/TrigParticle/TrigElectronContainer.h:32
xAOD::TrigRNNOutputAuxContainer
TrigRNNOutputAuxContainer_v2 TrigRNNOutputAuxContainer
Define the latest version of the RingerRings class.
Definition: TrigRNNOutputAuxContainer.h:17
xAOD::MuonAuxContainer
MuonAuxContainer_v5 MuonAuxContainer
Definition of the current Muon auxiliary container.
Definition: MuonAuxContainer.h:19
CREATE
#define CREATE(__TYPE)
xAOD::AFPTrackContainer
AFPTrackContainer_v2 AFPTrackContainer
Definition: AFPTrackContainer.h:12
xAOD::L2CombinedMuonAuxContainer
L2CombinedMuonAuxContainer_v1 L2CombinedMuonAuxContainer
Define the latest version of the muon CB auxiliary container.
Definition: L2CombinedMuonAuxContainer.h:14
xAOD::MuonRoIContainer
MuonRoIContainer_v1 MuonRoIContainer
Definition: MuonRoIContainer.h:16
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
xAOD::gFexGlobalRoIAuxContainer
gFexGlobalRoIAuxContainer_v1 gFexGlobalRoIAuxContainer
Definition: gFexGlobalRoIAuxContainer.h:14
xAOD::AFPProtonAuxContainer
AFPProtonAuxContainer_v1 AFPProtonAuxContainer
Definition: AFPProtonAuxContainer.h:11
TrigCaloClusterContainer
Container from TrigCaloCluster type objects.
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigCaloClusterContainer.h:29
xAOD::gFexJetRoIAuxContainer
gFexJetRoIAuxContainer_v1 gFexJetRoIAuxContainer
Definition: gFexJetRoIAuxContainer.h:14
xAOD::AFPToFTrackAuxContainer
AFPToFTrackAuxContainer_v1 AFPToFTrackAuxContainer
Definition: AFPToFTrackAuxContainer.h:12
xAOD::AFPSiHitsClusterContainer
AFPSiHitsClusterContainer_v1 AFPSiHitsClusterContainer
Definition: AFPSiHitsClusterContainer.h:12
xAOD::eFexEMRoIContainer
eFexEMRoIContainer_v1 eFexEMRoIContainer
Definition: eFexEMRoIContainer.h:16
fitman.k
k
Definition: fitman.py:528
xAOD::L2IsoMuonContainer
L2IsoMuonContainer_v1 L2IsoMuonContainer
Define the latest version of the muon Iso container.
Definition: L2IsoMuonContainer.h:15
ViewContainer
Definition: View.h:158