ATLAS Offline Software
Loading...
Searching...
No Matches
xAOD::RDataSourceEvent Class Referencefinal

Extension to xAOD::TEvent, used by xAOD::RDataSource. More...

#include <RDataSourceEvent.h>

Inheritance diagram for xAOD::RDataSourceEvent:
Collaboration diagram for xAOD::RDataSourceEvent:

Classes

class  key_hash
 Custom hash functor for use with Key_t. More...

Public Types

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

Public Member Functions

std::vector< std::pair< std::string, std::string > > columnAndTypeNames ()
 Get the available columm and type names from the input.
void * columnReader (std::string_view columnName, const std::type_info &typeInfo)
 Get a "column reader", a pointer to a pointer to the object.
void updateObjectsForEntry (Long64_t entry)
 Update all objects in memory for a new event.
 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.
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.
StatusCode record (void *obj, const std::string &typeName, const std::string &key, bool overwrite, bool metadata, bool isOwner)
 Record an object into a connected output file.
Persistent data accessor/modifier functions
::Long64_t getEntries () const override
 Get how many entries are available from the current input file(s).
::Int_t getEntry (::Long64_t entry, ::Int_t getall=0) override
 Function loading a given entry of the input 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 recordAux (TAuxStore *store, const std::string &key)
 Function setting up an existing auxiliary store for writing.
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.
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
StatusCode recordAux (TVirtualManager &mgr, const std::string &key, bool metadata) override
 Record an auxiliary store into a connected output file.
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 recordImpl (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.
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 Types

typedef std::pair< std::string, const std::type_info * > Key_t
 Type of the key used in the internal map of object pointers.

Private Member Functions

friend::TTree * MakeTransientTree (TEvent &, const char *)
void initMessaging () const
 Initialize our message level and MessageSvc.

Private Attributes

std::unordered_map< Key_t, const void *, key_hash > m_objects
 Objects served to RDataFrame.
std::string m_nm
 Message source name.
boost::thread_specific_ptr< MsgStream > m_msg_tls
 MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * > m_imsg { nullptr }
 MessageSvc pointer.
std::atomic< MSG::Level > m_lvl { MSG::NIL }
 Current logging level.

Setup functions

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

Functions implementing the @c xAOD::TVirtualEvent interface

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

Variable(s) used in the @c IProxyDict implementation

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.

Detailed Description

Extension to xAOD::TEvent, used by xAOD::RDataSource.

In order to get access to the internals of xAOD::TEvent, and provide pointers for ROOT::RDataFrame in a convenient way, this class provides a layer between the two codebases.

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 31 of file RDataSourceEvent.h.

Member Typedef Documentation

◆ Key_t

typedef std::pair< std::string, const std::type_info* > xAOD::RDataSourceEvent::Key_t
private

Type of the key used in the internal map of object pointers.

Definition at line 47 of file RDataSourceEvent.h.

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

◆ sgkey_t

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

◆ upgrading_lock_t

using xAOD::Event::upgrading_lock_t
protectedinherited
Initial value:

Lock type for multithread synchronization.

Definition at line 391 of file Event.h.

Member Enumeration Documentation

◆ EAuxMode

enum xAOD::TEvent::EAuxMode
inherited

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.

71 {
72 kBranchAccess = 0,
73 kClassAccess = 1,
74 kAthenaAccess = 2
75 };
@ kAthenaAccess
Access containers/objects like Athena does.
@ kClassAccess
Access auxiliary data using the aux containers.
@ kBranchAccess
Access auxiliary data branch-by-branch.

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
listenerPointer to the object that should be notified
Returns
The usual StatusCode types

Definition at line 106 of file EventCore.cxx.

106 {
107
108 // Check that we received a valid pointer:
109 if (listener == nullptr) {
110 ATH_MSG_ERROR("Received a null pointer for the listener");
111 return StatusCode::FAILURE;
112 }
113
114 // Check whether we already have this listener.
115 auto itr = std::find(m_listeners.begin(), m_listeners.end(), listener);
116 if (itr != m_listeners.end()) {
117 ATH_MSG_WARNING("Listener " << static_cast<void*>(listener)
118 << " is already registered");
119 return StatusCode::SUCCESS;
120 }
121
122 // Add the listener.
123 m_listeners.push_back(listener);
124
125 // Return gracefully:
126 return StatusCode::SUCCESS;
127}
#define ATH_MSG_ERROR(x,...)
#define ATH_MSG_WARNING(x,...)
std::vector< TVirtualIncidentListener * > m_listeners
Listeners who should be notified when certain incidents happen.
Definition Event.h:369

◆ 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
onfileThe name of the container as it was saved into the input file
newNameThe alias with which the object/container should be accessible
Returns
The usual StatusCode types

Save the new name association:

Definition at line 171 of file EventCore.cxx.

172 {
173
174 // Check if this name is known on the input or output already. As that's
175 // not good.
176 if (m_inputEventFormat.exists(newName)) {
177 ATH_MSG_ERROR("Can't use \"" << newName << "\" as the target name in the \""
178 << onfile << "\" -> \"" << newName
179 << "\" remapping");
180 return StatusCode::FAILURE;
181 }
182
183 // Check if this name was remapped to something already.
184 auto itr = m_nameRemapping.find(newName);
185 if (itr != m_nameRemapping.end()) {
186 ATH_MSG_WARNING("Overriding existing name remapping \""
187 << itr->second << "\" -> \"" << itr->first << "\" with: \""
188 << onfile << "\" -> \"" << newName << "\"");
189 }
190
192 m_nameRemapping[newName] = onfile;
193
194 // Return gracefully:
195 return StatusCode::SUCCESS;
196}
EventFormat m_inputEventFormat
Format of the current input file.
Definition Event.h:361
std::unordered_map< std::string, std::string > m_nameRemapping
Container name re-mapping rules.
Definition Event.h:372

◆ 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
clidThe CLID of the type. Not taken into account.
proxyThe proxy to take posession of. Not used for anything useful.

Definition at line 257 of file EventIProxyDict.cxx.

257 {
258
260
261 // Warn the user that the function got called:
262 static std::atomic_flag warningPrinted ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT;
263 if (!warningPrinted.test_and_set() && m_printEventProxyWarnings) {
265 "Function should only be called through an invalid ElementLink");
266 }
267
268 // Hold on to the proxy
269 BranchInfo bi;
270 bi.m_proxy.reset(proxy);
271 lock.upgrade();
272#ifdef XAOD_STANDALONE
273 std::string uniqueKey = std::format("NonExistentKey_{}", m_branches.size());
274 SG::sgkey_t sgkey = stringToKey(uniqueKey, clid);
275#else
276 SG::sgkey_t sgkey = proxy->sgkey();
277#endif
278 m_branches.emplace (sgkey, std::move(bi));
279
280 // Return gracefully:
281 return StatusCode::SUCCESS;
282}
virtual void lock()=0
Interface to allow an object to lock itself when made const in SG.
SG::sgkey_t stringToKey(const std::string &str, CLID clid) override
Find the string corresponding to a given key.
upgrade_mutex_t m_branchesMutex
Mutex for multithread synchronization.
Definition Event.h:394
bool m_printEventProxyWarnings
Option to silence common warnings that seem to be harmless.
Definition Event.h:375
SG::SGKeyMap< BranchInfo > m_branches ATLAS_THREAD_SAFE
Map from hashed sgkey to BranchInfo.
Definition Event.h:398
AthContainers_detail::upgrading_lock< upgrade_mutex_t > upgrading_lock_t
Lock type for multithread synchronization.
Definition Event.h:391
SG::DataProxy * proxy(const void *const pTransient) const override
get proxy for a given data object address in memory
uint32_t sgkey_t
Type used for hashed StoreGate key+CLID pairs.
Definition sgkey_t.h:32
sgkey(tool)
Definition common.py:1027
Helper struct used by the IProxyDict code.
Definition Event.h:381
std::unique_ptr< SG::DataProxy > m_proxy
Data proxy describing this branch/object.
Definition Event.h:383

◆ auxMode()

TEvent::EAuxMode xAOD::TEvent::auxMode ( ) const
inherited

Get what auxiliary access mode the object was constructed with.

Returns
The auxiliary data access mode currently in use

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

107{ return m_auxMode; }
EAuxMode m_auxMode
The auxiliary access mode.

◆ 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 152 of file EventCore.cxx.

152 {
153
154 m_listeners.clear();
155}

◆ 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 202 of file EventCore.cxx.

202 {
203
204 m_nameRemapping.clear();
205}

◆ columnAndTypeNames()

std::vector< std::pair< std::string, std::string > > xAOD::RDataSourceEvent::columnAndTypeNames ( )

Get the available columm and type names from the input.

Definition at line 25 of file RDataSourceEvent.cxx.

25 {
26
27 // This makes sure that the input is connected to.
28 if( ( ! m_inTree ) && ( getEntry( 0 ) < 0 ) ) {
29 ::Error( "xAOD::RDataSourceEvent::columnAndTypeNames",
30 XAOD_MESSAGE( "No input file opened yet" ) );
31 throw std::runtime_error( "No input file opened yet" );
32 }
33
34 // A sanity check.
35 if( ! inputEventFormat() ) {
36 ::Error( "xAOD::RDataSourceEvent::columnAndTypeNames",
37 XAOD_MESSAGE( "No xAOD::EventFormat object available" ) );
38 throw std::runtime_error( "No xAOD::EventFormat object available" );
39 }
40
41 // The result object.
42 std::vector< std::pair< std::string, std::string > > result;
43
44 // Loop over the known objects.
47 for( ; ef_itr != ef_end; ++ef_itr ) {
48
49 // A convenient reference.
50 const xAOD::EventFormatElement& efe = ef_itr->second;
51
52 // Skip auxiliary containers.
53 if( efe.branchName().rfind( "Aux." ) ==
54 ( efe.branchName().size() - 4 ) ) {
55 continue;
56 }
57 // Skip dynamic branches.
58 if( efe.parentName() != "" ) {
59 continue;
60 }
61 // Skip unavailable branches.
62 if( ! m_inTree->GetBranch( efe.branchName().c_str() ) ) {
63 continue;
64 }
65 // Skip unknown types.
66 ::TClass* cl = ::TClass::GetClass( efe.className().c_str() );
67 if( ! cl ) {
68 continue;
69 }
70 // Skip auxiliary containers that are mislabeled.
71 if( cl->InheritsFrom( "SG::IConstAuxStore" ) ) {
72 continue;
73 }
74
75 // Make sure that we have a functional dictionary for the type.
76 const std::type_info* ti = cl->GetTypeInfo();
77 if( ! ti ) {
78 ::Warning( "xAOD::RDataSourceEvent::columnAndTypeNames",
79 "No std::type_info available for type %s (key=%s)",
80 cl->GetName(), efe.branchName().c_str() );
81 continue;
82 }
83
84 // And do one final check that we can really read this type.
85 static constexpr bool METADATA = false;
86 if( ! contains( efe.branchName(), *ti, METADATA ) ) {
87 continue;
88 }
89
90 // Remember this objects.
91 result.emplace_back( efe.branchName(), efe.className() );
92 }
93
94 // Return the collected results.
95 return result;
96 }
#define XAOD_MESSAGE(MESSAGE)
Simple macro for printing error/verbose messages.
const std::string & branchName() const
Get the branch/key name.
const std::string & parentName() const
Get the name of the parent auxiliary object.
const std::string & className() const
Get the class name of this branch/key.
KeyedData_t::const_iterator const_iterator
Iterator for looping over the elements of the object.
const_iterator end() const
STL-like function for getting the end of the container.
const_iterator begin() const
STL-like function for getting the beginning of the container.
const EventFormat * inputEventFormat() const
Get information about the input objects.
bool contains(const std::string &key)
Function checking if an object is available from the store.
::Int_t getEntry(::Long64_t entry, ::Int_t getall=0) override
Function loading a given entry of the input TTree.
::TTree * m_inTree
The main tree that we are reading from.
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]

◆ columnReader()

void * xAOD::RDataSourceEvent::columnReader ( std::string_view columnName,
const std::type_info & typeInfo )

Get a "column reader", a pointer to a pointer to the object.

Definition at line 98 of file RDataSourceEvent.cxx.

99 {
100
101 // Make sure that this is the active event in the current thread.
102 setActive();
103
104 // Create/access the pointer for this object.
105 return &( m_objects[ std::make_pair( std::string( columnName ),
106 &typeInfo ) ] );
107 }
void setActive() const
Set this event object as the currently active one.
Definition EventCore.cxx:63
std::unordered_map< Key_t, const void *, key_hash > m_objects
Objects served to RDataFrame.

◆ connectAux()

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

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
prefixThe prefix (main branch name) of the auxiliary data
standaloneType of the auxiliary store that should be created
Returns
The usual StatusCode types

Implements xAOD::Event.

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

