xAOD::TEvent Class Reference

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

#include <TEvent.h>

Inheritance diagram for xAOD::TEvent:
xAOD::TVirtualEvent TEventClass xAOD::TPyEvent

List of all members.

Public Types

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

Auxiliary store "mode".

More...

Public Member Functions

 TEvent (EAuxMode mode=kUndefinedAccess)
 Default constructor.
 TEvent (::TFile *file, EAuxMode mode=kUndefinedAccess)
 Constructor connecting the object to an input TFile.
 TEvent (::TTree *tree, EAuxMode mode=kUndefinedAccess)
 Constructor connecting the objects to an input TTree/TChain.
 ~TEvent ()
 Destructor.
EAuxMode auxMode () const
 Get what auxiliary access mode the object was constructed with.
std::string dump ()
 Function creating a user-readable dump of the current input.
void printIOStats () const
 Function printing the I/O statistics of the current process.
Setup functions



TReturnCode readFrom (::TFile *file, Bool_t useTreeCache=kTRUE, const char *treeName=EVENT_TREE_NAME)
 Connect the object to a new input file.
TReturnCode readFrom (::TTree *tree, Bool_t useTreeCache=kTRUE)
 Connect the object to a new input tree/chain.
TReturnCode writeTo (::TFile *file, Int_t autoFlush=200, const char *treeName=EVENT_TREE_NAME)
 Connect the object to an output file.
TReturnCode finishWritingTo (::TFile *file)
 Finish writing to an output file.
void setActive () const
 Set this event object as the currently active one.
void setAuxItemList (const std::string &containerKey, const std::string &itemList)
 Configure which dynamic variables to write out for a given store.
TReturnCode addListener (TVirtualIncidentListener *listener)
 Register an incident listener object.
TReturnCode removeListener (TVirtualIncidentListener *listener)
 Remove an incident listener object.
void clearListeners ()
 Remove all listeners from the object.
TReturnCode addNameRemap (const std::string &onfile, const std::string &newName)
 Add a name re-mapping rule.
void clearNameRemap ()
 Clear the current name re-mapping.
void printNameRemap () const
 Print the current name re-mapping rules.
Event data accessor/modifier functions



template<typename T >
::Bool_t contains (const std::string &key)
 Function checking if an object is available from the store.
template<typename T >
::Bool_t transientContains (const std::string &key) const
 Function checking if an object is already in memory.
template<typename T >
TReturnCode retrieve (const T *&obj, const std::string &key)
 Retrieve either an input or an output object from the event.
template<typename T >
TReturnCode retrieve (T *&obj, const std::string &key)
 Retrieve an output object from the event.
template<typename T >
TReturnCode record (T *obj, const std::string &key,::Int_t basketSize=32000,::Int_t splitLevel=0)
 Add an output object to the event.
template<typename T >
TReturnCode record (std::unique_ptr< T > obj, const std::string &key,::Int_t basketSize=32000,::Int_t splitLevel=0)
 Add an output object to the event, explicitly taking ownership of it.
SG::IAuxStorerecordAux (const std::string &key, SG::IAuxStoreHolder::AuxStoreType type=SG::IAuxStoreHolder::AST_ContainerStore, Int_t basketSize=32000, Int_t splitLevel=0)
 Add an auxiliary store object to the output.
TReturnCode copy (const std::string &key,::Int_t basketSize=32000,::Int_t splitLevel=0)
 Copy an object directly from the input to the output.
TReturnCode copy (::Int_t basketSize=32000,::Int_t splitLevel=0)
 Copy all (ROOT readable) objects directly from the input to the output.
Metadata accessor/modifier functions



template<typename T >
::Bool_t containsMeta (const std::string &key)
 Function checking if a meta-object is available from the store.
template<typename T >
::Bool_t transientContainsMeta (const std::string &key) const
 Function checking if a meta-object is already in memory.
template<typename T >
TReturnCode retrieveMetaInput (const T *&obj, const std::string &key)
 Retrieve an input metadata object.
template<typename T >
TReturnCode retrieveMetaOutput (const T *&obj, const std::string &key)
 Retrieve an output metadata object.
template<typename T >
TReturnCode retrieveMetaOutput (T *&obj, const std::string &key)
 Retrieve an output metadata object.
