xAODMaker::FileMetaDataCreatorTool Class Reference

Tool creating xAOD::FileMetaData information. More...

#include <FileMetaDataCreatorTool.h>

Inheritance diagram for xAODMaker::FileMetaDataCreatorTool:

Collaboration diagram for xAODMaker::FileMetaDataCreatorTool:

Public Member Functions
AlgTool Methods
Called by AthenaOutputStream::initialize() (via ToolSvc retrieve()).
StatusCode	initialize () override
StatusCode	finalize () override
	Called at the end of AthenaOutputStream::finalize() (via release()).
Methods inherited by IAthenaOutputTool
Called at the end of AthenaOutputStream::initialize().
StatusCode	postInitialize () override
StatusCode	preExecute () override
	Called at the beginning of AthenaOutputStream::execute().
StatusCode	preStream () override
	Called before actually streaming objects.
StatusCode	postExecute () override
	Fill the FileMetaData with event information.
StatusCode	preFinalize () override
	Write the FileMetaData object to the MetaDataStore via the MetaDataSvc.

IIncidentListener methods
Gaudi::Property< std::string >	m_key
	output key for produced xAOD::FileMetaData in MetaDataStore
Gaudi::Property< std::string >	m_tagInfoKey
	Read tag information.
Gaudi::Property< std::string >	m_simInfoKey
	Read simulation parameters.
Gaudi::Property< std::string >	m_eventInfoKey
	Key for xAOD::EventInfo to update MC channel number.
Gaudi::Property< std::string >	m_dataHeaderKey
	Key for DataHeader in StoreGateSvc.
ServiceHandle< StoreGateSvc >	m_eventStore {"StoreGateSvc", name()}
	DataHeader is produced by another OutputTool, so need StoreGateSvc.
ServiceHandle< IAthMetaDataSvc >	m_metaDataSvc {"MetaDataSvc", name()}
	Use MetaDataSvc store interface to support output in EventService.
ServiceHandle< StoreGateSvc >	m_inputMetaDataStore
	Access to the input metadata store.
ServiceHandle< StoreGateSvc >	m_metaDataStore
ServiceHandle< ITagInfoMgr >	m_tagInfoMgr
	Access to TagInfoMgr for tags.
std::unique_ptr< xAOD::FileMetaData >	m_info
	The object created for this output stream.
std::unique_ptr< xAOD::FileMetaDataAuxInfo >	m_aux
	The auxiliary containing the created object.
bool	m_filledNonEvent {false}
	FileMetaData has been filled with non-event info.
bool	m_filledEvent {false}
	FileMetaData has been filled with event information.
bool	m_hasInputFile {false}
	Input file incident check.
std::mutex	m_toolMutex
	creation of FileMetaData should happen on a single thread
void	handle (const Incident &) override
	Handle BeginInputFile incident after MetaDataSvc.
StatusCode	updateFromNonEvent ()
	Update from Simulation Parameters and TagInfo.
void	set (const xAOD::FileMetaData::MetaDataType, bool)
	helper method to update FileMetaDataProperty with some checks
void	set (const xAOD::FileMetaData::MetaDataType, uint32_t)
void	set (const xAOD::FileMetaData::MetaDataType, float)
void	set (const xAOD::FileMetaData::MetaDataType, const std::string &)
void	addUniqueValue (const std::string &type, uint32_t value)
	helper function to add values to lists

Detailed Description

Tool creating xAOD::FileMetaData information.

This Athena-only tool can be used to create xAOD::FileMetaData information out of the non-ROOT-readable metadata available in the input. The FileMetaDataTool may have copied a xAOD::FileMetaData object to the MetaDataStore. If such a xAOD::FileMetaData object is found it is updated to reflect the current data type and MC channel number.

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 44 of file FileMetaDataCreatorTool.h.

Member Function Documentation

addUniqueValue()

void xAODMaker::FileMetaDataCreatorTool::addUniqueValue ( const std::string & type, uint32_t value )

private

helper function to add values to lists