1366 {
1367
1368 // A simple test...
1369 if (hasInput() == false) {
1370 ATH_MSG_ERROR("No input tree is available");
1371 return StatusCode::FAILURE;
1372 }
1373
1374 // Check if we know anything about this auxiliary object:
1375 if ((!m_inTree->GetBranch(prefix.c_str())) &&
1377 // If not, then let's just return right away. Not having
1378 // an auxiliary object with this name is not an error per se.
1379 return StatusCode::SUCCESS;
1380 }
1381
1382 // Check if the branch is already connected.
1383 if (m_inputObjects.contains(prefix)) {
1384 return StatusCode::SUCCESS;
1385 }
1386
1387 // Do different things based on the "auxiliary mode" we are in.
1388 if ((m_auxMode == kClassAccess) || (m_auxMode == kAthenaAccess)) {
1389
1390 // In "class" and "athena" access modes just connect the concrete auxiliary
1391 // object to the input.
1392 static constexpr bool SILENT = false;
1393 ATH_CHECK(connectObject(prefix, SILENT));
1394
1395 // Return gracefully.
1396 return StatusCode::SUCCESS;
1397
1398 } else if (m_auxMode == kBranchAccess) {
1399
1400 // In "branch access mode" let's create a TAuxStore object, and let
1401 // that take care of the auxiliary store access.
1402 static constexpr bool TOP_STORE = true;
1403 auto store = std::make_unique<TAuxStore>(
1404 this->currentContext(),
1405 prefix, TOP_STORE,
1408
1409 // Connect it to the input tree.
1410 ATH_CHECK(store->readFrom(*m_inTree));
1411
1412 // We're using this object to read from the input, it needs to be
1413 // locked:
1414 store->lock();
1415
1416 // Finally, set up an appropriate manager for it.
1417 static constexpr bool IS_OWNER = true;
1419 std::make_unique<TAuxManager>(store.release(), IS_OWNER);
1420
1421 // Return gracefully:
1422 return StatusCode::SUCCESS;
1423 }
1424
1425 // There was some problem:
1426 ATH_MSG_ERROR("Unknown auxiliary access mode set (" << m_auxMode << ")");
1427 return StatusCode::FAILURE;
1428}
#define ATH_CHECK
Evaluate an expression and check for errors.
Object_t m_inputObjects
Collection of all the managed input objects.
Definition Event.h:348
const EventContext & currentContext() const
Return the event context corresponding to this event.
StatusCode connectObject(const std::string &key, bool silent) override
Function setting up access to a particular object.
bool hasInput() const override
Check if an input file is connected to the object.
@ kObjectStore
The object describes a single object.
@ kContainerStore
The object describes an entire container.
@ SILENT
don't print anything and return success
TestStore store
Definition TestStore.cxx:23

◆ connectMetaAux()

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

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
prefixThe prefix (main branch name) of the auxiliary data
standaloneType of the auxiliary store that should be created
Returns
The usual StatusCode types

Implements xAOD::Event.

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

1439 {
1440
1441 // Check if the branch is already connected:
1442 if (m_inputMetaObjects.contains(prefix)) {
1443 return StatusCode::SUCCESS;
1444 }
1445
1446 // A sanity check:
1447 if (!m_inMetaTree) {
1448 ATH_MSG_FATAL("Internal logic error detected");
1449 return StatusCode::FAILURE;
1450 }
1451
1452 // Do different things based on the "auxiliary mode" we are in:
1454
1455 // In "class" and "athena" access modes just connect the concrete auxiliary
1456 // object to the input.
1457 static constexpr bool SILENT = false;
1458 ATH_CHECK(connectMetaObject(prefix, SILENT));
1459
1460 // Return gracefully:
1461 return StatusCode::SUCCESS;
1462
1463 } else if (m_auxMode == kBranchAccess) {
1464
1465 // In "branch access mode" let's create a TAuxStore object, and let
1466 // that take care of the auxiliary store access.
1467 static constexpr bool TOP_STORE = true;
1468 auto store = std::make_unique<TAuxStore>(
1469 this->currentContext(),
1470 prefix, TOP_STORE,
1473
1474 // Connect it to the input tree.
1475 ATH_CHECK(store->readFrom(*m_inMetaTree));
1476
1477 // We're using this object to read from the input, it needs to be
1478 // locked:
1479 store->lock();
1480
1481 // Finally, set up an appropriate manager for it.
1482 static constexpr bool IS_OWNER = true;
1484 std::make_unique<TAuxManager>(store.release(), IS_OWNER);
1485
1486 // Return gracefully.
1487 return StatusCode::SUCCESS;
1488 }
1489
1490 // There was some problem:
1491 ATH_MSG_ERROR("Unknown auxiliary access mode set (" << m_auxMode << ")");
1492 return StatusCode::FAILURE;
1493}
#define ATH_MSG_FATAL(x,...)
Object_t m_inputMetaObjects
Collection of all the managed input meta-objects.
Definition Event.h:356
::TTree * m_inMetaTree
Pointer to the metadata tree in the input file.
StatusCode connectMetaObject(const std::string &key, bool silent) override
Function setting up access to a particular metadata object.

◆ connectMetaObject()

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

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
keyThe key (branch name) of the metadata object to retrieve
silentSet 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 1265 of file Control/xAODRootAccess/Root/TEvent.cxx.

1265 {
1266
1267 // A little sanity check:
1268 if (!m_inMetaTree) {
1269 ATH_MSG_ERROR("Function called on un-initialised object");
1270 return StatusCode::FAILURE;
1271 }
1272
1273 // Check if the branch is already connected:
1274 if (m_inputMetaObjects.contains(key)) {
1275 return StatusCode::SUCCESS;
1276 }
1277
1278 // Check if the branch exists in our metadata tree:
1279 ::TBranch* br = m_inMetaTree->GetBranch(key.c_str());
1280 if (br == nullptr) {
1281 if (silent == false) {
1282 ATH_MSG_WARNING("Metadata branch \"" << key
1283 << "\" not available on input");
1284 }
1285 return StatusCode::RECOVERABLE;
1286 }
1287
1288 // Check that we have an entry in the branch:
1289 if (br->GetEntries() == 0) {
1290 if (silent == false) {
1291 ATH_MSG_WARNING("Metadata branch \"" << key
1292 << "\" doesn't hold any data");
1293 }
1294 return StatusCode::RECOVERABLE;
1295 }
1296
1297 // Make sure that it's not in "MakeClass mode":
1298 br->SetMakeClass(0);
1299
1300 // Extract the type of the branch:
1301 ::TClass* cl = 0;
1302 ::EDataType dt = kOther_t;
1303 if (br->GetExpectedType(cl, dt) || (!cl)) {
1304 ATH_MSG_ERROR("Couldn't get the type for metadata branch \"" << key
1305 << "\"");
1306 return StatusCode::FAILURE;
1307 }
1308
1309 // Create the object, and all of the managers around it:
1310 void* ptr = cl->New();
1311 const bool renewOnRead = (m_auxMode == kAthenaAccess);
1312 auto mgr = std::make_unique<TObjectManager>(
1313 nullptr, std::make_unique<THolder>(ptr, cl), renewOnRead);
1314
1315 // Now try to connect to the branch:
1316 const ::Int_t status = m_inMetaTree->SetBranchAddress(
1317 key.c_str(), mgr->holder()->getPtr(), mgr->branchPtr(), cl, dt, kTRUE);
1318 if (status < 0) {
1319 ATH_MSG_ERROR("Couldn't connect variable of type \""
1320 << cl->GetName() << "\" to input branch \"" << key
1321 << "\". Return code: " << status);
1322 // Clean up:
1323 *(mgr->holder()->getPtr()) = 0;
1324 m_inputMetaObjects.erase(key);
1325 return StatusCode::FAILURE;
1326 }
1327
1328 // Store the manager.
1329 TObjectManager *mgrPtr = mgr.get();
1330 m_inputMetaObjects[key] = std::move(mgr);
1331
1332 // Read in the object:
1333 if (mgrPtr->getEntry() < 0) {
1334 ATH_MSG_ERROR("Couldn't read in metadata object with key \"" << key
1335 << "\"");
1336 return StatusCode::FAILURE;
1337 }
1338
1339 // If it's an auxiliary store object, set it up correctly:
1340 if (Details::isAuxStore(*(mgrPtr->holder()->getClass()))) {
1342 }
1343
1344 // If there may be an auxiliary object connected to this one,
1345 // connect that as well.
1346 if (Details::hasAuxStore(*(mgrPtr->holder()->getClass()))) {
1348 key + "Aux.", Details::isStandalone(*(mgrPtr->holder()->getClass()))));
1349 static constexpr bool METADATA = true;
1350 ATH_CHECK(setAuxStore(key, *mgrPtr, METADATA));
1351 }
1352
1353 // We succeeded:
1354 return StatusCode::SUCCESS;
1355}
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 setUpDynamicStore(TObjectManager &mgr, ::TTree *tree)
Function adding dynamic variable reading capabilities to an auxiliary store object.
constexpr auto getPtr(typename std::remove_reference< T >::type &arg) noexcept
void * ptr(T *p)
Definition SGImplSvc.cxx:76
status
Definition merge.py:16
bool hasAuxStore(const TClass &cl)
Helper function deciding if a given type "has an auxiliary store".
Definition IOUtils.cxx:40
bool isAuxStore(const TClass &cl)
Helper function deciding if a given type "is an auxiliary store".
Definition IOUtils.cxx:53
bool isStandalone(const TClass &cl)
Helper function deciding if a given type "is a standalone object".
Definition IOUtils.cxx:65

◆ connectObject()

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

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
keyThe name of the branch to connect to
silentSet 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 1093 of file Control/xAODRootAccess/Root/TEvent.cxx.

1093 {
1094
1095 // A little sanity check:
1096 if (hasInput() == false) {
1097 ATH_MSG_ERROR("Function called on un-initialised object");
1098 return StatusCode::FAILURE;
1099 }
1100
1101 // Increment the access counter on this container:
1103
1104 // Check if the branch is already connected:
1105 if (m_inputObjects.contains(key)) {
1106 return StatusCode::SUCCESS;
1107 }
1108 // Check if it was already found to be missing.
1109 if (m_inputMissingObjects.contains(key)) {
1110 if (silent == false) {
1111 ATH_MSG_WARNING("Branch \"" << key << "\" not available on input");
1112 }
1113 return StatusCode::RECOVERABLE;
1114 }
1115
1116 // Check if we have metadata about this branch:
1117 const xAOD::EventFormatElement* ef = nullptr;
1118 if (m_inputEventFormat.exists(key) == false) {
1119 if (silent == false) {
1120 ATH_MSG_WARNING("No metadata available for branch: " << key);
1121 }
1122 } else {
1123 ef = m_inputEventFormat.get(key);
1124 }
1125
1126 // Check if the branch exists in our input tree:
1127 ::TBranch* br = m_inTree->GetBranch(key.c_str());
1128 if (br == nullptr) {
1129 if (!silent) {
1130 ATH_MSG_WARNING("Branch \"" << key << "\" not available on input");
1131 }
1132 m_inputMissingObjects.insert(key);
1133 return StatusCode::RECOVERABLE;
1134 }
1135
1136 // Make sure that it's not in "MakeClass mode":
1137 br->SetMakeClass(0);
1138
1139 // Decide about the type that we need to use for the reading of this
1140 // branch:
1141 std::string className = br->GetClassName();
1142 if (className == "") {
1143 if (ef) {
1144 // This is a fairly weird situation, but let's fall back to taking
1145 // the class name from the metadata object in this case.
1146 className = ef->className();
1147 } else {
1149 "Couldn't find an appropriate type with a dictionary for branch \""
1150 << key << "\"");
1151 return StatusCode::FAILURE;
1152 }
1153 }
1154 ::TClass* realClass = ::TClass::GetClass(className.c_str());
1155 if (((!realClass) || (!realClass->IsLoaded())) && ef) {
1156 // We may need to do an actual schema evolution here, in which
1157 // case let's fall back on the class name coming from the metadata
1158 // object.
1159 className = ef->className();
1160 realClass = ::TClass::GetClass(className.c_str());
1161 }
1162 if ((!realClass) || (!realClass->IsLoaded())) {
1163 // Now we're in trouble...
1165 "Couldn't find an appropriate type with a dictionary for branch \""
1166 << key << "\"");
1167 return StatusCode::FAILURE;
1168 }
1169
1170 // Make sure that the current object is the "active event":
1171#ifndef XAOD_STANDALONE
1172 SG::WithEventContext saveContext;
1173#endif
1174 setActive();
1175
1176 // The data type is always "other" for us:
1177 static const ::EDataType dataType = kOther_t;
1178
1179 // Check if the output already has this object. If it does, let's
1180 // assume that we have been copying the object to the output. Which
1181 // means that we need to resume filling the same memory address that
1182 // the output holder points to.
1183 void* ptr = nullptr;
1184 Object_t::const_iterator out_itr = m_outputObjects.find(key);
1185 if (out_itr != m_outputObjects.end()) {
1186 // It needs to be an object manager...
1187 TObjectManager* mgr = dynamic_cast<TObjectManager* >(out_itr->second.get());
1188 if (mgr == nullptr) {
1189 ATH_MSG_ERROR("Couldn't access output manager for: " << key);
1190 return StatusCode::FAILURE;
1191 }
1192 // Get the pointer out of it:
1193 ptr = mgr->holder()->get();
1194 }
1195
1196 // If there is no output object, then let's create one ourselves.
1197 // This is the only way in which we can have the memory management of
1198 // THolder do the right thing with this object.
1199 if (ptr == nullptr) {
1200 ptr = realClass->New();
1201 }
1202
1203 // Create the new manager object that will hold this EDM object:
1204 const bool renewOnRead = (m_auxMode == kAthenaAccess);
1205 auto mgr = std::make_unique<TObjectManager>(
1206 nullptr, std::make_unique<THolder>(ptr, realClass), renewOnRead);
1207
1208 // One final check. If it's not an auxiliary store, then it must have
1209 // a split level of 0. Otherwise read rules may not work on it. Causing
1210 // *very* serious silent corruption in the data read, if we don't use
1211 // the "Athena read mode".
1212 if ((m_auxMode != kAthenaAccess) && (br->GetSplitLevel() != 0) &&
1213 (Details::isAuxStore(*(mgr->holder()->getClass())) == false)) {
1214 ATH_MSG_ERROR("Split level for branch \""
1215 << key << "\" is " << br->GetSplitLevel()
1216 << ". This can only be read in kAthenaAccess mode.");
1217 // Clean up:
1218 *(mgr->holder()->getPtr()) = nullptr;
1219 m_inputObjects.erase(key);
1220 return StatusCode::FAILURE;
1221 }
1222
1223 // Now try to connect to the branch:
1224 const ::Int_t status =
1225 m_inTree->SetBranchAddress(key.c_str(), mgr->holder()->getPtr(),
1226 mgr->branchPtr(), realClass, dataType, kTRUE);
1227 if (status < 0) {
1228 ATH_MSG_ERROR("Couldn't connect variable of type \""
1229 << className << "\" to input branch \"" << key
1230 << "\". Return code: " << status);
1231 // Clean up:
1232 *(mgr->holder()->getPtr()) = 0;
1233 m_inputObjects.erase(key);
1234 return StatusCode::FAILURE;
1235 }
1236
1237 // At this point we have successfully connected the branch.
1238 TObjectManager* mgrPtr = mgr.get();
1239 m_inputObjects[key] = std::move(mgr);
1240
1241 // If it's an auxiliary store object, set it up correctly:
1242 if (Details::isAuxStore(*(mgrPtr->holder()->getClass()))) {
1244 }
1245
1246 // If there may be an auxiliary object connected to this one,
1247 // connect that as well:
1248 if (Details::hasAuxStore(*(mgrPtr->holder()->getClass()))) {
1250 key + "Aux.", Details::isStandalone(*(mgrPtr->holder()->getClass()))));
1251 }
1252
1253 // Return gracefully.
1254 return StatusCode::SUCCESS;
1255}
std::set< std::string > m_inputMissingObjects
Objects that have been asked for, but were found to be missing in the current input.
Definition Event.h:351
Object_t m_outputObjects
Collection of all the managed output object.
Definition Event.h:353
ReadStats & stats()
Access the object belonging to the current thread.
Definition IOStats.cxx:17
static IOStats & instance()
Singleton object accessor.
Definition IOStats.cxx:11
void readContainer(const std::string &name)
Function incrementing the read counter on a specific container.
StatusCode connectAux(const std::string &prefix, bool standalone) override
Function setting up access to a set of auxiliary branches.

◆ 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
patternRegular expression for the key(s)/name(s) of the object(s)/container(s) to copy

Definition at line 95 of file EventIO.cxx.

95 {
96
97 // Tell the user what's happening.
98 ATH_MSG_DEBUG("Copying objects matching pattern \"" << pattern
99 << "\" to the output");
100
101 // Collect a list of keys to copy.
102 std::set<std::string> keys;
103
104 // The regular expression to use.
105 std::regex re{pattern};
106
107 // Loop over the known input containers.
108 for (const auto& [key, efe] : m_inputEventFormat) {
109
110 // Tell the user what's happening.
111 ATH_MSG_VERBOSE("Considering input object with key \"" << key << "\"");
112
113 // Check if the class in question matches the requested pattern.
114 if (std::regex_match(key, re) == false) {
115 continue;
116 }
117 // Skip all branches ending in "Aux.":
118 if (key.ends_with("Aux.")) {
119 continue;
120 }
121 // Also skip dynamic branches:
122 if (efe.parentName() != "") {
123 continue;
124 }
125 // Ignore objects that don't exist on the input.
126 static const bool SILENT = true;
127 if (connectObject(key, SILENT).isSuccess() == false) {
128 continue;
129 }
130 // Add the key to the list.
131 ATH_MSG_VERBOSE("Matched key \"" << key << "\"");
132 keys.insert(key);
133 }
134
135 // Check if the pattern matches any of the name remapping rules.
136 for (const auto& [newname, onfile] : m_nameRemapping) {
137
138 // Tell the user what's happening.
139 ATH_MSG_VERBOSE("Considering remapped key \"" << newname << "\"");
140
141 // Check if the remapped name matches the pattern.
142 if (std::regex_match(newname, re) == false) {
143 continue;
144 }
145 // Ignore objects that don't exist on the input.
146 static const bool SILENT = true;
147 if (connectObject(onfile, SILENT).isSuccess() == false) {
148 continue;
149 }
150 // Add the remapped name to the list.
151 ATH_MSG_VERBOSE("Matched remapped key \"" << newname << "\"");
152 keys.insert(newname);
153 }
154
155 // Now loop over all of the found keys.
156 for (const std::string& key : keys) {
157
158 // Check if a name re-mapping should be applied or not.
159 std::string keyToUse = key;
160 auto remap_itr = m_nameRemapping.find(key);
161 if ((remap_itr != m_nameRemapping.end()) &&
162 (!m_inputEventFormat.exists(key)) &&
163 m_inputEventFormat.exists(remap_itr->second)) {
164 keyToUse = remap_itr->second;
165 }
166
167 // Make sure that the input object got connected to.
168 static const bool SILENT = false;
169 ATH_CHECK(connectObject(keyToUse, SILENT));
170
171 // Make sure that the input object is properly updated.
172 Object_t::const_iterator vobjMgr = m_inputObjects.find(keyToUse);
173 if (vobjMgr == m_inputObjects.end()) {
174 ATH_MSG_FATAL("Internal logic error detected");
175 return StatusCode::FAILURE;
176 }
177 Details::IObjectManager* objMgr =
178 dynamic_cast<Details::IObjectManager*>(vobjMgr->second.get());
179 if (objMgr == nullptr) {
180 ATH_MSG_FATAL("Internal logic error detected");
181 return StatusCode::FAILURE;
182 }
183 static const bool METADATA = false;
184 if (getInputObject(keyToUse, *(objMgr->holder()->getClass()->GetTypeInfo()),
185 SILENT, METADATA) == nullptr) {
186 ATH_MSG_FATAL("Internal logic error detected");
187 return StatusCode::FAILURE;
188 }
189
190 // Put the interface object into the output.
191 static const bool OVERWRITE = true;
192 static const bool IS_OWNER = true;
193 ATH_CHECK(recordImpl(objMgr->object(), objMgr->holder()->getClass()->GetName(),
194 key, OVERWRITE, METADATA, IS_OWNER));
195
196 // If there is also an auxiliary store for this object/container, copy that
197 // as well.
198 const std::string auxKey = keyToUse + "Aux.";
199 if (m_inputObjects.contains(auxKey)) {
200 ATH_CHECK(
201 recordAux(*(m_inputObjects.at(auxKey)), key + "Aux.", METADATA));
202 }
203 }
204
205 // Return gracefully:
206 return StatusCode::SUCCESS;
207}
const std::regex re(r_e)
#define ATH_MSG_DEBUG(x,...)
#define ATH_MSG_VERBOSE(x,...)
virtual StatusCode recordAux(TVirtualManager &mgr, const std::string &key, bool metadata)=0
Record an auxiliary store into a connected output file.
virtual StatusCode recordImpl(void *obj, const std::string &typeName, const std::string &key, bool overwrite, bool metadata, bool isOwner)=0
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.
virtual StatusCode connectObject(const std::string &key, bool silent)=0
Function setting up access to a particular object.
StatusCode keys(std::vector< std::string > &vkeys, bool metadata) const
Provide a list of all data object keys associated with a specific type.
@ OVERWRITE
create the directory as is, removing existing directories if needed

◆ 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.