template<typename T >
TReturnCode recordMeta (T *obj, const std::string &key,::Int_t basketSize=32000,::Int_t splitLevel=1)
 Add an object to the output file's metadata.
template<typename T >
TReturnCode recordMeta (std::unique_ptr< T > obj, const std::string &key,::Int_t basketSize=32000,::Int_t splitLevel=1)
Persistent data accessor/modifier functions



::Long64_t getEntries () const
 Get how many entries are available from the current input file(s).
::Int_t getEntry (::Long64_t entry,::Int_t getall=0)
 Function loading a given entry of the input TTree.
::Long64_t getFiles () const
 Get how many files are available on the currently defined input.
::Int_t getFile (::Long64_t file,::Int_t getall=0)
 Load the first event for a given file from the input TChain.
::Int_t fill ()
 Function filling one event into the output tree.
const EventFormatinputEventFormat () const
 Get information about the input objects.
const EventFormatoutputEventFormat () const
 Get information about the output objects.

Protected Types

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

Protected Member Functions

TReturnCode initStats ()
 Function to initialise the statistics for all Tree content.
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.
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.
TReturnCode 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.
TReturnCode 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.
TReturnCode connectBranch (const std::string &key,::Bool_t silent=kFALSE)
 Function setting up access to a particular branch.
TReturnCode connectMetaBranch (const std::string &key,::Bool_t silent=kFALSE)
 Function setting up access to a branch in the metadata tree.
TReturnCode connectAux (const std::string &prefix,::Bool_t standalone)
 Function setting up access to a set of auxiliary branches.
TReturnCode connectMetaAux (const std::string &prefix,::Bool_t standalone)
TReturnCode setUpDynamicStore (TObjectManager &mgr,::TTree *tree)
TReturnCode setAuxStore (TObjectManager &mgr,::Bool_t metadata=kFALSE)
 Function connecting a DV object to its auxiliary store.
TReturnCode putAux (::TTree &outTree, TVirtualManager &mgr,::Int_t basketSize=32000,::Int_t splitLevel=0,::Bool_t metadata=kFALSE)
 Function saving the dynamically created auxiliary properties.
::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.
::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.

Static Protected Member Functions

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

Protected Attributes

EAuxMode m_auxMode
 The auxiliary access mode.
::TTree * m_inTree
 The tree that we are reading from.
::Bool_t m_inTreeMissing
::TChain * m_inChain
 The (optional) chain provided as input.
TChainStateTrackerm_inChainTracker
 Optional object for tracking the state changes of an input TChain.
::Int_t m_inTreeNumber
 The number of the currently open tree in the input chain.
::TTree * m_inMetaTree
 Pointer to the metadata tree in the input file.
::Long64_t m_entry
 The entry to look at from the input tree.
::TTree * m_outTree
 The tree that we are writing to.
Object_t m_inputObjects
 Collection of all the managed input objects.
Object_t m_outputObjects
 Collection of all the managed output object.
Object_t m_inputMetaObjects
 Collection of all the managed input meta-objects.
Object_t m_outputMetaObjects
 Collection of all the managed output meta-objects.
EventFormat m_inputEventFormat
 Format of the current input file.
EventFormatm_outputEventFormat
 Format of the current output file.
std::map< std::string,
std::set< std::string > > 
m_auxItemList
 Rules for selecting which auxiliary branches to write.
Listener_t m_listeners
 Listeners who should be notified when certain incidents happen.
std::map< std::string,
std::string > 
m_nameRemapping
 Container name re-mapping rules.

Static Protected Attributes

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

Friends

class xAOD::TEventBranch
class xAOD::TMetaBranch
class xAOD::TFileMerger
class xAOD::TTreeMgr
friend::TTree * MakeTransientTree (TEvent &, const char *)

Functions implementing the TVirtualEvent interface



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

Detailed Description

Tool for accessing xAOD files outside of Athena.

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

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

Author:
Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch>
Revision
746122
Date
2016-05-11 12:11:31 +0200 (Wed, 11 May 2016)

Member Enumeration Documentation

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.


Member Function Documentation

TReturnCode xAOD::TEvent::addListener ( TVirtualIncidentListener listener  ) 

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 TReturnCode types
TReturnCode xAOD::TEvent::addNameRemap ( const std::string &  onfile,
const std::string &  newName 
)

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 TReturnCode types

Save the new name association:

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

Get what auxiliary access mode the object was constructed with.