Definition at line 430 of file FileMetaDataCreatorTool.cxx.

                                         {
  try {
    std::vector<uint32_t> list;
    if (m_info->value(type, list)) {
      ATH_MSG_DEBUG("retrieved existing list of " << type);
    } else {
      ATH_MSG_DEBUG("adding new list for " << type);
    }
    // we want a sorted list of unique values (without using std::set)
    std::sort(list.begin(), list.end());
    auto it = std::lower_bound(list.begin(), list.end(), value);
    if (it == list.end() || (*it) != value) {
      list.insert(it, value);
      ATH_MSG_DEBUG("added " << value << " to list of " << type);
    }
    if (!m_info->setValue(type, list)) {
      ATH_MSG_WARNING("error updating list for " + type);
    }
  } catch (std::exception& e) {
    // Processing generated events not data
    ATH_MSG_WARNING(e.what());
  }
}

finalize()

StatusCode xAODMaker::FileMetaDataCreatorTool::finalize ( )

override

Called at the end of AthenaOutputStream::finalize() (via release()).

Definition at line 143 of file FileMetaDataCreatorTool.cxx.

                                      {
      return StatusCode::SUCCESS;
    }

handle()

void xAODMaker::FileMetaDataCreatorTool::handle ( const Incident & inc )

override

Handle BeginInputFile incident after MetaDataSvc.

Calls updateFromNonEvent on BeginInputFile

Definition at line 63 of file FileMetaDataCreatorTool.cxx.

                                                       {
      // gracefully ignore unexpected incident types
      if (inc.type() == "EndInputFile") {
        // Lock the tool while we work on the FileMetaData
        std::lock_guard lock(m_toolMutex);
        m_hasInputFile = true;
        if (!updateFromNonEvent().isSuccess())
          ATH_MSG_DEBUG("Failed to fill FileMetaData with non-event info");
      }
    }

initialize()

StatusCode xAODMaker::FileMetaDataCreatorTool::initialize ( )

override

Definition at line 28 of file FileMetaDataCreatorTool.cxx.

                                        {
      ATH_CHECK(m_eventStore.retrieve());
      ATH_CHECK(m_metaDataSvc.retrieve());
      ATH_CHECK(m_inputMetaDataStore.retrieve());
      ATH_CHECK(m_metaDataStore.retrieve());
      ATH_CHECK(m_tagInfoMgr.retrieve());
 
      // If DataHeader key not specified, try determining it
      if (m_dataHeaderKey.empty()) {
        const auto *parentAlg = dynamic_cast< const INamedInterface* >(parent());
        if (parentAlg)
          m_dataHeaderKey = parentAlg->name();
      }
 
      // Listen for the begin of an input file. Act after MetaDataSvc (prio 80) and
      // TagInfoMgr (prio 50). That means the FileMetaDataTool be called first
      ServiceHandle< IIncidentSvc > incidentSvc("IncidentSvc", name());
      ATH_CHECK(incidentSvc.retrieve());
      incidentSvc->addListener(this, "EndInputFile", 40);
 
      // Create a fresh object to fill
      ATH_MSG_DEBUG("Creating new xAOD::FileMetaData object to fill");
      m_info = std::make_unique< xAOD::FileMetaData >();
      m_aux  = std::make_unique< xAOD::FileMetaDataAuxInfo >();
      m_info->setStore(m_aux.get());
 
      // FileMetaData has no content
      m_filledNonEvent = false;
      m_filledEvent = false;
 
      // Return gracefully:
      return StatusCode::SUCCESS;
    }

postExecute()

StatusCode xAODMaker::FileMetaDataCreatorTool::postExecute ( )

override

Fill the FileMetaData with event information.

Use information from xAOD::EventInfo to fill xAOD::FileMetaData::mcProcID and DataHeader to set xAOD::FileMetaData::dataType

