xAOD::Experimental::REvent Class Reference

Tool for accessing xAOD files outside of Athena, version RNTuple. More...

#include <REvent.h>

Inheritance diagram for xAOD::Experimental::REvent:

Collaboration diagram for xAOD::Experimental::REvent:

Public Types
using	sgkey_t = SG::sgkey_t

Public Member Functions
	REvent ()
	Default constructor. More...
virtual	~REvent ()
	Destructor. More...
template<typename T >
bool	retrieve (const T *&obj, sgkey_t key=DEFAULT_KEY, bool silent=false)
	Function retrieving an object from the event (constant version) More...
template<typename T >
bool	retrieve (const T *&obj, const std::string &key, bool silent=false)
	Function retrieving an object from the event (constant version) More...
void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Static Public Attributes
static constexpr sgkey_t	DEFAULT_KEY = ~static_cast<sgkey_t>(0)
	Key for retrieving the "default" object of a given type. More...
static constexpr sgkey_t	KEY_MASK = DEFAULT_KEY >> 2
	Mask for the keys, used mostly internally. More...

Protected Types
using	Object_t = std::unordered_map< std::string, std::unique_ptr< TVirtualManager > >
	Definition of the internal data structure type. More...

Protected Member Functions
bool	contains (const std::string &key, const std::type_info &ti, bool metadata)
	Internal function checking if an object is in the input. More...
bool	transientContains (const std::string &key, const std::type_info &ti, bool metadata) const
	Internal function checking if an object is already in memory. More...
void *	getOutputObject (const std::string &key, const std::type_info &ti, bool metadata) const
	Function for retrieving an output object in a non-template way. More...
const void *	getInputObject (const std::string &key, const std::type_info &ti, bool silent, bool metadata)
	Function for retrieving an input object in a non-template way. More...
StatusCode	recordTypeless (void *obj, const std::string &typeName, const std::string &key, bool overwrite=false, bool metadata=true, bool isOwner=true)
	Internal function for recording an object into the output. More...

Protected Attributes
Object_t	m_inputObjects
	Collection of all the managed input objects. More...
std::set< std::string >	m_inputMissingObjects
	Objects that have been asked for, but were found to be missing in the current input. More...
Object_t	m_outputObjects
	Collection of all the managed output object. More...
Object_t	m_inputMetaObjects
	Collection of all the managed input meta-objects. More...
Object_t	m_outputMetaObjects
	Collection of all the managed output meta-objects. More...
EventFormat	m_inputEventFormat
	Format of the current input file. More...
EventFormat *	m_outputEventFormat = nullptr
	Format of the current output file. More...
std::unordered_map< std::string, std::set< std::string > >	m_auxItemList
	Rules for selecting which auxiliary branches to write. More...
std::vector< TVirtualIncidentListener * >	m_listeners
	Listeners who should be notified when certain incidents happen. More...
std::unordered_map< std::string, std::string >	m_nameRemapping
	Container name re-mapping rules. More...
bool	m_printEventProxyWarnings = false
	Option to silence common warnings that seem to be harmless. More...

Private Member Functions
StatusCode	initStats ()
	Function to initialise the statistics for all Tree content. More...
StatusCode	setUpDynamicStore (RObjectManager &mgr, ROOT::RNTupleReader &ntupleReader)
	event uses RNTupleReader: More...
void	initMessaging () const
	Initialize our message level and MessageSvc. More...

Private Attributes
std::unique_ptr< ROOT::RNTupleReader >	m_eventReader
	The main event data reader. More...
bool	m_inputNTupleIsMissing = false
	Whether the input has an event RNTuple or not. More...
std::unique_ptr< ROOT::RNTupleReader >	m_metaReader
	The metadata reader. More...
::Long64_t	m_entry
	The entry to look at from the input tree. More...
std::string	m_nm
	Message source name. More...
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...

Functions implementing the @c xAOD::TVirtualEvent interface
SG::sgkey_t	getHash (const std::string &key) const override
	Function returning the hash describing an object name. More...
SG::sgkey_t	getKey (const void *obj) const override
	Function returning the hash describing a known object. More...
const std::string &	getName (const void *obj) const override
	Function returning the key describing a known object. More...
const std::string &	getName (SG::sgkey_t hash) const override
	Function returning the key describing a known object. More...
void *	getOutputObject (SG::sgkey_t key, const std::type_info &ti) override
	Function for retrieving an output object in a non-template way. More...
const void *	getInputObject (SG::sgkey_t key, const std::type_info &ti, bool silent) override
	Function for retrieving an input object in a non-template way. More...

Variable(s) used in the @c IProxyDict implementation
using	upgrade_mutex_t = AthContainers_detail::upgrade_mutex
	Mutex type for multithread synchronization. More...
using	upgrading_lock_t = AthContainers_detail::upgrading_lock< upgrade_mutex_t >
	Lock type for multithread synchronization. More...
upgrade_mutex_t	m_branchesMutex
	Mutex for multithread synchronization. More...
SG::SGKeyMap< BranchInfo > m_branches	ATLAS_THREAD_SAFE
	Map from hashed sgkey to BranchInfo. More...

Detailed Description

Tool for accessing xAOD files outside of Athena, version RNTuple.

Proper access to xAOD files in ROOT (outside of Athena) needs to be done through such an object. It takes care of reading and writing xAOD files together with their file format metadata, setting up smart pointers correctly, etc.

Definition at line 28 of file REvent.h.

Member Typedef Documentation

Object_t

using xAOD::Event::Object_t = std::unordered_map<std::string, std::unique_ptr<TVirtualManager> >

protectedinherited

Definition of the internal data structure type.

Definition at line 304 of file Event.h.

sgkey_t

using xAOD::TVirtualEvent::sgkey_t = SG::sgkey_t

inherited

Definition at line 29 of file TVirtualEvent.h.

upgrade_mutex_t

using xAOD::Event::upgrade_mutex_t = AthContainers_detail::upgrade_mutex

protectedinherited

Mutex type for multithread synchronization.

Definition at line 349 of file Event.h.

upgrading_lock_t

using xAOD::Event::upgrading_lock_t = AthContainers_detail::upgrading_lock<upgrade_mutex_t>

protectedinherited

Lock type for multithread synchronization.

Definition at line 351 of file Event.h.

Constructor & Destructor Documentation

REvent()

xAOD::Experimental::REvent::REvent

(

)

Default constructor.

Definition at line 73 of file REvent.cxx.

: Event("xAOD::Experimental::REvent") {}

~REvent()

xAOD::Experimental::REvent::~REvent ( )

virtual

Destructor.

Definition at line 75 of file REvent.cxx.

                {
 
  // Clear the input and output objects before the input/output files would be
  // closed. Otherwise we can be left with RNTuple view objects pointing
  // nowhere.
  m_inputObjects.clear();
  m_outputObjects.clear();
}

Member Function Documentation

addListener()

StatusCode Event::addListener ( TVirtualIncidentListener *  listener )

inherited

Register an incident listener object.

This function works pretty much like IIncidentSvc::addListener does in Athena.

It tells the TEvent object that when certain "interesting incidents" happen, a given object should be notified about it.

Parameters

listener

Pointer to the object that should be notified

Returns

The usual StatusCode types

Definition at line 97 of file EventCore.cxx.

                                                                {
 
  // 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;
}

addNameRemap()

StatusCode Event::addNameRemap ( const std::string &  onfile, const std::string &  newName  )

inherited

Add a name re-mapping rule.

The names of containers can change during the lifetime of the experiment.

One such change happened after the DC14 exercise, when many containers got a new name. (Like "ElectronCollection" became simply "Electrons".)

This function allows us to create aliases with which certain containers should be accessible. So that the analyser would be able to access older files, while using the latest container name(s).

Parameters

onfile	The name of the container as it was saved into the input file
newName	The alias with which the object/container should be accessible

Returns

The usual StatusCode types

Save the new name association:

Definition at line 162 of file EventCore.cxx.

                                                         {
 
  // 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;
}

addToStore()

StatusCode Event::addToStore ( CLID  clid, SG::DataProxy *  proxy  )

overrideprotectedinherited

Add a new proxy to the store.

Smart pointers to objects that don't exist in the input event, can end up calling this function.

In this case warn the user that something fishy is happening, and take posession of the received proxy.

Parameters

clid	The CLID of the type. Not taken into account.
proxy	The proxy to take posession of. Not used for anything useful.

