xAOD::TEvent Class Reference

Tool for accessing xAOD files outside of Athena. More...

#include <TEvent.h>

Inheritance diagram for xAOD::TEvent:

Collaboration diagram for xAOD::TEvent:

Public Types
enum	EAuxMode { kBranchAccess = 0 , kClassAccess = 1 , kAthenaAccess = 2 }
	Auxiliary store "mode". More...
using	sgkey_t = SG::sgkey_t

Public Member Functions
	TEvent (EAuxMode mode=kClassAccess, const EventContext *ctx=nullptr)
	Default constructor.
	TEvent (::TFile *file, EAuxMode mode=kClassAccess)
	Constructor connecting the object to an input TFile.
	TEvent (::TTree *tree, EAuxMode mode=kClassAccess)
	Constructor connecting the objects to an input TTree/TChain.
virtual	~TEvent ()
	Destructor.
void	setOtherMetaDataTreeNamePattern (const std::string &pattern)
	Change the pattern used for collecting information from other MetaData trees NB: Additional MetaData trees are only expected for augmented files This function also allows user to redefine MetaData tree pattern to skip trees that would not be proper MetaData ones i.e.
EAuxMode	auxMode () const
	Get what auxiliary access mode the object was constructed with.
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 (::TFile *file, bool useTreeCache=true, std::string_view treeName=EVENT_TREE_NAME)
	This is the 'native' interface for reading from a TFile, allowing the specification of TTree cache use and the event tree name.
StatusCode	readFrom (::TTree *tree, bool useTreeCache=true)
	Connect the object to a new input tree/chain.
StatusCode	writeTo (TFile &file) override
	Connect the object to an output file.
StatusCode	writeTo (::TFile *file, int autoFlush=200, std::string_view treeName=EVENT_TREE_NAME)
	Connect the object to an output file.
StatusCode	finishWritingTo (TFile &file) override
	Finish writing to an output file.
StatusCode	finishWritingTo (::TFile *file)
	Finish writing to an output file.
Event data accessor/modifier functions
SG::IAuxStore *	recordAux (const std::string &key, SG::IAuxStoreHolder::AuxStoreType type=SG::IAuxStoreHolder::AST_ContainerStore)
	Add an auxiliary store object to 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
::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 TTree.
::Long64_t	getFiles () const
	Get how many files are available on the currently defined input.
::Int_t	getFile (::Long64_t file, ::Int_t getall=0)
	Load the first event for a given file from the input TChain.
::Int_t	fill () override
	Function filling one event into the output tree.
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
StatusCode	initStats ()
	Function to initialise the statistics for all Tree content.
StatusCode	record (std::unique_ptr< TAuxStore > store, const std::string &key)
	Internal function for adding an auxiliary store object to the output.
StatusCode	setUpDynamicStore (TObjectManager &mgr, ::TTree *tree)
	Function adding dynamic variable reading capabilities to an auxiliary store object.
StatusCode	putAux (::TTree &outTree, TVirtualManager &mgr, bool metadata)
	Function saving the dynamically created auxiliary properties.
StatusCode	recordAux (TAuxStore *store, const std::string &key)
	Function setting up an existing auxiliary store for writing.
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.
const EventContext &	currentContext () const
	Return the event context corresponding to this event.
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.
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.

Protected Attributes
EAuxMode	m_auxMode
	The auxiliary access mode.
::TTree *	m_inTree = nullptr
	The main tree that we are reading from.
bool	m_inTreeMissing = false
	Internal status flag showing that an input file is open, but it doesn't contain an event tree.
::TChain *	m_inChain = nullptr
	The (optional) chain provided as input.
std::unique_ptr< TChainStateTracker >	m_inChainTracker
	Optional object for tracking the state changes of an input TChain.
::Int_t	m_inTreeNumber = -1
	The number of the currently open tree in the input chain.
::TTree *	m_inMetaTree = nullptr
	Pointer to the metadata tree in the input file.
::Long64_t	m_entry = -1
	The entry to look at from the input tree.
std::unique_ptr<::TTree >	m_outTree
	The tree that we are writing to.
std::regex	m_otherMetaDataTreeNamePattern
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
friend::TTree *	MakeTransientTree (TEvent &, const char *)
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
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.

Friends
class	::xAODTEventBranch
class	::xAODTMetaBranch
class	xAOD::TFileMerger
class	xAOD::TTreeMgr
class	CP::xAODWriterAlg

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

Helper functions for the IProxyDict interface
EventContext	m_ctx
	The event context associated with this event.
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.

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.

Detailed Description

Tool for accessing xAOD files outside of Athena.

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

For a detailed description of the usage of this class, see: <Link to be added here...>

Author

Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h

Definition at line 59 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

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

Member Enumeration Documentation

EAuxMode

enum xAOD::TEvent::EAuxMode

Auxiliary store "mode".

Enumerator
kBranchAccess	Access auxiliary data branch-by-branch.
kClassAccess	Access auxiliary data using the aux containers.
kAthenaAccess	Access containers/objects like Athena does.

Definition at line 71 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

                {
    kBranchAccess = 0, 
    kClassAccess = 1,  
    kAthenaAccess = 2  
  };

Constructor & Destructor Documentation

TEvent() [1/3]

xAOD::TEvent::TEvent	(	EAuxMode	mode = kClassAccess,
		const EventContext *	ctx = nullptr )

Default constructor.

Definition at line 72 of file Control/xAODRootAccess/Root/TEvent.cxx.

  : Event("xAOD::TEvent", ctx),
    m_auxMode(mode)
{}

TEvent() [2/3]

xAOD::TEvent::TEvent	(	::TFile *	file,
		EAuxMode	mode = kClassAccess )

Constructor connecting the object to an input TFile.

Definition at line 77 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                         : TEvent(mode) {
 
  // Let the initialisation function deal with setting up the object.
  readFrom(file).ignore();
}

TEvent() [3/3]

xAOD::TEvent::TEvent	(	::TTree *	tree,
		EAuxMode	mode = kClassAccess )

Constructor connecting the objects to an input TTree/TChain.

Definition at line 83 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                         : TEvent(mode) {
 
  // Let the initialisation function deal with setting up the object.
  readFrom(tree).ignore();
}

~TEvent()

xAOD::TEvent::~TEvent ( )

virtual

Destructor.

Definition at line 89 of file Control/xAODRootAccess/Root/TEvent.cxx.

                {
 
  // Check that the user didn't forget to call finishWritingTo().
  if (m_outTree) {
    ATH_MSG_ERROR(
        "Did not call finishWritingTo() before destroying the TEvent object!");
  }
 
  // Clear the input and output objects before the input/output files would be
  // closed. Otherwise we can be left with "TTree related" objects pointing
  // nowhere.
  m_inputObjects.clear();
  m_outputObjects.clear();
}

Member Function Documentation

addListener()

StatusCode Event::addListener ( TVirtualIncidentListener * listener )

inherited

Register an incident listener object.

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

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

Parameters

listener

Pointer to the object that should be notified

Returns

The usual StatusCode types

Definition at line 109 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 174 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 257 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
  BranchInfo bi;
  bi.m_proxy.reset(proxy);
  lock.upgrade();
#ifdef XAOD_STANDALONE
  std::string uniqueKey = std::format("NonExistentKey_{}", m_branches.size());
  SG::sgkey_t sgkey = stringToKey(uniqueKey, clid);
#else
  SG::sgkey_t sgkey = proxy->sgkey();
#endif
  m_branches.emplace (sgkey, std::move(bi));
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

auxMode()

TEvent::EAuxMode xAOD::TEvent::auxMode

(

)

const

Get what auxiliary access mode the object was constructed with.

Returns

The auxiliary data access mode currently in use

Definition at line 106 of file Control/xAODRootAccess/Root/TEvent.cxx.

{ return m_auxMode; }

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 155 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 205 of file EventCore.cxx.

                           {
 
  m_nameRemapping.clear();
}

connectAux()

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

overrideprotectedvirtual

Function setting up access to a set of auxiliary branches.

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

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

Parameters

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

Returns

The usual StatusCode types

Implements xAOD::Event.

Definition at line 1365 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                                      {
 
  // A simple test...
  if (hasInput() == false) {
    ATH_MSG_ERROR("No input tree is available");
    return StatusCode::FAILURE;
  }
 
  // Check if we know anything about this auxiliary object:
  if ((!m_inTree->GetBranch(prefix.c_str())) &&
      (m_auxMode == kClassAccess || m_auxMode == kAthenaAccess)) {
    // If not, then let's just return right away. Not having
    // an auxiliary object with this name is not an error per se.
    return StatusCode::SUCCESS;
  }
 
  // Check if the branch is already connected.
  if (m_inputObjects.contains(prefix)) {
    return StatusCode::SUCCESS;
  }
 
  // Do different things based on the "auxiliary mode" we are in.
  if ((m_auxMode == kClassAccess) || (m_auxMode == kAthenaAccess)) {
 
    // In "class" and "athena" access modes just connect the concrete auxiliary
    // object to the input.
    static constexpr bool SILENT = false;
    ATH_CHECK(connectObject(prefix, SILENT));
 
    // Return gracefully.
    return StatusCode::SUCCESS;
 
  } else if (m_auxMode == kBranchAccess) {
 
    // In "branch access mode" let's create a TAuxStore object, and let
    // that take care of the auxiliary store access.
    static constexpr bool TOP_STORE = true;
    auto store = std::make_unique<TAuxStore>(
        this->currentContext(),
        prefix, TOP_STORE,
        (standalone ? TAuxStore::EStructMode::kObjectStore
                    : TAuxStore::EStructMode::kContainerStore));
 
    // Connect it to the input tree.
    ATH_CHECK(store->readFrom(*m_inTree));
 
    // We're using this object to read from the input, it needs to be
    // locked:
    store->lock();
 
    // Finally, set up an appropriate manager for it.
    static constexpr bool IS_OWNER = true;
    m_inputObjects[prefix] =
        std::make_unique<TAuxManager>(store.release(), IS_OWNER);
 
    // Return gracefully:
    return StatusCode::SUCCESS;
  }
 
  // There was some problem:
  ATH_MSG_ERROR("Unknown auxiliary access mode set (" << m_auxMode << ")");
  return StatusCode::FAILURE;
}

connectMetaAux()

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

overrideprotectedvirtual

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

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

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

Parameters

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

Returns

The usual StatusCode types

Implements xAOD::Event.

