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 (DiTauJetContainer)
	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 (EventContext const &context) 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"}
Gaudi::Property< bool >	m_renounceOutputs { this, "RenounceOutputs", false, "Renounce outputs so that no algs can become dependent on this tool's output. Done in HLT jobs"}

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 86 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 67 of file HLTEDMCreator.cxx.

  : 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, M  merger  ) const

private

Definition at line 361 of file HLTEDMCreator.cxx.

                                                                                                                                          {
 
  // Declare a ReadHandleKey that we can re-use during the loop for reading.
  SG::ReadHandleKey<T> rhk("temp");
 
  // Same for the Aux store. If there is none (void) this would not compile
  // so we just define a dummy RHK, which will never be used, of type T again.
  using AuxType = std::conditional_t<std::is_void_v<STORE>, T, STORE>;
  SG::ReadHandleKey<AuxType> rhkAux("temp");
 
  ATH_CHECK( rhk.initialize() && rhkAux.initialize() );
 
  for (size_t i = 0; i < handles.out.size(); ++i) {
    const SG::WriteHandleKey<T>& whk = handles.out.at(i);
    rhk = whk.key();  // set the RHK to the same key as the WHK
 
    if ( handles.views.empty() ) { // no merging will be needed
      // Note: This is correct. We are testing if we can read, and if we cannot then we write.
      // What we write will either be a dummy (empty) container, or be populated from N in-View collections.
      auto readHandle = SG::makeHandle( rhk, context );
      if ( readHandle.isValid() ) {
        ATH_MSG_VERBOSE( rhk.key() << " is already present" );
        generator.create(false, false);
 
        // For xAOD types we need to ensure there is an Aux store. This can happen if the
        // Aux store gets truncated for collections marked with "allowTruncation".
        // The TriggerEDMDeserialiserAlg will already have created a DataLink to the Aux store
        // for the interface container. Now we just need to create an empty Aux store.
        if constexpr (!std::is_void_v<STORE>) {
          rhkAux = rhk.key() + "Aux.";
          auto readAuxHandle = SG::makeHandle(rhkAux, context);
          if ( !readAuxHandle.isValid() ) {
            // This is rare so we just create a WH as needed:
            SG::WriteHandle<STORE> writeAuxHandle( rhkAux.key(), context );
            ATH_MSG_DEBUG("Creating missing Aux store for " << rhk.key());
            ATH_CHECK( writeAuxHandle.record(std::make_unique<STORE>()) );
          }
        }
      } else {
        ATH_MSG_DEBUG( rhk.key() << " is missing, creating it" );
        generator.create(true, true);
      }
 
    } else {
      // there are views, we assume that in the main store collection of given type#name is absent, else it will not work anyways
      // simplest case, only one set of views is handled first
      // below is handled the cases when the configuration of output keys is for example: A A B C C C D D E
      // 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
      // thefore generators need to instructed to:
      //   - create new collection when a new name is handled (or for the first key)
      //   - and record when it is last identical name in the row (or it is last handled collection)
      if ( handles.out.size() == 1  ) {
        generator.create(true, true);
      } else  {
        const bool doCreate = i == 0 or handles.out.at(i-1).key() != whk.key();
        const bool doRecord = i == handles.out.size()-1 or handles.out.at(i+1).key() != whk.key();
        ATH_MSG_DEBUG( "Instructing generator " <<  (doCreate ? "to" : "NOT TO") <<  " create collection and " << (doRecord ? "to" : "NOT TO") << " record collection in this iteration");
        generator.create(doCreate, doRecord);
      }
 
      const SG::ReadHandleKey<ViewContainer>& viewsReadHandleKey = handles.views.at(i);
      ATH_MSG_DEBUG("Will be trying to merge from the " << viewsReadHandleKey.key() << " view container into that output");
 
      auto viewsHandle = SG::makeHandle( viewsReadHandleKey, context );
      if ( viewsHandle.isValid() ) {
        const SG::ReadHandleKey<T>& inViewReadHandleKey = handles.in.at(i);
        ATH_MSG_DEBUG("Will be merging from " << viewsHandle->size() << " views using in-view key " << inViewReadHandleKey.key() );
        ATH_CHECK( (this->*merger)( *viewsHandle, inViewReadHandleKey , context, *generator.data.get() ) );
      } else {
        ATH_MSG_DEBUG("Views " << viewsReadHandleKey.key() << " are missing. Will leave " << whk.key() << " output collection empty.");
      }
 
      // Also consider probe variants of each EventView.
      // Not every container will have a corresponding set of (typically) lower-pT probe ROIs, but it's safer to always test.
      const std::string viewsReadHandleKeyProbe = viewsReadHandleKey.key() + "_probe";
      ATH_MSG_VERBOSE("Will try to merge from the " << viewsReadHandleKeyProbe <<  " view container into that output");
 
      // Falling back to direct SG access here to avoid uninitiated key errors. This is safe to do in the context of the Trigger ControlFlow.
      // I.e. if this collection is to exist in this event, then it is guaranteed to have been produced prior to this alg executing.
      const ViewContainer* viewsContainer_probe = nullptr;
      if (evtStore()->contains<ViewContainer>(viewsReadHandleKeyProbe)) {
        ATH_CHECK(evtStore()->retrieve(viewsContainer_probe, viewsReadHandleKeyProbe));
      }
      if ( viewsContainer_probe ) {
        const SG::ReadHandleKey<T>& inViewReadHandleKey = handles.in.at(i);
        ATH_MSG_DEBUG("Will be merging from " << viewsContainer_probe->size() << " probe views using in-view key " << inViewReadHandleKey.key() );
        ATH_CHECK( (this->*merger)( *viewsContainer_probe, inViewReadHandleKey , context, *generator.data.get() ) );
      } else {
        ATH_MSG_VERBOSE("Probe views " << viewsReadHandleKeyProbe << " are missing.");
      }
 
    }
 
    auto writeHandle = SG::makeHandle( whk, context );
    ATH_CHECK( generator.record( writeHandle ) );
  }
 
  return StatusCode::SUCCESS;
}

