xAOD::TPyEvent Class Reference

Python interface to xAOD::TEvent. More...

#include <TPyEvent.h>

Inheritance diagram for xAOD::TPyEvent:

Collaboration diagram for xAOD::TPyEvent:

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

Public Member Functions
	TPyEvent (EAuxMode mode=kUndefinedAccess)
	Constructor with an access mode - only that one is used from the python TPyEvent. More...
::Bool_t	contains (const std::string &key, const std::string &type)
	Function checking if an object is available from the store. More...
::Bool_t	transientContains (const std::string &key, const std::string &type) const
	Function checking if an object is already in memory. More...
StatusCode	record (int dummy, void *obj, const std::string &key, const std::string &type, ::Int_t basketSize=32000, ::Int_t splitLevel=0)
	Add an output object to the event. More...
EAuxMode	auxMode () const
	Get what auxiliary access mode the object was constructed with. More...
std::string	dump ()
	Function creating a user-readable dump of the current input. More...
void	printIOStats () const
	Function printing the I/O statistics of the current process. More...
void	setPrintEventProxyWarnings (bool)
	Function to silence warnings associated with broken element links. More...
template<typename T >
bool	retrieve (const T *&obj, sgkey_t key=DEFAULT_KEY, bool silent=false)
	Function retrieving an object from the event (constant version) More...
template<typename T >
bool	retrieve (const T *&obj, const std::string &key, bool silent=false)
	Function retrieving an object from the event (constant version) More...
template<typename T >
void	keys (std::vector< std::string > &vkeys, bool metadata=false) const
	provide list of all keys associated with provided type. More...

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

Protected Types
typedef std::unordered_map< std::string, TVirtualManager * >	Object_t
	Definition of the internal data structure type. More...
typedef std::vector< TVirtualIncidentListener * >	Listener_t
	Definition of the structure type holding on to listeners. More...

Protected Member Functions
::Bool_t	contains (const std::string &key, const std::type_info &ti, ::Bool_t metadata=kFALSE)
	Internal function checking if an object is in the input. More...
::Bool_t	transientContains (const std::string &key, const std::type_info &ti, ::Bool_t metadata=kFALSE) const
	Internal function checking if an object is already in memory. More...
StatusCode	record (TAuxStore *store, const std::string &key, ::Int_t basketSize, ::Int_t splitLevel, ::Bool_t ownsStore=kFALSE)
	Internal function for adding an auxiliary store object to the output. More...
void *	getOutputObject (const std::string &key, const std::type_info &ti, ::Bool_t metadata=kFALSE) const
	Function for retrieving an output object in a non-template way. More...
const void *	getInputObject (const std::string &key, const std::type_info &ti, ::Bool_t silent=kFALSE, ::Bool_t metadata=kFALSE)
	Function for retrieving an input object in a non-template way. More...
StatusCode	initStats ()
	Function to initialise the statistics for all Tree content. More...
StatusCode	connectBranch (const std::string &key, ::Bool_t silent=kFALSE)
	Function setting up access to a particular branch. More...
StatusCode	connectMetaBranch (const std::string &key, ::Bool_t silent=kFALSE)
	Function setting up access to a branch in the metadata tree. More...
StatusCode	connectAux (const std::string &prefix, ::Bool_t standalone)
	Function setting up access to a set of auxiliary branches. More...
StatusCode	connectMetaAux (const std::string &prefix, ::Bool_t standalone)
	Function setting up access to a set of auxiliary branches for a metadata object. More...
StatusCode	setUpDynamicStore (TObjectManager &mgr, ::TTree *tree)
	Function adding dynamic variable reading capabilities to an auxiliary store object. More...
StatusCode	setAuxStore (TObjectManager &mgr, ::Bool_t metadata=kFALSE)
	Function connecting a DV object to its auxiliary store. More...
StatusCode	putAux (::TTree &outTree, TVirtualManager &mgr, ::Int_t basketSize=32000, ::Int_t splitLevel=0, ::Bool_t metadata=kFALSE)
	Function saving the dynamically created auxiliary properties. More...

Static Protected Member Functions
::Bool_t	hasAuxStore (const TObjectManager &mgr)
	Function checking if a given object may have an auxiliary store. More...
::Bool_t	isAuxStore (const TObjectManager &mgr)
	Function checking if a given object may be an auxiliary store. More...
::Bool_t	isStandalone (const TObjectManager &mgr)
	Function checking if an object is standalone (not a container) More...

Protected Attributes
EAuxMode	m_auxMode
	The auxiliary access mode. More...
::TTree *	m_inTree
	The main tree that we are reading from. More...
::Bool_t	m_inTreeMissing
	Internal status flag showing that an input file is open, but it doesn't contain an event tree. More...
::TChain *	m_inChain
	The (optional) chain provided as input. More...
TChainStateTracker *	m_inChainTracker
	Optional object for tracking the state changes of an input TChain. More...
::Int_t	m_inTreeNumber
	The number of the currently open tree in the input chain. More...
::TTree *	m_inMetaTree
	Pointer to the metadata tree in the input file. More...
::Long64_t	m_entry
	The entry to look at from the input tree. More...
::TTree *	m_outTree
	The tree that we are writing to. More...
Object_t	m_inputObjects
	Collection of all the managed input objects. More...
std::set< std::string >	m_inputMissingObjects
	Objects that have been asked for, but were found to be missing in the current input. More...
Object_t	m_outputObjects
	Collection of all the managed output object. More...
Object_t	m_inputMetaObjects
	Collection of all the managed input meta-objects. More...
Object_t	m_outputMetaObjects
	Collection of all the managed output meta-objects. More...
EventFormat	m_inputEventFormat
	Format of the current input file. More...
EventFormat *	m_outputEventFormat
	Format of the current output file. More...
std::unordered_map< std::string, std::set< std::string > >	m_auxItemList
	Rules for selecting which auxiliary branches to write. More...
Listener_t	m_listeners
	Listeners who should be notified when certain incidents happen. More...
std::unordered_map< std::string, std::string >	m_nameRemapping
	Container name re-mapping rules. More...
Bool_t	m_printEventProxyWarnings = true
	Option to silence common warnings that seem to be harmless. More...

Static Protected Attributes
static const ::Int_t	CACHE_SIZE = -1
	Size of a possible TTreeCache (30 MB) More...
static const char *const	EVENT_TREE_NAME = "CollectionTree"
	Name of the event tree. More...
static const char *const	METADATA_TREE_NAME = "MetaData"
	Name of the metadata tree. More...

Functions implementing the xAOD::TVirtualEvent interface
StatusCode	record (void *obj, const std::string &typeName, const std::string &key, ::Int_t basketSize, ::Int_t splitLevel, ::Bool_t overwrite=kFALSE, ::Bool_t metadata=kFALSE, ::Bool_t isOwner=kTRUE)
	Internal function for recording an object into the output. More...
SG::sgkey_t	getHash (const std::string &key) const override
	Function returning the hash describing an object name. More...
SG::sgkey_t	getKey (const void *obj) const override
	Function returning the hash describing a known object. More...
const std::string &	getName (const void *obj) const override
	Function returning the key describing a known object. More...
const std::string &	getName (SG::sgkey_t hash) const override
	Function returning the key describing a known object. More...
void *	getOutputObject (SG::sgkey_t key, const std::type_info &ti) override
	Function for retrieving an output object in a non-template way. More...
const void *	getInputObject (SG::sgkey_t key, const std::type_info &ti, bool silent=false) override
	Function for retrieving an input object in a non-template way. More...
void	getNames (const std::string &targetClassName, std::vector< std::string > &vkeys, bool metadata=false) const override
	Function determining the list keys associated with a type name. More...

Variable(s) used in the IProxyDict implementation
typedef AthContainers_detail::upgrade_mutex	upgrade_mutex_t
	Mutex and lock for multithread synchronization. More...
typedef AthContainers_detail::upgrading_lock< upgrade_mutex_t >	upgrading_lock_t
upgrade_mutex_t	m_branchesMutex
SG::SGKeyMap< BranchInfo > m_branches	ATLAS_THREAD_SAFE
	Map from hashed sgkey to BranchInfo. More...

Detailed Description

Python interface to xAOD::TEvent.

In order to make it possible to record objects that are created in Python, into an xAOD::TEvent object (in order to record selected objects into an output file for instance), this class extends the xAOD::TEvent object with some non-template functions. Functions that are inconvenient to use from C++, but which allow for much more flexibility in PyROOT.

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 29 of file TPyEvent.h.

Member Typedef Documentation

Listener_t

typedef std::vector< TVirtualIncidentListener* > xAOD::TEvent::Listener_t

protectedinherited

Definition of the structure type holding on to listeners.

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

Object_t

typedef std::unordered_map< std::string, TVirtualManager* > xAOD::TEvent::Object_t

protectedinherited

Definition of the internal data structure type.

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

sgkey_t

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

inherited

Definition at line 35 of file TVirtualEvent.h.

upgrade_mutex_t

typedef AthContainers_detail::upgrade_mutex xAOD::TEvent::upgrade_mutex_t

protectedinherited

Mutex and lock for multithread synchronization.

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

upgrading_lock_t

typedef AthContainers_detail::upgrading_lock< upgrade_mutex_t > xAOD::TEvent::upgrading_lock_t

protectedinherited

Definition at line 483 of file Control/xAODRootAccess/xAODRootAccess/TEvent.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.
kUndefinedAccess	Undefined, to be selected by the object.

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

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

Constructor & Destructor Documentation

TPyEvent()

xAOD::TPyEvent::TPyEvent ( EAuxMode  mode = kUndefinedAccess )

inline

Constructor with an access mode - only that one is used from the python TPyEvent.

Definition at line 33 of file TPyEvent.h.

: TEvent(mode) {} 

Member Function Documentation

addListener()

StatusCode xAOD::TEvent::addListener ( TVirtualIncidentListener *  listener )

inherited

Register an incident listener object.

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

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

Parameters

listener

Pointer to the object that should be notified

Returns