Returns:
The auxiliary data access mode currently in use
void xAOD::TEvent::clearListeners (  ) 

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.

void xAOD::TEvent::clearNameRemap (  ) 

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.

TReturnCode xAOD::TEvent::connectAux ( const std::string &  prefix,
::Bool_t  standalone 
) [protected]

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
TReturnCode xAOD::TEvent::connectBranch ( const std::string &  key,
::Bool_t  silent = kFALSE 
) [protected]

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
TReturnCode xAOD::TEvent::connectMetaAux ( const std::string &  prefix,
::Bool_t  standalone 
) [protected]

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 TReturnCode types
TReturnCode xAOD::TEvent::connectMetaBranch ( const std::string &  key,
::Bool_t  silent = kFALSE 
) [protected]

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 TReturnCode types
Bool_t xAOD::TEvent::contains ( const std::string &  key,
const std::type_info &  ti,
::Bool_t  metadata = kFALSE 
) [protected]

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
template<typename T >
Bool_t xAOD::TEvent::contains ( const std::string &  key  )  [inline]

Function checking if an object is available from the store.

This function works pretty much like StoreGateSvc::contains. It can be used to check if an object with a given type having a given key can be retrieved from the event.

Parameters:
key The key (branch name) of the object
Returns:
kTRUE if the object is available, kFALSE otherwise
template<typename T >
Bool_t xAOD::TEvent::containsMeta ( const std::string &  key  )  [inline]

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

This function works pretty much like StoreGateSvc::contains for metadata objects. It can be used to check if a metadata object with a given type having a given key can be (const) retrieved.

Parameters:
key The key (branch name) of the metadata object
Returns:
kTRUE if the object is available, kFALSE otherwise
TReturnCode xAOD::TEvent::copy ( ::Int_t  basketSize = 32000,
::Int_t  splitLevel = 0 
)

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:
xAOD::TReturnCode::kSuccess if the copy was successful, or xAOD::TReturnCode::kFailure if not
TReturnCode xAOD::TEvent::copy ( const std::string &  key,
::Int_t  basketSize = 32000,
::Int_t  splitLevel = 0 
)

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
std::string xAOD::TEvent::dump (  ) 

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

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
TReturnCode xAOD::TEvent::finishWritingTo ( ::TFile *  file  ) 

Finish writing to an output file.

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

Parameters:
file The file that the event data is written to
Returns:
kTRUE if successful, kFALSE otherwise
Long64_t xAOD::TEvent::getEntries (  )  const

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

Returns:
The number of events in the input file(s)
Int_t xAOD::TEvent::getEntry ( ::Long64_t  entry,
::Int_t  getall = 0 
)

Function loading a given entry of the input TTree.

This function is used to move to looking at a new entry from the input 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
Int_t xAOD::TEvent::getFile ( ::Long64_t  file,
::Int_t  getall = 0 
)

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

This function can be used to iterate over the input files specified for the object. It should be most useful for collecting metadata about a set of input files, if there's no regular event loop done to process them.

Parameters:
file The file number to load
getall If set to 1, all connected branches are loaded
Returns:
The number of read bytes on success, or a negative number on failure
Long64_t xAOD::TEvent::getFiles (  )  const

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

This function can be used to get the number of input files that the object currently knows about. This is meant to be used to collect the metadata from each of the input files, or to access the metadata using a transient tree. (xAOD::TMetaTree)

Returns:
The number of input files when reading from a TChain, 1 when reading from a TFile, and 0 if the object is not connected to any input
uint32_t xAOD::TEvent::getHash ( const std::string &  key  )  const [virtual]

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.

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

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
const void * xAOD::TEvent::getInputObject ( uint32_t  key,
const std::type_info &  ti,
bool  silent = false 
) [protected, virtual]

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.

uint32_t xAOD::TEvent::getKey ( const void *  obj  )  const [virtual]

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.

const std::string & xAOD::TEvent::getName ( uint32_t  hash  )  const [virtual]

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.

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

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.

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

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
void * xAOD::TEvent::getOutputObject ( uint32_t  key,
const std::type_info &  ti 
) [protected, virtual]

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.

Bool_t xAOD::TEvent::hasAuxStore ( const TObjectManager mgr  )  [static, protected]

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
TReturnCode xAOD::TEvent::initStats (  )  [protected]

Function to initialise the statistics for all Tree content.