43 {
44
45 // Make use of the messaging function(s) from the xAODEvent namespace.
46 using xAODEvent::msg;
47
48 if (inFile.FindKey(EVENT_RNTUPLE_NAME) != nullptr) {
49 // Create and set up an REvent object
50 auto event = std::make_unique<Experimental::REvent>();
51 if (event->readFrom(inFile).isFailure()) {
52 ANA_MSG_ERROR("Could not read RNTuple from: " << inFile.GetName());
53 return {};
54 }
55 return event;
56 } else if (inFile.FindKey(EVENT_TREE_NAME) != nullptr) {
57 // Create and set up a TEvent object
58 // Check if file is AOD, in which case kAthenaAccess must be used
59 auto eauxMode = TEvent::kClassAccess;
60 std::string sauxMode = "kClassAccess";
61 auto metaData = dynamic_cast<TTree*>(inFile.Get("MetaData"));
62 if (metaData) {
63 auto rc = metaData->LoadTree(0);
64 if (rc < 0)[[unlikely]]{
65 ANA_MSG_ERROR("Error from LoadTree: "<< rc);
66 return {};
67 }
68 if (metaData->GetBranch("StreamAOD")) {
69 eauxMode = TEvent::kAthenaAccess;
70 sauxMode = "kAthenaAccess";
71 }
72 }
73 ANA_MSG_INFO("Using aux mode " << sauxMode << " for file " << inFile.GetName());
74 auto event = std::make_unique<TEvent>(eauxMode);
75 if (event->readFrom(inFile).isFailure()) {
76 ANA_MSG_ERROR("Could not read TTree from: " << inFile.GetName());
77 return {};
78 }
79 return event;
80 } else {
81 ANA_MSG_ERROR("Could not recognize file: " << inFile.GetName());
82 return {};
83 }
84}
#define ANA_MSG_ERROR(xmsg,...)
Macro printing error messages.
#define ANA_MSG_INFO(xmsg,...)
Macro printing info messages.
static Double_t rc
static const char *const EVENT_TREE_NAME
Default name of the event TTree.
Definition Event.h:79
static const char *const EVENT_RNTUPLE_NAME
Name of the event RNTuple.
Definition Event.h:80
str inFile
Definition makeTOC.py:5
#define unlikely(x)

◆ currentContext()

const EventContext & Event::currentContext ( ) const
protectedinherited

Return the event context corresponding to this event.

(Returns a dummy in standalone builds.)

Definition at line 313 of file EventCore.cxx.

313 {
314#ifdef XAOD_STANDALONE
315 return Gaudi::Hive::currentContext();
316#else
317 return m_ctx;
318#endif
319}
EventContext m_ctx
The event context associated with this event.
Definition Event.h:414

◆ 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 259 of file EventCore.cxx.

259 {
260
261 // The internal stream object.
262 std::ostringstream ost;
263 ost << "<<<<<<<<<<<<<<<<<<<< xAOD::TEvent Dump >>>>>>>>>>>>>>>>>>>>\n";
264
265 // Loop over the input EventFormat object.
266 for (const auto& [key, element] : m_inputEventFormat) {
267
268 // Get the type.
269 ::TClass* cl = ::TClass::GetClass(element.className().c_str());
270 const std::type_info* ti = (cl ? cl->GetTypeInfo() : nullptr);
271 if ((cl == nullptr) || (cl->IsLoaded() == false) || (ti == nullptr)) {
272 ATH_MSG_WARNING("Unknown type (" << element.className()
273 << ") found in the event format");
274 continue;
275 }
276
277 // Skip containers that are not available anyway.
278 static const bool METADATA = false;
279 if (!contains(element.branchName(), *ti, METADATA)) {
280 continue;
281 }
282
283 // Do the printout.
284 ost << " Hash: 0x" << std::setw(8) << std::setfill('0') << std::hex
285 << element.hash() << " Key: \"" << element.branchName() << "\"\n";
286
287 ost << " type: " << element.className() << "\n";
288 const bool isNonConst =
289 transientContains(element.branchName(), *ti, METADATA);
290 ost << " isConst: " << (isNonConst ? "No" : "Yes") << "\n";
291 static const bool SILENT = false;
292 ost << " Data: "
293 << (isNonConst
294 ? getOutputObject(element.branchName(), *ti, METADATA)
295 : getInputObject(element.branchName(), *ti, SILENT, METADATA))
296 << "\n";
297 }
298
299 // Finish with the construction:
300 ost << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
301 return ost.str();
302}
bool transientContains(const std::string &key) const
Function checking if an object is already in memory.
void * getOutputObject(SG::sgkey_t key, const std::type_info &ti) override
Function for retrieving an output object in a non-template way.

◆ fill()

Int_t xAOD::TEvent::fill ( )
overridevirtualinherited

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

851 {
852
853 // A little sanity check:
854 if (!m_outTree) {
855 ATH_MSG_ERROR("Object not connected to an output file!");
856 return 0;
857 }
858
859 // Make sure that all objects have been read in. The 99 as the value
860 // has a special meaning for TAuxStore. With this value it doesn't
861 // delete its transient (decoration) variables. Otherwise it does.
862 // (As it's supposed to, when moving to a new event.)
863 Int_t readBytes = 0;
864 if (m_inChain != nullptr) {
865 readBytes = getEntry(m_inChain->GetReadEntry(), 99);
866 } else if (m_inTree != nullptr) {
867 readBytes = getEntry(m_entry, 99);
868 }
869 if (readBytes < 0) {
870 ATH_MSG_ERROR("getEntry failed!");
871 return readBytes;
872 }
873
874 // Prepare the objects for writing. Note that we need to iterate over a
875 // copy of the m_outputObjects container. Since the putAux(...) function
876 // called inside the loop may itself add elements to the m_outputObject
877 // container.
878 std::string unsetObjects;
879 std::vector<std::pair<std::string, TVirtualManager* >> outputObjectsCopy;
880 outputObjectsCopy.reserve(m_outputObjects.size());
881 for (const auto &[key, mgr] : m_outputObjects) {
882 outputObjectsCopy.emplace_back(key, mgr.get());
883 }
884 for (auto &[key, mgr] : outputObjectsCopy) {
885 // Check that a new object was provided in the event:
886 if (!mgr->create()) {
887 // We are now going to fail. But let's collect the names of
888 // all the unset objects:
889 if (unsetObjects.size()) {
890 unsetObjects += ", ";
891 }
892 unsetObjects.append("\"" + key + "\"");
893 continue;
894 }
895 // Make sure that any dynamic auxiliary variables that
896 // were added to the object after it was put into the event,
897 // get added to the output:
898 static constexpr bool METADATA = false;
899 if (putAux(*m_outTree, *mgr, METADATA).isFailure()) {
900 ATH_MSG_ERROR("Failed to put dynamic auxiliary variables "
901 "in the output for object \""
902 << key << "\"");
903 return 0;
904 }
905 }
906
907 // Check if there were any unset objects:
908 if (unsetObjects.size()) {
909 ATH_MSG_ERROR("The following objects were not set in the current event: "
910 << unsetObjects);
911 return 0;
912 }
913
914 // Write the entry, and check the return value:
915 const ::Int_t ret = m_outTree->Fill();
916 if (ret <= 0) {
917 ATH_MSG_ERROR("Output tree filling failed with return value: " << ret);
918 }
919
920 // Reset the object managers.
921 for (auto &[key, mgr] : m_outputObjects) {
922 mgr->reset();
923 }
924
925 // Return the value:
926 return ret;
927}
::Long64_t m_entry
The entry to look at from the input tree.
::TChain * m_inChain
The (optional) chain provided as input.
StatusCode putAux(::TTree &outTree, TVirtualManager &mgr, bool metadata)
Function saving the dynamically created auxiliary properties.
std::unique_ptr<::TTree > m_outTree
The tree that we are writing to.

◆ finishWritingTo() [1/2]

StatusCode xAOD::TEvent::finishWritingTo ( ::TFile * file)
inherited

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
fileThe file that the event data is written to
Returns
The usual StatusCode tyoes

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

483 {
484
485 // A small sanity check:
486 if (!m_outTree) {
487 ATH_MSG_ERROR("The object doesn't seem to be connected to an output file!");
488 return StatusCode::FAILURE;
489 }
490
491 // Make sure we return to the current directory:
492 TDirectoryReset dr;
493
494 // Notify the listeners that they should write out their metadata, if they
495 // have any.
496 const TIncident incident(IncidentType::MetaDataStop);
497 for (auto &listener : m_listeners) {
498 listener->handle(incident);
499 }
500
501 // Write out the event tree, and delete it:
502 m_outTree->AutoSave("FlushBaskets");
503 m_outTree->SetDirectory(0);
504 m_outTree.reset();
505
506 // Now go to the output file:
507 file->cd();
508
509 // Check if there's already a metadata tree in the output:
510 if (file->Get(METADATA_OBJECT_NAME)) {
511 // Let's assume that the metadata is complete in the file already.
512 return StatusCode::SUCCESS;
513 }
514
515 // Create the metadata tree.
516 auto metatree =
517 std::make_unique<TTree>(METADATA_OBJECT_NAME, "xAOD metadata tree");
518 metatree->SetAutoSave(10000);
519 metatree->SetAutoFlush(-30000000);
520 metatree->SetDirectory(file);
521
522 // Create the xAOD::EventFormat branch in it.
523 try {
524 metatree->Branch(
525 "EventFormat",
528 } catch (const CxxUtils::ClassName::ExcBadClassName &e) {
529 ::Error("xAOD::TEvent::finishWritingTo",
530 XAOD_MESSAGE("Class name parsing fails for %s ! "), e.what());
531 return StatusCode::FAILURE;
532 }
533
534 // Create a copy of the m_outputMetaObjects variable. This is necessary
535 // because the putAux(...) function will modify this variable while we
536 // loop over it.
537 std::vector<std::pair<std::string, TObjectManager* >> outputMetaObjects;
538 outputMetaObjects.reserve(m_outputMetaObjects.size());
539 for (const auto &[key, mgr] : m_outputMetaObjects) {
540 TObjectManager* objMgr = dynamic_cast<TObjectManager* >(mgr.get());
541 if (objMgr == nullptr) {
542 ATH_MSG_FATAL("Internal logic error detected");
543 return StatusCode::FAILURE;
544 }
545 outputMetaObjects.emplace_back(key, objMgr);
546 }
547
548 // Now loop over all the metadata objects that need to be put into the
549 // output file:
550 for (auto &[key, mgr] : outputMetaObjects) {
551
552 // Select a split level depending on whether this is an interface or an
553 // auxiliary object:
554 const ::Int_t splitLevel = (key.ends_with("Aux.") ? 1 : 0);
555 // Create the new branch:
556 *(mgr->branchPtr()) =
557 metatree->Branch(key.c_str(), mgr->holder()->getClass()->GetName(),
558 mgr->holder()->getPtr(), 32000, splitLevel);
559 if (!mgr->branch()) {
560 ATH_MSG_ERROR("Failed to create metadata branch \""
561 << mgr->holder()->getClass()->GetName() << "/" << key
562 << "\"");
563 return StatusCode::FAILURE;
564 }
565 // Set up the saving of all the dynamic auxiliary properties
566 // of the object if it has any:
567 static constexpr bool METADATA = true;
568 ATH_CHECK(putAux(*metatree, *mgr, METADATA));
569 }
570
571 // Write the metadata objects:
572 if (metatree->Fill() <= 0) {
573 ATH_MSG_ERROR("Failed to write event format metadata into the output");
574 metatree->SetDirectory(nullptr);
575 return StatusCode::FAILURE;
576 }
577
578 // Now clean up:
579 metatree->Write();
580 metatree->SetDirectory(nullptr);
581 m_outputEventFormat = nullptr;
582 m_outputObjects.clear();
583 m_outputMetaObjects.clear();
584
585 // Return gracefully:
586 return StatusCode::SUCCESS;
587}
static const char *const METADATA_OBJECT_NAME
Name of the metadata tree or RNTuple.
Definition Event.h:81
EventFormat * m_outputEventFormat
Format of the current output file.
Definition Event.h:363
Object_t m_outputMetaObjects
Collection of all the managed output meta-objects.
Definition Event.h:358
std::string normalizedTypeinfoName(const std::type_info &info)
Convert a type_info to a normalized string representation (matching the names used in the root dictio...
static const ::Int_t MetaDataStop
The metadata for the output file should be written out.
Definition TIncident.h:31
EventFormat_v1 EventFormat
Definition of the current event format version.
Definition EventFormat.h:16
TFile * file

◆ finishWritingTo() [2/2]

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

Finish writing to an output file.

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

Parameters
fileThe file that the event data is written to
Returns
The usual StatusCode tyoes

Implements xAOD::Event.

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

473 {
474 return finishWritingTo(&file);
475}
StatusCode finishWritingTo(TFile &file) override
Finish writing to an output 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.

356 {
357
358 {
359 // We can only hold the lock (even though it's a shared lock) for
360 // this limited scope because the call to getInputObject below
361 // leads to a recursion and dead-lock if not released immediately.
363
364 // If the object already exists, return it:
365 auto it = m_branches.find(sgkey);
366 if (it != m_branches.end()) {
367 return &(it->second);
368 }
369 }
370
371 // If not, construct it now:
372 BranchInfo bi;
373 const xAOD::EventFormatElement* efe = getEventFormatElement(sgkey);
374 if (!efe) {
375 // Apparently this key is not known:
376 return nullptr;
377 }
378
379 // Helper variable(s).
380 static const bool SILENT = true;
381 static const bool METADATA = false;
382
383 // The name of the requested object.
384 const std::string& name = getName(sgkey);
385 // This is a bit perverse... In order to let the "base class" figure
386 // out the exact type of this object, we ask for it with an "Event
387 // pointer". I use that type because I need something that has a
388 // dictionary, and which should always be available when this code
389 // runs. In the end it doesn't matter that the object can't be
390 // retrieved as that type (of course...), it only matters that it gets
391 // "set up" following these calls.
392 Event* nc_this = const_cast<Event*>(this);
393 static const std::type_info& dummy = typeid(Event);
394 nc_this->getInputObject(name, dummy, SILENT, METADATA);
395 auto itr = m_outputObjects.find(name);
396 if (itr == m_outputObjects.end()) {
397 itr = m_inputObjects.find(name);
398 if (itr == m_inputObjects.end()) {
399 // We didn't find this object in the store...
400 return nullptr;
401 }
402 }
403 const Details::IObjectManager* mgr =
404 dynamic_cast<const Details::IObjectManager*>(itr->second.get());
405 if (!mgr) {
406 ATH_MSG_ERROR("Internal logic error found");
407 return nullptr;
408 }
409 bi.m_class = mgr->holder()->getClass();
410 // There's no need to check whether this is a "proper" dictionary
411 // at this point, since if TEvent is holding on to it, the type
412 // must have a proper compiled dictionary.
413
414#ifndef XAOD_STANDALONE
415 // Create a proper proxy for the input branch:
416 auto taddr = std::make_unique<SG::TransientAddress>(
417 CLID_NULL, efe->branchName(), new GenericAddress());
418 taddr->setSGKey(sgkey);
420 *nc_this, getName(sgkey), *bi.m_class->GetTypeInfo());
421 bi.m_proxy = std::make_unique<SG::DataProxy>(std::move(taddr), loader);
422 loader->setProxy(*bi.m_proxy.get());
423#endif // not XAOD_STANDALONE
424
425 // Add the branch info to our list:
427 lock.upgrade();
428 auto ret = m_branches.insert(std::make_pair(sgkey, std::move(bi)));
429
430 // Return a pointer to the branch info:
431 return &(ret.first->second);
432}
void setProxy(SG::DataProxy &proxy)
const std::string & name() const override
Get the name of the instance.
const std::string & getName(const void *obj) const override
Function returning the key describing a known object.
Event(std::string_view name, const EventContext *ctx=nullptr)
Constructor with a name.
Definition EventCore.cxx:28
friend class xAODPrivate::Loader
Definition Event.h:65
const xAOD::EventFormatElement * getEventFormatElement(SG::sgkey_t sgkey) const
Get the metadata object for a given "SG key".

◆ getEntries()

Long64_t xAOD::TEvent::getEntries ( ) const
overridevirtualinherited

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

Returns
The number of events in the input file(s)

Implements xAOD::Event.

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

658 {
659
660 if (m_inChain) {
661 return m_inChain->GetEntries();
662 } else if (m_inTree) {
663 return m_inTree->GetEntries();
664 } else if (m_inTreeMissing) {
665 // The input file is empty:
666 return 0;
667 } else {
668 ATH_MSG_ERROR("Function called on an uninitialised object");
669 return 0;
670 }
671}
bool m_inTreeMissing
Internal status flag showing that an input file is open, but it doesn't contain an event tree.

◆ getEntry()

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

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
entryThe entry from the input tree to load
getallParameter 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 687 of file Control/xAODRootAccess/Root/TEvent.cxx.

687 {
688
689 // A little sanity check:
690 if ((!m_inTree) && (!m_inChain)) {
691 ATH_MSG_ERROR("Function called on an uninitialised object");
692 return -1;
693 }
694
695 // If we have a chain as input:
696 if (m_inChain) {
697 // Make sure that the correct tree is loaded:
698 const ::Long64_t fileEntry = m_inChain->LoadTree(entry);
699 if (fileEntry < 0) {
700 ATH_MSG_ERROR("Failure in loading entry " << entry
701 << " from the input chain");
702 return -1;
703 }
704 // Check if a new file was loaded:
705 if ((m_inTreeNumber != m_inChain->GetTreeNumber()) ||
706 m_inChainTracker->internalStateChanged()) {
707 // Reset the tracker:
708 m_inChainTracker->reset();
709 // Connect to this new file:
710 m_inTreeNumber = m_inChain->GetTreeNumber();
711 ::TFile* file = m_inChain->GetFile();
712 // The useTreeCache parameter is set to false, since the cache
713 // is anyway set up through the TChain. It shouldn't be modified
714 // on the file level.
715 static constexpr bool USE_TREE_CACHE = false;
716 if (readFrom(file, USE_TREE_CACHE, m_inChain->GetName()).isFailure()) {
717 ATH_MSG_ERROR("Couldn't connect to input file #"
718 << m_inTreeNumber << " of the input chain");
719 return -1;
720 }
721 }
722 // Restore the previously received entry number.
723 m_entry = fileEntry;
724 }
725 // If we have a regular file/tree as input:
726 else {
727 m_entry = entry;
728 }
729
730 // In order to make the reading of branches+tree cache work
731 // NB: TTree::LoadTree() only set the entry that should be read for each
732 // branch but no reading of the branch content is performed when calling that
733 // function. The entry set that can be retrieved with
734 // branch->GetTree()->GetReadEntry()
735 // For friend trees, if an index was built, then the entry which is set for
736 // the related branches is found by the LoadTree function by matching the the
737 // major and minor values of the main tree and friend tree
738 if (m_inTree && m_inTree->LoadTree(m_entry) < 0) {
739 ATH_MSG_ERROR("Failure in loading entry " << m_entry
740 << " from the input file");
741 return -1;
742 }
743
744 // Stats counter needs to know it's the next event:
746
747 // The final number of bytes read.
748 ::Int_t result = 0;
749
750 // Check if objects need to be read in.
751 if (getall) {
752 if (m_auxMode == kAthenaAccess) {
753 // In kAthenaAccess mode we need to use getInputObject(...) to load
754 // all the input objects correctly.
755 for (auto &[key, mgr] : m_inputObjects) {
756 static const std::string dynStorePostfix = "Aux.Dynamic";
757 if (key.ends_with(dynStorePostfix)) {
758 // Ignore the dynamic store objects. They get loaded through
759 // their parents.
760 } else {
761 // Load the objects and their auxiliary stores through the
762 // getInputObject(...) function, which takes care of correctly
763 // setting them up. The type is irrelevant here. We don't
764 // really care about the exact type of the objects.
765 static constexpr bool SILENT = true;
766 static constexpr bool METADATA = false;
767 getInputObject(key, typeid(int), SILENT, METADATA);
768 }
769 }
770 } else {
771 // In a "reasonable" access mode, we do something very simple:
772 for (auto &[key, mgr] : m_inputObjects) {
773 result += mgr->getEntry(getall);
774 }
775 }
776 }
777
778 // Notify the listeners that a new event was loaded:
779 const TIncident incident(IncidentType::BeginEvent);
780 for (auto &listener : m_listeners) {
781 listener->handle(incident);
782 }
783
784 // Return the number of bytes read:
785 return result;
786}
void nextEvent()
Function incrementing the processed event counter.
std::unique_ptr< TChainStateTracker > m_inChainTracker
Optional object for tracking the state changes of an input TChain.
StatusCode readFrom(::TFile &inFile) override
Set up the reading of an input file from TFile This method implements the interface from Event.
::Int_t m_inTreeNumber
The number of the currently open tree in the input chain.
static const ::Int_t BeginEvent
A new event was just loaded.
Definition TIncident.h:29

◆ 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.

331 {
332
333 const xAOD::EventFormatElement* efe = nullptr;
334 static const bool QUIET = true;
336 efe = m_outputEventFormat->get(sgkey, QUIET);
337 }
338 if (!efe) {
339 efe = m_inputEventFormat.get(sgkey, QUIET);
340 }
341 if (!efe) {
342 static SG::SGKeySet missingSGKeys ATLAS_THREAD_SAFE;
343 static mutex_t mutex;
344 guard_t lock(mutex);
345 if (missingSGKeys.emplace(sgkey).second) {
348 "Can't find EventFormatElement for hashed SG key: " << sgkey);
349 }
350 return 0;
351 }
352 }
353 return efe;
354}
AthContainers_detail::lock_guard< mutex_t > guard_t
Guard type for multithreaded synchronisation.
std::unordered_set< sgkey_t > SGKeySet
A set of sgkey_t values.
Definition sgkey_t.h:97
AthContainers_detail::mutex mutex_t
Mutex used to synchronize modifications to the cache vector.