createOutput()

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

overridevirtual

Definition at line 463 of file HLTEDMCreator.cxx.

                                                                        {
  ATH_MSG_DEBUG("Confirming / Creating this tool's output");
  if ( m_dumpSGBefore )  
    ATH_MSG_DEBUG( evtStore()->dump() );
 
#define CREATE(__TYPE) \
    {                 \
      plainGenerator<__TYPE> generator;         \
      ATH_CHECK( (createIfMissing<__TYPE, void>( context, ConstHandlesGroup<__TYPE>( m_##__TYPE, m_##__TYPE##InViews, m_##__TYPE##Views ), generator, &HLTEDMCreator::noMerge<__TYPE>)) ); \
    }
 
  CREATE( TrigRoiDescriptorCollection )
 
#undef CREATE
 
#define CREATE_XAOD(__TYPE, __STORE_TYPE) \
  { \
    xAODGenerator<xAOD::__TYPE, xAOD::__STORE_TYPE> generator; \
    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>))  ); \
  }
 
 
  CREATE_XAOD( TrigCompositeContainer, TrigCompositeAuxContainer );
  CREATE_XAOD( TrigElectronContainer, TrigElectronAuxContainer );
  CREATE_XAOD( ElectronContainer, ElectronAuxContainer );
  CREATE_XAOD( PhotonContainer, PhotonAuxContainer );
  CREATE_XAOD( TrigPhotonContainer, TrigPhotonAuxContainer );
  CREATE_XAOD( TrigEMClusterContainer, TrigEMClusterAuxContainer );
  CREATE_XAOD( TrigCaloClusterContainer, TrigCaloClusterAuxContainer );
  CREATE_XAOD( TrigRingerRingsContainer, TrigRingerRingsAuxContainer );
  CREATE_XAOD( TrackParticleContainer, TrackParticleAuxContainer );
  CREATE_XAOD( TrigMissingETContainer, TrigMissingETAuxContainer );
 
  CREATE_XAOD( L2StandAloneMuonContainer, L2StandAloneMuonAuxContainer );
  CREATE_XAOD( L2CombinedMuonContainer, L2CombinedMuonAuxContainer );
  CREATE_XAOD( L2IsoMuonContainer, L2IsoMuonAuxContainer );
  CREATE_XAOD( MuonContainer, MuonAuxContainer );
  CREATE_XAOD( TauJetContainer, TauJetAuxContainer );
  CREATE_XAOD( DiTauJetContainer, DiTauJetAuxContainer );
  CREATE_XAOD( TauTrackContainer, TauTrackAuxContainer );
  CREATE_XAOD( CaloClusterContainer, CaloClusterTrigAuxContainer ); // NOTE: Difference in interface and aux
  CREATE_XAOD( JetContainer, JetAuxContainer );
  CREATE_XAOD( VertexContainer,VertexAuxContainer );
  CREATE_XAOD( TrigBphysContainer, TrigBphysAuxContainer );
  CREATE_XAOD( BTaggingContainer,BTaggingAuxContainer );
  CREATE_XAOD( BTagVertexContainer,BTagVertexAuxContainer );
  CREATE_XAOD( TrigT2MbtsBitsContainer, TrigT2MbtsBitsAuxContainer );
  CREATE_XAOD( HIEventShapeContainer, HIEventShapeAuxContainer );
  CREATE_XAOD( TrigRNNOutputContainer, TrigRNNOutputAuxContainer );
  CREATE_XAOD( AFPSiHitsClusterContainer, AFPSiHitsClusterAuxContainer );
  CREATE_XAOD( AFPTrackContainer, AFPTrackAuxContainer );
  CREATE_XAOD( AFPToFTrackContainer, AFPToFTrackAuxContainer );
  CREATE_XAOD( AFPProtonContainer, AFPProtonAuxContainer );
  CREATE_XAOD( AFPVertexContainer, AFPVertexAuxContainer );
 
  // Phase-I L1 RoIs EDM
  CREATE_XAOD( eFexEMRoIContainer, eFexEMRoIAuxContainer );
  CREATE_XAOD( eFexTauRoIContainer, eFexTauRoIAuxContainer );
  CREATE_XAOD( jFexTauRoIContainer, jFexTauRoIAuxContainer );
  CREATE_XAOD( jFexFwdElRoIContainer, jFexFwdElRoIAuxContainer );
  CREATE_XAOD( jFexSRJetRoIContainer, jFexSRJetRoIAuxContainer );
  CREATE_XAOD( jFexLRJetRoIContainer, jFexLRJetRoIAuxContainer );
  CREATE_XAOD( jFexMETRoIContainer, jFexMETRoIAuxContainer );
  CREATE_XAOD( jFexSumETRoIContainer, jFexSumETRoIAuxContainer );
  CREATE_XAOD( gFexJetRoIContainer, gFexJetRoIAuxContainer );
  CREATE_XAOD( gFexGlobalRoIContainer, gFexGlobalRoIAuxContainer);
  CREATE_XAOD( MuonRoIContainer, MuonRoIAuxContainer );
 
  // After view collections are merged, need to update collection links
  ATH_CHECK( fixLinks(context) );
  
#undef CREATE_XAOD
 
  // special cases
  #define CREATE_SHALLOW(__TYPE) \
  { \
    for ( size_t index = 0; index < m_##__TYPE##ShallowCopy.size(); ++index ){ \
      auto readHandle = SG::makeHandle<xAOD::__TYPE> (  m_##__TYPE##ShallowCopy[index], context ); \
      if ( not readHandle.isValid() ) { \
    ATH_MSG_DEBUG( "Creating missing "#__TYPE"ShallowCopy " <<  m_##__TYPE##ShallowCopy[index].key() ); \
    auto writeHandle = SG::makeHandle( m_##__TYPE##ShallowCopyOut[index], context ); \
    ATH_CHECK( writeHandle.record( std::make_unique<xAOD::__TYPE>(), std::make_unique<xAOD::ShallowAuxContainer>() )); \
      } else { \
    ATH_MSG_DEBUG( #__TYPE"ShallowCopy " <<  m_##__TYPE##ShallowCopyOut[index].key() << " present in the event, done nothing"); \
      } \
    } \
  }
 
  CREATE_SHALLOW( CaloClusterContainer )
  CREATE_SHALLOW( JetContainer )
 
  #undef CREATE_SHALLOW
 
  if ( m_dumpSGAfter )  
    ATH_MSG_DEBUG( evtStore()->dump() );
 
  ATH_MSG_DEBUG("Done");
  return StatusCode::SUCCESS;
}

DEF_KEY()

HLTEDMCreator::DEF_KEY ( TrigRoiDescriptorCollection  )

private

DEF_XAOD_KEY() [1/42]

HLTEDMCreator::DEF_XAOD_KEY ( AFPProtonContainer  )

private

DEF_XAOD_KEY() [2/42]

HLTEDMCreator::DEF_XAOD_KEY ( AFPSiHitsClusterContainer  )

private

DEF_XAOD_KEY() [3/42]

HLTEDMCreator::DEF_XAOD_KEY ( AFPToFTrackContainer  )

private

DEF_XAOD_KEY() [4/42]

HLTEDMCreator::DEF_XAOD_KEY ( AFPTrackContainer  )

private

DEF_XAOD_KEY() [5/42]

HLTEDMCreator::DEF_XAOD_KEY ( AFPVertexContainer  )

private

DEF_XAOD_KEY() [6/42]

HLTEDMCreator::DEF_XAOD_KEY ( BTaggingContainer  )

private

DEF_XAOD_KEY() [7/42]

HLTEDMCreator::DEF_XAOD_KEY ( BTagVertexContainer  )

private

DEF_XAOD_KEY() [8/42]

HLTEDMCreator::DEF_XAOD_KEY ( CaloClusterContainer  )

private

DEF_XAOD_KEY() [9/42]

HLTEDMCreator::DEF_XAOD_KEY ( DiTauJetContainer  )

private

DEF_XAOD_KEY() [10/42]

HLTEDMCreator::DEF_XAOD_KEY ( eFexEMRoIContainer  )

private

DEF_XAOD_KEY() [11/42]

HLTEDMCreator::DEF_XAOD_KEY ( eFexTauRoIContainer  )

private

DEF_XAOD_KEY() [12/42]

HLTEDMCreator::DEF_XAOD_KEY ( ElectronContainer  )

private

DEF_XAOD_KEY() [13/42]

HLTEDMCreator::DEF_XAOD_KEY ( gFexGlobalRoIContainer  )

private

DEF_XAOD_KEY() [14/42]

HLTEDMCreator::DEF_XAOD_KEY ( gFexJetRoIContainer  )

private

DEF_XAOD_KEY() [15/42]

HLTEDMCreator::DEF_XAOD_KEY ( HIEventShapeContainer  )

private

DEF_XAOD_KEY() [16/42]

HLTEDMCreator::DEF_XAOD_KEY ( JetContainer  )

private

DEF_XAOD_KEY() [17/42]

HLTEDMCreator::DEF_XAOD_KEY ( jFexFwdElRoIContainer  )

private

DEF_XAOD_KEY() [18/42]

HLTEDMCreator::DEF_XAOD_KEY ( jFexLRJetRoIContainer  )

private

DEF_XAOD_KEY() [19/42]

HLTEDMCreator::DEF_XAOD_KEY ( jFexMETRoIContainer  )

private

DEF_XAOD_KEY() [20/42]

HLTEDMCreator::DEF_XAOD_KEY ( jFexSRJetRoIContainer  )

private

DEF_XAOD_KEY() [21/42]

HLTEDMCreator::DEF_XAOD_KEY ( jFexSumETRoIContainer  )

private

DEF_XAOD_KEY() [22/42]

HLTEDMCreator::DEF_XAOD_KEY ( jFexTauRoIContainer  )

private

DEF_XAOD_KEY() [23/42]

HLTEDMCreator::DEF_XAOD_KEY ( L2CombinedMuonContainer  )

private

DEF_XAOD_KEY() [24/42]

HLTEDMCreator::DEF_XAOD_KEY ( L2IsoMuonContainer  )

private

DEF_XAOD_KEY() [25/42]

HLTEDMCreator::DEF_XAOD_KEY ( L2StandAloneMuonContainer  )

private

DEF_XAOD_KEY() [26/42]

HLTEDMCreator::DEF_XAOD_KEY ( MuonContainer  )

private

DEF_XAOD_KEY() [27/42]

HLTEDMCreator::DEF_XAOD_KEY ( MuonRoIContainer  )

private

DEF_XAOD_KEY() [28/42]

HLTEDMCreator::DEF_XAOD_KEY ( PhotonContainer  )

private

DEF_XAOD_KEY() [29/42]

HLTEDMCreator::DEF_XAOD_KEY ( TauJetContainer  )

private

DEF_XAOD_KEY() [30/42]

HLTEDMCreator::DEF_XAOD_KEY ( TauTrackContainer  )

private

DEF_XAOD_KEY() [31/42]

HLTEDMCreator::DEF_XAOD_KEY ( TrackParticleContainer  )

private

DEF_XAOD_KEY() [32/42]

HLTEDMCreator::DEF_XAOD_KEY ( TrigBphysContainer  )

private

DEF_XAOD_KEY() [33/42]

HLTEDMCreator::DEF_XAOD_KEY ( TrigCaloClusterContainer  )

private

DEF_XAOD_KEY() [34/42]

HLTEDMCreator::DEF_XAOD_KEY ( TrigCompositeContainer  )

private

DEF_XAOD_KEY() [35/42]

HLTEDMCreator::DEF_XAOD_KEY ( TrigElectronContainer  )

private

DEF_XAOD_KEY() [36/42]

HLTEDMCreator::DEF_XAOD_KEY ( TrigEMClusterContainer  )

private

DEF_XAOD_KEY() [37/42]

HLTEDMCreator::DEF_XAOD_KEY ( TrigMissingETContainer  )

private

DEF_XAOD_KEY() [38/42]

HLTEDMCreator::DEF_XAOD_KEY ( TrigPhotonContainer  )

private

DEF_XAOD_KEY() [39/42]

HLTEDMCreator::DEF_XAOD_KEY ( TrigRingerRingsContainer  )

private

DEF_XAOD_KEY() [40/42]

HLTEDMCreator::DEF_XAOD_KEY ( TrigRNNOutputContainer  )

private

DEF_XAOD_KEY() [41/42]

HLTEDMCreator::DEF_XAOD_KEY ( TrigT2MbtsBitsContainer  )

private

DEF_XAOD_KEY() [42/42]

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 ( EventContext const &  context ) const

private

Definition at line 268 of file HLTEDMCreator.cxx.

                                                                      {
  if ( m_fixLinks.value().empty() ) {
    ATH_MSG_DEBUG("fixLinks: No collections defined for this tool");
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG("fixLinks called for " << m_fixLinks.size() << " of " << m_TrigCompositeContainer.size() << " collections");
 
  // Do the remapping
  int writeHandleArrayIndex = -1;
 
  // Create a HandleKey that we can re-use during the loop (slightly better performance)
  SG::ReadHandleKey<xAOD::TrigCompositeContainer> readHandleKey("temp");
  ATH_CHECK( readHandleKey.initialize() );
 
  for ( const auto& writeHandleKey: m_TrigCompositeContainer ) {
    // Check if we are re-mapping this handle
    const bool doFixLinks = std::any_of(m_fixLinks.begin(), m_fixLinks.end(), [&](const std::string& s) { return s == writeHandleKey.key(); } );
    if ( not doFixLinks ) {
      ATH_MSG_DEBUG("Not requested to fix TrigComposite ElementLinks for " << writeHandleKey.key());
      continue;
    }
 
    // Only increment this index for the sub-set of the TrigComposite collections that we are fixing. Mirror the initialize() logic.
    ++writeHandleArrayIndex;
 
    ATH_MSG_DEBUG("Fixing links: confirm collection is there: " << writeHandleKey.key() << ", write handle array index: " << writeHandleArrayIndex);
    // Update key name
    readHandleKey = writeHandleKey.key();
    auto readHandle = SG::makeHandle(readHandleKey, context);
    if ( not readHandle.isValid() ) { // object missing, this is now an error as we should have literally just created it
      ATH_MSG_ERROR("Collection is not present. " << readHandleKey.key() << " should have been created by createIfMissing.");
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_DEBUG("Collection exists with size " << readHandle->size() << " Decision objects" );
    ATH_MSG_DEBUG("Adding decorations: " << m_remapLinkColKeys.at( writeHandleArrayIndex ).key() << " and " << m_remapLinkColIndices.at( writeHandleArrayIndex ).key() );
    
    SG::WriteDecorHandle<xAOD::TrigCompositeContainer, std::vector<SG::sgkey_t> >
      keyDecor(m_remapLinkColKeys.at( writeHandleArrayIndex ), context );
    SG::WriteDecorHandle<xAOD::TrigCompositeContainer, std::vector<xAOD::TrigComposite::index_type> >
      indexDecor( m_remapLinkColIndices.at( writeHandleArrayIndex ), context );
 
    // Examine each input TC
    int decisionObjectIndex = -1;
    for ( auto inputDecision : *( readHandle.cptr() ) ) {
      ++decisionObjectIndex;
 
      // Retrieve the link information for remapping
      std::vector< SG::sgkey_t > remappedKeys = inputDecision->linkColKeys(); // Vec copy
      std::vector< xAOD::TrigComposite::index_type > remappedIndexes = inputDecision->linkColIndices(); // Vec copy
 
      // Search the linked collections for remapping
      size_t const collectionTotal = inputDecision->linkColNames().size();
      ATH_MSG_DEBUG("  Decision object #" << decisionObjectIndex << " has " << collectionTotal << " links");
      for ( size_t elementLinkIndex = 0; elementLinkIndex < collectionTotal; ++elementLinkIndex ) {
 
        // Load ElementLink identifiers (except for CLID)
        std::string const collectionName = inputDecision->linkColNames().at(elementLinkIndex);
        SG::sgkey_t const collectionKey = remappedKeys.at(elementLinkIndex); //Note: This is the existing before-remap key
        std::string const keyString = *( evtStore()->keyToString( collectionKey ) );
        xAOD::TrigComposite::index_type const collectionIndex = remappedIndexes.at(elementLinkIndex); //Note: This is the existing before-remap index
 
        // Check for remapping in a merge
        SG::sgkey_t newKey = 0;
        size_t newIndex = 0;
        bool isRemapped = evtStore()->tryELRemap( collectionKey, collectionIndex, newKey, newIndex);
        if ( isRemapped ) {
 
          ATH_MSG_DEBUG( "    Remap link [" << collectionName <<"] from " << keyString << " to " << *( evtStore()->keyToString( newKey ) ) << ", from index " << collectionIndex << " to index " << newIndex );
          remappedKeys[ elementLinkIndex ] = newKey;
          remappedIndexes[ elementLinkIndex ] = newIndex;
 
        } else {
 
          ATH_MSG_DEBUG( "    StoreGate did not remap link [" << collectionName << "] from  " << keyString << " index " << collectionIndex );
 
        }
 
      }
      
      // Save the remaps
      keyDecor( *inputDecision ) = remappedKeys;
      indexDecor( *inputDecision ) = remappedIndexes;
 
    }    
  }  
  
  return StatusCode::SUCCESS;
}

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 93 of file HLTEDMCreator.cxx.

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

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 73 of file HLTEDMCreator.cxx.

                                                                       {
  ATH_CHECK( handles.out.initialize() );
  if(m_renounceOutputs) { renounceArray( handles.out ); }
  ATH_CHECK( handles.in.initialize() );
  renounceArray( handles.in );
  ATH_CHECK( handles.views.initialize() );
  renounceArray( handles.views );
 
  // the case w/o reading from views, both views handles and collection in views should be empty
  if ( handles.views.empty() ) {
    ATH_CHECK( handles.in.empty() );
  } else {
    // the case with views, for every output we expect an input View and an input collection inside that View
    ATH_CHECK( handles.out.size() == handles.in.size() );
    ATH_CHECK( handles.in.size()  == handles.views.size() );
  }
  return StatusCode::SUCCESS;
}

initialize()

StatusCode HLTEDMCreator::initialize ( )

overridevirtual

Definition at line 103 of file HLTEDMCreator.cxx.

{  
  if ( m_fixLinks.size() > 0 ) {
    // Confirm that m_fixLinks is a sub-set of m_TrigCompositeContainer
    for (const std::string& entry : m_fixLinks) {
      const bool found = std::any_of(m_TrigCompositeContainer.begin(),
                                     m_TrigCompositeContainer.end(), [&](const auto& writeHandleKey) { return writeHandleKey.key() == entry; } );
      if (!found) {
        ATH_MSG_ERROR("FixLinks contains the entry " << entry << ", however this is not one of this EDMCreator tool's managed TrigCompositeContainers.");
        ATH_MSG_ERROR("Configure FixLinks to be a sub-set of TrigCompositeContainer");
        return StatusCode::FAILURE;
      }
    }
    // Set up the write decorate handles to hold the remapped data
    for ( const auto& writeHandleKey: m_TrigCompositeContainer ) {
      const bool doFixLinks = std::any_of(m_fixLinks.begin(), m_fixLinks.end(), [&](const std::string& s) { return s == writeHandleKey.key(); } );
      if (doFixLinks) {
        // This writeHandleKey is being included in the element link remapping
        m_remapLinkColKeys.emplace_back( writeHandleKey.key()+".remap_linkColKeys" );
        m_remapLinkColIndices.emplace_back( writeHandleKey.key()+".remap_linkColIndices" );
      }
    }
    ATH_CHECK( m_remapLinkColKeys.initialize() ) ;
    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
    ATH_CHECK( m_remapLinkColIndices.initialize() );
    renounceArray( m_remapLinkColIndices );
  }
 
  // this section has to appear after the above initialisation of DecorHandles, else the renounce of TrigComposite does not work as expected
 
#define INIT(__TYPE) \
  ATH_CHECK( initHandles( HandlesGroup<__TYPE>( m_##__TYPE, m_##__TYPE##InViews, m_##__TYPE##Views ) ) );
 
#define INIT_XAOD(__TYPE, __STORE_TYPE) \
  ATH_CHECK( initHandles( HandlesGroup<xAOD::__TYPE>( m_##__TYPE, m_##__TYPE##InViews, m_##__TYPE##Views ) ) ); \
  ATH_CHECK( initAuxKey<xAOD::__STORE_TYPE>( m_##__TYPE.keys() ) );
 
  INIT( TrigRoiDescriptorCollection );
  INIT_XAOD( TrigCompositeContainer, TrigCompositeAuxContainer );
    
  INIT_XAOD( TrigEMClusterContainer, TrigEMClusterAuxContainer );
  INIT_XAOD( TrigCaloClusterContainer, TrigCaloClusterAuxContainer );
  INIT_XAOD( TrigRingerRingsContainer, TrigRingerRingsAuxContainer );
  INIT_XAOD( TrigElectronContainer, TrigElectronAuxContainer );
  INIT_XAOD( ElectronContainer, ElectronAuxContainer );
  INIT_XAOD( PhotonContainer, PhotonAuxContainer );
  INIT_XAOD( TrigPhotonContainer, TrigPhotonAuxContainer );
  INIT_XAOD( TrackParticleContainer, TrackParticleAuxContainer );
  INIT_XAOD( TrigMissingETContainer, TrigMissingETAuxContainer );
 
  INIT_XAOD( L2StandAloneMuonContainer, L2StandAloneMuonAuxContainer );
  INIT_XAOD( L2CombinedMuonContainer, L2CombinedMuonAuxContainer );
  INIT_XAOD( L2IsoMuonContainer, L2IsoMuonAuxContainer );
  INIT_XAOD( MuonContainer, MuonAuxContainer );
  INIT_XAOD( TauJetContainer, TauJetAuxContainer );
  INIT_XAOD( DiTauJetContainer, DiTauJetAuxContainer );
  INIT_XAOD( TauTrackContainer, TauTrackAuxContainer );
  INIT_XAOD( JetContainer, JetAuxContainer );
  INIT_XAOD( VertexContainer, VertexAuxContainer );
  INIT_XAOD( TrigBphysContainer, TrigBphysAuxContainer );
  INIT_XAOD( BTaggingContainer, BTaggingAuxContainer );
  INIT_XAOD( BTagVertexContainer, BTagVertexAuxContainer );
  INIT_XAOD( CaloClusterContainer, CaloClusterTrigAuxContainer ); // NOTE: Difference in interface and aux
  INIT_XAOD( TrigT2MbtsBitsContainer, TrigT2MbtsBitsAuxContainer );
  INIT_XAOD( HIEventShapeContainer, HIEventShapeAuxContainer );
  INIT_XAOD( TrigRNNOutputContainer, TrigRNNOutputAuxContainer );
  INIT_XAOD( AFPSiHitsClusterContainer, AFPSiHitsClusterAuxContainer );
  INIT_XAOD( AFPTrackContainer, AFPTrackAuxContainer );
  INIT_XAOD( AFPToFTrackContainer, AFPToFTrackAuxContainer );
  INIT_XAOD( AFPProtonContainer, AFPProtonAuxContainer );
  INIT_XAOD( AFPVertexContainer, AFPVertexAuxContainer );
 
  // Phase-I L1 RoIs EDM
  INIT_XAOD( eFexEMRoIContainer, eFexEMRoIAuxContainer );
  INIT_XAOD( eFexTauRoIContainer, eFexTauRoIAuxContainer );
  INIT_XAOD( jFexTauRoIContainer, jFexTauRoIAuxContainer );
  INIT_XAOD( jFexFwdElRoIContainer, jFexFwdElRoIAuxContainer );
  INIT_XAOD( jFexSRJetRoIContainer, jFexSRJetRoIAuxContainer );
  INIT_XAOD( jFexLRJetRoIContainer, jFexLRJetRoIAuxContainer );
  INIT_XAOD( jFexMETRoIContainer, jFexMETRoIAuxContainer );
  INIT_XAOD( jFexSumETRoIContainer, jFexSumETRoIAuxContainer );
  INIT_XAOD( gFexJetRoIContainer, gFexJetRoIAuxContainer );
  INIT_XAOD( gFexGlobalRoIContainer, gFexGlobalRoIAuxContainer);
  INIT_XAOD( MuonRoIContainer, MuonRoIAuxContainer );
 
#undef INIT
#undef INIT_XAOD
 
#define INIT_SHALLOW(__TYPE) \
  ATH_CHECK( m_##__TYPE##ShallowCopy.initialize() ); \
  renounceArray( m_##__TYPE##ShallowCopy ); \
  for ( auto k: m_##__TYPE##ShallowCopy ) \
    m_##__TYPE##ShallowCopyOut.push_back(k.key()); \
  ATH_CHECK( m_##__TYPE##ShallowCopyOut.initialize() ); \
  if(m_renounceOutputs) { renounceArray( m_##__TYPE##ShallowCopyOut ); }
 
  INIT_SHALLOW( CaloClusterContainer );
  INIT_SHALLOW( JetContainer );
 
#undef INIT_SHALLOW
 
  return StatusCode::SUCCESS;
}

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 247 of file HLTEDMCreator.cxx.

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

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 255 of file HLTEDMCreator.cxx.

                                                               {
  
  using type_in_container = typename T::base_value_type;
  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
  ATH_CHECK( sg != nullptr );
  ViewHelper::ViewMerger merger( sg, msg() );
  ATH_CHECK( merger.mergeViewCollection<type_in_container>( views, inViewKey, context, output ) );
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_dumpSGAfter

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

private

Definition at line 105 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 104 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 100 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 102 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 101 of file HLTEDMCreator.h.

m_renounceOutputs

Gaudi::Property<bool> HLTEDMCreator::m_renounceOutputs { this, "RenounceOutputs", false, "Renounce outputs so that no algs can become dependent on this tool's output. Done in HLT jobs"}

private

Definition at line 106 of file HLTEDMCreator.h.

---

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

• HLTEDMCreator.h
• HLTEDMCreator.cxx