This function is used internally to initialise the reading of an input file. It prepares the "monitoring information" in memory that gets filled while the code is running, with information about xAOD I/O.

Returns:
TReturnCode::kSuccess if the function is successful, or TReturnCode::kFaulure if not
const EventFormat * xAOD::TEvent::inputEventFormat (  )  const

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.
Bool_t xAOD::TEvent::isAuxStore ( const TObjectManager mgr  )  [static, protected]

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
Bool_t xAOD::TEvent::isStandalone ( const TObjectManager mgr  )  [static, protected]

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
const EventFormat * xAOD::TEvent::outputEventFormat (  )  const

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.
void xAOD::TEvent::printIOStats (  )  const

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.

void xAOD::TEvent::printNameRemap (  )  const

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.

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

Function saving the dynamically created auxiliary properties.

This function is used internally to set up the writing of the auxiliary store variables that were dynamically created on an object. (And not statically defined to be part of that object.)

Parameters:
outTree The TTree to put the auxiliary branches into
mgr The object manager of the output object
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
TReturnCode xAOD::TEvent::readFrom ( ::TTree *  tree,
Bool_t  useTreeCache = kTRUE 
)

Connect the object to a new input tree/chain.

This version of the function sets up the object to readin 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
TReturnCode xAOD::TEvent::readFrom ( ::TFile *  file,
Bool_t  useTreeCache = kTRUE,
const char *  treeName = EVENT_TREE_NAME 
)

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
TReturnCode xAOD::TEvent::record ( TAuxStore store,
const std::string &  key,
::Int_t  basketSize,
::Int_t  splitLevel,
::Bool_t  ownsStore = kFALSE 
) [protected]

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

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

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

Parameters:
store The store object to connect to the output
key The "key" with which to record the object
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
TReturnCode 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 
) [protected]

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
template<typename T >
TReturnCode xAOD::TEvent::record ( std::unique_ptr< T obj,
const std::string &  key,
::Int_t  basketSize = 32000,
::Int_t  splitLevel = 0 
) [inline]

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

This function is used to add an object to the output. As the interface clearly states, the function takes posession of the object given to it. Since the user must give up ownership of the object in order to call this function, it doesn't even need to be said that the user must not delete the object by hand after calling this function.

Parameters:
obj Smart pointer to the object to tbe added to the event
key The key (branch name) to give the object
basketSize Basket size for the branch created from the object
splitLevel The split level of the branch to create
Returns:
kTRUE if the operation was successful, kFALSE if it wasn't
template<typename T >
TReturnCode xAOD::TEvent::record ( T obj,
const std::string &  key,
::Int_t  basketSize = 32000,
::Int_t  splitLevel = 0 
) [inline]

Add an output object to the event.

This function can be used to add an object to the output. The function takes posession of the object, so the user code must not delete an object that was added to an event.

Parameters:
obj Pointer to the object to be added to the event
key The key (branch name) to give the object
basketSize Basket size for the branch created from the object
splitLevel The split level of the branch to create
Returns:
kTRUE if the operation was successful, kFALSE if it wasn't
template<typename T >
TReturnCode xAOD::TEvent::recordMeta ( std::unique_ptr< T obj,
const std::string &  key,
::Int_t  basketSize = 32000,
::Int_t  splitLevel = 1 
) [inline]

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

This function can be used to add a metadata object to the output. As the interface clearly states, the function takes posession of the object given to it. So it's not even worth mentioning that the user must not delete the object after giving it to this function.

Parameters:
obj Smart pointer to the object to be added to the output metadata
key The key (branch name) to give the object
basketSize Basket size for the branch created from the object
splitLevel The split level of the branch to create
Returns:
kTRUE if the operation was successful, kFALSE if it wasn't
template<typename T >
TReturnCode xAOD::TEvent::recordMeta ( T obj,
const std::string &  key,
::Int_t  basketSize = 32000,
::Int_t  splitLevel = 1 
) [inline]

Add an object to the output file's metadata.

This function can be used to add a metadata object to the output. The function takes posession of the object, so the user code must not delete an object that was added to the output.