Definition at line 1438 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                                          {
 
  // Check if the branch is already connected:
  if (m_inputMetaObjects.contains(prefix)) {
    return StatusCode::SUCCESS;
  }
 
  // A sanity check:
  if (!m_inMetaTree) {
    ATH_MSG_FATAL("Internal logic error detected");
    return StatusCode::FAILURE;
  }
 
  // Do different things based on the "auxiliary mode" we are in:
  if (m_auxMode == kClassAccess || m_auxMode == kAthenaAccess) {
 
    // In "class" and "athena" access modes just connect the concrete auxiliary
    // object to the input.
    static constexpr bool SILENT = false;
    ATH_CHECK(connectMetaObject(prefix, SILENT));
 
    // Return gracefully:
    return StatusCode::SUCCESS;
 
  } else if (m_auxMode == kBranchAccess) {
 
    // In "branch access mode" let's create a TAuxStore object, and let
    // that take care of the auxiliary store access.
    static constexpr bool TOP_STORE = true;
    auto store = std::make_unique<TAuxStore>(
        this->currentContext(),
        prefix, TOP_STORE,
        (standalone ? TAuxStore::EStructMode::kObjectStore
                    : TAuxStore::EStructMode::kContainerStore));
 
    // Connect it to the input tree.
    ATH_CHECK(store->readFrom(*m_inMetaTree));
 
    // We're using this object to read from the input, it needs to be
    // locked:
    store->lock();
 
    // Finally, set up an appropriate manager for it.
    static constexpr bool IS_OWNER = true;
    m_inputMetaObjects[prefix] =
        std::make_unique<TAuxManager>(store.release(), IS_OWNER);
 
    // Return gracefully.
    return StatusCode::SUCCESS;
  }
 
  // There was some problem:
  ATH_MSG_ERROR("Unknown auxiliary access mode set (" << m_auxMode << ")");
  return StatusCode::FAILURE;
}

connectMetaObject()

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

overrideprotectedvirtual

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 1264 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                                      {
 
  // A little sanity check:
  if (!m_inMetaTree) {
    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;
  }
 
  // Check if the branch exists in our metadata tree:
  ::TBranch* br = m_inMetaTree->GetBranch(key.c_str());
  if (br == nullptr) {
    if (silent == false) {
      ATH_MSG_WARNING("Metadata branch \"" << key
                                           << "\" not available on input");
    }
    return StatusCode::RECOVERABLE;
  }
 
  // Check that we have an entry in the branch:
  if (br->GetEntries() == 0) {
    if (silent == false) {
      ATH_MSG_WARNING("Metadata branch \"" << key
                                           << "\" doesn't hold any data");
    }
    return StatusCode::RECOVERABLE;
  }
 
  // Make sure that it's not in "MakeClass mode":
  br->SetMakeClass(0);
 
  // Extract the type of the branch:
  ::TClass* cl = 0;
  ::EDataType dt = kOther_t;
  if (br->GetExpectedType(cl, dt) || (!cl)) {
    ATH_MSG_ERROR("Couldn't get the type for metadata branch \"" << key
                                                                 << "\"");
    return StatusCode::FAILURE;
  }
 
  // Create the object, and all of the managers around it:
  void* ptr = cl->New();
  const bool renewOnRead = (m_auxMode == kAthenaAccess);
  auto mgr = std::make_unique<TObjectManager>(
      nullptr, std::make_unique<THolder>(ptr, cl), renewOnRead);
 
  // Now try to connect to the branch:
  const ::Int_t status = m_inMetaTree->SetBranchAddress(
      key.c_str(), mgr->holder()->getPtr(), mgr->branchPtr(), cl, dt, kTRUE);
  if (status < 0) {
    ATH_MSG_ERROR("Couldn't connect variable of type \""
                  << cl->GetName() << "\" to input branch \"" << key
                  << "\". Return code: " << status);
    // Clean up:
    *(mgr->holder()->getPtr()) = 0;
    m_inputMetaObjects.erase(key);
    return StatusCode::FAILURE;
  }
 
  // Store the manager.
  TObjectManager *mgrPtr = mgr.get();
  m_inputMetaObjects[key] = std::move(mgr);
 
  // Read in the object:
  if (mgrPtr->getEntry() < 0) {
    ATH_MSG_ERROR("Couldn't read in metadata object with key \"" << key
                                                                 << "\"");
    return StatusCode::FAILURE;
  }
 
  // If it's an auxiliary store object, set it up correctly:
  if (Details::isAuxStore(*(mgrPtr->holder()->getClass()))) {
    ATH_CHECK(setUpDynamicStore(*mgrPtr, m_inMetaTree));
  }
 
  // If there may be an auxiliary object connected to this one,
  // connect that 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));
  }
 
  // We succeeded:
  return StatusCode::SUCCESS;
}

connectObject()

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

overrideprotectedvirtual

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 branch of the input TTree.

The type that is read in to memory is not actually determined by the type written to the tree itself, but from the xAOD::EventFormat object. Which is there to make it possible to possibly use ROOT read rules in the future 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 branch can't be connected to

Returns

The usual StatusCode types

Implements xAOD::Event.

Definition at line 1092 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                                  {
 
  // A little sanity check:
  if (hasInput() == false) {
    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 == false) {
      ATH_MSG_WARNING("Branch \"" << key << "\" not available on input");
    }
    return StatusCode::RECOVERABLE;
  }
 
  // Check if we have metadata about this branch:
  const xAOD::EventFormatElement* ef = nullptr;
  if (m_inputEventFormat.exists(key) == false) {
    if (silent == false) {
      ATH_MSG_WARNING("No metadata available for branch: " << key);
    }
  } else {
    ef = m_inputEventFormat.get(key);
  }
 
  // Check if the branch exists in our input tree:
  ::TBranch* br = m_inTree->GetBranch(key.c_str());
  if (br == nullptr) {
    if (!silent) {
      ATH_MSG_WARNING("Branch \"" << key << "\" not available on input");
    }
    m_inputMissingObjects.insert(key);
    return StatusCode::RECOVERABLE;
  }
 
  // Make sure that it's not in "MakeClass mode":
  br->SetMakeClass(0);
 
  // Decide about the type that we need to use for the reading of this
  // branch:
  std::string className = br->GetClassName();
  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 branch \""
          << key << "\"");
      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 branch \""
        << key << "\"");
    return StatusCode::FAILURE;
  }
 
  // Make sure that the current object is the "active event":
#ifndef XAOD_STANDALONE
  SG::CurrentEventStore::Push save (SG::CurrentEventStore::store());
#endif
  setActive();
 
  // The data type is always "other" for us:
  static const ::EDataType dataType = kOther_t;
 
  // 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;
  Object_t::const_iterator out_itr = m_outputObjects.find(key);
  if (out_itr != m_outputObjects.end()) {
    // It needs to be an object manager...
    TObjectManager* mgr = dynamic_cast<TObjectManager* >(out_itr->second.get());
    if (mgr == nullptr) {
      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:
  const bool renewOnRead = (m_auxMode == kAthenaAccess);
  auto mgr = std::make_unique<TObjectManager>(
      nullptr, std::make_unique<THolder>(ptr, realClass), renewOnRead);
 
  // One final check. If it's not an auxiliary store, then it must have
  // a split level of 0. Otherwise read rules may not work on it. Causing
  // *very* serious silent corruption in the data read, if we don't use
  // the "Athena read mode".
  if ((m_auxMode != kAthenaAccess) && (br->GetSplitLevel() != 0) &&
      (Details::isAuxStore(*(mgr->holder()->getClass())) == false)) {
    ATH_MSG_ERROR("Split level for branch \""
                  << key << "\" is " << br->GetSplitLevel()
                  << ". This can only be read in kAthenaAccess mode.");
    // Clean up:
    *(mgr->holder()->getPtr()) = nullptr;
    m_inputObjects.erase(key);
    return StatusCode::FAILURE;
  }
 
  // Now try to connect to the branch:
  const ::Int_t status =
      m_inTree->SetBranchAddress(key.c_str(), mgr->holder()->getPtr(),
                                 mgr->branchPtr(), realClass, dataType, kTRUE);
  if (status < 0) {
    ATH_MSG_ERROR("Couldn't connect variable of type \""
                  << className << "\" to input branch \"" << key
                  << "\". Return code: " << status);
    // Clean up:
    *(mgr->holder()->getPtr()) = 0;
    m_inputObjects.erase(key);
    return StatusCode::FAILURE;
  }
 
  // At this point we have successfully connected the branch.
  TObjectManager* 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_inTree));
  }
 
  // If there may be an auxiliary object connected to this one,
  // connect that as well:
  if (Details::hasAuxStore(*(mgrPtr->holder()->getClass()))) {
    ATH_CHECK(connectAux(
        key + "Aux.", Details::isStandalone(*(mgrPtr->holder()->getClass()))));
  }
 
  // Return gracefully.
  return StatusCode::SUCCESS;
}

contains() [1/2]

template<typename T>

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

inherited

Function checking if an object is available from the store.

contains() [2/2]

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

protectedinherited

Internal function checking if an object is in the input.

containsMeta()

template<typename T>

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

inherited

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

copy()

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

inherited

Copy an object directly from the input to the output.

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

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

Parameters

pattern

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

Definition at line 95 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 43 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
    // Check if file is AOD, in which case kAthenaAccess must be used
    auto eauxMode = TEvent::kClassAccess;
    std::string sauxMode = "kClassAccess";
    auto metaData = dynamic_cast<TTree*>(inFile.Get("MetaData"));
    if (metaData) {
      auto rc = metaData->LoadTree(0);
      if (rc < 0)[[unlikely]]{
        ANA_MSG_ERROR("Error from LoadTree: "<< rc);
        return {};
      }
      if (metaData->GetBranch("StreamAOD")) {
        eauxMode = TEvent::kAthenaAccess; 
        sauxMode = "kAthenaAccess";
      }
    }
    ANA_MSG_INFO("Using aux mode " << sauxMode << " for file " << inFile.GetName());
    auto event = std::make_unique<TEvent>(eauxMode);
    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 {};
  }
}

currentContext()

const EventContext & Event::currentContext ( ) const

protectedinherited

Return the event context corresponding to this event.

(Returns a dummy in standalone builds.)

Definition at line 316 of file EventCore.cxx.

                                                {
#ifdef XAOD_STANDALONE
  return Gaudi::Hive::currentContext();
#else
  return m_ctx;
#endif
}

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 262 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::TEvent::fill ( )

overridevirtual