◆ getFile()

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

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
fileThe file number to load
getallIf 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 817 of file Control/xAODRootAccess/Root/TEvent.cxx.

817 {
818
819 // Check if the file number is valid:
820 if ((file < 0) || (file >= getFiles())) {
821 ATH_MSG_ERROR("Function called with invalid file number (" << file << ")");
822 return -1;
823 }
824
825 // If we are not reading a TChain, return at this point. As the one and
826 // only file is open already...
827 if (!m_inChain) {
828 return 0;
829 }
830
831 // Trigger the "scanning" of the input files, so the TChain would know
832 // how many entries are in the various files.
833 getEntries();
834
835 // Calculate which entry/event we need to load:
836 ::Long64_t entry = 0;
837 for (::Long64_t i = 0; i < file; ++i) {
838 entry += m_inChain->GetTreeOffset()[i];
839 }
840
841 // Load this entry using the regular event opening function:
842 return getEntry(entry, getall);
843}
::Long64_t getFiles() const
Get how many files are available on the currently defined input.
::Long64_t getEntries() const override
Get how many entries are available from the current input file(s).

◆ getFiles()

Long64_t xAOD::TEvent::getFiles ( ) const
inherited

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

797 {
798
799 if (m_inChain) {
800 return m_inChain->GetListOfFiles()->GetEntries();
801 } else if (m_inTree || m_inTreeMissing) {
802 return 1;
803 } else {
804 return 0;
805 }
806}

◆ 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
keyString 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.

27 {
28
29 // For empty keys let's finish quickly.
30 if (key == "") {
31 return 0;
32 }
33
34 // If the key is used in the input file, let's use the same hash for
35 // the output file as well.
36 static constexpr bool QUIET = true;
37 if (const EventFormatElement* efe = m_inputEventFormat.get(key, QUIET)) {
38 return efe->hash();
39 }
40
41 // If it's a new key, make a new hash for it from scratch:
42 return Utils::hash(key);
43}
SG::sgkey_t hash(const std::string &name)
This function provides a hashed version of the key (branch) names used in the xAOD file,...

◆ 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
keyThe key (branch name) of the object to retrieve
tiThe type as which the object is to be retrieved
silentSet to kTRUE to make the code fail silently in case the object can't be retrieved
metadataFlag 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.

283 {
284
285 // Check if a name remapping should be applied or not:
286 std::string keyToUse = key;
287 auto remap_itr = m_nameRemapping.find(key);
288 if ((remap_itr != m_nameRemapping.end()) &&
289 (!m_inputEventFormat.exists(key)) &&
290 m_inputEventFormat.exists(remap_itr->second)) {
291 keyToUse = remap_itr->second;
292 }
293
294 // The following catches the cases when we ask for a transient
295 // ConstDataVector object to be returned as "const DataVector".
296 const TStore* store = TActiveStore::store();
297 if (const THolder* holder = (store ? store->holder(keyToUse) : nullptr)) {
298 static constexpr bool SILENT = true;
299 const void* result = holder->getAsConst(ti, SILENT);
300 if (result && !holder->getAs(ti, SILENT)) {
301 return result;
302 }
303 }
304
305 // A sanity check before checking for an object from the input file.
306 if (hasInput() == false) {
307 if (silent == false) {
308 ATH_MSG_WARNING("No input file connected to the Event object");
309 }
310 return nullptr;
311 }
312
313 // Make sure that the requested input is connected to.
314 const StatusCode sc = (metadata ? connectMetaObject(keyToUse, silent)
315 : connectObject(keyToUse, silent));
316 if (sc.isSuccess() == false) {
317 return nullptr;
318 }
319
320 // Select which object container to use:
321 Object_t& objects = (metadata ? m_inputMetaObjects : m_inputObjects);
322
323 // Access the object's manager:
324 auto itr = objects.find(keyToUse);
325 if (itr == objects.end()) {
326 ATH_MSG_FATAL("There is an internal logic error in the code...");
327 return nullptr;
328 }
329
330 // This has to be an ObjectManager object:
331 Details::IObjectManager* mgr =
332 dynamic_cast<Details::IObjectManager*>(itr->second.get());
333 if (mgr == nullptr) {
334 if (key == keyToUse) {
335 ATH_MSG_ERROR("Object of wrong type found for key \"" << key << "\"");
336 } else {
337 ATH_MSG_ERROR("Object of wrong type found for key \""
338 << key << "\"/\"" << keyToUse << "\"");
339 }
340 return nullptr;
341 }
342
343 // Make sure that the current entry is loaded for event data objects.
344 if (metadata == false) {
345 const Int_t readBytes = mgr->getEntry();
346 if (readBytes > 0) {
347 // Connect the auxiliary store to objects needing it. This call also
348 // takes care of updating the dynamic store of auxiliary containers,
349 // when they are getting accessed directly.
350 static const bool IS_METADATA = false;
351 if (setAuxStore(key, *mgr, IS_METADATA).isSuccess() == false) {
352 ATH_MSG_ERROR("Failed to set the auxiliary store for "
353 << mgr->holder()->getClass()->GetName() << "/"
354 << keyToUse);
355 return nullptr;
356 }
357 } else if (readBytes < 0) {
358 ATH_MSG_ERROR("Failed to load current entry for object "
359 << mgr->holder()->getClass()->GetName() << "/" << keyToUse);
360 return nullptr;
361 }
362 }
363
364 // Ask the holder object for the object of this type:
365 const void* result = mgr->holder()->getAsConst(ti, silent);
366 if (result == nullptr) {
367 if (!silent) {
368 ATH_MSG_WARNING("Could not retrieve object with key \""
369 << keyToUse << "\" as \""
370 << SG::normalizedTypeinfoName(ti) << "\"");
371 }
372 return nullptr;
373 }
374
375 // We succeeded:
376 return result;
377}
static Double_t sc
if(pathvar)
virtual bool hasInput() const =0
Check if an input file is connected to the object.
std::unordered_map< std::string, std::unique_ptr< TVirtualManager > > Object_t
Definition of the internal data structure type.
Definition Event.h:344
virtual StatusCode connectMetaObject(const std::string &key, bool silent)=0
Function setting up access to a particular metadata object.
virtual StatusCode setAuxStore(const std::string &key, Details::IObjectManager &mgr, bool metadata)=0
Function connecting a DV object to its auxiliary store.
static TStore * store()
Access the currently active TStore object.
::StatusCode StatusCode
StatusCode definition for legacy code.
silent(func)
Redirect stdout/err to /dev/null Useful wrapper to get rid of ROOT verbosity... N....

◆ 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
keyThe hashed key of the input object
tiThe type description of the object requested
silentSwitch 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.

166 {
167
168 // Get a string name for this key:
169 const std::string& name = getName(key);
170 if (name.empty() && (silent == false)) {
171 ATH_MSG_WARNING("Key 0x" << std::hex << key << " unknown");
172 return nullptr;
173 }
174
175 // Forward the call to the function using an std::string key:
176 static const bool METADATA = false;
177 return getInputObject(name, ti, silent, METADATA);
178}

◆ 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
objPointer 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.

52 {
53
54 // Make use of the getName function.
55 return getHash(getName(obj));
56}
SG::sgkey_t getHash(const std::string &key) const override
Function returning the hash describing an object name.

◆ 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
objPointer 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.

65 {
66
67 // Check the active TStore first, its pointer lookup is cheap.
68 const TStore* store = TActiveStore::store();
69 if (store && store->contains(obj)) {
70 return store->getName(obj);
71 }
72
73 // Then look among the output objects.
74 for (const auto& [key, manager] : m_outputObjects) {
75 // Check if this is our object.
76 if (manager->object() == obj) {
77 // If it is, let's return right away.
78 return key;
79 }
80 }
81
82 // Now look among the input objects.
83 for (const auto& [key, manager] : m_inputObjects) {
84 // Check if this is our object.
85 if (manager->object() == obj) {
86 // If it is, let's return.
87 return key;
88 }
89 }
90
91 // We didn't find the object in the event...
92 ATH_MSG_WARNING("Didn't find object with pointer \"" << obj
93 << "\" in the event");
94 static const std::string dummy;
95 return dummy;
96}

◆ 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
hashThe 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.

105 {
106
107 // If the branch is known from the input:
108 static constexpr bool QUIET = true;
109 if (const EventFormatElement* efe = m_inputEventFormat.get(hash, QUIET)) {
110 return efe->branchName();
111 }
112
113 // If the branch is known on the output:
114 if (const EventFormatElement* efe =
115 (m_outputEventFormat ? m_outputEventFormat->get(hash, QUIET)
116 : nullptr)) {
117 return efe->branchName();
118 }
119
120 // If this is an object in the active store:
121 const TStore* store = TActiveStore::store();
122 if (store && store->contains(hash)) {
123 return store->getName(hash);
124 }
125
126 // If it is unknown:
127 static const std::string dummy;
128 return dummy;
129}

◆ getNames()

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

Function determining the list keys associated with a type name.

Implements xAOD::Event.

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

938 {
939 // The results go in here
940 std::set<std::string> keys;
941
942 // Get list of branches from
943 // the input metadata tree or input tree
944 std::vector<TObjArray* > fullListOfBranches = {};
945 if (metadata) {
946 if (m_inMetaTree) {
947 // No friend tree expected for metadata tree
948 // Only add the list of branches of the metadata tree
949 ATH_MSG_DEBUG("Scanning for input metadata objects");
950 fullListOfBranches.push_back(m_inMetaTree->GetListOfBranches());
951 }
952 } else {
953 if (m_inTree) {
954 ATH_MSG_DEBUG("Scanning for input data objects");
955 // Add the list of branches of the main tree
956 fullListOfBranches.push_back(m_inTree->GetListOfBranches());
957 // If the input tree has friend trees
958 // add as well the list of friend tree branches
959 if (m_inTree->GetListOfFriends()) {
960 // Get the list of friends
961 TList* fList = m_inTree->GetListOfFriends();
962 // Loop over friend elements
963 for (TObject* feObj : *fList) {
964 if (feObj) {
965 // Get corresponding friend tree
966 auto* pElement = dynamic_cast<TFriendElement* >(feObj);
967 if (pElement == nullptr) {
968 continue;
969 }
970 TTree* friendTree = pElement->GetTree();
971 // Add list of branches of the friend tree
972 fullListOfBranches.push_back(friendTree->GetListOfBranches());
973 }
974 }
975 }
976 }
977 }
978
979 // Loop over all list of branches (if any)
980 for (const TObjArray* in : fullListOfBranches) {
981 // Loop over all branches inside the current list of branches
982 for (const TObject* obj : *in) {
983
984 if (obj == nullptr) {
985 continue;
986 }
987 const TBranch* element = dynamic_cast<const TBranch* >(obj);
988 if (!element) {
989 ATH_MSG_ERROR("Failure inspecting input data objects");
990 return StatusCode::FAILURE;
991 }
992 const std::string objClassName = element->GetClassName();
993 std::string key = obj->GetName();
994 ATH_MSG_VERBOSE("Inspecting \"" << objClassName << "\" / \"" << key
995 << "\"");
996 if (objClassName == targetClassName) {
997 ATH_MSG_DEBUG("Matched \"" << targetClassName << "\" to key \"" << key
998 << "\"");
999 keys.insert(std::move(key));
1000 }
1001 }
1002 }
1003
1005
1006 ATH_MSG_DEBUG("Scanning input objects for \"" << targetClassName << "\"");
1007 for (const auto &[key, vmgr] : inAux) {
1008 // All (metadata) objects should be held by TObjectManager objects.
1009 const TObjectManager* mgr =
1010 dynamic_cast<const TObjectManager* >(vmgr.get());
1011 if (mgr == nullptr) {
1012 continue;
1013 }
1014 const std::string &objClassName = mgr->holder()->getClass()->GetName();
1015 ATH_MSG_VERBOSE("Inspecting \"" << objClassName << "\" / \"" << key
1016 << "\"");
1017 if (objClassName == targetClassName) {
1018 ATH_MSG_DEBUG("Matched \"" << targetClassName << "\" to key \"" << key
1019 << "\"");
1020 keys.insert(key);
1021 }
1022 }
1023
1024 // Check for output objects.
1025 if ((metadata == false) && m_outTree) {
1026 const TObjArray* out = m_outTree->GetListOfBranches();
1027 ATH_MSG_DEBUG("Scanning for output data objects");
1028
1029 for (const TObject* obj : *out) {
1030 if (obj == nullptr) {
1031 continue;
1032 }
1033 const TBranch* element = dynamic_cast<const TBranch* >(obj);
1034 if (element == nullptr) {
1035 ATH_MSG_ERROR("Failure inspecting output objects");
1036 return StatusCode::FAILURE;
1037 }
1038 const std::string objClassName = element->GetClassName();
1039 std::string key = obj->GetName();
1040 ATH_MSG_VERBOSE("Inspecting \"" << objClassName << "\" / \"" << key
1041 << "\"");
1042 if (objClassName == targetClassName) {
1043 ATH_MSG_DEBUG("Matched \"" << targetClassName << "\" to key \"" << key
1044 << "\"");
1045 keys.insert(std::move(key));
1046 }
1047 }
1048 }
1049
1051
1052 // Search though the in-memory output objects.
1053 ATH_MSG_DEBUG("Scanning output objects for \"" << targetClassName << "\"");
1054 for (const auto &[key, vmgr] : outAux) {
1055 // All (metadata) objects should be held by TObjectManager objects.
1056 TObjectManager* mgr = dynamic_cast<TObjectManager* >(vmgr.get());
1057 if (mgr == nullptr) {
1058 continue;
1059 }
1060 const std::string &objClassName = mgr->holder()->getClass()->GetName();
1061 ATH_MSG_VERBOSE("Inspecting \"" << objClassName << "\" / \"" << key
1062 << "\"");
1063 if (objClassName == targetClassName) {
1064 ATH_MSG_DEBUG("Matched \"" << targetClassName << "\" to key \"" << key
1065 << "\"");
1066 keys.insert(key);
1067 }
1068 }
1069
1070 vkeys.insert(vkeys.end(), keys.begin(), keys.end());
1071
1072 // Return gracefully.
1073 return StatusCode::SUCCESS;
1074}