Definition at line 249 of file EventIProxyDict.cxx.

                                                          {
 
  upgrading_lock_t lock(m_branchesMutex);
 
  // Warn the user that the function got called:
  static std::atomic_flag warningPrinted ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT;
  if (!warningPrinted.test_and_set() && m_printEventProxyWarnings) {
    ATH_MSG_WARNING(
        "Function should only be called through an invalid ElementLink");
  }
 
  // Hold on to the proxy with some non-existent, hopefully unique key:
  const ::TString uniqueKey =
      ::TString::Format("NonExistentKey_%lu", m_branches.size());
  BranchInfo bi;
  bi.m_proxy.reset(proxy);
  lock.upgrade();
  m_branches.insert(
      std::make_pair(stringToKey(uniqueKey.Data(), clid), std::move(bi)));
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

clearListeners()

void Event::clearListeners ( )

inherited

Remove all listeners from the object.

This function can be used to remove all the listeners from the internal list.

Should not be necessary under regular circumstances.

Definition at line 143 of file EventCore.cxx.

                           {
 
  m_listeners.clear();
}

clearNameRemap()

void Event::clearNameRemap ( )

inherited

Clear the current name re-mapping.

This function simply clears out any existing name remapping declarations.

In case the remapping rules need to be changed in the code in some complicated way.

Definition at line 193 of file EventCore.cxx.

                           {
 
  m_nameRemapping.clear();
}

connectAux()

StatusCode xAOD::Experimental::REvent::connectAux ( const std::string &  prefix, bool  standalone  )

overrideprivatevirtual

Function setting up access to a set of auxiliary branches.

This function is used internally to connect an auxiliary object to the input.

Based on the configuration of the object it will either use TAuxStore, or the EDM object that was used to write the auxiliary information in Athena.

Parameters

prefix	The prefix (main branch name) of the auxiliary data
standalone	Type of the auxiliary store that should be created

Returns

kTRUE if the connection was successful, or kFALSE if it was not

Implements xAOD::Event.

Definition at line 576 of file REvent.cxx.

                                                                        {
 
  // A little sanity check.
  if (!m_eventReader) {
    ATH_MSG_ERROR("Function called on un-initialised object");
    return StatusCode::FAILURE;
  }
 
  // Check if the field is already connected.
  if (m_inputObjects.contains(prefix)) {
    return StatusCode::SUCCESS;
  }
 
  // Connect to the field as we would for any other.
  static constexpr bool SILENT = false;
  ATH_CHECK(connectObject(prefix, SILENT));
 
  // Access the object's manager.
  Object_t::const_iterator mgr_itr = m_inputObjects.find(prefix);
  if (mgr_itr == m_inputObjects.end()) {
    ATH_MSG_FATAL("There's a logic error in the code");
    return StatusCode::FAILURE;
  }
  const Details::IObjectManager* omgr =
      dynamic_cast<const RObjectManager*>(mgr_itr->second.get());
  if (omgr == nullptr) {
    ATH_MSG_FATAL("There's a logic error in the code");
    return StatusCode::FAILURE;
  }
 
  // Check if we can switch out the internal store of this object.
  static const TClass* const holderClass =
      TClass::GetClass(typeid(SG::IAuxStoreHolder));
  if (omgr->holder()->getClass()->InheritsFrom(holderClass) == false) {
    // Nope... So let's just end the journey here.
    return StatusCode::SUCCESS;
  }
 
  // Try to get the object as an IAuxStoreHolder.
  SG::IAuxStoreHolder* storeHolder = reinterpret_cast<SG::IAuxStoreHolder*>(
      omgr->holder()->getAs(typeid(SG::IAuxStoreHolder)));
  if (!storeHolder) {
    ATH_MSG_FATAL("There's a logic error in the code");
    return StatusCode::FAILURE;
  }
 
  // A sanity check to see whether the store's type is in sync with the
  // object's type that it will be connected to:
  if ((standalone &&
       (storeHolder->getStoreType() != SG::IAuxStoreHolder::AST_ObjectStore)) ||
      ((!standalone) && (storeHolder->getStoreType() !=
                         SG::IAuxStoreHolder::AST_ContainerStore))) {
    ATH_MSG_ERROR("Requested store types inconsistent for: " << prefix);
    ATH_MSG_ERROR("standalone = "
                  << standalone << ", getStoreType() = "
                  << static_cast<int>(storeHolder->getStoreType()));
    return StatusCode::FAILURE;
  }
 
  // Return gracefully.
  return StatusCode::SUCCESS;
}

connectMetaAux()

StatusCode xAOD::Experimental::REvent::connectMetaAux ( const std::string &  prefix, bool  standalone  )

overrideprivatevirtual

Function setting up access to a set of auxiliary branches for a metadata object.

This function is used internally to connect an auxiliary metadata object to the input.

Based on the configuration of the object it will either use TAuxStore, or the EDM object that was used to write the auxiliary information in Athena.

Parameters

prefix	The prefix (main branch name) of the auxiliary data
standalone	Type of the auxiliary store that should be created

Returns

The usual StatusCode types

Implements xAOD::Event.

Definition at line 648 of file REvent.cxx.

                                                     {
 
  // A little sanity check.
  if (!m_metaReader) {
    ATH_MSG_ERROR("Function called on un-initialised object");
    return StatusCode::FAILURE;
  }
 
  // Check if the field is already connected.
  if (m_inputMetaObjects.contains(prefix)) {
    return StatusCode::SUCCESS;
  }
 
  // Connect to the field as we would for any other.
  static constexpr bool SILENT = false;
  ATH_CHECK(connectMetaObject(prefix, SILENT));
 
  // Access the object's manager.
  Object_t::const_iterator mgr_itr = m_inputMetaObjects.find(prefix);
  if (mgr_itr == m_inputMetaObjects.end()) {
    ATH_MSG_FATAL("There's a logic error in the code");
    return StatusCode::FAILURE;
  }
  const Details::IObjectManager* omgr =
      dynamic_cast<const RObjectManager*>(mgr_itr->second.get());
  if (omgr == nullptr) {
    ATH_MSG_FATAL("There's a logic error in the code");
    return StatusCode::FAILURE;
  }
 
  // Check if we can switch out the internal store of this object.
  static const TClass* const holderClass =
      TClass::GetClass(typeid(SG::IAuxStoreHolder));
  if (omgr->holder()->getClass()->InheritsFrom(holderClass) == false) {
    // Nope... So let's just end the journey here.
    return StatusCode::SUCCESS;
  }
 
  // Try to get the object as an IAuxStoreHolder.
  SG::IAuxStoreHolder* storeHolder = reinterpret_cast<SG::IAuxStoreHolder*>(
      omgr->holder()->getAs(typeid(SG::IAuxStoreHolder)));
  if (!storeHolder) {
    ATH_MSG_FATAL("There's a logic error in the code");
    return StatusCode::FAILURE;
  }
 
  // A sanity check to see whether the store's type is in sync with the
  // object's type that it will be connected to:
  if ((standalone &&
       (storeHolder->getStoreType() != SG::IAuxStoreHolder::AST_ObjectStore)) ||
      ((!standalone) && (storeHolder->getStoreType() !=
                         SG::IAuxStoreHolder::AST_ContainerStore))) {
    ATH_MSG_ERROR("Requested store types inconsistent for: " << prefix);
    ATH_MSG_ERROR("standalone = "
                  << standalone << ", getStoreType() = "
                  << static_cast<int>(storeHolder->getStoreType()));
    return StatusCode::FAILURE;
  }
 
  // Return gracefully.
  return StatusCode::SUCCESS;
}

connectMetaObject()

StatusCode xAOD::Experimental::REvent::connectMetaObject ( const std::string &  key, bool  silent  )

overrideprivatevirtual

Function setting up access to a particular metadata object.

This is the function doing the heavy lifting with creating metadata objects in memory out of the payload of the input file.

Parameters

key	The key (branch name) of the metadata object to retrieve
silent	Set to kTRUE to make the code fail silently in case the branch can't be connected to

Returns

The usual StatusCode types

Implements xAOD::Event.

Definition at line 490 of file REvent.cxx.

                                                                      {
 
  // A little sanity check.
  if (!m_metaReader) {
    ATH_MSG_ERROR("Function called on un-initialised object");
    return StatusCode::FAILURE;
  }
 
  // Check if the branch is already connected.
  if (m_inputMetaObjects.contains(key)) {
    return StatusCode::SUCCESS;
  }
 
  // RNTuples store fields with an "Aux:" postfix instead of "Aux.".
  std::string key_to_read = key;
  if (key.ends_with("Aux.")) {
    key_to_read.replace(key_to_read.size() - 1, 1, ":");
  }
 
  // Check if the field exists in our input RNTuple.
  if (m_metaReader->GetDescriptor().FindFieldId(key_to_read.c_str()) ==
      ROOT::kInvalidDescriptorId) {
    // Field doesn't exist
    if (!silent) {
      ATH_MSG_WARNING("Field \"" << key_to_read << "\" not available on input");
    }
    return StatusCode::RECOVERABLE;
  }
 
  // RDS: may need some logic here to get type from inputEventFormat rather than
  // the view
  //      to read in with automatic schema evolution
 
  // Get class name from the field
  ROOT::RNTupleView<void> view =
      m_metaReader->GetView<void>(key_to_read.c_str(), nullptr);
  std::string className = view.GetField().GetTypeName();
  if (className == "") {
    ATH_MSG_ERROR(
        "Couldn't find an appropriate type with a dictionary for field \""
        << key_to_read << "\"");
    return StatusCode::FAILURE;
  }
  ::TClass* realClass = ::TClass::GetClass(className.c_str());
  if ((!realClass) || (!realClass->IsLoaded())) {
    // Now we're in trouble...
    ATH_MSG_ERROR(
        "Couldn't find an appropriate type with a dictionary for field \""
        << key_to_read << "\"");
    return StatusCode::FAILURE;
  }
 
  // Create the object and the manager(s) around it.
  void* ptr = realClass->New();
  static const ::Long64_t FIRST_ENTRY = 0;
  auto mgr = std::make_unique<RObjectManager>(
      m_metaReader->GetView(key_to_read, ptr, className), FIRST_ENTRY,
      std::make_unique<THolder>(ptr, realClass));
  RObjectManager* mgrPtr = mgr.get();
  m_inputMetaObjects[key] = std::move(mgr);
 
  // If it's an auxiliary store object, set it up correctly.
  if (Details::isAuxStore(*(mgrPtr->holder()->getClass()))) {
    ATH_CHECK(setUpDynamicStore(*mgrPtr, *m_metaReader));
  }
 
  // If it (probably) has an associated auxiliary store, set it up as well.
  if (Details::hasAuxStore(*(mgrPtr->holder()->getClass()))) {
    ATH_CHECK(connectMetaAux(
        key + "Aux.", Details::isStandalone(*(mgrPtr->holder()->getClass()))));
  }
 
  // Return gracefully.
  return StatusCode::SUCCESS;
}

connectObject()

StatusCode xAOD::Experimental::REvent::connectObject ( const std::string &  key, bool  silent  )

overrideprivatevirtual

Function setting up access to a particular object.

This is one of the more important functions of the class.

It connects the event object to a given field of the input RNTuple.

The type that is read in to memory is not actually determined by the type written to the ntuple itself, but from the xAOD::EventFormat object. Which is there to make it possible to possibly use ROOT read rules to read a different type than what's on disk.

Everything else is fairly basic ROOT stuff, the code just has to make sure that the memory management is set up correctly for the created object.

Parameters

key	The name of the branch to connect to
silent	Set to true to make the code fail silently in case the field can't be connected to

Returns

The usual StatusCode values

Implements xAOD::Event.

Definition at line 352 of file REvent.cxx.

                                                                    {
 
  // A little sanity check.
  if (!m_eventReader) {
    ATH_MSG_ERROR("Function called on un-initialised object");
    return StatusCode::FAILURE;
  }
 
  // Increment the access counter on this container.
  IOStats::instance().stats().readContainer(key);
 
  // Check if the branch is already connected.
  if (m_inputObjects.contains(key)) {
    return StatusCode::SUCCESS;
  }
  // Check if it was already found to be missing.
  if (m_inputMissingObjects.contains(key)) {
    if (!silent) {
      ATH_MSG_WARNING("Field \"" << key << "\" not available on input");
    }
    return StatusCode::RECOVERABLE;
  }
 
  // Tell the user what's happening.
  ATH_MSG_DEBUG("Connecting to branch \"" << key << "\"");
 
  // Check if we have metadata about this branch.
  const xAOD::EventFormatElement* ef = nullptr;
 
  // RNTuples store fields with an "Aux:" postfix instead of "Aux.".
  std::string key_to_read = key;
  if (key.ends_with("Aux.")) {
    key_to_read.replace(key_to_read.size() - 1, 1, ":");
  }
 
  if (m_inputEventFormat.exists(key) == false) {
    if (!silent) {
      ATH_MSG_WARNING("No metadata available for object: " << key);
    }
  } else {
    ef = m_inputEventFormat.get(key);
  }
 
  // Check if the field exists in our input RNTuple.
  if (m_eventReader->GetDescriptor().FindFieldId(key_to_read.c_str()) ==
      ROOT::kInvalidDescriptorId) {
    // Field doesn't exist
    if (!silent) {
      ATH_MSG_WARNING("Field \"" << key_to_read << "\" not available on input");
    }
    m_inputMissingObjects.insert(key);
    return StatusCode::RECOVERABLE;
  }
 
  // RDS: may need some logic here to get type from inputEventFormat rather than
  // the view
  //      to read in with automatic schema evolution
 
  // Get class name from the field
  ROOT::RNTupleView<void> view =
      m_eventReader->GetView<void>(key_to_read.c_str(), nullptr);
  std::string className = view.GetField().GetTypeName();
  if (className == "") {
    if (ef) {
      // This is a fairly weird situation, but let's fall back to taking
      // the class name from the metadata object in this case.
      className = ef->className();
    } else {
      ATH_MSG_ERROR(
          "Couldn't find an appropriate type with a dictionary for field \""
          << key_to_read << "\"");
      return StatusCode::FAILURE;
    }
  }
  ::TClass* realClass = ::TClass::GetClass(className.c_str());
  if (((!realClass) || (!realClass->IsLoaded())) && ef) {
    // We may need to do an actual schema evolution here, in which
    // case let's fall back on the class name coming from the metadata
    // object.
    className = ef->className();
    realClass = ::TClass::GetClass(className.c_str());
  }
  if ((!realClass) || (!realClass->IsLoaded())) {
    // Now we're in trouble...
    ATH_MSG_ERROR(
        "Couldn't find an appropriate type with a dictionary for field \""
        << key_to_read << "\"");
    return StatusCode::FAILURE;
  }
 
  // Make sure that the current object is the "active event":
  setActive();
 
  // Check if the output already has this object. If it does, let's
  // assume that we have been copying the object to the output. Which
  // means that we need to resume filling the same memory address that
  // the output holder points to.
  void* ptr = nullptr;
 
  // Handle the case where an output object with this key already exists.
 
  // If there is no output object, then let's create one ourselves.
  // This is the only way in which we can have the memory management of
  // THolder do the right thing with this object.
  if (ptr == nullptr) {
    ptr = realClass->New();
  }
 
  // Create the new manager object that will hold this EDM object.
  auto mgr = std::make_unique<RObjectManager>(
      m_eventReader->GetView(key_to_read, ptr, className), m_entry,
      std::make_unique<THolder>(ptr, realClass));
  RObjectManager* mgrPtr = mgr.get();
  m_inputObjects[key] = std::move(mgr);
 
  // If it's an auxiliary store object, set it up correctly.
  if (Details::isAuxStore(*(mgrPtr->holder()->getClass()))) {
    ATH_CHECK(setUpDynamicStore(*mgrPtr, *m_eventReader));
  }
 
  // If it (probably) has an associated auxiliary store, set it up as well.
  if (Details::hasAuxStore(*(mgrPtr->holder()->getClass()))) {
    ATH_CHECK(connectAux(
        key + "Aux.", Details::isStandalone(*(mgrPtr->holder()->getClass()))));
  }
 
  // Return gracefully.
  return StatusCode::SUCCESS;
}

contains() [1/2]

template<typename T >

bool xAOD::Event::contains ( const std::string &  key )

inherited

Function checking if an object is available from the store.

contains() [2/2]

bool xAOD::Event::contains ( const std::string &  key, const std::type_info &  ti, bool  metadata  )

protectedinherited

Internal function checking if an object is in the input.

containsMeta()

template<typename T >

bool xAOD::Event::containsMeta ( const std::string &  key )

inherited

Function checking if a meta-object is available from the store.

copy()

StatusCode Event::copy ( const std::string &  pattern = ".*" )

inherited

Copy an object directly from the input to the output.

This function can be used to easily copy a given (set of) object/container(s) to the output, without modifying the contents of it/them.

It only needs to be called on the interface object/container(s), the copying of the auxiliary data is done automatically, and is steered by the xAOD::Event::setAuxItemList function.

Parameters

pattern

Regular expression for the key(s)/name(s) of the object(s)/container(s) to copy

Definition at line 28 of file EventIO.cxx.

                                               {
 
  // Tell the user what's happening.
  ATH_MSG_DEBUG("Copying objects matching pattern \"" << pattern
                                                      << "\" to the output");
 
  // Collect a list of keys to copy.
  std::set<std::string> keys;
 
  // The regular expression to use.
  std::regex re{pattern};
 
  // Loop over the known input containers.
  for (const auto& [key, efe] : m_inputEventFormat) {
 
    // Tell the user what's happening.
    ATH_MSG_VERBOSE("Considering input object with key \"" << key << "\"");
 
    // Check if the class in question matches the requested pattern.
    if (std::regex_match(key, re) == false) {
      continue;
    }
    // Ignore objects that don't exist on the input.
    static const bool SILENT = true;
    if (connectObject(key, SILENT).isSuccess() == false) {
      continue;
    }
    // Skip all branches ending in "Aux.":
    if (key.ends_with("Aux.")) {
      continue;
    }
    // Also skip dynamic branches:
    if (efe.parentName() != "") {
      continue;
    }
    // Add the key to the list.
    ATH_MSG_VERBOSE("Matched key \"" << key << "\"");
    keys.insert(key);
  }
 
  // Check if the pattern matches any of the name remapping rules.
  for (const auto& [newname, onfile] : m_nameRemapping) {
 
    // Tell the user what's happening.
    ATH_MSG_VERBOSE("Considering remapped key \"" << newname << "\"");
 
    // Check if the remapped name matches the pattern.
    if (std::regex_match(newname, re) == false) {
      continue;
    }
    // Ignore objects that don't exist on the input.
    static const bool SILENT = true;
    if (connectObject(onfile, SILENT).isSuccess() == false) {
      continue;
    }
    // Add the remapped name to the list.
    ATH_MSG_VERBOSE("Matched remapped key \"" << newname << "\"");
    keys.insert(newname);
  }
 
  // Now loop over all of the found keys.
  for (const std::string& key : keys) {
 
    // Check if a name re-mapping should be applied or not.
    std::string keyToUse = key;
    auto remap_itr = m_nameRemapping.find(key);
    if ((remap_itr != m_nameRemapping.end()) &&
        (!m_inputEventFormat.exists(key)) &&
        m_inputEventFormat.exists(remap_itr->second)) {
      keyToUse = remap_itr->second;
    }
 
    // Make sure that the input object got connected to.
    static const bool SILENT = false;
    ATH_CHECK(connectObject(keyToUse, SILENT));
 
    // Make sure that the input object is properly updated.
    Object_t::const_iterator vobjMgr = m_inputObjects.find(keyToUse);
    if (vobjMgr == m_inputObjects.end()) {
      ATH_MSG_FATAL("Internal logic error detected");
      return StatusCode::FAILURE;
    }
    Details::IObjectManager* objMgr =
        dynamic_cast<Details::IObjectManager*>(vobjMgr->second.get());
    if (objMgr == nullptr) {
      ATH_MSG_FATAL("Internal logic error detected");
      return StatusCode::FAILURE;
    }
    static const bool METADATA = false;
    if (getInputObject(keyToUse, *(objMgr->holder()->getClass()->GetTypeInfo()),
                       SILENT, METADATA) == nullptr) {
      ATH_MSG_FATAL("Internal logic error detected");
      return StatusCode::FAILURE;
    }
 
    // Put the interface object into the output.
    static const bool OVERWRITE = true;
    static const bool IS_OWNER = true;
    ATH_CHECK(record(objMgr->object(), objMgr->holder()->getClass()->GetName(),
                     key, OVERWRITE, METADATA, IS_OWNER));
 
    // If there is also an auxiliary store for this object/container, copy that
    // as well.
    const std::string auxKey = keyToUse + "Aux.";
    if (m_inputObjects.contains(auxKey)) {
      ATH_CHECK(
          recordAux(*(m_inputObjects.at(auxKey)), key + "Aux.", METADATA));
    }
  }
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

dump()

std::string Event::dump ( )

inherited

Function creating a user-readable dump of the current input.

This function behaves exactly like StoreGateSvc::dump().

It doesn't actually print anything to the screen, it just returns a user readable dump of the contents of the current input file/chain.

It is a pretty dumb implementation for the moment. Should be made nicer later on.

Returns

The user-readable contents of the current input file/chain

Definition at line 250 of file EventCore.cxx.

                      {
 
  // 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();
}

getBranchInfo()

const Event::BranchInfo * Event::getBranchInfo ( SG::sgkey_t  sgkey ) const

protectedinherited

Get the object describing one object/branch.

Definition at line 345 of file EventIProxyDict.cxx.

                                                                 {
 
  {
    // We can only hold the lock (even though it's a shared lock) for
    // this limited scope because the call to getInputObject below
    // leads to a recursion and dead-lock if not released immediately.
    upgrading_lock_t lock(m_branchesMutex);
 
    // If the object already exists, return it:
    auto it = m_branches.find(sgkey);
    if (it != m_branches.end()) {
      return &(it->second);
    }
  }
 
  // If not, construct it now:
  BranchInfo bi;
  const xAOD::EventFormatElement* efe = getEventFormatElement(sgkey);
  if (!efe) {
    // Apparently this key is not known:
    return nullptr;
  }
 
  // Helper variable(s).
  static const bool SILENT = true;
  static const bool METADATA = false;
 
  // The name of the requested object.
  const std::string& name = getName(sgkey);
  // This is a bit perverse... In order to let the "base class" figure
  // out the exact type of this object, we ask for it with an "Event
  // pointer". I use that type because I need something that has a
  // dictionary, and which should always be available when this code
  // runs. In the end it doesn't matter that the object can't be
  // retrieved as that type (of course...), it only matters that it gets
  // "set up" following these calls.
  Event* nc_this = const_cast<Event*>(this);
  static const std::type_info& dummy = typeid(Event);
  nc_this->getInputObject(name, dummy, SILENT, METADATA);
  auto itr = m_outputObjects.find(name);
  if (itr == m_outputObjects.end()) {
    itr = m_inputObjects.find(name);
    if (itr == m_inputObjects.end()) {
      // We didn't find this object in the store...
      return nullptr;
    }
  }
  const Details::IObjectManager* mgr =
      dynamic_cast<const Details::IObjectManager*>(itr->second.get());
  if (!mgr) {
    ATH_MSG_ERROR("Internal logic error found");
    return nullptr;
  }
  bi.m_class = mgr->holder()->getClass();
  // There's no need to check whether this is a "proper" dictionary
  // at this point, since if TEvent is holding on to it, the type
  // must have a proper compiled dictionary.
 
#ifndef XAOD_STANDALONE
  // Create a proper proxy for the input branch:
  SG::TransientAddress* taddr = new SG::TransientAddress(
      CLID_NULL, efe->branchName(), new GenericAddress());
  taddr->setSGKey(sgkey);
  xAODPrivate::Loader* loader = new xAODPrivate::Loader(
      *nc_this, getName(sgkey), *bi.m_class->GetTypeInfo());
  bi.m_proxy.reset(new SG::DataProxy(taddr, loader));
  loader->setProxy(*bi.m_proxy.get());
#endif  // not XAOD_STANDALONE
 
  // Add the branch info to our list:
  upgrading_lock_t lock(m_branchesMutex);
  lock.upgrade();
  auto ret = m_branches.insert(std::make_pair(sgkey, std::move(bi)));
 
  // Return a pointer to the branch info:
  return &(ret.first->second);
}

getEntries()

Long64_t xAOD::Experimental::REvent::getEntries

(

)

const

Get how many entries are available from the current input file(s)

Returns

The number of events in the input file(s)

Definition at line 252 of file REvent.cxx.

                                  {
 
  if (m_eventReader) {
    return m_eventReader->GetNEntries();
  } else if (m_inputNTupleIsMissing) {
    return 0u;
  } else {
    ATH_MSG_ERROR("Function called on an uninitialised object");
    return 0u;
  }
}

getEntry()

Int_t xAOD::Experimental::REvent::getEntry	(	::Long64_t	entry,
		::Int_t	getall = 0
	)

Function loading a given entry of the input TTree.

This function is used to move to looking at a new entry from the input ntuple.

It doesn't do any I/O operation at this point, it just remembers which entry the objects should be loaded from later on.

Unless one calls the function with getall==1. In that case all input is force-read. This is necessary when writing out an event that was processed in a load-on-request manner.

Parameters

entry	The entry from the input tree to load
getall	Parameter deciding if partial reading should be used or not.

Returns

The number of bytes read, or a negative number in case of an error

Definition at line 278 of file REvent.cxx.

                                                   {
 
  // A little sanity check:
  if (!m_eventReader) {
    ATH_MSG_ERROR("Function called on an uninitialised object");
    return -1;
  }
 
  // Check if anything needs to be done.
  if (entry == m_entry) {
    ATH_MSG_DEBUG("Entry " << entry << " is already the active one");
    return 0;
  }
 
  // Set entry value
  m_entry = entry;
 
  // Stats counter needs to know it's the next event.
  IOStats::instance().stats().nextEvent();
 
  // Loop over all input object managers, and force them to load their
  // content. But only if getall was used.
  ::Int_t result = 0;
  if (getall) {
    for (auto& [key, inObj] : m_inputObjects) {
      result += inObj->getEntry(getall);
    }
  }
 
  // Notify the listeners that a new event was loaded.
  const TIncident incident(IncidentType::BeginEvent);
  for (TVirtualIncidentListener* listener : m_listeners) {
    listener->handle(incident);
  }
 
  // Return the number of bytes read.
  return result;
}

getEventFormatElement()

const xAOD::EventFormatElement * Event::getEventFormatElement ( SG::sgkey_t  sgkey ) const

protectedinherited

Get the metadata object for a given "SG key".

Definition at line 319 of file EventIProxyDict.cxx.

                           {
 
  const xAOD::EventFormatElement* efe = nullptr;
  static const bool QUIET = true;
  if (m_outputEventFormat) {
    efe = m_outputEventFormat->get(sgkey, QUIET);
  }
  if (!efe) {
    efe = m_inputEventFormat.get(sgkey, QUIET);
  }
  if (!efe) {
    static SG::SGKeySet missingSGKeys ATLAS_THREAD_SAFE;
    static mutex_t mutex;
    guard_t lock(mutex);
    if (missingSGKeys.emplace(sgkey).second) {
      if (m_printEventProxyWarnings) {
        ATH_MSG_WARNING(
            "Can't find EventFormatElement for hashed SG key: " << sgkey);
      }
      return 0;
    }
  }
  return efe;
}

getHash()

SG::sgkey_t Event::getHash ( const std::string &  key ) const

overridevirtualinherited

Function returning the hash describing an object name.

This helper function is mostly needed by the smart pointers of the xAOD EDM.

Right now it very simply just calculates the hash just based on the key given to the function. But later on it might be good to do some tests here, checking if the event format knows about the specified key or not. This is why it's not made to be a static function

Parameters

key	String key to turn into a hash

Returns

A hash corresponding to the specified string key

Implements xAOD::TVirtualEvent.

Definition at line 27 of file EventTVirtualEvent.cxx.

                                                   {
 
  // For empty keys let's finish quickly.
  if (key == "") {
    return 0;
  }
 
  // If the key is used in the input file, let's use the same hash for
  // the output file as well.
  if (m_inputEventFormat.exists(key)) {
    return m_inputEventFormat.get(key)->hash();
  }
 
  // If it's a new key, make a new hash for it from scratch:
  return Utils::hash(key);
}

getInputObject() [1/2]

const void * Event::getInputObject ( const std::string &  key, const std::type_info &  ti, bool  silent, bool  metadata  )

protectedinherited

Function for retrieving an input object in a non-template way.

This is the function doing the heavy lifting to retrieve objects from the input file.

Parameters

key	The key (branch name) of the object to retrieve
ti	The type as which the object is to be retrieved
silent	Set to kTRUE to make the code fail silently in case the object can't be retrieved
metadata	Flag deciding whether we're looking for a metadata or event data object

Returns

A pointer to the input object if successful, or a null pointer if not

Definition at line 218 of file EventIO.cxx.

                                                 {
 
  // Check if a name remapping should be applied or not:
  std::string keyToUse = key;
  auto remap_itr = m_nameRemapping.find(key);
  if ((remap_itr != m_nameRemapping.end()) &&
      (!m_inputEventFormat.exists(key)) &&
      m_inputEventFormat.exists(remap_itr->second)) {
    keyToUse = remap_itr->second;
  }
 
  // The following catches the cases when we ask for a transient
  // ConstDataVector object to be returned as "const DataVector".
  TStore* store = TActiveStore::store();
  if (store && store->contains(keyToUse, ti) && store->isConst(keyToUse, ti)) {
    const void* result = store->getConstObject(keyToUse, ti);
    return result;
  }
 
  // A sanity check before checking for an object from the input file.
  if (hasInput() == false) {
    if (silent == false) {
      ATH_MSG_WARNING("No input file connected to the Event object");
    }
    return nullptr;
  }
 
  // Make sure that the requested input is connected to.
  const StatusCode sc = (metadata ? connectMetaObject(keyToUse, silent)
                                  : connectObject(keyToUse, silent));
  if (sc.isSuccess() == false) {
    return nullptr;
  }
 
  // Select which object container to use:
  Object_t& objects = (metadata ? m_inputMetaObjects : m_inputObjects);
 
  // Access the object's manager:
  auto itr = objects.find(keyToUse);
  if (itr == objects.end()) {
    ATH_MSG_FATAL("There is an internal logic error in the code...");
    return nullptr;
  }
 
  // This has to be an ObjectManager object:
  Details::IObjectManager* mgr =
      dynamic_cast<Details::IObjectManager*>(itr->second.get());
  if (mgr == nullptr) {
    if (key == keyToUse) {
      ATH_MSG_ERROR("Object of wrong type found for key \"" << key << "\"");
    } else {
      ATH_MSG_ERROR("Object of wrong type found for key \""
                    << key << "\"/\"" << keyToUse << "\"");
    }
    return nullptr;
  }
 
  // Make sure that the current entry is loaded for event data objects.
  if (metadata == false) {
    const Int_t readBytes = mgr->getEntry();
    if (readBytes > 0) {
      // Connect the auxiliary store to objects needing it. This call also
      // takes care of updating the dynamic store of auxiliary containers,
      // when they are getting accessed directly.
      static const bool IS_METADATA = false;
      if (setAuxStore(key, *mgr, IS_METADATA).isSuccess() == false) {
        ATH_MSG_ERROR("Failed to set the auxiliary store for "
                      << mgr->holder()->getClass()->GetName() << "/"
                      << keyToUse);
        return nullptr;
      }
    } else if (readBytes < 0) {
      ATH_MSG_ERROR("Failed to load current entry for object "
                    << mgr->holder()->getClass()->GetName() << "/" << keyToUse);
      return nullptr;
    }
  }
 
  // Ask the holder object for the object of this type:
  const void* result = mgr->holder()->getAsConst(ti, silent);
  if (result == nullptr) {
    if (!silent) {
      ATH_MSG_WARNING("Could not retrieve object with key \""
                      << keyToUse << "\" as \""
                      << SG::normalizedTypeinfoName(ti) << "\"");
    }
    return nullptr;
  }
 
  // We succeeded:
  return result;
}

getInputObject() [2/2]

const void * Event::getInputObject ( SG::sgkey_t  key, const std::type_info &  ti, bool  silent  )

overrideprotectedvirtualinherited

Function for retrieving an input object in a non-template way.

This function is used by the TVirtualEvent interface to access an input object with a given hashed key.

The function looks up the string key belonging to the hash, and then calls the other GetInputObject(...) function in the class with that parameter.

Parameters

key	The hashed key of the input object
ti	The type description of the object requested
silent	Switch for being silent about failures or not

Returns

A pointer to the requested object, or a null pointer in case of failure

Implements xAOD::TVirtualEvent.

Definition at line 162 of file EventTVirtualEvent.cxx.

                                               {
 
  // Get a string name for this key:
  const std::string& name = getName(key);
  if (name.empty() && (silent == false)) {
    ATH_MSG_WARNING("Key 0x" << std::hex << key << " unknown");
    return nullptr;
  }
 
  // Forward the call to the function using an std::string key:
  static const bool METADATA = false;
  return getInputObject(name, ti, silent, METADATA);
}

getKey()

SG::sgkey_t Event::getKey ( const void *  obj ) const

overridevirtualinherited

Function returning the hash describing a known object.

This function is used by the smart pointer code to find the identifier of an object that's already in the event in some way.

Parameters

obj	Pointer to the object that we want to look up

Returns

The hashed identifier of the object, or 0 if the object was not found in the event

Implements xAOD::TVirtualEvent.

Definition at line 51 of file EventTVirtualEvent.cxx.

                                             {
 
  // Make use of the getName function.
  return getHash(getName(obj));
}

getName() [1/2]

const std::string & Event::getName ( const void *  obj ) const

overridevirtualinherited

Function returning the key describing a known object.

This function is used by the smart pointer code to find the identifier of an object that's already in the event in some way.

Parameters

obj	Pointer to the object that we want to look up

Returns

The name of the object, or an empty string if the object was not found in the event

Implements xAOD::TVirtualEvent.

Definition at line 64 of file EventTVirtualEvent.cxx.

                                                     {
 
  // First look among the output objects.
  for (const auto& [key, manager] : m_outputObjects) {
    // Check if this is our object.
    if (manager->object() == obj) {
      // If it is, let's return right away.
      return key;
    }
  }
 
  // Now look among the input objects.
  for (const auto& [key, manager] : m_inputObjects) {
    // Check if this is our object.
    if (manager->object() == obj) {
      // If it is, let's return.
      return key;
    }
  }
 
  // If it's not there either, check if it's in an active TStore object:
  const TStore* store = TActiveStore::store();
  if (store && store->contains(obj)) {
    // Get the name from the store then:
    return store->getName(obj);
  }
 
  // We didn't find the object in the event...
  ATH_MSG_WARNING("Didn't find object with pointer \"" << obj
                                                       << "\" in the event");
  static const std::string dummy;
  return dummy;
}

getName() [2/2]

const std::string & Event::getName ( SG::sgkey_t  hash ) const

overridevirtualinherited

Function returning the key describing a known object.

This function is used primarily when getting the string key of a smart pointer that we read in from a file, or access it in memory.

Parameters

hash	The hashed key for the container/object

Returns

The name of the object, or an empty string if the object was not found in the event

Implements xAOD::TVirtualEvent.

Definition at line 105 of file EventTVirtualEvent.cxx.

                                                    {
 
  // If the branch is known from the input:
  if (m_inputEventFormat.exists(hash)) {
    return m_inputEventFormat.get(hash)->branchName();
  }
 
  // If the branch is known on the output:
  if (m_outputEventFormat && m_outputEventFormat->exists(hash)) {
    return m_outputEventFormat->get(hash)->branchName();
  }
 
  // If this is an object in the active store:
  const TStore* store = TActiveStore::store();
  if (store && store->contains(hash)) {
    return store->getName(hash);
  }
 
  // If it is unknown:
  static const std::string dummy;
  return dummy;
}

getNames()

StatusCode xAOD::Experimental::REvent::getNames ( const std::string &  targetClassName, std::vector< std::string > &  vkeys, bool  metadata  ) const

overrideprivatevirtual

Function determining the list keys associated with a type name.

Implements xAOD::Event.

Definition at line 327 of file REvent.cxx.

                                          {
 
  ATH_MSG_ERROR("xAOD::REvent::getNames not yet implemented");
  return StatusCode::FAILURE;
}

getOutputObject() [1/2]

void * Event::getOutputObject ( const std::string &  key, const std::type_info &  ti, bool  metadata  ) const

protectedinherited

Function for retrieving an output object in a non-template way.

This function does the heavy lifting of retrieving object from the list of output objects.

While it returns a typeless pointer, that pointer can be cast directly to the type described by the second parameter in the caller code.

Parameters

key	The key (branch name) of the object to retrieve
ti	The type as which the object is to be retrieved
metadata	Flag deciding whether we're looking for a metadata or event data object

Returns

A pointer to the output object if successful, or a null pointer if not

Definition at line 154 of file EventIO.cxx.

                                                  {
 
  // Select which object container to use:
  const Object_t& objects = (metadata ? m_outputMetaObjects : m_outputObjects);
 
  // Check if the object can be found:
  auto itr = objects.find(key);
  if (itr == objects.end()) {
    // Do the following only for event data:
    if (!metadata) {
      // It's not in the event. Let's check if we find it in an active
      // TStore object...
      TStore* store = TActiveStore::store();
      if ((!store) || (!store->contains(key, ti)) || store->isConst(key, ti)) {
        // Nope, not there either...
        return nullptr;
      }
      // Let's return the object from the TStore:
      void* result = store->getObject(key, ti);
      return result;
    } else {
      // For metadata we don't use external resources.
      return nullptr;
    }
  }
 
  // If the object is not set in this event yet, we can't continue:
  if (itr->second->isSet() == false) {
    return nullptr;
  }
 
  // If it does exist, check if it's the right kind of object:
  Details::IObjectManager* mgr =
      dynamic_cast<Details::IObjectManager*>(itr->second.get());
  if (mgr == nullptr) {
    ATH_MSG_ERROR("Object of wrong type found for key \"" << key << "\"");
    return nullptr;
  }
 
  // Ask the holder object for the object of this type:
  void* result = mgr->holder()->getAs(ti);
  if (result == nullptr) {
    ATH_MSG_WARNING("Couldn't retrieve object as \""
                    << SG::normalizedTypeinfoName(ti) << "\"");
    return nullptr;
  }
 
  // Return the object:
  return result;
}

getOutputObject() [2/2]

void * Event::getOutputObject ( SG::sgkey_t  key, const std::type_info &  ti  )

overrideprotectedvirtualinherited

Function for retrieving an output object in a non-template way.

This function is used by the TVirtualEvent interface to access an output object with a given hashed key.

The function looks up the string key belonging to the hash, and then calls the other GetOutputObject(...) function in the class with that parameter.

Parameters

key	The hashed key of the output object
ti	The type description of the object requested

Returns

A pointer to the requested object, or a null pointer in case of failure

Implements xAOD::TVirtualEvent.

Definition at line 138 of file EventTVirtualEvent.cxx.

                                                                  {
 
  // Get a string name for this key.
  const std::string& name = getName(key);
  if (name.empty()) {
    return nullptr;
  }
 
  // Forward the call to the function using an std::string key.
  static const bool METADATA = false;
  return getOutputObject(name, ti, METADATA);
}

hasInput()

bool xAOD::Experimental::REvent::hasInput ( ) const

overrideprivatevirtual

Check if an input file is connected to the object.

Implements xAOD::Event.

Definition at line 317 of file REvent.cxx.

                            {
 
  return (m_eventReader || m_inputNTupleIsMissing);
}

hasOutput()

bool xAOD::Experimental::REvent::hasOutput ( ) const

overrideprivatevirtual

Check if an output file is connected to the object.

Implements xAOD::Event.

Definition at line 322 of file REvent.cxx.

                             {
 
  return false;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  m_lvl = m_imsg ?
    static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
    MSG::INFO;
}

initStats()

StatusCode xAOD::Experimental::REvent::initStats ( )

private

Function to initialise the statistics for all Tree content.

This function is used internally to initialise the reading of an input file.

It prepares the "monitoring information" in memory that gets filled while the code is running, with information about xAOD I/O.

Returns

The usual StatusCode values

Definition at line 850 of file REvent.cxx.

                             {
 
  // A little sanity check.
  if (!m_eventReader) {
    ATH_MSG_ERROR("Function called on an uninitialised object");
    return StatusCode::FAILURE;
  }
 
  // Reset the number of input branches information.
  IOStats::instance().stats().setBranchNum(0);
 
  // Loop over the EventFormat information.
  for (const auto& [key, format] : m_inputEventFormat) {
 
    ATH_MSG_DEBUG("Investigating object \"" << key << "\" of class \""
                                            << format.className() << "\"");
 
    // If it's an auxiliary container, scan it using RAuxStore.
    if (key.ends_with("Aux.")) {
 
      // But first decide whether it describes a container, or just
      // a single object. For that, first get the class that it was
      // written with.
      TClass* cl = TClass::GetClass(format.className().c_str());
      if ((cl == nullptr) || (cl->IsLoaded() == false)) {
        ATH_MSG_WARNING(
            "Couldn't find the dictionary for type: " << format.className());
        continue;
      }
 
      // And then check if it inherits from xAOD::AuxContainerBase or from
      // xAOD::AuxInfoBase.
      static TClass* const auxContCl = TClass::GetClass(
          SG::normalizedTypeinfoName(typeid(xAOD::AuxContainerBase)).c_str());
      static TClass* const auxInfoCl = TClass::GetClass(
          SG::normalizedTypeinfoName(typeid(xAOD::AuxInfoBase)).c_str());
      if ((auxContCl == nullptr) || (auxInfoCl == nullptr)) {
        ATH_MSG_ERROR(
            "Couldn't get dictionary for xAOD::AuxContainerBase or "
            "xAOD::AuxInfoBase");
        return StatusCode::FAILURE;
      }
      const bool isContainer = cl->InheritsFrom(auxContCl);
      const bool isInfo = cl->InheritsFrom(auxInfoCl);
      if ((isContainer == false) && (isInfo == false)) {
        ATH_MSG_WARNING("Auxiliary store \""
                        << key
                        << "\" is of an unknown type: " << format.className());
        continue;
      }
      ATH_MSG_VERBOSE("isContainer = " << isContainer
                                       << ", isInfo = " << isInfo);
 
      // Scan the branches using a temporary RAuxStore instance.
      const std::string fieldName = key.substr(0, key.size() - 1) + ":";
      const RAuxStore::EStructMode mode =
          (isContainer ? RAuxStore::EStructMode::kContainerStore
                       : RAuxStore::EStructMode::kObjectStore);
      static constexpr bool TOP_STORE = true;
      RAuxStore temp(fieldName, TOP_STORE, mode);
      ATH_CHECK(temp.readFrom(*m_eventReader));
 
      // Add all the auxids to the statistics object:
      ReadStats& stats = IOStats::instance().stats();
      for (SG::auxid_t id : temp.getAuxIDs()) {
        stats.branch(fieldName, id);
      }
 
      // Increment the number of known branches.
      stats.setBranchNum(stats.branchNum() + temp.getAuxIDs().size());
    }
    // If it's an interface container.
    else {
      // Check if it's part of the input ntuple.
      if (m_eventReader->GetDescriptor().FindFieldId(key) !=
          ROOT::kInvalidDescriptorId) {
        IOStats::instance().stats().container(key);
      }
    }
  }
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

inputEventFormat()

const EventFormat * Event::inputEventFormat ( ) const

inherited

Get information about the input objects.

Definition at line 228 of file EventCore.cxx.

                                                 {
 
  if (hasInput()) {
    return &m_inputEventFormat;
  }
  return nullptr;
}

keys()

template<typename T >

StatusCode xAOD::Event::keys ( std::vector< std::string > &  vkeys, bool  metadata  ) const

inherited

Provide a list of all data object keys associated with a specific type.

keyToString() [1/2]

const std::string * Event::keyToString ( SG::sgkey_t  key ) const

overrideprotectedinherited

Find the string corresponding to a given key.

Definition at line 292 of file EventIProxyDict.cxx.

                                                       {
 
  return &(getName(key));
}

keyToString() [2/2]

const std::string * Event::keyToString ( SG::sgkey_t  key, CLID &  clid  ) const

overrideprotectedinherited

Find the string and CLID corresponding to a given key.

Definition at line 297 of file EventIProxyDict.cxx.

                                                              {
 
  return &(getName(key));
}

metaKeys()

template<typename T >

StatusCode xAOD::Event::metaKeys ( std::vector< std::string > &  vkeys ) const

inherited

Provide a list of all metadata object keys associated with a specific type.

msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns

A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level  lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns

A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level  lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns

boolean Indicting if messages at given level will be printed

true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

name()

const std::string & Event::name ( ) const

overrideprotectedinherited

Get the name of the instance.

Definition at line 313 of file EventIProxyDict.cxx.

                                   {
 
  static const std::string result{"xAOD::Event"};
  return result;
}

outputEventFormat()

const EventFormat * Event::outputEventFormat ( ) const

inherited

Get information about the output objects.

Definition at line 236 of file EventCore.cxx.

                                                  {
 
  return m_outputEventFormat;
}

printIOStats()

void Event::printIOStats ( ) const

inherited

Function printing the I/O statistics of the current process.

This is a convenience function for printing basic I/O information about the current job.

It can be called at the end of a job to get an overview of what the job did exactly I/O-wise.

Definition at line 298 of file EventCore.cxx.

                               {
 
  // Simply do this via the xAODCore code:
  IOStats::instance().stats().Print("Summary");
}

printNameRemap()

void Event::printNameRemap ( ) const

inherited

Print the current name re-mapping rules.

This function can be used for debugging, to check what container/object name remapping rules are in place for the current TEvent object.

Definition at line 201 of file EventCore.cxx.

                                 {
 
  // 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 << "\"");
  }
}

printProxyWarnings()

void Event::printProxyWarnings ( bool  value = true )

inherited

Enable warnings associated with broken element links.

These appear harmless so long as you don't actually try to access the links.

Which will cause other errors anyway.

Parameters

value

The new value for the option

Definition at line 223 of file EventCore.cxx.

                                         {
 
  m_printEventProxyWarnings = value;
}

proxies()

std::vector< const SG::DataProxy * > Event::proxies ( ) const

overrideprotectedinherited

return the list of all current proxies in store

Definition at line 273 of file EventIProxyDict.cxx.

                                                   {
 
  upgrading_lock_t lock(m_branchesMutex);
 
  std::vector<const SG::DataProxy*> ret;
  for (const auto& p : m_branches) {
    const SG::DataProxy* proxy = p.second.m_proxy.get();
    if (proxy) {
      ret.push_back(proxy);
    }
  }
  return ret;
}

proxy() [1/2]

SG::DataProxy * Event::proxy ( const CLID &  id, const std::string &  key  ) const

overrideprotectedinherited

get proxy with given id and key. Returns 0 to flag failure

Definition at line 211 of file EventIProxyDict.cxx.

                                                                 {
 
  const SG::sgkey_t sgkey = getHash(key);
  if (!sgkey) {
    return 0;
  }
  return proxy_exact(sgkey);
}

proxy() [2/2]

SG::DataProxy * Event::proxy ( const void *const  pTransient ) const

overrideprotectedinherited

get proxy for a given data object address in memory

Definition at line 183 of file EventIProxyDict.cxx.

                                                            {
 
  // Look up the name of this object
  std::string name = getName(pTransient);
  if (name.empty()) {
    // Apparently the object is not known...
    return nullptr;
  }
 
  // Get the metadata object for it:
  const xAOD::EventFormatElement* efe = 0;
  static const bool QUIET = true;
  if (m_outputEventFormat) {
    efe = m_outputEventFormat->get(name, QUIET);
  }
  if (!efe) {
    efe = m_inputEventFormat.get(name, QUIET);
  }
  if (!efe) {
    // No metadata found...
    return nullptr;
  }
 
  // Return the proxy:
  const BranchInfo* bi = getBranchInfo(efe->hash());
  return bi->m_proxy.get();
}

proxy_exact()

SG::DataProxy * Event::proxy_exact ( SG::sgkey_t  sgkey ) const

overrideprotectedinherited

Get proxy given a hashed key+clid.

Definition at line 220 of file EventIProxyDict.cxx.

                                                     {
 
  // Get the object describing this branch/object:
  const BranchInfo* bi = getBranchInfo(sgkey);
  if (!bi) {
    static SG::SGKeySet missingSGKeys ATLAS_THREAD_SAFE;
    static mutex_t mutex;
    guard_t lock(mutex);
    if (missingSGKeys.emplace(sgkey).second && m_printEventProxyWarnings) {
      ATH_MSG_WARNING("Can't find BranchInfo for: " << sgkey);
    }
    return 0;
  }
 
  // Access its data proxy:
  SG::DataProxy* proxy = bi->m_proxy.get();
 
  // Return the proxy:
  return proxy;
}

readFrom()

StatusCode xAOD::Experimental::REvent::readFrom

(

std::string_view

fileName

)

Set up the reading of an input file.

This function takes care of connecting the event object to a new input file.

It reads in the metadata of the input file needed for reading the file.

Parameters

fileName

name of file needed for metadata access

Definition at line 90 of file REvent.cxx.

                                                   {
 
  // Clear the cached input objects.
  m_inputObjects.clear();
  m_inputMissingObjects.clear();
  m_inputMetaObjects.clear();
  {
    upgrading_lock_t lock(m_branchesMutex);
    lock.upgrade();
    m_branches.clear();
  }
  m_eventReader.reset();
 
  // Reset the internal flags.
  m_entry = -1;
  m_inputNTupleIsMissing = false;
 
  // Clear out the current object.
  m_inputEventFormat = {};
 
  // Set up a reader for the metadata ntuple.
  m_metaReader = ROOT::RNTupleReader::Open(METADATA_NTUPLE_NAME, fileName);
  if (!m_metaReader) {
    ATH_MSG_ERROR("Couldn't find \"" << METADATA_NTUPLE_NAME
                                     << "\" tree in input file: " << fileName);
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Created RNTupleReader for \"" << METADATA_NTUPLE_NAME
                                               << "\" in file: " << fileName);
 
  // Make sure that the xAOD::EventFormat dictonary is loaded.
  // This may not be the case if streamer information reading is turned
  // off.
  static const std::string eventFormatTypeName =
      Utils::getTypeName(typeid(EventFormat));
  if (::TClass::GetClass(eventFormatTypeName.c_str()) == nullptr) {
    ATH_MSG_WARNING("Couldn't load the EventFormat dictionary");
  }
  ATH_MSG_VERBOSE("Loaded the xAOD::EventFormat dictionary");
 
  // Helper lambda for collecting the event format metadata from an RNTuple
  // with a given name.
  auto readEventFormatMetadata = [&](std::string_view tupleName) -> StatusCode {
    // Set up a reader. This may technically be the same as m_metaReader, but
    // it's easier to write the code this way.
    auto metaReader = ROOT::RNTupleReader::Open(tupleName, fileName);
    if (!metaReader) {
      ATH_MSG_ERROR("Couldn't find \""
                    << tupleName << "\" ntuple in input file: " << fileName);
      return StatusCode::FAILURE;
    }
    ATH_MSG_VERBOSE("Created temporary RNTupleReader for \""
                    << tupleName << "\" in file: " << fileName);
 
    // Try to read in the event format metadata.
    const std::string eventFormatFieldName =
        getFirstFieldMatch(*m_metaReader, "EventFormat");
    try {
      // Add its elements to m_inputEventFormat.
      auto ef = m_metaReader->GetView<xAOD::EventFormat>(eventFormatFieldName);
      for (const auto& [key, element] : ef(0u)) {
        m_inputEventFormat.add(element);
      }
    } catch (const ROOT::RException&) {
      ATH_MSG_WARNING("Input file provides no event or metadata");
      return StatusCode::RECOVERABLE;
    }
    ATH_MSG_VERBOSE("Merged event format metadata from \"" << tupleName
                                                           << "\" ntuple");
 
    // Return gracefully.
    return StatusCode::SUCCESS;
  };
 
  // Read in the metadata from the "main" metadata ntuple.
  const StatusCode sc = readEventFormatMetadata(METADATA_NTUPLE_NAME);
  if (sc.isRecoverable()) {
    m_inputNTupleIsMissing = true;
    return StatusCode::SUCCESS;
  }
  ATH_CHECK(sc);
 
  // List all the other Metadata RNTuples in the input file.
  // Having several metadata tuples can happen for augmented files
  // as one metadata tree per stream is produced.
  std::set<std::string> lOtherMetaTupleNames;
  {
    std::unique_ptr<TFile> inFile(TFile::Open(fileName.data(), "READ"));
    TList* lKeys = inFile->GetListOfKeys();
    if (lKeys == nullptr) {
      ATH_MSG_ERROR("Could not get list of keys for input file: " << fileName);
      return StatusCode::FAILURE;
    }
    for (const TObject* obj : *lKeys) {
      const std::string keyName = obj->GetName();
      // Make sure the key corresponds to a metadata ntuple but
      // do not add the current metadata tree in the list of other trees
      // and do not add the metadata tree handlers to the list
      if ((keyName != METADATA_NTUPLE_NAME) &&
          (keyName.find("MetaData") != std::string::npos) &&
          (keyName.find("MetaDataHdr") == std::string::npos)) {
        // Make sure key corresponds to an RNTuple
        const TKey* key = dynamic_cast<const TKey*>(obj);
        if (key == nullptr) {
          ATH_MSG_ERROR("Object describing \"" << keyName << "\" in file \""
                                               << fileName
                                               << "\" is not a TKey?");
          return StatusCode::FAILURE;
        }
        const char* className = key->GetClassName();
        static constexpr bool LOAD = kFALSE;
        static constexpr bool SILENT = kTRUE;
        ::TClass* cl = ::TClass::GetClass(className, LOAD, SILENT);
        if ((cl != nullptr) && cl->InheritsFrom(ROOT::RNTuple::Class())) {
          lOtherMetaTupleNames.insert(keyName);
        }
      }
    }
  }
 
  // Read in the metadata from any additonal NTuples found (if any).
  for (const std::string& tupleName : lOtherMetaTupleNames) {
    ATH_CHECK(readEventFormatMetadata(tupleName));
  }
 
  // Set up the main ntuple reader.
  m_eventReader = ROOT::RNTupleReader::Open(EVENT_NTUPLE_NAME, fileName);
  if (!m_eventReader) {
    ATH_MSG_ERROR("Couldn't access RNTuple \"" << EVENT_NTUPLE_NAME
                                               << "\" in file: " << fileName);
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Created RNTupleReader for \"" << EVENT_NTUPLE_NAME
                                               << "\" in file: " << fileName);
 
  // Init the statistics collection.
  ATH_CHECK(initStats());
  // Update the event counter in the statistics object:
  xAOD::ReadStats& stats = IOStats::instance().stats();
  stats.setNEvents(stats.nEvents() + m_eventReader->GetNEntries());
 
  // Notify the listeners that a new file was opened:
  const TIncident beginIncident(IncidentType::BeginInputFile);
  for (TVirtualIncidentListener* listener : m_listeners) {
    listener->handle(beginIncident);
  }
  // For now implement a very simple scheme in which we claim already
  // at the start that the entire file was processed. Since we have no way
  // of ensuring that the user indeed does this. And we can't delay calling
  // this function, as the user may likely close his/her output file before
  // closing the last opened input file.
  const TIncident endIncident(IncidentType::EndInputFile);
  for (TVirtualIncidentListener* listener : m_listeners) {
    listener->handle(endIncident);
  }
 
  // The initialisation was successful:
  return StatusCode::SUCCESS;
}

record() [1/3]

template<typename T >

StatusCode xAOD::Event::record ( std::unique_ptr< T >  obj, const std::string &  key  )

inherited

Add an output object to the event, explicitly taking ownership of it.

record() [2/3]

template<typename T >

StatusCode xAOD::Event::record ( T *  obj, const std::string &  key  )

inherited

Add an output object to the event.

record() [3/3]

StatusCode xAOD::Experimental::REvent::record ( void *  obj, const std::string &  typeName, const std::string &  key, bool  overwrite, bool  metadata, bool  isOwner  )

overrideprivatevirtual

Record an object into a connected output file.

Implements xAOD::Event.

Definition at line 831 of file REvent.cxx.

                                      {
 
  ATH_MSG_ERROR("xAOD::REvent::record not yet implemented");
  return StatusCode::FAILURE;
}

recordAux()

StatusCode xAOD::Experimental::REvent::recordAux ( TVirtualManager &  mgr, const std::string &  key, bool  metadata  )

overrideprivatevirtual

Record an auxiliary store into a connected output file.

Implements xAOD::Event.

Definition at line 838 of file REvent.cxx.

                                                                     {
 
  ATH_MSG_ERROR("xAOD::REvent::recordAux not yet implemented");
  return StatusCode::FAILURE;
}

recordMeta() [1/2]

template<typename T >

StatusCode xAOD::Event::recordMeta ( std::unique_ptr< T >  obj, const std::string &  key  )

inherited

Add an object to the output file's metadata, explicitly taking ownership of it.

recordMeta() [2/2]

template<typename T >

StatusCode xAOD::Event::recordMeta ( T *  obj, const std::string &  key  )

inherited

Add an object to the output file's metadata.

recordObject()

SG::DataProxy * Event::recordObject ( SG::DataObjectSharedPtr< DataObject >  obj, const std::string &  key, bool  allowMods, bool  returnExisting  )

overrideprotectedinherited

Record an object in the store.

Definition at line 307 of file EventIProxyDict.cxx.

                                                                 {
 
  throw std::runtime_error("xAOD::Event::recordObject is not implemented");
}

recordTypeless()

StatusCode xAOD::Event::recordTypeless ( void *  obj, const std::string &  typeName, const std::string &  key, bool  overwrite = false, bool  metadata = true, bool  isOwner = true  )

protectedinherited

Internal function for recording an object into the output.

registerKey()

void Event::registerKey ( SG::sgkey_t  key, const std::string &  str, CLID  clid  )

overrideprotectedinherited

Remember an additional mapping from key to string/CLID.

Definition at line 302 of file EventIProxyDict.cxx.

                                                         {
 
  return;
}

removeListener()

StatusCode Event::removeListener ( TVirtualIncidentListener *  listener )

inherited

Remove an incident listener object.

This function allows us to remove a listener when for instance a metadata tool is deleted during a job.

Parameters

listener

Pointer to the listener that should be removed

Returns

The usual StatusCode types

Definition at line 126 of file EventCore.cxx.

                                                                   {
 
  // 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;
}

retrieve() [1/4]

template<typename T >

StatusCode xAOD::Event::retrieve ( const T *&  obj, const std::string &  key  )

inherited

Retrieve either an input or an output object from the event.

retrieve() [2/4]

template<typename T >

bool xAOD::TVirtualEvent::retrieve ( const T *&  obj, const std::string &  key, bool  silent = false  )

inherited

Function retrieving an object from the event (constant version)

retrieve() [3/4]

template<typename T >

bool xAOD::TVirtualEvent::retrieve ( const T *&  obj, sgkey_t  key = DEFAULT_KEY, bool  silent = false  )

inherited

Function retrieving an object from the event (constant version)

retrieve() [4/4]

template<typename T >

StatusCode xAOD::Event::retrieve ( T *&  obj, const std::string &  key  )

inherited

Retrieve an output object from the event.

retrieveMetaInput()

template<typename T >

StatusCode xAOD::Event::retrieveMetaInput ( const T *&  obj, const std::string &  key  )

inherited

Retrieve an input metadata object.

retrieveMetaOutput() [1/2]

template<typename T >

StatusCode xAOD::Event::retrieveMetaOutput ( const T *&  obj, const std::string &  key  )

inherited

Retrieve an output metadata object.

retrieveMetaOutput() [2/2]

template<typename T >

StatusCode xAOD::Event::retrieveMetaOutput ( T *&  obj, const std::string &  key  )

inherited

Retrieve an output metadata object.

setActive()

void Event::setActive ( ) const

inherited

Set this event object as the currently active one.

Definition at line 54 of file EventCore.cxx.

                            {
 
  // 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);
#endif  // not XAOD_STANDALONE
}

setAuxItemList()

void Event::setAuxItemList ( const std::string &  containerKey, const std::string &  itemList  )

inherited

Configure which dynamic variables to write out for a given store.

This function receives the rules for selecting which dynamic auxiliary branches should be written for a given container, in the exact same format in which we need to set it in the Athena output ItemList.

Parameters

containerKey	The name of the auxiliary container in question
itemList	The variable list according to the formatting rules

Definition at line 71 of file EventCore.cxx.

                                                      {
 
  // 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);
}

setAuxStore()

StatusCode xAOD::Experimental::REvent::setAuxStore ( const std::string &  key, Details::IObjectManager &  mgr, bool  metadata  )

overrideprivatevirtual

Function connecting a DV object to its auxiliary store.

Every time a DataVector is read in from the input for a new RNTuple entry, one needs to re-connect it with its auxiliary store.

This function takes care of this.

Parameters

key	The key (field name) of the object whose auxiliary store should be set up
mgr	The manager object of the DV container
metadata	Flag specifying whether we're dealing with a metadata or event data object

Returns

The usual StatusCode types

Implements xAOD::Event.

Definition at line 723 of file REvent.cxx.

                                                                          {
 
  // Check if we need to do anything:
  if ((Details::hasAuxStore(*(mgr.holder()->getClass())) == false) &&
      (Details::isAuxStore(*(mgr.holder()->getClass())) == false)) {
    return StatusCode::SUCCESS;
  }
 
  // Select which object container to use:
  Object_t& objects = (metadata ? m_inputMetaObjects : m_inputObjects);
 
  // Look up the auxiliary object's manager:
  TVirtualManager* auxMgr = nullptr;
  std::string auxKey;
  if (Details::isAuxStore(*(mgr.holder()->getClass()))) {
    auxMgr = &mgr;
    auxKey = key;
  } else {
    auto itr = objects.find(key + "Aux.");
    if (itr == objects.end()) {
      // Apparently there's no auxiliary object for this DV, so let's
      // give up.
      return StatusCode::SUCCESS;
    }
    auxMgr = itr->second.get();
    auxKey = key + "Aux:";
  }
 
  if (!metadata) {
    // Make sure the auxiliary object is up to date.
    ::Int_t readBytes = auxMgr->getEntry();
 
    // Check if there is a separate auxiliary object for the dynamic
    // variables, which would need to be updated.
    const std::string dynAuxKey = auxKey + "Dynamic";
    auto dynAuxMgr = objects.find(dynAuxKey);
    if ((dynAuxMgr != objects.end()) && (readBytes || (auxMgr == &mgr))) {
 
      // Tell the dynamic store object to switch to a new entry.
      dynAuxMgr->second->getEntry();
    }
  }
 
  // Stop here if we've set up an auxiliary store.
  if (auxMgr == &mgr) {
    return StatusCode::SUCCESS;
  }
 
  // Access the auxiliary base class of the object/vector:
  SG::AuxVectorBase* vec = 0;
  SG::AuxElement* aux = 0;
  switch (mgr.holder()->typeKind()) {
    case THolder::DATAVECTOR: {
      void* vvec = mgr.holder()->getAs(typeid(SG::AuxVectorBase));
      vec = reinterpret_cast<SG::AuxVectorBase*>(vvec);
    } break;
    case THolder::AUXELEMENT: {
      void* vaux = mgr.holder()->getAs(typeid(SG::AuxElement));
      aux = reinterpret_cast<SG::AuxElement*>(vaux);
    } break;
    default:
      break;
  }
 
  // Check whether index tracking is enabled for the type. If not, then
  // we need to fix it...
  if (vec && (!vec->trackIndices())) {
    Details::forceTrackIndices(*vec);
  }
 
  // Check if we were successful:
  if ((!vec) && (!aux)) {
    ATH_MSG_FATAL("Couldn't access class \""
                  << mgr.holder()->getClass()->GetName()
                  << "\" as SG::AuxVectorBase or SG::AuxElement");
    return StatusCode::FAILURE;
  }
 
  // Get the concrete auxiliary manager:
  RObjectManager* omgr = dynamic_cast<RObjectManager*>(auxMgr);
  if (!omgr) {
    ATH_MSG_FATAL("Auxiliary manager for \"" << auxKey
                                             << "\" is not of the right type");
    return StatusCode::FAILURE;
  }
  void* p = omgr->holder()->getAs(typeid(SG::IConstAuxStore));
  const SG::IConstAuxStore* store =
      reinterpret_cast<const SG::IConstAuxStore*>(p);
  if (store == nullptr) {
    ATH_MSG_FATAL("There's a logic error in the code");
    return StatusCode::FAILURE;
  }
 
  // Connect the two:
  if (vec) {
    vec->setStore(store);
  } else if (aux) {
    aux->setStore(store);
  } else {
    ATH_MSG_FATAL("There's a logic error in the code");
    return StatusCode::FAILURE;
  }
 
  // We succeeded:
  return StatusCode::SUCCESS;
}

setLevel()

void AthMessaging::setLevel ( MSG::Level  lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setUpDynamicStore()

StatusCode xAOD::Experimental::REvent::setUpDynamicStore ( RObjectManager &  mgr, ROOT::RNTupleReader &  reader  )

private

event uses RNTupleReader:

This function is used by connectObject(...) and connectMetaObject(...) to set up auxiliary store type objects correctly for accessing dynamic variables from the input file.

Parameters

mgr	The object manager of the auxiliary store object
reader	The RNTuple reader to read dynamic variables from

Returns

The usual StatusCode types

Definition at line 943 of file REvent.cxx.

                                                                {
 
  // The name of the field that the object is connected to.
  const std::string fieldName = mgr.field().GetField().GetFieldName();
 
  // Check if we can call setName(...) on the object.
  ::TMethodCall setNameCall;
  setNameCall.InitWithPrototype(mgr.holder()->getClass(), "setName",
                                "const char*");
  if (setNameCall.IsValid()) {
    // Yes, there is such a function. Let's call it with the field
    // name.
    const ::TString params = ::TString::Format("\"%s\"", fieldName.c_str());
    const char* charParams = params.Data();
    setNameCall.Execute(mgr.holder()->get(), charParams);
  } else {
    // This is weird. What sort of auxiliary container is this? :-/
    ATH_MSG_WARNING("Couldn't find setName(...) function for container \""
                    << fieldName << "\"  (type: "
                    << mgr.holder()->getClass()->GetName() << ")");
  }
 
  // Check if we can switch out the internal store of this object:
  static const TClass* const holderClass =
      TClass::GetClass(typeid(SG::IAuxStoreHolder));
  if (!mgr.holder()->getClass()->InheritsFrom(holderClass)) {
    // Nope... So let's just end the journey here.
    return StatusCode::SUCCESS;
  }
 
  // Try to get the object as an IAuxStoreHolder:
  SG::IAuxStoreHolder* storeHolder = reinterpret_cast<SG::IAuxStoreHolder*>(
      mgr.holder()->getAs(typeid(SG::IAuxStoreHolder)));
  if (!storeHolder) {
    ATH_MSG_FATAL("There's a logic error in the code");
    return StatusCode::FAILURE;
  }
 
  // Create an RAuxStore instance that will read the dynamic variables
  // of this container. Notice that the RAuxManager doesn't own the
  // RAuxStore object. It will be owned by the SG::IAuxStoreHolder
  // object.
  static constexpr bool TOP_STORE = false;
  auto store = std::make_unique<RAuxStore>(
      fieldName, TOP_STORE,
      (storeHolder->getStoreType() == SG::IAuxStoreHolder::AST_ObjectStore
           ? RAuxStore::EStructMode::kObjectStore
           : RAuxStore::EStructMode::kContainerStore));
  // This object is used to read data from the input, it needs to be
  // locked:
  store->lock();
 
  // Set it up to read from the input RNTuple.
  ATH_CHECK(store->readFrom(reader));
  // Tell the auxiliary store which entry to use. This is essential for
  // metadata objects, and non-important for event data objects, which will
  // get a possibly different entry loaded in setAuxStore(...).
  ATH_CHECK(store->getEntry(0));
 
  // Set up a manager for it.
  static constexpr bool SHARED_OWNER = false;
  m_inputObjects[fieldName + "Dynamic"] =
      std::make_unique<RAuxManager>(store.get(), m_entry, SHARED_OWNER);
 
  // Give this object to the store holder.
  storeHolder->setStore(store.release());
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

stringToKey()

SG::sgkey_t Event::stringToKey ( const std::string &  str, CLID  clid  )

overrideprotectedinherited

Find the string corresponding to a given key.

Definition at line 287 of file EventIProxyDict.cxx.

                                                       {
 
  return getHash(str);
}

transientContains() [1/2]

template<typename T >

bool xAOD::Event::transientContains ( const std::string &  key ) const

inherited

Function checking if an object is already in memory.

transientContains() [2/2]

bool xAOD::Event::transientContains ( const std::string &  key, const std::type_info &  ti, bool  metadata  ) const

protectedinherited

Internal function checking if an object is already in memory.

transientContainsMeta()

template<typename T >

bool xAOD::Event::transientContainsMeta ( const std::string &  key ) const

inherited

Function checking if a meta-object is already in memory.

Member Data Documentation

ATLAS_THREAD_SAFE

SG::SGKeyMap<BranchInfo> m_branches xAOD::Event::ATLAS_THREAD_SAFE

mutableprotectedinherited

Map from hashed sgkey to BranchInfo.

Definition at line 358 of file Event.h.

DEFAULT_KEY

constexpr sgkey_t xAOD::TVirtualEvent::DEFAULT_KEY = ~static_cast<sgkey_t>(0)

staticconstexprinherited

Key for retrieving the "default" object of a given type.

Definition at line 35 of file TVirtualEvent.h.

KEY_MASK

constexpr sgkey_t xAOD::TVirtualEvent::KEY_MASK = DEFAULT_KEY >> 2

staticconstexprinherited

Mask for the keys, used mostly internally.

Definition at line 37 of file TVirtualEvent.h.

m_auxItemList

std::unordered_map<std::string, std::set<std::string> > xAOD::Event::m_auxItemList

protectedinherited

Rules for selecting which auxiliary branches to write.

Definition at line 326 of file Event.h.

m_branchesMutex

upgrade_mutex_t xAOD::Event::m_branchesMutex

mutableprotectedinherited

Mutex for multithread synchronization.

Definition at line 354 of file Event.h.

m_entry

::Long64_t xAOD::Experimental::REvent::m_entry

private

The entry to look at from the input tree.

Definition at line 109 of file REvent.h.

m_eventReader

std::unique_ptr<ROOT::RNTupleReader> xAOD::Experimental::REvent::m_eventReader

private

The main event data reader.

Definition at line 102 of file REvent.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

m_inputEventFormat

EventFormat xAOD::Event::m_inputEventFormat

protectedinherited

Format of the current input file.

Definition at line 321 of file Event.h.

m_inputMetaObjects

Object_t xAOD::Event::m_inputMetaObjects

protectedinherited

Collection of all the managed input meta-objects.

Definition at line 316 of file Event.h.

m_inputMissingObjects

std::set<std::string> xAOD::Event::m_inputMissingObjects

protectedinherited

Objects that have been asked for, but were found to be missing in the current input.

Definition at line 311 of file Event.h.

m_inputNTupleIsMissing

bool xAOD::Experimental::REvent::m_inputNTupleIsMissing = false

private

Whether the input has an event RNTuple or not.

Definition at line 104 of file REvent.h.

m_inputObjects

Object_t xAOD::Event::m_inputObjects

protectedinherited

Collection of all the managed input objects.

Definition at line 308 of file Event.h.

m_listeners

std::vector<TVirtualIncidentListener*> xAOD::Event::m_listeners

protectedinherited

Listeners who should be notified when certain incidents happen.

Definition at line 329 of file Event.h.

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

m_metaReader

std::unique_ptr<ROOT::RNTupleReader> xAOD::Experimental::REvent::m_metaReader

private

The metadata reader.

Definition at line 106 of file REvent.h.

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nameRemapping

std::unordered_map<std::string, std::string> xAOD::Event::m_nameRemapping

protectedinherited

Container name re-mapping rules.

Definition at line 332 of file Event.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_outputEventFormat

EventFormat* xAOD::Event::m_outputEventFormat = nullptr

protectedinherited

Format of the current output file.

Definition at line 323 of file Event.h.

m_outputMetaObjects

Object_t xAOD::Event::m_outputMetaObjects

protectedinherited

Collection of all the managed output meta-objects.

Definition at line 318 of file Event.h.

m_outputObjects

Object_t xAOD::Event::m_outputObjects

protectedinherited

Collection of all the managed output object.

Definition at line 313 of file Event.h.

m_printEventProxyWarnings

bool xAOD::Event::m_printEventProxyWarnings = false

protectedinherited

Option to silence common warnings that seem to be harmless.

Definition at line 335 of file Event.h.

---

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

• REvent.h
• REvent.cxx