Function filling one event into the output tree.

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 850 of file Control/xAODRootAccess/Root/TEvent.cxx.

                   {
 
  // A little sanity check:
  if (!m_outTree) {
    ATH_MSG_ERROR("Object not connected to an output file!");
    return 0;
  }
 
  // Make sure that all objects have been read in. The 99 as the value
  // has a special meaning for TAuxStore. 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.)
  Int_t readBytes = 0;
  if (m_inChain != nullptr) {
    readBytes = getEntry(m_inChain->GetReadEntry(), 99);
  } else if (m_inTree != nullptr) {
    readBytes = getEntry(m_entry, 99);
  }
  if (readBytes < 0) {
    ATH_MSG_ERROR("getEntry failed!");
    return readBytes;
  }
 
  // 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) {
    outputObjectsCopy.emplace_back(key, mgr.get());
  }
  for (auto &[key, mgr] : outputObjectsCopy) {
    // Check that a new object was provided in the event:
    if (!mgr->create()) {
      // 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,
    // get added to the output:
    static constexpr bool METADATA = false;
    if (putAux(*m_outTree, *mgr, METADATA).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;
  }
 
  // Write the entry, and check the return value:
  const ::Int_t ret = m_outTree->Fill();
  if (ret <= 0) {
    ATH_MSG_ERROR("Output tree filling failed with return value: " << ret);
  }
 
  // Reset the object managers.
  for (auto &[key, mgr] : m_outputObjects) {
    mgr->reset();
  }
 
  // Return the value:
  return ret;
}

finishWritingTo() [1/2]

StatusCode xAOD::TEvent::finishWritingTo

(

::TFile *

file

)

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

The usual StatusCode tyoes

Definition at line 482 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                              {
 
  // A small sanity check:
  if (!m_outTree) {
    ATH_MSG_ERROR("The object doesn't seem to be connected to an output file!");
    return StatusCode::FAILURE;
  }
 
  // Make sure we return to the current directory:
  TDirectoryReset dr;
 
  // 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);
  }
 
  // Write out the event tree, and delete it:
  m_outTree->AutoSave("FlushBaskets");
  m_outTree->SetDirectory(0);
  m_outTree.reset();
 
  // Now go to the output file:
  file->cd();
 
  // Check if there's already a metadata tree in the output:
  if (file->Get(METADATA_OBJECT_NAME)) {
    // Let's assume that the metadata is complete in the file already.
    return StatusCode::SUCCESS;
  }
 
  // Create the metadata tree.
  auto metatree =
      std::make_unique<TTree>(METADATA_OBJECT_NAME, "xAOD metadata tree");
  metatree->SetAutoSave(10000);
  metatree->SetAutoFlush(-30000000);
  metatree->SetDirectory(file);
 
  // Create the xAOD::EventFormat branch in it.
  try {
    metatree->Branch(
        "EventFormat",
        SG::normalizedTypeinfoName(typeid(xAOD::EventFormat)).c_str(),
        &m_outputEventFormat);
  } catch (const CxxUtils::ClassName::ExcBadClassName &e) {
    ::Error("xAOD::TEvent::finishWritingTo",
            XAOD_MESSAGE("Class name parsing fails for %s ! "), e.what());
    return StatusCode::FAILURE;
  }
 
  // Create a copy of the m_outputMetaObjects variable. This is necessary
  // because the putAux(...) function will modify this variable while we
  // loop over it.
  std::vector<std::pair<std::string, TObjectManager* >> outputMetaObjects;
  outputMetaObjects.reserve(m_outputMetaObjects.size());
  for (const auto &[key, mgr] : m_outputMetaObjects) {
    TObjectManager* objMgr = dynamic_cast<TObjectManager* >(mgr.get());
    if (objMgr == nullptr) {
      ATH_MSG_FATAL("Internal logic error detected");
      return StatusCode::FAILURE;
    }
    outputMetaObjects.emplace_back(key, objMgr);
  }
 
  // Now loop over all the metadata objects that need to be put into the
  // output file:
  for (auto &[key, mgr] : outputMetaObjects) {
 
    // Select a split level depending on whether this is an interface or an
    // auxiliary object:
    const ::Int_t splitLevel = (key.ends_with("Aux.") ? 1 : 0);
    // Create the new branch:
    *(mgr->branchPtr()) =
        metatree->Branch(key.c_str(), mgr->holder()->getClass()->GetName(),
                         mgr->holder()->getPtr(), 32000, splitLevel);
    if (!mgr->branch()) {
      ATH_MSG_ERROR("Failed to create metadata branch \""
                    << mgr->holder()->getClass()->GetName() << "/" << key
                    << "\"");
      return StatusCode::FAILURE;
    }
    // Set up the saving of all the dynamic auxiliary properties
    // of the object if it has any:
    static constexpr bool METADATA = true;
    ATH_CHECK(putAux(*metatree, *mgr, METADATA));
  }
 
  // Write the metadata objects:
  if (metatree->Fill() <= 0) {
    ATH_MSG_ERROR("Failed to write event format metadata into the output");
    metatree->SetDirectory(nullptr);
    return StatusCode::FAILURE;
  }
 
  // Now clean up:
  metatree->Write();
  metatree->SetDirectory(nullptr);
  m_outputEventFormat = nullptr;
  m_outputObjects.clear();
  m_outputMetaObjects.clear();
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

finishWritingTo() [2/2]

StatusCode xAOD::TEvent::finishWritingTo ( TFile & file )

overridevirtual

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

The usual StatusCode tyoes

Implements xAOD::Event.

Definition at line 472 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                              {
  return finishWritingTo(&file);
}

getBranchInfo()

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

protectedinherited

Get the object describing one object/branch.

Definition at line 356 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::TEvent::getEntries ( ) const

overridevirtual

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 657 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                  {
 
  if (m_inChain) {
    return m_inChain->GetEntries();
  } else if (m_inTree) {
    return m_inTree->GetEntries();
  } else if (m_inTreeMissing) {
    // The input file is empty:
    return 0;
  } else {
    ATH_MSG_ERROR("Function called on an uninitialised object");
    return 0;
  }
}

getEntry()

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

overridevirtual

Function loading a given entry of the input TTree.

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

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

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

Parameters

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

Returns

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

Implements xAOD::Event.

Definition at line 686 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                   {
 
  // A little sanity check:
  if ((!m_inTree) && (!m_inChain)) {
    ATH_MSG_ERROR("Function called on an uninitialised object");
    return -1;
  }
 
  // If we have a chain as input:
  if (m_inChain) {
    // Make sure that the correct tree is loaded:
    const ::Long64_t fileEntry = m_inChain->LoadTree(entry);
    if (fileEntry < 0) {
      ATH_MSG_ERROR("Failure in loading entry " << entry
                                                << " from the input chain");
      return -1;
    }
    // Check if a new file was loaded:
    if ((m_inTreeNumber != m_inChain->GetTreeNumber()) ||
        m_inChainTracker->internalStateChanged()) {
      // Reset the tracker:
      m_inChainTracker->reset();
      // Connect to this new file:
      m_inTreeNumber = m_inChain->GetTreeNumber();
      ::TFile* file = m_inChain->GetFile();
      // The useTreeCache parameter is set to false, since the cache
      // is anyway set up through the TChain. It shouldn't be modified
      // on the file level.
      static constexpr bool USE_TREE_CACHE = false;
      if (readFrom(file, USE_TREE_CACHE, m_inChain->GetName()).isFailure()) {
        ATH_MSG_ERROR("Couldn't connect to input file #"
                      << m_inTreeNumber << " of the input chain");
        return -1;
      }
    }
    // Restore the previously received entry number.
    m_entry = fileEntry;
  }
  // If we have a regular file/tree as input:
  else {
    m_entry = entry;
  }
 
  // In order to make the reading of branches+tree cache work
  // NB: TTree::LoadTree() only set the entry that should be read for each
  // branch but no reading of the branch content is performed when calling that
  // function. The entry set that can be retrieved with
  // branch->GetTree()->GetReadEntry()
  // For friend trees, if an index was built, then the entry which is set for
  // the related branches is found by the LoadTree function by matching the the
  // major and minor values of the main tree and friend tree
  if (m_inTree && m_inTree->LoadTree(m_entry) < 0) {
    ATH_MSG_ERROR("Failure in loading entry " << m_entry
                                              << " from the input file");
    return -1;
  }
 
  // Stats counter needs to know it's the next event:
  IOStats::instance().stats().nextEvent();
 
  // The final number of bytes read.
  ::Int_t result = 0;
 
  // Check if objects need to be read in.
  if (getall) {
    if (m_auxMode == kAthenaAccess) {
      // In kAthenaAccess mode we need to use getInputObject(...) to load
      // all the input objects correctly.
      for (auto &[key, mgr] : m_inputObjects) {
        static const std::string dynStorePostfix = "Aux.Dynamic";
        if (key.ends_with(dynStorePostfix)) {
          // Ignore the dynamic store objects. They get loaded through
          // their parents.
        } else {
          // Load the objects and their auxiliary stores through the
          // getInputObject(...) function, which takes care of correctly
          // setting them up. The type is irrelevant here. We don't
          // really care about the exact type of the objects.
          static constexpr bool SILENT = true;
          static constexpr bool METADATA = false;
          getInputObject(key, typeid(int), SILENT, METADATA);
        }
      }
    } else {
      // In a "reasonable" access mode, we do something very simple:
      for (auto &[key, mgr] : m_inputObjects) {
        result += mgr->getEntry(getall);
      }
    }
  }
 
  // Notify the listeners that a new event was loaded:
  const TIncident incident(IncidentType::BeginEvent);
  for (auto &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 330 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;
}

getFile()

Int_t xAOD::TEvent::getFile	(	::Long64_t	file,
		::Int_t	getall = 0 )

Load the first event for a given file from the input TChain.

This function can be used to iterate over the input files specified for the object.

It should be most useful for collecting metadata about a set of input files, if there's no regular event loop done to process them.

Parameters

file	The file number to load
getall	If set to 1, all connected branches are loaded

Returns

The number of read bytes on success, or a negative number on failure

Definition at line 816 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                 {
 
  // Check if the file number is valid:
  if ((file < 0) || (file >= getFiles())) {
    ATH_MSG_ERROR("Function called with invalid file number (" << file << ")");
    return -1;
  }
 
  // If we are not reading a TChain, return at this point. As the one and
  // only file is open already...
  if (!m_inChain) {
    return 0;
  }
 
  // Trigger the "scanning" of the input files, so the TChain would know
  // how many entries are in the various files.
  getEntries();
 
  // Calculate which entry/event we need to load:
  ::Long64_t entry = 0;
  for (::Long64_t i = 0; i < file; ++i) {
    entry += m_inChain->GetTreeOffset()[i];
  }
 
  // Load this entry using the regular event opening function:
  return getEntry(entry, getall);
}

getFiles()

Long64_t xAOD::TEvent::getFiles

(

)

const

Get how many files are available on the currently defined input.

This function can be used to get the number of input files that the object currently knows about.

This is meant to be used to collect the metadata from each of the input files, or to access the metadata using a transient tree. (xAOD::TMetaTree)

Returns

The number of input files when reading from a TChain, 1 when reading from a TFile, and 0 if the object is not connected to any input

Definition at line 796 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                {
 
  if (m_inChain) {
    return m_inChain->GetListOfFiles()->GetEntries();
  } else if (m_inTree || m_inTreeMissing) {
    return 1;
  } else {
    return 0;
  }
}

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.
  static constexpr bool QUIET = true;
  if (const EventFormatElement* efe = m_inputEventFormat.get(key, QUIET)) {
    return efe->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 281 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".
  const TStore* store = TActiveStore::store();
  if (const THolder* holder = (store ? store->holder(keyToUse) : nullptr)) {
    static constexpr bool SILENT = true;
    const void* result = holder->getAsConst(ti, SILENT);
    if (result && !holder->getAs(ti, SILENT)) {
      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 165 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 52 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 65 of file EventTVirtualEvent.cxx.

                                                     {
 
  // Check the active TStore first, its pointer lookup is cheap.
  const TStore* store = TActiveStore::store();
  if (store && store->contains(obj)) {
    return store->getName(obj);
  }
 
  // Then 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;
    }
  }
 
  // 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:
  static constexpr bool QUIET = true;
  if (const EventFormatElement* efe = m_inputEventFormat.get(hash, QUIET)) {
    return efe->branchName();
  }
 
  // If the branch is known on the output:
  if (const EventFormatElement* efe =
          (m_outputEventFormat ? m_outputEventFormat->get(hash, QUIET)
                               : nullptr)) {
    return efe->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::TEvent::getNames ( const std::string & targetClassName, std::vector< std::string > & vkeys, bool metadata ) const

overrideprotectedvirtual

Function determining the list keys associated with a type name.

Implements xAOD::Event.

Definition at line 935 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                 {
  // The results go in here
  std::set<std::string> keys;
 
  // Get list of branches from
  // the input metadata tree or input tree
  std::vector<TObjArray* > fullListOfBranches = {};
  if (metadata) {
    if (m_inMetaTree) {
      // No friend tree expected for metadata tree
      // Only add the list of branches of the metadata tree
      ATH_MSG_DEBUG("Scanning for input metadata objects");
      fullListOfBranches.push_back(m_inMetaTree->GetListOfBranches());
    }
  } else {
    if (m_inTree) {
      ATH_MSG_DEBUG("Scanning for input data objects");
      // Add the list of branches of the main tree
      fullListOfBranches.push_back(m_inTree->GetListOfBranches());
      // If the input tree has friend trees
      // add as well the list of friend tree branches
      if (m_inTree->GetListOfFriends()) {
        // Get the list of friends
        TList* fList = m_inTree->GetListOfFriends();
        // Loop over friend elements
        for (TObject* feObj : *fList) {
          if (feObj) {
            // Get corresponding friend tree
            auto* pElement = dynamic_cast<TFriendElement* >(feObj);
            if (pElement == nullptr) {
              continue;
            }
            TTree* friendTree = pElement->GetTree();
            // Add list of branches of the friend tree
            fullListOfBranches.push_back(friendTree->GetListOfBranches());
          }
        }
      }
    }
  }
 
  // Loop over all list of branches (if any)
  for (const TObjArray* in : fullListOfBranches) {
    // Loop over all branches inside the current list of branches
    for (const TObject* obj : *in) {
 
      if (obj == nullptr) {
        continue;
      }
      const TBranch* element = dynamic_cast<const TBranch* >(obj);
      if (!element) {
        ATH_MSG_ERROR("Failure inspecting input data objects");
        return StatusCode::FAILURE;
      }
      const std::string objClassName = element->GetClassName();
      std::string key = obj->GetName();
      ATH_MSG_VERBOSE("Inspecting \"" << objClassName << "\" / \"" << key
                                      << "\"");
      if (objClassName == targetClassName) {
        ATH_MSG_DEBUG("Matched \"" << targetClassName << "\" to key \"" << key
                                   << "\"");
        keys.insert(std::move(key));
      }
    }
  }
 
  const Object_t &inAux = (metadata ? m_inputMetaObjects : m_inputObjects);
 
  ATH_MSG_DEBUG("Scanning input objects for \"" << targetClassName << "\"");
  for (const auto &[key, vmgr] : inAux) {
    // All (metadata) objects should be held by TObjectManager objects.
    const TObjectManager* mgr =
        dynamic_cast<const TObjectManager* >(vmgr.get());
    if (mgr == nullptr) {
      continue;
    }
    const std::string &objClassName = mgr->holder()->getClass()->GetName();
    ATH_MSG_VERBOSE("Inspecting \"" << objClassName << "\" / \"" << key
                                    << "\"");
    if (objClassName == targetClassName) {
      ATH_MSG_DEBUG("Matched \"" << targetClassName << "\" to key \"" << key
                                 << "\"");
      keys.insert(key);
    }
  }
 
  // Check for output objects.
  if ((metadata == false) && m_outTree) {
    const TObjArray* out = m_outTree->GetListOfBranches();
    ATH_MSG_DEBUG("Scanning for output data objects");
 
    for (const TObject* obj : *out) {
      if (obj == nullptr) {
        continue;
      }
      const TBranch* element = dynamic_cast<const TBranch* >(obj);
      if (element == nullptr) {
        ATH_MSG_ERROR("Failure inspecting output objects");
        return StatusCode::FAILURE;
      }
      const std::string objClassName = element->GetClassName();
      std::string key = obj->GetName();
      ATH_MSG_VERBOSE("Inspecting \"" << objClassName << "\" / \"" << key
                                      << "\"");
      if (objClassName == targetClassName) {
        ATH_MSG_DEBUG("Matched \"" << targetClassName << "\" to key \"" << key
                                   << "\"");
        keys.insert(std::move(key));
      }
    }
  }
 
  const Object_t &outAux = (metadata ? m_outputMetaObjects : m_outputObjects);
 
  // Search though the in-memory output objects.
  ATH_MSG_DEBUG("Scanning output objects for \"" << targetClassName << "\"");
  for (const auto &[key, vmgr] : outAux) {
    // All (metadata) objects should be held by TObjectManager objects.
    TObjectManager* mgr = dynamic_cast<TObjectManager* >(vmgr.get());
    if (mgr == nullptr) {
      continue;
    }
    const std::string &objClassName = mgr->holder()->getClass()->GetName();
    ATH_MSG_VERBOSE("Inspecting \"" << objClassName << "\" / \"" << key
                                    << "\"");
    if (objClassName == targetClassName) {
      ATH_MSG_DEBUG("Matched \"" << targetClassName << "\" to key \"" << key
                                 << "\"");
      keys.insert(key);
    }
  }
 
  vkeys.insert(vkeys.end(), keys.begin(), keys.end());
 
  // Return gracefully.
  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 221 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. (getAs fails for const objects, and wrong types.)
      const TStore* store = TActiveStore::store();
      const THolder* holder = (store ? store->holder(key) : nullptr);
      static constexpr bool SILENT = true;
      return (holder ? holder->getAs(ti, SILENT) : nullptr);
    } 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 141 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::TEvent::hasInput ( ) const

overrideprotectedvirtual

Check if an input file is connected to the object.

Implements xAOD::Event.

Definition at line 928 of file Control/xAODRootAccess/Root/TEvent.cxx.

                            {
 
  return ((m_inTree != nullptr) || (m_inChain != nullptr));
}

hasOutput()

bool xAOD::TEvent::hasOutput ( ) const

overrideprotectedvirtual

Check if an output file is connected to the object.

Implements xAOD::Event.

Definition at line 933 of file Control/xAODRootAccess/Root/TEvent.cxx.

{ return (m_outTree.get() != 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::TEvent::initStats ( )

protected

Function to initialise the statistics for all Tree content.

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

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

Returns

The usual StatusCode tyoes

Definition at line 1866 of file Control/xAODRootAccess/Root/TEvent.cxx.

                             {
 
  // If we're dealing with an empty input file, stop here:
  if (m_inTreeMissing) {
    return StatusCode::SUCCESS;
  }
 
  // A little sanity check:
  if (!m_inTree) {
    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
  EventFormat::const_iterator itr = m_inputEventFormat.begin();
  EventFormat::const_iterator end = m_inputEventFormat.end();
  for (; itr != end; ++itr) {
 
    // Get the name of the branch in question:
    const std::string &branchName = itr->second.branchName();
 
    // If it's an auxiliary container, scan it using TAuxStore:
    if (branchName.find("Aux.") != std::string::npos) {
 
      // But first decide whether it describes a container, or just
      // a single object. Since the file may have been written in
      // kBranchAccess mode, it's not necessarily a good idea to check
      // the type of the auxiliary class. So let's check the interface
      // class instead.
      //
      // Get the name of the interface object/container:
      const std::string intName = branchName.substr(0, branchName.size() - 4);
      if (!m_inputEventFormat.exists(intName)) {
        // When this happens, it may still be that both the interface and
        // the auxiliary container is missing from the file. As we didn't
        // check yet whether the auxiliary container is in place or not.
        // So, before printing a warning, let's check for this.
        // Unfortunately the check is pretty expensive, but this should
        // not be performance critical code after all...
        ::Bool_t auxFound = kFALSE;
        const std::string dynName = Utils::dynBranchPrefix(branchName);
 
        std::vector<TObjArray* > fullListOfBranches = {};
        // Add the list of branches of the main tree
        fullListOfBranches.push_back(m_inTree->GetListOfBranches());
        // If input tree has friend trees
        // add as well the list of friend tree branches
        if (m_inTree->GetListOfFriends()) {
          // Get the list of friends
          TList* fList = m_inTree->GetListOfFriends();
          // Loop over friend elements
          for (TObject* feObj : *fList) {
            if (feObj) {
              // Get corresponding friend tree
              auto* pElement = dynamic_cast<TFriendElement* >(feObj);
              if (not pElement)
                continue;
              TTree* friendTree = pElement->GetTree();
              // Add list of branches of the friend tree
              fullListOfBranches.push_back(friendTree->GetListOfBranches());
            }
          }
        }
 
        for (TObjArray* branches : fullListOfBranches) {
          for (Int_t i = 0; i < branches->GetEntriesFast(); ++i) {
            if (!branches->At(i))
              continue;
 
            const TString name(branches->At(i)->GetName());
            if (name.BeginsWith(branchName) || name.BeginsWith(dynName)) {
              auxFound = kTRUE;
              break;
            }
          }
        }
        if (auxFound) {
          ATH_MSG_WARNING("Couldn't find interface object/container \""
                          << intName << "\" belonging to branch \""
                          << branchName << "\"");
        }
        continue;
      }
 
      // Get the type of the interface:
      const EventFormatElement* el = m_inputEventFormat.get(intName);
      ::TClass* cl = ::TClass::GetClass(el->className().c_str());
      if ((!cl) || (!cl->IsLoaded())) {
        ATH_MSG_WARNING("Couldn't find dictionary for type \""
                        << el->className() << "\"");
        continue;
      }
 
      // Get the dictionary for the DataVector base class:
      static const std::type_info &baseTi = typeid(SG::AuxVectorBase);
      static const std::string baseName = SG::normalizedTypeinfoName(baseTi);
      static ::TClass* const baseCl = ::TClass::GetClass(baseName.c_str());
      if (!baseCl) {
        ATH_MSG_ERROR("Couldn't get dictionary for type \"" << baseName
                                                            << "\"");
        return StatusCode::FAILURE;
      }
 
      // The type of the auxiliary store is finally deduced from the
      // inheritance of the interface container.
      const TAuxStore::EStructMode mode =
          (cl->InheritsFrom(baseCl) ? TAuxStore::EStructMode::kContainerStore
                                    : TAuxStore::EStructMode::kObjectStore);
 
      // Scan the branches using a temporary TAuxStore instance:
      static constexpr bool TOP_STORE = true;
      TAuxStore temp(this->currentContext(), branchName, TOP_STORE, mode);
      static constexpr bool PRINT_WARNINGS = false;
      ATH_CHECK(temp.readFrom(*m_inTree, PRINT_WARNINGS));
 
      // Conveninence variable:
      ReadStats &stats = IOStats::instance().stats();
 
      // Teach the cache about all the branches:
      for (SG::auxid_t id : temp.getAuxIDs()) {
        stats.branch(branchName, id);
      }
 
      // Increment the number of known branches:
      stats.setBranchNum(stats.branchNum() + temp.getAuxIDs().size());
    }
    // If it's an interface container:
    else {
      // Try to access the branch:
      const ::TBranch* container = m_inTree->GetBranch(branchName.c_str());
      // If it exists, let's remember it:
      if (container) {
        IOStats::instance().stats().container(branchName);
      }
    }
  }
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

inputEventFormat()

const EventFormat * Event::inputEventFormat ( ) const

inherited

Get information about the input objects.

Definition at line 240 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 303 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 308 of file EventIProxyDict.cxx.

                                                              {
 
  return &(getName(key));
}

MakeTransientTree()

friend::TTree * xAOD::TEvent::MakeTransientTree ( TEvent & , const char *  )

private

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 324 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 248 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 310 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 213 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 235 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 284 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 219 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 191 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 228 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::TEvent::putAux ( ::TTree & outTree, TVirtualManager & vmgr, bool metadata )

protected

Function 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.)

Parameters

outTree	The TTree to put the auxiliary branches into
mgr	The object manager of the output object
metadata	Flag specifying whether the info written is metadata or not

Returns

The usual StatusCode types

Definition at line 2183 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                         {
 
  // A little sanity check:
  assert(m_outputEventFormat != 0);
 
  // Do the conversion:
  TObjectManager* mgr = dynamic_cast<TObjectManager* >(&vmgr);
  if (!mgr) {
    // It's not an error any more when we don't get a TObjectManager.
    return StatusCode::SUCCESS;
  }
 
  // Check if we need to do anything here:
  if (!mgr->holder()->getClass()->InheritsFrom("SG::IAuxStoreIO")) {
    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!");
    return StatusCode::FAILURE;
  }
 
  // 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->branch()->GetName());
    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());
 
  // If there are no dynamic auxiliary variables in the object, return
  // right away:
  if (auxids.empty()) {
    return StatusCode::SUCCESS;
  }
 
  // Decide what should be the prefix of all the dynamic branches:
  const std::string dynNamePrefix =
      Utils::dynBranchPrefix(mgr->branch()->GetName());
 
  // Select which container to add the variables to:
  Object_t &objects = (metadata ? m_outputMetaObjects : m_outputObjects);
 
  // 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 name for the branch that we will write:
    const std::string brName = dynNamePrefix + p.first;
 
    // Try to find the branch:
    Object_t::iterator bmgr = objects.find(brName);
 
    // 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_ERROR("No I/O type found for variable " << brName);
        return StatusCode::FAILURE;
      }
      const std::string brTypeName = Utils::getTypeName(*brType);
      std::string brProperTypeName = "<unknown>";
 
      // The branch that will hopefully be created:
      ::TBranch* br = 0;
 
      // Check if it's a primitive type or not:
      if (strlen(brType->name()) == 1) {
 
        // Making the "proper" type name is simple in this case:
        brProperTypeName = brTypeName;
 
        // Get the character describing this type for ROOT:
        const char rootType = Utils::rootType(brType->name()[0]);
        if (rootType == '\0') {
          ATH_MSG_ERROR("Type not known for variable \""
                        << brName << "\" of type \"" << brTypeName << "\"");
          return StatusCode::FAILURE;
        }
 
        // Create the full description of the variable for ROOT:
        std::ostringstream leaflist;
        leaflist << brName << "/" << rootType;
 
        // Let's create a holder for this property:
        static constexpr bool IS_OWNER = false;
        auto auxmgr = std::make_unique<TPrimitiveAuxBranchManager>(
            id, nullptr, new THolder(aux->getIOData(id), nullptr, IS_OWNER));
 
        // ... and let's add it to the output TTree:
        static constexpr Int_t BASKET_SIZE = 32000;
        *(auxmgr->branchPtr()) =
            outTree.Branch(brName.c_str(), auxmgr->holder()->get(),
                           leaflist.str().c_str(), BASKET_SIZE);
        if (!auxmgr->branch()) {
          ATH_MSG_ERROR("Failed to create branch \""
                        << brName << "\" out of type \"" << brProperTypeName
                        << "\"");
          // Clean up:
          *(auxmgr->holder()->getPtr()) = 0;
          return StatusCode::FAILURE;
        }
        br = auxmgr->branch();
 
        // Store it in the output list.
        objects[brName] = std::move(auxmgr);
 
      } else {
 
        // Check if we have a dictionary for this type:
        static constexpr Bool_t LOAD_IF_NOT_FOUND = kTRUE;
        static constexpr Bool_t SILENT = kTRUE;
        TClass* cl = TClass::GetClass(*brType, LOAD_IF_NOT_FOUND, SILENT);
        if (cl == nullptr) {
          // 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 == nullptr) {
            ATH_MSG_ERROR("Dictionary not available for variable \""
                          << brName << "\" of type \"" << brTypeName << "\"");
            return StatusCode::FAILURE;
          }
        }
 
        // The proper type name comes from the dictionary in this case:
        brProperTypeName = cl->GetName();
 
        // Let's create a holder for this property:
        static constexpr bool IS_OWNER = false;
        auto auxmgr = std::make_unique<TAuxBranchManager>(
            id, nullptr, new THolder(aux->getIOData(id), cl, IS_OWNER));
 
        // ... and let's add it to the output TTree.
        static constexpr Int_t BASKET_SIZE = 32000;
        static constexpr Int_t SPLIT_LEVEL = 0;
        *(auxmgr->branchPtr()) = outTree.Branch(brName.c_str(), cl->GetName(),
                                                auxmgr->holder()->getPtr(),
                                                BASKET_SIZE, SPLIT_LEVEL);
        if (!auxmgr->branch()) {
          ATH_MSG_ERROR("Failed to create branch \""
                        << brName << "\" out of type \"" << brProperTypeName
                        << "\"");
          // Clean up:
          *(auxmgr->holder()->getPtr()) = 0;
          return StatusCode::FAILURE;
        }
        br = auxmgr->branch();
 
        // Store it in the output list.
        objects[brName] = std::move(auxmgr);
      }
 
      // If this is not the first event, fill up the already filled
      // events with (empty) content:
      if (outTree.GetEntries()) {
        void* ptr = br->GetAddress();
        br->SetAddress(0);
        for (::Long64_t i = 0; i < outTree.GetEntries(); ++i) {
          br->Fill();
        }
        br->SetAddress(ptr);
      }
 
      // If all went fine, let's add this branch to the event format
      // metadata:
      if (!m_outputEventFormat->exists(brName)) {
        m_outputEventFormat->add(EventFormatElement(brName, brProperTypeName,
                                                    mgr->branch()->GetName(),
                                                    getHash(brName)));
      }
 
      // We don't need to do the rest:
      continue;
    }
 
    // Access the object manager:
    bmgr = objects.find(brName);
    if (bmgr == objects.end()) {
      ATH_MSG_FATAL("There is an internal logic error in the code...");
      return StatusCode::FAILURE;
    }
 
    // 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/3]

StatusCode xAOD::TEvent::readFrom ( ::TFile & inFile )

overridevirtual

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

Interface implementation for reading - forward to readFrom below.

Implements xAOD::Event.

Definition at line 117 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                         {
  ATH_CHECK(readFrom(&inFile));
  return StatusCode::SUCCESS;
}

readFrom() [2/3]

StatusCode xAOD::TEvent::readFrom	(	::TFile *	file,
		bool	useTreeCache = true,
		std::string_view	treeName = EVENT_TREE_NAME )

This is the 'native' interface for reading from a TFile, allowing the specification of TTree cache use and the event tree name.

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

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

Parameters

file	Pointer to the file being read
useTreeCache	Flag for turning on/off the usage of TTreeCache
treeName	Name of the input tree

Returns

The usual StatusCode tyoes

Definition at line 132 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                     {
 
  // If no file was specified, return gracefully.
  if (file == nullptr) {
    ATH_MSG_DEBUG("No input file specified for readFrom(...)");
    return StatusCode::SUCCESS;
  }
 
  // 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();
  }
 
  // Reset the internal flags.
  m_inTreeMissing = kFALSE;
  m_entry = -1;
 
  // Make sure we return to the current directory:
  TDirectoryReset dr;
 
  // Set up the file access tracer.
  TFileAccessTracer::instance().add(file->GetName());
 
  // Look for the metadata tree:
  m_inMetaTree = file->Get<TTree>(METADATA_OBJECT_NAME);
  if (m_inMetaTree == nullptr) {
    ATH_MSG_ERROR("Couldn't find metadata tree on input. Object is unusable!");
    return StatusCode::FAILURE;
  }
 
  // Set metadata entry to be read
  // NB: no reading is done calling LoadTree
  if (m_inMetaTree->LoadTree(0) < 0) {
    ATH_MSG_ERROR("Failed to load entry 0 for metadata tree");
    return StatusCode::FAILURE;
  }
 
  // A sanity check.
  if (m_inMetaTree->GetEntries() != 1) {
    ATH_MSG_WARNING("Was expecting a metadata tree with size 1, instead of "
                    << m_inMetaTree->GetEntries() << ".");
    ATH_MSG_WARNING("The input file was most probably produced by hadd...");
  }
 
  // 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));
  ::TClass* cl = ::TClass::GetClass(eventFormatTypeName.c_str());
  if (cl == nullptr) {
    ATH_MSG_WARNING("Couldn't load the xAOD::EventFormat dictionary");
  }
 
  // Helper lambda for collecting the event format metadata from an RNTuple
  // with a given name.
  auto readEventFormatMetadata =
      [&](std::string_view thisTreeName) -> StatusCode {
    // Look for the metadata tree:
    TTree* metaTree = file->Get<TTree>(thisTreeName.data());
    if (metaTree == nullptr) {
      ATH_MSG_ERROR("Couldn't find metadata tree \"" << thisTreeName
                                                     << "\"on input.");
      return StatusCode::FAILURE;
    }
    // Set metadata entry to be read.
    if (metaTree->LoadTree(0) < 0) {
      ATH_MSG_ERROR("Failed to load entry 0 for metadata tree \""
                    << thisTreeName << "\"");
      return StatusCode::FAILURE;
    }
 
    // Check if the EventFormat branch is available:
    const std::string eventFormatBranchName =
        Utils::getFirstBranchMatch(m_inMetaTree, "EventFormat");
    if (!metaTree->GetBranch(eventFormatBranchName.c_str())) {
      // This can happen when the file was produced by an Athena job that
      // didn't have any input events itself. This means that the file
      // doesn't actually have any useful metadata.
      ATH_MSG_INFO("Input file provides no event or metadata");
      return StatusCode::RECOVERABLE;
    }
 
    // Read in the event format object:
    EventFormat* format = 0;
    ::TBranch* br = 0;
    const Int_t status =
        metaTree->SetBranchAddress(eventFormatBranchName.c_str(), &format, &br);
    if (status < 0) {
      ATH_MSG_ERROR("Failed to connect to xAOD::EventFormat object");
      return StatusCode::FAILURE;
    }
 
    // Merge the object into our private member.
    br->GetEntry(0);
    for (const auto &[key, element] : *format) {
      m_inputEventFormat.add(element);
    }
 
    // This is a strange place. The object has to be deleted, as it is the
    // responsibility of the user code to do so. But if I also explicitly
    // tell the branch to forget about the address of the pointer, then
    // all hell breaks loose...
    delete format;
 
    // Return gracefully.
    return StatusCode::SUCCESS;
  };
 
  // Read in the metadata from the "main" metadata ntuple.
  m_inputEventFormat = {};
  const StatusCode sc = readEventFormatMetadata(METADATA_OBJECT_NAME);
  if (sc.isRecoverable()) {
    m_inTree = nullptr;
    m_inTreeMissing = true;
    return StatusCode::SUCCESS;
  }
  ATH_CHECK(sc);
 
  // List all the other Metadata trees in the input file
  // Having several metatrees can happen for augmented files for instance
  // as one metadata tree per stream is produced
  std::set<std::string> lOtherMetaTreeNames = {};
  TList* lKeys = file->GetListOfKeys();
 
  if (lKeys) {
    for (int iKey = 0; iKey < lKeys->GetEntries(); iKey++) {
      // iterate over keys and add
      std::string keyName = lKeys->At(iKey)->GetName();
      // Make sure the key corresponds to a metadata tree 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) &&
          std::regex_match(keyName, m_otherMetaDataTreeNamePattern)) {
        // Make sure key corresponds to a tree
        const char* className = ((::TKey* )lKeys->At(iKey))->GetClassName();
        static constexpr Bool_t LOAD = kFALSE;
        static constexpr Bool_t SILENT = kTRUE;
        ::TClass* cl = ::TClass::GetClass(className, LOAD, SILENT);
        if ((cl != nullptr) && cl->InheritsFrom(::TTree::Class())) {
          // key is corresponding to a metadata tree
          lOtherMetaTreeNames.insert(std::move(keyName));
        }
      }
    }
  }
 
  // Loop over the other metadata trees found (if any).
  for (const std::string &metaTreeName : lOtherMetaTreeNames) {
    ATH_CHECK(readEventFormatMetadata(metaTreeName));
  }
 
  // Look for the event tree in the input file.
  m_inTree = file->Get<TTree>(treeName.data());
  if (m_inTree == nullptr) {
    // This is no longer an error condition. As it can happen for DxAODs
    // that don't have any events in them. But they still have metadata
    // that needs to be collected.
    m_inTreeMissing = kTRUE;
  }
 
  // Turn on the cache if requested.
  if (m_inTree && useTreeCache && (!m_inTree->GetCacheSize())) {
    m_inTree->SetCacheSize(CACHE_SIZE);
    m_inTree->SetCacheLearnEntries(10);
  }
 
  // Init the statistics collection.
  ATH_CHECK(initStats());
  // Update the event counter in the statistics object.
  xAOD::ReadStats &stats = IOStats::instance().stats();
  if (m_inTree) {
    stats.setNEvents(stats.nEvents() + m_inTree->GetEntries());
  }
 
  // 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() [3/3]

StatusCode xAOD::TEvent::readFrom	(	::TTree *	tree,
		bool	useTreeCache = true )

Connect the object to a new input tree/chain.

This version of the function sets up the object to read information from a tree/chain.

Using it with a TTree pointer makes not much sense, but using it with a TChain pointer could be a very valid usage mode.

Parameters

tree	The pointer to a TTree or a TChain
useTreeCache	Flag for switching TTreeCache usage on/off

Returns

The usual StatusCode tyoes

Definition at line 340 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                          {
 
  // Remember the info:
  m_inTree = nullptr;
  m_inTreeMissing = false;
  m_inChain = dynamic_cast<TChain* >(tree);
  m_inMetaTree = nullptr;
 
  if (m_inChain) {
 
    // Set up the caching on the chain level. The individual trees of the
    // input files will get a cache set up automatically after this.
    if (useTreeCache && (!m_inChain->GetCacheSize())) {
      m_inChain->SetCacheSize(CACHE_SIZE);
      m_inChain->SetCacheLearnEntries(10);
    }
 
    // Explicitly open the first file of the chain. To correctly auto-load
    // the dictionaries necessary. This doesn't happen automatically with
    // some ROOT versions...
    const TObjArray* files = m_inChain->GetListOfFiles();
    if (!files) {
      ATH_MSG_ERROR("Couldn't get the list of files from the input TChain");
      return StatusCode::FAILURE;
    }
    if (!files->GetEntries()) {
      ATH_MSG_ERROR("No files are present in the received TChain");
      return StatusCode::FAILURE;
    }
    const ::TChainElement* chEl =
        dynamic_cast<const ::TChainElement* >(files->At(0));
    if (!chEl) {
      ATH_MSG_ERROR("Couldn't cast object to TChainElement");
      return StatusCode::FAILURE;
    }
    {
      std::unique_ptr<TFile> dummyFile{TFile::Open(chEl->GetTitle())};
      if (!dummyFile) {
        ATH_MSG_ERROR("Couldn't open file " << chEl->GetTitle());
        return StatusCode::FAILURE;
      }
    }
 
    // Set up a tracker for the chain.
    if (!m_inChainTracker) {
      m_inChainTracker = std::make_unique<TChainStateTracker>();
    }
    m_inChainTracker->reset();
    tree->SetNotify(m_inChainTracker.get());
 
    // Stop at this point. The first file will be opened when the user
    // asks for the first event. Otherwise we open the first file of the
    // chain multiple times.
    m_inTreeNumber = -1;
    return StatusCode::SUCCESS;
 
  } else {
 
    // If it's a simple TTree, then let's fully initialise the object
    // using its file:
    m_inTreeNumber = -1;
    if (m_inChainTracker) {
      m_inChainTracker.reset();
    }
    ::TFile* file = tree->GetCurrentFile();
    return readFrom(file, useTreeCache, tree->GetName());
  }
}

record() [1/4]

template<typename T>

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

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

record() [2/4]

StatusCode xAOD::TEvent::record ( std::unique_ptr< TAuxStore > store, const std::string & key )

protected

Internal function for adding an auxiliary store object to the output.

This function is used internally when copying an object with its auxiliary store from the input file, and branch access mode is activated for the event object.

The assumption is that the store object already knows what prefix it should be using. The key parameter only specifies under what ID the object should be handled in the output object list.

Parameters

store	The store object to connect to the output
key	The "key" with which to record the object

Returns

The usual StatusCode tyoes

Definition at line 2022 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                {
 
  // Check if we have an output tree:
  if (!m_outTree) {
    ATH_MSG_ERROR(
        "No output tree defined. Did you forget to call writeTo(...)?");
    return StatusCode::FAILURE;
  }
 
  // Check if we have a filtering rule for this key:
  const std::set<std::string>* filter = 0;
  auto filter_itr = m_auxItemList.find(key);
  if (filter_itr != m_auxItemList.end()) {
    filter = &(filter_itr->second);
  }
 
  // Check if we need to add it to the event record:
  Object_t::iterator vitr = m_outputObjects.find(key);
  if (vitr == m_outputObjects.end()) {
 
    // Configure the object for variable filtering:
    if (filter) {
      store->selectAux(*filter);
    }
    // Tell the object where to write its contents:
    ATH_CHECK(store->writeTo(*m_outTree));
    // Record it to the output list:
    static constexpr bool OWNS_STORE = true;
    m_outputObjects[key] =
        std::make_unique<TAuxManager>(store.release(), OWNS_STORE);
 
    // We're done:
    return StatusCode::SUCCESS;
  }
 
  // Check if the output has the right store:
  if (vitr->second->object() == store.get()) {
    // We're done already:
    return StatusCode::SUCCESS;
  }
 
  // If not, update the output manager. This can happen when we copy
  // objects from the input to the output files, and we process
  // multiple input files.
 
  // Check if the output manager is of the right type:
  TAuxManager* mgr = dynamic_cast<TAuxManager* >(vitr->second.get());
  if (mgr == nullptr) {
    ATH_MSG_ERROR("Output object with key \""
                  << key << "\" already exists, and is not of type TAuxStore");
    return StatusCode::FAILURE;
  }
 
  // Configure the object for variable filtering:
  if (filter) {
    store->selectAux(*filter);
  }
 
  // Connect the auxiliary store to the output tree:
  ATH_CHECK(store->writeTo(*m_outTree));
 
  // Update the manager:
  mgr->setObject(store.release());
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

record() [3/4]

template<typename T>

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

Add an output object to the event.

record() [4/4]

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

overrideprotectedvirtual

Record an object into a connected output file.

This is the function doing the heavy lifting when recording a new object into the output tree/file.

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

The usual StatusCode tyoes

Implements xAOD::Event.

Definition at line 1696 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                        {
 
  // Check if we have an output tree when writing an event:
  if (!m_outTree && !metadata) {
    ATH_MSG_ERROR(
        "No output tree defined. Did you forget to call writeTo(...)?");
    return StatusCode::FAILURE;
  }
  assert(m_outputEventFormat != 0);
 
  // If this is metadata, just take ownership of it. The object will only
  // be recorded into the output file when calling finishWritingTo(...).
  if (metadata) {
    // Check whether we already have such an object:
    if ((!overwrite) &&
        (m_outputMetaObjects.find(key) != m_outputMetaObjects.end())) {
      ATH_MSG_ERROR("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;
    }
    // Let's create a holder for the object:
    const bool renewOnRead = (m_auxMode == kAthenaAccess);
    m_outputMetaObjects[key] = std::make_unique<TObjectManager>(
        nullptr, std::make_unique<THolder>(obj, cl, isOwner), renewOnRead);
    // 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_ERROR("Object \"" << typeName << "\"/\"" << key
                              << "\" already accessed from the input, can't be "
                                 "overwritten in memory");
    return StatusCode::FAILURE;
  }
 
  // Choose a split level.
  const Int_t splitLevel = (key.ends_with("Aux.") ? 1 : 0);
 
  // 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 == nullptr) {
      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)));
    }
 
    // Let's create a holder for the object.
    const bool renewOnRead = (m_auxMode == kAthenaAccess);
    auto mgr = std::make_unique<TObjectManager>(
        nullptr, std::make_unique<THolder>(obj, cl, isOwner), renewOnRead);
    TObjectManager* mgrPtr = mgr.get();
    m_outputObjects[key] = std::move(mgr);
 
    // ... and let's add it to the output TTree.
    static constexpr Int_t basketSize = 32000;
    *(mgrPtr->branchPtr()) =
        m_outTree->Branch(key.c_str(), cl->GetName(),
                          mgrPtr->holder()->getPtr(), basketSize, splitLevel);
    if (!mgrPtr->branch()) {
      ATH_MSG_ERROR("Failed to create branch \"" << key << "\" out of type \""
                                                 << cl->GetName() << "\"");
      // Clean up:
      mgrPtr->holder()->setOwner(kFALSE);
      return StatusCode::FAILURE;
    }
 
    // Set up the saving of all the dynamic auxiliary properties
    // of the object if it has any:
    static constexpr bool METADATA = false;
    ATH_CHECK(putAux(*m_outTree, *mgrPtr, METADATA));
 
    // 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:
  TObjectManager* omgr = dynamic_cast<TObjectManager* >(vitr->second.get());
  if (!omgr) {
    ATH_MSG_ERROR("Manager object of the wrong type encountered");
    return StatusCode::FAILURE;
  }
 
  // 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_ERROR("For output key \""
                    << key << "\" the previous type was \""
                    << omgr->holder()->getClass()->GetName()
                    << "\", but the newly requested type is \"" << typeName
                    << "\"");
      return StatusCode::FAILURE;
    }
  }
 
  // Replace the managed object.
  omgr->setObject(obj);
 
  // Replace the auxiliary objects.
  static constexpr bool METADATA = false;
  ATH_CHECK(putAux(*m_outTree, *omgr, METADATA));
 
  // Return gracefully.
  return StatusCode::SUCCESS;
}