◆ 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
keyThe key (branch name) of the object to retrieve
tiThe type as which the object is to be retrieved
metadataFlag 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.

222 {
223
224 // Select which object container to use:
226
227 // Check if the object can be found:
228 auto itr = objects.find(key);
229 if (itr == objects.end()) {
230 // Do the following only for event data:
231 if (!metadata) {
232 // It's not in the event. Let's check if we find it in an active
233 // TStore object. (getAs fails for const objects, and wrong types.)
234 const TStore* store = TActiveStore::store();
235 const THolder* holder = (store ? store->holder(key) : nullptr);
236 static constexpr bool SILENT = true;
237 return (holder ? holder->getAs(ti, SILENT) : nullptr);
238 } else {
239 // For metadata we don't use external resources.
240 return nullptr;
241 }
242 }
243
244 // If the object is not set in this event yet, we can't continue:
245 if (itr->second->isSet() == false) {
246 return nullptr;
247 }
248
249 // If it does exist, check if it's the right kind of object:
250 Details::IObjectManager* mgr =
251 dynamic_cast<Details::IObjectManager*>(itr->second.get());
252 if (mgr == nullptr) {
253 ATH_MSG_ERROR("Object of wrong type found for key \"" << key << "\"");
254 return nullptr;
255 }
256
257 // Ask the holder object for the object of this type:
258 void* result = mgr->holder()->getAs(ti);
259 if (result == nullptr) {
260 ATH_MSG_WARNING("Couldn't retrieve object as \""
261 << SG::normalizedTypeinfoName(ti) << "\"");
262 return nullptr;
263 }
264
265 // Return the object:
266 return result;
267}

◆ 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
keyThe hashed key of the output object
tiThe 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.

141 {
142
143 // Get a string name for this key.
144 const std::string& name = getName(key);
145 if (name.empty()) {
146 return nullptr;
147 }
148
149 // Forward the call to the function using an std::string key.
150 static const bool METADATA = false;
151 return getOutputObject(name, ti, METADATA);
152}

◆ hasInput()

bool xAOD::TEvent::hasInput ( ) const
overrideprotectedvirtualinherited

Check if an input file is connected to the object.

Implements xAOD::Event.

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

929 {
930
931 return ((m_inTree != nullptr) || (m_inChain != nullptr));
932}

◆ hasOutput()

bool xAOD::TEvent::hasOutput ( ) const
overrideprotectedvirtualinherited

Check if an output file is connected to the object.

Implements xAOD::Event.

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