Definition at line 148 of file FileMetaDataCreatorTool.cxx.

                                         {
      // Lock the tool while working with FileMetaData
      std::lock_guard lock(m_toolMutex);
 
      // Fill information from TagInfo and Simulation Parameters
      if (!updateFromNonEvent().isSuccess())
        ATH_MSG_DEBUG("Failed to fill FileMetaData with non-event info");
 
      // Sanity check
      if (!(m_info && m_aux)) {
        ATH_MSG_DEBUG("No xAOD::FileMetaData object to fill");
        return StatusCode::SUCCESS;
      }
 
      {  // MC channel, run and/or lumi block numbers
        const xAOD::EventInfo* eventInfo = nullptr;
        StatusCode sc = StatusCode::FAILURE;
 
        if (m_eventStore->contains< xAOD::EventInfo >(m_eventInfoKey))
          sc = m_eventStore->retrieve(eventInfo, m_eventInfoKey);
        else if (m_eventStore->contains< xAOD::EventInfo >("Mc" + m_eventInfoKey))
          sc = m_eventStore->retrieve(eventInfo, "Mc" + m_eventInfoKey);
 
        if (eventInfo && sc.isSuccess()) {
          addUniqueValue("runNumbers", eventInfo->runNumber());
          addUniqueValue("lumiBlocks", eventInfo->lumiBlock());
          // Return if object has already been filled
          if (m_filledEvent) return StatusCode::SUCCESS;
 
          try {
            ATH_MSG_DEBUG("Retrieved " << m_eventInfoKey);
 
            xAOD::FileMetaData::MetaDataType type = xAOD::FileMetaData::mcProcID;
            const float id = static_cast< float >(eventInfo->mcChannelNumber());
 
            if (m_info->setValue(type, id))
              ATH_MSG_DEBUG("setting " << type << " to " << id);
            else
              ATH_MSG_DEBUG("error setting " << type << " to " << id);
          } catch (std::exception&) {
            // Processing data not generated events
            ATH_MSG_DEBUG("Failed to set " << xAOD::FileMetaData::mcProcID);
          }
        } else {
          ATH_MSG_DEBUG(
            "Failed to retrieve " << m_eventInfoKey << " => cannot set "
            << xAOD::FileMetaData::mcProcID
            << ", runNumbers, or lumiBlockNumbers");
        }
      }
 
      m_filledEvent = true;
 
      return StatusCode::SUCCESS;
    }

postInitialize()

StatusCode xAODMaker::FileMetaDataCreatorTool::postInitialize ( )

override

Definition at line 75 of file FileMetaDataCreatorTool.cxx.

                                            {
      return StatusCode::SUCCESS;
    }

preExecute()

StatusCode xAODMaker::FileMetaDataCreatorTool::preExecute ( )

override

Called at the beginning of AthenaOutputStream::execute().

Definition at line 80 of file FileMetaDataCreatorTool.cxx.

                                        {
      return StatusCode::SUCCESS;
    }

preFinalize()

StatusCode xAODMaker::FileMetaDataCreatorTool::preFinalize ( )

override

Write the FileMetaData object to the MetaDataStore via the MetaDataSvc.

Definition at line 90 of file FileMetaDataCreatorTool.cxx.

                                         {
      std::lock_guard lock(m_toolMutex);
 
      if (!m_filledNonEvent) {
        ATH_MSG_DEBUG("Not writing empty or incomplete FileMetaData object");
        return StatusCode::SUCCESS;
      }
 
      // Set metadata with content created for given stream
      for (const std::string& key : m_metaDataSvc->getPerStreamKeysFor(m_key)) {
        // Remove any existing objects with this key
        if (!m_metaDataSvc->contains<xAOD::FileMetaData>(key)) {
          auto info = std::make_unique<xAOD::FileMetaData>();
          auto aux = std::make_unique<xAOD::FileMetaDataAuxInfo>();
          info->setStore(aux.get());
          ATH_CHECK(m_metaDataSvc->record(std::move(info), key));
          ATH_CHECK(m_metaDataSvc->record(std::move(aux), key + "Aux."));
        }
 
        auto* output = m_metaDataSvc->tryRetrieve<xAOD::FileMetaData>(key);
        if (output) {
          // save event info that we've already had
          float orig_mcProcID = -1;
          std::vector<uint32_t> orig_runNumbers, orig_lumiBlocks;
          if (!output->value(xAOD::FileMetaData::mcProcID, orig_mcProcID))
            ATH_MSG_DEBUG("Could not get mcProcID");
          if (!output->value("runNumbers", orig_runNumbers))
            ATH_MSG_DEBUG("Could not get runNumbers");
          if (!output->value("lumiBlocks", orig_lumiBlocks))
            ATH_MSG_DEBUG("Could not get lumiBlocks");
 
          // Replace content in store with content created for this stream
          *output = *m_info;
          ATH_MSG_DEBUG("FileMetaData payload replaced in store with content created for this stream");
          if (!m_filledEvent) {
            // restore original event info if it was not filled for this stream
            ATH_MSG_DEBUG("Event information was not filled, restoring what we had");
            if (!output->setValue(xAOD::FileMetaData::mcProcID, orig_mcProcID))
              ATH_MSG_DEBUG("Could not set " << xAOD::FileMetaData::mcProcID << " to " << orig_mcProcID);
            if (!output->setValue("runNumbers", orig_runNumbers))
              ATH_MSG_DEBUG("Could not restore runNumbers");
            if (!output->setValue("lumiBlocks", orig_lumiBlocks))
              ATH_MSG_DEBUG("Could not restore lumiBlocks");
          }
        } else {
            ATH_MSG_DEBUG("cannot copy FileMetaData payload to output");
        }
      }
 
      return StatusCode::SUCCESS;
}

preStream()

StatusCode xAODMaker::FileMetaDataCreatorTool::preStream ( )

override

Called before actually streaming objects.

Definition at line 85 of file FileMetaDataCreatorTool.cxx.

                                       {
      return StatusCode::SUCCESS;
    }

set() [1/4]

void xAODMaker::FileMetaDataCreatorTool::set ( const xAOD::FileMetaData::MetaDataType key, bool value )

private

helper method to update FileMetaDataProperty with some checks

Definition at line 369 of file FileMetaDataCreatorTool.cxx.

                        {
      try {
        if (m_info->setValue(key, value))
          ATH_MSG_DEBUG("setting " << key << " to " << value);
        else
          ATH_MSG_DEBUG("error setting " << key << " to " << std::boolalpha << value
                        << std::noboolalpha);
      } catch (std::exception&) {
        // Processing data not generated events
        ATH_MSG_DEBUG("Failed to set " << key);
      }
    }

set() [2/4]

void xAODMaker::FileMetaDataCreatorTool::set ( const xAOD::FileMetaData::MetaDataType key, const std::string & value )

private

Definition at line 415 of file FileMetaDataCreatorTool.cxx.

                                    {
      if (value.empty()) return;
      try {
        if (m_info->setValue(key, value))
          ATH_MSG_DEBUG("setting " << key << " to " << value);
        else
          ATH_MSG_DEBUG("error setting " << key << " to " << value);
      } catch (std::exception&) {
        // Processing data not generated events
        ATH_MSG_DEBUG("Failed to set " << key);
      }
    }

set() [3/4]

void xAODMaker::FileMetaDataCreatorTool::set ( const xAOD::FileMetaData::MetaDataType key, float value )

private

Definition at line 400 of file FileMetaDataCreatorTool.cxx.

                         {
      try {
        if (m_info->setValue(key, value))
          ATH_MSG_DEBUG("setting " << key << " to " << value);
        else
          ATH_MSG_DEBUG("error setting " << key << " to " << value);
      } catch (std::exception&) {
        // Processing data not generated events
        ATH_MSG_DEBUG("Failed to set " << key);
      }
    }

set() [4/4]

void xAODMaker::FileMetaDataCreatorTool::set ( const xAOD::FileMetaData::MetaDataType key, uint32_t value )

private

Definition at line 385 of file FileMetaDataCreatorTool.cxx.

                            {
      try {
        if (m_info->setValue(key, value))
          ATH_MSG_DEBUG("setting " << key << " to " << value);
        else
          ATH_MSG_DEBUG("error setting " << key << " to " << value);
      } catch (std::exception&) {
        // Processing data not generated events
        ATH_MSG_DEBUG("Failed to set " << key);
      }
    }

updateFromNonEvent()

StatusCode xAODMaker::FileMetaDataCreatorTool::updateFromNonEvent ( )

private

Update from Simulation Parameters and TagInfo.

Definition at line 205 of file FileMetaDataCreatorTool.cxx.

                                                {
 
      // Have we already done this?
      if (m_filledNonEvent) return StatusCode::SUCCESS;
 
      // Sanity check
      if (!(m_info && m_aux)) {
        ATH_MSG_DEBUG("No xAOD::FileMetaData object to fill");
        return StatusCode::SUCCESS;
      }
 
      if (m_hasInputFile && m_tagInfoMgr->getInputTags().empty()) {
        ATH_MSG_DEBUG("Deferring non-event fill due to eventless-input");
        return StatusCode::SUCCESS;
      }
 
      set(xAOD::FileMetaData::productionRelease,
          m_tagInfoMgr->findTag("AtlasRelease"));
 
      set(xAOD::FileMetaData::amiTag, m_tagInfoMgr->findTag("AMITag"));
 
      set(xAOD::FileMetaData::geometryVersion, m_tagInfoMgr->findTag("GeoAtlas"));
 
      set(xAOD::FileMetaData::conditionsTag,
          m_tagInfoMgr->findTag("IOVDbGlobalTag"));
 
      set(xAOD::FileMetaData::beamType, m_tagInfoMgr->findTag("beam_type"));
 
      set(xAOD::FileMetaData::mcCampaign, m_tagInfoMgr->findTag("mc_campaign"));
 
      set(xAOD::FileMetaData::generatorsInfo, m_tagInfoMgr->findTag("generators"));
 
      std::string beamEnergy = m_tagInfoMgr->findTag("beam_energy");
      try {
        set(xAOD::FileMetaData::beamEnergy,
            std::stof(beamEnergy));
      } catch (std::invalid_argument& e) {
        ATH_MSG_DEBUG("beam energy \"" << beamEnergy << "\" tag could not be converted to float");
      } catch (std::out_of_range& e) {
        ATH_MSG_DEBUG("converted beam energy value (\"" << beamEnergy << "\") outside float range");
      }
 
      std::string dataYear = m_tagInfoMgr->findTag("data_year");
      if (!dataYear.empty()) {
        try {
          set(xAOD::FileMetaData::dataYear,
              static_cast<uint32_t>(std::stoul(dataYear)));
        } catch (std::invalid_argument& e) {
          ATH_MSG_DEBUG("data year \"" << dataYear << "\" tag could not be converted to unsigned long");
        } catch (std::out_of_range& e) {
          ATH_MSG_DEBUG("converted data year value (\"" << dataYear << "\") outside unsigned long range");
        }
      }
 
      // Read simulation parameters
      const IOVMetaDataContainer * simInfo = nullptr;
      StatusCode sc = StatusCode::FAILURE;
      if (m_inputMetaDataStore->contains< IOVMetaDataContainer >(m_simInfoKey)) {
        sc = m_inputMetaDataStore->retrieve(simInfo, m_simInfoKey);
      } else if (m_metaDataStore->contains< IOVMetaDataContainer >(m_simInfoKey)) {
        sc = m_metaDataStore->retrieve(simInfo, m_simInfoKey);
      }
      const coral::AttributeList * attrList = nullptr;
      if (simInfo && sc.isSuccess()) {
        for (const CondAttrListCollection* payload : *simInfo->payloadContainer()) {
          for (const auto& itr : *payload) {
            attrList = &(itr.second);
          }
        }
      }
 
      bool simFlavourSet{};
      bool isDataOverlaySet{};
      if (attrList) {
        { // set simulation flavor
          std::string key = "SimulationFlavour";
          if (attrList->exists(key)) {
            std::string value = (*attrList)[key].data< std::string >();
 
            // remap simulation flavor "default" to "FullSim"
            if (value == "default")
              value = "FullSim";
 
            set(xAOD::FileMetaData::simFlavour, value);
            simFlavourSet = true;
          }
        }
 
        { // set whether this is overlay
          std::string key = "IsDataOverlay";
          if (attrList->exists(key)) {
            std::string attr = (*attrList)[key].data< std::string >();
            set(xAOD::FileMetaData::isDataOverlay, attr == "True");
            isDataOverlaySet = true;
          }
        }
      }
 
      if (!simFlavourSet || !isDataOverlaySet) {
          ATH_MSG_DEBUG(
            "Failed to set "
            << xAOD::FileMetaData::simFlavour << " or "
            << xAOD::FileMetaData::isDataOverlay
            << ". Trying to get them from input metadata store." );
 
          for (const std::string& key : m_metaDataSvc->getPerStreamKeysFor(m_key)) {
              const xAOD::FileMetaData* input = nullptr;
              input = m_inputMetaDataStore->tryConstRetrieve< xAOD::FileMetaData >(key);
              if (input) {
                  if (!simFlavourSet) {
                    std::string orig_simFlavour = "none";
                    if (!input->value(xAOD::FileMetaData::simFlavour, orig_simFlavour)) {
                        ATH_MSG_DEBUG(
                            "Could not get xAOD::FileMetaData::simFlavour "
                            "from input metadata "
                            "store");
                    } else {
                        ATH_MSG_DEBUG("Retrieved from input metadata store: "
                                      << xAOD::FileMetaData::simFlavour << " = "
                                      << orig_simFlavour);
                        set(xAOD::FileMetaData::simFlavour, orig_simFlavour);
                    }
                  }
 
                  if (!isDataOverlaySet) {
                    bool orig_isDataOverlay = false;
                    if (!input->value(xAOD::FileMetaData::isDataOverlay, orig_isDataOverlay)) {
                        ATH_MSG_DEBUG(
                            "Could not get "
                            "xAOD::FileMetaData::isDataOverlay from input "
                            "metadata store");
                    } else {
                        ATH_MSG_DEBUG("Retrieved from input metadata store: "
                                      << xAOD::FileMetaData::isDataOverlay << " = "
                                      << orig_isDataOverlay);
                        set(xAOD::FileMetaData::isDataOverlay, orig_isDataOverlay);
                    }
                  }
              }
          }
      }
 
      if (m_filledNonEvent) return StatusCode::SUCCESS;
 
      {  // get dataType
        xAOD::FileMetaData::MetaDataType type = xAOD::FileMetaData::dataType;
        try {
          if (m_info->setValue(type, m_dataHeaderKey.value()))
            ATH_MSG_DEBUG("set " << type << " to " << m_dataHeaderKey.value());
          else
            ATH_MSG_DEBUG("error setting " << type << " to " << m_dataHeaderKey.value());
        } catch (std::exception&) {
          // This is unexpected
          ATH_MSG_DEBUG("Failed to set " << xAOD::FileMetaData::dataType);
        }
      }
 
      // FileMetaData object has been filled with non event info
      m_filledNonEvent = true;
 
      return StatusCode::SUCCESS;
    }

Member Data Documentation

m_aux

std::unique_ptr< xAOD::FileMetaDataAuxInfo > xAODMaker::FileMetaDataCreatorTool::m_aux

private

The auxiliary containing the created object.

Definition at line 162 of file FileMetaDataCreatorTool.h.

m_dataHeaderKey

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

private

Initial value:

{
      this,
      "StreamName",
      "",
      "Key to read data header from event store"
  }

Key for DataHeader in StoreGateSvc.

Definition at line 122 of file FileMetaDataCreatorTool.h.

                                             {
      this,
      "StreamName",
      "",
      "Key to read data header from event store"
  };

m_eventInfoKey

Gaudi::Property< std::string > xAODMaker::FileMetaDataCreatorTool::m_eventInfoKey

private

Initial value:

{
      this,
      "EventInfoKey",
      "EventInfo",
      "Key to read xAOD::EventInfo from EventStore"
  }

Key for xAOD::EventInfo to update MC channel number.

Definition at line 114 of file FileMetaDataCreatorTool.h.

                                            {
      this,
      "EventInfoKey",
      "EventInfo",
      "Key to read xAOD::EventInfo from EventStore"
  };

m_eventStore

ServiceHandle< StoreGateSvc > xAODMaker::FileMetaDataCreatorTool::m_eventStore {"StoreGateSvc", name()}

private

DataHeader is produced by another OutputTool, so need StoreGateSvc.

Definition at line 130 of file FileMetaDataCreatorTool.h.

{"StoreGateSvc", name()};