recordAux() [1/3]

SG::IAuxStore * xAOD::TEvent::recordAux	(	const std::string &	key,
		SG::IAuxStoreHolder::AuxStoreType	type = SG::IAuxStoreHolder::AST_ContainerStore )

Add an auxiliary store object to the output.

This function can be used to create/retrieve a ROOT-specific auxiliary object container that can be used to write information in the output file.

Any auxiliary information written this way will however only be readable in ROOT, using the kBranchAccess option.

Parameters

key	The name/prefix of the auxiliary store object/branches
type	The type of the auxiliary store (object/container)

Returns

An auxiliary store object that will write to the output

Definition at line 597 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                                     {
 
  // A sanity check:
  if (!m_outTree) {
    ATH_MSG_ERROR("No output tree given to the object");
    return nullptr;
  }
 
  // Check for an object with this name in the output list:
  Object_t::iterator itr = m_outputObjects.find(key);
  if (itr == m_outputObjects.end()) {
    // Create one if if it doesn't exist yet...
    // Translate the store type:
    TAuxStore::EStructMode mode = TAuxStore::EStructMode::kUndefinedStore;
    switch (type) {
      case SG::IAuxStoreHolder::AST_ObjectStore:
        mode = TAuxStore::EStructMode::kObjectStore;
        break;
      case SG::IAuxStoreHolder::AST_ContainerStore:
        mode = TAuxStore::EStructMode::kContainerStore;
        break;
      default:
        ATH_MSG_ERROR("Unknown store type (" << type << ") requested");
        return nullptr;
    }
    // Create and record the object:
    static constexpr bool TOP_STORE = true;
    if (record(std::make_unique<TAuxStore>(this->currentContext(),
                                           key, TOP_STORE, mode), key)
            .isFailure()) {
      ATH_MSG_ERROR("Couldn't connect TAuxStore object to the output");
      return nullptr;
    }
    // Update the iterator:
    itr = m_outputObjects.find(key);
  }
 
  // A security check:
  if (itr == m_outputObjects.end()) {
    ATH_MSG_ERROR("Internal logic error detected");
    return nullptr;
  }
 
  // Check that it is of the right type:
  TAuxManager* mgr = dynamic_cast<TAuxManager* >(itr->second.get());
  if (!mgr) {
    ATH_MSG_ERROR("Internal logic error detected");
    return nullptr;
  }
 
  // Extract the pointer out of it:
  TAuxStore* store = mgr->getStore();
 
  // Give it to the user:
  return store;
}