934{ 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.

40{
42 // If user did not set an explicit level, set a default
43 if (m_lvl == MSG::NIL) {
44 m_lvl = m_imsg ?
45 static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
46 MSG::INFO;
47 }
48}
std::string m_nm
Message source name.
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
std::atomic< MSG::Level > m_lvl
Current logging level.
IMessageSvc * getMessageSvc(bool quiet=false)
int outputLevel(const IMessageSvc *ims, const std::string &source)

◆ initStats()

StatusCode xAOD::TEvent::initStats ( )
protectedinherited

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

1867 {
1868
1869 // If we're dealing with an empty input file, stop here:
1870 if (m_inTreeMissing) {
1871 return StatusCode::SUCCESS;
1872 }
1873
1874 // A little sanity check:
1875 if (!m_inTree) {
1876 ATH_MSG_ERROR("Function called on an uninitialised object");
1877 return StatusCode::FAILURE;
1878 }
1879
1880 // Reset the number of input branches information:
1882
1883 // Loop over the EventFormat information
1886 for (; itr != end; ++itr) {
1887
1888 // Get the name of the branch in question:
1889 const std::string &branchName = itr->second.branchName();
1890
1891 // If it's an auxiliary container, scan it using TAuxStore:
1892 if (branchName.find("Aux.") != std::string::npos) {
1893
1894 // But first decide whether it describes a container, or just
1895 // a single object. Since the file may have been written in
1896 // kBranchAccess mode, it's not necessarily a good idea to check
1897 // the type of the auxiliary class. So let's check the interface
1898 // class instead.
1899 //
1900 // Get the name of the interface object/container:
1901 const std::string intName = branchName.substr(0, branchName.size() - 4);
1902 if (!m_inputEventFormat.exists(intName)) {
1903 // When this happens, it may still be that both the interface and
1904 // the auxiliary container is missing from the file. As we didn't
1905 // check yet whether the auxiliary container is in place or not.
1906 // So, before printing a warning, let's check for this.
1907 // Unfortunately the check is pretty expensive, but this should
1908 // not be performance critical code after all...
1909 ::Bool_t auxFound = kFALSE;
1910 const std::string dynName = Utils::dynBranchPrefix(branchName);
1911
1912 std::vector<TObjArray* > fullListOfBranches = {};
1913 // Add the list of branches of the main tree
1914 fullListOfBranches.push_back(m_inTree->GetListOfBranches());
1915 // If input tree has friend trees
1916 // add as well the list of friend tree branches
1917 if (m_inTree->GetListOfFriends()) {
1918 // Get the list of friends
1919 TList* fList = m_inTree->GetListOfFriends();
1920 // Loop over friend elements
1921 for (TObject* feObj : *fList) {
1922 if (feObj) {
1923 // Get corresponding friend tree
1924 auto* pElement = dynamic_cast<TFriendElement* >(feObj);
1925 if (not pElement)
1926 continue;
1927 TTree* friendTree = pElement->GetTree();
1928 // Add list of branches of the friend tree
1929 fullListOfBranches.push_back(friendTree->GetListOfBranches());
1930 }
1931 }
1932 }
1933
1934 for (TObjArray* branches : fullListOfBranches) {
1935 for (Int_t i = 0; i < branches->GetEntriesFast(); ++i) {
1936 if (!branches->At(i))
1937 continue;
1938
1939 const TString name(branches->At(i)->GetName());
1940 if (name.BeginsWith(branchName) || name.BeginsWith(dynName)) {
1941 auxFound = kTRUE;
1942 break;
1943 }
1944 }
1945 }
1946 if (auxFound) {
1947 ATH_MSG_WARNING("Couldn't find interface object/container \""
1948 << intName << "\" belonging to branch \""
1949 << branchName << "\"");
1950 }
1951 continue;
1952 }
1953
1954 // Get the type of the interface:
1955 const EventFormatElement* el = m_inputEventFormat.get(intName);
1956 ::TClass* cl = ::TClass::GetClass(el->className().c_str());
1957 if ((!cl) || (!cl->IsLoaded())) {
1958 ATH_MSG_WARNING("Couldn't find dictionary for type \""
1959 << el->className() << "\"");
1960 continue;
1961 }
1962
1963 // Get the dictionary for the DataVector base class:
1964 static const std::type_info &baseTi = typeid(SG::AuxVectorBase);
1965 static const std::string baseName = SG::normalizedTypeinfoName(baseTi);
1966 static ::TClass* const baseCl = ::TClass::GetClass(baseName.c_str());
1967 if (!baseCl) {
1968 ATH_MSG_ERROR("Couldn't get dictionary for type \"" << baseName
1969 << "\"");
1970 return StatusCode::FAILURE;
1971 }
1972
1973 // The type of the auxiliary store is finally deduced from the
1974 // inheritance of the interface container.
1976 (cl->InheritsFrom(baseCl) ? TAuxStore::EStructMode::kContainerStore
1978
1979 // Scan the branches using a temporary TAuxStore instance:
1980 static constexpr bool TOP_STORE = true;
1981 TAuxStore temp(this->currentContext(), branchName, TOP_STORE, mode);
1982 static constexpr bool PRINT_WARNINGS = false;
1983 ATH_CHECK(temp.readFrom(*m_inTree, PRINT_WARNINGS));
1984
1985 // Conveninence variable:
1986 ReadStats &stats = IOStats::instance().stats();
1987
1988 // Teach the cache about all the branches:
1989 for (SG::auxid_t id : temp.getAuxIDs()) {
1990 stats.branch(branchName, id);
1991 }
1992
1993 // Increment the number of known branches:
1994 stats.setBranchNum(stats.branchNum() + temp.getAuxIDs().size());
1995 }
1996 // If it's an interface container:
1997 else {
1998 // Try to access the branch:
1999 const ::TBranch* container = m_inTree->GetBranch(branchName.c_str());
2000 // If it exists, let's remember it:
2001 if (container) {
2002 IOStats::instance().stats().container(branchName);
2003 }
2004 }
2005 }
2006
2007 // Return gracefully:
2008 return StatusCode::SUCCESS;
2009}
BranchStats * container(const std::string &name)
Access the description of a container. Creating it if necessary.
void setBranchNum(::Int_t num)
Set the total number of branches on the input.
EStructMode
"Structural" modes of the object
const SG::AuxVectorData * container() const
Return the container holding this element.
size_t auxid_t
Identifier for a particular aux data item.
Definition AuxTypes.h:27
std::string dynBranchPrefix(const std::string &key)
This function is used to figure out what to name dynamic auxiliary branches coming from a container c...

◆ inputEventFormat()

const EventFormat * Event::inputEventFormat ( ) const
inherited

Get information about the input objects.

Definition at line 237 of file EventCore.cxx.

237 {
238
239 if (hasInput()) {
240 return &m_inputEventFormat;
241 }
242 return nullptr;
243}

◆ 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.

303 {
304
305 return &(getName(key));
306}

◆ 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.

308 {
309
310 return &(getName(key));
311}

◆ MakeTransientTree()

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

◆ 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.

49 {
50#ifndef XAOD_STANDALONE
51 return ::AthMessaging::msg();
52#else // not XAOD_STANDALONE
53 return m_msg;
54#endif // not XAOD_STANDALONE
55 }

◆ msg() [2/2]

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

The standard message stream.

Parameters
lvlThe 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.

57 {
58#ifndef XAOD_STANDALONE
59 return ::AthMessaging::msg( lvl );
60#else // not XAOD_STANDALONE
61 m_msg << lvl;
62 return m_msg;
63#endif // not XAOD_STANDALONE
64 }

◆ msgLvl()

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

Test the output level of the object.

Parameters
lvlThe 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.

41 {
42#ifndef XAOD_STANDALONE
43 return ::AthMessaging::msgLvl( lvl );
44#else // not XAOD_STANDALONE
45 return m_msg.msgLevel( lvl );
46#endif // not XAOD_STANDALONE
47 }

◆ name()

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

Get the name of the instance.

Definition at line 324 of file EventIProxyDict.cxx.

324 {
325
326 static const std::string result{"xAOD::Event"};
327 return result;
328}

◆ outputEventFormat()

const EventFormat * Event::outputEventFormat ( ) const
inherited

Get information about the output objects.

Definition at line 245 of file EventCore.cxx.

245 {
246
247 return m_outputEventFormat;
248}

◆ 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 307 of file EventCore.cxx.

307 {
308
309 // Simply do this via the xAODCore code:
310 IOStats::instance().stats().Print("Summary");
311}
void Print(::Option_t *option="") const
Print information about the collected statistics.

◆ 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 210 of file EventCore.cxx.

210 {
211
212 // Print a header.
213 ATH_MSG_INFO("Name remapping rules:");
214
215 // In case no remapping rules have been set.
216 if (m_nameRemapping.empty()) {
217 ATH_MSG_INFO(" NONE");
218 return;
219 }
220
221 // Otherwise.
222 for (const auto& [newName, onfile] : m_nameRemapping) {
223 ATH_MSG_INFO(" \"" << newName << "\" -> \"" << onfile << "\"");
224 }
225}
#define ATH_MSG_INFO(x,...)

◆ 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
valueThe new value for the option

Definition at line 232 of file EventCore.cxx.

232 {
233
235}

◆ 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.

284 {
285
287
288 std::vector<const SG::DataProxy*> ret;
289 for (const auto& p : m_branches) {
290 const SG::DataProxy* proxy = p.second.m_proxy.get();
291 if (proxy) {
292 ret.push_back(proxy);
293 }
294 }
295 return ret;
296}

◆ 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.

219 {
220
221 const SG::sgkey_t sgkey = getHash(key);
222 if (!sgkey) {
223 return 0;
224 }
225 return proxy_exact(sgkey);
226}
SG::DataProxy * proxy_exact(SG::sgkey_t sgkey) const override
Get proxy given a hashed key+clid.

◆ 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.

191 {
192
193 // Look up the name of this object
194 std::string name = getName(pTransient);
195 if (name.empty()) {
196 // Apparently the object is not known...
197 return nullptr;
198 }
199
200 // Get the metadata object for it:
201 const xAOD::EventFormatElement* efe = 0;
202 static const bool QUIET = true;
204 efe = m_outputEventFormat->get(name, QUIET);
205 }
206 if (!efe) {
207 efe = m_inputEventFormat.get(name, QUIET);
208 }
209 if (!efe) {
210 // No metadata found...
211 return nullptr;
212 }
213
214 // Return the proxy:
215 const BranchInfo* bi = getBranchInfo(efe->hash());
216 return bi->m_proxy.get();
217}
sgkey_t hash() const
Get the hash belonging to this branch/key.
const BranchInfo * getBranchInfo(SG::sgkey_t sgkey) const
Get the object describing one object/branch.

◆ 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.

228 {
229
230 // Get the object describing this branch/object:
231 const BranchInfo* bi = getBranchInfo(sgkey);
232 if (!bi) {
233 static SG::SGKeySet missingSGKeys ATLAS_THREAD_SAFE;
234 static mutex_t mutex;
235 guard_t lock(mutex);
236 if (missingSGKeys.emplace(sgkey).second && m_printEventProxyWarnings) {
237 ATH_MSG_WARNING("Can't find BranchInfo for: " << sgkey);
238 }
239 return 0;
240 }
241
242 // Access its data proxy:
243 SG::DataProxy* proxy = bi->m_proxy.get();
244
245 // Return the proxy:
246 return proxy;
247}

◆ putAux()

StatusCode xAOD::TEvent::putAux ( ::TTree & outTree,
TVirtualManager & vmgr,
bool metadata )
protectedinherited

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
outTreeThe TTree to put the auxiliary branches into
mgrThe object manager of the output object
metadataFlag specifying whether the info written is metadata or not
Returns
The usual StatusCode types

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

2185 {
2186
2187 // A little sanity check:
2188 assert(m_outputEventFormat != 0);
2189
2190 // Do the conversion:
2191 TObjectManager* mgr = dynamic_cast<TObjectManager* >(&vmgr);
2192 if (!mgr) {
2193 // It's not an error any more when we don't get a TObjectManager.
2194 return StatusCode::SUCCESS;
2195 }
2196
2197 // Check if we need to do anything here:
2198 if (!mgr->holder()->getClass()->InheritsFrom("SG::IAuxStoreIO")) {
2199 return StatusCode::SUCCESS;
2200 }
2201
2202 // Get a pointer to the auxiliary store I/O interface:
2203 SG::IAuxStoreIO* aux = reinterpret_cast<SG::IAuxStoreIO* >(
2204 mgr->holder()->getAs(typeid(SG::IAuxStoreIO)));
2205 if (!aux) {
2206 ATH_MSG_FATAL("There is a logic error in the code!");
2207 return StatusCode::FAILURE;
2208 }
2209
2210 // Check if we have rules defined for which auxiliary properties
2211 // to write out:
2212 xAOD::AuxSelection sel;
2213 if (!metadata) {
2214 auto item_itr = m_auxItemList.find(mgr->branch()->GetName());
2215 if (item_itr != m_auxItemList.end()) {
2216 sel.selectAux(item_itr->second);
2217 }
2218 }
2219
2220 // Get the dynamic auxiliary variables held by this object, which
2221 // were selected to be written:
2222 const SG::auxid_set_t auxids =
2223 sel.getSelectedAuxIDs(aux->getSelectedAuxIDs());
2224
2225 // If there are no dynamic auxiliary variables in the object, return
2226 // right away:
2227 if (auxids.empty()) {
2228 return StatusCode::SUCCESS;
2229 }
2230
2231 // Decide what should be the prefix of all the dynamic branches:
2232 const std::string dynNamePrefix =
2233 Utils::dynBranchPrefix(mgr->branch()->GetName());
2234
2235 // Select which container to add the variables to:
2237
2238 // This iteration will determine the ordering of branches within
2239 // the tree, so sort auxids by name.
2240 const SG::AuxTypeRegistry &r = SG::AuxTypeRegistry::instance();
2241 typedef std::pair<std::string, SG::auxid_t> AuxVarSort_t;
2242 std::vector<AuxVarSort_t> varsort;
2243 varsort.reserve(auxids.size());
2244 for (SG::auxid_t id : auxids) {
2245 varsort.emplace_back(r.getName(id), id);
2246 }
2247 std::sort(varsort.begin(), varsort.end());
2248
2249 // Extract all the dynamic variables from the object:
2250 for (const auto &p : varsort) {
2251
2252 // The auxiliary ID:
2253 const SG::auxid_t id = p.second;
2254
2255 // Construct a name for the branch that we will write:
2256 const std::string brName = dynNamePrefix + p.first;
2257
2258 // Try to find the branch:
2259 Object_t::iterator bmgr = objects.find(brName);
2260
2261 // Check if we already know about this variable:
2262 if (bmgr == objects.end()) {
2263
2264 // Construct the full type name of the variable:
2265 const std::type_info* brType = aux->getIOType(id);
2266 if (!brType) {
2267 ATH_MSG_ERROR("No I/O type found for variable " << brName);
2268 return StatusCode::FAILURE;
2269 }
2270 const std::string brTypeName = Utils::getTypeName(*brType);
2271 std::string brProperTypeName = "<unknown>";
2272
2273 // The branch that will hopefully be created:
2274 ::TBranch* br = 0;
2275
2276 // Check if it's a primitive type or not:
2277 if (strlen(brType->name()) == 1) {
2278
2279 // Making the "proper" type name is simple in this case:
2280 brProperTypeName = brTypeName;
2281
2282 // Get the character describing this type for ROOT:
2283 const char rootType = Utils::rootType(brType->name()[0]);
2284 if (rootType == '\0') {
2285 ATH_MSG_ERROR("Type not known for variable \""
2286 << brName << "\" of type \"" << brTypeName << "\"");
2287 return StatusCode::FAILURE;
2288 }
2289
2290 // Create the full description of the variable for ROOT:
2291 std::ostringstream leaflist;
2292 leaflist << brName << "/" << rootType;
2293
2294 // Let's create a holder for this property:
2295 static constexpr bool IS_OWNER = false;
2296 auto auxmgr = std::make_unique<TPrimitiveAuxBranchManager>(
2297 id, nullptr, new THolder(aux->getIOData(id), nullptr, IS_OWNER));
2298
2299 // ... and let's add it to the output TTree:
2300 static constexpr Int_t BASKET_SIZE = 32000;
2301 *(auxmgr->branchPtr()) =
2302 outTree.Branch(brName.c_str(), auxmgr->holder()->get(),
2303 leaflist.str().c_str(), BASKET_SIZE);
2304 if (!auxmgr->branch()) {
2305 ATH_MSG_ERROR("Failed to create branch \""
2306 << brName << "\" out of type \"" << brProperTypeName
2307 << "\"");
2308 // Clean up:
2309 *(auxmgr->holder()->getPtr()) = 0;
2310 return StatusCode::FAILURE;
2311 }
2312 br = auxmgr->branch();
2313
2314 // Store it in the output list.
2315 objects[brName] = std::move(auxmgr);
2316
2317 } else {
2318
2319 // Check if we have a dictionary for this type:
2320 static constexpr Bool_t LOAD_IF_NOT_FOUND = kTRUE;
2321 static constexpr Bool_t SILENT = kTRUE;
2322 TClass* cl = TClass::GetClass(*brType, LOAD_IF_NOT_FOUND, SILENT);
2323 if (cl == nullptr) {
2324 // The dictionary needs to be loaded now. This could be an
2325 // issue. But let's hope for the best...
2326 cl = TClass::GetClass(brTypeName.c_str());
2327 // If still not found...
2328 if (cl == nullptr) {
2329 ATH_MSG_ERROR("Dictionary not available for variable \""
2330 << brName << "\" of type \"" << brTypeName << "\"");
2331 return StatusCode::FAILURE;
2332 }
2333 }
2334
2335 // The proper type name comes from the dictionary in this case:
2336 brProperTypeName = cl->GetName();
2337
2338 // Let's create a holder for this property:
2339 static constexpr bool IS_OWNER = false;
2340 auto auxmgr = std::make_unique<TAuxBranchManager>(
2341 id, nullptr, new THolder(aux->getIOData(id), cl, IS_OWNER));
2342
2343 // ... and let's add it to the output TTree.
2344 static constexpr Int_t BASKET_SIZE = 32000;
2345 static constexpr Int_t SPLIT_LEVEL = 0;
2346 *(auxmgr->branchPtr()) = outTree.Branch(brName.c_str(), cl->GetName(),
2347 auxmgr->holder()->getPtr(),
2348 BASKET_SIZE, SPLIT_LEVEL);
2349 if (!auxmgr->branch()) {
2350 ATH_MSG_ERROR("Failed to create branch \""
2351 << brName << "\" out of type \"" << brProperTypeName
2352 << "\"");
2353 // Clean up:
2354 *(auxmgr->holder()->getPtr()) = 0;
2355 return StatusCode::FAILURE;
2356 }
2357 br = auxmgr->branch();
2358
2359 // Store it in the output list.
2360 objects[brName] = std::move(auxmgr);
2361 }
2362
2363 // If this is not the first event, fill up the already filled
2364 // events with (empty) content:
2365 if (outTree.GetEntries()) {
2366 void* ptr = br->GetAddress();
2367 br->SetAddress(0);
2368 for (::Long64_t i = 0; i < outTree.GetEntries(); ++i) {
2369 br->Fill();
2370 }
2371 br->SetAddress(ptr);
2372 }
2373
2374 // If all went fine, let's add this branch to the event format
2375 // metadata:
2376 if (!m_outputEventFormat->exists(brName)) {
2377 m_outputEventFormat->add(EventFormatElement(brName, brProperTypeName,
2378 mgr->branch()->GetName(),
2379 getHash(brName)));
2380 }
2381
2382 // We don't need to do the rest:
2383 continue;
2384 }
2385
2386 // Access the object manager:
2387 bmgr = objects.find(brName);
2388 if (bmgr == objects.end()) {
2389 ATH_MSG_FATAL("There is an internal logic error in the code...");
2390 return StatusCode::FAILURE;
2391 }
2392
2393 // Replace the managed object:
2394 void* nc_data ATLAS_THREAD_SAFE = // we hold non-const pointers but check
2395 // on retrieve
2396 const_cast<void* >(static_cast<const void* >(aux->getIOData(id)));
2397 bmgr->second->setObject(nc_data);
2398 }
2399
2400 // Return gracefully:
2401 return StatusCode::SUCCESS;
2402}
std::atomic_flag m_initialized ATLAS_THREAD_SAFE
Messaging initialized (initMessaging).
static AuxTypeRegistry & instance()
Return the singleton registry instance.
virtual SG::auxid_set_t getSelectedAuxIDs() const
Get a list of dynamic variables that need to be written out.
Definition IAuxStoreIO.h:86
virtual const std::type_info * getIOType(SG::auxid_t auxid) const =0
Return the type of the data to be stored for one aux data item.
virtual const void * getIOData(SG::auxid_t auxid) const =0
Return a pointer to the data to be stored for one aux data item.
std::unordered_map< std::string, std::set< std::string > > m_auxItemList
Rules for selecting which auxiliary branches to write.
Definition Event.h:366
int r
Definition globals.cxx:22
void sort(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of sort for DataVector/List.
char rootType(char typeidType)
This function is used internally in the code when creating primitive dynamic auxiliary branches.
std::string getTypeName(const std::type_info &ti)
This function is necessary in order to create type names that ROOT can understand.

◆ readFrom() [1/3]

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

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

118 {
119 ATH_CHECK(readFrom(&inFile));
120 return StatusCode::SUCCESS;
121}

◆ readFrom() [2/3]

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

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
filePointer to the file being read
useTreeCacheFlag for turning on/off the usage of TTreeCache
treeNameName of the input tree
Returns
The usual StatusCode tyoes

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

134 {
135
136 // If no file was specified, return gracefully.
137 if (file == nullptr) {
138 ATH_MSG_DEBUG("No input file specified for readFrom(...)");
139 return StatusCode::SUCCESS;
140 }
141
142 // Clear the cached input objects.
143 m_inputObjects.clear();
144 m_inputMissingObjects.clear();
145 m_inputMetaObjects.clear();
146 {
148 lock.upgrade();
149 m_branches.clear();
150 }
151
152 // Reset the internal flags.
153 m_inTreeMissing = kFALSE;
154 m_entry = -1;
155
156 // Make sure we return to the current directory:
157 TDirectoryReset dr;
158
159 // Set up the file access tracer.
161
162 // Look for the metadata tree:
164 if (m_inMetaTree == nullptr) {
165 ATH_MSG_ERROR("Couldn't find metadata tree on input. Object is unusable!");
166 return StatusCode::FAILURE;
167 }
168
169 // Set metadata entry to be read
170 // NB: no reading is done calling LoadTree
171 if (m_inMetaTree->LoadTree(0) < 0) {
172 ATH_MSG_ERROR("Failed to load entry 0 for metadata tree");
173 return StatusCode::FAILURE;
174 }
175
176 // A sanity check.
177 if (m_inMetaTree->GetEntries() != 1) {
178 ATH_MSG_WARNING("Was expecting a metadata tree with size 1, instead of "
179 << m_inMetaTree->GetEntries() << ".");
180 ATH_MSG_WARNING("The input file was most probably produced by hadd...");
181 }
182
183 // Make sure that the xAOD::EventFormat dictonary is loaded.
184 // This may not be the case if streamer information reading is turned
185 // off.
186 static const std::string eventFormatTypeName =
188 ::TClass* cl = ::TClass::GetClass(eventFormatTypeName.c_str());
189 if (cl == nullptr) {
190 ATH_MSG_WARNING("Couldn't load the xAOD::EventFormat dictionary");
191 }
192
193 // Helper lambda for collecting the event format metadata from an RNTuple
194 // with a given name.
195 auto readEventFormatMetadata =
196 [&](std::string_view thisTreeName) -> StatusCode {
197 // Look for the metadata tree:
198 TTree* metaTree = file->Get<TTree>(thisTreeName.data());
199 if (metaTree == nullptr) {
200 ATH_MSG_ERROR("Couldn't find metadata tree \"" << thisTreeName
201 << "\"on input.");
202 return StatusCode::FAILURE;
203 }
204 // Set metadata entry to be read.
205 if (metaTree->LoadTree(0) < 0) {
206 ATH_MSG_ERROR("Failed to load entry 0 for metadata tree \""
207 << thisTreeName << "\"");
208 return StatusCode::FAILURE;
209 }
210
211 // Check if the EventFormat branch is available:
212 const std::string eventFormatBranchName =
214 if (!metaTree->GetBranch(eventFormatBranchName.c_str())) {
215 // This can happen when the file was produced by an Athena job that
216 // didn't have any input events itself. This means that the file
217 // doesn't actually have any useful metadata.
218 ATH_MSG_INFO("Input file provides no event or metadata");
219 return StatusCode::RECOVERABLE;
220 }
221
222 // Read in the event format object:
223 EventFormat* format = 0;
224 ::TBranch* br = 0;
225 const Int_t status =
226 metaTree->SetBranchAddress(eventFormatBranchName.c_str(), &format, &br);
227 if (status < 0) {
228 ATH_MSG_ERROR("Failed to connect to xAOD::EventFormat object");
229 return StatusCode::FAILURE;
230 }
231
232 // Merge the object into our private member.
233 br->GetEntry(0);
234 for (const auto &[key, element] : *format) {
235 m_inputEventFormat.add(element);
236 }
237
238 // This is a strange place. The object has to be deleted, as it is the
239 // responsibility of the user code to do so. But if I also explicitly
240 // tell the branch to forget about the address of the pointer, then
241 // all hell breaks loose...
242 delete format;
243
244 // Return gracefully.
245 return StatusCode::SUCCESS;
246 };
247
248 // Read in the metadata from the "main" metadata ntuple.
250 const StatusCode sc = readEventFormatMetadata(METADATA_OBJECT_NAME);
251 if (sc.isRecoverable()) {
252 m_inTree = nullptr;
253 m_inTreeMissing = true;
254 return StatusCode::SUCCESS;
255 }
256 ATH_CHECK(sc);
257
258 // List all the other Metadata trees in the input file
259 // Having several metatrees can happen for augmented files for instance
260 // as one metadata tree per stream is produced
261 std::set<std::string> lOtherMetaTreeNames = {};
262 TList* lKeys = file->GetListOfKeys();
263
264 if (lKeys) {
265 for (int iKey = 0; iKey < lKeys->GetEntries(); iKey++) {
266 // iterate over keys and add
267 std::string keyName = lKeys->At(iKey)->GetName();
268 // Make sure the key corresponds to a metadata tree but
269 // do not add the current metadata tree in the list of other trees
270 // and do not add the metadata tree handlers to the list
271 if ((keyName != METADATA_OBJECT_NAME) &&
272 std::regex_match(keyName, m_otherMetaDataTreeNamePattern)) {
273 // Make sure key corresponds to a tree
274 const char* className = ((::TKey* )lKeys->At(iKey))->GetClassName();
275 static constexpr Bool_t LOAD = kFALSE;
276 static constexpr Bool_t SILENT = kTRUE;
277 ::TClass* cl = ::TClass::GetClass(className, LOAD, SILENT);
278 if ((cl != nullptr) && cl->InheritsFrom(::TTree::Class())) {
279 // key is corresponding to a metadata tree
280 lOtherMetaTreeNames.insert(std::move(keyName));
281 }
282 }
283 }
284 }
285
286 // Loop over the other metadata trees found (if any).
287 for (const std::string &metaTreeName : lOtherMetaTreeNames) {
288 ATH_CHECK(readEventFormatMetadata(metaTreeName));
289 }
290
291 // Look for the event tree in the input file.
292 m_inTree = file->Get<TTree>(treeName.data());
293 if (m_inTree == nullptr) {
294 // This is no longer an error condition. As it can happen for DxAODs
295 // that don't have any events in them. But they still have metadata
296 // that needs to be collected.
297 m_inTreeMissing = kTRUE;
298 }
299
300 // Turn on the cache if requested.
301 if (m_inTree && useTreeCache && (!m_inTree->GetCacheSize())) {
302 m_inTree->SetCacheSize(CACHE_SIZE);
303 m_inTree->SetCacheLearnEntries(10);
304 }
305
306 // Init the statistics collection.
308 // Update the event counter in the statistics object.
309 xAOD::ReadStats &stats = IOStats::instance().stats();
310 if (m_inTree) {
311 stats.setNEvents(stats.nEvents() + m_inTree->GetEntries());
312 }
313
314 // Notify the listeners that a new file was opened.
315 const TIncident beginIncident(IncidentType::BeginInputFile);
316 for (TVirtualIncidentListener* listener : m_listeners) {
317 listener->handle(beginIncident);
318 }
319 // For now implement a very simple scheme in which we claim already
320 // at the start that the entire file was processed. Since we have no way
321 // of ensuring that the user indeed does this. And we can't delay calling
322 // this function, as the user may likely close his/her output file before
323 // closing the last opened input file.
324 const TIncident endIncident(IncidentType::EndInputFile);
325 for (TVirtualIncidentListener* listener : m_listeners) {
326 listener->handle(endIncident);
327 }
328
329 // The initialisation was successful.
330 return StatusCode::SUCCESS;
331}
StatusCode initStats()
Function to initialise the statistics for all Tree content.
void add(std::string_view fileName)
Add information about a new file that got accessed.
static TFileAccessTracer & instance()
Access the singleton instance of this class.
static const ::Int_t EndInputFile
The processing of an input file has finished.
Definition TIncident.h:40
static const ::Int_t BeginInputFile
A new input file was just opened.
Definition TIncident.h:27
std::string getFirstBranchMatch(TTree *tree, const std::string &pre)
This function is used to search for a branch in a TTree that contains a given substring.
static const ::Int_t CACHE_SIZE
Size of a possible TTreeCache.

◆ readFrom() [3/3]

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

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
treeThe pointer to a TTree or a TChain
useTreeCacheFlag for switching TTreeCache usage on/off
Returns
The usual StatusCode tyoes

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

341 {
342
343 // Remember the info:
344 m_inTree = nullptr;
345 m_inTreeMissing = false;
346 m_inChain = dynamic_cast<TChain* >(tree);
347 m_inMetaTree = nullptr;
348
349 if (m_inChain) {
350
351 // Set up the caching on the chain level. The individual trees of the
352 // input files will get a cache set up automatically after this.
353 if (useTreeCache && (!m_inChain->GetCacheSize())) {
354 m_inChain->SetCacheSize(CACHE_SIZE);
355 m_inChain->SetCacheLearnEntries(10);
356 }
357
358 // Explicitly open the first file of the chain. To correctly auto-load
359 // the dictionaries necessary. This doesn't happen automatically with
360 // some ROOT versions...
361 const TObjArray* files = m_inChain->GetListOfFiles();
362 if (!files) {
363 ATH_MSG_ERROR("Couldn't get the list of files from the input TChain");
364 return StatusCode::FAILURE;
365 }
366 if (!files->GetEntries()) {
367 ATH_MSG_ERROR("No files are present in the received TChain");
368 return StatusCode::FAILURE;
369 }
370 const ::TChainElement* chEl =
371 dynamic_cast<const ::TChainElement* >(files->At(0));
372 if (!chEl) {
373 ATH_MSG_ERROR("Couldn't cast object to TChainElement");
374 return StatusCode::FAILURE;
375 }
376 {
377 std::unique_ptr<TFile> dummyFile{TFile::Open(chEl->GetTitle())};
378 if (!dummyFile) {
379 ATH_MSG_ERROR("Couldn't open file " << chEl->GetTitle());
380 return StatusCode::FAILURE;
381 }
382 }
383
384 // Set up a tracker for the chain.
385 if (!m_inChainTracker) {
386 m_inChainTracker = std::make_unique<TChainStateTracker>();
387 }
388 m_inChainTracker->reset();
389 tree->SetNotify(m_inChainTracker.get());
390
391 // Stop at this point. The first file will be opened when the user
392 // asks for the first event. Otherwise we open the first file of the
393 // chain multiple times.
394 m_inTreeNumber = -1;
395 return StatusCode::SUCCESS;
396
397 } else {
398
399 // If it's a simple TTree, then let's fully initialise the object
400 // using its file:
401 m_inTreeNumber = -1;
402 if (m_inChainTracker) {
403 m_inChainTracker.reset();
404 }
405 ::TFile* file = tree->GetCurrentFile();
406 return readFrom(file, useTreeCache, tree->GetName());
407 }
408}
std::vector< std::string > files
file names and file pointers
Definition hcg.cxx:52
TChain * tree

◆ record() [1/4]

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

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

◆ record() [2/4]

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

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
storeThe store object to connect to the output
keyThe "key" with which to record the object
Returns
The usual StatusCode tyoes

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

2024 {
2025
2026 // Check if we have an output tree:
2027 if (!m_outTree) {
2029 "No output tree defined. Did you forget to call writeTo(...)?");
2030 return StatusCode::FAILURE;
2031 }
2032
2033 // Check if we have a filtering rule for this key:
2034 const std::set<std::string>* filter = 0;
2035 auto filter_itr = m_auxItemList.find(key);
2036 if (filter_itr != m_auxItemList.end()) {
2037 filter = &(filter_itr->second);
2038 }
2039
2040 // Check if we need to add it to the event record:
2041 Object_t::iterator vitr = m_outputObjects.find(key);
2042 if (vitr == m_outputObjects.end()) {
2043
2044 // Configure the object for variable filtering:
2045 if (filter) {
2046 store->selectAux(*filter);
2047 }
2048 // Tell the object where to write its contents:
2049 ATH_CHECK(store->writeTo(*m_outTree));
2050 // Record it to the output list:
2051 static constexpr bool OWNS_STORE = true;
2053 std::make_unique<TAuxManager>(store.release(), OWNS_STORE);
2054
2055 // We're done:
2056 return StatusCode::SUCCESS;
2057 }
2058
2059 // Check if the output has the right store:
2060 if (vitr->second->object() == store.get()) {
2061 // We're done already:
2062 return StatusCode::SUCCESS;
2063 }
2064
2065 // If not, update the output manager. This can happen when we copy
2066 // objects from the input to the output files, and we process
2067 // multiple input files.
2068
2069 // Check if the output manager is of the right type:
2070 TAuxManager* mgr = dynamic_cast<TAuxManager* >(vitr->second.get());
2071 if (mgr == nullptr) {
2072 ATH_MSG_ERROR("Output object with key \""
2073 << key << "\" already exists, and is not of type TAuxStore");
2074 return StatusCode::FAILURE;
2075 }
2076
2077 // Configure the object for variable filtering:
2078 if (filter) {
2079 store->selectAux(*filter);
2080 }
2081
2082 // Connect the auxiliary store to the output tree:
2083 ATH_CHECK(store->writeTo(*m_outTree));
2084
2085 // Update the manager:
2086 mgr->setObject(store.release());
2087
2088 // Return gracefully:
2089 return StatusCode::SUCCESS;
2090}

◆ record() [3/4]

template<typename T>
StatusCode xAOD::Event::record ( T * obj,
const std::string & key )
inherited

Add an output object to the event.

◆ record() [4/4]

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

Record an object into a connected output file.

Definition at line 313 of file Event.h.

316 { return recordImpl( obj, typeName, key, overwrite, metadata, isOwner ); }
StatusCode recordImpl(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.

◆ recordAux() [1/3]

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

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
keyThe name/prefix of the auxiliary store object/branches
typeThe type of the auxiliary store (object/container)
Returns
An auxiliary store object that will write to the output

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

599 {
600
601 // A sanity check:
602 if (!m_outTree) {
603 ATH_MSG_ERROR("No output tree given to the object");
604 return nullptr;
605 }
606
607 // Check for an object with this name in the output list:
608 Object_t::iterator itr = m_outputObjects.find(key);
609 if (itr == m_outputObjects.end()) {
610 // Create one if if it doesn't exist yet...
611 // Translate the store type:
613 switch (type) {
616 break;
619 break;
620 default:
621 ATH_MSG_ERROR("Unknown store type (" << type << ") requested");
622 return nullptr;
623 }
624 // Create and record the object:
625 static constexpr bool TOP_STORE = true;
626 if (record(std::make_unique<TAuxStore>(this->currentContext(),
627 key, TOP_STORE, mode), key)
628 .isFailure()) {
629 ATH_MSG_ERROR("Couldn't connect TAuxStore object to the output");
630 return nullptr;
631 }
632 // Update the iterator:
633 itr = m_outputObjects.find(key);
634 }
635
636 // A security check:
637 if (itr == m_outputObjects.end()) {
638 ATH_MSG_ERROR("Internal logic error detected");
639 return nullptr;
640 }
641
642 // Check that it is of the right type:
643 TAuxManager* mgr = dynamic_cast<TAuxManager* >(itr->second.get());
644 if (!mgr) {
645 ATH_MSG_ERROR("Internal logic error detected");
646 return nullptr;
647 }
648
649 // Extract the pointer out of it:
650 TAuxStore* store = mgr->getStore();
651
652 // Give it to the user:
653 return store;
654}
@ AST_ContainerStore
The store describes a container.
@ AST_ObjectStore
The store describes a single object.
StatusCode record(std::unique_ptr< TAuxStore > store, const std::string &key)
Internal function for adding an auxiliary store object to the output.
@ kUndefinedStore
The structure mode is not defined.

◆ recordAux() [2/3]

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

Function setting up an existing auxiliary store for writing.

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

2404 {
2405
2406 // Check if we have an output tree:
2407 if (hasOutput() == false) {
2408 ATH_MSG_ERROR("No output tree set up.");
2409 return StatusCode::FAILURE;
2410 }
2411
2412 // Check if we have a filtering rule for this key:
2413 const std::set<std::string>* filter = 0;
2414 auto filter_itr = m_auxItemList.find(key);
2415 if (filter_itr != m_auxItemList.end()) {
2416 filter = &(filter_itr->second);
2417 }
2418
2419 // Check if we need to add it to the event record:
2420 Object_t::iterator vitr = m_outputObjects.find(key);
2421 if (vitr == m_outputObjects.end()) {
2422
2423 // Configure the object for variable filtering:
2424 if (filter) {
2425 store->selectAux(*filter);
2426 }
2427 // Tell the object where to write its contents:
2428 ATH_CHECK(store->writeTo(*m_outTree));
2429 // Record it to the output list.
2430 static constexpr bool OWNS_STORE = false;
2431 m_outputObjects[key] = std::make_unique<TAuxManager>(store, OWNS_STORE);
2432
2433 // We're done:
2434 return StatusCode::SUCCESS;
2435 }
2436
2437 // Check if the output has the right store:
2438 if (vitr->second->object() == store) {
2439 // We're done already:
2440 return StatusCode::SUCCESS;
2441 }
2442
2443 // If not, update the output manager. This can happen when we copy
2444 // objects from the input to the output files, and we process
2445 // multiple input files.
2446
2447 // Check if the output manager is of the right type:
2448 TAuxManager* mgr = dynamic_cast<TAuxManager* >(vitr->second.get());
2449 if (mgr == nullptr) {
2450 ATH_MSG_ERROR("Output object with key \""
2451 << key << "\" already exists, and is not of type TAuxStore");
2452 return StatusCode::FAILURE;
2453 }
2454
2455 // Configure the object for variable filtering:
2456 if (filter) {
2457 store->selectAux(*filter);
2458 }
2459
2460 // Connect the auxiliary store to the output tree:
2461 ATH_CHECK(store->writeTo(*m_outTree));
2462
2463 // Update the manager:
2464 mgr->setObject(store);
2465
2466 // Return gracefully:
2467 return StatusCode::SUCCESS;
2468}
bool hasOutput() const override
Check if an output file is connected to the object.

◆ recordAux() [3/3]

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

Record an auxiliary store into a connected output file.

Implements xAOD::Event.

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

1829 {
1830
1831 // Check if the auxiliary store is a generic object.
1832 Details::IObjectManager* iomgr = dynamic_cast<Details::IObjectManager*>(&mgr);
1833 if (iomgr != nullptr) {
1834 // Record the auxiliary object using the main record function.
1835 static const bool OVERWRITE = true;
1836 static const bool IS_OWNER = true;
1837 ATH_CHECK(record(iomgr->object(), iomgr->holder()->getClass()->GetName(),
1838 key, OVERWRITE, metadata, IS_OWNER));
1839 return StatusCode::SUCCESS;
1840 }
1841
1842 // Check if it's a TAuxStore object.
1843 TAuxManager* auxmgr = dynamic_cast<TAuxManager* >(&mgr);
1844 if (auxmgr != nullptr) {
1845 // This type has to be an event object.
1846 if (metadata) {
1848 "TAuxStore auxiliary objects can only be recorded for event data");
1849 return StatusCode::FAILURE;
1850 }
1851 // Record the auxiliary object with the dedicated record function.
1852 ATH_CHECK(recordAux(auxmgr->getStore(), key));
1853 return StatusCode::SUCCESS;
1854 }
1855
1856 // Apparently we didn't recorgnize the auxiliary store type.
1857 ATH_MSG_ERROR("Unknown auxiliary store manager type encountered");
1858 return StatusCode::FAILURE;
1859}
SG::IAuxStore * recordAux(const std::string &key, SG::IAuxStoreHolder::AuxStoreType type=SG::IAuxStoreHolder::AST_ContainerStore)
Add an auxiliary store object to the output.

◆ recordImpl()

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

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
objA typeless pointer to the object that we want to record
typeNameThe type name of the output object
keyThe key (branch name) of the object to record
overwriteFlag selecting if it is allowed to overwrite an already existing object (used internally)
metadataFlag selecting if we are writing an event or a metadata object
isOwnerFlag selecting if we should take ownership of the object or not
Returns
The usual StatusCode tyoes

Implements xAOD::Event.

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

1699 {
1700
1701 // Check if we have an output tree when writing an event:
1702 if (!m_outTree && !metadata) {
1704 "No output tree defined. Did you forget to call writeTo(...)?");
1705 return StatusCode::FAILURE;
1706 }
1707 assert(m_outputEventFormat != 0);
1708
1709 // If this is metadata, just take ownership of it. The object will only
1710 // be recorded into the output file when calling finishWritingTo(...).
1711 if (metadata) {
1712 // Check whether we already have such an object:
1713 if ((!overwrite) &&
1714 (m_outputMetaObjects.find(key) != m_outputMetaObjects.end())) {
1715 ATH_MSG_ERROR("Meta-object \"" << typeName << "\"/\"" << key
1716 << "\" already recorded");
1717 return StatusCode::FAILURE;
1718 }
1719 // Check if we have a dictionary for this object:
1720 TClass* cl = TClass::GetClass(typeName.c_str());
1721 if (!cl) {
1722 ATH_MSG_ERROR("Didn't find dictionary for type: " << typeName);
1723 return StatusCode::FAILURE;
1724 }
1725 // Let's create a holder for the object:
1726 const bool renewOnRead = (m_auxMode == kAthenaAccess);
1727 m_outputMetaObjects[key] = std::make_unique<TObjectManager>(
1728 nullptr, std::make_unique<THolder>(obj, cl, isOwner), renewOnRead);
1729 // We're done. The rest will be done later on.
1730 return StatusCode::SUCCESS;
1731 }
1732
1733 // Check if we accessed this object on the input. If yes, then this
1734 // key may not be used for recording.
1735 if ((!overwrite) && (m_inputObjects.find(key) != m_inputObjects.end())) {
1736 ATH_MSG_ERROR("Object \"" << typeName << "\"/\"" << key
1737 << "\" already accessed from the input, can't be "
1738 "overwritten in memory");
1739 return StatusCode::FAILURE;
1740 }
1741
1742 // Choose a split level.
1743 const Int_t splitLevel = (key.ends_with("Aux.") ? 1 : 0);
1744
1745 // Check if we need to add it to the event record:
1746 Object_t::iterator vitr = m_outputObjects.find(key);
1747 if (vitr == m_outputObjects.end()) {
1748
1749 // Check if we have a dictionary for this object:
1750 TClass* cl = TClass::GetClass(typeName.c_str());
1751 if (cl == nullptr) {
1752 ATH_MSG_ERROR("Didn't find dictionary for type: " << typeName);
1753 return StatusCode::FAILURE;
1754 }
1755
1756 // Check if this is a new object "type" or not.
1757 if (!m_outputEventFormat->exists(key)) {
1759 EventFormatElement(key, cl->GetName(), "", getHash(key)));
1760 }
1761
1762 // Let's create a holder for the object.
1763 const bool renewOnRead = (m_auxMode == kAthenaAccess);
1764 auto mgr = std::make_unique<TObjectManager>(
1765 nullptr, std::make_unique<THolder>(obj, cl, isOwner), renewOnRead);
1766 TObjectManager* mgrPtr = mgr.get();
1767 m_outputObjects[key] = std::move(mgr);
1768
1769 // ... and let's add it to the output TTree.
1770 static constexpr Int_t basketSize = 32000;
1771 *(mgrPtr->branchPtr()) =
1772 m_outTree->Branch(key.c_str(), cl->GetName(),
1773 mgrPtr->holder()->getPtr(), basketSize, splitLevel);
1774 if (!mgrPtr->branch()) {
1775 ATH_MSG_ERROR("Failed to create branch \"" << key << "\" out of type \""
1776 << cl->GetName() << "\"");
1777 // Clean up:
1778 mgrPtr->holder()->setOwner(kFALSE);
1779 return StatusCode::FAILURE;
1780 }
1781
1782 // Set up the saving of all the dynamic auxiliary properties
1783 // of the object if it has any:
1784 static constexpr bool METADATA = false;
1785 ATH_CHECK(putAux(*m_outTree, *mgrPtr, METADATA));
1786
1787 // Return at this point, as we don't want to run the rest of
1788 // the function's code:
1789 return StatusCode::SUCCESS;
1790 }
1791
1792 // Access the object manager:
1793 TObjectManager* omgr = dynamic_cast<TObjectManager* >(vitr->second.get());
1794 if (!omgr) {
1795 ATH_MSG_ERROR("Manager object of the wrong type encountered");
1796 return StatusCode::FAILURE;
1797 }
1798
1799 // Check that the type of the object matches that of the previous
1800 // object:
1801 if (typeName != omgr->holder()->getClass()->GetName()) {
1802 // This may still be, when the ROOT dictionary name differs from the
1803 // "simple type name" known to C++. So let's get the ROOT name of the
1804 // new type:
1805 TClass* cl = TClass::GetClass(typeName.c_str());
1806 if ((!cl) ||
1807 ::strcmp(cl->GetName(), omgr->holder()->getClass()->GetName())) {
1808 ATH_MSG_ERROR("For output key \""
1809 << key << "\" the previous type was \""
1810 << omgr->holder()->getClass()->GetName()
1811 << "\", but the newly requested type is \"" << typeName
1812 << "\"");
1813 return StatusCode::FAILURE;
1814 }
1815 }
1816
1817 // Replace the managed object.
1818 omgr->setObject(obj);
1819
1820 // Replace the auxiliary objects.
1821 static constexpr bool METADATA = false;
1822 ATH_CHECK(putAux(*m_outTree, *omgr, METADATA));
1823
1824 // Return gracefully.
1825 return StatusCode::SUCCESS;
1826}

