REventClass Class Reference

Class used for the test. More...

Inheritance diagram for REventClass:

Collaboration diagram for REventClass:

Public Types
using	sgkey_t = SG::sgkey_t

Public Member Functions
StatusCode	loadInputObjects ()
	Function loading all interface objects of the event.
	REvent ()
	Default constructor.
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)
template<typename T>
bool	retrieve (const T *&obj, const std::string &key, bool silent=false)
	Function retrieving an object from the event (constant version)
void	setLevel (MSG::Level lvl)
	Change the current logging level.
Setup functions
StatusCode	readFrom (TFile &inFile) override
	Set up the reading of an input file from TFile This method implements the interface from Event.
StatusCode	readFrom (std::string_view fileName)
	Set up the reading of an input file via a file name.
StatusCode	writeTo (TFile &file) override
	Connect the object to an output file.
StatusCode	finishWritingTo (TFile &file) override
	Finish writing to an output file.
Persistent data accessor/modifier functions
::Long64_t	getEntries () const override
	Get how many entries are available from the current input file(s)
::Int_t	getEntry (::Long64_t entry, ::Int_t getall=0) override
	Function loading a given entry of the input RNTuple.
::Int_t	fill () override
	Method filling one event into the output.
template<typename T>
StatusCode	record (T *obj, const std::string &key)
	Add an output object to the event.
template<typename T>
StatusCode	record (std::unique_ptr< T > obj, const std::string &key)
	Add an output object to the event, explicitly taking ownership of it.
Persistent data accessor/modifier functions
const EventFormat *	inputEventFormat () const
	Get information about the input objects.
const EventFormat *	outputEventFormat () const
	Get information about the output objects.
Event data accessor/modifier functions
std::string	dump ()
	Function creating a user-readable dump of the current input.
void	printIOStats () const
	Function printing the I/O statistics of the current process.
template<typename T>
bool	contains (const std::string &key)
	Function checking if an object is available from the store.
template<typename T>
bool	transientContains (const std::string &key) const
	Function checking if an object is already in memory.
template<typename T>
StatusCode	keys (std::vector< std::string > &vkeys, bool metadata) const
	Provide a list of all data object keys associated with a specific type.
template<typename T>
StatusCode	retrieve (const T *&obj, const std::string &key)
	Retrieve either an input or an output object from the event.
template<typename T>
StatusCode	retrieve (T *&obj, const std::string &key)
	Retrieve an output object from the event.
StatusCode	copy (const std::string &pattern=".*")
	Copy an object directly from the input to the output.
Metadata accessor/modifier functions
template<typename T>
bool	containsMeta (const std::string &key)
	Function checking if a meta-object is available from the store.
template<typename T>
bool	transientContainsMeta (const std::string &key) const
	Function checking if a meta-object is already in memory.
template<typename T>
StatusCode	metaKeys (std::vector< std::string > &vkeys) const
	Provide a list of all metadata object keys associated with a specific type.
template<typename T>
StatusCode	retrieveMetaInput (const T *&obj, const std::string &key)
	Retrieve an input metadata object.
template<typename T>
StatusCode	retrieveMetaOutput (const T *&obj, const std::string &key)
	Retrieve an output metadata object.
template<typename T>
StatusCode	retrieveMetaOutput (T *&obj, const std::string &key)
	Retrieve an output metadata object.
template<typename T>
StatusCode	recordMeta (T *obj, const std::string &key)
	Add an object to the output file's metadata.
template<typename T>
StatusCode	recordMeta (std::unique_ptr< T > obj, const std::string &key)
	Add an object to the output file's metadata, explicitly taking ownership of it.
Functions providing the same interface as AthMessaging
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

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

Protected Types
using	Object_t
	Definition of the internal data structure type.

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.
bool	transientContains (const std::string &key, const std::type_info &ti, bool metadata) const
	Internal function checking if an object is already in memory.
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.
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.
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.
Functions implementing the IProxyDict interface
SG::DataProxy *	proxy (const void *const pTransient) const override
	get proxy for a given data object address in memory
SG::DataProxy *	proxy (const CLID &id, const std::string &key) const override
	get proxy with given id and key. Returns 0 to flag failure
SG::DataProxy *	proxy_exact (SG::sgkey_t sgkey) const override
	Get proxy given a hashed key+clid.
StatusCode	addToStore (CLID id, SG::DataProxy *proxy) override
	Add a new proxy to the store.
std::vector< const SG::DataProxy * >	proxies () const override
	return the list of all current proxies in store
SG::sgkey_t	stringToKey (const std::string &str, CLID clid) override
	Find the string corresponding to a given key.
const std::string *	keyToString (SG::sgkey_t key) const override
	Find the string corresponding to a given key.
const std::string *	keyToString (SG::sgkey_t key, CLID &clid) const override
	Find the string and CLID corresponding to a given key.
void	registerKey (SG::sgkey_t key, const std::string &str, CLID clid) override
	Remember an additional mapping from key to string/CLID.
SG::DataProxy *	recordObject (SG::DataObjectSharedPtr< DataObject > obj, const std::string &key, bool allowMods, bool returnExisting) override
	Record an object in the store.
const std::string &	name () const override
	Get the name of the instance.
Helper functions for the IProxyDict interface
const xAOD::EventFormatElement *	getEventFormatElement (SG::sgkey_t sgkey) const
	Get the metadata object for a given "SG key".
const BranchInfo *	getBranchInfo (SG::sgkey_t sgkey) const
	Get the object describing one object/branch.

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

Private Member Functions
StatusCode	initStats ()
	Function to initialise the statistics for all RNTuple content.
StatusCode	setUpDynamicStore (RObjectManager &mgr, ROOT::RNTupleReader &ntupleReader)
	event uses RNTupleReader:
void	initMessaging () const
	Initialize our message level and MessageSvc.
Functions implemented from @c xAOD::Event
bool	hasInput () const override
	Check if an input file is connected to the object.
bool	hasOutput () const override
	Check if an output file is connected to the object.
StatusCode	getNames (const std::string &targetClassName, std::vector< std::string > &vkeys, bool metadata) const override
	Function determining the list keys associated with a type name.
StatusCode	connectObject (const std::string &key, bool silent) override
	Function setting up access to a particular object.
StatusCode	connectMetaObject (const std::string &key, bool silent) override
	Function setting up access to a particular metadata object.
StatusCode	connectAux (const std::string &prefix, bool standalone) override
	Function setting up access to a set of auxiliary branches.
StatusCode	connectMetaAux (const std::string &prefix, bool standalone) override
	Function setting up access to a set of auxiliary branches for a metadata object.