recordAux() [2/3]

StatusCode xAOD::TEvent::recordAux ( TAuxStore * store, const std::string & key )

protected

Function setting up an existing auxiliary store for writing.

Definition at line 2403 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                                   {
 
  // Check if we have an output tree:
  if (hasOutput() == false) {
    ATH_MSG_ERROR("No output tree set up.");
    return StatusCode::FAILURE;
  }
 
  // Check if we have a filtering rule for this key:
  const std::set<std::string>* filter = 0;
  auto filter_itr = m_auxItemList.find(key);
  if (filter_itr != m_auxItemList.end()) {
    filter = &(filter_itr->second);
  }
 
  // Check if we need to add it to the event record:
  Object_t::iterator vitr = m_outputObjects.find(key);
  if (vitr == m_outputObjects.end()) {
 
    // Configure the object for variable filtering:
    if (filter) {
      store->selectAux(*filter);
    }
    // Tell the object where to write its contents:
    ATH_CHECK(store->writeTo(*m_outTree));
    // Record it to the output list.
    static constexpr bool OWNS_STORE = false;
    m_outputObjects[key] = std::make_unique<TAuxManager>(store, OWNS_STORE);
 
    // We're done:
    return StatusCode::SUCCESS;
  }
 
  // Check if the output has the right store:
  if (vitr->second->object() == store) {
    // We're done already:
    return StatusCode::SUCCESS;
  }
 
  // If not, update the output manager. This can happen when we copy
  // objects from the input to the output files, and we process
  // multiple input files.
 
  // Check if the output manager is of the right type:
  TAuxManager* mgr = dynamic_cast<TAuxManager* >(vitr->second.get());
  if (mgr == nullptr) {
    ATH_MSG_ERROR("Output object with key \""
                  << key << "\" already exists, and is not of type TAuxStore");
    return StatusCode::FAILURE;
  }
 
  // Configure the object for variable filtering:
  if (filter) {
    store->selectAux(*filter);
  }
 
  // Connect the auxiliary store to the output tree:
  ATH_CHECK(store->writeTo(*m_outTree));
 
  // Update the manager:
  mgr->setObject(store);
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

recordAux() [3/3]

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

overrideprotectedvirtual

Record an auxiliary store into a connected output file.

Implements xAOD::Event.

Definition at line 1827 of file Control/xAODRootAccess/Root/TEvent.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;
  }
 
  // Check if it's a TAuxStore object.
  TAuxManager* auxmgr = dynamic_cast<TAuxManager* >(&mgr);
  if (auxmgr != nullptr) {
    // This type has to be an event object.
    if (metadata) {
      ATH_MSG_ERROR(
          "TAuxStore auxiliary objects can only be recorded for event data");
      return StatusCode::FAILURE;
    }
    // Record the auxiliary object with the dedicated record function.
    ATH_CHECK(recordAux(auxmgr->getStore(), key));
    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 318 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 313 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 138 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.

setActive()

void Event::setActive ( ) const

inherited

Set this event object as the currently active one.

Definition at line 65 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);
  Atlas::setProxyDictInEventContext(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 83 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::TEvent::setAuxStore ( const std::string & key, Details::IObjectManager & mgr, bool metadata )

overrideprotectedvirtual

Function connecting a DV object to its auxiliary store.

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

This function takes care of this.

Parameters

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 1503 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                                          {
 
  // Pre-compute some values.
  const bool isAuxStore = Details::isAuxStore(*(mgr.holder()->getClass()));
 
  // Check if we need to do anything.
  if ((Details::hasAuxStore(*(mgr.holder()->getClass())) == false) &&
      (isAuxStore == 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 (isAuxStore) {
    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 == false) {
    // Make sure the auxiliary object is up to date:
    const ::Int_t readBytes = auxMgr->getEntry();
    if (readBytes < 0) {
      ATH_MSG_ERROR(
          "Couldn't load current entry for auxiliary object with key \""
          << auxKey << "\"");
      return StatusCode::FAILURE;
    }
 
    // Check if there is a separate auxiliary object for the dynamic
    // variables:
    const std::string dynAuxKey = auxKey + "Dynamic";
    auto dynAuxMgr = objects.find(dynAuxKey);
 
    if ((dynAuxMgr != objects.end()) &&
        (readBytes || (m_auxMode == kAthenaAccess) || (auxMgr == &mgr))) {
      // Do different things based on the access mode:
      if (m_auxMode != kAthenaAccess) {
        // In "normal" access modes just tell the dynamic store object
        // to switch to a new event.
        dynAuxMgr->second->getEntry();
      } else {
        // In "Athena mode" this object has already been deleted when
        // the main auxiliary store object was switched to the new
        // event. So let's re-create it:
        xAOD::TObjectManager &auxMgrRef =
            dynamic_cast<xAOD::TObjectManager &>(*auxMgr);
        ATH_CHECK(
            setUpDynamicStore(auxMgrRef, (metadata ? m_inMetaTree : m_inTree)));
        // Now tell the newly created dynamic store object which event
        // it should be looking at:
        auto dynAuxMgr = objects.find(dynAuxKey);
        if (dynAuxMgr == objects.end()) {
          ATH_MSG_ERROR("Internal logic error detected");
          return StatusCode::FAILURE;
        }
        dynAuxMgr->second->getEntry();
      }
    }
  }
 
  // Stop here if we've set up an auxiliary store.
  if (isAuxStore) {
    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 auxiliary store object:
  const SG::IConstAuxStore* store = 0;
#ifndef XAOD_STANDALONE
  SG::IAuxStore* store_nc = 0;
#endif
  if (m_auxMode == kBranchAccess) {
    // Get the concrete auxiliary manager:
    TAuxManager* amgr = dynamic_cast<TAuxManager* >(auxMgr);
    if (!amgr) {
      ATH_MSG_FATAL("Auxiliary manager for \""
                    << auxKey << "\" is not of the right type");
      return StatusCode::FAILURE;
    }
    store = amgr->getConstStore();
    // If the store still doesn't know its type, help it now:
    if (amgr->getStore()->structMode() ==
        TAuxStore::EStructMode::kUndefinedStore) {
      const TAuxStore::EStructMode mode =
          (vec ? TAuxStore::EStructMode::kContainerStore
               : TAuxStore::EStructMode::kObjectStore);
      amgr->getStore()->setStructMode(mode);
    }
#ifndef XAOD_STANDALONE
    store_nc = amgr->getStore();
#endif
  } else if (m_auxMode == kClassAccess || m_auxMode == kAthenaAccess) {
    // Get the concrete auxiliary manager:
    TObjectManager* omgr = dynamic_cast<TObjectManager* >(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));
    SG::IConstAuxStore* store1 = reinterpret_cast<SG::IConstAuxStore* >(p);
    store = store1;
#ifndef XAOD_STANDALONE
    store_nc = dynamic_cast<SG::IAuxStore*>(store1);
#endif
  }
  if (!store) {
    ATH_MSG_FATAL("Logic error detected in the code");
    return StatusCode::FAILURE;
  }
 
#ifndef XAOD_STANDALONE
  // Call toTransient on the aux store.
  if (store_nc)[[likely]] {
    store_nc->toTransient( this->currentContext() );
  } else {
    ATH_MSG_FATAL("Logic error detected in the code");
    return StatusCode::FAILURE;
  }
#endif
 
  // Connect the two:
  if (vec) {
    vec->setStore(store);
  } else if (aux) {
    aux->setStore(store);
  } else {
    ATH_MSG_FATAL("Logic error detected 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;
}

setOtherMetaDataTreeNamePattern()

void xAOD::TEvent::setOtherMetaDataTreeNamePattern

(

const std::string &

pattern

)

Change the pattern used for collecting information from other MetaData trees NB: Additional MetaData trees are only expected for augmented files This function also allows user to redefine MetaData tree pattern to skip trees that would not be proper MetaData ones i.e.

trees not containing an EventFormat* branch

Definition at line 108 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                                     {
  // Only change if pattern provided is not empty
  if (pattern.size()) {
    // User provided a regular expression for other MetaData trees
    m_otherMetaDataTreeNamePattern = std::regex(pattern);
  }
}

setUpDynamicStore()

StatusCode xAOD::TEvent::setUpDynamicStore ( TObjectManager & mgr, ::TTree * tree )

protected

Function adding dynamic variable reading capabilities to an auxiliary store object.

This function is used by connectBranch(...) and connectMetaBranch(...) 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
tree	The tree to read dynamic variables from

Returns

The usual StatusCode types

Definition at line 2099 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                                     {
 
  // Check if we can call setName(...) on the object:
  ::TMethodCall setNameCall;
  // Don't use this code in Athena access mode. And just accept that access
  // monitoring is disabled in this case...
  if (m_auxMode != kAthenaAccess) {
    setNameCall.InitWithPrototype(mgr.holder()->getClass(), "setName",
                                  "const char*");
    if (setNameCall.IsValid()) {
      // Yes, there is such a function. Let's call it with the branch
      // name:
      const ::TString params =
          ::TString::Format("\"%s\"", mgr.branch()->GetName());
      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 \""
                      << mgr.branch()->GetName() << "\"  (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 a TAuxStore instance that will read the dynamic variables
  // of this container. Notice that the TAuxManager doesn't own the
  // TAuxStore object. It will be owned by the SG::IAuxStoreHolder
  // object.
  static constexpr bool TOP_STORE = false;
  const EventContext& ctx = this->currentContext();
  auto store = std::make_unique<TAuxStore>(
      ctx, mgr.branch()->GetName(), TOP_STORE,
      (storeHolder->getStoreType() == SG::IAuxStoreHolder::AST_ObjectStore
           ? TAuxStore::EStructMode::kObjectStore
           : TAuxStore::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 TTree.
  ATH_CHECK(store->readFrom(*tree));
  // 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(...).
  store->getEntry(0);
 
  // Set up a manager for it.
  static constexpr bool SHARED_OWNER = false;
  m_inputObjects[std::string(mgr.branch()->GetName()) + "Dynamic"] =
      std::make_unique<TAuxManager>(store.get(), 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 298 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() [1/2]

StatusCode xAOD::TEvent::writeTo	(	::TFile *	file,
		int	autoFlush = 200,
		std::string_view	treeName = EVENT_TREE_NAME )

Connect the object to an output file.

This function should be called on a file opened be the user, before any event processing would occur.

It sets up the output event tree.

Parameters

file	The file that the event data should be written to
autoFlush	The auto-flush setting to use on the output TTree
treeName	Name of the output event tree

Returns

The usual StatusCode tyoes

Definition at line 433 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                                    {
 
  // Just a simple security check.
  if (!file) {
    ATH_MSG_ERROR("Null pointer received!");
    return StatusCode::FAILURE;
  }
 
  // Check that the object is in the "right state":
  if (m_outTree) {
    ATH_MSG_ERROR("Object already writing to a file. Close that file first!");
    return StatusCode::FAILURE;
  }
 
  // Make sure we return to the current directory:
  TDirectoryReset dr;
 
  // Create the output TTree:
  file->cd();
  m_outTree = std::make_unique<TTree>(treeName.data(), "xAOD event tree");
  m_outTree->SetDirectory(file);
  m_outTree->SetAutoSave(1000000);
  m_outTree->SetAutoFlush(autoFlush);
 
  // Access the EventFormat object associated with this file:
  m_outputEventFormat =
      &(TEventFormatRegistry::instance().getEventFormat(file));
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

writeTo() [2/2]

StatusCode xAOD::TEvent::writeTo ( TFile & file )

overridevirtual

Connect the object to an output file.

This interface function should be called on a file opened be the user, before any event processing would occur.

It sets up the output event tree.

Parameters

file	The file that the event data should be written to

Returns

The usual StatusCode tyoes

Implements xAOD::Event.

Definition at line 416 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                      {
 
  // Forward call
  ATH_CHECK(writeTo(&file));
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

Friends And Related Symbol Documentation

::xAODTEventBranch

friend class ::xAODTEventBranch

friend

Definition at line 63 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

::xAODTMetaBranch

friend class ::xAODTMetaBranch

friend

Definition at line 64 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

CP::xAODWriterAlg

friend class CP::xAODWriterAlg

friend

Definition at line 67 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

xAOD::TFileMerger

friend class xAOD::TFileMerger

friend

Definition at line 65 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

xAOD::TTreeMgr

friend class xAOD::TTreeMgr

friend

Definition at line 66 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

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 394 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 80 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 79 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 362 of file Event.h.

m_auxMode

EAuxMode xAOD::TEvent::m_auxMode

protected

The auxiliary access mode.

Definition at line 206 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

m_branchesMutex

upgrade_mutex_t xAOD::Event::m_branchesMutex

mutableprotectedinherited

Mutex for multithread synchronization.

Definition at line 390 of file Event.h.

m_ctx

EventContext xAOD::Event::m_ctx

protectedinherited

The event context associated with this event.

Definition at line 410 of file Event.h.

m_entry

::Long64_t xAOD::TEvent::m_entry = -1

protected

The entry to look at from the input tree.

Definition at line 222 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_inChain

::TChain* xAOD::TEvent::m_inChain = nullptr

protected

The (optional) chain provided as input.

Definition at line 214 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

m_inChainTracker

std::unique_ptr<TChainStateTracker> xAOD::TEvent::m_inChainTracker

protected

Optional object for tracking the state changes of an input TChain.

Definition at line 216 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

m_inMetaTree

::TTree* xAOD::TEvent::m_inMetaTree = nullptr

protected

Pointer to the metadata tree in the input file.

Definition at line 220 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

m_inputEventFormat

EventFormat xAOD::Event::m_inputEventFormat

protectedinherited

Format of the current input file.

Definition at line 357 of file Event.h.

m_inputMetaObjects

Object_t xAOD::Event::m_inputMetaObjects

protectedinherited

Collection of all the managed input meta-objects.

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

m_inputObjects

Object_t xAOD::Event::m_inputObjects

protectedinherited

Collection of all the managed input objects.

Definition at line 344 of file Event.h.

m_inTree

::TTree* xAOD::TEvent::m_inTree = nullptr

protected

The main tree that we are reading from.

Definition at line 209 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

m_inTreeMissing

bool xAOD::TEvent::m_inTreeMissing = false

protected

Internal status flag showing that an input file is open, but it doesn't contain an event tree.

Definition at line 212 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

m_inTreeNumber

::Int_t xAOD::TEvent::m_inTreeNumber = -1

protected

The number of the currently open tree in the input chain.

Definition at line 218 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

m_listeners

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

protectedinherited

Listeners who should be notified when certain incidents happen.

Definition at line 365 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_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 368 of file Event.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_otherMetaDataTreeNamePattern

std::regex xAOD::TEvent::m_otherMetaDataTreeNamePattern

protected

Initial value:

                                      =
std::regex("^MetaData(?!Hdr)_.*$")

Definition at line 230 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

m_outputEventFormat

EventFormat* xAOD::Event::m_outputEventFormat = nullptr

protectedinherited

Format of the current output file.

Definition at line 359 of file Event.h.

m_outputMetaObjects

Object_t xAOD::Event::m_outputMetaObjects

protectedinherited

Collection of all the managed output meta-objects.

Definition at line 354 of file Event.h.

m_outputObjects

Object_t xAOD::Event::m_outputObjects

protectedinherited

Collection of all the managed output object.

Definition at line 349 of file Event.h.

m_outTree

std::unique_ptr<::TTree> xAOD::TEvent::m_outTree

protected

The tree that we are writing to.

Definition at line 225 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.

m_printEventProxyWarnings

bool xAOD::Event::m_printEventProxyWarnings = false

protectedinherited

Option to silence common warnings that seem to be harmless.

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

---

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

• Control/xAODRootAccess/xAODRootAccess/TEvent.h
• Control/xAODRootAccess/Root/TEvent.cxx