◆ 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.

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

◆ 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.

313 {
314
315 return;
316}

◆ 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
listenerPointer to the listener that should be removed
Returns
The usual StatusCode types

Definition at line 135 of file EventCore.cxx.

135 {
136
137 // Remove the listener. Or at least try to...
138 auto itr = std::find(m_listeners.begin(), m_listeners.end(), listener);
139 if (itr == m_listeners.end()) {
140 ATH_MSG_ERROR("Listener " << static_cast<void*>(listener) << " not known");
141 return StatusCode::FAILURE;
142 }
143 m_listeners.erase(itr);
144
145 // Return gracefully:
146 return StatusCode::SUCCESS;
147}

◆ 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 63 of file EventCore.cxx.

63 {
64
65 // The active event and current store are thread-local globals.
66 Event* nc_this ATLAS_THREAD_SAFE = const_cast<Event*>(this);
67 TActiveEvent::setEvent(static_cast<TVirtualEvent*>(nc_this));
68#ifndef XAOD_STANDALONE
70#endif // not XAOD_STANDALONE
71}
static void setEvent(TVirtualEvent *ptr)
Set the active event pointer.
void setProxyDictInEventContext(IProxyDict *sg)
Update the IProxyDict in the current EventContext.

◆ 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
containerKeyThe name of the auxiliary container in question
itemListThe variable list according to the formatting rules