StatusCode	setAuxStore (const std::string &key, Details::IObjectManager &mgr, bool metadata) override
	Function connecting a DV object to its auxiliary store.
StatusCode	record (void *obj, const std::string &typeName, const std::string &key, bool overwrite, bool metadata, bool isOwner) override
	Record an object into a connected output file.
StatusCode	recordAux (TVirtualManager &mgr, const std::string &key, bool metadata) override
	Record an auxiliary store into a connected output file.
StatusCode	putAux (TVirtualManager &mgr, ::Bool_t metadata=kFALSE)
	Method saving the dynamically created auxiliary properties.
StatusCode	addField (const std::string &key, const TVirtualManager &mgr)
	Add field to RNTuple model given the StoreGate key and output object manager.

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

Setup functions
void	setActive () const
	Set this event object as the currently active one.
void	setAuxItemList (const std::string &containerKey, const std::string &itemList)
	Configure which dynamic variables to write out for a given store.
StatusCode	addListener (TVirtualIncidentListener *listener)
	Register an incident listener object.
StatusCode	removeListener (TVirtualIncidentListener *listener)
	Remove an incident listener object.
void	clearListeners ()
	Remove all listeners from the object.
StatusCode	addNameRemap (const std::string &onfile, const std::string &newName)
	Add a name re-mapping rule.
void	clearNameRemap ()
	Clear the current name re-mapping.
void	printNameRemap () const
	Print the current name re-mapping rules.
void	printProxyWarnings (bool value=true)
	Enable warnings associated with broken element links.
static const char *const	EVENT_TREE_NAME = "CollectionTree"
	Default name of the event TTree.
static const char *const	EVENT_RNTUPLE_NAME = "EventData"
	Name of the event RNTuple.
static const char *const	METADATA_OBJECT_NAME = "MetaData"
	Name of the metadata tree or RNTuple.
static std::unique_ptr< Event >	createAndReadFrom (TFile &file)
	static method to create an Event object and readFrom a file, given by a TFile.

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.
SG::sgkey_t	getKey (const void *obj) const override
	Function returning the hash describing a known object.
const std::string &	getName (const void *obj) const override
	Function returning the key describing a known object.
const std::string &	getName (SG::sgkey_t hash) const override
	Function returning the key describing a known object.
void *	getOutputObject (SG::sgkey_t key, const std::type_info &ti) override
	Function for retrieving an output object in a non-template way.
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.

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

Detailed Description

Class used for the test.

Definition at line 36 of file xAODRNFileReadTest.cxx.

Member Typedef Documentation

Object_t

using xAOD::Event::Object_t

protectedinherited

Initial value:

 
      std::unordered_map<std::string, std::unique_ptr<TVirtualManager>>

Definition of the internal data structure type.

Definition at line 333 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 378 of file Event.h.

upgrading_lock_t

using xAOD::Event::upgrading_lock_t

protectedinherited

Initial value:

 
      AthContainers_detail::upgrading_lock<upgrade_mutex_t>

Lock type for multithread synchronization.

Definition at line 380 of file Event.h.

Member Function Documentation

addField()

StatusCode xAOD::Experimental::REvent::addField ( const std::string & key, const TVirtualManager & mgr )

privateinherited

Add field to RNTuple model given the StoreGate key and output object manager.

Definition at line 1677 of file REvent.cxx.

                                                                            {
 
  // Add to the RNTuple model -
  //   This is done by either adding the field to  the initial model before the first event is written, or
  //   after the first event has been written a new field is added via an extension of the output RNTuple model.
  //   This can occurs when an AuxStore is empty for the initial events
 
  // Get field name and class name to create a RFieldBase
  std::string fieldName;
  std::string className;
  if (getInfoForFieldCreation( key, mgr, fieldName, className ).isFailure()) return StatusCode::FAILURE;
  // should have found class name
  if ( className.empty() ) {
    ATH_MSG_ERROR( "could not find className!" );
    return StatusCode::FAILURE;
  }
 
  if (m_model) {
    // Continue to add to the initial RNTuple model
    m_model->AddField( ROOT::RFieldBase::Create( fieldName, className ).Unwrap());
  }
  else {
    if (m_eventWriter.get() == nullptr) {
      ATH_MSG_ERROR("Internal logic error detected - no output found");
      return StatusCode::FAILURE;
    }
    // After the first event, one needs to extend the output RNTuple model
    auto field = ROOT::RFieldBase::Create(fieldName, className).Unwrap();
    auto updater = m_eventWriter->CreateModelUpdater();
    updater->BeginUpdate();
    updater->AddField(std::move(field));
    updater->CommitUpdate();
  }
 
  // Return gracefully:
  return StatusCode::SUCCESS;
 
}

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 251 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 )

overrideprivatevirtualinherited

Function setting up access to a set of auxiliary branches.

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

This uses 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 1072 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 )

overrideprivatevirtualinherited

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.

This uses 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 1142 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 )

overrideprivatevirtualinherited

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 983 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 fieldName = key;
  if (key.ends_with("Aux.")) {
    fieldName.replace(fieldName.size() - 1, 1, ":");
  }
 
  // Check if the field exists in our input RNTuple.
  if (m_metaReader->GetDescriptor().FindFieldId(fieldName.c_str()) ==
      ROOT::kInvalidDescriptorId) {
    // Field doesn't exist
    if (!silent) {
      ATH_MSG_WARNING("Field \"" << fieldName << "\" 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>(fieldName.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 \""
        << fieldName << "\"");
    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 \""
        << fieldName << "\"");
    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(fieldName, ptr, className), FIRST_ENTRY,
      std::make_unique<THolder>(ptr, realClass));
  // For metadata, we must read in the first entry - entry number already set by FIRST_ENTRY in constructor
  mgr->getEntry();
  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()))) {
    // For reading in of the dynamic variables for metadata
    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()))));
    static constexpr bool METADATA = true;
    ATH_CHECK(setAuxStore(key, *mgrPtr, METADATA));
  }
 
  // Return gracefully.
  return StatusCode::SUCCESS;
} // connectMetaObject

connectObject()

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