The usual StatusCode types

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

                                                                      {
 
      // Check that we received a valid pointer:
      if( ! listener ) {
         ::Error( "xAOD::TEvent::addListener",
                  XAOD_MESSAGE( "Received a null pointer for the listener" ) );
         return StatusCode::FAILURE;
      }
 
      // Check if this listener is already in our list:
      bool listenerKnown = false;
      for( TVirtualIncidentListener* l : m_listeners ) {
         if( l == listener ) {
            ::Warning( "xAOD::TEvent::addListener",
                       "Listener %p was added previously already",
                       static_cast< void* >( listener ) );
            listenerKnown = true;
            break;
         }
      }
 
      // If we don't know it yet, let's add it now:
      if( ! listenerKnown ) {
         m_listeners.push_back( listener );
      }
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

addNameRemap()

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

inherited

Add a name re-mapping rule.

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

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

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

Parameters

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

Returns

The usual StatusCode types

Save the new name association:

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

                                                                {
 
      // Check if this name is known on the input or output already. As that's
      // not good.
      if( m_inputEventFormat.exists( newName ) ) {
         ::Error( "xAOD::TEvent::addNameRemap",
                  XAOD_MESSAGE( "Can't use \"%s\" as the target name in the"
                                "\"%s\" -> \"%s\" remapping" ),
                  newName.c_str(), onfile.c_str(), newName.c_str() );
         return StatusCode::FAILURE;
      }
 
      // Check if this name was remapped to something already:
      auto itr = m_nameRemapping.find( newName );
      if( itr != m_nameRemapping.end() ) {
         ::Warning( "xAOD::TEvent::addNameRemap",
                    "Overriding existing name remapping \"%s\" -> \"%s\"",
                    itr->second.c_str(), itr->first.c_str() );
         ::Warning( "xAOD::TEvent::addNameRemap", "  with: \"%s\" -> \"%s\"",
                    onfile.c_str(), newName.c_str() );
      }
 
      m_nameRemapping[ newName ] = onfile;
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

addToStore()

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

overrideprotectedinherited

Add a new proxy to the store.

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

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

Parameters

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

Definition at line 385 of file TEventProxyDict.cxx.

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

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

                                        {
 
      return m_auxMode;
   }

clearListeners()

void xAOD::TEvent::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 971 of file Control/xAODRootAccess/Root/TEvent.cxx.

                               {
 
      m_listeners.clear();
      return;
   }

clearNameRemap()

void xAOD::TEvent::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 1025 of file Control/xAODRootAccess/Root/TEvent.cxx.

                               {
 
      m_nameRemapping.clear();
      return;
   }

connectAux()

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

protectedinherited

Function setting up access to a set of auxiliary branches.

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

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

Parameters

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

Returns

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

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

                                                       {
 
      // A simple test...
      if( ! m_inTree ) {
         ::Error( "xAOD::TEvent::connectAux",
                  XAOD_MESSAGE( "No input tree is available" ) );
         return StatusCode::FAILURE;
      }
 
      // Check if we know anything about this auxiliary object:
      if( ( ! m_inTree->GetBranch( prefix.c_str() ) ) &&
          ( m_auxMode == kClassAccess || m_auxMode == kAthenaAccess ) ) {
         // If not, then let's just return right away. Not having
         // an auxiliary object with this name is not an error per se.
         return StatusCode::SUCCESS;
      }
 
      // Check if the branch is already connected:
      if( m_inputObjects.find( prefix ) != m_inputObjects.end() ) {
         return StatusCode::SUCCESS;
      }
 
      // Do different things based on the "auxiliary mode" we are in:
      if( m_auxMode == kClassAccess || m_auxMode == kAthenaAccess ) {
 
         // In "class access mode" let's first connect the concrete auxiliary
         // object to the input:
         RETURN_CHECK( "xAOD::TEvent::connectAux", connectBranch( prefix ) );
 
         // Access the object's manager:
         Object_t::const_iterator mgr_itr = m_inputObjects.find( prefix );
         if( mgr_itr == m_inputObjects.end() ) {
            ::Fatal( "xAOD::TEvent::connectAux",
                     XAOD_MESSAGE( "There's a logic error in the code" ) );
         }
         const TObjectManager* omgr =
            dynamic_cast< const TObjectManager* >( mgr_itr->second );
         if( ! omgr ) {
            ::Fatal( "xAOD::TEvent::connectAux",
                     XAOD_MESSAGE( "There's a logic error in the code" ) );
            return StatusCode::FAILURE;
         }
 
         // Check if we can switch out the internal store of this object:
         static const TClass* const holderClass =
            TClass::GetClass( typeid( SG::IAuxStoreHolder ) );
         if( ! omgr->holder()->getClass()->InheritsFrom( holderClass ) ) {
            // Nope... So let's just end the journey here.
            return StatusCode::SUCCESS;
         }
 
         // Try to get the object as an IAuxStoreHolder:
         SG::IAuxStoreHolder* storeHolder =
            reinterpret_cast< SG::IAuxStoreHolder* >(
               omgr->holder()->getAs( typeid( SG::IAuxStoreHolder ) ) );
         if( ! storeHolder ) {
            ::Fatal( "xAOD::TEvent::connectAux",
                     XAOD_MESSAGE( "There's a logic error in the code" ) );
         }
 
         // A sanity check to see whether the store's type is in sync with the
         // object's type that it will be connected to:
         if( ( standalone && ( storeHolder->getStoreType() !=
                               SG::IAuxStoreHolder::AST_ObjectStore ) ) ||
             ( ( ! standalone ) &&
               ( storeHolder->getStoreType() !=
                 SG::IAuxStoreHolder::AST_ContainerStore ) ) ) {
            ::Error( "xAOD::TEvent::connectAux",
                     XAOD_MESSAGE( "Requested store types inconsistent "
                                   "for: %s" ), prefix.c_str() );
            ::Error( "xAOD::TEvent::connectAux",
                     XAOD_MESSAGE( "standalone = %s, getStoreType() = %i" ),
                     ( standalone ? "kTRUE" : "kFALSE" ),
                     static_cast< int >( storeHolder->getStoreType() ) );
            return StatusCode::FAILURE;
         }
 
         // Return gracefully:
         return StatusCode::SUCCESS;
 
      } else if( m_auxMode == kBranchAccess ) {
 
         // In "branch access mode" let's create a TAuxStore object, and let
         // that take care of the auxiliary store access:
         TAuxStore* store =
            new TAuxStore( prefix.c_str(), kTRUE,
                           ( standalone ? TAuxStore::kObjectStore :
                             TAuxStore::kContainerStore ) );
         // We're using this object to read from the input, it needs to be
         // locked:
         store->lock();
         TAuxManager* mgr = new TAuxManager( store );
         m_inputObjects[ prefix ] = mgr;
 
         // Now connect the object to the input tree:
         RETURN_CHECK( "xAOD::TEvent::connectAux",
                       store->readFrom( m_inTree ) );
 
         // Return gracefully:
         return StatusCode::SUCCESS;
      }
 
      // There was some problem:
      ::Error( "xAOD::TEvent::connectAux",
               XAOD_MESSAGE( "Unknown auxiliary access mode set (%i)" ),
               static_cast< int >( m_auxMode ) );
      return StatusCode::FAILURE;
   }

connectBranch()

StatusCode xAOD::TEvent::connectBranch ( const std::string &  key, ::Bool_t  silent = kFALSE  )

protectedinherited

Function setting up access to a particular branch.

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

It connects the event object to a given branch of the input TTree.

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

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

Parameters

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

Returns

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

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

                                                      {
 
      // A little sanity check:
      if( ! m_inTree ) {
         ::Error( "xAOD::TEvent::connectBranch",
                  XAOD_MESSAGE( "Function called on un-initialised object" ) );
         return StatusCode::FAILURE;
      }
 
      // Increment the access counter on this container:
      IOStats::instance().stats().readContainer( key );
 
      // Check if the branch is already connected:
      if( m_inputObjects.find( key ) != m_inputObjects.end() ) {
         return StatusCode::SUCCESS;
      }
      // Check if it was already found to be missing.
      if( m_inputMissingObjects.find( key ) != m_inputMissingObjects.end() ) {
         if( ! silent ) {
            ::Warning( "xAOD::TEvent::connectBranch",
                       "Branch \"%s\" not available on input",
                       key.c_str() );
         }
         return StatusCode::RECOVERABLE;
      }
 
      // Check if we have metadata about this branch:
      const xAOD::EventFormatElement* ef = 0;
      if( ! m_inputEventFormat.exists( key ) ) {
         if( ! silent ) {
            ::Warning( "xAOD::TEvent::connectBranch",
                       "No metadata available for branch: %s",
                       key.c_str() );
         }
      } else {
         ef = m_inputEventFormat.get( key );
      }
 
      // Check if the branch exists in our input tree:
      ::TBranch* br =
         m_inTree->GetBranch( key.c_str() );
      if( ! br ) {
         if( ! silent ) {
            ::Warning( "xAOD::TEvent::connectBranch",
                       "Branch \"%s\" not available on input",
                       key.c_str() );
         }
         m_inputMissingObjects.insert( key );
         return StatusCode::RECOVERABLE;
      }
 
      // Make sure that it's not in "MakeClass mode":
      br->SetMakeClass( 0 );
 
      // Decide about the type that we need to use for the reading of this
      // branch:
      std::string className = br->GetClassName();
      if( className == "" ) {
         if( ef ) {
            // This is a fairly weird situation, but let's fall back to taking
            // the class name from the metadata object in this case.
            className = ef->className();
         } else {
            ::Error( "xAOD::TEvent::connectBranch",
                     XAOD_MESSAGE( "Couldn't find an appropriate type with a "
                                   "dictionary for branch \"%s\"" ),
                     key.c_str() );
            return StatusCode::FAILURE;
         }
      }
      ::TClass* realClass = ::TClass::GetClass( className.c_str() );
      if( ( ( ! realClass ) || ( ! realClass->IsLoaded() ) ) && ef ) {
         // We may need to do an actual schema evolution here, in which
         // case let's fall back on the class name coming from the metadata
         // object.
         className = ef->className();
         realClass = ::TClass::GetClass( className.c_str() );
      }
      if( ( ! realClass ) || ( ! realClass->IsLoaded() ) ) {
         // Now we're in trouble...
         ::Error( "xAOD::TEvent::connectBranch",
                  XAOD_MESSAGE( "Couldn't find an appropriate type with a "
                                "dictionary for branch \"%s\"" ),
                  key.c_str() );
         return StatusCode::FAILURE;
      }
 
      // Make sure that the current object is the "active event":
      setActive();
 
      // The data type is always "other" for us:
      static const ::EDataType dataType = kOther_t;
 
      // Check if the output already has this object. If it does, let's
      // assume that we have been copying the object to the output. Which
      // means that we need to resume filling the same memory address that
      // the output holder points to.
      void* ptr = 0;
      Object_t::const_iterator out_itr = m_outputObjects.find( key );
      if( out_itr != m_outputObjects.end() ) {
         // It needs to be an object manager...
         TObjectManager* mgr =
            dynamic_cast< TObjectManager* >( out_itr->second );
         if( ! mgr ) {
            ::Error( "xAOD::TEvent::connectBranch",
                     XAOD_MESSAGE( "Couldn't access output manager for: %s" ),
                     key.c_str() );
            return StatusCode::FAILURE;
         }
         // Get the pointer out of it:
         ptr = mgr->holder()->get();
      }
 
      // If there is no output object, then let's create one ourselves.
      // This is the only way in which we can have the memory management of
      // THolder do the right thing with this object.
      if( ! ptr ) {
         ptr = realClass->New();
      }
 
      // Create the new manager object that will hold this EDM object:
      THolder* hldr = new THolder( ptr, realClass );
      TObjectManager* mgr =
         new TObjectManager( 0, hldr, ( m_auxMode == kAthenaAccess ) );
      m_inputObjects[ key ] = mgr;
 
      // One final check. If it's not an auxiliary store, then it must have
      // a split level of 0. Otherwise read rules may not work on it. Causing
      // *very* serious silent corruption in the data read, if we don't use
      // the "Athena read mode".
      if( ( m_auxMode != kAthenaAccess ) && ( br->GetSplitLevel() != 0 ) &&
          ( ! isAuxStore( *mgr ) ) ) {
         ::Error( "xAOD::TEvent::connectBranch",
                  XAOD_MESSAGE( "Split level for branch \"%s\" is %i. "
                                "This can only be read in kAthenaAccess mode." ),
                  key.c_str(), br->GetSplitLevel() );
         // Clean up:
         *( hldr->getPtr() ) = 0;
         delete mgr;
         m_inputObjects.erase( key );
         return StatusCode::FAILURE;
      }
 
      // Now try to connect to the branch:
      const ::Int_t status = m_inTree->SetBranchAddress( key.c_str(),
                                                         hldr->getPtr(),
                                                         mgr->branchPtr(),
                                                         realClass, dataType,
                                                         kTRUE );
      if( status < 0 ) {
         ::Error( "xAOD::TEvent::connectBranch",
                  XAOD_MESSAGE( "Couldn't connect variable of type \"%s\" to "
                                "input branch \"%s\". Return code: %i" ),
                  className.c_str(), key.c_str(), status );
         // Clean up:
         *( hldr->getPtr() ) = 0;
         delete mgr;
         m_inputObjects.erase( key );
         return StatusCode::FAILURE;
      }
 
      // If it's an auxiliary store object, set it up correctly:
      if( isAuxStore( *mgr ) ) {
         RETURN_CHECK( "xAOD::TEvent::connectBranch",
                       setUpDynamicStore( *mgr, m_inTree ) );
      }
 
      // Return here if the object can't have an auxiliary store:
      if( ! hasAuxStore( *mgr ) ) return StatusCode::SUCCESS;
 
      // If there may be an auxiliary object connected to this one,
      // connect that as well:
      return connectAux( key + "Aux.", isStandalone( *mgr ) );
   }

connectMetaAux()

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

protectedinherited

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

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

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

Parameters

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

Returns

The usual StatusCode types

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

                                                           {
 
      // Check if the branch is already connected:
      if( m_inputMetaObjects.find( prefix ) != m_inputMetaObjects.end() ) {
         return StatusCode::SUCCESS;
      }
 
      // A sanity check:
      if( ! m_inMetaTree ) {
         ::Fatal( "xAOD::TEvent::connectMetaAux",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
         return StatusCode::FAILURE;
      }
 
      // Do different things based on the "auxiliary mode" we are in:
      if( m_auxMode == kClassAccess || m_auxMode == kAthenaAccess ) {
 
         // In "class access mode" let's first connect the concrete auxiliary
         // object to the input:
         RETURN_CHECK( "xAOD::TEvent::connectMetaAux",
                       connectMetaBranch( prefix ) );
 
         // Access the object's manager:
         Object_t::const_iterator mgr_itr = m_inputMetaObjects.find( prefix );
         if( mgr_itr == m_inputMetaObjects.end() ) {
            ::Fatal( "xAOD::TEvent::connectMetaAux",
                     XAOD_MESSAGE( "There's a logic error in the code" ) );
         }
         const TObjectManager* omgr =
            dynamic_cast< const TObjectManager* >( mgr_itr->second );
         if( ! omgr ) {
            ::Fatal( "xAOD::TEvent::connectMetaAux",
                     XAOD_MESSAGE( "There's a logic error in the code" ) );
            return StatusCode::FAILURE;
         }
 
         // Check if we can switch out the internal store of this object:
         static const TClass* const holderClass =
            TClass::GetClass( typeid( SG::IAuxStoreHolder ) );
         if( ! omgr->holder()->getClass()->InheritsFrom( holderClass ) ) {
            // Nope... So let's just end the journey here.
            return StatusCode::SUCCESS;
         }
 
         // Try to get the object as an IAuxStoreHolder:
         SG::IAuxStoreHolder* storeHolder =
            reinterpret_cast< SG::IAuxStoreHolder* >(
               omgr->holder()->getAs( typeid( SG::IAuxStoreHolder ) ) );
         if( ! storeHolder ) {
            ::Fatal( "xAOD::TEvent::connectMetaAux",
                     XAOD_MESSAGE( "There's a logic error in the code" ) );
         }
 
         // A sanity check to see whether the store's type is in sync with the
         // object's type that it will be connected to:
         if( ( standalone && ( storeHolder->getStoreType() !=
                               SG::IAuxStoreHolder::AST_ObjectStore ) ) ||
             ( ( ! standalone ) &&
               ( storeHolder->getStoreType() !=
                 SG::IAuxStoreHolder::AST_ContainerStore ) ) ) {
            ::Error( "xAOD::TEvent::connectMetaAux",
                     XAOD_MESSAGE( "Requested store types inconsistent" ) );
            ::Error( "xAOD::TEvent::connectMetaAux",
                     XAOD_MESSAGE( "standalone = %s, getStoreType() = %i" ),
                     ( standalone ? "kTRUE" : "kFALSE" ),
                     static_cast< int >( storeHolder->getStoreType() ) );
            return StatusCode::FAILURE;
         }
 
         // Return gracefully:
         return StatusCode::SUCCESS;
 
      } else if( m_auxMode == kBranchAccess ) {
 
         // In "branch access mode" let's create a TAuxStore object, and let
         // that take care of the auxiliary store access:
         TAuxStore* store =
            new TAuxStore( prefix.c_str(), kTRUE,
                           ( standalone ? TAuxStore::kObjectStore :
                             TAuxStore::kContainerStore ) );
         // We use this object to read data from the input, it needs to be
         // locked:
         store->lock();
         TAuxManager* mgr = new TAuxManager( store );
         m_inputMetaObjects[ prefix ] = mgr;
 
         // Now connect the object to the input tree:
         RETURN_CHECK( "xAOD::TEvent::connectMetaAux",
                       store->readFrom( m_inMetaTree ) );
 
         // Tell the auxiliary store which entry to use:
         store->getEntry( 0 );
 
         // Return gracefully:
         return StatusCode::SUCCESS;
      }
 
      // There was some problem:
      ::Error( "xAOD::TEvent::connectMetaAux",
               XAOD_MESSAGE( "Unknown auxiliary access mode set (%i)" ),
               static_cast< int >( m_auxMode ) );
      return StatusCode::FAILURE;
   }

connectMetaBranch()

StatusCode xAOD::TEvent::connectMetaBranch ( const std::string &  key, ::Bool_t  silent = kFALSE  )

protectedinherited

Function setting up access to a branch in the metadata tree.

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

Parameters

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

Returns

The usual StatusCode types

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

                                                          {
 
      // A little sanity check:
      if( ! m_inMetaTree ) {
         ::Error( "xAOD::TEvent::connectMetaBranch",
                  XAOD_MESSAGE( "Function called on un-initialised object" ) );
         return StatusCode::FAILURE;
      }
 
      // Check if the branch is already connected:
      if( m_inputMetaObjects.find( key ) != m_inputMetaObjects.end() ) {
         return StatusCode::SUCCESS;
      }
 
      // Check if the branch exists in our metadata tree:
      ::TBranch* br = m_inMetaTree->GetBranch( key.c_str() );
      if( ! br ) {
         if( ! silent ) {
            ::Warning( "xAOD::TEvent::connectMetaBranch",
                       "Branch \"%s\" not available on input",
                       key.c_str() );
         }
         return StatusCode::RECOVERABLE;
      }
 
      // Check that we have an entry in the branch:
      if( ! br->GetEntries() ) {
         if( ! silent ) {
            ::Warning( "xAOD::TEvent::connectMetaBranch",
                       "Branch \"%s\" doesn't hold any data",
                       key.c_str() );
         }
         return StatusCode::RECOVERABLE;
      }
 
      // Make sure that it's not in "MakeClass mode":
      br->SetMakeClass( 0 );
 
      // Extract the type of the branch:
      ::TClass* cl = 0;
      ::EDataType dt = kOther_t;
      if( br->GetExpectedType( cl, dt ) || ( ! cl ) ) {
         ::Error( "xAOD::TEvent::connectMetaBranch",
                  XAOD_MESSAGE( "Couldn't get the type for metadata "
                                "branch %s" ), key.c_str() );
         return StatusCode::FAILURE;
      }
 
      // Create the object, and all of the managers around it:
      void* ptr = cl->New();
      THolder* hldr = new THolder( ptr, cl );
      TObjectManager* mgr =
         new TObjectManager( 0, hldr, m_auxMode == kAthenaAccess );
      m_inputMetaObjects[ key ] = mgr;
 
      // Now try to connect to the branch:
      const ::Int_t status = m_inMetaTree->SetBranchAddress( key.c_str(),
                                                             hldr->getPtr(),
                                                             mgr->branchPtr(),
                                                             cl, dt,
                                                             kTRUE );
      if( status < 0 ) {
         ::Error( "xAOD::TEvent::connectMetaBranch",
                  XAOD_MESSAGE( "Couldn't connect variable of type \"%s\" to "
                                "input branch \"%s\". Return code: %i" ),
                  cl->GetName(), key.c_str(), status );
         // Clean up:
         *( hldr->getPtr() ) = 0;
         delete mgr;
         m_inputMetaObjects.erase( key );
         return StatusCode::FAILURE;
      }
 
      // Read in the object:
      if( mgr->getEntry() < 0 ) {
         ::Error( "xAOD::TEvent::connectMetaBranch",
                  XAOD_MESSAGE( "Couldn't read in metadata object with key "
                                "\"%s\"" ), key.c_str() );
         return StatusCode::FAILURE;
      }
 
      // If it's an auxiliary store object, set it up correctly:
      if( isAuxStore( *mgr ) ) {
         RETURN_CHECK( "xAOD::TEvent::connectBranch",
                       setUpDynamicStore( *mgr, m_inMetaTree ) );
      }
 
      // Return here if the object can't have an auxiliary store:
      if( ! hasAuxStore( *mgr ) ) return StatusCode::SUCCESS;
 
      // If there may be an auxiliary object connected to this one,
      // connect that as well:
      RETURN_CHECK( "xAOD::TEvent::connectMetaBranch",
                    connectMetaAux( key + "Aux.", isStandalone( *mgr ) ) );
 
      // And now connect the first object to its auxiliary store:
      RETURN_CHECK( "xAOD::TEvent::connectMetaBranch",
                    setAuxStore( *mgr, kTRUE ) );
 
      // We succeeded:
      return StatusCode::SUCCESS;
   }

contains() [1/3]

template<typename T >

::Bool_t xAOD::TEvent::contains ( const std::string &  key )

inherited

Function checking if an object is available from the store.

contains() [2/3]

Bool_t xAOD::TPyEvent::contains	(	const std::string &	key,
		const std::string &	type
	)

Function checking if an object is available from the store.

Definition at line 13 of file TPyEvent.cxx.

                                                        {
 
      // Try to access the dictionary of this type:
      ::TClass* cl = ::TClass::GetClass( type.c_str() );
      if( ! cl ) {
         ::Warning( "xAOD::TPyEvent::contains",
                    "Type name \"%s\" not known", type.c_str() );
         return kFALSE;
      }
 
      // Check if the dictionary can return a type_info:
      const std::type_info* ti = cl->GetTypeInfo();
      if( ! ti ) {
         ::Warning( "xAOD::TPyEvent::contains",
                    "Type \"%s\" doesn't have a proper dictionary",
                    type.c_str() );
         return kFALSE;
      }
 
      // Let the base class do the work:
      return TEvent::contains( key, *ti, kFALSE );
   }

contains() [3/3]

Bool_t xAOD::TEvent::contains ( const std::string &  key, const std::type_info &  ti, ::Bool_t  metadata = kFALSE  )

protectedinherited

Internal function checking if an object is in the input.

Created a non-template version of the call internally to be able to use it from xAOD::MakeTransientTree.

Parameters

key	The key to check
ti	The type of the object to check
metadata	Flag deciding whether we are looking for a metadata object or not

Returns

kTRUE if such an object is held by the event object at the moment, kFALSE otherwise

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

                                                {
 
      return ( getOutputObject( key, ti, metadata ) ||
               getInputObject( key, ti, kTRUE, metadata ) );
   }

containsMeta()

template<typename T >

::Bool_t xAOD::TEvent::containsMeta ( const std::string &  key )

inherited

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

copy() [1/2]

StatusCode xAOD::TEvent::copy ( ::Int_t  basketSize = 32000, ::Int_t  splitLevel = 0  )

inherited

Copy all (ROOT readable) objects directly from the input to the output.

This function is here to make it easy to write code that skims an input file into an output file without applying any modification to the events.

Parameters

basketSize	Optional size for the basket associated with the output branch
splitLevel	Optional split level of the output branch

Returns

StatusCode::SUCCESS if the copy was successful, or StatusCode::FAILURE if not

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

                                                               {
 
      // Make sure that an input TTree is available:
      if( ! m_inTree ) {
         ::Error( "xAOD::TEvent::copy",
                  XAOD_MESSAGE( "No input TTree is open" ) );
         return StatusCode::FAILURE;
      }
 
      // Loop over the known input containers:
      EventFormat::const_iterator itr = m_inputEventFormat.begin();
      EventFormat::const_iterator end = m_inputEventFormat.end();
      for( ; itr != end; ++itr ) {
 
         // Convenience reference:
         const EventFormatElement& efe = itr->second;
 
         // Ignore objects that don't exist on the input:
         if( ! m_inTree->GetBranch( efe.branchName().c_str() ) ) {
            continue;
         }
         // Skip all branches ending in "Aux.":
         if( efe.branchName().find( "Aux." ) ==
             ( efe.branchName().size() - 4 ) ) {
            continue;
         }
         // Also skip dynamic branches:
         if( efe.parentName() != "" ) {
            continue;
         }
         // Check if the class in question is known:
         ::TClass* cl = ::TClass::GetClass( efe.className().c_str() );
         if( ( ! cl ) || ( ! cl->IsLoaded() ) ) {
            continue;
         }
 
         // Make the copy then...
         RETURN_CHECK( "xAOD::TEvent::copy",
                       this->copy( efe.branchName(), basketSize, splitLevel ) );
      }
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

copy() [2/2]

StatusCode xAOD::TEvent::copy ( const std::string &  key, ::Int_t  basketSize = 32000, ::Int_t  splitLevel = 0  )

inherited

Copy an object directly from the input to the output.

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

It only needs to be called on the interface object/container, the copying of the auxiliary data is done automatically, and is steered by the SetAuxItemList function.

Parameters

key	The key (branch name) of the object/container to copy
basketSize	Optional size for the basket associated with the output branch
splitLevel	Optional split level of the output branch

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

                                                                  {
 
      // Check if a name re-mapping should be applied or not:
      std::string keyToUse = key;
      auto remap_itr = m_nameRemapping.find( key );
      if( ( remap_itr != m_nameRemapping.end() ) &&
          ( ! m_inputEventFormat.exists( key ) ) &&
          m_inputEventFormat.exists( remap_itr->second ) ) {
         keyToUse = remap_itr->second;
      }
 
      // Make sure that the branch got connected to:
      RETURN_CHECK( "xAOD::TEvent::copy", connectBranch( keyToUse ) );
 
      // Make sure that the input object is properly updated:
      Object_t::const_iterator vobjMgr = m_inputObjects.find( keyToUse );
      if( vobjMgr == m_inputObjects.end() ) {
         ::Error( "xAOD::TEvent::copy",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
         return StatusCode::FAILURE;
      }
      TObjectManager* objMgr =
         dynamic_cast< TObjectManager* >( vobjMgr->second );
      if( ! objMgr ) {
         ::Error( "xAOD::TEvent::copy",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
         return StatusCode::FAILURE;
      }
      if( ! getInputObject( key,
                       *( objMgr->holder()->getClass()->GetTypeInfo() ) ) ) {
         ::Error( "xAOD::TEvent::copy",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
         return StatusCode::FAILURE;
      }
 
      // Put the interface object into the output:
      RETURN_CHECK( "xAOD::TEvent::copy",
                    record( objMgr->object(),
                            objMgr->holder()->getClass()->GetName(),
                            key, basketSize, splitLevel, kTRUE ) );
 
      // Check if we have a filtering rule for the store:
      const std::set< std::string >* filter = 0;
      auto fitr = m_auxItemList.find( key + "Aux." );
      if( fitr != m_auxItemList.end() ) {
         filter = &( fitr->second );
      }
 
      // Put the auxiliary store object into the output:
      Object_t::const_iterator vauxMgr = m_inputObjects.find( keyToUse +
                                                              "Aux." );
      if( vauxMgr == m_inputObjects.end() ) {
         // If there is no auxiliary store for this object/container, we're
         // done already:
         return StatusCode::SUCCESS;
      }
      // Check what type of auxiliary store this is:
      if( m_auxMode == kClassAccess || m_auxMode == kAthenaAccess ) {
         TObjectManager* auxMgr =
            dynamic_cast< TObjectManager* >( vauxMgr->second );
         if( ! auxMgr ) {
            ::Error( "xAOD::TEvent::copy",
                     XAOD_MESSAGE( "Internal logic error detected" ) );
            return StatusCode::FAILURE;
         }
         RETURN_CHECK( "xAOD::TEvent::copy",
                       record( auxMgr->object(),
                               auxMgr->holder()->getClass()->GetName(),
                               key + "Aux.", basketSize, splitLevel, kTRUE ) );
      } else if( m_auxMode == kBranchAccess ) {
         TAuxManager* auxMgr =
            dynamic_cast< TAuxManager* >( vauxMgr->second );
         if( ! auxMgr ) {
            ::Error( "xAOD::TEvent::copy",
                     XAOD_MESSAGE( "Internal logic error detected" ) );
            return StatusCode::FAILURE;
         }
         // Set up the filtering:
         if( filter ) {
            auxMgr->getStore()->selectAux( *filter );
         }
         RETURN_CHECK( "xAOD::TEvent::copy",
                       record( auxMgr->getStore(),
                               key + "Aux.", basketSize, splitLevel ) );
      } else {
         ::Fatal( "xAOD::TEvent::copy",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
      }
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

dump()

std::string xAOD::TEvent::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 293 of file Control/xAODRootAccess/Root/TEvent.cxx.

                          {
 
      // The internal stream object:
      std::ostringstream ost;
      ost << "<<<<<<<<<<<<<<<<<<<< xAOD::TEvent Dump >>>>>>>>>>>>>>>>>>>>\n";
 
      // Loop over the EventFormat object:
      EventFormat::const_iterator ef_itr = m_inputEventFormat.begin();
      EventFormat::const_iterator ef_end = m_inputEventFormat.end();
      for( ; ef_itr != ef_end; ++ef_itr ) {
 
         // Construct the type name:
         std::string typeName = ef_itr->second.className();
         removeVersionNames( typeName );
 
         // Get the type:
         ::TClass* cl =
              ::TClass::GetClass( ef_itr->second.className().c_str() );
         const std::type_info* ti = ( cl ? cl->GetTypeInfo() : nullptr );
         if( ( ! cl ) || ( ! cl->IsLoaded() ) || ( ! ti ) ) {
            Warning( "xAOD::TEvent::dump",
                     "Unknown type (%s) found in the event format",
                     ef_itr->second.className().c_str() );
            continue;
         }
 
         // Skip containers that are not available anyway:
         if( ! contains( ef_itr->second.branchName(), *ti ) ) {
            continue;
         }
 
         // Do the printout:
         ost << " Hash: 0x" << std::setw( 8 ) << std::setfill( '0' )
             << std::hex << ef_itr->second.hash()
             << " Key: \"" << ef_itr->second.branchName() << "\"\n";
 
         ost << "   type: " << typeName << "\n";
         const bool isNonConst = transientContains( ef_itr->second.branchName(),
                                                    *ti );
         ost << "   isConst: " << ( isNonConst ? "No" : "Yes" ) << "\n";
         ost << "   Data: "
             << ( isNonConst ? getOutputObject( ef_itr->second.branchName(),
                                                *ti ) :
                  getInputObject( ef_itr->second.branchName(), *ti ) ) << "\n";
      }
 
      // Finish with the construction:
      ost << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
      return ost.str();
   }

fill()

Int_t xAOD::TEvent::fill ( )

inherited

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

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

                      {
 
      // A little sanity check:
      if( ! m_outTree ) {
         ::Error( "xAOD::TEvent::fill",
                  XAOD_MESSAGE( "Object not connected to an output file!" ) );
         return 0;
      }
 
      // Make sure that all objects have been read in. The 99 as the value
      // has a special meaning for TAuxStore. With this value it doesn't
      // delete its transient (decoration) variables. Otherwise it does.
      // (As it's supposed to, when moving to a new event.)
      if( m_inChain ) {
         if (getEntry( m_inChain->GetReadEntry(), 99 ) < 0) {
           ::Error( "xAOD::TEvent::fill",
                    XAOD_MESSAGE( "getEntry failed!" ) );
           return 0;
         }
      } else if( m_inTree ) {
         if (getEntry( m_entry, 99 ) < 0) {
           ::Error( "xAOD::TEvent::fill",
                    XAOD_MESSAGE( "getEntry failed!" ) );
           return 0;
         }
      }
 
      // Prepare the objects for writing. Note that we need to iterate over a
      // copy of the m_outputObjects container. Since the putAux(...) function
      // called inside the loop may itself add elements to the m_outputObject
      // container.
      std::string unsetObjects;
      Object_t outputObjectsCopy = m_outputObjects;
      for( auto& itr : outputObjectsCopy ) {
         // Check that a new object was provided in the event:
         if( ! itr.second->create() ) {
            // We are now going to fail. But let's collect the names of
            // all the unset objects:
            if( unsetObjects.size() ) {
               unsetObjects.append( ", \"" + itr.first + "\"" );
            } else {
               unsetObjects.append( "\"" + itr.first + "\"" );
            }
            continue;
         }
         // Make sure that any dynamic auxiliary variables that
         // were added to the object after it was put into the event,
         // get added to the output:
         if( ! putAux( *m_outTree, *( itr.second ) ) ) {
            ::Error( "xAOD::TEvent::fill",
                     XAOD_MESSAGE( "Failed to put dynamic auxiliary variables "
                                   "in the output for object \"%s\"" ),
                     itr.first.c_str() );
            return 0;
         }
      }
 
      // Check if there were any unset objects:
      if( unsetObjects.size() ) {
         ::Error( "xAOD::TEvent::fill",
                  XAOD_MESSAGE( "The following objects were not set in the "
                                "current event: %s" ), unsetObjects.c_str() );
         return 0;
      }
 
      // Write the entry, and check the return value:
      const ::Int_t ret = m_outTree->Fill();
      if( ret <= 0 ) {
         ::Error( "xAOD::TEvent::fill",
                  XAOD_MESSAGE( "Output tree filling failed with return "
                                "value: %i" ), ret );
      }
 
      // Reset the object managers:
      Object_t::iterator ncitr = m_outputObjects.begin();
      Object_t::iterator ncend = m_outputObjects.end();
      for( ; ncitr != ncend; ++ncitr ) {
         ncitr->second->reset();
      }
 
      // Return the value:
      return ret;
   }

finishWritingTo()

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

file	The file that the event data is written to

Returns

kTRUE if successful, kFALSE otherwise

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

                                                   {
 
      // A small sanity check:
      if( ! m_outTree ) {
         ::Error( "xAOD::TEvent::finishWritingTo",
                  XAOD_MESSAGE( "The object doesn't seem to be connected to an "
                                "output file!" ) );
         return StatusCode::FAILURE;
      }
 
      // Make sure we return to the current directory:
      TDirectoryReset dr;
 
      // Notify the listeners that they should write out their metadata, if they
      // have any.
      const TIncident incident( IncidentType::MetaDataStop );
      Listener_t::iterator l_itr = m_listeners.begin();
      Listener_t::iterator l_end = m_listeners.end();
      for( ; l_itr != l_end; ++l_itr ) {
         ( *l_itr )->handle( incident );
      }
 
      // Write out the event tree, and delete it:
      m_outTree->AutoSave( "FlushBaskets" );
      m_outTree->SetDirectory( 0 );
      delete m_outTree;
      m_outTree = 0;
 
      // Now go to the output file:
      file->cd();
 
      // Check if there's already a metadata tree in the output:
      if( file->Get( METADATA_TREE_NAME ) ) {
         // Let's assume that the metadata is complete in the file already.
         return StatusCode::SUCCESS;
      }
 
      // Create the metadata tree:
      ::TTree* metatree =
         new ::TTree( METADATA_TREE_NAME, "xAOD metadata tree" );
      metatree->SetAutoSave( 10000 );
      metatree->SetAutoFlush( -30000000 );
      metatree->SetDirectory( file );
 
      // Create the only branch in it:
      metatree->Branch( "EventFormat",
         SG::normalizedTypeinfoName( typeid( xAOD::EventFormat ) ).c_str(),
         &m_outputEventFormat );
 
      // Create a copy of the m_outputMetaObjects variable. This is necessary
      // because the putAux(...) function will modify this variable while we
      // loop over it.
      Object_t outputMetaObjects = m_outputMetaObjects;
 
      // Now loop over all the metadata objects that need to be put into the
      // output file:
      for( auto& object : outputMetaObjects ) {
         // All metadata objects should be held by TObjectManager objects.
         // Anything else is an error.
         TObjectManager* mgr = dynamic_cast< TObjectManager* >( object.second );
         if( ! mgr ) {
            ::Error( "xAOD::TEvent::finishWritingTo",
                     XAOD_MESSAGE( "Internal logic error detected" ) );
            return StatusCode::FAILURE;
         }
         // Select a split level depending on whether this is an interface or an
         // auxiliary object:
         const ::Int_t splitLevel = ( object.first.find( "Aux." ) ==
                                      ( object.first.size() - 4 ) ? 1 : 0 );
         // Create the new branch:
         *( mgr->branchPtr() ) =
            metatree->Branch( object.first.c_str(),
                              mgr->holder()->getClass()->GetName(),
                              mgr->holder()->getPtr(), 32000, splitLevel );
         if( ! mgr->branch() ) {
            ::Error( "xAOD::TEvent::finishWritingTo",
                     XAOD_MESSAGE( "Failed to create metadata branch "
                                   "\"%s/%s\"" ),
                     mgr->holder()->getClass()->GetName(),
                     object.first.c_str() );
            return StatusCode::FAILURE;
         }
         // Set up the saving of all the dynamic auxiliary properties
         // of the object if it has any:
         RETURN_CHECK( "xAOD::TEvent::finishWritingTo",
                       putAux( *metatree, *( object.second ), 32000, 0,
                               kTRUE ) );
      }
 
      // Write the metadata objects:
      if( metatree->Fill() <= 0 ) {
         ::Error( "xAOD::TEvent::finishWritingTo",
                  XAOD_MESSAGE( "Failed to write event format metadata into "
                                "the output" ) );
         metatree->SetDirectory( 0 );
         delete metatree;
         return StatusCode::FAILURE;
      }
 
      // Now clean up:
      metatree->Write();
      metatree->SetDirectory( 0 );
      delete metatree;
      m_outputEventFormat = 0;
      Object_t::iterator obj_itr = m_outputObjects.begin();
      Object_t::iterator obj_end = m_outputObjects.end();
      for( ; obj_itr != obj_end; ++obj_itr ) {
         delete obj_itr->second;
      }
      m_outputObjects.clear();
      obj_itr = m_outputMetaObjects.begin();
      obj_end = m_outputMetaObjects.end();
      for( ; obj_itr != obj_end; ++obj_itr ) {
         delete obj_itr->second;
      }
      m_outputMetaObjects.clear();
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

getBranchInfo()

const TEvent::BranchInfo * xAOD::TEvent::getBranchInfo ( SG::sgkey_t  sgkey ) const

protectedinherited

Get the object describing one object/branch.

Definition at line 268 of file TEventProxyDict.cxx.

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

getEntries()

Long64_t xAOD::TEvent::getEntries ( ) const

inherited

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

Returns

The number of events in the input file(s)

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

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

getEntry()

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

inherited

Function loading a given entry of the input TTree.

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

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

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

Parameters

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

Returns

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

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

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

getEventFormatElement()

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

protectedinherited

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

Definition at line 351 of file TEventProxyDict.cxx.

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

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

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

Returns

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

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

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

getFiles()

Long64_t xAOD::TEvent::getFiles ( ) const

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

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

getHash()

SG::sgkey_t xAOD::TEvent::getHash ( const std::string &  key ) const

overridevirtualinherited

Function returning the hash describing an object name.

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

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

Parameters

key	String key to turn into a hash

Returns

A hash corresponding to the specified string key

Implements xAOD::TVirtualEvent.

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

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

getInputObject() [1/2]

const void * xAOD::TEvent::getInputObject ( const std::string &  key, const std::type_info &  ti, ::Bool_t  silent = kFALSE, ::Bool_t  metadata = kFALSE  )

protectedinherited

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

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

Parameters

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

Returns

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

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

                                                         {
 
      // Check if a name remapping should be applied or not:
      std::string keyToUse = key;
      auto remap_itr = m_nameRemapping.find( key );
      if( ( remap_itr != m_nameRemapping.end() ) &&
          ( ! m_inputEventFormat.exists( key ) ) &&
          m_inputEventFormat.exists( remap_itr->second ) ) {
         keyToUse = remap_itr->second;
      }
 
      // The following catches the cases when we ask for a transient
      // ConstDataVector object to be returned as "const DataVector".
      TStore* store = TActiveStore::store();
      if( store && store->contains( keyToUse, ti ) &&
          store->isConst( keyToUse, ti ) ) {
         const void* result = store->getConstObject( keyToUse, ti );
         return result;
      }
 
      // A sanity check before checking for an object from the input file:
      if( ( ( ! m_inTree ) || ( m_entry < 0 ) ) &&
          ( ! metadata ) ) {
         return 0;
      }
      if( ( ! m_inMetaTree ) && metadata ) {
         return 0;
      }
 
      // Make sure that the requested branch is connected to:
      if( metadata ) {
         if( ! connectMetaBranch( keyToUse, silent ).isSuccess() ) {
            return 0;
         }
      } else {
         if( ! connectBranch( keyToUse, silent ).isSuccess() ) {
            return 0;
         }
      }
 
      // Select which object container to use:
      Object_t& objects = ( metadata ?
                            m_inputMetaObjects : m_inputObjects );
 
      // Access the object's manager:
      Object_t::iterator itr = objects.find( keyToUse );
      if( itr == objects.end() ) {
         ::Fatal( "xAOD::TEvent::getInputObject",
                  XAOD_MESSAGE( "There is an internal logic error in the "
                                "code..." ) );
         return 0;
      }
 
      // This has to be an ObjectManager object:
      TObjectManager* mgr =
         dynamic_cast< TObjectManager* >( itr->second );
      if( ! mgr ) {
         if( key == keyToUse ) {
            ::Error( "xAOD::TEvent::getInputObject",
                     XAOD_MESSAGE( "Object of wrong type found for key "
                                   "\"%s\"" ),
                     key.c_str() );
         } else {
            ::Error( "xAOD::TEvent::getInputObject",
                     XAOD_MESSAGE( "Object of wrong type found for key "
                                   "\"%s\"/\"%s\"" ), key.c_str(),
                     keyToUse.c_str() );
         }
         return 0;
      }
 
      // Make sure that the current entry is loaded for event data objects:
      if( ! metadata ) {
         if( mgr->getEntry() ) {
            // Connect the auxiliary store to objects needing it. This call also
            // takes care of updating the dynamic store of auxiliary containers,
            // when they are getting accessed directly.
            if( ! setAuxStore( *mgr ).isSuccess() ) {
               ::Error( "xAOD::TEvent::getInputObject",
                        XAOD_MESSAGE( "Failed to set the auxiliary store for "
                                      "%s/%s" ),
                        mgr->holder()->getClass()->GetName(),
                        keyToUse.c_str() );
               return 0;
            }
         }
      }
 
      // Ask the holder object for the object of this type:
      const void* result = mgr->holder()->getAsConst( ti, silent );
      if( ! result ) {
         if( ! silent ) {
            ::Warning( "xAOD::TEvent::getInputObject",
                       "Could not retrieve object with key \"%s\" "
                       "as \"%s\"", keyToUse.c_str(),
                       Utils::getTypeName( ti ).c_str() );
         }
         return 0;
      }
 
      // We succeeded:
      return result;
   }

getInputObject() [2/2]

const void * xAOD::TEvent::getInputObject ( SG::sgkey_t  key, const std::type_info &  ti, bool  silent = false  )

overrideprotectedvirtualinherited

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

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

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

Parameters

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

Returns

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

Implements xAOD::TVirtualEvent.

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

                                                     {
 
      // Get a string name for this key:
      const std::string& name = getName( key );
      if( ( ! name.length() ) && ( ! silent ) ) {
         Warning( "xAOD::TEvent::getInputObject",
                  "Key 0x%08x unknown", key );
         return 0;
      }
 
      // Forward the call to the function using an std::string key:
      return getInputObject( name, ti, silent );
   }

getKey()

SG::sgkey_t xAOD::TEvent::getKey ( const void *  obj ) const

overridevirtualinherited

Function returning the hash describing a known object.

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

Parameters

obj	Pointer to the object that we want to look up

Returns

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

Implements xAOD::TVirtualEvent.

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

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

getName() [1/2]

const std::string & xAOD::TEvent::getName ( const void *  obj ) const

overridevirtualinherited

Function returning the key describing a known object.

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

Parameters

obj	Pointer to the object that we want to look up

Returns

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

Implements xAOD::TVirtualEvent.

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

                                                           {
 
      // First look among the output objects:
      Object_t::const_iterator obj_itr = m_outputObjects.begin();
      Object_t::const_iterator obj_end = m_outputObjects.end();
      for( ; obj_itr != obj_end; ++obj_itr ) {
 
         // Check if this is our object:
         if( obj_itr->second->object() != obj ) continue;
 
         // If it is, let's return right away:
         return obj_itr->first;
      }
 
      // Now look among the input objects:
      obj_itr = m_inputObjects.begin();
      obj_end = m_inputObjects.end();
      for( ; obj_itr != obj_end; ++obj_itr ) {
 
         // Check if this is our object:
         if( obj_itr->second->object() != obj ) continue;
 
         // If it is, let's return:
         return obj_itr->first;
      }
 
      // If it's not there either, check if it's in an active TStore object:
      const TStore* store = TActiveStore::store();
      if( store && store->contains( obj ) ) {
         // Get the name from the store then:
         return store->getName( obj );
      }
 
      // We didn't find the object in the event...
      ::Warning( "xAOD::TEvent::getName",
                 "Didn't find object with pointer %p in the event",
                 obj );
      static const std::string dummy;
      return dummy;
   }

getName() [2/2]

const std::string & xAOD::TEvent::getName ( SG::sgkey_t  hash ) const

overridevirtualinherited

Function returning the key describing a known object.

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

Parameters

hash	The hashed key for the container/object

Returns

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

Implements xAOD::TVirtualEvent.

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

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

getNames()

void xAOD::TEvent::getNames ( const std::string &  targetClassName, std::vector< std::string > &  vkeys, bool  metadata = false  ) const

overrideprotectedvirtualinherited

Function determining the list keys associated with a type name.

Implements xAOD::TVirtualEvent.

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

                                              {
      // The results go in here
      std::set<std::string> keys;
 
      // Get list of branches from 
      // the input metadata tree or input tree 
      std::vector<TObjArray*> fullListOfBranches = {};
      if (metadata){
         if (m_inMetaTree){
            // No friend tree expected for metadata tree
            // Only add the list of branches of the metadata tree 
            ::Info("xAOD::TEvent::getNames", "scanning input objects");
            fullListOfBranches.push_back(m_inMetaTree->GetListOfBranches());
         }
      }
      else {
         if (m_inTree){
            ::Info("xAOD::TEvent::getNames", "scanning input objects");
             // Add the list of branches of the main tree 
            fullListOfBranches.push_back(m_inTree->GetListOfBranches());
            // If input tree has friend trees 
            // add as well the list of friend tree branches  
            if (m_inTree->GetListOfFriends()){
               // Get the list of friends 
               TList *fList = m_inTree->GetListOfFriends();
               // Loop over friend elements 
               for (TObject * feObj : *fList){
                  if (feObj){
                     // Get corresponding friend tree 
                     TTree *friendTree = dynamic_cast<TFriendElement*>(feObj)->GetTree();
                     // Add list of branches of the friend tree 
                     fullListOfBranches.push_back(friendTree->GetListOfBranches());
                  }
               }
            }
         }
      }
      
      // Loop over all list of branches (if any)
      for (const TObjArray * in : fullListOfBranches){
         // Loop over all branches inside the current list of branches 
         for ( Int_t index = 0; index < in->GetEntriesFast(); ++index ) {
            const TObject * obj = in->At(index);
            if ( ! obj ) continue;
            const TBranch * element = dynamic_cast<const TBranch*>(obj);
            if (!element) {
               ::Error("xAOD::TEvent::getNames", "Failure inspecting input objects");
               break;
            }
            std::string objClassName = element->GetClassName();
            std::string key = obj->GetName();
            ::Info("xAOD::TEvent::getNames",
                  "Inspecting %s / %s",
                  objClassName.c_str(), key.c_str());
            if (objClassName == targetClassName) {
               ::Info("xAOD::TEvent::getNames",
                     "Matched %s to key %s",
                     targetClassName.c_str(), key.c_str());
               keys.insert(key);
            }
         }
      }
      
      const Object_t& inAux = ( metadata ?
                                m_inputMetaObjects : m_inputObjects );
 
      ::Info("xAOD::TEvent::getNames",
             "scanning input Aux objects for %s", targetClassName.c_str());
      for( const auto& object : inAux ) {
         // All metadata objects should be held by TObjectManager objects.
         // Anything else is an error.
         TObjectManager* mgr = dynamic_cast< TObjectManager* >( object.second );
         if ( ! mgr ) continue;
         const std::string& objClassName = mgr->holder()->getClass()->GetName();
         const std::string& key = object.first;
         ::Info("xAOD::TEvent::getNames",
                "Inspecting %s / %s",
                objClassName.c_str(), key.c_str());
         if (objClassName == targetClassName) {
            ::Info("xAOD::TEvent::getNames",
                   "Matched %s to key %s",
                   targetClassName.c_str(), key.c_str());
            keys.insert(key);
         }
      }
 
 
      // check output objects
      TTree *tree = ( metadata ? nullptr : m_outTree );
      if (tree) {
         const TObjArray * out = tree->GetListOfBranches();
         ::Info("xAOD::TEvent::getNames", "scanning output objects");
 
         for ( Int_t index = 0; index < out->GetEntriesFast(); ++index ) {
            const TObject * obj = out->At(index);
            if ( ! obj ) continue;
            const TBranch * element = dynamic_cast<const TBranch*>(obj);
            if (!element) {
               ::Error("xAOD::TEvent::getNames", "Failure inspecting input objects");
               break;
            }
            std::string objClassName = element->GetClassName();
            std::string key = obj->GetName();
            ::Info("xAOD::TEvent::getNames",
                   "Inspecting %s / %s",
                   objClassName.c_str(), key.c_str());
            if (objClassName == targetClassName) {
               ::Info("xAOD::TEvent::getNames",
                     "Matched %s to key %s",
                     targetClassName.c_str(), key.c_str());
               keys.insert(key);
            }
         }
      } else {
         ::Info("xAOD::TEvent::getNames", "no output tree connected");
      }
 
 
      const Object_t& outAux = ( metadata ?
                                 m_outputMetaObjects : m_outputObjects );
 
      // Search though EventFormat for entries where class matches the provided
      // typeName
      ::Info("xAOD::TEvent::getNames",
             "scanning output Aux objects for %s", targetClassName.c_str());
      for( const auto& object : outAux ) {
         // All metadata objects should be held by TObjectManager objects.
         // Anything else is an error.
         TObjectManager* mgr = dynamic_cast< TObjectManager* >( object.second );
         if ( ! mgr ) continue;
         const std::string& objClassName = mgr->holder()->getClass()->GetName();
         const std::string& key = object.first;
         ::Info("xAOD::TEvent::getNames",
                "Inspecting %s / %s",
                objClassName.c_str(), key.c_str());
         if (objClassName == targetClassName) {
            ::Info("xAOD::TEvent::getNames",
                   "Matched %s to key %s",
                   targetClassName.c_str(), key.c_str());
            keys.insert(key);
         }
      }
 
      vkeys.insert(vkeys.end(), keys.begin(), keys.end());
   }

getOutputObject() [1/2]

void * xAOD::TEvent::getOutputObject ( const std::string &  key, const std::type_info &  ti, ::Bool_t  metadata = kFALSE  ) const

protectedinherited

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

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

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

Parameters

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

Returns

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

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

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

getOutputObject() [2/2]

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

overrideprotectedvirtualinherited

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

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

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

Parameters

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

Returns

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

Implements xAOD::TVirtualEvent.

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

                                                           {
 
      // Get a string name for this key:
      const std::string& name = getName( key );
      if( ! name.length() ) {
         return 0;
      }
 
      // Forward the call to the function using an std::string key:
      return getOutputObject( name, ti );
   }

hasAuxStore()

Bool_t xAOD::TEvent::hasAuxStore ( const TObjectManager &  mgr )

staticprotectedinherited

Function checking if a given object may have an auxiliary store.

Since the code needs to check in a few places whether a given object has an auxiliary store, and as this check may change slightly over time, it seemed to be a good idea to outsource this check into this function.

Parameters

mgr	The manager of the object that should be checked

Returns

kTRUE if the object can have an auxiliary store, kFALSE otherwise

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

                                                         {
 
      // The classes whose children can have an auxiliary store attached
      // to them:
      static const TClass* const dvClass =
         ::TClass::GetClass( typeid( SG::AuxVectorBase ) );
      static const TClass* const aeClass =
         ::TClass::GetClass( typeid( SG::AuxElement ) );
 
      // Do the check:
      return ( mgr.holder()->getClass()->InheritsFrom( dvClass ) ||
               mgr.holder()->getClass()->InheritsFrom( aeClass ) );
   }

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

StatusCode::SUCCESS if the function is successful, or StatusCode::kFaulure if not

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

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

inputEventFormat()

const EventFormat * xAOD::TEvent::inputEventFormat ( ) const

inherited

Get information about the input objects.

This function makes it possible for the user to investigate the contents of the input file that the object is currently connected to.

Notice that this doesn't necessarily mean that all the objects for which metadata is stored, would necessarily be part of the input TTree that this object is connected to.

Returns

The event format object if a file is being read, or a null pointer if no input file is connected at the moment.

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

                                                     {
 
      // If we *are* reading an input file:
      if( m_inTree || m_inTreeMissing ) {
         return &m_inputEventFormat;
      }
 
      // If not, let's complain:
      ::Warning( "xAOD::TEvent::inputEventFormat",
                 "No input file is connected at the moment" );
      return 0;
   }

isAuxStore()

Bool_t xAOD::TEvent::isAuxStore ( const TObjectManager &  mgr )

staticprotectedinherited

Function checking if a given object may be an auxiliary store.

This function is used to decide if a given object is an auxiliary store type or not.

Parameters

mgr	The manager of the object that should be checked

Returns

kTRUE if the object is an auxiliary store, kFALSE if it is not

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

                                                        {
 
      // The classes whose children are considered auxiliary stores:
      static const TClass* const storeClass =
         ::TClass::GetClass( typeid( SG::IConstAuxStore ) );
      static const TClass* const storeHolderClass =
         ::TClass::GetClass( typeid( SG::IAuxStoreHolder ) );
 
      // Do the check:
      return ( mgr.holder()->getClass()->InheritsFrom( storeClass ) ||
               mgr.holder()->getClass()->InheritsFrom( storeHolderClass ) );
   }

isStandalone()

Bool_t xAOD::TEvent::isStandalone ( const TObjectManager &  mgr )

staticprotectedinherited

Function checking if an object is standalone (not a container)

This function is used to figure out while setting up the reading of the TTree in kBranchAccess mode, what to tell the underlying TAuxStore object, what kind of store it needs to be.

It's done in pretty much the same way in which hasAuxStore(...) decides if the object in question can have an auxiliary store.

Parameters

mgr	The manager of the object that should be checked

Returns

kTRUE if the object is a standalone one, kFALSE if it is a container

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

                                                          {
 
      // The classes whose children can have an auxiliary store attached
      // to them:
      static const TClass* const dvClass =
         TClass::GetClass( typeid( SG::AuxVectorBase ) );
      static const TClass* const aeClass =
         TClass::GetClass( typeid( SG::AuxElement ) );
 
      // Do the check:
      if( mgr.holder()->getClass()->InheritsFrom( aeClass ) ) {
         return kTRUE;
      } else if( mgr.holder()->getClass()->InheritsFrom( dvClass ) ) {
         return kFALSE;
      }
 
      // Some logic error happened:
      ::Error( "xAOD::TEvent::isStandalone",
               XAOD_MESSAGE( "Received type (%s) that can't have an "
                             "auxiliary store" ),
               mgr.holder()->getClass()->GetName() );
      return kFALSE;
   }

keys()

template<typename T >

void xAOD::TVirtualEvent::keys ( std::vector< std::string > &  vkeys, bool  metadata = false  ) const

inherited

provide list of all keys associated with provided type.

usage: event->keys( vec_to_fill, metadata )

Parameters

vkeys	will be filled with the list of keys (may be empty)
metadata	(default false) look in metadata content if true

keyToString() [1/2]

const std::string * xAOD::TEvent::keyToString ( SG::sgkey_t  key ) const

overrideprotectedinherited

Find the string corresponding to a given key.

Definition at line 430 of file TEventProxyDict.cxx.

                                                             {
 
      return &( getName( key ) );
   }

keyToString() [2/2]

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

overrideprotectedinherited

Find the string and CLID corresponding to a given key.

Definition at line 435 of file TEventProxyDict.cxx.

                                                                    {
 
      return &( getName( key ) );
   }

name()

const std::string & xAOD::TEvent::name ( ) const

overrideprotectedinherited

Get the name of the instance.

Definition at line 452 of file TEventProxyDict.cxx.

                                       {
 
      static const std::string NAME = "xAOD::TEvent";
      return NAME;
   }

outputEventFormat()

const EventFormat * xAOD::TEvent::outputEventFormat ( ) const

inherited

Get information about the output objects.

This function makes it possible for the user to investigate the content that is being written to the output file.

Notice that this doesn't necessarily mean that all the objects for which metadata is stored, would necessarily be part of the output TTree that this object is connected to.

Returns

The event format object if a file is being written, or a null pointer if not.

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

                                                      {
 
      // If we *are* reading an input file:
      if( m_outTree ) {
         return m_outputEventFormat;
      }
 
      // If not, let's complain:
      ::Warning( "xAOD::TEvent::outputEventFormat",
                 "No output file is connected at the moment" );
      return 0;
   }

printIOStats()

void xAOD::TEvent::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 348 of file Control/xAODRootAccess/Root/TEvent.cxx.

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

printNameRemap()

void xAOD::TEvent::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 1034 of file Control/xAODRootAccess/Root/TEvent.cxx.

                                     {
 
      // Print a header:
      ::Info( "xAOD::TEvent::printNameRemap", "Name remapping rules:" );
 
      // In case no remapping rules have been set:
      if( ! m_nameRemapping.size() ) {
         ::Info( "xAOD::TEvent::printNameRemap", "   NONE" );
         return;
      }
 
      // Otherwise:
      for( auto itr = m_nameRemapping.begin(); itr != m_nameRemapping.end();
           ++itr ) {
         ::Info( "xAOD::TEvent::printNameRemap", "   \"%s\" -> \"%s\"",
                 itr->second.c_str(), itr->first.c_str() );
      }
 
      // Return gracefully:
      return;
   }

proxies()

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

overrideprotectedinherited

return the list of all current proxies in store

Definition at line 411 of file TEventProxyDict.cxx.

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

proxy() [1/2]

SG::DataProxy * xAOD::TEvent::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 234 of file TEventProxyDict.cxx.

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

proxy() [2/2]

SG::DataProxy * xAOD::TEvent::proxy ( const void *const  pTransient ) const

overrideprotectedinherited

get proxy for a given data object address in memory

Definition at line 206 of file TEventProxyDict.cxx.

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

proxy_exact()

SG::DataProxy * xAOD::TEvent::proxy_exact ( SG::sgkey_t  sgkey ) const

overrideprotectedinherited

Get proxy given a hashed key+clid.

Definition at line 244 of file TEventProxyDict.cxx.

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

putAux()

StatusCode xAOD::TEvent::putAux ( ::TTree &  outTree, TVirtualManager &  vmgr, ::Int_t  basketSize = 32000, ::Int_t  splitLevel = 0, ::Bool_t  metadata = kFALSE  )

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

outTree	The TTree to put the auxiliary branches into
mgr	The object manager of the output object
basketSize	Size of the buffer associated with the branches
splitLevel	The split level to use for the created branches
metadata	Flag specifying whether the info written is metadata or not

Returns

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

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

                                                 {
 
      // A little sanity check:
      assert( m_outputEventFormat != 0 );
 
      // Do the conversion:
      TObjectManager* mgr = dynamic_cast< TObjectManager* >( &vmgr );
      if( ! mgr ) {
         // It's not an error any more when we don't get a TObjectManager.
         return StatusCode::SUCCESS;
      }
 
      // Check if we need to do anything here:
      if( ! mgr->holder()->getClass()->InheritsFrom( "SG::IAuxStoreIO" ) ) {
         return StatusCode::SUCCESS;
      }
 
      // Get a pointer to the auxiliary store I/O interface:
      SG::IAuxStoreIO* aux =
         reinterpret_cast< SG::IAuxStoreIO* >(
            mgr->holder()->getAs( typeid( SG::IAuxStoreIO ) ) );
      if( ! aux ) {
         ::Fatal( "xAOD::TEvent::putAux",
                  XAOD_MESSAGE( "There is a logic error in the code!" ) );
      }
 
      // Check if we have rules defined for which auxiliary properties
      // to write out:
      xAOD::AuxSelection sel;
      if( ! metadata ) {
         auto item_itr = m_auxItemList.find( mgr->branch()->GetName() );
         if( item_itr != m_auxItemList.end() ) {
            sel.selectAux( item_itr->second );
         }
      }
 
      // Get the dynamic auxiliary variables held by this object, which
      // were selected to be written:
      const SG::auxid_set_t auxids = sel.getSelectedAuxIDs (aux->getSelectedAuxIDs());
 
      // If there are no dynamic auxiliary variables in the object, return
      // right away:
      if( auxids.empty() ) {
         return StatusCode::SUCCESS;
      }
 
      // Decide what should be the prefix of all the dynamic branches:
      const std::string dynNamePrefix =
         Utils::dynBranchPrefix( mgr->branch()->GetName() );
 
      // Select which container to add the variables to:
      Object_t& objects = ( metadata ? m_outputMetaObjects : m_outputObjects );
 
      // This iteration will determine the ordering of branches within
      // the tree, so sort auxids by name.
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      typedef std::pair< std::string, SG::auxid_t > AuxVarSort_t;
      std::vector< AuxVarSort_t > varsort;
      varsort.reserve( auxids.size() );
      for( SG::auxid_t id : auxids ) {
         varsort.emplace_back( r.getName( id ), id );
      }
      std::sort( varsort.begin(), varsort.end() );
 
      // Extract all the dynamic variables from the object:
      for( const auto& p : varsort ) {
 
         // The auxiliary ID:
         const SG::auxid_t id = p.second;
 
         // Construct a name for the branch that we will write:
         const std::string brName = dynNamePrefix + p.first;
 
         // Try to find the branch:
         Object_t::iterator bmgr = objects.find( brName );
 
         // Check if we already know about this variable:
         if( bmgr == objects.end() ) {
 
            // Construct the full type name of the variable:
            const std::type_info* brType = aux->getIOType( id );
            if( ! brType ) {
               ::Error( "xAOD::TEvent::putAux",
                        XAOD_MESSAGE( "No I/O type found for variable %s" ),
                        brName.c_str() );
               return StatusCode::FAILURE;
            }
            const std::string brTypeName =
               Utils::getTypeName( *brType );
            std::string brProperTypeName = "<unknown>";
 
            // The branch that will hopefully be created:
            ::TBranch* br = 0;
 
            // Check if it's a primitive type or not:
            if( strlen( brType->name() ) == 1 ) {
 
               // Making the "proper" type name is simple in this case:
               brProperTypeName = brTypeName;
 
               // Get the character describing this type for ROOT:
               const char rootType = Utils::rootType( brType->name()[ 0 ] );
               if( rootType == '\0' ) {
                  ::Error( "xAOD::TEvent::putAux",
                           XAOD_MESSAGE( "Type not known for variable \"%s\" "
                                         "of type \"%s\"" ),
                           brName.c_str(), brTypeName.c_str() );
                  return StatusCode::FAILURE;
               }
 
               // Create the full description of the variable for ROOT:
               std::ostringstream leaflist;
               leaflist << brName << "/" << rootType;
 
               // Let's create a holder for this property:
               THolder* hldr = new THolder( aux->getIOData( id ),
                                            0, kFALSE );
               TPrimitiveAuxBranchManager* auxmgr =
                  new TPrimitiveAuxBranchManager( id, 0, hldr );
               objects[ brName ] = auxmgr;
 
               // ... and let's add it to the output TTree:
               *( auxmgr->branchPtr() ) =
                  outTree.Branch( brName.c_str(), hldr->get(),
                                  leaflist.str().c_str(),
                                  basketSize );
               if( ! auxmgr->branch() ) {
                  ::Error( "xAOD::TEvent::putAux",
                           XAOD_MESSAGE( "Failed to create branch \"%s\" out "
                                         "of type \"%s\"" ),
                           brName.c_str(), brProperTypeName.c_str() );
                  // Clean up:
                  *( auxmgr->holder()->getPtr() ) = 0;
                  delete auxmgr;
                  objects.erase( brName );
                  return StatusCode::FAILURE;
               }
               br = auxmgr->branch();
 
            } else {
 
               // Check if we have a dictionary for this type:
               TClass* cl = TClass::GetClass( *brType, kTRUE, kTRUE );
               if( ! cl ) {
                  // The dictionary needs to be loaded now. This could be an
                  // issue. But let's hope for the best...
                  cl = TClass::GetClass( brTypeName.c_str() );
                  // If still not found...
                  if( ! cl ) {
                     ::Error( "xAOD::TEvent::putAux",
                              XAOD_MESSAGE( "Dictionary not available for "
                                            "variable \"%s\" of type \"%s\"" ),
                              brName.c_str(), brTypeName.c_str() );
                     return StatusCode::FAILURE;
                  }
               }
 
               // The proper type name comes from the dictionary in this case:
               brProperTypeName = cl->GetName();
 
               // Let's create a holder for this property:
               THolder* hldr = new THolder( aux->getIOData( id ),
                                            cl, kFALSE );
               TAuxBranchManager* auxmgr =
                  new TAuxBranchManager( id, 0, hldr );
               objects[ brName ] = auxmgr;
 
               if (!cl->CanSplit() && strncmp (cl->GetName(), "SG::PackedContainer<", 20) == 0)
                 splitLevel = 0;
 
               // ... and let's add it to the output TTree:
               *( auxmgr->branchPtr() ) =
                  outTree.Branch( brName.c_str(),
                                  cl->GetName(),
                                  hldr->getPtr(), basketSize, splitLevel );
               if( ! auxmgr->branch() ) {
                  ::Error( "xAOD::TEvent::putAux",
                           XAOD_MESSAGE( "Failed to create branch \"%s\" out "
                                         "of type \"%s\"" ),
                           brName.c_str(), brProperTypeName.c_str() );
                  // Clean up:
                  *( auxmgr->holder()->getPtr() ) = 0;
                  delete auxmgr;
                  objects.erase( brName );
                  return StatusCode::FAILURE;
               }
               br = auxmgr->branch();
 
            }
 
            // If this is not the first event, fill up the already filled
            // events with (empty) content:
            if( outTree.GetEntries() ) {
               void* ptr = br->GetAddress();
               br->SetAddress( 0 );
               for( ::Long64_t i = 0; i < outTree.GetEntries(); ++i ) {
                  br->Fill();
               }
               br->SetAddress( ptr );
            }
 
            // If all went fine, let's add this branch to the event format
            // metadata:
            if( ! m_outputEventFormat->exists( brName ) ) {
               m_outputEventFormat->add(
                      EventFormatElement( brName,
                                          brProperTypeName,
                                          mgr->branch()->GetName(),
                                          getHash( brName ) ) );
            }
 
            // We don't need to do the rest:
            continue;
         }
 
         // Access the object manager:
         bmgr = objects.find( brName );
         if( bmgr == objects.end() ) {
            ::Fatal( "xAOD::TEvent::putAux",
                     XAOD_MESSAGE( "There is an internal logic error in the "
                                   "code..." ) );
         }
 
         // Replace the managed object:
         void* nc_data ATLAS_THREAD_SAFE = // we hold non-const pointers but check on retrieve
           const_cast< void* >( static_cast< const void* >( aux->getIOData( id ) ) );
         bmgr->second->setObject( nc_data );
      }
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

readFrom() [1/2]

StatusCode xAOD::TEvent::readFrom ( ::TFile *  file, Bool_t  useTreeCache = kTRUE, const char *  treeName = EVENT_TREE_NAME  )

inherited

Connect the object to a new input file.

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

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

Parameters

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

Returns

kTRUE if successful, kFALSE otherwise

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

                                                        {
 
      // If no file was specified, return gracefully:
      if( ! file ) return StatusCode::SUCCESS;
 
      // Clear the cached input objects:
      Object_t::iterator itr = m_inputObjects.begin();
      Object_t::iterator end = m_inputObjects.end();
      for( ; itr != end; ++itr ) {
         delete itr->second;
      }
      m_inputObjects.clear();
      m_inputMissingObjects.clear();
      {
        upgrading_lock_t lock(m_branchesMutex);
        lock.upgrade();
        m_branches.clear();
      }
 
      // Clear the cached input meta-objects:
      itr = m_inputMetaObjects.begin();
      end = m_inputMetaObjects.end();
      for( ; itr != end; ++itr ) {
         delete itr->second;
      }
      m_inputMetaObjects.clear();
 
      // Reset the internal flags:
      m_inTreeMissing = kFALSE;
      m_entry = -1;
 
      // Make sure we return to the current directory:
      TDirectoryReset dr;
 
      // Set up the file access tracer:
      static TFileAccessTracer tracer ATLAS_THREAD_SAFE;
      tracer.add( *file );
 
      // Look for the metadata tree:
      m_inMetaTree =
         dynamic_cast< ::TTree* >( file->Get( METADATA_TREE_NAME ) );
      if( ! m_inMetaTree ) {
         ::Error( "xAOD::TEvent::readFrom",
                  XAOD_MESSAGE( "Couldn't find metadata tree on input. Object "
                                "unusable!" ) );
         return StatusCode::FAILURE;
      }
 
      // Set metadata entry to be read 
      // NB: no reading is done calling LoadTree
      if ( m_inMetaTree->LoadTree(0) < 0 ){
         ::Error( "xAOD::TEvent::readFrom",
                  XAOD_MESSAGE( "Failed to load entry for metadata tree=%s" ),
                  m_inMetaTree->GetName() );
         return StatusCode::FAILURE;
      }
 
      // A sanity check:
      if( m_inMetaTree->GetEntries() != 1 ) {
         ::Info( "xAOD::TEvent::readFrom",
                 "Was expecting a metadata tree with size 1, instead of %i.",
                 static_cast< int >( m_inMetaTree->GetEntries() ) );
         ::Info( "xAOD::TEvent::readFrom",
                 "File most probably produced by hadd..." );
      }
 
      // Make sure that the xAOD::EventFormat dictonary is loaded.
      // This may not be the case if streamer information reading is turned
      // off.
      static const std::string eventFormatTypeName =
         Utils::getTypeName( typeid( EventFormat ) );
      ::TClass* cl = ::TClass::GetClass( eventFormatTypeName.c_str() );
      if( ! cl ) {
         ::Warning( "xAOD::TEvent::readFrom",
                    "Couldn't load the EventFormat dictionary" );
      }
 
      // Check if the EventFormat branch is available:
      const std::string eventFormatBranchName =
         Utils::getFirstBranchMatch( m_inMetaTree, "EventFormat");
      if( ! m_inMetaTree->GetBranch( eventFormatBranchName.c_str() ) ) {
         // This can happen when the file was produced by an Athena job that
         // didn't have any input events itself. This means that the file
         // doesn't actually have any useful metadata.
         ::Info( "xAOD::TEvent::readFrom", "Input file provides no event or "
                 "metadata" );
         m_inTree = 0;
         m_inTreeMissing = kTRUE;
         return StatusCode::SUCCESS;
      }
 
      // Read in the event format object:
      EventFormat* format = 0; ::TBranch* br = 0;
      const Int_t status =
         m_inMetaTree->SetBranchAddress( eventFormatBranchName.c_str(),
                                         &format, &br );
      if( status < 0 ) {
         ::Error( "xAOD::TEvent::readFrom",
                  XAOD_MESSAGE( "Failed to connect to EventFormat object" ) );
         return StatusCode::FAILURE;
      }
 
      // Read in the object to our private member:
      br->GetEntry( 0 );
      m_inputEventFormat = *format;
 
      // This is a strange place. The object has to be deleted, as it is the
      // responsibility of the user code to do so. But if I also explicitly
      // tell the branch to forget about the address of the pointer, then
      // all hell breaks loose...
      delete format;
 
 
      // List all the other Metadata trees in the input file 
      // Having several metatrees can happen for augmented files for instance 
      // as one metadata tree per stream is produced  
      std::set<std::string> lOtherMetaTreeNames = {};
      TList *lKeys = file->GetListOfKeys();
 
      if (lKeys){
         for (int iKey = 0; iKey < lKeys->GetEntries() ; iKey++){
            // iterate over keys and add 
            std::string keyName = lKeys->At(iKey)->GetName();
            // Make sure the key corresponds to a metadata tree but  
            // do not add the current metadata tree in the list of other trees
            // and do not add the metadata tree handlers to the list  
            if (  (keyName != METADATA_TREE_NAME) 
               && (keyName.find("MetaData") != std::string::npos)
               && !(keyName.find("MetaDataHdr") != std::string::npos)){
               // Make sure key corresponds to a tree 
               const char *className = ((::TKey*)lKeys->At(iKey))->GetClassName();
               static constexpr Bool_t LOAD = kFALSE;
               static constexpr Bool_t SILENT = kTRUE;
               ::TClass* cl = ::TClass::GetClass(className, LOAD, SILENT);
               if ((cl != nullptr) && cl->InheritsFrom(::TTree::Class())){
                  // key is corresponding to a metadata tree 
                  lOtherMetaTreeNames.insert(keyName);
               }
            }
         }
      }
 
      // Loop over the other metadata trees found (if any) 
      for (const std::string & metaTreeName : lOtherMetaTreeNames){
         TTree *tmpMetaTree =  dynamic_cast< ::TTree* >( file->Get( metaTreeName.c_str() ) );
 
         if (!tmpMetaTree){ 
            // Skip tree if could not read it 
            ::Warning( "xAOD::TEvent::readFrom", "Could not read metadata tree=%s",metaTreeName.c_str());
            continue;
         }
 
         // Set metadata entry to be read 
         // NB: no reading is done calling LoadTree
         if ( tmpMetaTree->LoadTree(0) < 0 ){
            ::Error( "xAOD::TEvent::readFrom",
                     XAOD_MESSAGE( "Failed to load entry for metadata tree=%s" ),
                     tmpMetaTree->GetName() );
            return StatusCode::FAILURE;
         }
 
         // Check if the EventFormat branch is available:
         const std::string tmpEventFormatBranchName =
            Utils::getFirstBranchMatch( tmpMetaTree, "EventFormat");
         if( ! tmpMetaTree->GetBranch( tmpEventFormatBranchName.c_str() ) ) {
           // skip the additionnal metadata tree 
           ::Warning( "xAOD::TEvent::readFrom", "No EventFormat branch found in metadata tree=%s",tmpMetaTree->GetName() );
            continue ;
         }
         // Read in the event format object:
         EventFormat* tmpFormat = 0; ::TBranch* tmpBr = 0;
         const Int_t status =
            tmpMetaTree->SetBranchAddress( tmpEventFormatBranchName.c_str(),
                                          &tmpFormat, &tmpBr );
         if( status < 0 ) {
            ::Error( "xAOD::TEvent::readFrom",
                     XAOD_MESSAGE( "Failed to connect to EventFormat object for metadata tree = %s"), tmpMetaTree->GetName() );
            return StatusCode::FAILURE;
         }
         // Read in the object 
         tmpBr->GetEntry( 0 );
         // read all objects contained in the event format 
         for (const std::pair<const std::string, xAOD::EventFormatElement> &evtElem : *tmpFormat){
            // if element is not existing 
            // then add it to the private event format member
            if (!m_inputEventFormat.exists(evtElem.first)){
               m_inputEventFormat.add(evtElem.second);
            }
         }
         delete tmpFormat;
      }
 
      // Look for the event tree in the input file:
      m_inTree = dynamic_cast< ::TTree* >( file->Get( treeName ) );
      if( ! m_inTree ) {
         // This is no longer an error condition. As it can happen for DxAODs
         // that don't have any events in them. But they still have metadata
         // that needs to be collected.
         m_inTreeMissing = kTRUE;
      }
     
      // Turn on the cache if requested:
      if( m_inTree && useTreeCache && ( ! m_inTree->GetCacheSize() ) ) {
         m_inTree->SetCacheSize( CACHE_SIZE );
         m_inTree->SetCacheLearnEntries( 10 );
      }
 
      // Init the statistics collection:
      RETURN_CHECK( "xAOD::TEvent::readFrom", initStats() );
      // Update the event counter in the statistics object:
      xAOD::ReadStats& stats = IOStats::instance().stats();
      if( m_inTree ) {
         stats.setNEvents( stats.nEvents() + m_inTree->GetEntries() );
      }
 
      // Notify the listeners that a new file was opened:
      const TIncident beginIncident( IncidentType::BeginInputFile );
      for( TVirtualIncidentListener* listener : m_listeners ) {
         listener->handle( beginIncident );
      }
      // For now implement a very simple scheme in which we claim already
      // at the start that the entire file was processed. Since we have no way
      // of ensuring that the user indeed does this. And we can't delay calling
      // this function, as the user may likely close his/her output file before
      // closing the last opened input file.
      const TIncident endIncident( IncidentType::EndInputFile );
      for( TVirtualIncidentListener* listener : m_listeners ) {
         listener->handle( endIncident );
      }
 
      // The initialisation was successful:
      return StatusCode::SUCCESS;
   }

readFrom() [2/2]

StatusCode xAOD::TEvent::readFrom ( ::TTree *  tree, Bool_t  useTreeCache = kTRUE  )

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

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

Returns

kTRUE if successful, kFALSE when not

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

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

record() [1/5]

StatusCode xAOD::TPyEvent::record	(	int	dummy,
		void *	obj,
		const std::string &	key,
		const std::string &	type,
		::Int_t	basketSize = 32000,
		::Int_t	splitLevel = 0
	)

Add an output object to the event.

This function is designed to be callable from PyROOT in order to record hand-made containers into an output file.

Notice that unline TEvent::record(...), this function doesn't take ownership of the object that's given to it. That's because all objects created by the Python interpreter are garbage collected by the Python interpreter. And we don't want to run into double-deletes.

Parameters

dummy	Necessary to make sure that this function's signature is distinct from xAOD::TEvent::record. So that PyROOT would not mistake them for each other.
obj	Typeless pointer to the object that is to be recorded
key	The key with which the object is to be recorded
type	The type name of the object being recorded
basketSize	The size of the baskets used to write the payload
splitLevel	The split level of the branch created

Returns

The usual StatusCode types

Definition at line 79 of file TPyEvent.cxx.

                                                                      {
 
      // Simply forward the call to the base class:
      RETURN_CHECK( "xAOD::TPyEvent::record",
                    TEvent::record( obj, type, key, basketSize, splitLevel,
                                    kFALSE, kFALSE, kFALSE ) );
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

record() [2/5]

template<typename T >

StatusCode xAOD::TEvent::record ( std::unique_ptr< T >  obj, const std::string &  key, ::Int_t  basketSize = 32000, ::Int_t  splitLevel = 0  )

inherited

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

record() [3/5]

template<typename T >

StatusCode xAOD::TEvent::record ( T *  obj, const std::string &  key, ::Int_t  basketSize = 32000, ::Int_t  splitLevel = 0  )

inherited

Add an output object to the event.

record() [4/5]

StatusCode xAOD::TEvent::record ( TAuxStore *  store, const std::string &  key, ::Int_t  basketSize, ::Int_t  splitLevel, ::Bool_t  ownsStore = kFALSE  )

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

store	The store object to connect to the output
key	The "key" with which to record the object
basketSize	The basket size of the output branches
splitLevel	The split level of the output branches

Returns

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

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

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

record() [5/5]

StatusCode xAOD::TEvent::record ( void *  obj, const std::string &  typeName, const std::string &  key, ::Int_t  basketSize, ::Int_t  splitLevel, ::Bool_t  overwrite = kFALSE, ::Bool_t  metadata = kFALSE, ::Bool_t  isOwner = kTRUE  )

inherited

Internal function for recording an object into the output.

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

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

Parameters

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

Returns

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

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

                                                {
 
      // Check if we have an output tree:
      if( ! m_outTree ) {
         ::Error( "xAOD::TEvent::record",
                  XAOD_MESSAGE( "No output tree defined. Did you forget to "
                                "call writeTo(...)?" ) );
         return StatusCode::FAILURE;
      }
      assert( m_outputEventFormat != 0 );
 
      // If this is metadata, just take ownership of it. The object will only
      // be recorded into the output file when calling finishWritingTo(...).
      if( metadata ) {
         // Check whether we already have such an object:
         if( ( ! overwrite ) &&
             ( m_outputMetaObjects.find( key ) !=
               m_outputMetaObjects.end() ) ) {
            ::Error( "xAOD::TEvent::record",
                     XAOD_MESSAGE( "Meta-object %s/%s already recorded" ),
                     typeName.c_str(), key.c_str() );
            return StatusCode::FAILURE;
         }
         // Check if we have a dictionary for this object:
         TClass* cl = TClass::GetClass( typeName.c_str() );
         if( ! cl ) {
            ::Error( "xAOD::TEvent::record",
                     XAOD_MESSAGE( "Didn't find dictionary for type: %s" ),
                     typeName.c_str() );
            return StatusCode::FAILURE;
         }
         // Let's create a holder for the object:
         THolder* hldr = new THolder( obj, cl, isOwner );
         TObjectManager* mgr =
            new TObjectManager( 0, hldr, m_auxMode == kAthenaAccess );
         m_outputMetaObjects[ key ] = mgr;
         // We're done. The rest will be done later on.
         return StatusCode::SUCCESS;
      }
 
      // Check if we accessed this object on the input. If yes, then this
      // key may not be used for recording.
      if( ( ! overwrite ) &&
          ( m_inputObjects.find( key ) != m_inputObjects.end() ) ) {
         ::Error( "xAOD::TEvent::record",
                  XAOD_MESSAGE( "Object %s/%s already accessed from the input, "
                                "can't be overwritten in memory" ),
                  typeName.c_str(), key.c_str() );
         return StatusCode::FAILURE;
      }
 
      // Override the default 0 split level with a split level of 1 for
      // auxiliary container objects.
      if( ( splitLevel == 0 ) &&
          ( key.find( "Aux." ) == ( key.size() - 4 ) ) ) {
         splitLevel = 1;
      }
 
      // Check if we need to add it to the event record:
      Object_t::iterator vitr = m_outputObjects.find( key );
      if( vitr == m_outputObjects.end() ) {
 
         // Check if we have a dictionary for this object:
         TClass* cl = TClass::GetClass( typeName.c_str() );
         if( ! cl ) {
            ::Error( "xAOD::TEvent::record",
                     XAOD_MESSAGE( "Didn't find dictionary for type: %s" ),
                     typeName.c_str() );
            return StatusCode::FAILURE;
         }
 
         // Check if this is a new object "type" or not:
         if( ! m_outputEventFormat->exists( key ) ) {
            m_outputEventFormat->add( EventFormatElement( key, cl->GetName(),
                                                          "", getHash( key ) ) );
         }
 
         // Let's create a holder for the object:
         THolder* hldr = new THolder( obj, cl, isOwner );
         TObjectManager* mgr =
            new TObjectManager( 0, hldr, m_auxMode == kAthenaAccess );
         m_outputObjects[ key ] = mgr;
 
         // ... and let's add it to the output TTree:
         *( mgr->branchPtr() ) =
            m_outTree->Branch( key.c_str(), cl->GetName(),
                               hldr->getPtr(), basketSize, splitLevel );
         if( ! mgr->branch() ) {
            ::Error( "xAOD::TEvent::record",
                     XAOD_MESSAGE( "Failed to create branch \"%s\" out of "
                                   "type \"%s\"" ),
                     key.c_str(), cl->GetName() );
            // Clean up:
            hldr->setOwner( kFALSE );
            delete mgr;
            return StatusCode::FAILURE;
         }
 
         // Set up the saving of all the dynamic auxiliary properties
         // of the object if it has any:
         RETURN_CHECK( "xAOD::TEvent::record",
                       putAux( *m_outTree, *mgr, basketSize, splitLevel,
                               kFALSE ) );
 
         // Return at this point, as we don't want to run the rest of
         // the function's code:
         return StatusCode::SUCCESS;
      }
 
      // Access the object manager:
      TObjectManager* omgr = dynamic_cast< TObjectManager* >( vitr->second );
      if( ! omgr ) {
         ::Error( "xAOD::TEvent::record",
                  XAOD_MESSAGE( "Manager object of the wrong type "
                                "encountered" ) );
         return StatusCode::FAILURE;
      }
 
      // Check that the type of the object matches that of the previous
      // object:
      if( typeName != omgr->holder()->getClass()->GetName() ) {
         // This may still be, when the ROOT dictionary name differs from the
         // "simple type name" known to C++. So let's get the ROOT name of the
         // new type:
         TClass* cl = TClass::GetClass( typeName.c_str() );
         if( ( ! cl ) || ::strcmp( cl->GetName(),
                                   omgr->holder()->getClass()->GetName() ) ) {
            ::Error( "xAOD::TEvent::record",
                     XAOD_MESSAGE( "For output key \"%s\" the previous type "
                                   "was \"%s\", the newly requested type is "
                                   "\"%s\"" ),
                     key.c_str(), omgr->holder()->getClass()->GetName(),
                     typeName.c_str() );
            return StatusCode::FAILURE;
         }
      }
 
      // Replace the managed object:
      omgr->setObject( obj );
 
      // Replace the auxiliary objects:
      return putAux( *m_outTree, *omgr, basketSize, splitLevel, kFALSE );
   }

recordAux()

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

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

key	The name/prefix of the auxiliary store object/branches
type	The type of the auxiliary store (object/container)
basketSize	Size of the baskets created by the store object
splitLevel	The split level of the branches created by the store

Returns

An auxiliary store object that will write to the output

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

                                                                          {
 
      // A sanity check:
      if( ! m_outTree ) {
         ::Error( "xAOD::TEvent::recordAux",
                  XAOD_MESSAGE( "No output tree given to the object" ) );
         return 0;
      }
 
      // Check for an object with this name in the output list:
      Object_t::iterator itr = m_outputObjects.find( key );
      if( itr == m_outputObjects.end() ) {
         // Create one if if it doesn't exist yet...
         // Translate the store type:
         TAuxStore::EStructMode mode = TAuxStore::kUndefinedStore;
         switch( type ) {
         case SG::IAuxStoreHolder::AST_ObjectStore:
            mode = TAuxStore::kObjectStore;
            break;
         case SG::IAuxStoreHolder::AST_ContainerStore:
            mode = TAuxStore::kContainerStore;
            break;
         default:
            ::Error( "xAOD::TEvent::recordAux",
                     XAOD_MESSAGE( "Unknown store type (%i) requested" ),
                     static_cast< int >( type ) );
            return 0;
         }
         // Create and record the object:
         TAuxStore* store = new TAuxStore( key.c_str(), kTRUE, mode,
                                           basketSize, splitLevel );
         if( record( store, key, basketSize, splitLevel, kTRUE ).isFailure() ) {
            ::Error( "xAOD::TEvent::recordAux",
                     XAOD_MESSAGE( "Couldn't connect TAuxStore object to the "
                                   "output" ) );
            delete store;
            return 0;
         }
         // Update the iterator:
         itr = m_outputObjects.find( key );
      }
 
      // A security check:
      if( itr == m_outputObjects.end() ) {
         ::Error( "xAOD::TEvent::recordAux",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
         return 0;
      }
 
      // Check that it is of the right type:
      TAuxManager* mgr = dynamic_cast< TAuxManager* >( itr->second );
      if( ! mgr ) {
         ::Error( "xAOD::TEvent::recordAux",
                  XAOD_MESSAGE( "Object of non-TAuxStore type registered "
                                "with key \"%s\"" ), key.c_str() );
         return 0;
      }
 
      // Extract the pointer out of it:
      TAuxStore* store = mgr->getStore();
 
      // Give it to the user:
      return store;
   }

recordMeta() [1/2]

template<typename T >

StatusCode xAOD::TEvent::recordMeta ( std::unique_ptr< T >  obj, const std::string &  key, ::Int_t  basketSize = 32000, ::Int_t  splitLevel = 1  )

inherited

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

recordMeta() [2/2]

template<typename T >

StatusCode xAOD::TEvent::recordMeta ( T *  obj, const std::string &  key, ::Int_t  basketSize = 32000, ::Int_t  splitLevel = 1  )

inherited

Add an object to the output file's metadata.

recordObject()

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

overrideprotectedinherited

Record an object in the store.

Definition at line 445 of file TEventProxyDict.cxx.

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

registerKey()

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

overrideprotectedinherited

Remember an additional mapping from key to string/CLID.

Definition at line 440 of file TEventProxyDict.cxx.

                                                               {
 
      return;
   }

removeListener()

StatusCode xAOD::TEvent::removeListener ( TVirtualIncidentListener *  listener )

inherited

Remove an incident listener object.

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

Parameters

listener

Pointer to the listener that should be removed

Returns

The usual StatusCode types

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

                                                                         {
 
      // Find the pointer if we can...
      Listener_t::iterator itr = std::find( m_listeners.begin(),
                                            m_listeners.end(), listener );
 
      // If we didn't find it:
      if( itr == m_listeners.end() ) {
         ::Error( "xAOD::TEvent::removeListener",
                  XAOD_MESSAGE( "Listener %p not known" ),
                  static_cast< void* >( listener ) );
         return StatusCode::FAILURE;
      }
 
      // Remove it:
      m_listeners.erase( itr );
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

retrieve() [1/4]

template<typename T >

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

inherited

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

retrieve() [2/4]

template<typename T >

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

inherited

Function retrieving an object from the event (constant version)

retrieve() [3/4]

template<typename T >

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

inherited

Function retrieving an object from the event (constant version)

retrieve() [4/4]

template<typename T >

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

inherited

Retrieve an output object from the event.

retrieveMetaInput()

template<typename T >

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

inherited

Retrieve an input metadata object.

retrieveMetaOutput() [1/2]

template<typename T >

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

inherited

Retrieve an output metadata object.

retrieveMetaOutput() [2/2]

template<typename T >

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

inherited

Retrieve an output metadata object.

setActive()

void xAOD::TEvent::setActive ( ) const

inherited

Set this event object as the currently active one.

Setting TEvent objects happens automatically when reading a file, but when writing a file from scratch, the code doesn't necessarily know which TEvent object a given smart pointer should "belong to".

This function helps the user with setting this up.

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

                                {
 
      // The active event and current store are thread-local globals:
      TEvent* nc_this ATLAS_THREAD_SAFE = const_cast<TEvent*>(this);
 
      TActiveEvent::setEvent( static_cast<TVirtualEvent*>( nc_this ) );
 
#ifndef XAOD_STANDALONE
      SG::CurrentEventStore::setStore( nc_this );
#endif // not XAOD_STANDALONE
 
      // Return gracefully:
      return;
   }

setAuxItemList()

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

inherited

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

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

Parameters

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

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

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

setAuxStore()

StatusCode xAOD::TEvent::setAuxStore ( TObjectManager &  mgr, ::Bool_t  metadata = kFALSE  )

protectedinherited

Function connecting a DV object to its auxiliary store.

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

This function takes care of this.

Parameters

mgr	The manager object of the DV container
metadata	Flag specifying whether we're dealing with a metadata or event data object

Returns

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

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

                                                      {
 
      // Check if we need to do anything:
      if( ( ! hasAuxStore( mgr ) ) && ( ! isAuxStore( mgr ) ) ) {
         return StatusCode::SUCCESS;
      }
 
      // Get the branch name of the object in question:
      const std::string key = mgr.branch()->GetName();
 
      // Select which object container to use:
      Object_t& objects = ( metadata ?
                            m_inputMetaObjects : m_inputObjects );
 
 
      // Look up the auxiliary object's manager:
      TVirtualManager* auxMgr = nullptr;
      std::string auxKey;
      if( isAuxStore( mgr ) ) {
         auxMgr = &mgr;
         auxKey = key;
      } else {
         auto itr = objects.find( key + "Aux." );
         if( itr == objects.end() ) {
            // Apparently there's no auxiliary object for this DV, so let's
            // give up:
            return StatusCode::SUCCESS;
         }
         auxMgr = itr->second;
         auxKey = key + "Aux.";
      }
 
      if( ! metadata ) {
         // Make sure the auxiliary object is up to date:
         ::Int_t readBytes = auxMgr->getEntry();
 
         // Check if there is a separate auxiliary object for the dynamic
         // variables:
         const std::string dynAuxKey = auxKey + "Dynamic";
         auto dynAuxMgr = objects.find( dynAuxKey );
 
         if( ( dynAuxMgr != objects.end() ) &&
             ( readBytes || ( m_auxMode == kAthenaAccess ) ||
               ( auxMgr == &mgr ) ) ) {
            // Do different things based on the access mode:
            if( m_auxMode != kAthenaAccess ) {
               // In "normal" access modes just tell the dynamic store object
               // to switch to a new event.
               dynAuxMgr->second->getEntry();
            } else {
               // In "Athena mode" this object has already been deleted when
               // the main auxiliary store object was switched to the new
               // event. So let's re-create it:
               xAOD::TObjectManager& auxMgrRef =
                  dynamic_cast< xAOD::TObjectManager& >( *auxMgr );
               RETURN_CHECK( "xAOD::TEvent::setAuxStore",
                             setUpDynamicStore( auxMgrRef,
                                                ( metadata ?
                                                  m_inMetaTree :
                                                  m_inTree ) ) );
               // Now tell the newly created dynamic store object which event
               // it should be looking at:
               auto dynAuxMgr = objects.find( dynAuxKey );
               if( dynAuxMgr == objects.end() ) {
                  ::Error( "xAOD::TEvent::setAuxStore",
                           XAOD_MESSAGE( "Internal logic error detected" ) );
                  return StatusCode::FAILURE;
               }
               dynAuxMgr->second->getEntry();
            }
         }
      }
 
      // Stop here if we've set up an auxiliary store.
      if( auxMgr == &mgr ) {
         return StatusCode::SUCCESS;
      }
 
      // Access the auxiliary base class of the object/vector:
      SG::AuxVectorBase* vec = 0;
      SG::AuxElement* aux = 0;
      switch( mgr.holder()->typeKind() ) {
      case THolder::DATAVECTOR:
         {
            void* vvec = mgr.holder()->getAs( typeid( SG::AuxVectorBase ) );
            vec = reinterpret_cast< SG::AuxVectorBase* >( vvec );
         }
         break;
      case THolder::AUXELEMENT:
         {
            void* vaux = mgr.holder()->getAs( typeid( SG::AuxElement ) );
            aux = reinterpret_cast< SG::AuxElement* >( vaux );
         }
         break;
      default:
         break;
      }
 
      // Check whether index tracking is enabled for the type. If not, then
      // we need to fix it...
      if( vec && ( ! vec->trackIndices() ) ) {
         forceTrackIndices( *vec );
      }
 
      // Check if we were successful:
      if( ( ! vec ) && ( ! aux ) ) {
         ::Fatal( "xAOD::TEvent::setAuxStore",
                  XAOD_MESSAGE( "Couldn't access class \"%s\" as "
                                "SG::AuxVectorBase or SG::AuxElement" ),
                  mgr.holder()->getClass()->GetName() );
      }
 
      // Get the auxiliary store object:
      const SG::IConstAuxStore* store = 0;
      if( m_auxMode == kBranchAccess ) {
         // Get the concrete auxiliary manager:
         TAuxManager* amgr = dynamic_cast< TAuxManager* >( auxMgr );
         if( ! amgr ) {
            ::Fatal( "xAOD::TEvent::setAuxStore",
                     XAOD_MESSAGE( "Auxiliary manager for \"%s\" is not of the "
                                   "right type" ), auxKey.c_str() );
            return StatusCode::FAILURE;
         }
         store = amgr->getConstStore();
         // If the store still doesn't know its type, help it now:
         if( amgr->getStore()->structMode() == TAuxStore::kUndefinedStore ) {
            const TAuxStore::EStructMode mode = ( vec ?
                                                  TAuxStore::kContainerStore :
                                                  TAuxStore::kObjectStore );
            RETURN_CHECK( "xAOD::TEvent::setAuxStore",
                          amgr->getStore()->setStructMode( mode ) );
         }
      } else if( m_auxMode == kClassAccess || m_auxMode == kAthenaAccess ) {
         // Get the concrete auxiliary manager:
         TObjectManager* omgr =
            dynamic_cast< TObjectManager* >( auxMgr );
         if( ! omgr ) {
            ::Fatal( "xAOD::TEvent::setAuxStore",
                     XAOD_MESSAGE( "Auxiliary manager for \"%s\" is not of the "
                                   "right type" ), auxKey.c_str() );
            return StatusCode::FAILURE;
         }
         void* p = omgr->holder()->getAs( typeid( SG::IConstAuxStore ) );
         store = reinterpret_cast< const SG::IConstAuxStore* >( p );
      }
      if( ! store ) {
         ::Fatal( "xAOD::TEvent::setAuxStore",
                  XAOD_MESSAGE( "Logic error detected in the code" ) );
      }
 
      // Connect the two:
      if( vec ) {
         vec->setStore( store );
      } else if( aux ) {
         aux->setStore( store );
      } else {
         ::Fatal( "xAOD::TEvent::setAuxStore",
                  XAOD_MESSAGE( "Logic error detected in the code" ) );
      }
 
      // We succeeded:
      return StatusCode::SUCCESS;
   }

setPrintEventProxyWarnings()

void xAOD::TEvent::setPrintEventProxyWarnings ( bool  print )

inherited

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

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

                                                     {
      m_printEventProxyWarnings = print;
   }

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

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

Returns

The usual StatusCode types

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

                                                                          {
 
      // Check if we can call setName(...) on the object:
      ::TMethodCall setNameCall;
      // Don't use this code in Athena access mode. And just accept that access
      // monitoring is disabled in this case...
      if( m_auxMode != kAthenaAccess ) {
         setNameCall.InitWithPrototype( mgr.holder()->getClass(),
                                        "setName", "const char*" );
         if( setNameCall.IsValid() ) {
            // Yes, there is such a function. Let's call it with the branch
            // name:
            const ::TString params =
               ::TString::Format( "\"%s\"", mgr.branch()->GetName() );
            const char* charParams = params.Data();
            setNameCall.Execute( mgr.holder()->get(), charParams );
         } else {
            // This is weird. What sort of auxiliary container is this? :-/
            ::Warning( "xAOD::TEvent::setUpDynamicStore",
                       "Couldn't find setName(...) function for container %s "
                       " (type: %s)",
                       mgr.branch()->GetName(),
                       mgr.holder()->getClass()->GetName() );
         }
      }
 
      // Check if we can switch out the internal store of this object:
      static const TClass* const holderClass =
         TClass::GetClass( typeid( SG::IAuxStoreHolder ) );
      if( ! mgr.holder()->getClass()->InheritsFrom( holderClass ) ) {
         // Nope... So let's just end the journey here.
         return StatusCode::SUCCESS;
      }
 
      // Try to get the object as an IAuxStoreHolder:
      SG::IAuxStoreHolder* storeHolder =
         reinterpret_cast< SG::IAuxStoreHolder* >(
                         mgr.holder()->getAs( typeid( SG::IAuxStoreHolder ) ) );
      if( ! storeHolder ) {
         ::Fatal( "xAOD::TEvent::setUpDynamicStore",
                  XAOD_MESSAGE( "There's a logic error in the code" ) );
         return StatusCode::FAILURE;
      }
 
      // Create a TAuxStore instance that will read the dynamic variables
      // of this container. Notice that the TAuxManager doesn't own the
      // TAuxStore object. It will be owned by the SG::IAuxStoreHolder
      // object.
      TAuxStore* store =
         new TAuxStore( mgr.branch()->GetName(), kFALSE,
                        ( storeHolder->getStoreType() ==
                          SG::IAuxStoreHolder::AST_ObjectStore ?
                          TAuxStore::kObjectStore :
                          TAuxStore::kContainerStore ) );
      // This object is used to read data from the input, it needs to be
      // locked:
      store->lock();
      TAuxManager* amgr = new TAuxManager( store, kFALSE );
      m_inputObjects[ std::string( mgr.branch()->GetName() ) +
                      "Dynamic" ] = amgr;
      RETURN_CHECK( "xAOD::TEvent::setUpDynamicStore",
                    store->readFrom( tree ) );
      // Tell the auxiliary store which entry to use. This is essential for
      // metadata objects, and non-important for event data objects, which will
      // get a possibly different entry loaded in setAuxStore(...).
      store->getEntry( 0 );
 
      // Give this object to the store holder:
      storeHolder->setStore( store );
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

stringToKey()

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

overrideprotectedinherited

Find the string corresponding to a given key.

Definition at line 425 of file TEventProxyDict.cxx.

                                                             {
 
      return getHash( str );
   }

transientContains() [1/3]

template<typename T >

::Bool_t xAOD::TEvent::transientContains ( const std::string &  key ) const

inherited

Function checking if an object is already in memory.

transientContains() [2/3]

Bool_t xAOD::TPyEvent::transientContains	(	const std::string &	key,
		const std::string &	type
	)		const

Function checking if an object is already in memory.

Definition at line 37 of file TPyEvent.cxx.

                                                                       {
 
      // Try to access the dictionary of this type:
      ::TClass* cl = ::TClass::GetClass( type.c_str() );
      if( ! cl ) {
         ::Warning( "xAOD::TPyEvent::transientContains",
                    "Type name \"%s\" not known", type.c_str() );
         return kFALSE;
      }
 
      // Check if the dictionary can return a type_info:
      const std::type_info* ti = cl->GetTypeInfo();
      if( ! ti ) {
         ::Warning( "xAOD::TPyEvent::transientContains",
                    "Type \"%s\" doesn't have a proper dictionary",
                    type.c_str() );
         return kFALSE;
      }
 
      // Let the base class do the work:
      return TEvent::transientContains( key, *ti, kFALSE );
   }

transientContains() [3/3]

Bool_t xAOD::TEvent::transientContains ( const std::string &  key, const std::type_info &  ti, ::Bool_t  metadata = kFALSE  ) const

protectedinherited

Internal function checking if an object is already in memory.

Internal function checking if an object of a given type, with a given key is held in memory by the event object.

It's this function doing the heavy lifting for the public template function.

Parameters

key	The key/branch name of the object
ti	The type description of the object
metadata	Flag deciding whether we are looking for a metadata object or not

Returns

kTRUE if such a modifiable object is held by the event object at the moment, kFALSE otherwise

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

                                                               {
 
      return getOutputObject( key, ti, metadata );
   }

transientContainsMeta()

template<typename T >

::Bool_t xAOD::TEvent::transientContainsMeta ( const std::string &  key ) const

inherited

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

writeTo()

StatusCode xAOD::TEvent::writeTo ( ::TFile *  file, Int_t  autoFlush = 200, const char *  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

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

Returns

kTRUE if successful, kFALSE otherwise

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

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

Member Data Documentation

ATLAS_THREAD_SAFE

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

mutableprotectedinherited

Map from hashed sgkey to BranchInfo.

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

CACHE_SIZE

const ::Int_t xAOD::TEvent::CACHE_SIZE = -1

staticprotectedinherited

Size of a possible TTreeCache (30 MB)

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

DEFAULT_KEY

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

staticconstexprinherited

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

Definition at line 41 of file TVirtualEvent.h.

EVENT_TREE_NAME

const char *const xAOD::TEvent::EVENT_TREE_NAME = "CollectionTree"

staticprotectedinherited

Name of the event tree.

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

KEY_MASK

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

staticconstexprinherited

Mask for the keys, used mostly internally.

Definition at line 43 of file TVirtualEvent.h.

m_auxItemList

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

protectedinherited

Rules for selecting which auxiliary branches to write.

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

m_auxMode

EAuxMode xAOD::TEvent::m_auxMode

protectedinherited

The auxiliary access mode.

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

m_branchesMutex

upgrade_mutex_t xAOD::TEvent::m_branchesMutex

mutableprotectedinherited

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

m_entry

::Long64_t xAOD::TEvent::m_entry

protectedinherited

The entry to look at from the input tree.

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

m_inChain

::TChain* xAOD::TEvent::m_inChain

protectedinherited

The (optional) chain provided as input.

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

m_inChainTracker

TChainStateTracker* xAOD::TEvent::m_inChainTracker

protectedinherited

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

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

m_inMetaTree

::TTree* xAOD::TEvent::m_inMetaTree

protectedinherited

Pointer to the metadata tree in the input file.

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

m_inputEventFormat

EventFormat xAOD::TEvent::m_inputEventFormat

protectedinherited

Format of the current input file.

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

m_inputMetaObjects

Object_t xAOD::TEvent::m_inputMetaObjects

protectedinherited

Collection of all the managed input meta-objects.

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

m_inputMissingObjects

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

protectedinherited

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

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

m_inputObjects

Object_t xAOD::TEvent::m_inputObjects

protectedinherited

Collection of all the managed input objects.

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

m_inTree

::TTree* xAOD::TEvent::m_inTree

protectedinherited

The main tree that we are reading from.

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

m_inTreeMissing

::Bool_t xAOD::TEvent::m_inTreeMissing

protectedinherited

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

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

m_inTreeNumber

::Int_t xAOD::TEvent::m_inTreeNumber

protectedinherited

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

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

m_listeners

Listener_t xAOD::TEvent::m_listeners

protectedinherited

Listeners who should be notified when certain incidents happen.

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

m_nameRemapping

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

protectedinherited

Container name re-mapping rules.

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

m_outputEventFormat

EventFormat* xAOD::TEvent::m_outputEventFormat

protectedinherited

Format of the current output file.

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

m_outputMetaObjects

Object_t xAOD::TEvent::m_outputMetaObjects

protectedinherited

Collection of all the managed output meta-objects.

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

m_outputObjects

Object_t xAOD::TEvent::m_outputObjects

protectedinherited

Collection of all the managed output object.

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

m_outTree

::TTree* xAOD::TEvent::m_outTree

protectedinherited

The tree that we are writing to.

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

m_printEventProxyWarnings

Bool_t xAOD::TEvent::m_printEventProxyWarnings = true

protectedinherited

Option to silence common warnings that seem to be harmless.

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

METADATA_TREE_NAME

const char *const xAOD::TEvent::METADATA_TREE_NAME = "MetaData"

staticprotectedinherited

Name of the metadata tree.

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

---

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

• TPyEvent.h
• TPyEvent.cxx