Definition at line 80 of file EventCore.cxx.

81 {
82
83 // Decoded attributes.
84 std::set<std::string> attributes;
85
86 // Split up the received string using "." as the separator.
87 if (itemList.size()) {
88 std::istringstream ss(itemList);
89 std::string attr;
90 while (std::getline(ss, attr, '.')) {
91 attributes.insert(attr);
92 }
93 }
94
95 // Remember the setting.
96 m_auxItemList[containerKey] = std::move(attributes);
97}
static Double_t ss

◆ setAuxStore()

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

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
mgrThe manager object of the DV container
metadataFlag specifying whether we're dealing with a metadata or event data object
Returns
The usual StatusCode types

Implements xAOD::Event.

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

1505 {
1506
1507 // Pre-compute some values.
1508 const bool isAuxStore = Details::isAuxStore(*(mgr.holder()->getClass()));
1509
1510 // Check if we need to do anything.
1511 if ((Details::hasAuxStore(*(mgr.holder()->getClass())) == false) &&
1512 (isAuxStore == false)) {
1513 return StatusCode::SUCCESS;
1514 }
1515
1516 // Select which object container to use:
1518
1519 // Look up the auxiliary object's manager:
1520 TVirtualManager* auxMgr = nullptr;
1521 std::string auxKey;
1522 if (isAuxStore) {
1523 auxMgr = &mgr;
1524 auxKey = key;
1525 } else {
1526 auto itr = objects.find(key + "Aux.");
1527 if (itr == objects.end()) {
1528 // Apparently there's no auxiliary object for this DV, so let's
1529 // give up:
1530 return StatusCode::SUCCESS;
1531 }
1532 auxMgr = itr->second.get();
1533 auxKey = key + "Aux.";
1534 }
1535
1536 if (metadata == false) {
1537 // Make sure the auxiliary object is up to date:
1538 const ::Int_t readBytes = auxMgr->getEntry();
1539 if (readBytes < 0) {
1541 "Couldn't load current entry for auxiliary object with key \""
1542 << auxKey << "\"");
1543 return StatusCode::FAILURE;
1544 }
1545
1546 // Check if there is a separate auxiliary object for the dynamic
1547 // variables:
1548 const std::string dynAuxKey = auxKey + "Dynamic";
1549 auto dynAuxMgr = objects.find(dynAuxKey);
1550
1551 if ((dynAuxMgr != objects.end()) &&
1552 (readBytes || (m_auxMode == kAthenaAccess) || (auxMgr == &mgr))) {
1553 // Do different things based on the access mode:
1554 if (m_auxMode != kAthenaAccess) {
1555 // In "normal" access modes just tell the dynamic store object
1556 // to switch to a new event.
1557 dynAuxMgr->second->getEntry();
1558 } else {
1559 // In "Athena mode" this object has already been deleted when
1560 // the main auxiliary store object was switched to the new
1561 // event. So let's re-create it:
1562 xAOD::TObjectManager &auxMgrRef =
1563 dynamic_cast<xAOD::TObjectManager &>(*auxMgr);
1564 ATH_CHECK(
1565 setUpDynamicStore(auxMgrRef, (metadata ? m_inMetaTree : m_inTree)));
1566 // Now tell the newly created dynamic store object which event
1567 // it should be looking at:
1568 auto dynAuxMgr = objects.find(dynAuxKey);
1569 if (dynAuxMgr == objects.end()) {
1570 ATH_MSG_ERROR("Internal logic error detected");
1571 return StatusCode::FAILURE;
1572 }
1573 dynAuxMgr->second->getEntry();
1574 }
1575 }
1576 }
1577
1578 // Stop here if we've set up an auxiliary store.
1579 if (isAuxStore) {
1580 return StatusCode::SUCCESS;
1581 }
1582
1583 // Access the auxiliary base class of the object/vector:
1584 SG::AuxVectorBase* vec = 0;
1585 SG::AuxElement* aux = 0;
1586 switch (mgr.holder()->typeKind()) {
1587 case THolder::DATAVECTOR: {
1588 void* vvec = mgr.holder()->getAs(typeid(SG::AuxVectorBase));
1589 vec = reinterpret_cast<SG::AuxVectorBase*>(vvec);
1590 } break;
1591 case THolder::AUXELEMENT: {
1592 void* vaux = mgr.holder()->getAs(typeid(SG::AuxElement));
1593 aux = reinterpret_cast<SG::AuxElement*>(vaux);
1594 } break;
1595 default:
1596 break;
1597 }
1598
1599 // Check whether index tracking is enabled for the type. If not, then
1600 // we need to fix it...
1601 if (vec && (!vec->trackIndices())) {
1602 Details::forceTrackIndices(*vec);
1603 }
1604
1605 // Check if we were successful:
1606 if ((!vec) && (!aux)) {
1607 ATH_MSG_FATAL("Couldn't access class \""
1608 << mgr.holder()->getClass()->GetName()
1609 << "\" as SG::AuxVectorBase or SG::AuxElement");
1610 return StatusCode::FAILURE;
1611 }
1612
1613 // Get the auxiliary store object:
1614 const SG::IConstAuxStore* store = 0;
1615#ifndef XAOD_STANDALONE
1616 SG::IAuxStore* store_nc = 0;
1617#endif
1618 if (m_auxMode == kBranchAccess) {
1619 // Get the concrete auxiliary manager:
1620 TAuxManager* amgr = dynamic_cast<TAuxManager* >(auxMgr);
1621 if (!amgr) {
1622 ATH_MSG_FATAL("Auxiliary manager for \""
1623 << auxKey << "\" is not of the right type");
1624 return StatusCode::FAILURE;
1625 }
1626 store = amgr->getConstStore();
1627 // If the store still doesn't know its type, help it now:
1628 if (amgr->getStore()->structMode() ==
1633 amgr->getStore()->setStructMode(mode);
1634 }
1635#ifndef XAOD_STANDALONE
1636 store_nc = amgr->getStore();
1637#endif
1638 } else if (m_auxMode == kClassAccess || m_auxMode == kAthenaAccess) {
1639 // Get the concrete auxiliary manager:
1640 TObjectManager* omgr = dynamic_cast<TObjectManager* >(auxMgr);
1641 if (!omgr) {
1642 ATH_MSG_FATAL("Auxiliary manager for \""
1643 << auxKey << "\" is not of the right type");
1644 return StatusCode::FAILURE;
1645 }
1646 void* p = omgr->holder()->getAs(typeid(SG::IConstAuxStore));
1647 SG::IConstAuxStore* store1 = reinterpret_cast<SG::IConstAuxStore* >(p);
1648 store = store1;
1649#ifndef XAOD_STANDALONE
1650 store_nc = dynamic_cast<SG::IAuxStore*>(store1);
1651#endif
1652 }
1653 if (!store) {
1654 ATH_MSG_FATAL("Logic error detected in the code");
1655 return StatusCode::FAILURE;
1656 }
1657
1658#ifndef XAOD_STANDALONE
1659 // Call toTransient on the aux store.
1660 if (store_nc)[[likely]] {
1661 store_nc->toTransient( this->currentContext() );
1662 } else {
1663 ATH_MSG_FATAL("Logic error detected in the code");
1664 return StatusCode::FAILURE;
1665 }
1666#endif
1667
1668 // Connect the two:
1669 if (vec) {
1670 vec->setStore(store);
1671 } else if (aux) {
1672 aux->setStore(store);
1673 } else {
1674 ATH_MSG_FATAL("Logic error detected in the code");
1675 return StatusCode::FAILURE;
1676 }
1677
1678 // We succeeded:
1679 return StatusCode::SUCCESS;
1680}
std::vector< size_t > vec
virtual void toTransient(const EventContext &ctx)=0
Perform post-read processing on this store.
@ DATAVECTOR
A DataVector container.
Definition THolder.h:105
@ AUXELEMENT
A type inheriting from SG::AuxElement.
Definition THolder.h:106
AuxElement(SG::AuxVectorData *container, size_t index)
Base class for elements of a container that can have aux data.
#define likely(x)

◆ 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.

29{
30 m_lvl = lvl;
31}

◆ setOtherMetaDataTreeNamePattern()

void xAOD::TEvent::setOtherMetaDataTreeNamePattern ( const std::string & pattern)
inherited

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

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

◆ setUpDynamicStore()

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

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
mgrThe object manager of the auxiliary store object
treeThe tree to read dynamic variables from
Returns
The usual StatusCode types

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

2100 {
2101
2102 // Check if we can call setName(...) on the object:
2103 ::TMethodCall setNameCall;
2104 // Don't use this code in Athena access mode. And just accept that access
2105 // monitoring is disabled in this case...
2106 if (m_auxMode != kAthenaAccess) {
2107 setNameCall.InitWithPrototype(mgr.holder()->getClass(), "setName",
2108 "const char*");
2109 if (setNameCall.IsValid()) {
2110 // Yes, there is such a function. Let's call it with the branch
2111 // name:
2112 const ::TString params =
2113 ::TString::Format("\"%s\"", mgr.branch()->GetName());
2114 const char* charParams = params.Data();
2115 setNameCall.Execute(mgr.holder()->get(), charParams);
2116 } else {
2117 // This is weird. What sort of auxiliary container is this? :-/
2118 ATH_MSG_WARNING("Couldn't find setName(...) function for container \""
2119 << mgr.branch()->GetName() << "\" (type: "
2120 << mgr.holder()->getClass()->GetName() << ")");
2121 }
2122 }
2123
2124 // Check if we can switch out the internal store of this object:
2125 static const TClass* const holderClass =
2126 TClass::GetClass(typeid(SG::IAuxStoreHolder));
2127 if (!mgr.holder()->getClass()->InheritsFrom(holderClass)) {
2128 // Nope... So let's just end the journey here.
2129 return StatusCode::SUCCESS;
2130 }
2131
2132 // Try to get the object as an IAuxStoreHolder:
2133 SG::IAuxStoreHolder* storeHolder = reinterpret_cast<SG::IAuxStoreHolder* >(
2134 mgr.holder()->getAs(typeid(SG::IAuxStoreHolder)));
2135 if (!storeHolder) {
2136 ATH_MSG_FATAL("There's a logic error in the code");
2137 return StatusCode::FAILURE;
2138 }
2139
2140 // Create a TAuxStore instance that will read the dynamic variables
2141 // of this container. Notice that the TAuxManager doesn't own the
2142 // TAuxStore object. It will be owned by the SG::IAuxStoreHolder
2143 // object.
2144 static constexpr bool TOP_STORE = false;
2145 const EventContext& ctx = this->currentContext();
2146 auto store = std::make_unique<TAuxStore>(
2147 ctx, mgr.branch()->GetName(), TOP_STORE,
2151 // This object is used to read data from the input, it needs to be
2152 // locked:
2153 store->lock();
2154
2155 // Set it up to read from the input TTree.
2156 ATH_CHECK(store->readFrom(*tree));
2157 // Tell the auxiliary store which entry to use. This is essential for
2158 // metadata objects, and non-important for event data objects, which will
2159 // get a possibly different entry loaded in setAuxStore(...).
2160 store->getEntry(0);
2161
2162 // Set up a manager for it.
2163 static constexpr bool SHARED_OWNER = false;
2164 m_inputObjects[std::string(mgr.branch()->GetName()) + "Dynamic"] =
2165 std::make_unique<TAuxManager>(store.get(), SHARED_OWNER);
2166
2167 // Give this object to the store holder:
2168 storeHolder->setStore(store.release());
2169
2170 // Return gracefully:
2171 return StatusCode::SUCCESS;
2172}
virtual AuxStoreType getStoreType() const =0
Return the type of the store object.
virtual void setStore(IAuxStore *store)=0
Give an auxiliary store object to the holder object.

◆ 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.

298 {
299
300 return getHash(str);
301}

◆ TEvent() [1/3]

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

Constructor connecting the object to an input TFile.

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

78 : TEvent(mode) {
79
80 // Let the initialisation function deal with setting up the object.
81 readFrom(file).ignore();
82}
TEvent(EAuxMode mode=kClassAccess, const EventContext *ctx=nullptr)
Default constructor.

◆ TEvent() [2/3]

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

Constructor connecting the objects to an input TTree/TChain.

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

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

◆ TEvent() [3/3]

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

Default constructor.

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

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

◆ 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.

◆ updateObjectsForEntry()

void xAOD::RDataSourceEvent::updateObjectsForEntry ( Long64_t entry)

Update all objects in memory for a new event.

Definition at line 109 of file RDataSourceEvent.cxx.

109 {
110
111 // Make sure that this is the active event in the current thread.
112 setActive();
113
114 // Switch to the new entry.
115 if( getEntry( entry ) < 0 ) {
116 ::Error( "xAOD::RDataSourceEvent::updateObjectsForEntry",
117 XAOD_MESSAGE( "Failed to get entry %lld" ), entry );
118 throw std::runtime_error( "Failed to get entry" );
119 }
120
121 // Loop over all "registered" objects.
122 for( auto& obj : m_objects ) {
123 // (Re-)Access this object.
124 static constexpr bool SILENT = false;
125 static constexpr bool METADATA = false;
126 obj.second = getInputObject( obj.first.first, *( obj.first.second ),
127 SILENT, METADATA );
128 }
129
130 // Return gracefully.
131 return;
132 }

◆ writeTo() [1/2]

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

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
fileThe file that the event data should be written to
autoFlushThe auto-flush setting to use on the output TTree
treeNameName of the output event tree
Returns
The usual StatusCode tyoes

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

435 {
436
437 // Just a simple security check.
438 if (!file) {
439 ATH_MSG_ERROR("Null pointer received!");
440 return StatusCode::FAILURE;
441 }
442
443 // Check that the object is in the "right state":
444 if (m_outTree) {
445 ATH_MSG_ERROR("Object already writing to a file. Close that file first!");
446 return StatusCode::FAILURE;
447 }
448
449 // Make sure we return to the current directory:
450 TDirectoryReset dr;
451
452 // Create the output TTree:
453 file->cd();
454 m_outTree = std::make_unique<TTree>(treeName.data(), "xAOD event tree");
455 m_outTree->SetDirectory(file);
456 m_outTree->SetAutoSave(1000000);
457 m_outTree->SetAutoFlush(autoFlush);
458
459 // Access the EventFormat object associated with this file:
462
463 // Return gracefully:
464 return StatusCode::SUCCESS;
465}
static const TEventFormatRegistry & instance()
Access the only instance of the object in memory.
EventFormat & getEventFormat(const TFile *file) const
Access the managed EventFormat object.

◆ writeTo() [2/2]

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

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
fileThe file that the event data should be written to
Returns
The usual StatusCode tyoes

Implements xAOD::Event.

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

417 {
418
419 // Forward call
421
422 // Return gracefully:
423 return StatusCode::SUCCESS;
424}
StatusCode writeTo(TFile &file) override
Connect the object to an output file.

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

◆ m_auxMode

EAuxMode xAOD::TEvent::m_auxMode
protectedinherited

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

◆ m_ctx

EventContext xAOD::Event::m_ctx
protectedinherited

The event context associated with this event.

Definition at line 414 of file Event.h.

◆ m_entry

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

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.

135{ nullptr };

◆ m_inChain

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

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
protectedinherited

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
protectedinherited

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

◆ m_inputMetaObjects

Object_t xAOD::Event::m_inputMetaObjects
protectedinherited

Collection of all the managed input meta-objects.

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

◆ m_inputObjects

Object_t xAOD::Event::m_inputObjects
protectedinherited

Collection of all the managed input objects.

Definition at line 348 of file Event.h.

◆ m_inTree

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

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
protectedinherited

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
protectedinherited

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 369 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.

138{ 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 372 of file Event.h.

◆ m_nm

std::string AthMessaging::m_nm
privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_objects

std::unordered_map< Key_t, const void*, key_hash > xAOD::RDataSourceEvent::m_objects
private

Objects served to RDataFrame.

Definition at line 57 of file RDataSourceEvent.h.

◆ m_otherMetaDataTreeNamePattern

std::regex xAOD::TEvent::m_otherMetaDataTreeNamePattern
protectedinherited
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 363 of file Event.h.

◆ m_outputMetaObjects

Object_t xAOD::Event::m_outputMetaObjects
protectedinherited

Collection of all the managed output meta-objects.

Definition at line 358 of file Event.h.

◆ m_outputObjects

Object_t xAOD::Event::m_outputObjects
protectedinherited

Collection of all the managed output object.

Definition at line 353 of file Event.h.

◆ m_outTree

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

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 375 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: