EventCore.cxx

Go to the documentation of this file.

// Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
 
// Local include(s).
#include "xAODRootAccess/Event.h"
#include "xAODRootAccess/TVirtualIncidentListener.h"
#include "xAODRootAccess/tools/TVirtualManager.h"
 
// Project include(s).
#include "xAODCore/tools/IOStats.h"
#include "xAODCore/tools/PerfStats.h"
#include "xAODRootAccessInterfaces/TActiveEvent.h"
#include "AthContainers/CurrentContext.h"
#ifndef XAOD_STANDALONE
# include "AthenaKernel/proxyDictFromEventContext.h"
# include "SGTools/CurrentEventStore.h"
#endif  // not XAOD_STANDALONE
 
// ROOT include(s).
#include <TClass.h>
 
// System include(s).
#include <iomanip>
#include <sstream>
 
namespace xAOD {

Event::Event(std::string_view name,
             [[maybe_unused]] const EventContext* ctx /* = nullptr*/)
    : TVirtualEvent(),
      Details::IProxyDictBase(),
      asg::AsgMessaging(std::string{name}) {
 
  // Make sure that the I/O monitoring is active.
  PerfStats::instance();
 
  if (ctx) {
#ifndef XAOD_STANDALONE
    m_ctx = *ctx;
#endif
  }
  else {
    // Make this the active event.
    this->setActive();
  }
}
 
Event::~Event() {
 
  // If this is set up as the active event at the moment, notify
  // the active event object that this object will no longer be
  // available.
  if (TActiveEvent::event() == this) {
    TActiveEvent::setEvent(nullptr);
  }
#ifndef XAOD_STANDALONE
  if (Atlas::proxyDictFromEventContext() == this) {
    SG::CurrentEventStore::setStore(nullptr);
    Atlas::setProxyDictInEventContext(nullptr);
  }
#endif  // not XAOD_STANDALONE
}
 
void Event::setActive() const {
 
  // The active event and current store are thread-local globals.
  Event* nc_this ATLAS_THREAD_SAFE = const_cast<Event*>(this);
  TActiveEvent::setEvent(static_cast<TVirtualEvent*>(nc_this));
#ifndef XAOD_STANDALONE
  SG::CurrentEventStore::setStore(nc_this);
  Atlas::setProxyDictInEventContext(nc_this);
#endif  // not XAOD_STANDALONE
}

void Event::setAuxItemList(const std::string& containerKey,
                           const std::string& itemList) {
 
  // Decoded attributes.
  std::set<std::string> attributes;
 
  // Split up the received string using "." as the separator.
  if (itemList.size()) {
    std::istringstream ss(itemList);
    std::string attr;
    while (std::getline(ss, attr, '.')) {
      attributes.insert(attr);
    }
  }
 
  // Remember the setting.
  m_auxItemList[containerKey] = std::move(attributes);
}

StatusCode Event::addListener(TVirtualIncidentListener* listener) {
 
  // Check that we received a valid pointer:
  if (listener == nullptr) {
    ATH_MSG_ERROR("Received a null pointer for the listener");
    return StatusCode::FAILURE;
  }
 
  // Check whether we already have this listener.
  auto itr = std::find(m_listeners.begin(), m_listeners.end(), listener);
  if (itr != m_listeners.end()) {
    ATH_MSG_WARNING("Listener " << static_cast<void*>(listener)
                                << " is already registered");
    return StatusCode::SUCCESS;
  }
 
  // Add the listener.
  m_listeners.push_back(listener);
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

StatusCode Event::removeListener(TVirtualIncidentListener* listener) {
 
  // Remove the listener. Or at least try to...
  auto itr = std::find(m_listeners.begin(), m_listeners.end(), listener);
  if (itr == m_listeners.end()) {
    ATH_MSG_ERROR("Listener " << static_cast<void*>(listener) << " not known");
    return StatusCode::FAILURE;
  }
  m_listeners.erase(itr);
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

void Event::clearListeners() {
 
  m_listeners.clear();
}

StatusCode Event::addNameRemap(const std::string& onfile,
                               const std::string& newName) {
 
  // Check if this name is known on the input or output already. As that's
  // not good.
  if (m_inputEventFormat.exists(newName)) {
    ATH_MSG_ERROR("Can't use \"" << newName << "\" as the target name in the \""
                                 << onfile << "\" -> \"" << newName
                                 << "\" remapping");
    return StatusCode::FAILURE;
  }
 
  // Check if this name was remapped to something already.
  auto itr = m_nameRemapping.find(newName);
  if (itr != m_nameRemapping.end()) {
    ATH_MSG_WARNING("Overriding existing name remapping \""
                    << itr->second << "\" -> \"" << itr->first << "\" with: \""
                    << onfile << "\" -> \"" << newName << "\"");
  }

  m_nameRemapping[newName] = onfile;
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

void Event::clearNameRemap() {
 
  m_nameRemapping.clear();
}

void Event::printNameRemap() const {
 
  // Print a header.
  ATH_MSG_INFO("Name remapping rules:");
 
  // In case no remapping rules have been set.
  if (m_nameRemapping.empty()) {
    ATH_MSG_INFO("   NONE");
    return;
  }
 
  // Otherwise.
  for (const auto& [newName, onfile] : m_nameRemapping) {
    ATH_MSG_INFO("   \"" << newName << "\" -> \"" << onfile << "\"");
  }
}

void Event::printProxyWarnings(bool value) {
 
  m_printEventProxyWarnings = value;
}
 
const EventFormat* Event::inputEventFormat() const {
 
  if (hasInput()) {
    return &m_inputEventFormat;
  }
  return nullptr;
}
 
const EventFormat* Event::outputEventFormat() const {
 
  return m_outputEventFormat;
}

std::string Event::dump() {
 
  // The internal stream object.
  std::ostringstream ost;
  ost << "<<<<<<<<<<<<<<<<<<<< xAOD::TEvent Dump >>>>>>>>>>>>>>>>>>>>\n";
 
  // Loop over the input EventFormat object.
  for (const auto& [key, element] : m_inputEventFormat) {
 
    // Get the type.
    ::TClass* cl = ::TClass::GetClass(element.className().c_str());
    const std::type_info* ti = (cl ? cl->GetTypeInfo() : nullptr);
    if ((cl == nullptr) || (cl->IsLoaded() == false) || (ti == nullptr)) {
      ATH_MSG_WARNING("Unknown type (" << element.className()
                                       << ") found in the event format");
      continue;
    }
 
    // Skip containers that are not available anyway.
    static const bool METADATA = false;
    if (!contains(element.branchName(), *ti, METADATA)) {
      continue;
    }
 
    // Do the printout.
    ost << " Hash: 0x" << std::setw(8) << std::setfill('0') << std::hex
        << element.hash() << " Key: \"" << element.branchName() << "\"\n";
 
    ost << "   type: " << element.className() << "\n";
    const bool isNonConst =
        transientContains(element.branchName(), *ti, METADATA);
    ost << "   isConst: " << (isNonConst ? "No" : "Yes") << "\n";
    static const bool SILENT = false;
    ost << "   Data: "
        << (isNonConst
                ? getOutputObject(element.branchName(), *ti, METADATA)
                : getInputObject(element.branchName(), *ti, SILENT, METADATA))
        << "\n";
  }
 
  // Finish with the construction:
  ost << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
  return ost.str();
}

void Event::printIOStats() const {
 
  // Simply do this via the xAODCore code:
  IOStats::instance().stats().Print("Summary");
}
 
const EventContext& Event::currentContext() const {
#ifdef XAOD_STANDALONE
  return Gaudi::Hive::currentContext();
#else
  return m_ctx;
#endif
}
 
}  // namespace xAOD