overrideprivatevirtualinherited

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 834 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 field \"" << 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 fieldName = key;
  if (key.ends_with("Aux.")) {
    fieldName.replace(fieldName.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(fieldName.c_str()) ==
      ROOT::kInvalidDescriptorId) {
    // Field doesn't exist
    if (!silent) {
      ATH_MSG_WARNING("Field \"" << fieldName << "\" 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>(fieldName.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 \""
          << fieldName << "\"");
      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 \""
        << fieldName << "\"");
    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.
  Object_t::const_iterator out_itr = m_outputObjects.find( key );
  if( out_itr != m_outputObjects.end() ) {
    // It needs to be an object manager...
    RObjectManager* mgr =
    dynamic_cast< RObjectManager* >( out_itr->second.get() );
    if( ! mgr ) {
      ATH_MSG_ERROR("Couldn't access output manager for: " << key );
      return StatusCode::FAILURE;
    }
    // Get the pointer out of it:
    ptr = mgr->holder()->get();
  }
 
  // 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(fieldName, 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;
} // connectObject

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 75 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;
    }
    // Skip all branches ending in "Aux.":
    if (key.ends_with("Aux.")) {
      continue;
    }
    // Also skip dynamic branches:
    if (efe.parentName() != "") {
      continue;
    }
    // Ignore objects that don't exist on the input.
    static const bool SILENT = true;
    if (connectObject(key, SILENT).isSuccess() == false) {
      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;
}

createAndReadFrom()

std::unique_ptr< Event > Event::createAndReadFrom ( TFile & inFile )

staticinherited

static method to create an Event object and readFrom a file, given by a TFile.

static method to get Event object for reading either TTree (TEvent) or RNTuple (REvent).

The the reader technology, TTree read by TEvent or RNTuple read by REvent, is determined by the looking into the file, given as a TFile object.

Here we access by TFile object

Definition at line 39 of file EventIO.cxx.

                                                           {
 
  // Make use of the messaging function(s) from the xAODEvent namespace.
  using xAODEvent::msg;
 
  if (inFile.FindKey(EVENT_RNTUPLE_NAME) != nullptr) {
    // Create and set up an REvent object
    auto event = std::make_unique<Experimental::REvent>();
    if (event->readFrom(inFile).isFailure()) {
      ANA_MSG_ERROR("Could not read RNTuple from: " << inFile.GetName());
      return {};
    }
    return event;
  } else if (inFile.FindKey(EVENT_TREE_NAME) != nullptr) {
    // Create and set up a TEvent object
    auto event = std::make_unique<TEvent>();
    if (event->readFrom(inFile).isFailure()) {
      ANA_MSG_ERROR("Could not read TTree from: " << inFile.GetName());
      return {};
    }
    return event;
  } else {
    ANA_MSG_ERROR("Could not recognize file: " << inFile.GetName());
    return {};
  }
}

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

fill()

Int_t xAOD::Experimental::REvent::fill ( )

overridevirtualinherited

Method filling one event into the output.

This function needs to be called by the user at the end of processing each event that is meant to be written out.

Returns

The number of bytes written if successful, a negative number if not

Implements xAOD::Event.

Definition at line 607 of file REvent.cxx.

                   {
 
  // Make sure that all objects have been read in. The 99 as the value
  // has a special meaning for RAuxStore. With this value it doesn't
  // delete its transient (decoration) variables. Otherwise it does.
  // (As it's supposed to, when moving to a new event.)
  if( m_eventReader ) {
    if (getEntry( m_entry, 99 ) < 0) {
      ATH_MSG_ERROR( "getEntry failed!" );
      return 0;
    }
  }
 
  // Prepare the objects for writing. Note that we need to iterate over a
  // copy of the m_outputObjects container. Since the putAux(...) function
  // called inside the loop may itself add elements to the m_outputObject
  // container.
  std::string unsetObjects;
  std::vector<std::pair<std::string, TVirtualManager*>> outputObjectsCopy;
  outputObjectsCopy.reserve(m_outputObjects.size());
  for (const auto& [key, mgr] : m_outputObjects) {
    TVirtualManager* objMgr = dynamic_cast<TVirtualManager*>(mgr.get());
    if (objMgr == nullptr) {
      ATH_MSG_ERROR("Internal logic error detected");
      return 0;
    }
    outputObjectsCopy.emplace_back(key, objMgr);
  }
  for (auto &[key, mgr] : outputObjectsCopy) {
 
    ATH_MSG_DEBUG("REvent::fill - checking and adding aux for " << key << ", " << mgr << " isSet " << mgr->isSet());
 
    // Check that a new object was provided in the event - skip dynamic variables:
    if ((key.find("AuxDyn") == std::string::npos) && !mgr->isSet()) {
 
      ATH_MSG_DEBUG("REvent::fill - not set " << key);
 
      // We are now going to fail. But let's collect the names of
      // all the unset objects:
      if (unsetObjects.size()) {
        unsetObjects += ", ";
      }
      unsetObjects.append("\"" + key + "\"");
      continue;
    }
 
    // Make sure that any dynamic auxiliary variables that
    // were added to the object after it was put into the event
    // are also added to the output.
    if( putAux( *mgr ).isFailure() ) {
      ATH_MSG_ERROR( "Failed to put dynamic auxiliary variables in the output for object \"" << key << "\"" );
      return 0;
    }
  }
 
  // Check if there were any unset objects:
  if (unsetObjects.size()) {
    ATH_MSG_ERROR("The following objects were not set in the current event: "
                  << unsetObjects);
    return 0;
  }
 
  // For the first call to fill, we create an RNTupleWriter with the RNTuple model already accumulated
  // - there may be extensions for Aux containers which are empty for the first few events
  ATH_MSG_DEBUG( "REvent::fill - has event writer " << (m_eventWriter.get() != nullptr) );
 
  if( m_eventWriter.get() == nullptr ) {
 
    // Set output RNTuple name as model description
    const char*  rnTupleName = EVENT_RNTUPLE_NAME;
 
    //  Create RNTuple write with model
    m_eventWriter = ROOT::RNTupleWriter::Append(std::move(m_model), rnTupleName, *m_outputFile);
 
    // Reset the RNTupleModel so that subsequent additions of new fields will be done with model extensions
    m_model.reset();
 
    ATH_MSG_DEBUG( "REvent::fill - created writer and reset model " );
 
  }
 
  // Get entry for writing
  auto rnEntry = m_eventWriter->GetModel().CreateBareEntry();
 
  // Now loop over all object managers and bind the output object pointers 
  // to the those in the output RNTuple
  ::Int_t nbytes = 0;
  for (auto &[key, mgr] : m_outputObjects) {
 
    // Get field name from the key
    auto fieldName = getFieldNameFromKey(key);
 
    // Check if this is a container, top-level or aux, rather than a aux variable (AuxDyn):
    ROutObjManager* omgr = dynamic_cast< ROutObjManager* >( mgr.get() );
    bool isContainer = (omgr != nullptr);
 
    ATH_MSG_DEBUG("REvent::fill - bind ptr " << key << " mgr " << mgr << " is set " << mgr->isSet()
                  << ", is container " << isContainer);
 
    // Save value, if an object has been set, otherwise save default value
    // Dynamic attributes don't exist for empty containers, e.g. no electrons in an event
    if (mgr->isSet()) {
      rnEntry->BindRawPtr(fieldName, mgr->object());
    } else {
 
      ATH_MSG_DEBUG("REvent::fill - bind unSet ptr " << key << " mgr " << mgr << " is set " << mgr->isSet()
                    << ", is container " << isContainer);
 
      rnEntry->EmplaceNewValue(fieldName);
    }
  }
 
  ATH_MSG_DEBUG("REvent::fill - writer fill ");
 
  // Write the entry, and check the return value:
  const ::Int_t ret = m_eventWriter->Fill(*rnEntry);
  if( ret <= 0 ) {
    ATH_MSG_ERROR( "Output RNTuple filling failed with return value: " << ret );
  }
  nbytes += ret;
 
  ATH_MSG_DEBUG("REvent::fill - writer filled ");
 
  // Reset the object managers:
  for (auto &[key, mgr] : m_outputObjects) {
    mgr->reset();
 
    ATH_MSG_DEBUG("REvent::fill - after reset " << key << " is set " << mgr->isSet());
 
  }
 
  // Return the number of bytes written:
  return nbytes;
}

