 |
ATLAS Offline Software
|
Python interface to xAOD::TEvent.
More...
#include <TPyEvent.h>
|
| 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...
|
|
|
::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...
|
|
|
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...
|
|
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.
◆ Listener_t
◆ Object_t
◆ sgkey_t
◆ upgrade_mutex_t
◆ upgrading_lock_t
◆ EAuxMode
Auxiliary store "mode".
Enumerator |
---|
kBranchAccess | Access auxiliary data branch-by-branch.
|
kClassAccess | Access auxiliary data using the aux containers.
|
kAthenaAccess | Access containers/objects like Athena does.
|
kUndefinedAccess | Undefined, to be selected by the object.
|
Definition at line 99 of file Control/xAODRootAccess/xAODRootAccess/TEvent.h.
◆ TPyEvent()
Constructor with an access mode - only that one is used from the python TPyEvent.
Definition at line 33 of file TPyEvent.h.
◆ addListener()
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 912 of file Control/xAODRootAccess/Root/TEvent.cxx.
916 ::Error(
"xAOD::TEvent::addListener",
917 XAOD_MESSAGE(
"Received a null pointer for the listener" ) );
918 return StatusCode::FAILURE;
922 bool listenerKnown =
false;
924 if(
l == listener ) {
925 ::Warning(
"xAOD::TEvent::addListener",
926 "Listener %p was added previously already",
927 static_cast< void*
>( listener ) );
928 listenerKnown =
true;
934 if( ! listenerKnown ) {
939 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 992 of file Control/xAODRootAccess/Root/TEvent.cxx.
998 ::Error(
"xAOD::TEvent::addNameRemap",
999 XAOD_MESSAGE(
"Can't use \"%s\" as the target name in the"
1000 "\"%s\" -> \"%s\" remapping" ),
1002 return StatusCode::FAILURE;
1008 ::Warning(
"xAOD::TEvent::addNameRemap",
1009 "Overriding existing name remapping \"%s\" -> \"%s\"",
1010 itr->second.c_str(), itr->first.c_str() );
1011 ::Warning(
"xAOD::TEvent::addNameRemap",
" with: \"%s\" -> \"%s\"",
1012 onfile.c_str(),
newName.c_str() );
1019 return StatusCode::SUCCESS;
◆ addToStore()
|
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.
392 ::Warning(
"xAOD::TEvent::addToStore",
393 "Function should only be called through an invalid "
401 bi.m_proxy.reset(
proxy );
403 m_branches.insert( std::make_pair(
stringToKey( uniqueKey.Data(),
408 return StatusCode::SUCCESS;
◆ 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 972 of file Control/xAODRootAccess/Root/TEvent.cxx.
◆ 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 1026 of file Control/xAODRootAccess/Root/TEvent.cxx.
◆ 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 2871 of file Control/xAODRootAccess/Root/TEvent.cxx.
2876 ::Error(
"xAOD::TEvent::connectAux",
2878 return StatusCode::FAILURE;
2886 return StatusCode::SUCCESS;
2891 return StatusCode::SUCCESS;
2904 ::Fatal(
"xAOD::TEvent::connectAux",
2907 const TObjectManager* omgr =
2908 dynamic_cast< const TObjectManager*
>( mgr_itr->second );
2910 ::Fatal(
"xAOD::TEvent::connectAux",
2912 return StatusCode::FAILURE;
2916 static const TClass*
const holderClass =
2918 if( ! omgr->holder()->getClass()->InheritsFrom( holderClass ) ) {
2920 return StatusCode::SUCCESS;
2927 if( ! storeHolder ) {
2928 ::Fatal(
"xAOD::TEvent::connectAux",
2939 ::Error(
"xAOD::TEvent::connectAux",
2941 "for: %s" ),
prefix.c_str() );
2942 ::Error(
"xAOD::TEvent::connectAux",
2943 XAOD_MESSAGE(
"standalone = %s, getStoreType() = %i" ),
2946 return StatusCode::FAILURE;
2950 return StatusCode::SUCCESS;
2957 new TAuxStore(
prefix, kTRUE,
2963 TAuxManager*
mgr =
new TAuxManager(
store );
2971 return StatusCode::SUCCESS;
2975 ::Error(
"xAOD::TEvent::connectAux",
2976 XAOD_MESSAGE(
"Unknown auxiliary access mode set (%i)" ),
2978 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 2573 of file Control/xAODRootAccess/Root/TEvent.cxx.
2578 ::Error(
"xAOD::TEvent::connectBranch",
2579 XAOD_MESSAGE(
"Function called on un-initialised object" ) );
2580 return StatusCode::FAILURE;
2588 return StatusCode::SUCCESS;
2593 ::Warning(
"xAOD::TEvent::connectBranch",
2594 "Branch \"%s\" not available on input",
2597 return StatusCode::RECOVERABLE;
2604 ::Warning(
"xAOD::TEvent::connectBranch",
2605 "No metadata available for branch: %s",
2617 ::Warning(
"xAOD::TEvent::connectBranch",
2618 "Branch \"%s\" not available on input",
2622 return StatusCode::RECOVERABLE;
2626 br->SetMakeClass( 0 );
2637 ::Error(
"xAOD::TEvent::connectBranch",
2638 XAOD_MESSAGE(
"Couldn't find an appropriate type with a "
2639 "dictionary for branch \"%s\"" ),
2641 return StatusCode::FAILURE;
2644 ::TClass* realClass = ::TClass::GetClass(
className.c_str() );
2645 if( ( ( ! realClass ) || ( ! realClass->IsLoaded() ) ) &&
ef ) {
2650 realClass = ::TClass::GetClass(
className.c_str() );
2652 if( ( ! realClass ) || ( ! realClass->IsLoaded() ) ) {
2654 ::Error(
"xAOD::TEvent::connectBranch",
2655 XAOD_MESSAGE(
"Couldn't find an appropriate type with a "
2656 "dictionary for branch \"%s\"" ),
2658 return StatusCode::FAILURE;
2665 static const ::EDataType
dataType = kOther_t;
2675 TObjectManager*
mgr =
2676 dynamic_cast< TObjectManager*
>( out_itr->second );
2678 ::Error(
"xAOD::TEvent::connectBranch",
2679 XAOD_MESSAGE(
"Couldn't access output manager for: %s" ),
2681 return StatusCode::FAILURE;
2684 ptr =
mgr->holder()->get();
2691 ptr = realClass->New();
2695 THolder* hldr =
new THolder(
ptr, realClass );
2696 TObjectManager*
mgr =
2706 ::Error(
"xAOD::TEvent::connectBranch",
2708 "This can only be read in kAthenaAccess mode." ),
2709 key.c_str(),
br->GetSplitLevel() );
2711 *( hldr->getPtr() ) = 0;
2714 return StatusCode::FAILURE;
2724 ::Error(
"xAOD::TEvent::connectBranch",
2725 XAOD_MESSAGE(
"Couldn't connect variable of type \"%s\" to "
2726 "input branch \"%s\". Return code: %i" ),
2729 *( hldr->getPtr() ) = 0;
2732 return StatusCode::FAILURE;
◆ 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 2990 of file Control/xAODRootAccess/Root/TEvent.cxx.
2995 return StatusCode::SUCCESS;
3000 ::Fatal(
"xAOD::TEvent::connectMetaAux",
3002 return StatusCode::FAILURE;
3016 ::Fatal(
"xAOD::TEvent::connectMetaAux",
3019 const TObjectManager* omgr =
3020 dynamic_cast< const TObjectManager*
>( mgr_itr->second );
3022 ::Fatal(
"xAOD::TEvent::connectMetaAux",
3024 return StatusCode::FAILURE;
3028 static const TClass*
const holderClass =
3030 if( ! omgr->holder()->getClass()->InheritsFrom( holderClass ) ) {
3032 return StatusCode::SUCCESS;
3039 if( ! storeHolder ) {
3040 ::Fatal(
"xAOD::TEvent::connectMetaAux",
3051 ::Error(
"xAOD::TEvent::connectMetaAux",
3052 XAOD_MESSAGE(
"Requested store types inconsistent" ) );
3053 ::Error(
"xAOD::TEvent::connectMetaAux",
3054 XAOD_MESSAGE(
"standalone = %s, getStoreType() = %i" ),
3057 return StatusCode::FAILURE;
3061 return StatusCode::SUCCESS;
3068 new TAuxStore(
prefix, kTRUE,
3074 TAuxManager*
mgr =
new TAuxManager(
store );
3082 store->getEntry( 0 );
3085 return StatusCode::SUCCESS;
3089 ::Error(
"xAOD::TEvent::connectMetaAux",
3090 XAOD_MESSAGE(
"Unknown auxiliary access mode set (%i)" ),
3092 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 2757 of file Control/xAODRootAccess/Root/TEvent.cxx.
2762 ::Error(
"xAOD::TEvent::connectMetaBranch",
2763 XAOD_MESSAGE(
"Function called on un-initialised object" ) );
2764 return StatusCode::FAILURE;
2769 return StatusCode::SUCCESS;
2776 ::Warning(
"xAOD::TEvent::connectMetaBranch",
2777 "Branch \"%s\" not available on input",
2780 return StatusCode::RECOVERABLE;
2784 if( !
br->GetEntries() ) {
2786 ::Warning(
"xAOD::TEvent::connectMetaBranch",
2787 "Branch \"%s\" doesn't hold any data",
2790 return StatusCode::RECOVERABLE;
2794 br->SetMakeClass( 0 );
2798 ::EDataType
dt = kOther_t;
2799 if(
br->GetExpectedType(
cl,
dt ) || ( !
cl ) ) {
2800 ::Error(
"xAOD::TEvent::connectMetaBranch",
2802 "branch %s" ),
key.c_str() );
2803 return StatusCode::FAILURE;
2807 void*
ptr =
cl->New();
2808 THolder* hldr =
new THolder(
ptr,
cl );
2809 TObjectManager*
mgr =
2820 ::Error(
"xAOD::TEvent::connectMetaBranch",
2821 XAOD_MESSAGE(
"Couldn't connect variable of type \"%s\" to "
2822 "input branch \"%s\". Return code: %i" ),
2825 *( hldr->getPtr() ) = 0;
2828 return StatusCode::FAILURE;
2832 if(
mgr->getEntry() < 0 ) {
2833 ::Error(
"xAOD::TEvent::connectMetaBranch",
2834 XAOD_MESSAGE(
"Couldn't read in metadata object with key "
2835 "\"%s\"" ),
key.c_str() );
2836 return StatusCode::FAILURE;
2858 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.
17 ::TClass*
cl = ::TClass::GetClass(
type.c_str() );
19 ::Warning(
"xAOD::TPyEvent::contains",
20 "Type name \"%s\" not known",
type.c_str() );
25 const std::type_info* ti =
cl->GetTypeInfo();
27 ::Warning(
"xAOD::TPyEvent::contains",
28 "Type \"%s\" doesn't have a proper dictionary",
◆ 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 3685 of file Control/xAODRootAccess/Root/TEvent.cxx.
◆ 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 1248 of file Control/xAODRootAccess/Root/TEvent.cxx.
1252 ::Error(
"xAOD::TEvent::copy",
1254 return StatusCode::FAILURE;
1260 for( ; itr !=
end; ++itr ) {
1263 const EventFormatElement& efe = itr->second;
1266 if( !
m_inTree->GetBranch( efe.branchName().c_str() ) ) {
1270 if( efe.branchName().find(
"Aux." ) ==
1271 ( efe.branchName().size() - 4 ) ) {
1275 if( efe.parentName() !=
"" ) {
1279 ::TClass*
cl = ::TClass::GetClass( efe.className().c_str() );
1280 if( ( !
cl ) || ( !
cl->IsLoaded() ) ) {
1286 this->
copy( efe.branchName(), basketSize, splitLevel ) );
1290 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 1145 of file Control/xAODRootAccess/Root/TEvent.cxx.
1149 std::string keyToUse =
key;
1154 keyToUse = remap_itr->second;
1161 Object_t::const_iterator vobjMgr =
m_inputObjects.find( keyToUse );
1163 ::Error(
"xAOD::TEvent::copy",
1165 return StatusCode::FAILURE;
1167 TObjectManager* objMgr =
1168 dynamic_cast< TObjectManager*
>( vobjMgr->second );
1170 ::Error(
"xAOD::TEvent::copy",
1172 return StatusCode::FAILURE;
1175 *( objMgr->holder()->getClass()->GetTypeInfo() ) ) ) {
1176 ::Error(
"xAOD::TEvent::copy",
1178 return StatusCode::FAILURE;
1183 record( objMgr->object(),
1184 objMgr->holder()->getClass()->GetName(),
1185 key, basketSize, splitLevel, kTRUE ) );
1188 const std::set< std::string >*
filter = 0;
1191 filter = &( fitr->second );
1195 Object_t::const_iterator vauxMgr =
m_inputObjects.find( keyToUse +
1200 return StatusCode::SUCCESS;
1204 TObjectManager* auxMgr =
1205 dynamic_cast< TObjectManager*
>( vauxMgr->second );
1207 ::Error(
"xAOD::TEvent::copy",
1209 return StatusCode::FAILURE;
1212 record( auxMgr->object(),
1213 auxMgr->holder()->getClass()->GetName(),
1214 key +
"Aux.", basketSize, splitLevel, kTRUE ) );
1216 TAuxManager* auxMgr =
1217 dynamic_cast< TAuxManager*
>( vauxMgr->second );
1219 ::Error(
"xAOD::TEvent::copy",
1221 return StatusCode::FAILURE;
1225 auxMgr->getStore()->selectAux( *
filter );
1228 record( auxMgr->getStore(),
1229 key +
"Aux.", basketSize, splitLevel ) );
1231 ::Fatal(
"xAOD::TEvent::copy",
1236 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 294 of file Control/xAODRootAccess/Root/TEvent.cxx.
297 std::ostringstream
ost;
298 ost <<
"<<<<<<<<<<<<<<<<<<<< xAOD::TEvent Dump >>>>>>>>>>>>>>>>>>>>\n";
303 for( ; ef_itr != ef_end; ++ef_itr ) {
306 std::string
typeName = ef_itr->second.className();
311 ::TClass::GetClass( ef_itr->second.className().c_str() );
312 const std::type_info* ti = (
cl ?
cl->GetTypeInfo() : nullptr );
313 if( ( !
cl ) || ( !
cl->IsLoaded() ) || ( ! ti ) ) {
314 Warning(
"xAOD::TEvent::dump",
315 "Unknown type (%s) found in the event format",
316 ef_itr->second.className().c_str() );
321 if( !
contains( ef_itr->second.branchName(), *ti ) ) {
326 ost <<
" Hash: 0x" << std::setw( 8 ) << std::setfill(
'0' )
327 << std::hex << ef_itr->second.hash()
328 <<
" Key: \"" << ef_itr->second.branchName() <<
"\"\n";
333 ost <<
" isConst: " << ( isNonConst ?
"No" :
"Yes" ) <<
"\n";
341 ost <<
"<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
◆ 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 1510 of file Control/xAODRootAccess/Root/TEvent.cxx.
1514 ::Error(
"xAOD::TEvent::fill",
1515 XAOD_MESSAGE(
"Object not connected to an output file!" ) );
1525 ::Error(
"xAOD::TEvent::fill",
1531 ::Error(
"xAOD::TEvent::fill",
1541 std::string unsetObjects;
1543 for(
auto& itr : outputObjectsCopy ) {
1545 if( ! itr.second->create() ) {
1548 if( unsetObjects.size() ) {
1549 unsetObjects.append(
", \"" + itr.first +
"\"" );
1551 unsetObjects.append(
"\"" + itr.first +
"\"" );
1559 ::Error(
"xAOD::TEvent::fill",
1560 XAOD_MESSAGE(
"Failed to put dynamic auxiliary variables "
1561 "in the output for object \"%s\"" ),
1562 itr.first.c_str() );
1568 if( unsetObjects.size() ) {
1569 ::Error(
"xAOD::TEvent::fill",
1570 XAOD_MESSAGE(
"The following objects were not set in the "
1571 "current event: %s" ), unsetObjects.c_str() );
1578 ::Error(
"xAOD::TEvent::fill",
1579 XAOD_MESSAGE(
"Output tree filling failed with return "
1580 "value: %i" ), ret );
1586 for( ; ncitr != ncend; ++ncitr ) {
1587 ncitr->second->reset();
◆ 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 736 of file Control/xAODRootAccess/Root/TEvent.cxx.
740 ::Error(
"xAOD::TEvent::finishWritingTo",
741 XAOD_MESSAGE(
"The object doesn't seem to be connected to an "
743 return StatusCode::FAILURE;
751 const TIncident incident( IncidentType::MetaDataStop );
754 for( ; l_itr != l_end; ++l_itr ) {
755 ( *l_itr )->handle( incident );
770 return StatusCode::SUCCESS;
776 metatree->SetAutoSave( 10000 );
777 metatree->SetAutoFlush( -30000000 );
778 metatree->SetDirectory(
file );
781 metatree->Branch(
"EventFormat",
792 for(
auto&
object : outputMetaObjects ) {
795 TObjectManager*
mgr =
dynamic_cast< TObjectManager*
>(
object.second );
797 ::Error(
"xAOD::TEvent::finishWritingTo",
799 return StatusCode::FAILURE;
803 const ::Int_t splitLevel = (
object.first.find(
"Aux." ) ==
804 (
object.first.size() - 4 ) ? 1 : 0 );
806 *(
mgr->branchPtr() ) =
807 metatree->Branch(
object.first.c_str(),
808 mgr->holder()->getClass()->GetName(),
809 mgr->holder()->getPtr(), 32000, splitLevel );
810 if( !
mgr->branch() ) {
811 ::Error(
"xAOD::TEvent::finishWritingTo",
814 mgr->holder()->getClass()->GetName(),
815 object.first.c_str() );
816 return StatusCode::FAILURE;
826 if( metatree->Fill() <= 0 ) {
827 ::Error(
"xAOD::TEvent::finishWritingTo",
828 XAOD_MESSAGE(
"Failed to write event format metadata into "
830 metatree->SetDirectory( 0 );
832 return StatusCode::FAILURE;
837 metatree->SetDirectory( 0 );
842 for( ; obj_itr != obj_end; ++obj_itr ) {
843 delete obj_itr->second;
848 for( ; obj_itr != obj_end; ++obj_itr ) {
849 delete obj_itr->second;
854 return StatusCode::SUCCESS;
◆ getBranchInfo()
Get the object describing one object/branch.
Definition at line 268 of file TEventProxyDict.cxx.
277 auto it = m_branches.find(
sgkey );
278 if(
it != m_branches.end() ) {
279 return &(
it->second );
292 static const bool SILENT =
true;
293 static const bool METADATA =
false;
305 static const std::type_info&
dummy =
typeid(
TEvent );
306 nc_this->getInputObject(
name,
dummy, SILENT, METADATA );
315 const TObjectManager*
mgr =
316 dynamic_cast< const TObjectManager*
>( itr->second );
318 ::Error(
"xAOD::TEvent::getBranchInfo",
322 bi.m_class =
mgr->holder()->getClass();
327 #ifndef XAOD_STANDALONE
331 new GenericAddress() );
336 *bi.m_class->GetTypeInfo());
338 loader->
setProxy (*bi.m_proxy.get());
339 #endif // not XAOD_STANDALONE
344 auto ret = m_branches.insert( std::make_pair(
sgkey, std::move( bi ) ) );
347 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 1295 of file Control/xAODRootAccess/Root/TEvent.cxx.
1305 ::Error(
"xAOD::TEvent::getEntries",
◆ 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 1326 of file Control/xAODRootAccess/Root/TEvent.cxx.
1330 ::Error(
"xAOD::TEvent::getEntry",
1340 if( fileEntry < 0 ) {
1341 ::Error(
"xAOD::TEvent::getEntry",
1344 static_cast< int >(
entry ) );
1359 ::Error(
"xAOD::TEvent::getEntry",
1382 ::Error(
"xAOD::TEvent::getEntry",
1383 XAOD_MESSAGE(
"Failure in loading entry %i from the input "
1384 "file" ),
static_cast< int >(
m_entry ) );
1395 const TIncident incident( IncidentType::BeginEvent );
1398 for( ; l_itr != l_end; ++l_itr ) {
1399 ( *l_itr )->handle( incident );
1413 static const std::string dynStorePostfix =
"Aux.Dynamic";
1414 if( inObj.first.find( dynStorePostfix ) ==
1415 ( inObj.first.size() - dynStorePostfix.size() ) ) {
1429 result += inObj.second->getEntry( getall );
1434 const TIncident incident( IncidentType::BeginEvent );
1437 for( ; l_itr != l_end; ++l_itr ) {
1438 ( *l_itr )->handle( incident );
◆ getEventFormatElement()
Get the metadata object for a given "SG key".
Definition at line 351 of file TEventProxyDict.cxx.
354 static const bool QUIET =
true;
363 static mutex_t
mutex;
365 if( missingSGKeys.emplace(
sgkey ).second ) {
367 ::Warning(
"xAOD::TEvent::getEventFormatElement",
368 "Can't find EventFormatElement for hashed "
369 "SG key %d",
sgkey );
◆ 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 1474 of file Control/xAODRootAccess/Root/TEvent.cxx.
1478 ::Error(
"xAOD::TEvent::getFile",
1479 XAOD_MESSAGE(
"Function called with invalid file number "
1480 "(%i)" ),
static_cast< int >(
file ) );
1495 ::Long64_t
entry = 0;
1496 for( ::Long64_t
i = 0;
i <
file; ++
i ) {
◆ 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 1454 of file Control/xAODRootAccess/Root/TEvent.cxx.
1457 return m_inChain->GetListOfFiles()->GetEntries();
◆ getHash()
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 1651 of file Control/xAODRootAccess/Root/TEvent.cxx.
1654 if(
key ==
"" )
return 0;
◆ 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 2195 of file Control/xAODRootAccess/Root/TEvent.cxx.
2201 std::string keyToUse =
key;
2206 keyToUse = remap_itr->second;
2212 if(
store &&
store->contains( keyToUse, ti ) &&
2213 store->isConst( keyToUse, ti ) ) {
2214 const void*
result =
store->getConstObject( keyToUse, ti );
2245 ::Fatal(
"xAOD::TEvent::getInputObject",
2246 XAOD_MESSAGE(
"There is an internal logic error in the "
2252 TObjectManager*
mgr =
2253 dynamic_cast< TObjectManager*
>( itr->second );
2255 if(
key == keyToUse ) {
2256 ::Error(
"xAOD::TEvent::getInputObject",
2261 ::Error(
"xAOD::TEvent::getInputObject",
2263 "\"%s\"/\"%s\"" ),
key.c_str(),
2271 if(
mgr->getEntry() ) {
2276 ::Error(
"xAOD::TEvent::getInputObject",
2279 mgr->holder()->getClass()->GetName(),
2290 ::Warning(
"xAOD::TEvent::getInputObject",
2291 "Could not retrieve object with key \"%s\" "
2292 "as \"%s\"", keyToUse.c_str(),
◆ getInputObject() [2/2]
|
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 1940 of file Control/xAODRootAccess/Root/TEvent.cxx.
1947 Warning(
"xAOD::TEvent::getInputObject",
1948 "Key 0x%08x unknown",
key );
◆ getKey()
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 1673 of file Control/xAODRootAccess/Root/TEvent.cxx.
◆ 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 1686 of file Control/xAODRootAccess/Root/TEvent.cxx.
1691 for( ; obj_itr != obj_end; ++obj_itr ) {
1694 if( obj_itr->second->object() !=
obj )
continue;
1697 return obj_itr->first;
1703 for( ; obj_itr != obj_end; ++obj_itr ) {
1706 if( obj_itr->second->object() !=
obj )
continue;
1709 return obj_itr->first;
1720 ::Warning(
"xAOD::TEvent::getName",
1721 "Didn't find object with pointer %p in the event",
1723 static const std::string
dummy;
◆ getName() [2/2]
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 1882 of file Control/xAODRootAccess/Root/TEvent.cxx.
1902 static const std::string
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 1727 of file Control/xAODRootAccess/Root/TEvent.cxx.
1731 std::set<std::string>
keys;
1735 std::vector<TObjArray*> fullListOfBranches = {};
1740 ::Info(
"xAOD::TEvent::getNames",
"scanning input objects");
1741 fullListOfBranches.push_back(
m_inMetaTree->GetListOfBranches());
1746 ::Info(
"xAOD::TEvent::getNames",
"scanning input objects");
1748 fullListOfBranches.push_back(
m_inTree->GetListOfBranches());
1753 TList *fList =
m_inTree->GetListOfFriends();
1755 for (TObject * feObj : *fList){
1758 TTree *friendTree =
dynamic_cast<TFriendElement*
>(feObj)->GetTree();
1760 fullListOfBranches.push_back(friendTree->GetListOfBranches());
1768 for (
const TObjArray * in : fullListOfBranches){
1771 const TObject *
obj = in->At(
index);
1772 if ( !
obj )
continue;
1773 const TBranch * element =
dynamic_cast<const TBranch*
>(
obj);
1775 ::Error(
"xAOD::TEvent::getNames",
"Failure inspecting input objects");
1778 std::string objClassName = element->GetClassName();
1779 std::string
key =
obj->GetName();
1780 ::Info(
"xAOD::TEvent::getNames",
1781 "Inspecting %s / %s",
1782 objClassName.c_str(),
key.c_str());
1783 if (objClassName == targetClassName) {
1784 ::Info(
"xAOD::TEvent::getNames",
1785 "Matched %s to key %s",
1786 targetClassName.c_str(),
key.c_str());
1795 ::Info(
"xAOD::TEvent::getNames",
1796 "scanning input Aux objects for %s", targetClassName.c_str());
1797 for(
const auto&
object : inAux ) {
1800 TObjectManager*
mgr =
dynamic_cast< TObjectManager*
>(
object.second );
1801 if ( !
mgr )
continue;
1802 const std::string& objClassName =
mgr->holder()->getClass()->GetName();
1803 const std::string&
key =
object.first;
1804 ::Info(
"xAOD::TEvent::getNames",
1805 "Inspecting %s / %s",
1806 objClassName.c_str(),
key.c_str());
1807 if (objClassName == targetClassName) {
1808 ::Info(
"xAOD::TEvent::getNames",
1809 "Matched %s to key %s",
1810 targetClassName.c_str(),
key.c_str());
1819 const TObjArray *
out =
tree->GetListOfBranches();
1820 ::Info(
"xAOD::TEvent::getNames",
"scanning output objects");
1824 if ( !
obj )
continue;
1825 const TBranch * element =
dynamic_cast<const TBranch*
>(
obj);
1827 ::Error(
"xAOD::TEvent::getNames",
"Failure inspecting input objects");
1830 std::string objClassName = element->GetClassName();
1831 std::string
key =
obj->GetName();
1832 ::Info(
"xAOD::TEvent::getNames",
1833 "Inspecting %s / %s",
1834 objClassName.c_str(),
key.c_str());
1835 if (objClassName == targetClassName) {
1836 ::Info(
"xAOD::TEvent::getNames",
1837 "Matched %s to key %s",
1838 targetClassName.c_str(),
key.c_str());
1843 ::Info(
"xAOD::TEvent::getNames",
"no output tree connected");
1852 ::Info(
"xAOD::TEvent::getNames",
1853 "scanning output Aux objects for %s", targetClassName.c_str());
1854 for(
const auto&
object : outAux ) {
1857 TObjectManager*
mgr =
dynamic_cast< TObjectManager*
>(
object.second );
1858 if ( !
mgr )
continue;
1859 const std::string& objClassName =
mgr->holder()->getClass()->GetName();
1860 const std::string&
key =
object.first;
1861 ::Info(
"xAOD::TEvent::getNames",
1862 "Inspecting %s / %s",
1863 objClassName.c_str(),
key.c_str());
1864 if (objClassName == targetClassName) {
1865 ::Info(
"xAOD::TEvent::getNames",
1866 "Matched %s to key %s",
1867 targetClassName.c_str(),
key.c_str());
1872 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 2125 of file Control/xAODRootAccess/Root/TEvent.cxx.
2134 Object_t::const_iterator itr =
objects.find(
key );
2156 if( ! itr->second->isSet() ) {
2161 TObjectManager*
mgr =
2162 dynamic_cast< TObjectManager*
>( itr->second );
2164 ::Error(
"xAOD::TEvent::getOutputObject",
2165 XAOD_MESSAGE(
"Object of wrong type found for key \"%s\"" ),
2171 void*
result =
mgr->holder()->getAs( ti );
2173 ::Warning(
"xAOD::TEvent::getOutputObject",
2174 "Couldn't retrieve object as \"%s\"",
◆ 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 1916 of file Control/xAODRootAccess/Root/TEvent.cxx.
1921 if( !
name.length() ) {
◆ hasAuxStore()
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 3607 of file Control/xAODRootAccess/Root/TEvent.cxx.
3611 static const TClass*
const dvClass =
3613 static const TClass*
const aeClass =
3617 return (
mgr.holder()->getClass()->InheritsFrom( dvClass ) ||
3618 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 1963 of file Control/xAODRootAccess/Root/TEvent.cxx.
1967 return StatusCode::SUCCESS;
1972 ::Error(
"xAOD::TEvent::initStats",
1975 return StatusCode::FAILURE;
1984 for( ; itr !=
end; ++itr ) {
1987 const std::string& branchName = itr->second.branchName();
1990 if( branchName.find(
"Aux." ) != std::string::npos ) {
1999 const std::string intName =
2000 branchName.substr( 0, branchName.size() - 4 );
2008 ::Bool_t auxFound = kFALSE;
2011 std::vector<TObjArray*> fullListOfBranches = {};
2013 fullListOfBranches.push_back(
m_inTree->GetListOfBranches());
2018 TList *fList =
m_inTree->GetListOfFriends();
2020 for (TObject * feObj : *fList){
2023 TTree *friendTree =
dynamic_cast<TFriendElement*
>(feObj)->GetTree();
2025 fullListOfBranches.push_back(friendTree->GetListOfBranches());
2030 for (TObjArray*
branches : fullListOfBranches){
2031 for( Int_t
i = 0;
i <
branches->GetEntriesFast(); ++
i ){
2035 if(
name.BeginsWith( branchName ) ||
2036 name.BeginsWith( dynName ) ) {
2043 ::Warning(
"xAOD::TEvent::initStats",
2044 "Couldn't find interface object/container "
2045 "\"%s\" belonging to branch \"%s\"",
2046 intName.c_str(), branchName.c_str() );
2053 ::TClass*
cl = ::TClass::GetClass(
el->className().c_str() );
2054 if( ( !
cl ) || ( !
cl->IsLoaded() ) ) {
2055 ::Warning(
"xAOD::TEvent::initStats",
2056 "Couldn't find dictionary for type \"%s\"",
2057 el->className().c_str() );
2063 static const std::string baseName =
2065 static ::TClass*
const baseCl = ::TClass::GetClass( baseName.c_str() );
2067 ::Error(
"xAOD::TEvent::initStats",
2069 "\"%s\"" ), baseName.c_str() );
2070 return StatusCode::FAILURE;
2080 static constexpr
bool TOP_STORE =
true;
2081 TAuxStore temp( branchName, TOP_STORE,
mode );
2082 static constexpr
bool PRINT_WARNINGS =
false;
2084 temp.readFrom( *
m_inTree, PRINT_WARNINGS ) );
2091 stats.branch(branchName,
id);
2095 stats.setBranchNum(
stats.branchNum() + temp.getAuxIDs().size());
2100 const ::TBranch* container =
2101 m_inTree->GetBranch( branchName.c_str() );
2110 return StatusCode::SUCCESS;
◆ inputEventFormat()
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 1605 of file Control/xAODRootAccess/Root/TEvent.cxx.
1613 ::Warning(
"xAOD::TEvent::inputEventFormat",
1614 "No input file is connected at the moment" );
◆ isAuxStore()
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 3628 of file Control/xAODRootAccess/Root/TEvent.cxx.
3631 static const TClass*
const storeClass =
3633 static const TClass*
const storeHolderClass =
3637 return (
mgr.holder()->getClass()->InheritsFrom( storeClass ) ||
3638 mgr.holder()->getClass()->InheritsFrom( storeHolderClass ) );
◆ isStandalone()
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 3651 of file Control/xAODRootAccess/Root/TEvent.cxx.
3655 static const TClass*
const dvClass =
3657 static const TClass*
const aeClass =
3661 if(
mgr.holder()->getClass()->InheritsFrom( aeClass ) ) {
3663 }
else if(
mgr.holder()->getClass()->InheritsFrom( dvClass ) ) {
3668 ::Error(
"xAOD::TEvent::isStandalone",
3670 "auxiliary store" ),
3671 mgr.holder()->getClass()->GetName() );
◆ 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]
|
overrideprotectedinherited |
◆ keyToString() [2/2]
|
overrideprotectedinherited |
◆ name()
const std::string & xAOD::TEvent::name |
( |
| ) |
const |
|
overrideprotectedinherited |
Get the name of the instance.
Definition at line 452 of file TEventProxyDict.cxx.
454 static const std::string NAME =
"xAOD::TEvent";
◆ outputEventFormat()
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 1628 of file Control/xAODRootAccess/Root/TEvent.cxx.
1636 ::Warning(
"xAOD::TEvent::outputEventFormat",
1637 "No output file is connected at the moment" );
◆ 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 349 of file Control/xAODRootAccess/Root/TEvent.cxx.
◆ 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 1035 of file Control/xAODRootAccess/Root/TEvent.cxx.
1038 ::Info(
"xAOD::TEvent::printNameRemap",
"Name remapping rules:" );
1042 ::Info(
"xAOD::TEvent::printNameRemap",
" NONE" );
1049 ::Info(
"xAOD::TEvent::printNameRemap",
" \"%s\" -> \"%s\"",
1050 itr->second.c_str(), itr->first.c_str() );
◆ proxies()
|
overrideprotectedinherited |
return the list of all current proxies in store
Definition at line 411 of file TEventProxyDict.cxx.
415 std::vector< const SG::DataProxy* > ret;
416 for(
const auto&
p : m_branches ) {
419 ret.push_back(
proxy );
◆ proxy() [1/2]
|
overrideprotectedinherited |
get proxy with given id and key. Returns 0 to flag failure
Definition at line 234 of file TEventProxyDict.cxx.
◆ proxy() [2/2]
|
overrideprotectedinherited |
get proxy for a given data object address in memory
Definition at line 206 of file TEventProxyDict.cxx.
217 static const bool QUIET =
true;
231 return bi->m_proxy.get();
◆ proxy_exact()
|
overrideprotectedinherited |
Get proxy given a hashed key+clid.
Definition at line 244 of file TEventProxyDict.cxx.
250 static mutex_t
mutex;
252 if( missingSGKeys.emplace(
sgkey ).second &&
254 ::Warning(
"xAOD::TEvent::proxy_exact",
255 "Can't find BranchInfo for %d.",
◆ 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 3364 of file Control/xAODRootAccess/Root/TEvent.cxx.
3372 TObjectManager*
mgr =
dynamic_cast< TObjectManager*
>( &vmgr );
3375 return StatusCode::SUCCESS;
3379 if( !
mgr->holder()->getClass()->InheritsFrom(
"SG::IAuxStoreIO" ) ) {
3380 return StatusCode::SUCCESS;
3388 ::Fatal(
"xAOD::TEvent::putAux",
3389 XAOD_MESSAGE(
"There is a logic error in the code!" ) );
3398 sel.selectAux( item_itr->second );
3408 if( auxids.
empty() ) {
3409 return StatusCode::SUCCESS;
3413 const std::string dynNamePrefix =
3422 typedef std::pair< std::string, SG::auxid_t > AuxVarSort_t;
3423 std::vector< AuxVarSort_t > varsort;
3424 varsort.reserve( auxids.
size() );
3426 varsort.emplace_back(
r.getName(
id ),
id );
3428 std::sort( varsort.begin(), varsort.end() );
3431 for(
const auto&
p : varsort ) {
3437 const std::string
brName = dynNamePrefix +
p.first;
3446 const std::type_info* brType = aux->
getIOType(
id );
3448 ::Error(
"xAOD::TEvent::putAux",
3451 return StatusCode::FAILURE;
3453 const std::string brTypeName =
3455 std::string brProperTypeName =
"<unknown>";
3461 if( strlen( brType->name() ) == 1 ) {
3464 brProperTypeName = brTypeName;
3469 ::Error(
"xAOD::TEvent::putAux",
3472 brName.c_str(), brTypeName.c_str() );
3473 return StatusCode::FAILURE;
3477 std::ostringstream leaflist;
3481 THolder* hldr =
new THolder( aux->
getIOData(
id ),
3483 TPrimitiveAuxBranchManager* auxmgr =
3484 new TPrimitiveAuxBranchManager(
id, 0, hldr );
3488 *( auxmgr->branchPtr() ) =
3489 outTree.Branch(
brName.c_str(), hldr->get(),
3490 leaflist.str().c_str(),
3492 if( ! auxmgr->branch() ) {
3493 ::Error(
"xAOD::TEvent::putAux",
3496 brName.c_str(), brProperTypeName.c_str() );
3498 *( auxmgr->holder()->getPtr() ) = 0;
3501 return StatusCode::FAILURE;
3503 br = auxmgr->branch();
3508 TClass*
cl = TClass::GetClass( *brType, kTRUE, kTRUE );
3512 cl = TClass::GetClass( brTypeName.c_str() );
3515 ::Error(
"xAOD::TEvent::putAux",
3517 "variable \"%s\" of type \"%s\"" ),
3518 brName.c_str(), brTypeName.c_str() );
3519 return StatusCode::FAILURE;
3524 brProperTypeName =
cl->GetName();
3527 THolder* hldr =
new THolder( aux->
getIOData(
id ),
3529 TAuxBranchManager* auxmgr =
3530 new TAuxBranchManager(
id, 0, hldr );
3533 if (!
cl->CanSplit() && strncmp (
cl->GetName(),
"SG::PackedContainer<", 20) == 0)
3537 *( auxmgr->branchPtr() ) =
3538 outTree.Branch(
brName.c_str(),
3540 hldr->getPtr(), basketSize, splitLevel );
3541 if( ! auxmgr->branch() ) {
3542 ::Error(
"xAOD::TEvent::putAux",
3545 brName.c_str(), brProperTypeName.c_str() );
3547 *( auxmgr->holder()->getPtr() ) = 0;
3550 return StatusCode::FAILURE;
3552 br = auxmgr->branch();
3558 if( outTree.GetEntries() ) {
3559 void*
ptr =
br->GetAddress();
3560 br->SetAddress( 0 );
3561 for( ::Long64_t
i = 0;
i < outTree.GetEntries(); ++
i ) {
3564 br->SetAddress(
ptr );
3571 EventFormatElement(
brName,
3573 mgr->branch()->GetName(),
3584 ::Fatal(
"xAOD::TEvent::putAux",
3585 XAOD_MESSAGE(
"There is an internal logic error in the "
3591 const_cast< void*
>(
static_cast< const void*
>( aux->
getIOData(
id ) ) );
3592 bmgr->second->setObject( nc_data );
3596 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 366 of file Control/xAODRootAccess/Root/TEvent.cxx.
370 if( !
file )
return StatusCode::SUCCESS;
375 for( ; itr !=
end; ++itr ) {
389 for( ; itr !=
end; ++itr ) {
409 ::Error(
"xAOD::TEvent::readFrom",
410 XAOD_MESSAGE(
"Couldn't find metadata tree on input. Object "
412 return StatusCode::FAILURE;
418 ::Error(
"xAOD::TEvent::readFrom",
419 XAOD_MESSAGE(
"Failed to load entry for metadata tree=%s" ),
421 return StatusCode::FAILURE;
426 ::Info(
"xAOD::TEvent::readFrom",
427 "Was expecting a metadata tree with size 1, instead of %i.",
429 ::Info(
"xAOD::TEvent::readFrom",
430 "File most probably produced by hadd..." );
436 static const std::string eventFormatTypeName =
438 ::TClass*
cl = ::TClass::GetClass( eventFormatTypeName.c_str() );
440 ::Warning(
"xAOD::TEvent::readFrom",
441 "Couldn't load the EventFormat dictionary" );
445 const std::string eventFormatBranchName =
447 if( !
m_inMetaTree->GetBranch( eventFormatBranchName.c_str() ) ) {
451 ::Info(
"xAOD::TEvent::readFrom",
"Input file provides no event or "
455 return StatusCode::SUCCESS;
461 m_inMetaTree->SetBranchAddress( eventFormatBranchName.c_str(),
464 ::Error(
"xAOD::TEvent::readFrom",
465 XAOD_MESSAGE(
"Failed to connect to EventFormat object" ) );
466 return StatusCode::FAILURE;
483 std::set<std::string> lOtherMetaTreeNames = {};
484 TList *lKeys =
file->GetListOfKeys();
487 for (
int iKey = 0; iKey < lKeys->GetEntries() ; iKey++){
489 std::string
keyName = lKeys->At(iKey)->GetName();
494 && (
keyName.find(
"MetaData") != std::string::npos)
495 && !(
keyName.find(
"MetaDataHdr") != std::string::npos)){
497 const char *
className = ((::TKey*)lKeys->At(iKey))->GetClassName();
498 static constexpr Bool_t LOAD = kFALSE;
499 static constexpr Bool_t
SILENT = kTRUE;
500 ::TClass*
cl = ::TClass::GetClass(
className, LOAD, SILENT);
501 if ((
cl !=
nullptr) &&
cl->InheritsFrom(::TTree::Class())){
503 lOtherMetaTreeNames.insert(
keyName);
510 for (
const std::string & metaTreeName : lOtherMetaTreeNames){
511 TTree *tmpMetaTree =
dynamic_cast< ::TTree*
>(
file->Get( metaTreeName.c_str() ) );
515 ::Warning(
"xAOD::TEvent::readFrom",
"Could not read metadata tree=%s",metaTreeName.c_str());
521 if ( tmpMetaTree->LoadTree(0) < 0 ){
522 ::Error(
"xAOD::TEvent::readFrom",
523 XAOD_MESSAGE(
"Failed to load entry for metadata tree=%s" ),
524 tmpMetaTree->GetName() );
525 return StatusCode::FAILURE;
529 const std::string tmpEventFormatBranchName =
531 if( ! tmpMetaTree->GetBranch( tmpEventFormatBranchName.c_str() ) ) {
533 ::Warning(
"xAOD::TEvent::readFrom",
"No EventFormat branch found in metadata tree=%s",tmpMetaTree->GetName() );
539 tmpMetaTree->SetBranchAddress( tmpEventFormatBranchName.c_str(),
540 &tmpFormat, &tmpBr );
542 ::Error(
"xAOD::TEvent::readFrom",
543 XAOD_MESSAGE(
"Failed to connect to EventFormat object for metadata tree = %s"), tmpMetaTree->GetName() );
544 return StatusCode::FAILURE;
547 tmpBr->GetEntry( 0 );
549 for (
const std::pair<const std::string, xAOD::EventFormatElement> &evtElem : *tmpFormat){
571 m_inTree->SetCacheLearnEntries( 10 );
583 const TIncident beginIncident( IncidentType::BeginInputFile );
584 for( TVirtualIncidentListener* listener :
m_listeners ) {
585 listener->handle( beginIncident );
592 const TIncident endIncident( IncidentType::EndInputFile );
593 for( TVirtualIncidentListener* listener :
m_listeners ) {
594 listener->handle( endIncident );
598 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 609 of file Control/xAODRootAccess/Root/TEvent.cxx.
621 if( useTreeCache && ( !
m_inChain->GetCacheSize() ) ) {
631 ::Error(
"xAOD::TEvent::readFrom",
632 XAOD_MESSAGE(
"Couldn't get the list of files from the "
634 return StatusCode::FAILURE;
636 if( !
files->GetEntries() ) {
637 ::Error(
"xAOD::TEvent::readFrom",
640 return StatusCode::FAILURE;
642 const ::TChainElement* chEl =
643 dynamic_cast< const ::TChainElement*
>(
files->At( 0 ) );
645 ::Error(
"xAOD::TEvent::readFrom",
646 XAOD_MESSAGE(
"Couldn't cast object to TChainElement" ) );
647 return StatusCode::FAILURE;
649 ::TFile* dummyFile = ::TFile::Open( chEl->GetTitle() );
651 ::Error(
"xAOD::TEvent::readFrom",
654 return StatusCode::FAILURE;
669 return StatusCode::SUCCESS;
680 ::TFile*
file =
tree->GetCurrentFile();
◆ 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.
87 kFALSE, kFALSE, kFALSE ) );
89 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 2483 of file Control/xAODRootAccess/Root/TEvent.cxx.
2489 ::Error(
"xAOD::TEvent::record",
2490 XAOD_MESSAGE(
"No output tree defined. Did you forget to "
2491 "call writeTo(...)?" ) );
2492 return StatusCode::FAILURE;
2496 const std::set< std::string >*
filter = 0;
2499 filter = &( filter_itr->second );
2513 TAuxManager*
mgr =
new TAuxManager(
store, ownsStore );
2517 return StatusCode::SUCCESS;
2521 if( vitr->second->object() ==
store ) {
2523 return StatusCode::SUCCESS;
2531 TAuxManager*
mgr =
dynamic_cast< TAuxManager*
>( vitr->second );
2533 ::Error(
"xAOD::TEvent::record",
2534 XAOD_MESSAGE(
"Output object with key %s already exists, "
2535 "and is not of type TAuxStore" ),
2537 return StatusCode::FAILURE;
2552 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 2320 of file Control/xAODRootAccess/Root/TEvent.cxx.
2328 ::Error(
"xAOD::TEvent::record",
2329 XAOD_MESSAGE(
"No output tree defined. Did you forget to "
2330 "call writeTo(...)?" ) );
2331 return StatusCode::FAILURE;
2339 if( ( ! overwrite ) &&
2342 ::Error(
"xAOD::TEvent::record",
2345 return StatusCode::FAILURE;
2348 TClass*
cl = TClass::GetClass(
typeName.c_str() );
2350 ::Error(
"xAOD::TEvent::record",
2353 return StatusCode::FAILURE;
2356 THolder* hldr =
new THolder(
obj,
cl, isOwner );
2357 TObjectManager*
mgr =
2361 return StatusCode::SUCCESS;
2366 if( ( ! overwrite ) &&
2368 ::Error(
"xAOD::TEvent::record",
2369 XAOD_MESSAGE(
"Object %s/%s already accessed from the input, "
2370 "can't be overwritten in memory" ),
2372 return StatusCode::FAILURE;
2377 if( ( splitLevel == 0 ) &&
2378 (
key.find(
"Aux." ) == (
key.size() - 4 ) ) ) {
2387 TClass*
cl = TClass::GetClass(
typeName.c_str() );
2389 ::Error(
"xAOD::TEvent::record",
2392 return StatusCode::FAILURE;
2402 THolder* hldr =
new THolder(
obj,
cl, isOwner );
2403 TObjectManager*
mgr =
2408 *(
mgr->branchPtr() ) =
2410 hldr->getPtr(), basketSize, splitLevel );
2411 if( !
mgr->branch() ) {
2412 ::Error(
"xAOD::TEvent::record",
2415 key.c_str(),
cl->GetName() );
2417 hldr->setOwner( kFALSE );
2419 return StatusCode::FAILURE;
2430 return StatusCode::SUCCESS;
2434 TObjectManager* omgr =
dynamic_cast< TObjectManager*
>( vitr->second );
2436 ::Error(
"xAOD::TEvent::record",
2439 return StatusCode::FAILURE;
2444 if(
typeName != omgr->holder()->getClass()->GetName() ) {
2448 TClass*
cl = TClass::GetClass(
typeName.c_str() );
2449 if( ( !
cl ) || ::strcmp(
cl->GetName(),
2450 omgr->holder()->getClass()->GetName() ) ) {
2451 ::Error(
"xAOD::TEvent::record",
2452 XAOD_MESSAGE(
"For output key \"%s\" the previous type "
2453 "was \"%s\", the newly requested type is "
2455 key.c_str(), omgr->holder()->getClass()->GetName(),
2457 return StatusCode::FAILURE;
2462 omgr->setObject(
obj );
◆ recordAux()
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 1068 of file Control/xAODRootAccess/Root/TEvent.cxx.
1074 ::Error(
"xAOD::TEvent::recordAux",
1075 XAOD_MESSAGE(
"No output tree given to the object" ) );
1093 ::Error(
"xAOD::TEvent::recordAux",
1095 static_cast< int >(
type ) );
1100 basketSize, splitLevel );
1101 if(
record(
store,
key, basketSize, splitLevel, kTRUE ).isFailure() ) {
1102 ::Error(
"xAOD::TEvent::recordAux",
1103 XAOD_MESSAGE(
"Couldn't connect TAuxStore object to the "
1114 ::Error(
"xAOD::TEvent::recordAux",
1120 TAuxManager*
mgr =
dynamic_cast< TAuxManager*
>( itr->second );
1122 ::Error(
"xAOD::TEvent::recordAux",
1123 XAOD_MESSAGE(
"Object of non-TAuxStore type registered "
1124 "with key \"%s\"" ),
key.c_str() );
1129 TAuxStore*
store =
mgr->getStore();
◆ 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()
|
overrideprotectedinherited |
Record an object in the store.
Definition at line 445 of file TEventProxyDict.cxx.
448 throw std::runtime_error(
"xAOD::TEvent::recordObject is not "
◆ registerKey()
|
overrideprotectedinherited |
◆ removeListener()
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 948 of file Control/xAODRootAccess/Root/TEvent.cxx.
956 ::Error(
"xAOD::TEvent::removeListener",
958 static_cast< void*
>( listener ) );
959 return StatusCode::FAILURE;
966 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]
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 862 of file Control/xAODRootAccess/Root/TEvent.cxx.
869 #ifndef XAOD_STANDALONE
871 #endif // not XAOD_STANDALONE
◆ 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 884 of file Control/xAODRootAccess/Root/TEvent.cxx.
894 while( std::getline(
ss, attr,
'.' ) ) {
◆ 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 3187 of file Control/xAODRootAccess/Root/TEvent.cxx.
3192 return StatusCode::SUCCESS;
3196 const std::string
key =
mgr.branch()->GetName();
3204 TVirtualManager* auxMgr =
nullptr;
3214 return StatusCode::SUCCESS;
3216 auxMgr = itr->second;
3217 auxKey =
key +
"Aux.";
3222 ::Int_t readBytes = auxMgr->getEntry();
3226 const std::string dynAuxKey = auxKey +
"Dynamic";
3227 auto dynAuxMgr =
objects.find( dynAuxKey );
3229 if( ( dynAuxMgr !=
objects.end() ) &&
3231 ( auxMgr == &
mgr ) ) ) {
3236 dynAuxMgr->second->getEntry();
3250 auto dynAuxMgr =
objects.find( dynAuxKey );
3251 if( dynAuxMgr ==
objects.end() ) {
3252 ::Error(
"xAOD::TEvent::setAuxStore",
3254 return StatusCode::FAILURE;
3256 dynAuxMgr->second->getEntry();
3262 if( auxMgr == &
mgr ) {
3263 return StatusCode::SUCCESS;
3269 switch(
mgr.holder()->typeKind() ) {
3288 if(
vec && ( !
vec->trackIndices() ) ) {
3289 forceTrackIndices( *
vec );
3293 if( ( !
vec ) && ( ! aux ) ) {
3294 ::Fatal(
"xAOD::TEvent::setAuxStore",
3296 "SG::AuxVectorBase or SG::AuxElement" ),
3297 mgr.holder()->getClass()->GetName() );
3304 TAuxManager* amgr =
dynamic_cast< TAuxManager*
>( auxMgr );
3306 ::Fatal(
"xAOD::TEvent::setAuxStore",
3307 XAOD_MESSAGE(
"Auxiliary manager for \"%s\" is not of the "
3308 "right type" ), auxKey.c_str() );
3309 return StatusCode::FAILURE;
3311 store = amgr->getConstStore();
3317 amgr->getStore()->setStructMode(
mode );
3321 TObjectManager* omgr =
3322 dynamic_cast< TObjectManager*
>( auxMgr );
3324 ::Fatal(
"xAOD::TEvent::setAuxStore",
3325 XAOD_MESSAGE(
"Auxiliary manager for \"%s\" is not of the "
3326 "right type" ), auxKey.c_str() );
3327 return StatusCode::FAILURE;
3333 ::Fatal(
"xAOD::TEvent::setAuxStore",
3343 ::Fatal(
"xAOD::TEvent::setAuxStore",
3348 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 3711 of file Control/xAODRootAccess/Root/TEvent.cxx.
◆ 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 3103 of file Control/xAODRootAccess/Root/TEvent.cxx.
3106 ::TMethodCall setNameCall;
3110 setNameCall.InitWithPrototype(
mgr.holder()->getClass(),
3111 "setName",
"const char*" );
3112 if( setNameCall.IsValid() ) {
3117 const char* charParams =
params.Data();
3118 setNameCall.Execute(
mgr.holder()->get(), charParams );
3121 ::Warning(
"xAOD::TEvent::setUpDynamicStore",
3122 "Couldn't find setName(...) function for container %s "
3124 mgr.branch()->GetName(),
3125 mgr.holder()->getClass()->GetName() );
3130 static const TClass*
const holderClass =
3132 if( !
mgr.holder()->getClass()->InheritsFrom( holderClass ) ) {
3134 return StatusCode::SUCCESS;
3141 if( ! storeHolder ) {
3142 ::Fatal(
"xAOD::TEvent::setUpDynamicStore",
3144 return StatusCode::FAILURE;
3152 new TAuxStore(
mgr.branch()->GetName(), kFALSE,
3160 TAuxManager* amgr =
new TAuxManager(
store, kFALSE );
3168 store->getEntry( 0 );
3174 return StatusCode::SUCCESS;
◆ stringToKey()
|
overrideprotectedinherited |
◆ 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.
41 ::TClass*
cl = ::TClass::GetClass(
type.c_str() );
43 ::Warning(
"xAOD::TPyEvent::transientContains",
44 "Type name \"%s\" not known",
type.c_str() );
49 const std::type_info* ti =
cl->GetTypeInfo();
51 ::Warning(
"xAOD::TPyEvent::transientContains",
52 "Type \"%s\" doesn't have a proper dictionary",
◆ 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 3704 of file Control/xAODRootAccess/Root/TEvent.cxx.
◆ 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()
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 694 of file Control/xAODRootAccess/Root/TEvent.cxx.
699 ::Error(
"xAOD::TEvent::writeTo",
700 XAOD_MESSAGE(
"Null pointer given to the function!" ) );
701 return StatusCode::FAILURE;
706 ::Error(
"xAOD::TEvent::writeTo",
707 XAOD_MESSAGE(
"Object already writing to a file. Close that "
709 return StatusCode::FAILURE;
727 return StatusCode::SUCCESS;
◆ ATLAS_THREAD_SAFE
|
mutableprotectedinherited |
◆ CACHE_SIZE
const ::Int_t xAOD::TEvent::CACHE_SIZE = -1 |
|
staticprotectedinherited |
◆ 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
◆ KEY_MASK
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 |
◆ m_auxMode
◆ m_branchesMutex
|
mutableprotectedinherited |
◆ m_entry
::Long64_t xAOD::TEvent::m_entry |
|
protectedinherited |
◆ m_inChain
::TChain* xAOD::TEvent::m_inChain |
|
protectedinherited |
◆ m_inChainTracker
◆ m_inMetaTree
::TTree* xAOD::TEvent::m_inMetaTree |
|
protectedinherited |
◆ m_inputEventFormat
◆ m_inputMetaObjects
Object_t xAOD::TEvent::m_inputMetaObjects |
|
protectedinherited |
◆ m_inputMissingObjects
std::set< std::string > xAOD::TEvent::m_inputMissingObjects |
|
protectedinherited |
◆ m_inputObjects
◆ m_inTree
::TTree* xAOD::TEvent::m_inTree |
|
protectedinherited |
◆ m_inTreeMissing
::Bool_t xAOD::TEvent::m_inTreeMissing |
|
protectedinherited |
◆ m_inTreeNumber
::Int_t xAOD::TEvent::m_inTreeNumber |
|
protectedinherited |
◆ m_listeners
◆ m_nameRemapping
std::unordered_map< std::string, std::string > xAOD::TEvent::m_nameRemapping |
|
protectedinherited |
◆ m_outputEventFormat
◆ m_outputMetaObjects
Object_t xAOD::TEvent::m_outputMetaObjects |
|
protectedinherited |
◆ m_outputObjects
◆ m_outTree
::TTree* xAOD::TEvent::m_outTree |
|
protectedinherited |
◆ m_printEventProxyWarnings
Bool_t xAOD::TEvent::m_printEventProxyWarnings = true |
|
protectedinherited |
◆ METADATA_TREE_NAME
The documentation for this class was generated from the following files:
::Int_t m_inTreeNumber
The number of the currently open tree in the input chain.
JetConstituentVector::iterator iterator
std::unordered_map< std::string, std::string > m_nameRemapping
Container name re-mapping rules.
@ AUXELEMENT
A type inheriting from SG::AuxElement.
SG::DataProxy * proxy_exact(SG::sgkey_t sgkey) const override
Get proxy given a hashed key+clid.
#define RETURN_CHECK(CONTEXT, EXP)
Helper macro for checking return codes in a compact form in the code.
const std::string & name() const override
Get the name of the instance.
EAuxMode m_auxMode
The auxiliary access mode.
@ kUndefinedAccess
Undefined, to be selected by the object.
virtual AuxStoreType getStoreType() const =0
Return the type of the store object.
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.
std::string find(const std::string &s)
return a remapped string
ReadStats & stats()
Access the object belonging to the current thread.
static AuxTypeRegistry & instance()
Return the singleton registry instance.
@ SILENT
don't print anything and return success
static void setEvent(TVirtualEvent *ptr)
Set the active event pointer.
std::string normalizedTypeinfoName(const std::type_info &info)
Convert a type_info to a normalized string representation (matching the names used in the root dictio...
Base class for elements of a container that can have aux data.
void * getOutputObject(SG::sgkey_t key, const std::type_info &ti) override
Function for retrieving an output object in a non-template way.
@ DATAVECTOR
A DataVector container.
@ kAthenaAccess
Access containers/objects like Athena does.
::TTree * m_outTree
The tree that we are writing to.
::TChain * m_inChain
The (optional) chain provided as input.
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.
void Print(::Option_t *option="") const
Print information about the collected statistics.
EStructMode
"Structural" modes of the object
Object_t m_inputObjects
Collection of all the managed input objects.
static IProxyDict * setStore(IProxyDict *store)
Set the current store.
static TStore * store()
Access the currently active TStore object.
BranchStats * container(const std::string &name)
Access the description of a container. Creating it if necessary.
StatusCode copy(const std::string &key, ::Int_t basketSize=32000, ::Int_t splitLevel=0)
Copy an object directly from the input to the output.
std::vector< size_t > vec
@ kClassAccess
Access auxiliary data using the aux containers.
SG::sgkey_t stringToKey(const std::string &str, CLID clid) override
Find the string corresponding to a given key.
virtual const std::type_info * getIOType(SG::auxid_t auxid) const =0
Return the type of the data to be stored for one aux data item.
@ kObjectStore
The object describes a single object.
@ kContainerStore
The object describes an entire container.
Manage index tracking and synchronization of auxiliary data.
::TTree * m_inMetaTree
Pointer to the metadata tree in the input file.
Interface providing I/O for a generic auxiliary store.
std::string dynBranchPrefix(const std::string &key)
This function is used to figure out what to name dynamic auxiliary branches coming from a container c...
void nextEvent()
Function incrementing the processed event counter.
Handle mappings between names and auxid_t.
size_t auxid_t
Identifier for a particular aux data item.
Bool_t m_printEventProxyWarnings
Option to silence common warnings that seem to be harmless.
bit_t size() const
Count the number of 1 bits in the set.
const BranchInfo * getBranchInfo(SG::sgkey_t sgkey) const
Get the object describing one object/branch.
::TTree * m_inTree
The main tree that we are reading from.
std::string getTypeName(const std::type_info &ti)
This function is necessary in order to create type names that ROOT can understand.
void setStore(const SG::IConstAuxStore *store)
Set the store associated with this object.
::Long64_t getEntries() const
Get how many entries are available from the current input file(s)
std::unordered_map< std::string, std::set< std::string > > m_auxItemList
Rules for selecting which auxiliary branches to write.
::Int_t getEntry(::Long64_t entry, ::Int_t getall=0)
Function loading a given entry of the input TTree.
::Bool_t isStandalone(const TObjectManager &mgr)
Function checking if an object is standalone (not a container)
virtual SG::auxid_set_t getSelectedAuxIDs() const
Get a list of dynamic variables that need to be written out.
void reset()
Reset the object.
void setBranchNum(::Int_t num)
Set the total number of branches on the input.
EventFormat m_inputEventFormat
Format of the current input file.
bool empty() const
Return true if there are no 1 bits in the set.
SG::DataProxy * proxy(const void *const pTransient) const override
get proxy for a given data object address in memory
::Bool_t contains(const std::string &key)
Function checking if an object is available from the store.
const xAOD::EventFormatElement * getEventFormatElement(SG::sgkey_t sgkey) const
Get the metadata object for a given "SG key".
static IOStats & instance()
Singleton object accessor.
Listener_t m_listeners
Listeners who should be notified when certain incidents happen.
static const ::Int_t CACHE_SIZE
Size of a possible TTreeCache (30 MB)
Object_t m_outputMetaObjects
Collection of all the managed output meta-objects.
Object_t m_outputObjects
Collection of all the managed output object.
Object_t m_inputMetaObjects
Collection of all the managed input meta-objects.
virtual void setStore(IAuxStore *store)=0
Give an auxiliary store object to the holder object.
void setProxy(SG::DataProxy &proxy)
void print(char *figname, TCanvas *c1)
void keys(std::vector< std::string > &vkeys, bool metadata=false) const
provide list of all keys associated with provided type.
upgrade_mutex_t m_branchesMutex
Class helping in dealing with dynamic branch selection.
static const char *const METADATA_TREE_NAME
Name of the metadata tree.
::Bool_t internalStateChanged() const
Check whether there was an internal state change without us knowing.
std::unordered_set< sgkey_t > SGKeySet
A set of sgkey_t values.
StatusCode record(T *obj, const std::string &key, ::Int_t basketSize=32000, ::Int_t splitLevel=0)
Add an output object to the event.
AthContainers_detail::upgrading_lock< upgrade_mutex_t > upgrading_lock_t
TEvent(EAuxMode mode=kUndefinedAccess)
Default constructor.
::Bool_t m_inTreeMissing
Internal status flag showing that an input file is open, but it doesn't contain an event tree.
void readContainer(const std::string &name)
Function incrementing the read counter on a specific container.
StatusCode initStats()
Function to initialise the statistics for all Tree content.
Manager for EDM objects created by ROOT.
uint32_t sgkey_t
Type used for hashed StoreGate key+CLID pairs.
virtual const void * getIOData(SG::auxid_t auxid) const =0
Return a pointer to the data to be stored for one aux data item.
::Bool_t transientContains(const std::string &key) const
Function checking if an object is already in memory.
::Bool_t isAuxStore(const TObjectManager &mgr)
Function checking if a given object may be an auxiliary store.
StatusCode connectAux(const std::string &prefix, ::Bool_t standalone)
Function setting up access to a set of auxiliary branches.
EventFormat * m_outputEventFormat
Format of the current output file.
StatusCode setUpDynamicStore(TObjectManager &mgr, ::TTree *tree)
Function adding dynamic variable reading capabilities to an auxiliary store object.
::Long64_t getFiles() const
Get how many files are available on the currently defined input.
def silent(func)
Redirect stdout/err to /dev/null Useful wrapper to get rid of ROOT verbosity...
SG::SGKeyMap< BranchInfo > m_branches ATLAS_THREAD_SAFE
Map from hashed sgkey to BranchInfo.
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
::Bool_t hasAuxStore(const TObjectManager &mgr)
Function checking if a given object may have an auxiliary store.
std::string getFirstBranchMatch(TTree *tree, const std::string &pre)
This function is used to search for a branch in a TTree that contains a given substring.
StatusCode connectBranch(const std::string &key, ::Bool_t silent=kFALSE)
Function setting up access to a particular branch.
SG::sgkey_t getHash(const std::string &key) const override
Function returning the hash describing an object name.
EventFormat_v1 EventFormat
Definition of the current event format version.
void setSGKey(sgkey_t sgkey)
check if it is a transient ID (primary or symLinked):
::Long64_t m_entry
The entry to look at from the input tree.
TChainStateTracker * m_inChainTracker
Optional object for tracking the state changes of an input TChain.
@ kUndefinedStore
The structure mode is not defined.
StatusCode readFrom(::TFile *file, Bool_t useTreeCache=kTRUE, const char *treeName=EVENT_TREE_NAME)
Connect the object to a new input file.
A set of aux data identifiers.
std::unordered_map< std::string, TVirtualManager * > Object_t
Definition of the internal data structure type.
@ kBranchAccess
Access auxiliary data branch-by-branch.
const std::string & getName(const void *obj) const override
Function returning the key describing a known object.
Class describing the access statistics of a collection of branches.
Interface for const operations on an auxiliary store.
void setActive() const
Set this event object as the currently active one.
@ AST_ObjectStore
The store describes a single object.
Interface for objects taking part in direct ROOT I/O.
SG::sgkey_t hash(const std::string &name)
This function provides a hashed version of the key (branch) names used in the xAOD file,...
StatusCode connectMetaBranch(const std::string &key, ::Bool_t silent=kFALSE)
Function setting up access to a branch in the metadata tree.
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
char rootType(char typeidType)
This function is used internally in the code when creating primitive dynamic auxiliary branches.
std::set< std::string > m_inputMissingObjects
Objects that have been asked for, but were found to be missing in the current input.
@ AST_ContainerStore
The store describes a container.
StatusCode connectMetaAux(const std::string &prefix, ::Bool_t standalone)
Function setting up access to a set of auxiliary branches for a metadata object.
StatusCode setAuxStore(TObjectManager &mgr, ::Bool_t metadata=kFALSE)
Function connecting a DV object to its auxiliary store.