Tool creating and maintaining xAOD::EventFormat at the end-of-events. More...

#include <EventFormatStreamHelperTool.h>

Inheritance diagram for xAODMaker::EventFormatStreamHelperTool:

Collaboration diagram for xAODMaker::EventFormatStreamHelperTool:

Public Types
using	sgkey_t = SG::sgkey_t

Public Member Functions
Interface inherited from @c AthAlgTool
StatusCode	initialize () override
	Initialise the tool.
Interface inherited from @c IAthenaOutputTool
StatusCode	postInitialize () override
	Called at the end of initialize.
StatusCode	preExecute () override
	Called at the beginning of execute.
StatusCode	postExecute () override
	Called at the end of execute.
StatusCode	preFinalize () override
	Called at the beginning of finalize.
StatusCode	preStream () override
	Called at the.

Private Member Functions
StatusCode	collectFormatMetadata ()
sgkey_t	lookUpHash (CLID primaryClassID, const std::set< CLID > &classIDs, const std::vector< sgkey_t > &hashes) const
	look up hash corresponding to primary class ID

Private Attributes
ServiceHandle< IAthMetaDataSvc >	m_metadataStore
	Use the metadata tool interface to store the EventFormat object.
ServiceHandle< IClassIDSvc >	m_clidSvc
	Connection to the CLID service.
Gaudi::Property< std::string >	m_key
Gaudi::Property< std::vector< std::string > >	m_typeNames
	Type names for which a metadata entry should be added.
Gaudi::Property< std::vector< std::string > >	m_ignoreKeys
	StoreGate keys that should be ignored during the metadata collection.
Gaudi::Property< std::string >	m_dataHeaderKey
std::vector< std::regex >	m_ignoreKeyRegexes
	`m_ignoreKeys`, compiled once in `initialize()`
std::vector< std::regex >	m_typeNameRegexes
	`m_typeNames`, compiled once in `initialize()`
std::set< CLID >	m_warnedCLIDs
	CLIDs about which warnings have already been printed.
std::mutex	m_warnedCLIDsMutex
	Mutex for the `m_warnedCLIDs` variable.
std::mutex	m_efMutex
	Mutex for the `m_ef` variable.

Detailed Description

Tool creating and maintaining xAOD::EventFormat at the end-of-events.

This tool is meant to be added to every xAOD output stream, so that it would maintain xAOD::EventFormat object every time a new event is written out.

Author: Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h; Frank Berghaus fberg.nosp@m.haus.nosp@m.@anl..nosp@m.gov

Definition at line 30 of file EventFormatStreamHelperTool.h.

Member Typedef Documentation

◆ sgkey_t

using xAODMaker::EventFormatStreamHelperTool::sgkey_t = SG::sgkey_t

Definition at line 32 of file EventFormatStreamHelperTool.h.

Member Function Documentation

◆ collectFormatMetadata()

StatusCode xAODMaker::EventFormatStreamHelperTool::collectFormatMetadata ( )

private

Definition at line 57 of file EventFormatStreamHelperTool.cxx.

                                                       {
      // Get the EventFormat object
      xAOD::EventFormat * event_format =
          m_metadataStore->tryRetrieve< xAOD::EventFormat >(m_key.value());
 
      if (!event_format) {
        auto p_event_format = std::make_unique< xAOD::EventFormat >();
        event_format = p_event_format.get();
        ATH_CHECK(m_metadataStore->record(std::move(p_event_format), m_key));
        ATH_MSG_VERBOSE("Created new xAOD::EventFormat: " << m_key.value());
      } else {
        ATH_MSG_VERBOSE("Use existing xAOD::EventFormat: " << m_key.value());
      }
 
      // Grab output stream data header
      SG::ReadHandle< DataHeader > dataHeader(m_dataHeaderKey);
      if (!dataHeader.isValid()) {
        // DataHeader won't exist if this event was rejected.
        return StatusCode::SUCCESS;
      }
 
      // Loop over objects in output stream
      for (const DataHeaderElement& elem : *dataHeader) {
        // Caveat: assume branch name that Athena I/O is going to give to
        // this object is the key name
        const std::string& key = elem.getKey();
        const CLID classID = elem.getPrimaryClassID();
 
        // Skip objects that were set up to be ignored.
        {
          bool ignoreObject = false;
          for (const std::regex& ignorePattern : m_ignoreKeyRegexes) {
            if (std::regex_match(key, ignorePattern)) {
              ignoreObject = true;
              break;
            }
          }
          if (ignoreObject) continue;
        }
 
        // Get the type name of this object.
        std::string typeName;
        if (m_clidSvc->getTypeInfoNameOfID(classID, typeName).isFailure()) {
          // Make sure that nobody else is using @c m_warnedCLIDs right now.
          std::lock_guard< std::mutex > lock(m_warnedCLIDsMutex);
 
          // Print a warning if this CLID didn't produce a warning yet:
          if (m_warnedCLIDs.insert(classID).second)
            ATH_MSG_WARNING("Couldn't get type name for CLID = " << classID );
 
          continue;
        }
 
        // Now that we have the type name, check whether metadata for this type
        // should be stored.
        {
          bool ignoreObject = true;
          for (const std::regex& typePattern : m_typeNameRegexes) {
            if (std::regex_match(typeName, typePattern)) {
              ignoreObject = false;
              break;
            }
          }
          if (ignoreObject) continue;
        }
 
        // Update the metadata object
        try {
          const sgkey_t hash =
              lookUpHash(classID, elem.getClassIDs(), elem.getHashes());
 
          // Make sure that nobody else is modifying @c m_ef or @c m_spool
          // right now.
          std::lock_guard< std::mutex > lock(m_efMutex);
          // If we already know about this object, then don't bother.
          if (event_format->exists(key)) continue;
          static const std::string emptyStr{};
          // Add the info.
          event_format->add(xAOD::EventFormatElement(key, typeName, emptyStr, hash));
 
          // Tell the user what happened.
          ATH_MSG_VERBOSE("Adding info: key = \"" << key
                        << ", typeName = \"" << typeName << "\""
                        << ", hash = 0x" << std::hex << std::setw(8)
                        << std::setfill('0') << hash);
        } catch (const std::exception& e) {
          ATH_MSG_WARNING(e.what());
        }
      }
 
      // Return gracefully.
      return StatusCode::SUCCESS;
    }

◆ initialize()

StatusCode xAODMaker::EventFormatStreamHelperTool::initialize ( )

override

Initialise the tool.

Definition at line 21 of file EventFormatStreamHelperTool.cxx.

                                            {
      // Retrieve all needed components.
      ATH_CHECK(m_metadataStore.retrieve());
 
      // Compile the configured patterns once, so that the event loop doesn't
      // have to do it for every object of every event.
      m_ignoreKeyRegexes.reserve(m_ignoreKeys.size());
      for (const std::string& pattern : m_ignoreKeys.value())
        m_ignoreKeyRegexes.emplace_back(pattern, std::regex::optimize);
      m_typeNameRegexes.reserve(m_typeNames.size());
      for (const std::string& pattern : m_typeNames.value())
        m_typeNameRegexes.emplace_back(pattern, std::regex::optimize);
 
      if (m_dataHeaderKey.empty()) {
        // find out name of stream we are working for
        const Gaudi::Algorithm *parentAlg =
            dynamic_cast< const Gaudi::Algorithm* >(parent());
        if (parentAlg) m_dataHeaderKey = parentAlg->name();
      }
 
      // Return gracefully
      return StatusCode::SUCCESS;
    }

◆ lookUpHash()

EventFormatStreamHelperTool::sgkey_t xAODMaker::EventFormatStreamHelperTool::lookUpHash	(	CLID	primaryClassID,
		const std::set< CLID > &	classIDs,
		const std::vector< sgkey_t > &	hashes ) const

private

look up hash corresponding to primary class ID

We can retrieve the list of all class IDs and hashes corresponding to an element in the output stream. The two collections should be of the same size. Element one of the classIDs corresponds to element one of the hashes and so on. This function steps through the two collections and returns the hash corresponding to the classID matching the primaryClassID.

Parameters

[in]	primaryClassID	the primary class ID
[in]	classIDs	the set of classIDs associated with a DataHeaderElement
[in]	hashes	the vector of hashes associated with a DataHeaderElement

Warning: classIDs and hashes must have the same number of entries

Exceptions

std::runtime_error	classIDs and hashes not the same size
std::range_error	primaryClassID not found in classIDs

Returns: the hash corresponding to the primaryClassID

Definition at line 152 of file EventFormatStreamHelperTool.cxx.

                                              {
        // two collections of different size would cause undefined behaviour
        if (classIDs.size() != hashes.size())
          throw(std::runtime_error("CLID and hash sets not equal in size"));
 
        auto it = classIDs.find(primaryClassID);
 
        // bail if we don't find the primary class ID
        if (it == classIDs.end())
          throw(std::range_error("Primary class ID not in list of class IDs"));
 
        return hashes[std::distance(classIDs.begin(), it)];
      }

◆ postExecute()

StatusCode xAODMaker::EventFormatStreamHelperTool::postExecute ( )

override

Called at the end of execute.

Definition at line 46 of file EventFormatStreamHelperTool.cxx.

                                             {
      // Notify the event format service that it should collect the metadata
      // that it needs.
      ATH_CHECK(collectFormatMetadata());
      ATH_MSG_VERBOSE("Triggered metadata collection on: " << m_key.value());
 
      // Return gracefully.
      return StatusCode::SUCCESS;
    }

◆ postInitialize()

StatusCode xAODMaker::EventFormatStreamHelperTool::postInitialize ( )

inlineoverride

Called at the end of initialize.

Definition at line 49 of file EventFormatStreamHelperTool.h.

49{return StatusCode::SUCCESS;}

◆ preExecute()

StatusCode xAODMaker::EventFormatStreamHelperTool::preExecute ( )

inlineoverride

Called at the beginning of execute.

Definition at line 52 of file EventFormatStreamHelperTool.h.

52{return StatusCode::SUCCESS;}

◆ preFinalize()

StatusCode xAODMaker::EventFormatStreamHelperTool::preFinalize ( )

inlineoverride

Called at the beginning of finalize.

Definition at line 58 of file EventFormatStreamHelperTool.h.

58{return StatusCode::SUCCESS;}

◆ preStream()

StatusCode xAODMaker::EventFormatStreamHelperTool::preStream ( )

inlineoverride

Called at the.

Definition at line 61 of file EventFormatStreamHelperTool.h.

61{return StatusCode::SUCCESS;}

Member Data Documentation

◆ m_clidSvc

ServiceHandle< IClassIDSvc > xAODMaker::EventFormatStreamHelperTool::m_clidSvc

private

Initial value:

{ this, "ClassIDSvc", "ClassIDSvc",

"The ClassID service instance to use" }

Connection to the CLID service.

Definition at line 71 of file EventFormatStreamHelperTool.h.

71 { this, "ClassIDSvc", "ClassIDSvc",

72 "The ClassID service instance to use" };

◆ m_dataHeaderKey

Gaudi::Property< std::string > xAODMaker::EventFormatStreamHelperTool::m_dataHeaderKey

private

Initial value:

{this, "DataHeaderKey", "",

"Key of DataHeader produced by output stream" }

Definition at line 87 of file EventFormatStreamHelperTool.h.

87 {this, "DataHeaderKey", "",

88 "Key of DataHeader produced by output stream" };

◆ m_efMutex

std::mutex xAODMaker::EventFormatStreamHelperTool::m_efMutex

mutableprivate

Mutex for the m_ef variable.

Definition at line 130 of file EventFormatStreamHelperTool.h.

◆ m_ignoreKeyRegexes

std::vector< std::regex > xAODMaker::EventFormatStreamHelperTool::m_ignoreKeyRegexes

private

m_ignoreKeys, compiled once in initialize()

Definition at line 93 of file EventFormatStreamHelperTool.h.

◆ m_ignoreKeys

Gaudi::Property< std::vector< std::string > > xAODMaker::EventFormatStreamHelperTool::m_ignoreKeys

private

Initial value:

{ this,
    "IgnoreKeys", { "HLTAutoKey_.*" },
    "SG keys that should be ignored during the metadata collection" }

StoreGate keys that should be ignored during the metadata collection.

Definition at line 83 of file EventFormatStreamHelperTool.h.

                                                      { this,
    "IgnoreKeys", { "HLTAutoKey_.*" },
    "SG keys that should be ignored during the metadata collection" };

◆ m_key

Gaudi::Property< std::string > xAODMaker::EventFormatStreamHelperTool::m_key

private

Initial value:

{ this, "Key", "EventInfo",

"Key for EventFormat object in metadata store" }

Definition at line 74 of file EventFormatStreamHelperTool.h.

74 { this, "Key", "EventInfo",

75 "Key for EventFormat object in metadata store" };

◆ m_metadataStore

ServiceHandle< IAthMetaDataSvc > xAODMaker::EventFormatStreamHelperTool::m_metadataStore

private

Initial value:

{ this, "MetaDataSvc",

"MetaDataSvc", "The metadata service use to record the xAOD::EventFormat" }

Use the metadata tool interface to store the EventFormat object.

Definition at line 67 of file EventFormatStreamHelperTool.h.

67 { this, "MetaDataSvc",

68 "MetaDataSvc", "The metadata service use to record the xAOD::EventFormat" };

◆ m_typeNameRegexes

std::vector< std::regex > xAODMaker::EventFormatStreamHelperTool::m_typeNameRegexes

private

m_typeNames, compiled once in initialize()

Definition at line 95 of file EventFormatStreamHelperTool.h.

◆ m_typeNames

Gaudi::Property< std::vector< std::string > > xAODMaker::EventFormatStreamHelperTool::m_typeNames

private

Initial value:

{ this,
    "TypeNames", { ".*xAOD::.*", "DataVector<SG::AuxElement>" },
    "Type names for which metadata entries are added" }

Type names for which a metadata entry should be added.

Definition at line 78 of file EventFormatStreamHelperTool.h.

                                                     { this,
    "TypeNames", { ".*xAOD::.*", "DataVector<SG::AuxElement>" },
    "Type names for which metadata entries are added" };

◆ m_warnedCLIDs

std::set< CLID > xAODMaker::EventFormatStreamHelperTool::m_warnedCLIDs

private

CLIDs about which warnings have already been printed.

Definition at line 125 of file EventFormatStreamHelperTool.h.

◆ m_warnedCLIDsMutex

std::mutex xAODMaker::EventFormatStreamHelperTool::m_warnedCLIDsMutex

private

Mutex for the m_warnedCLIDs variable.

Definition at line 127 of file EventFormatStreamHelperTool.h.

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

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ sgkey_t

Member Function Documentation

◆ collectFormatMetadata()

◆ initialize()

◆ lookUpHash()

◆ postExecute()

◆ postInitialize()

◆ preExecute()

◆ preFinalize()

◆ preStream()

Member Data Documentation

◆ m_clidSvc

◆ m_dataHeaderKey

◆ m_efMutex

◆ m_ignoreKeyRegexes

◆ m_ignoreKeys

◆ m_key

◆ m_metadataStore

◆ m_typeNameRegexes

◆ m_typeNames

◆ m_warnedCLIDs

◆ m_warnedCLIDsMutex