finishWritingTo()

StatusCode xAOD::Experimental::REvent::finishWritingTo ( TFile & file )

overridevirtualinherited

Finish writing to an output file.

This function needs to be called when the user is done writing events to a file, before (s)he would close the file itself.

Parameters

file	The file that the event data is written to

Returns

kTRUE if successful, kFALSE otherwise

reset writer (metaDataWriter will be reset when going out of scope)

Implements xAOD::Event.

Definition at line 372 of file REvent.cxx.

                                              {
 
  // A small sanity check for meta data writing - need output file as long as MetaData is in a rntuple:
  if( m_outputFile != &file ) {
      ATH_MSG_FATAL("File given to finishWritingTo does not match the file given in writeTo file!");
      return StatusCode::FAILURE;
  }
 
  // Notify the listeners that they should write out their metadata, if they
  // have any.
  const TIncident incident( IncidentType::MetaDataStop );
  for (auto& listener : m_listeners) {
    listener->handle(incident);
  }
 
  // Now go to the output file:
  m_outputFile->cd();
 
  const char*  outRNTupleName = METADATA_OBJECT_NAME;
 
  // Check if there's already a metadata tree in the output, if so we can return:
  if( m_outputFile->Get( outRNTupleName ) ) {
 
      // Let's assume that the metadata is complete in the file already.
      ATH_MSG_INFO( "Metadata tree already exists, returning" );
 
      return StatusCode::SUCCESS;
  }
 
  // Write out meta data
 
  // Create new model for this file
  auto model = ROOT::RNTupleModel::Create();
 
  // Set output RNTuple name as model description
  model->SetDescription(outRNTupleName);
 
 
  // Create field explicitly for EventFormat
 
  // Check if we have a dictionary: for this object:
  std::string typeName = SG::normalizedTypeinfoName( typeid( xAOD::EventFormat ) );
  TClass* cl = TClass::GetClass( typeName.c_str() );
  if( ! cl ) {
      ATH_MSG_ERROR( "Didn't find dictionary for type: " << typeName );
      return StatusCode::FAILURE;
  }
  std::string efName = cl->GetName();
 
  ATH_MSG_DEBUG("finishWriting");
 
  model->AddField( ROOT::RFieldBase::Create( "EventFormat", efName ).Unwrap());
 
  // Loop over output meta data object managers and create the corresponding fields for the output model
 
  // Make sure that any dynamic auxiliary variables that
  // were added to the object after it was put into the event,
  // get added to the output
 
  // Must copy m_outputMetaObjects because it may be augmented in putAux
  std::vector<std::pair<std::string, TVirtualManager*>> outputMetaObjects;
  outputMetaObjects.reserve(m_outputMetaObjects.size());
  for (const auto& [key, mgr] : m_outputMetaObjects) {
    TVirtualManager* objMgr = dynamic_cast<TVirtualManager*>(mgr.get());
    if (objMgr == nullptr) {
      ATH_MSG_FATAL("Internal logic error detected");
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_DEBUG("finishWriting: save metadata key " << key);
 
    outputMetaObjects.emplace_back(key, objMgr);
  }
 
  // Set up the saving of all the dynamic auxiliary properties
  // of the object if it has any:
  for( auto& itr : outputMetaObjects ) {
    static constexpr bool IS_METADATA         = true;
    ATH_CHECK( putAux( *(itr.second), IS_METADATA ) );
  }
 
  // Now create fields for each output metadata object
  for (auto &[key, mgr] : m_outputMetaObjects) {
 
    // Get field name and class name to create a RFieldBase
    std::string fieldName;
    std::string className;
    if (getInfoForFieldCreation( key, *mgr, fieldName, className ).isFailure()) return StatusCode::FAILURE;
 
    // should have found class name
    if ( className.empty() ) {
      ATH_MSG_ERROR( "could not find className!" );
      return StatusCode::FAILURE;
    }
 
    // Add RFieldBase to model
    model->AddField( ROOT::RFieldBase::Create( fieldName, className ).Unwrap());
 
  }
 
  //  Create RNTuple write for meta data with model
  auto metaDataWriter = ROOT::RNTupleWriter::Append(std::move(model), outRNTupleName, *m_outputFile);
 
 
  // Get entry for writing
  auto rnEntry = metaDataWriter->GetModel().CreateBareEntry();
 
  // Now loop over all object managers and bind the output object pointers 
  // to the those in the output metadata RNTuple
  for (auto &[key, mgr] : m_outputMetaObjects) {
 
      // Get field name from the key
      auto fieldName = getFieldNameFromKey(key);
 
      // Save value, if exist, otherwise save default value
      if (mgr.get()) {
        rnEntry->BindRawPtr(fieldName, mgr->object());
      } else {
        rnEntry->EmplaceNewValue(fieldName);
      }
  }
 
  // Add EventFormat to the RNEntry
  rnEntry->BindRawPtr( "EventFormat", m_outputEventFormat );
 
  // Write the entry, and check the return value:
  const ::Int_t ret = metaDataWriter->Fill(*rnEntry);
  if( ret <= 0 ) {
      ATH_MSG_FATAL( "Output rntuple filling failed with return value: " << ret );
  }
  else {
      ATH_MSG_INFO( "Output meta data rntuple filled. nbytes = " << ret );
  }
 
  // Now clean up:
  
  // reset output EventFormat
  m_outputEventFormat = 0;
  m_outputObjects.clear();
  m_outputMetaObjects.clear();
 
  rnEntry.reset();

  m_eventWriter.reset();
 
  metaDataWriter.reset();
  
  // Return gracefully:
  return StatusCode::SUCCESS;
} // finishWriting

getBranchInfo()

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

protectedinherited

Get the object describing one object/branch.

Definition at line 347 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:
  auto taddr = std::make_unique<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 = std::make_unique<SG::DataProxy>(std::move(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

overridevirtualinherited

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

Returns

The number of events in the input file(s)

Implements xAOD::Event.

Definition at line 527 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 )

overridevirtualinherited

Function loading a given entry of the input RNTuple.

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 RNtuple 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

Implements xAOD::Event.

Definition at line 553 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 321 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 265 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

overrideprivatevirtualinherited

Function determining the list keys associated with a type name.

Implements xAOD::Event.

Definition at line 743 of file REvent.cxx.

                                              {
 
  // The results go in here
  std::set<std::string> keys;
 
  // Get list of fields from
  // the input metadata tree or input tree
  
  ROOT::RNTupleReader* reader = (metadata) ? m_metaReader.get() : m_eventReader.get();
  if (reader == nullptr) {
    ATH_MSG_ERROR("No input file is connected");
    return StatusCode::FAILURE;
  }
  if (metadata) ATH_MSG_DEBUG("scanning input objects for metadata for type name " << targetClassName);
  else          ATH_MSG_DEBUG("scanning input objects for event data for type name " << targetClassName);
 
  // add in names for all top level fields
  for (const auto &topLevelField : reader->GetDescriptor().GetTopLevelFields()) {
      std::string objClassName = topLevelField.GetTypeName();
      std::string key = topLevelField.GetFieldName();
      if (objClassName == targetClassName) {
        ATH_MSG_VERBOSE("Matched " << targetClassName << " to key " << key);
        keys.insert(std::move(key));
      }
  }
 
  // check output objects 
  if (m_eventWriter && !metadata){
      ATH_MSG_DEBUG("scanning output objects for type name " << targetClassName);
      // add in names for all top level fields
      for (const auto& topLevelFieldName : m_eventWriter->GetModel().GetRegisteredSubfieldNames()) {
        auto& topLevelField = m_eventWriter->GetModel().GetConstField(topLevelFieldName);
        std::string objClassName = topLevelField.GetTypeName();
        std::string key = topLevelField.GetFieldName();
        ATH_MSG_VERBOSE("Inspecting " << objClassName << "/" << key);
      if (objClassName == targetClassName) {
          ATH_MSG_VERBOSE("Matched " << targetClassName << " to key " << key);
            keys.insert(std::move(key));
        }
      }
  }
 
  const Object_t& outAux = ( metadata ?
                              m_outputMetaObjects : m_outputObjects );
 
  // Search though EventFormat for entries where class matches the provided
  // typeName
  
  ATH_MSG_DEBUG("scanning output Aux objects for type name " << targetClassName);
 
  for( const auto& object : outAux ) {
      // All metadata objects should be held by ROutObjManager objects.
      // Anything else is an error.
      std::string objClassName;
      if ( metadata ) {
        ROutObjManager* mgr = dynamic_cast< ROutObjManager* >( object.second.get() );
        if ( ! mgr ) continue;
        objClassName = mgr->holder()->getClass()->GetName();
      }
      const std::string& key = object.first;
      ATH_MSG_VERBOSE("Inspecting " << objClassName << "/" << key);
      if (objClassName == targetClassName) {
        ATH_MSG_VERBOSE("Matched " << targetClassName << " to key " << key);
        keys.insert(std::move(key));
      }
  }
 
  vkeys.insert(vkeys.end(), keys.begin(), keys.end());
 
  return StatusCode::SUCCESS;
}

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 201 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

overrideprivatevirtualinherited

Check if an input file is connected to the object.

Implements xAOD::Event.

Definition at line 592 of file REvent.cxx.

                            {
 
  return (m_eventReader || m_inputNTupleIsMissing);
}

hasOutput()

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

overrideprivatevirtualinherited

Check if an output file is connected to the object.

Implements xAOD::Event.

Definition at line 597 of file REvent.cxx.

                             {
  return (m_outputFile != nullptr);
}

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();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

initStats()

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

privateinherited

Function to initialise the statistics for all RNTuple 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 1723 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 294 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 299 of file EventIProxyDict.cxx.

                                                              {
 
  return &(getName(key));
}

loadInputObjects()

StatusCode REventClass::loadInputObjects ( )

inline

Function loading all interface objects of the event.

Definition at line 42 of file xAODRNFileReadTest.cxx.

                                 {
      // Get the event format object:
      const xAOD::EventFormat* ef = this->inputEventFormat();
      if( ! ef ) {
         return StatusCode::FAILURE;
      }
      // Loop over the objects of the file:
      for( const auto & ef_itr : *ef ) {
         // A helper object:
         const xAOD::EventFormatElement& efe = ef_itr.second;
         // Skip auxiliary objects:
         if( efe.branchName().rfind( "Aux." ) ==
             ( efe.branchName().size() - 4 ) ) {
            continue;
         }
         // And dynamic variables:
         if( efe.parentName() != "" ) {
            continue;
         }
         // Skip auxiliary stores with non-standard names:
         ::TClass* cl = ::TClass::GetClass( efe.className().c_str(), kTRUE,
                                            kTRUE );
         if( ! cl ) continue;
         if( cl->InheritsFrom( "SG::IConstAuxStore" ) ) {
            continue;
         }
         // Get the type of the branch:
         const std::type_info* ti = cl->GetTypeInfo();
         if( ! ti ) {
            ::Warning( "REventClass::loadInputObjects",
                       "Couldn't find std::type_info object for type %s "
                       "(key=%s)", cl->GetName(), efe.branchName().c_str() );
            continue;
         }
         // Check if the branch exists in the file:
         static constexpr bool METADATA = false;
         if( ! this->contains( efe.branchName(), *ti, METADATA ) ) {
            continue;
         }
         // Try to load the object/container:
         static constexpr bool SILENT = false;
         if( ! this->getInputObject( efe.branchName(), *ti, SILENT, METADATA ) ) {
            Error( "REventClass::loadInputObjects",
                   XAOD_MESSAGE( "Couldn't load object: %s" ),
                   efe.branchName().c_str() );
            return StatusCode::FAILURE;
         }
      }
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

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 315 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 275 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 213 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 185 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 222 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;
}

putAux()

StatusCode xAOD::Experimental::REvent::putAux ( TVirtualManager & vmgr, ::Bool_t metadata = kFALSE )

privateinherited

Method saving the dynamically created auxiliary properties.

This function is used internally to set up the writing of the auxiliary store variables that were dynamically created on an object.

(And not statically defined to be part of that object.) The first time an aux store variable is encountered, an RAuxFieldManager is created to manage it. And for each call, the manager holder is set to point to the aux variable. Note: this may be called when recording an aux container, but new aux variables may be created up to a call to fill One also needs to keep track of empty aux containers on the first event to allow to add in the aux fields to the RNTuple model for the next event which has a non-empty container

Parameters

mgr	The object manager of the output object
metadata	Flag specifying whether the info written is metadata or not

Returns

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

Add field to RNTuple model

Definition at line 1497 of file REvent.cxx.

                                                                  {
 
  // A little sanity check:
  assert( m_outputEventFormat != 0 );
 
  // Do the conversion:
  ROutObjManager* mgr = dynamic_cast< ROutObjManager* >( &vmgr );
 
  ATH_MSG_DEBUG("REvent::putAux -  vmgr " << mgr);
 
  if( ! mgr ) {
      // It's not an error any more when we don't get a ROutObjManager.
      return StatusCode::SUCCESS;
  }
 
  // Check if this class has an auxiliary store, if not nothing needs to be done:
  if( ! mgr->holder()->getClass()->InheritsFrom( "SG::IAuxStoreIO" ) ) {
 
    ATH_MSG_DEBUG("REvent::putAux -  no Aux store ");
 
    return StatusCode::SUCCESS;
  }
 
  // Get a pointer to the auxiliary store I/O interface:
  SG::IAuxStoreIO* aux = reinterpret_cast< SG::IAuxStoreIO* >(mgr->holder()->getAs( typeid( SG::IAuxStoreIO ) ) );
  if( ! aux ) {
    ATH_MSG_FATAL( "There is a logic error in the code!" );
  }
 
  // Check if we have rules defined for which auxiliary properties
  // to write out:
  xAOD::AuxSelection sel;
  if( ! metadata ) {
    auto item_itr = m_auxItemList.find( mgr->key() );
    if( item_itr != m_auxItemList.end() ) {
      sel.selectAux( item_itr->second );
    }
  }
 
  // Get the dynamic auxiliary variables held by this object, which
  // were selected to be written:
  const SG::auxid_set_t auxids = sel.getSelectedAuxIDs (aux->getSelectedAuxIDs());
 
  // Decide what should be the prefix of all the dynamic branches:
  const std::string dynNamePrefix = Utils::dynBranchPrefix( mgr->key() );
 
  ATH_MSG_DEBUG("REvent::putAux -  dynNamePrefix " << dynNamePrefix);
 
 
  // Select which container to add the variables to:
  Object_t& objects = ( metadata ? m_outputMetaObjects : m_outputObjects );
 
  // RDS: is the following needed in an RNTuple?
  // This iteration will determine the ordering of branches within
  // the tree, so sort auxids by name.
  const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
  typedef std::pair< std::string, SG::auxid_t > AuxVarSort_t;
  std::vector< AuxVarSort_t > varsort;
  varsort.reserve( auxids.size() );
  for( SG::auxid_t id : auxids ) {
      varsort.emplace_back( r.getName( id ), id );
  }
  std::sort( varsort.begin(), varsort.end() );
 
  // Extract all the dynamic variables from the object:
  for( const auto& p : varsort ) {
 
    // The auxiliary ID:
    const SG::auxid_t id = p.second;
 
    // Construct a dynamic key name for the field that we will write:
    const std::string dynKey = dynNamePrefix + p.first;
 
    ATH_MSG_DEBUG("REvent::putAux -  id, dynKey " << id << ", " << dynKey);
 
 
    // Try to find the object manager:
    Object_t::iterator bmgr = objects.find( dynKey );
 
    // Check if we already know about this variable:
    if( bmgr == objects.end() ) {
      // Construct the full type name of the variable:
      const std::type_info* brType = aux->getIOType( id );
      if( ! brType ) {
        ATH_MSG_FATAL( "No I/O type found for variable " << dynKey );
        return StatusCode::FAILURE;
      }
      const std::string brTypeName = Utils::getTypeName( *brType );
      std::string brProperTypeName = "<unknown>";
 
      // Check if it's a primitive type or not:
      bool isPrimitive = false;
      TVirtualManager* outmgrPtr = nullptr;
 
      if( strlen( brType->name() ) == 1 ) {
        isPrimitive = true;
 
        ATH_MSG_DEBUG("REvent::putAux -  primitive " << id << ", " << brTypeName << " brType name " << brType->name());
 
 
        // Making the "proper" type name is simple in this case:
        brProperTypeName = std::move(brTypeName);
 
        // Let's create an RAuxFieldManager for this property:
        static constexpr bool IS_OWNER = false;
        auto auxmgr = std::make_unique<RAuxFieldManager>( 
          std::make_unique<THolder>(aux->getIOData( id ), *brType, IS_OWNER), isPrimitive );
        outmgrPtr = auxmgr.get();
 
        objects[ dynKey ] = std::move(auxmgr);
 
      } else {
 
        ATH_MSG_DEBUG("REvent::putAux -  not primitive " << id << ", " << brTypeName);
 
        // Check if we have a dictionary for this type:
        TClass* cl = TClass::GetClass( *brType, kTRUE, kTRUE );
        if( ! cl ) {
          // The dictionary needs to be loaded now. This could be an
          // issue. But let's hope for the best...
          cl = TClass::GetClass( brTypeName.c_str() );
          // If still not found...
          if( ! cl ) {
            ATH_MSG_FATAL( "Dictionary not available for variable \"" << dynKey 
                            << "\" of type \"" << brTypeName << "\"" );
            return StatusCode::FAILURE;
          }
        }
 
        // The proper type name comes from the dictionary in this case:
        brProperTypeName = cl->GetName();
 
        // Let's create an RAuxFieldManager for this property - not a primitive:
        static constexpr bool IS_OWNER = false;
        auto auxmgr = std::make_unique<RAuxFieldManager>( 
          std::make_unique<THolder>(aux->getIOData( id ), cl, IS_OWNER), isPrimitive );
        outmgrPtr = auxmgr.get();
        objects[ dynKey ] = std::move(auxmgr);
      }
 
      // For event data, add in the the new fields to the RNTuple model and event format metadata
      if (!metadata) {

        ATH_CHECK( addField(dynKey, *outmgrPtr) );
 
        // If all went fine, let's add this branch to the event format
        // metadata (but not for regular metadata):
        if( ! m_outputEventFormat->exists( dynKey ) ) {
            m_outputEventFormat->add(
                  EventFormatElement( dynKey,
                                      brProperTypeName,
                                      mgr->key(),
                                      getHash( dynKey ) ) );
        }
      }
 
      // We don't need to do the rest:
      continue;
    } 
 
    ATH_MSG_DEBUG("REvent::putAux -  setObj " << dynKey);
 
    // Access the object manager:
    bmgr = objects.find( dynKey );
    if( bmgr == objects.end() ) {
      ATH_MSG_FATAL( "There is an internal logic error in the code..." );
    }
    // Replace the managed object:
    void* nc_data ATLAS_THREAD_SAFE = // we hold non-const pointers but check on retrieve
      const_cast< void* >( static_cast< const void* >( aux->getIOData( id ) ) );
    bmgr->second->setObject( nc_data );
  }
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

readFrom() [1/2]

StatusCode xAOD::Experimental::REvent::readFrom ( std::string_view fileName )

inherited

Set up the reading of an input file via a file name.

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

This can be considered the 'native' interface as an RNTupleReader opens a file with a name

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 165 of file REvent.cxx.

                                                   {
 
  ATH_MSG_INFO("REvent::readFrom:  fileName " << fileName);
 
  // 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 = {};
 
 
  ATH_MSG_DEBUG("Create RNTupleReader for \"" << METADATA_OBJECT_NAME
                                               << "\" in file: " << fileName);
 
  // Set up a reader for the metadata ntuple.
  // Since some types are non-xAOD types and so not 'visible' when running in AnalysisBase
  //   we need to protect for unknown types with SetEmulateUnknownTypes(true)
  ROOT::RNTupleDescriptor::RCreateModelOptions opts;
  opts.SetEmulateUnknownTypes(true);
  m_metaReader = ROOT::RNTupleReader::Open(opts, METADATA_OBJECT_NAME, fileName);
  if (!m_metaReader) {
    ATH_MSG_ERROR("Couldn't find \"" << METADATA_OBJECT_NAME
                                     << "\" tree in input file: " << fileName);
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Created RNTupleReader for \"" << METADATA_OBJECT_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_OBJECT_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_OBJECT_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(std::move(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_RNTUPLE_NAME, fileName);
  if (!m_eventReader) {
    ATH_MSG_ERROR("Couldn't access RNTuple \"" << EVENT_RNTUPLE_NAME
                                               << "\" in file: " << fileName);
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Created RNTupleReader for \"" << EVENT_RNTUPLE_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;
}

readFrom() [2/2]

StatusCode xAOD::Experimental::REvent::readFrom ( TFile & inFile )

overridevirtualinherited

Set up the reading of an input file from TFile This method implements the interface from Event.

Implementation of interface method taking a TFile object. Forwards to the method with a string view below.

Implements xAOD::Event.

Definition at line 154 of file REvent.cxx.

                                         {
  ATH_CHECK(readFrom(inFile.GetName()));
  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 )

overrideprivatevirtualinherited

Record an object into a connected output file.

This is the function doing the heavy lifting when recording a new object into the output RNTuple.

It makes sure that the object is saved together with all of its dynamic auxiliary data if it has any.

Parameters

obj	A typeless pointer to the object that we want to record
typeName	The type name of the output object
key	The key (branch name) of the object to record
overwrite	Flag selecting if it is allowed to overwrite an already existing object (used internally)
metadata	Flag selecting if we are writing an event or a metadata object
isOwner	Flag selecting if we should take ownership of the object or not

Returns

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

Add field to RNTuple model

Implements xAOD::Event.

Definition at line 1342 of file REvent.cxx.

                                          {
 
 
  // Check if we have an output file when writing an event:
  if ( !hasOutput() ) {
    ATH_MSG_FATAL("No output output file defined. Did you forget to call writeTo(...)?" );
    return StatusCode::FAILURE;
  }
  assert( m_outputEventFormat != 0 );
 
  ATH_MSG_DEBUG("REvent::record - key, type " << key << ", " << typeName);
 
 
  // If this is metadata, just take ownership of it. The object will only
  // be recorded into the output file when calling finishWriting(...).
  if( metadata ) {
    // Check whether we already have such an object:
    if( ( ! overwrite ) &&
        ( m_outputMetaObjects.find( key ) !=
          m_outputMetaObjects.end() ) ) {
      ATH_MSG_FATAL("Meta-object " << typeName << "/" << key << " already recorded" );
      return StatusCode::FAILURE;
    }
    // Check if we have a dictionary for this object:
    TClass* cl = TClass::GetClass( typeName.c_str() );
    if( ! cl ) {
      ATH_MSG_ERROR( "Didn't find dictionary for type: " << typeName );
      return StatusCode::FAILURE;
    }
    // Create output object manager with a holder for the object:
    auto outmgr = std::make_unique<ROutObjManager>( key, std::make_unique<THolder>(obj, cl, isOwner));
    m_outputMetaObjects[key]       = std::move(outmgr);
    // We're done. The rest will be done later on.
    return StatusCode::SUCCESS;
  }
 
  // Check if we accessed this object on the input. If yes, then this
  // key may not be used for recording.
  if( ( ! overwrite ) &&
    ( m_inputObjects.find( key ) != m_inputObjects.end() ) ) {
    ATH_MSG_FATAL( "Object " << typeName << "/" << key << 
                   " already accessed from the input, can't be overwritten in memory" );
    return StatusCode::FAILURE;
  }
 
  // Check if we need to add it to the event record:
  Object_t::iterator vitr = m_outputObjects.find( key );
  if( vitr == m_outputObjects.end() ) {
 
    // Check if we have a dictionary for this object:
    TClass* cl = TClass::GetClass( typeName.c_str() );
    if( ! cl ) {
      ATH_MSG_ERROR( "Didn't find dictionary for type: " << typeName );
      return StatusCode::FAILURE;
    }
    // Check if this is a new object "type" or not:
    if( ! m_outputEventFormat->exists( key ) ) {
      m_outputEventFormat->add( EventFormatElement( key, cl->GetName(),
                                                    "", getHash( key ) ) );
    }
    // Create output object manager with a holder for the object:
    auto outmgr = std::make_unique<ROutObjManager>( key, std::make_unique<THolder>(obj, cl, isOwner));
    ROutObjManager* outmgrPtr = outmgr.get();
    m_outputObjects[ key ] = std::move(outmgr);
 
    ATH_MSG_DEBUG("REvent::record - save outObjMgr for key, type " << key << ", " << typeName);
 
    // Set up the saving of all the dynamic auxiliary properties
    // of the object if it has any:
    ATH_CHECK( putAux( *outmgrPtr ) );

    ATH_CHECK( addField(key, *outmgrPtr) );
 
    // Return at this point, as we don't want to run the rest of
    // the function's code:
    return StatusCode::SUCCESS;
  }
 
  // Access the object manager:
  ROutObjManager* omgr = dynamic_cast< ROutObjManager* >( vitr->second.get() );
  if( ! omgr ) {
    ATH_MSG_FATAL( "Manager object of the wrong type encountered" );
    return StatusCode::FAILURE;
  }
 
  // RDS: Is the following still needed?
  // // Check that the type of the object matches that of the previous
  // // object:
  // if( typeName != omgr->holder()->getClass()->GetName() ) {
  //    // This may still be, when the ROOT dictionary name differs from the
  //    // "simple type name" known to C++. So let's get the ROOT name of the
  //    // new type:
  //    TClass* cl = TClass::GetClass( typeName.c_str() );
  //    if( ( ! cl ) || ::strcmp( cl->GetName(),
  //                              omgr->holder()->getClass()->GetName() ) ) {
  //       ATH_MSG_FATAL(
  //                XAOD_MESSAGE( "For output key \"%s\" the previous type "
  //                              "was \"%s\", the newly requested type is "
  //                              "\"%s\"" ),
  //                key.c_str(), omgr->holder()->getClass()->GetName(),
  //                typeName.c_str() );
  //       return StatusCode::FAILURE;
  //    }
  // }
 
  // Replace the managed object:
  omgr->setObject( obj );
 
  // Replace the auxiliary objects:
  return putAux( *omgr );
} // record

recordAux()

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

overrideprivatevirtualinherited

Record an auxiliary store into a connected output file.

Implements xAOD::Event.

Definition at line 1460 of file REvent.cxx.

                                            {
 
  // Check if the auxiliary store is a generic object.
  Details::IObjectManager* iomgr = dynamic_cast<Details::IObjectManager*>(&mgr);
  if (iomgr != nullptr) {
    // Record the auxiliary object using the main record function.
    static const bool OVERWRITE = true;
    static const bool IS_OWNER = true;
    ATH_CHECK(record(iomgr->object(), iomgr->holder()->getClass()->GetName(),
                     key, OVERWRITE, metadata, IS_OWNER));
    return StatusCode::SUCCESS;
  }
 
  // Apparently we didn't recorgnize the auxiliary store type.
  ATH_MSG_ERROR("Unknown auxiliary store manager type encountered");
  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 309 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 304 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>

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

inherited

Retrieve an output object from the event.

retrieve() [3/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() [4/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)

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.

REvent()

xAOD::Experimental::REvent::REvent

(

)

Default constructor.

Definition at line 37 of file REvent.cxx.

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

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 )

overrideprivatevirtualinherited

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 1217 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 )

privateinherited

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 1816 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 289 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.

writeTo()

StatusCode xAOD::Experimental::REvent::writeTo ( TFile & file )

overridevirtualinherited

Connect the object to an output file.

This function should be called to create a file for writing and setup the output RNTuple and metadata trees.

Parameters

file	the TFile to which the output is writter

Implements xAOD::Event.

Definition at line 342 of file REvent.cxx.

                                      {
 
  // Save filefor writing
  m_outputFile = &file;
  
  ATH_MSG_DEBUG("REvent::writeTo - opened output file " << m_outputFile->GetName());
 
  // Access the EventFormat object associated with this file:
  m_outputEventFormat =
      &( TEventFormatRegistry::instance().getEventFormat( m_outputFile ) );
 
  ATH_MSG_DEBUG("REvent::writeTo - creating RNTupleModel ");
 
  // Create new model for this file
  m_model = ROOT::RNTupleModel::Create();
 
  // Set output RNTuple name as model description
  const char*  rnTupleName = EVENT_RNTUPLE_NAME;
  m_model->SetDescription(rnTupleName);
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

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 387 of file Event.h.

DEFAULT_KEY

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.

EVENT_RNTUPLE_NAME

const char *const Event::EVENT_RNTUPLE_NAME = "EventData"

staticinherited

Name of the event RNTuple.

Definition at line 77 of file Event.h.

EVENT_TREE_NAME

const char *const Event::EVENT_TREE_NAME = "CollectionTree"

staticinherited

Default name of the event TTree.

Name of the event TTree.

Definition at line 76 of file Event.h.

KEY_MASK

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 355 of file Event.h.

m_branchesMutex

upgrade_mutex_t xAOD::Event::m_branchesMutex

mutableprotectedinherited

Mutex for multithread synchronization.

Definition at line 383 of file Event.h.

m_entry

::Long64_t xAOD::Experimental::REvent::m_entry {}

privateinherited

The entry to look at from the input.

Definition at line 138 of file REvent.h.

{};

m_eventReader

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

privateinherited

The main event data reader.

Definition at line 131 of file REvent.h.

m_eventWriter

std::unique_ptr<ROOT::RNTupleWriter> xAOD::Experimental::REvent::m_eventWriter

privateinherited

The main event writer: RNTupleWeader.

Definition at line 144 of file REvent.h.

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_inputEventFormat

EventFormat xAOD::Event::m_inputEventFormat

protectedinherited

Format of the current input file.

Definition at line 350 of file Event.h.

m_inputMetaObjects

Object_t xAOD::Event::m_inputMetaObjects

protectedinherited

Collection of all the managed input meta-objects.

Definition at line 345 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 340 of file Event.h.

m_inputNTupleIsMissing

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

privateinherited

Whether the input has an event RNTuple or not.

Definition at line 133 of file REvent.h.

m_inputObjects

Object_t xAOD::Event::m_inputObjects

protectedinherited

Collection of all the managed input objects.

Definition at line 337 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 358 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.

{ MSG::NIL };

m_metaReader

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

privateinherited

The metadata reader.

Definition at line 135 of file REvent.h.

m_model

std::unique_ptr<ROOT::RNTupleModel> xAOD::Experimental::REvent::m_model

privateinherited

The RNTuple model used for event fields.

Definition at line 141 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 361 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 352 of file Event.h.

m_outputFile

::TFile* xAOD::Experimental::REvent::m_outputFile {nullptr}

privateinherited

The output file for writing.

Definition at line 147 of file REvent.h.

{nullptr};

m_outputMetaObjects

Object_t xAOD::Event::m_outputMetaObjects

protectedinherited

Collection of all the managed output meta-objects.

Definition at line 347 of file Event.h.

m_outputObjects

Object_t xAOD::Event::m_outputObjects

protectedinherited

Collection of all the managed output object.

Definition at line 342 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 364 of file Event.h.

METADATA_OBJECT_NAME

const char *const Event::METADATA_OBJECT_NAME = "MetaData"

staticinherited

Name of the metadata tree or RNTuple.

Definition at line 78 of file Event.h.

---

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

• xAODRNFileReadTest.cxx