m_filledEvent

bool xAODMaker::FileMetaDataCreatorTool::m_filledEvent {false}

private

FileMetaData has been filled with event information.

Definition at line 168 of file FileMetaDataCreatorTool.h.

{false};

m_filledNonEvent

bool xAODMaker::FileMetaDataCreatorTool::m_filledNonEvent {false}

private

FileMetaData has been filled with non-event info.

Definition at line 165 of file FileMetaDataCreatorTool.h.

{false};

m_hasInputFile

bool xAODMaker::FileMetaDataCreatorTool::m_hasInputFile {false}

private

Input file incident check.

Definition at line 171 of file FileMetaDataCreatorTool.h.

{false};

m_info

std::unique_ptr< xAOD::FileMetaData > xAODMaker::FileMetaDataCreatorTool::m_info

private

The object created for this output stream.

Definition at line 159 of file FileMetaDataCreatorTool.h.

m_inputMetaDataStore

ServiceHandle< StoreGateSvc > xAODMaker::FileMetaDataCreatorTool::m_inputMetaDataStore

private

Initial value:

{
    "InputMetaDataStore", name()}

Access to the input metadata store.

Definition at line 136 of file FileMetaDataCreatorTool.h.

                                                    {
    "InputMetaDataStore", name()};

m_key

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

private

Initial value:

{
      this,
      "OutputKey",
      "FileMetaData",
      "Key used to write FileMetaData into MetaDataStore"
  }

output key for produced xAOD::FileMetaData in MetaDataStore

Definition at line 90 of file FileMetaDataCreatorTool.h.

                                  {
      this,
      "OutputKey",
      "FileMetaData",
      "Key used to write FileMetaData into MetaDataStore"
  };

m_metaDataStore

ServiceHandle< StoreGateSvc > xAODMaker::FileMetaDataCreatorTool::m_metaDataStore

private

Initial value:

{
    "MetaDataStore", name()}

Definition at line 139 of file FileMetaDataCreatorTool.h.

                                               {
    "MetaDataStore", name()};

m_metaDataSvc

ServiceHandle< IAthMetaDataSvc > xAODMaker::FileMetaDataCreatorTool::m_metaDataSvc {"MetaDataSvc", name()}

private

Use MetaDataSvc store interface to support output in EventService.

Definition at line 133 of file FileMetaDataCreatorTool.h.

{"MetaDataSvc", name()};

m_simInfoKey

Gaudi::Property< std::string > xAODMaker::FileMetaDataCreatorTool::m_simInfoKey

private

Initial value:

{
      this,
      "SimInfoKey",
      "/Simulation/Parameters",
      "Key to look up simulation parameters from InputMetaDataStore"
  }

Read simulation parameters.

Definition at line 106 of file FileMetaDataCreatorTool.h.

                                          {
      this,
      "SimInfoKey",
      "/Simulation/Parameters",
      "Key to look up simulation parameters from InputMetaDataStore"
  };

m_tagInfoKey

Gaudi::Property< std::string > xAODMaker::FileMetaDataCreatorTool::m_tagInfoKey

private

Initial value:

{
      this,
      "TagInfoKey",
      "/TagInfo",
      "Key to look up tags from InputMetaDataStore"
  }

Read tag information.

Definition at line 98 of file FileMetaDataCreatorTool.h.

                                          {
      this,
      "TagInfoKey",
      "/TagInfo",
      "Key to look up tags from InputMetaDataStore"
  };

m_tagInfoMgr

ServiceHandle< ITagInfoMgr > xAODMaker::FileMetaDataCreatorTool::m_tagInfoMgr

private

Initial value:

{
    "TagInfoMgr", name()}

Access to TagInfoMgr for tags.

Definition at line 143 of file FileMetaDataCreatorTool.h.

                                           {
    "TagInfoMgr", name()};

m_toolMutex

std::mutex xAODMaker::FileMetaDataCreatorTool::m_toolMutex

private

creation of FileMetaData should happen on a single thread

Definition at line 174 of file FileMetaDataCreatorTool.h.

---

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

• FileMetaDataCreatorTool.h
• FileMetaDataCreatorTool.cxx