Parameters:
obj Pointer to the object to be added to the output metadata
key The key (branch name) to give the object
basketSize Basket size for the branch created from the object
splitLevel The split level of the branch to create
Returns:
kTRUE if the operation was successful, kFALSE if it wasn't
TReturnCode xAOD::TEvent::removeListener ( TVirtualIncidentListener listener  ) 

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 TReturnCode types
template<typename T >
TReturnCode xAOD::TEvent::retrieve ( T *&  obj,
const std::string &  key 
) [inline]

Retrieve an output object from the event.

This function can be used to retrieve an object from the output list. Since only output objects are considered, the function returns a non-const object, allowing downstream code to modify an object that was put into the event somewhere upstream.

Parameters:
obj The pointer that will be set to the object requested
key The key (branch name) of the object
Returns:
kTRUE if the operation was successful, kFALSE if it wasn't
template<typename T >
TReturnCode xAOD::TEvent::retrieve ( const T *&  obj,
const std::string &  key 
) [inline]

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

This function needs to be used when retrieving an object either from the input or the output object list. The returned object can not be modified.

Parameters:
obj The pointer that will be set to the object requested
key The key (branch name) of the object
Returns:
kTRUE if the operation was successful, kFALSE if it wasn't
template<typename T >
TReturnCode xAOD::TEvent::retrieveMetaInput ( const T *&  obj,
const std::string &  key 
) [inline]

Retrieve an input metadata object.

This function can be used to retrieve an object from the input metadata list.

Parameters:
obj The pointer that will be set to the object requested
key The key (branch name) of the object
Returns:
The usual TReturnCode values
template<typename T >
TReturnCode xAOD::TEvent::retrieveMetaOutput ( T *&  obj,
const std::string &  key 
) [inline]

Retrieve an output metadata object.

This function can be used to retrieve an object from the output metadata list.

Parameters:
obj The pointer that will be set to the object requested
key The key (branch name) of the object
Returns:
The usual TReturnCode values
template<typename T >
TReturnCode xAOD::TEvent::retrieveMetaOutput ( const T *&  obj,
const std::string &  key 
) [inline]

Retrieve an output metadata object.

This function can be used to retrieve an object from the output metadata list.

Parameters:
obj The pointer that will be set to the object requested
key The key (branch name) of the object
Returns:
The usual TReturnCode values
void xAOD::TEvent::setActive (  )  const

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.

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

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
TReturnCode xAOD::TEvent::setAuxStore ( TObjectManager mgr,
::Bool_t  metadata = kFALSE 
) [protected]

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
TReturnCode xAOD::TEvent::setUpDynamicStore ( TObjectManager mgr,
::TTree *  tree 
) [protected]

Function adding dynamic variable reading capabilities to an auxiliary store object

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

Parameters:
mgr The object manager of the auxiliary store object
tree The tree to read dynamic variables from
Returns:
The usual TReturnCode types
Bool_t xAOD::TEvent::transientContains ( const std::string &  key,
const std::type_info &  ti,
::Bool_t  metadata = kFALSE 
) const [protected]

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
template<typename T >
Bool_t xAOD::TEvent::transientContains ( const std::string &  key  )  const [inline]

Function checking if an object is already in memory.

This function works pretty much like StoreGateSvc::transientContains. It doesn't try to do any I/O operations, it just checks if an object of a given type, with a given key, is already in memory.

Parameters:
key The key (branch name) of the object
Returns:
kTRUE if the object is already in memory, kFALSE otherwise
template<typename T >
Bool_t xAOD::TEvent::transientContainsMeta ( const std::string &  key  )  const [inline]

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

This function works pretty much like StoreGateSvc::transientContains for metadata objects. It doesn't try to do any I/O operations, it just checks if an object of a given type, with a given key, can be retrieved in non-const mode.

Parameters:
key The key (branch name) of the metadata object
Returns:
kTRUE if the object is available for modifications, kFALSE otherwise
TReturnCode xAOD::TEvent::writeTo ( ::TFile *  file,
Int_t  autoFlush = 200,
const char *  treeName = EVENT_TREE_NAME 
)

Connect the object to an output file.

This function should be called on a file opened be the user, before any event processing would occur. It sets up the output event tree.

Parameters:
file The file that the event data should be written to
autoFlush The auto-flush setting to use on the output TTree
treeName Name of the output event tree
Returns:
kTRUE if successful, kFALSE otherwise

Member Data Documentation

::Bool_t xAOD::TEvent::m_inTreeMissing [protected]

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


The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on 1 Dec 2017 for RootCore Packages by  doxygen 1.6.1