xAOD::TAuxStore Class Reference

"ROOT implementation" of IAuxStore More...

#include <TAuxStore.h>

Inheritance diagram for xAOD::TAuxStore:

Collaboration diagram for xAOD::TAuxStore:

Classes
class	TBranchHandle
	Class used internally to implement just-in-time reading. More...

Public Types
enum	EStructMode { kUndefinedStore = 0, kContainerStore = 1, kObjectStore = 2 }
	"Structural" modes of the object More...
typedef SG::auxid_t	auxid_t
	Convenience type declaration. More...
typedef SG::auxid_set_t	auxid_set_t
	Convenience type declaration. More...

Public Member Functions
	TAuxStore (const char *prefix="", Bool_t topStore=kTRUE, EStructMode mode=kUndefinedStore, Int_t basketSize=2048, Int_t splitLevel=0)
	Default constructor. More...
	~TAuxStore ()
	Destructor. More...
EStructMode	structMode () const
	Get what structure mode the object was constructed with. More...
StatusCode	setStructMode (EStructMode mode)
	Set the structure mode of the object to a new value. More...
const char *	prefix () const
	Get the currently configured branch name prefix. More...
void	setPrefix (const char *prefix)
	Set the branch name prefix. More...
Bool_t	isTopStore () const
	Check if the object is a "top store", or not. More...
void	setTopStore (Bool_t value=kTRUE)
	Set whether the object should behave as a "top store" or not. More...
Int_t	basketSize () const
	Get the size of the baskets created for the output branches. More...
void	setBasketSize (Int_t value)
	Set the size of the baskets created for the output branches. More...
Int_t	splitLevel () const
	Get the split level of the output branches. More...
void	setSplitLevel (Int_t value)
	Set the split level of the output branches. More...
StatusCode	readFrom (::TTree *tree, ::Bool_t printWarnings=kTRUE)
	Connect the object to an input TTree. More...
StatusCode	writeTo (::TTree *tree)
	Connect the object to an output TTree. More...
Int_t	getEntry (Int_t getall=0)
	Read the values from the TTree entry that was loaded with TTree::LoadTree() More...
void	reset ()
	Tell the object that all branches will need to be re-read. More...
virtual const void *	getData (SG::auxid_t auxid) const=0
	Pick up the const version from the base class. More...
virtual bool	insertMove (size_t pos, IAuxStore &other, const SG::auxid_set_t &ignore=SG::auxid_set_t())=0
	Move all elements from other to this store. More...
virtual bool	setOption (auxid_t, const AuxDataOption &)
	Set an option for a given auxiliary variable. More...
Functions implementing the SG::IConstAuxStore interface
virtual const void *	getData (auxid_t auxid) const override
	Get a pointer to a given array. More...
virtual const auxid_set_t &	getAuxIDs () const override
	Get the types(names) of variables handled by this container. More...
virtual void *	getDecoration (auxid_t auxid, size_t size, size_t capacity) override
	Get a pointer to a given array, creating the array if necessary. More...
virtual bool	isDecoration (auxid_t auxid) const override
	Test if a variable is a decoration. More...
virtual void	lock () override
	Lock the object, and don't let decorations be added. More...
virtual bool	clearDecorations () override
	Remove the decorations added so far. More...
virtual void	lockDecoration (SG::auxid_t auxid) override
	Lock a decoration. More...
virtual size_t	size () const override
	Return the number of elements in the store. More...
Functions implementing the SG::IAuxStore interface
virtual void *	getData (auxid_t auxid, size_t size, size_t capacity) override
	Get a pointer to a given array, creating the array if necessary. More...
virtual const auxid_set_t &	getWritableAuxIDs () const override
	Return a set of writable data identifiers. More...
virtual bool	resize (size_t size) override
	Resize the arrays to a given size. More...
virtual void	reserve (size_t size) override
	Reserve a given size for the arrays. More...
virtual void	shift (size_t pos, ptrdiff_t offs) override
	Shift the contents of the stored arrays. More...
virtual bool	insertMove (size_t pos, IAuxStore &other, const SG::auxid_set_t &ignore) override
	Insert contents of another store via move. More...
Functions implementing the SG::IAuxStoreIO interface
virtual const void *	getIOData (auxid_t auxid) const override
	Get a pointer to the data being stored for one aux data item. More...
virtual const std::type_info *	getIOType (auxid_t auxid) const override
	Return the type of the data to be stored for one aux data item. More...
virtual const auxid_set_t &	getDynamicAuxIDs () const override
	Get the types(names) of variables created dynamically. More...
virtual void	selectAux (const std::set< std::string > &attributes)
	Select dynamic auxiliary attributes for writing. More...
virtual auxid_set_t	getSelectedAuxIDs () const override
	Get the IDs of the selected aux variables. More...

Static Public Attributes
static constexpr bool	supportsThinning = true
	Mark that this type supports thinning operations. More...

Private Types
typedef AthContainers_detail::mutex	mutex_t
	Mutex type for multithread synchronization. More...
typedef AthContainers_detail::lock_guard< mutex_t >	guard_t
	Guard type for multithreaded synchronisation. More...

Private Member Functions
StatusCode	initStats (::TTree *tree)
	Function used for setting up the statistics info about the managed branches. More...
StatusCode	setupInputData (auxid_t auxid)
	Connect a variable to the input tree. More...
StatusCode	setupOutputData (auxid_t auxid)
	Connect a variable to the output tree. More...
StatusCode	scanInputTree ()
	Scan the input TTree for auxiliary branches. More...
StatusCode	setupAuxBranch (::TBranch *br, const char *auxName, ::Bool_t staticBranch)
	Register one input branch as an available auxiliary variable. More...
::Bool_t	isAuxIDSelected (auxid_t auxid) const
	Check if this auxiliary variable needs to go to the output. More...

Static Private Member Functions
::Bool_t	isPrimitiveBranch (TBranch *br)
	Check if a branch holds a primitive variable or not. More...
::Bool_t	isContainerBranch (TBranch *br, auxid_t auxid)
	Check if a branch describes a container or a single object. More...
::Bool_t	isRegisteredType (auxid_t auxid)
	Check if the auxiliary variable has a registered type. More...

Private Attributes
std::string	m_prefix
	Static prefix for the branch names. More...
std::string	m_dynPrefix
	Dynamic prefix for the branch names. More...
::Bool_t	m_topStore
	Flag stating whether this is a "top store". More...
EStructMode	m_structMode
	The "structural" mode of the object. More...
::Int_t	m_basketSize
	The basket size for the output branches. More...
::Int_t	m_splitLevel
	The split level for the output branches. More...
::TTree *	m_inTree
	The TTree being read from. More...
::TTree *	m_outTree
	The TTree being written to. More...
::Bool_t	m_inputScanned
	"Scan status" of the input TTree More...
AuxSelection	m_selection
	Object helping to select which auxiliary variables to write. More...
SG::AuxStoreInternal *	m_transientStore
	Store for the in-memory-only variables. More...
auxid_set_t	m_auxIDs
	Internal list of variable IDs handled currently by the object. More...
std::vector< SG::IAuxTypeVector * >	m_vecs
	Variables handled currently by the object. More...
std::size_t	m_size
	The current size of the container being described. More...
::Bool_t	m_locked
	Is this container locked? More...
std::vector< ::Bool_t >	m_isDecoration
	Flags items as decorations. More...
mutex_t	m_mutex1
	Mutexes object used for multithreaded synchronisation. More...
mutex_t	m_mutex2
std::vector< TBranchHandle * >	m_branches
	Branches reading the various auxiliary variables. More...
std::vector< bool >	m_branchesWritten
	"Write status" of the different variables More...
std::vector< bool >	m_missingBranches
	Mark branches we've found to be missing. More...

Friends
class	TEvent
	Make TEvent a friend of this class. More...

Detailed Description

"ROOT implementation" of IAuxStore

This is a "D3PDReader-like" implementation for the auxiliary store interface. It is meant to provide very efficient access to a relatively small number of auxiliary variables.

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 45 of file TAuxStore.h.

Member Typedef Documentation

auxid_set_t

typedef SG::auxid_set_t xAOD::TAuxStore::auxid_set_t

Convenience type declaration.

Definition at line 61 of file TAuxStore.h.

auxid_t

typedef SG::auxid_t xAOD::TAuxStore::auxid_t

Convenience type declaration.

Definition at line 59 of file TAuxStore.h.

guard_t

typedef AthContainers_detail::lock_guard< mutex_t > xAOD::TAuxStore::guard_t

private

Guard type for multithreaded synchronisation.

Definition at line 244 of file TAuxStore.h.

mutex_t

typedef AthContainers_detail::mutex xAOD::TAuxStore::mutex_t

private

Mutex type for multithread synchronization.

Definition at line 242 of file TAuxStore.h.

Member Enumeration Documentation

EStructMode

enum xAOD::TAuxStore::EStructMode

"Structural" modes of the object

Enumerator
kUndefinedStore	The structure mode is not defined.
kContainerStore	The object describes an entire container.
kObjectStore	The object describes a single object.

Definition at line 53 of file TAuxStore.h.

                       {
         kUndefinedStore = 0, 
         kContainerStore = 1, 
         kObjectStore    = 2  
      };

Constructor & Destructor Documentation

TAuxStore()

xAOD::TAuxStore::TAuxStore	(	const char *	prefix = "",
		Bool_t	topStore = kTRUE,
		EStructMode	mode = kUndefinedStore,
		Int_t	basketSize = 2048,
		Int_t	splitLevel = 0
	)

Default constructor.

Definition at line 56 of file TAuxStore.cxx.

      : SG::IAuxStore(), SG::IAuxStoreIO(),
        m_prefix( prefix ), m_dynPrefix( Utils::dynBranchPrefix( prefix ) ),
        m_topStore( topStore ), m_structMode( mode ), m_basketSize( basketSize ),
        m_splitLevel( splitLevel ), m_inTree( 0 ), m_outTree( 0 ),
        m_inputScanned( kFALSE ), m_selection(), m_transientStore( 0 ),
        m_auxIDs(), m_vecs(), m_size( 0 ), m_locked( kFALSE ), m_isDecoration(),
        m_mutex1(), m_mutex2(),
        m_branches(), m_branchesWritten(), m_missingBranches() {
 
   }

~TAuxStore()

xAOD::TAuxStore::~TAuxStore

(

)

Destructor.

Definition at line 70 of file TAuxStore.cxx.

                         {
 
      std::vector< SG::IAuxTypeVector* >::iterator vitr = m_vecs.begin();
      std::vector< SG::IAuxTypeVector* >::iterator vend = m_vecs.end();
      for( ; vitr != vend; ++vitr ) {
         if( *vitr ) delete *vitr;
      }
 
      std::vector< TBranchHandle* >::iterator bitr = m_branches.begin();
      std::vector< TBranchHandle* >::iterator bend = m_branches.end();
      for( ; bitr != bend; ++bitr ) {
         if( *bitr ) delete *bitr;
      }
 
      if( m_transientStore ) delete m_transientStore;
   }

Member Function Documentation

basketSize()

Int_t xAOD::TAuxStore::basketSize

(

)

const

Get the size of the baskets created for the output branches.

Definition at line 139 of file TAuxStore.cxx.

                                     {
 
      return m_basketSize;
   }

clearDecorations()

bool xAOD::TAuxStore::clearDecorations ( )

overridevirtual

Remove the decorations added so far.

Only works for transient decorations.

Implements SG::IConstAuxStore.

Definition at line 426 of file TAuxStore.cxx.

                                    {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // Clear the transient decorations:
      bool anycleared = false;
      if( m_transientStore ) {
         SG::auxid_set_t old_id_set = m_transientStore->getAuxIDs();
 
         // Clear the decorations from the transient store:
         anycleared = m_transientStore->clearDecorations();
 
         // Now remove ids that were cleared.
         if (anycleared) {
           old_id_set -= m_transientStore->getAuxIDs();
           // old_id_set is now the set of ids that were cleared.
           m_auxIDs -= old_id_set;
         }
      }
 
      // The decorations which are going into the output file, are here to stay.
      // Removing their IDs from the internal set would just cause more problems
      // in my mind than just leaving them be.
 
      return anycleared;
   }

getAuxIDs()

const TAuxStore::auxid_set_t & xAOD::TAuxStore::getAuxIDs ( ) const

overridevirtual

Get the types(names) of variables handled by this container.

Implements SG::IConstAuxStore.

Definition at line 321 of file TAuxStore.cxx.

                                                          {
 
      return m_auxIDs;
   }

getData() [1/3]

const void * xAOD::TAuxStore::getData ( auxid_t  auxid ) const

overridevirtual

Get a pointer to a given array.

Implements SG::IConstAuxStore.

Definition at line 286 of file TAuxStore.cxx.

                                                       {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // Check if the transient store already handles this variable:
      if( m_transientStore &&
          ( m_transientStore->getAuxIDs().test( auxid ) ) ) {
         return m_transientStore->getData( auxid );
      }
 
      // Connect this auxiliary variable both to the input and output
      // if needed:
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ||
          ( auxid >= m_branches.size() ) || ( ! m_branches[ auxid ] ) ) {
         auto this_nc ATLAS_THREAD_SAFE = const_cast<TAuxStore*>(this);  // locked above
         if( ( ! this_nc->setupInputData( auxid ).isSuccess() ) ||
             ( ! this_nc->setupOutputData( auxid ).isSuccess() ) ) {
            return 0;
         }
      }
 
      // Make sure the variable is up to date:
      const ::Int_t readBytes = m_branches[ auxid ]->getEntry();
      if( readBytes < 0 ) {
         ::Error( "xAOD::TAuxStore::getData",
                  XAOD_MESSAGE( "Couldn't read in variable %s" ),
                  SG::AuxTypeRegistry::instance().getName( auxid ).c_str() );
         return 0;
      }
 
      // Return the pointer to the object:
      return m_vecs[ auxid ]->toPtr();
   }

getData() [2/3]

void * xAOD::TAuxStore::getData ( auxid_t  auxid, size_t  size, size_t  capacity  )

overridevirtual

Get a pointer to a given array, creating the array if necessary.

Implements SG::IAuxStore.

Definition at line 488 of file TAuxStore.cxx.

                                               {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex2 );
 
      // Remember the size:
      m_size = size;
 
      // Check if we want to write this variable to the output:
      if( ( ! m_outTree ) || ( ! isAuxIDSelected( auxid ) ) ) {
         // Create the store only when necessary:
         if( ! m_transientStore ) {
            m_transientStore =
               new SG::AuxStoreInternal( m_structMode == kObjectStore );
            if( m_locked ) {
               m_transientStore->lock();
            }
         }
         // Let the transient store create the variable:
         size_t nids = m_transientStore->getAuxIDs().size();
         void* result = m_transientStore->getData( auxid, size, capacity );
         if( result && ( nids != m_transientStore->getAuxIDs().size() ) ) {
            m_auxIDs.insert( auxid );
         }
         // Return the address in the transient memory:
         return result;
      }
 
      // If the variable exists already, and this is a locked store, then
      // we are in trouble.
      if( m_locked && ( auxid < m_vecs.size() ) && m_vecs[ auxid ] ) {
         if( ! ( ( auxid < m_isDecoration.size() ) &&
                 m_isDecoration[ auxid ] ) ) {
            throw SG::ExcStoreLocked( auxid );
         }
      }
 
      // Connect this auxiliary variable just to the output:
      if( setupOutputData( auxid ).isFailure() ) {
         ::Error( "xAOD::TAuxStore::getData",
                  XAOD_MESSAGE( "Failed to set up variable %s" ),
                  SG::AuxTypeRegistry::instance().getName( auxid ).c_str() );
         return 0;
      }
 
      // Check whether things make sense:
      if( ( m_structMode == kObjectStore ) && ( size != 1 ) ) {
         ::Error( "xAOD::TAuxStore::getData",
                  XAOD_MESSAGE( "Branch creation requested with:" ) );
         ::Error( "xAOD::TAuxStore::getData",
                  XAOD_MESSAGE( "  name = %s" ),
                  SG::AuxTypeRegistry::instance().getName( auxid ).c_str() );
         ::Error( "xAOD::TAuxStore::getData",
                  XAOD_MESSAGE( "  size = %i" ),
                  static_cast< int >( size ) );
         ::Error( "xAOD::TAuxStore::getData",
                  XAOD_MESSAGE( "  m_structMode = kObjectStore" ) );
         return 0;
      }
 
      // Make sure the variable is of the right size:
      m_vecs[ auxid ]->reserve( capacity );
      m_vecs[ auxid ]->resize( size );
 
      // Return the object:
      return m_vecs[ auxid ]->toPtr();
   }

getData() [3/3]

virtual const void* SG::IConstAuxStore::getData

inherited

Pick up the const version from the base class.

getDecoration()

void * xAOD::TAuxStore::getDecoration ( auxid_t  auxid, size_t  size, size_t  capacity  )

overridevirtual

Get a pointer to a given array, creating the array if necessary.

Implements SG::IConstAuxStore.

Definition at line 326 of file TAuxStore.cxx.

                                                     {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // Remember the requested size:
      m_size = size;
 
      // If this is a locked object, deal with it correctly:
      if( m_locked ) {
         // If the variable exists already and it's a decoration, then let's
         // give it back.
         if( ( auxid < m_vecs.size() ) && m_vecs[ auxid ] &&
             ( auxid < m_isDecoration.size() && m_isDecoration[ auxid ] ) ) {
            // Things look okay...
            m_vecs[ auxid ]->reserve( capacity );
            m_vecs[ auxid ]->resize( size );
            return m_vecs[ auxid ]->toPtr();
         }
         // If it's in the transient store already, return it from there.
         // Since in a locked store *everything* is a decoration in the
         // transient store.
         if( m_transientStore &&
             m_transientStore->getAuxIDs().test( auxid ) ) {
            return m_transientStore->getDecoration( auxid, size, capacity );
         }
         // If we know this auxiliary ID, but it was not found as a decoration
         // by the previous checks, then we're in trouble.
         if( m_auxIDs.test( auxid ) ) {
            // It may still be a decoration in a transient store. If such
            // a store exists, leave it up to that store to
            throw SG::ExcStoreLocked( auxid );
         }
      }
 
      // Check if we want to write this variable to the output:
      if( ( ! isAuxIDSelected( auxid ) ) || ( ! m_outTree ) ) {
 
         // Create the store only when necessary:
         if( ! m_transientStore ) {
            m_transientStore =
               new SG::AuxStoreInternal( m_structMode == kObjectStore );
            if( m_locked ) {
               m_transientStore->lock();
            }
         }
         // Let the transient store create the decoration:
         const size_t nids = m_transientStore->getAuxIDs().size();
         void* result = m_transientStore->getDecoration( auxid, size,
                                                         capacity );
         if( result && ( nids != m_transientStore->getAuxIDs().size() ) ) {
            m_auxIDs.insert( auxid );
         }
         // Return the memory address from the transient store:
         return result;
      }
 
      // Doesn't exist yet. So let's make it:
      void* result = getData( auxid, size, capacity );
      if( m_locked ) {
         // If the container is locked, remember that this is a decoration:
         if( m_isDecoration.size() <= auxid ) {
            m_isDecoration.resize( auxid + 1 );
         }
         m_isDecoration[ auxid ] = ::kTRUE;
      }
 
      // Return the pointer made by getData(...):
      return result;
   }

getDynamicAuxIDs()

const TAuxStore::auxid_set_t & xAOD::TAuxStore::getDynamicAuxIDs ( ) const

overridevirtual

Get the types(names) of variables created dynamically.

Implements SG::IAuxStoreIO.

Definition at line 789 of file TAuxStore.cxx.

                                                                 {
 
      // All the auxiliary decorations handled by this object are considered
      // dynamic:
      return getAuxIDs();
   }

getEntry()

Int_t xAOD::TAuxStore::getEntry

(

Int_t

getall = 0

)

Read the values from the TTree entry that was loaded with TTree::LoadTree()

Definition at line 227 of file TAuxStore.cxx.

                                           {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // Reset the transient store. TEvent::fill() calls this function with
      // getall==99. When that is happening, we need to keep the transient
      // store still around. Since the user may want to interact with the
      // object after it was written out. (And since TEvent::fill() asks for
      // the transient decorations after calling getEntry(...).)
      if( m_transientStore && ( getall != 99 ) ) {
         // Remove the transient auxiliary IDs from the internal list:
         m_auxIDs -= m_transientStore->getAuxIDs();
         // Delete the object:
         delete m_transientStore;
         m_transientStore = 0;
      }
 
      // Now remove the IDs of the decorations that are getting persistified:
      if( getall != 99 ) {
         for( auxid_t auxid = 0; auxid < m_isDecoration.size(); ++auxid ) {
            if( ! m_isDecoration[ auxid ] ) {
               continue;
            }
            m_auxIDs.erase( auxid );
         }
      }
 
      // If we don't need everything loaded, return now:
      if( ! getall ) return 0;
 
      // Get all the variables at once:
      ::Int_t bytesRead = 0;
      std::vector< TBranchHandle* >::iterator itr = m_branches.begin();
      std::vector< TBranchHandle* >::iterator end = m_branches.end();
      for( ; itr != end; ++itr ) {
         if( *itr ) {
            bytesRead += ( *itr )->getEntry();
         }
      }
 
      return bytesRead;
   }

getIOData()

const void * xAOD::TAuxStore::getIOData ( auxid_t  auxid ) const

overridevirtual

Get a pointer to the data being stored for one aux data item.

Implements SG::IAuxStoreIO.

Definition at line 705 of file TAuxStore.cxx.

                                                         {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // If the variable is connected to already:
      if( ( auxid < m_branches.size() ) && m_branches[ auxid ] ) {
         // Make sure that the right payload is in memory:
         m_branches[ auxid ]->getEntry();
         // Return the pointer:
         return m_branches[ auxid ]->objectPtr();
      }
 
      // Check if it's in the transient store:
      if( m_transientStore && m_transientStore->getAuxIDs().test( auxid ) ) {
         return m_transientStore->getIOData( auxid );
      }
 
      // If not, try connecting to it now:
      auto this_nc ATLAS_THREAD_SAFE = const_cast<TAuxStore*>(this);  // locked above
      if( ! this_nc->setupInputData( auxid ).isSuccess() ) {
         // This is not actually an error condition anymore. We can end up here
         // when we decorate constant objects coming from the input file, but
         // on one event we can't set any decorations. For instance when the
         // input container is empty. In that case the object will still list
         // the auxiliary ID belonging to that decoration as being available,
         // but it really isn't.
         //
         // Later on it might be needed to tweak the logic of all of this, but
         // for now just silently returning 0 seems to do the right thing.
         return 0;
      }
 
      // Now we should know this variable:
      if( ( auxid >= m_branches.size() ) || ( ! m_branches[ auxid ] ) ) {
         ::Fatal( "xAOD::TAuxStore::getIOData",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
         return 0;
      }
 
      // Make sure that the right payload is in memory:
      m_branches[ auxid ]->getEntry();
 
      // Return the pointer:
      return m_branches[ auxid ]->objectPtr();
   }

getIOType()

const std::type_info * xAOD::TAuxStore::getIOType ( auxid_t  auxid ) const

overridevirtual

Return the type of the data to be stored for one aux data item.

Implements SG::IAuxStoreIO.

Definition at line 752 of file TAuxStore.cxx.

                                                                 {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // If the variable is connected to already:
      if( ( auxid < m_branches.size() ) && m_branches[ auxid ] ) {
         return m_branches[ auxid ]->typeInfo();
      }
 
      // Check if it's in the transient store:
      if( m_transientStore && m_transientStore->getAuxIDs().test( auxid ) ) {
         return m_transientStore->getIOType( auxid );
      }
 
      // If not, try connecting to it now:
      auto this_nc ATLAS_THREAD_SAFE = const_cast<TAuxStore*>(this);  // locked above
      if( ! this_nc->setupInputData( auxid ).isSuccess() ) {
         ::Error( "xAOD::TAuxStore::getIOType",
                  XAOD_MESSAGE( "Couldn't connect to auxiliary variable "
                                "%i %s" ),
                  static_cast< int >( auxid ),
                  SG::AuxTypeRegistry::instance().getName( auxid ).c_str() );
         return 0;
      }
 
      // Now we should know this variable:
      if( ( auxid >= m_branches.size() ) || ( ! m_branches[ auxid ] ) ) {
         ::Fatal( "xAOD::TAuxStore::getIOType",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
         return 0;
      }
 
      // Return the type info:
      return m_branches[ auxid ]->typeInfo();
   }

getSelectedAuxIDs()

TAuxStore::auxid_set_t xAOD::TAuxStore::getSelectedAuxIDs ( ) const

overridevirtual

Get the IDs of the selected aux variables.

Reimplemented from SG::IAuxStoreIO.

Definition at line 805 of file TAuxStore.cxx.

                                                           {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // Leave the calculation up to the internal object:
      return m_selection.getSelectedAuxIDs( m_auxIDs );
   }

getWritableAuxIDs()

const TAuxStore::auxid_set_t & xAOD::TAuxStore::getWritableAuxIDs ( ) const

overridevirtual

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 557 of file TAuxStore.cxx.

                                                                  {
 
      return getAuxIDs();
   }

initStats()

StatusCode xAOD::TAuxStore::initStats ( ::TTree *  tree )

private

Function used for setting up the statistics info about the managed branches.

This function is used to initialise the statistics registry with information about the branches managed by this object.

It is used by TEvent when connecting to new input files/chains.

Parameters

tree	The tree to collect the information from

Returns

StatusCode::SUCCESS if the function was successful, something else otherwise

Definition at line 822 of file TAuxStore.cxx.

                                                {
 
      // Connect the object to this input tree:
      RETURN_CHECK( "initStats", readFrom( tree, kFALSE ) );
 
      // Conveninence variable:
      ReadStats& stats = IOStats::instance().stats();
 
      // Teach the cache about all the branches:
      size_t nbranch = 0;
      for (SG::auxid_t id : m_auxIDs) {
         stats.branch( m_prefix, id );
         ++nbranch;
      }
 
      // Increment the number of known branches:
      stats.setBranchNum( stats.branchNum() + nbranch );
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

insertMove() [1/2]

bool xAOD::TAuxStore::insertMove ( size_t  pos, IAuxStore &  other, const SG::auxid_set_t &  ignore  )

overridevirtual

Insert contents of another store via move.

Definition at line 651 of file TAuxStore.cxx.

   {
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // A sanity check:
      if( m_structMode == kObjectStore ) {
         ::Error( "xAOD::TAuxStore::insertMove",
                  XAOD_MESSAGE( "Should not have been called for single-object "
                                "store" ) );
         return false;
      }
 
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      bool nomove = true;
      size_t other_size = other.size();
 
      SG::auxid_set_t ignore = ignore_in;
 
      for (SG::auxid_t id : m_auxIDs) {
        SG::IAuxTypeVector* v_dst = nullptr;
        if (id < m_vecs.size())
          v_dst = m_vecs[id];
        if (v_dst) {
          ignore.insert (id);
          if (other.getData (id)) {
            void* src_ptr = other.getData (id, other_size, other_size);
            if (src_ptr) {
              if (!v_dst->insertMove (pos, src_ptr,
                                      reinterpret_cast<char*>(src_ptr) + other_size*r.getEltSize(id),
                                      other))
                nomove = false;
            }
          }
          else {
            const void* orig = v_dst->toPtr();
            v_dst->shift (pos, other_size);
            if (orig != v_dst->toPtr())
              nomove = false;
          }
        }
      }
 
      if( m_transientStore ) {
        if (!m_transientStore->insertMove( pos, other, ignore ))
          nomove = false;
      }
 
      return nomove;
   }

insertMove() [2/2]

virtual bool SG::IAuxStore::insertMove ( size_t  pos, IAuxStore &  other, const SG::auxid_set_t &  ignore = SG::auxid_set_t()  )

pure virtualinherited

Move all elements from other to this store.

Parameters

pos	The starting index of the insertion.
other	Store from which to do the move.
ignore	Set of variables that should not be added to the store.

Let len be the size of other. The store will be increased in size by len elements, with the elements at pos being copied to pos+len. Then, for each auxiliary variable, the entire contents of that variable for other will be moved to this store at index pos. This will be done via move semantics if possible; otherwise, it will be done with a copy. Variables present in this store but not in other will have the corresponding elements default-initialized. Variables in other but not in this store will be added unless they are in ignore.

Returns true if it is known that none of the vectors' memory moved, false otherwise.

Implemented in SG::AuxStoreInternal.

isAuxIDSelected()

Bool_t xAOD::TAuxStore::isAuxIDSelected ( auxid_t  auxid ) const

private

Check if this auxiliary variable needs to go to the output.

This is a tricky one.

The function can't just rely on getSelectedAuxIDs, as the aux ID received here may be a new ID that the object doesn't yet know about. So we have no other choice but to check this ID explicitly.

@apram auxid The auxiliary ID that should be checked

Returns

kTRUE if the variable needs to be written out, kFALSE if not

Definition at line 1660 of file TAuxStore.cxx.

                                                          {
 
      // A temporary object:
      auxid_set_t auxids; auxids.insert( auxid );
 
      // Check if the auxid is returned as a selected ID:
      return m_selection.getSelectedAuxIDs( auxids ).size();
   }

isContainerBranch()

Bool_t xAOD::TAuxStore::isContainerBranch ( TBranch *  br, auxid_t  auxid  )

staticprivate

Check if a branch describes a container or a single object.

The code needs to know if a given branch describes a single object, or a container of objects.

This function decides about this.

In case the function encounters a problem it returns kFALSE, as that is more likely to cause a crash a little later...

The function should probably be a bit optimisied in the future, as it makes a lot of security checks at the moment.

Parameters

br	The branch whose type we're interested in
auxid	The auxiliary ID of the variable described by the branch

Returns

kTRUE if the branch describes a container, kFALSE if it describes a single object

Definition at line 1711 of file TAuxStore.cxx.

                                                                   {
 
      // For unknown types it doesn't matter if the branch describes a
      // container or a single element.
      if( ! isRegisteredType( auxid ) ) return kTRUE;
 
      // The variables needed for the check:
      ::TClass* cl = 0;
      ::EDataType dType = kOther_t;
 
      // Get the variable type from the branch:
      if( br->GetExpectedType( cl, dType ) ) {
         ::Error( "xAOD::TAuxStore::isContainerBranch",
                  XAOD_MESSAGE( "Couldn't determine the type of branch "
                                "\"%s\"" ), br->GetName() );
         return kFALSE;
      }
 
      // If there is no class associated with the branch then it should be
      // a branch describing a standalone object. (As it should be a
      // "primitive" branch in this case.)
      if( ! cl ) {
         return kFALSE;
      }
 
      // If there is a class, ask for the type_info of its type:
      const std::type_info* root_ti = cl->GetTypeInfo();
      if( ! root_ti ) {
         // This may be an emulated class. One known case is when the type name
         // is saved as "basic_string<char>" rather than "string" by Athena I/O.
         // (It's not fully understood why this happens for dynamic branches...)
         // So, let's see if we can get a functional TClass by massaging the
         // type name a bit.
         ::TString typeName( cl->GetName() );
         typeName.ReplaceAll( "basic_string<char>", "string" );
         ::TClass* newCl = ::TClass::GetClass( typeName );
         if( newCl ) {
            root_ti = newCl->GetTypeInfo();
         }
      }
      if( ! root_ti ) {
         ::Error( "xAOD::TAuxStore::isContainerBranch",
                  XAOD_MESSAGE( "Couldn't get an std::type_info object out of "
                                "branch \"%s\" of type \"%s\"" ),
                  br->GetName(), cl->GetName() );
         return kFALSE;
      }
 
      // Ask for the auxiliary type infos:
      const std::type_info* aux_obj_ti =
         SG::AuxTypeRegistry::instance().getType( auxid );
      if( ! aux_obj_ti ) {
         ::Error( "xAOD::TAuxStore::isContainerBranch",
                  XAOD_MESSAGE( "Couldn't get std::type_info object for "
                                "auxiliary id: %i" ),
                  static_cast< int >( auxid ) );
         return kFALSE;
      }
      const std::type_info* aux_vec_ti =
         SG::AuxTypeRegistry::instance().getVecType( auxid );
      if( ! aux_vec_ti ) {
         ::Error( "xAOD::TAuxStore::isContainerBranch",
                  XAOD_MESSAGE( "Couldn't get std::type_info object for "
                                "auxiliary id: %i" ),
                  static_cast< int >( auxid ) );
         return kFALSE;
      }
 
      // Check which one the ROOT type info agrees with:
      if( *root_ti == *aux_obj_ti ) {
         // This branch describes a single object:
         return kFALSE;
      } else if( *root_ti == *aux_vec_ti ) {
         // This branch describes a container of objects:
         return kTRUE;
      }
 
      // For enum and vector<enum> types (PFO...) the type given by
      // the aux type registry is vector<int>. We have to take it into account
      // here...
      if( cl->GetCollectionProxy() &&
          ( *aux_vec_ti == typeid( std::vector< int > ) ) ) {
         return kTRUE;
      }
 
      TClass* cl2 = lookupVectorType (cl);
      if (cl2) {
        if (*cl2->GetTypeInfo() == *aux_vec_ti)
          return kTRUE;
      }
 
      // If we got this far, the branch may have undergone schema evolution. If
      // it's one that ROOT can deal with itself, then we should still be able
      // to read the branch with this code.
      //
      // Note that even after looking at the ROOT source code, I'm still not
      // 100% sure whether we would need to delete the objects returned by
      // TClass::GetConversionStreamerInfo(...) in this code. :-( But based on
      // general experience with the ROOT code, I'm going to say no...
      TClass* aux_vec_cl =
         TClass::GetClass( Utils::getTypeName( *aux_vec_ti ).c_str() );
      if( aux_vec_cl && aux_vec_cl->GetConversionStreamerInfo( cl, cl->GetClassVersion() ) ) {
         return kTRUE;
      }
      TClass* aux_obj_cl =
         TClass::GetClass( Utils::getTypeName( *aux_obj_ti ).c_str() );
      if( aux_obj_cl && aux_obj_cl->GetConversionStreamerInfo( cl, cl->GetClassVersion() ) ) {
         return kFALSE;
      }
 
     // If neither, then something went wrong...
      ::Error( "xAOD::TAuxStore::isContainerBranch",
               XAOD_MESSAGE( "Couldn't determine if branch describes a single "
                             "object or a container" ) );
      ::Error( "xAOD::TAuxStore::isContainerBranch",
               XAOD_MESSAGE( "ROOT type  : %s" ),
               Utils::getTypeName( *root_ti ).c_str() );
      ::Error( "xAOD::TAuxStore::isContainerBranch",
               XAOD_MESSAGE( "Object type: %s" ),
               Utils::getTypeName( *aux_obj_ti ).c_str() );
      ::Error( "xAOD::TAuxStore::isContainerBranch",
               XAOD_MESSAGE( "Vector type: %s" ),
               Utils::getTypeName( *aux_vec_ti ).c_str() );
      return kFALSE;
   }

isDecoration()

bool xAOD::TAuxStore::isDecoration ( SG::auxid_t  auxid ) const

overridevirtual

Test if a variable is a decoration.

Implements SG::IConstAuxStore.

Definition at line 399 of file TAuxStore.cxx.

   {
     if (m_locked) {
       if (auxid < m_isDecoration.size() && m_isDecoration[auxid]) {
         return true;
       }
       if (m_transientStore) {
         return m_transientStore->isDecoration (auxid);
       }
     }
     return false;
   }

isPrimitiveBranch()

Bool_t xAOD::TAuxStore::isPrimitiveBranch ( TBranch *  br )

staticprivate

Check if a branch holds a primitive variable or not.

The code needs to be fairly smart to figure out whether a branch is a primitive one, or an std::vector<T> one.

The check is done in this function.

Parameters

br	The branch that should be checked

Returns

kTRUE if the branch describes a primitive variable, kFALSE otherwise

Definition at line 1677 of file TAuxStore.cxx.

                                                    {
 
      // The variables needed for the check:
      ::TClass* cl = 0;
      ::EDataType dType = kOther_t;
 
      // Get the variable type from the branch:
      if( br->GetExpectedType( cl, dType ) ) {
         ::Error( "xAOD::TAuxStore::isPrimitiveBranch",
                  XAOD_MESSAGE( "Couldn't determine the type of branch "
                                "\"%s\"" ), br->GetName() );
         return kFALSE;
      }
 
      // The check is made using the data type variable:
      return ( ( dType != kOther_t ) && ( dType != kNoType_t ) &&
               ( dType != kVoid_t ) );
   }

isRegisteredType()

Bool_t xAOD::TAuxStore::isRegisteredType ( auxid_t  auxid )

staticprivate

Check if the auxiliary variable has a registered type.

This function is used to test if a given auxiliary variable is known in the registry with a proper type.

Returns

kTRUE if the full type of the auxiliary property is known, kFALSE otherwise

Definition at line 1843 of file TAuxStore.cxx.

                                                     {
 
      // Cache some data:
      static SG::AuxTypeRegistry& registry ATLAS_THREAD_SAFE =
         SG::AuxTypeRegistry::instance();
      static const auxid_t sauxid =
         registry.getAuxID< SG::AuxTypePlaceholder >( "AuxTypePlaceholder" );
      static const std::type_info* const sti = registry.getVecType( sauxid );
 
      // Check if the types match:
      return ( *sti != *( registry.getVecType( auxid ) ) );
   }

isTopStore()

Bool_t xAOD::TAuxStore::isTopStore

(

)

const

Check if the object is a "top store", or not.

Definition at line 127 of file TAuxStore.cxx.

                                      {
 
      return m_topStore;
   }

lock()

void xAOD::TAuxStore::lock ( )

overridevirtual

Lock the object, and don't let decorations be added.

Implements SG::IConstAuxStore.

Definition at line 413 of file TAuxStore.cxx.

                        {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      m_locked = true;
      if( m_transientStore ) {
         m_transientStore->lock();
      }
 
      return;
   }

lockDecoration()

void xAOD::TAuxStore::lockDecoration ( SG::auxid_t  auxid )

overridevirtual

Lock a decoration.

Implements SG::IConstAuxStore.

Definition at line 455 of file TAuxStore.cxx.

   {
     if( m_transientStore ) {
       m_transientStore->lockDecoration (auxid);
     }
   }

prefix()

const char * xAOD::TAuxStore::prefix

(

)

const

Get the currently configured branch name prefix.

Definition at line 114 of file TAuxStore.cxx.

                                       {
 
      return m_prefix.c_str();
   }

readFrom()

StatusCode xAOD::TAuxStore::readFrom	(	::TTree *	tree,
		::Bool_t	printWarnings = kTRUE
	)

Connect the object to an input TTree.

This function is called by the infrastructure to connect the object to an input TTree whenever a new input file is opened.

Parameters

tree	Pointer to the TTree that is being read from

Definition at line 166 of file TAuxStore.cxx.

                                                                     {
 
      // Make sure that everything will be re-read after this:
      reset();
 
      // We will need to check again which branches are available:
      m_missingBranches.clear();
 
      // Remember the tree:
      m_inTree = tree;
 
      // Catalogue all the branches:
      RETURN_CHECK( "xAOD::TAuxStore::readFrom", scanInputTree() );
 
      // Check if we'll be likely to be able to read the "static"
      // variables:
      assert( m_inTree != nullptr );
      TBranch* br = m_inTree->GetBranch( m_prefix.c_str() );
      if( ! br ) {
         // We might not even have static branches, so this is not an error
         // by itself...
         return StatusCode::SUCCESS;
      }
      // In order to read complex objects, like smart pointers from an
      // auxiliary container variable-by-variable, the split level of the
      // branch must be exactly 1.
      if( ( br->GetSplitLevel() != 1 ) && m_topStore && printWarnings ) {
         ::Warning( "xAOD::TAuxStore::readFrom",
                    "Static branch (%s) with split level %i discovered",
                    m_prefix.c_str(), br->GetSplitLevel() );
         ::Warning( "xAOD::TAuxStore::readFrom",
                    "The reading of complex variables from it may/will fail!" );
      }
 
      return StatusCode::SUCCESS;
   }

reserve()

void xAOD::TAuxStore::reserve ( size_t  size )

overridevirtual

Reserve a given size for the arrays.

Implements SG::IAuxStore.

Definition at line 593 of file TAuxStore.cxx.

                                        {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // A sanity check:
      if( ( m_structMode == kObjectStore ) && ( size != 1 ) ) {
         ::Error( "xAOD::TAuxStore::reserve",
                  XAOD_MESSAGE( "size = %i for single-object store" ),
                  static_cast< int >( size ) );
         return;
      }
 
      std::vector< SG::IAuxTypeVector* >::iterator itr = m_vecs.begin();
      std::vector< SG::IAuxTypeVector* >::iterator end = m_vecs.end();
      for( ; itr != end; ++itr ) {
         if( *itr ) ( *itr )->reserve( size );
      }
      if( m_transientStore ) {
         m_transientStore->reserve( size );
      }
 
      return;
   }

reset()

void xAOD::TAuxStore::reset

(

)

Tell the object that all branches will need to be re-read.

Definition at line 271 of file TAuxStore.cxx.

                         {
 
      // Reset all the branches:
      std::vector< TBranchHandle* >::iterator itr = m_branches.begin();
      std::vector< TBranchHandle* >::iterator end = m_branches.end();
      for( ; itr != end; ++itr ) {
         if( *itr ) ( *itr )->reset();
      }
 
      // Remember that the input TTree needs to be re-scanned:
      m_inputScanned = kFALSE;
 
      return;
   }

resize()

bool xAOD::TAuxStore::resize ( size_t  size )

overridevirtual

Resize the arrays to a given size.

Implements SG::IAuxStore.

Definition at line 562 of file TAuxStore.cxx.

                                       {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // A sanity check:
      if( ( m_structMode == kObjectStore ) && ( size != 1 ) ) {
         ::Error( "xAOD::TAuxStore::resize",
                  XAOD_MESSAGE( "size = %i for single-object store" ),
                  static_cast< int >( size ) );
         return false;
      }
 
      // Remember the new size:
      m_size = size;
 
      bool nomoves = true;
      for (SG::IAuxTypeVector* v : m_vecs) {
         if(v) {
           if (!v->resize( size ))
             nomoves = false;
         }
      }
      if( m_transientStore ) {
        if (!m_transientStore->resize( size ))
          nomoves = false;
      }
 
      return nomoves;
   }

scanInputTree()

StatusCode xAOD::TAuxStore::scanInputTree ( )

private

Scan the input TTree for auxiliary branches.

When writing an output tree, while reading information from an input tree, it can often happen that we want to copy the contents of some variables that we don't actually need during the event processing of this particular job.

Since the user doesn't ask for all the possible input variables, this function needs to look at the input TTree, and try to figure out which of the branches in the tree belong to this object.

The function creates a "proper" or "virtual" auxiliary ID for each of the branches found, so they can be referenced in the "usual way" in the other parts of the code later on.

Returns

kTRUE if the operation was successful, kFALSE if not

Definition at line 1353 of file TAuxStore.cxx.

                                       {
 
      // Check if an input tree is even available:
      if( ! m_inTree ) {
         // It's not an error if it isn't.
         return StatusCode::SUCCESS;
      }
 
      // Check if the input was already scanned:
      if( m_inputScanned ) {
         return StatusCode::SUCCESS;
      }
 
      // Get a list of all branches in the tree:
      TObjArray* branches = m_inTree->GetListOfBranches();
 
      // Check each of them:
      for( Int_t i = 0; i < branches->GetEntriesFast(); ++i ) {
 
         // The name of this top-level branch:
         const TString brName = branches->At( i )->GetName();
 
         // Access the branch pointer:
         TBranch* br = dynamic_cast< TBranch* >( branches->At( i ) );
         if( ! br ) {
            ::Fatal( "xAOD::TAuxStore::scanInputTree",
                     XAOD_MESSAGE( "Logic error detected" ) );
         }
 
         // For top-level stores let's scan the static branches as well:
         if( m_topStore && ( brName == m_prefix ) ) {
 
            // Get a list of its sub-branches:
            TObjArray* sbranches = br->GetListOfBranches();
 
            // ...and then loop over them:
            for( Int_t j = 0; j < sbranches->GetEntriesFast(); ++j ) {
 
               // The name of the sub-branch:
               const TString brName = sbranches->At( j )->GetName();
 
               // Try to make a variable name out of the branch name:
               const TString auxName = brName( brName.Index( "." ) + 1,
                                               brName.Length() );
 
               // Skip this entry if it refers to a base class:
               if( auxName.BeginsWith( "xAOD::" ) ||
                   auxName.BeginsWith( "SG::" ) ||
                   ( auxName == "ILockable" ) ) {
                  continue;
               }
 
               // The sub-branch:
               ::TBranch* sbr =
                    dynamic_cast< ::TBranch* >( sbranches->At( j ) );
               if( ! sbr ) {
                  ::Fatal( "xAOD::TAuxStore::scanInputTree",
                           XAOD_MESSAGE( "Logic error detected" ) );
               }
 
               // Leave the rest up to the function that is shared with the
               // dynamic branches:
               RETURN_CHECK( "xAOD::TAuxStore::scanInputTree",
                             setupAuxBranch( sbr, auxName, kTRUE ) );
            }
 
            // Don't check the rest of the loop's body:
            continue;
         }
 
         // Check if it has the right prefix to be a dynamic variable:
         if( ! brName.BeginsWith( m_dynPrefix ) ) {
            continue;
         }
         // It's possible to create dynamic variables with an empty name
         // as well. Which is a bug. Such variables are just ignored
         // for now.
         if( brName == m_dynPrefix ) {
            ::Warning( "xAOD::TAuxStore::scanInputTree",
                       "Dynamic branch with empty name found on container: %s",
                       m_prefix.c_str() );
            continue;
         }
 
         // The auxiliary property name:
         const TString auxName = brName( brName.Index( "." ) + 1,
                                         brName.Length() );
 
         // Leave the rest up to the function that is shared with the
         // dynamic branches:
         RETURN_CHECK( "xAOD::TAuxStore::scanInputTree",
                       setupAuxBranch( br, auxName, kFALSE ) );
      }
 
      // Okay, the input was successfully scanned:
      m_inputScanned = kTRUE;
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

selectAux()

void xAOD::TAuxStore::selectAux ( const std::set< std::string > &  attributes )

virtual

Select dynamic auxiliary attributes for writing.

Definition at line 796 of file TAuxStore.cxx.

                                                                    {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      m_selection.selectAux( attributes );
      return;
   }

setBasketSize()

void xAOD::TAuxStore::setBasketSize

(

Int_t

value

)

Set the size of the baskets created for the output branches.

Definition at line 144 of file TAuxStore.cxx.

                                              {
 
      m_basketSize = value;
      return;
   }

setOption()

virtual bool SG::IAuxStore::setOption ( auxid_t  , const AuxDataOption &    )

inlinevirtualinherited

Set an option for a given auxiliary variable.

Parameters

auxid	The identifier of the desired aux data item.
option	The option to set.

The interpretation of the option depends on the particular representation of the variable.

Returns true if the option setting was successful; false otherwise.

Reimplemented in xAOD::AuxContainerBase, xAOD::AuxInfoBase, and SG::AuxStoreInternal.

Definition at line 176 of file IAuxStore.h.

  { return false; }

setPrefix()

void xAOD::TAuxStore::setPrefix

(

const char *

prefix

)

Set the branch name prefix.

Definition at line 119 of file TAuxStore.cxx.

                                                 {
 
      m_prefix = prefix;
      m_dynPrefix = Utils::dynBranchPrefix( prefix );
      reset();
      return;
   }

setSplitLevel()

void xAOD::TAuxStore::setSplitLevel

(

Int_t

value

)

Set the split level of the output branches.

Definition at line 155 of file TAuxStore.cxx.

                                              {
 
      m_splitLevel = value;
      return;
   }

setStructMode()

StatusCode xAOD::TAuxStore::setStructMode

(

EStructMode

mode

)

Set the structure mode of the object to a new value.

This function should be used with great care.

It makes it possible for the TEvent code to set the type of the object once the type is known. But user code should probably not fiddle with this function.

Parameters

mode	The structure mode to set

Returns

The usual StatusCode values

Definition at line 99 of file TAuxStore.cxx.

                                                         {
 
      // Only allow this on an uninitialised object:
      if( m_branches.size() || ( m_structMode != kUndefinedStore ) ) {
         ::Error( "xAOD::TAuxStore::setStructMode",
                  XAOD_MESSAGE( "Trying to change the structure mode of an "
                                "initialised object" ) );
         return StatusCode::FAILURE;
      }
 
      // Make the change:
      m_structMode = mode;
      return StatusCode::SUCCESS;
   }

setTopStore()

void xAOD::TAuxStore::setTopStore

(

Bool_t

value = kTRUE

)

Set whether the object should behave as a "top store" or not.

Definition at line 132 of file TAuxStore.cxx.

                                             {
 
      m_topStore = value;
      reset();
      return;
   }

setupAuxBranch()

StatusCode xAOD::TAuxStore::setupAuxBranch ( ::TBranch *  br, const char *  auxName, ::Bool_t  staticBranch  )

private

Register one input branch as an available auxiliary variable.

This function takes care of assigning an auxiliary ID to a given branch.

It tries its best to find an auxiliary vector factory for the branch's type, but if it fails, it still falls back to using SG::AuxTypePlaceholder as the type. In which case of course only dumb copying will be possible for the given branch. (And no vector operations on the branch's payload until the variable of the branch is accessed explicitly.)

Parameters

br	Pointer to the branch under investigation
auxName	The name of the auxiliary property, extracted from the branch's name
staticBranch	kTRUE if this is a "static branch", and kFALSE if it's a dynamic one

Returns

kTRUE if successful, kFALSE if not

Definition at line 1469 of file TAuxStore.cxx.

                                                                {
 
      // Get the branch's type:
      ::TClass* expectedClass = 0;
      ::EDataType expectedType = kOther_t;
      if( br->GetExpectedType( expectedClass, expectedType ) &&
          ( ( ! staticBranch ) || ( strncmp( auxName, "m_", 2 ) != 0 ) ) ) {
         ::Warning( "xAOD::TAuxStore::setupAuxBranch",
                    "Couldn't get the type of branch \"%s\"",
                    br->GetName() );
      }
 
      // Check for schema evolution:
      // If a branch has automatic schema evolution from one class to another,
      // then what we get from GetExpectedType will be the on-disk class.
      // What we have in memory is given by GetCurrentClass.
      if (expectedClass) {
        if (TBranchElement* bre = dynamic_cast<TBranchElement*> (br)) {
          TClass* newClass = bre->GetCurrentClass();
          if (newClass && newClass != expectedClass) {
            expectedClass = newClass;
          }
        }
      }
 
      // If this is a primitive variable, and we're still not sure whether this
      // is a store for an object or a container, the answer is given...
      if( ( ! expectedClass ) &&
          ( m_structMode == kUndefinedStore ) ) {
         m_structMode = kObjectStore;
      }
 
      // Get the type_info of the branch:
      const std::type_info* ti = 0;
      if( m_structMode == kObjectStore ) {
         if( expectedClass ) {
            ti = expectedClass->GetTypeInfo();
         } else {
            ti = &( Utils::getTypeInfo( expectedType ) );
         }
      } else {
         if( ! expectedClass ) {
            if( ( ! staticBranch ) || ( strncmp( auxName, "m_", 2 ) != 0 ) ) {
               ::Warning( "xAOD::TAuxStore::setupAuxBranch",
                          "Couldn't get the type of branch \"%s\"",
                          br->GetName() );
            }
         } else {
            ::TVirtualCollectionProxy* prox =
               expectedClass->GetCollectionProxy();
 
           if (!prox) {
             TClass* cl2 = lookupVectorType (expectedClass);
             if (cl2)
               prox = cl2->GetCollectionProxy();
           }
 
           if( ! prox ) {
               if( ( ! staticBranch ) ||
                   ( strncmp( auxName, "m_", 2 ) != 0 ) ) {
                  ::Warning( "xAOD::TAuxStore::setupAuxBranch",
                             "Couldn't get the type of branch \"%s\"",
                             br->GetName() );
               }
            } else {
               if( prox->GetValueClass() ) {
                  ti = prox->GetValueClass()->GetTypeInfo();
               } else {
                  ti = &( Utils::getTypeInfo( prox->GetType() ) );
               }
            }
         }
      }
 
      // Get the registry:
      SG::AuxTypeRegistry& registry = SG::AuxTypeRegistry::instance();
 
      // Check if the registry already knows this variable name. If yes, let's
      // use the type known by the registry. To be able to deal with simple
      // schema evolution in dynamic branches.
      const auxid_t regAuxid = registry.findAuxID( auxName );
      if( regAuxid != SG::null_auxid ) {
         m_auxIDs.insert( regAuxid );
         return StatusCode::SUCCESS;
      }
 
      // If we didn't find a type_info for the branch, give up now...
      if( ! ti ) {
         return StatusCode::SUCCESS;
      }
 
      // Check for an auxiliary ID for this branch:
      auxid_t auxid = registry.getAuxID( *ti, auxName, "",
                                         SG::AuxVarFlags::SkipNameCheck );
 
      // First try to find a compiled factory for the vector type:
      if( auxid == SG::null_auxid ) {
 
         // Construct the name of the factory's class:
         // But be careful --- if we don't exactly match the name
         // in TClassTable, then we may trigger autoparsing.  Besides the
         // resource usage that implies, that can lead to crashes in dbg
         // builds due to cling bugs.
         std::string tn = Utils::getTypeName( *ti );
         if (tn.starts_with("std::vector<"))
           tn.erase (0, 5);
         std::string fac_class_name = "SG::AuxTypeVectorFactory<" +
             tn + ",allocator<" + tn;
         if( fac_class_name[ fac_class_name.size() - 1 ] == '>' ) {
            fac_class_name += ' ';
         }
         fac_class_name += "> >";
 
         // Look for the dictionary of this type:
         ::TClass* fac_class = TClass::GetClass( fac_class_name.c_str() );
         if( fac_class && fac_class->IsLoaded() ) {
            ::TClass* base_class =
               ::TClass::GetClass( "SG::IAuxTypeVectorFactory" );
            if( base_class && base_class->IsLoaded() ) {
               const Int_t offs = fac_class->GetBaseClassOffset( base_class );
               if( offs >= 0 ) {
                  void* fac_vp = fac_class->New();
                  if( fac_vp ) {
                     unsigned long tmp =
                        reinterpret_cast< unsigned long >( fac_vp ) + offs;
                     SG::IAuxTypeVectorFactory* fac =
                        reinterpret_cast< SG::IAuxTypeVectorFactory* >( tmp );
                     registry.addFactory( *ti, *fac->tiAlloc(), std::unique_ptr<SG::IAuxTypeVectorFactory>( fac ) );
                     auxid = registry.getAuxID( *ti, auxName, "",
                                                SG::AuxVarFlags::SkipNameCheck );
                  }
               }
            }
         }
      }
 
      // If that didn't succeed, let's assign a generic factory to this type:
      if( auxid == SG::null_auxid ) {
 
         // Construct the name of the vector type:
         std::string vec_class_name = "std::vector<" +
            Utils::getTypeName( *ti );
         if( vec_class_name[ vec_class_name.size() - 1 ] == '>' ) {
            vec_class_name += ' ';
         }
         vec_class_name += '>';
 
         // Get the dictionary for the type:
         ::TClass* vec_class = ::TClass::GetClass( vec_class_name.c_str() );
         if( vec_class && vec_class->IsLoaded() ) {
            auto fac = std::make_unique<TAuxVectorFactory>( vec_class );
            if (fac->tiAlloc()) {
              const std::type_info* tiAlloc = fac->tiAlloc();
              registry.addFactory( *ti, *tiAlloc, std::move( fac ) );
            }
            else {
              std::string tiAllocName = fac->tiAllocName();
              registry.addFactory( *ti, tiAllocName, std::move( fac ) );
            }
            auxid = registry.getAuxID( *ti, auxName, "",
                                       SG::AuxVarFlags::SkipNameCheck );
         } else {
            ::Warning( "xAOD::TAuxStore::setupAuxBranch",
                       "Couldn't find dictionary for type: %s",
                       vec_class_name.c_str() );
         }
      }
 
      // Check if we succeeded:
      if( auxid == SG::null_auxid ) {
         ::Error( "xAOD::TAuxStore::setupAuxBranch",
                  XAOD_MESSAGE( "Couldn't assign auxiliary ID to branch "
                                "\"%s\"" ),
                  br->GetName() );
         return StatusCode::FAILURE;
      }
 
      // Remember the auxiliary ID:
      m_auxIDs.insert( auxid );
      return StatusCode::SUCCESS;
   }

setupInputData()

StatusCode xAOD::TAuxStore::setupInputData ( auxid_t  auxid )

private

Connect a variable to the input tree.

This internal function takes care of connecting to an individual (sub-)branch in the input file for a given auxiliary variable.

It needs to handle a number of different use cases, so it's a bit long.

Parameters

auxid

The ID of the variable to connect to

Returns

kTRUE if the operation was successful, kFALSE if not

Definition at line 852 of file TAuxStore.cxx.

                                                       {
 
      // Return right away if we already know that the branch is missing:
      if( ( auxid < m_missingBranches.size() ) && m_missingBranches[ auxid ] ) {
         return StatusCode::RECOVERABLE;
      }
 
      // Make sure the internal storage is large enough:
      if( m_vecs.size() <= auxid ) {
         m_vecs.resize( auxid + 1 );
      }
      if( m_branches.size() <= auxid ) {
         m_branches.resize( auxid + 1 );
      }
 
      // Check if we need to do anything:
      if( m_vecs[ auxid ] && m_branches[ auxid ] ) {
         return StatusCode::SUCCESS;
      }
 
      // A little sanity check:
      if( ! m_inTree ) {
         ::Error( "xAOD::TAuxStore::setupInputData",
                  XAOD_MESSAGE( "No input TTree set up!" ) );
         return StatusCode::FAILURE;
      }
 
      // Another sanity check:
      if( m_vecs[ auxid ] || m_branches[ auxid ] ) {
         ::Error( "xAOD::TAuxStore::setupInputData",
                  XAOD_MESSAGE( "The internal variables of the object got "
                                "messed up?!?" ) );
         return StatusCode::FAILURE;
      }
 
      // Get the property name:
      const TString statBrName = m_prefix +
         SG::AuxTypeRegistry::instance().getName( auxid ).c_str();
      const TString dynBrName = m_dynPrefix +
         SG::AuxTypeRegistry::instance().getName( auxid ).c_str();
 
      // Check if the branch exists:
      Bool_t staticBranch = kTRUE;
      TString brName = statBrName;
 
      TBranch* br = m_inTree->GetBranch( statBrName );
      if( ! br ) {
         br = m_inTree->GetBranch( dynBrName );
         if( ! br ) {
            // Since TTree::GetBranch / TTObjArray::FindObject is expensive,
            // remember that we didn't find this branch in this file.
            if( m_missingBranches.size() <= auxid ) {
               m_missingBranches.resize( auxid + 1 );
            }
            m_missingBranches[ auxid ] = true;
            // The branch doesn't exist, but this is not an error per se.
            // The user may just be calling isAvailable(...) on the variable.
            return StatusCode::RECOVERABLE;
         }
         // We have a dynamic branch:
         staticBranch = kFALSE;
         brName = dynBrName;
      }
 
      // Check if it's a "primitive branch":
      const Bool_t primitiveBranch = isPrimitiveBranch( br );
      // Check if it's a "container branch":
      const Bool_t containerBranch =
         ( primitiveBranch ? kFALSE : isContainerBranch( br, auxid ) );
 
      // Set the structure mode if it has not been defined externally:
      if( m_structMode == kUndefinedStore ) {
         m_structMode = ( containerBranch ? kContainerStore : kObjectStore );
      }
 
      // Check that the branch type makes sense:
      if( ( containerBranch && ( m_structMode != kContainerStore ) ) ||
          ( ( ! containerBranch ) && ( m_structMode != kObjectStore ) ) ) {
         ::Error( "xAOD::TAuxStore::setupInputData",
                  XAOD_MESSAGE( "Branch type and requested structure mode "
                                "differ for branch: %s" ),
                  brName.Data() );
         return StatusCode::FAILURE;
      }
 
      // Check what variable it is:
      ::TClass* clDummy = 0;
      ::EDataType dType = kOther_t;
      if( br->GetExpectedType( clDummy, dType ) ) {
         ::Error( "xAOD::TAuxStore::setupInputData",
                  XAOD_MESSAGE( "Couldn't determine the type of branch "
                                "\"%s\"" ), brName.Data() );
         return StatusCode::FAILURE;
      }
 
      // Get the property type:
      const std::type_info* brType = 0;
      if( isRegisteredType( auxid ) ) {
         // Get the type from the auxiliary type registry:
         brType =
            ( containerBranch ?
              SG::AuxTypeRegistry::instance().getVecType( auxid ) :
              SG::AuxTypeRegistry::instance().getType( auxid ) );
      } else {
         // Get the type from the input branch itself:
         brType = ( clDummy ? clDummy->GetTypeInfo() :
                    &( Utils::getTypeInfo( dType ) ) );
      }
      if( ! brType ) {
         ::Error( "xAOD::TAuxStore::setupInputData",
                  XAOD_MESSAGE( "Can't read/copy variable %s (%s)" ),
                  brName.Data(), clDummy->GetName() );
         return StatusCode::RECOVERABLE;
      }
      const TString brTypeName = Utils::getTypeName( *brType ).c_str();
 
      // Check if we have the needed dictionary for an object branch:
      ::TClass* brClass = 0;
      if( ! primitiveBranch ) {
         // Get the property's class:
         brClass = ::TClass::GetClass( *brType, kTRUE, kTRUE );
         if( ! brClass ) {
            brClass = ::TClass::GetClass( brTypeName );
         }
         if( ! brClass ) {
            ::Error( "xAOD::TAuxStore::setupInputData",
                     XAOD_MESSAGE( "No dictionary available for class \"%s\"" ),
                     brTypeName.Data() );
            return StatusCode::FAILURE;
         }
      }
 
      // Create the smart object holding this vector:
      if( isRegisteredType( auxid ) ) {
         m_vecs[ auxid ] =
            SG::AuxTypeRegistry::instance().makeVector( auxid, (size_t)0, (size_t)0 ).release();
         if( ! containerBranch ) {
            m_vecs[ auxid ]->resize( 1 );
         }
         if (clDummy && strncmp (clDummy->GetName(), "SG::PackedContainer<", 20) == 0) {
           SG::IAuxTypeVector* packed = m_vecs[ auxid ]->toPacked().release();
           std::swap (m_vecs[ auxid ], packed);
           delete packed;
         }
      } else {
         ::Error( "xAOD::TAuxStore::setupInputData",
                  XAOD_MESSAGE( "Couldn't create in-memory vector for "
                                "variable %s (%i)" ),
                  brName.Data(),
                  static_cast< int >( auxid ) );
         return StatusCode::FAILURE;
      }
 
      // Create a new branch handle:
      const std::type_info* objType = brType;
      if (containerBranch) {
        objType = m_vecs[ auxid ]->objType();
        if (!objType)
          objType = SG::AuxTypeRegistry::instance().getType( auxid );
      }
      m_branches[ auxid ] = new TBranchHandle( staticBranch, primitiveBranch,
                                               objType,
                                               ( containerBranch ?
                                                 m_vecs[ auxid ]->toVector() :
                                                 m_vecs[ auxid ]->toPtr() ),
                                               auxid, &m_prefix );
 
      // Set the tree/branch in the "right mode":
      if( staticBranch ) {
         br->SetMakeClass();
      }
 
      // Connect to the branch:
      ::Int_t status = 0;
      if( clDummy &&
          ::TString( clDummy->GetName() ).Contains( "basic_string<char>" ) ) {
         // This is pretty much just a hack. As it happens, Athena I/O can
         // create dynamic branches that consider themselves to be of type
         // "vector<basic_string<char> >" and similar. (Instead of the
         // canonical "vector<string>" name.) When we encounter such a branch,
         // we just connect to it without performing any compatibility checks.
         // Since we don't need to apply any read rules in this case anyway.
         status =
            m_inTree->SetBranchAddress( brName,
                                        m_branches[ auxid ]->inputObjectPtr(),
                                        m_branches[ auxid ]->branchPtr() );
      } else {
         status =
            m_inTree->SetBranchAddress( brName,
                                        m_branches[ auxid ]->inputObjectPtr(),
                                        m_branches[ auxid ]->branchPtr(),
                                        brClass, dType,
                                        ( ( ! staticBranch ) &&
                                          ( ! primitiveBranch ) ) );
      }
      if( status < 0 ) {
         ::Error( "xAOD::TAuxStore::setupInputData",
                  XAOD_MESSAGE( "Coulnd't connect to branch \"%s\"" ),
                  brName.Data() );
         ::Error( "xAOD::TAuxStore::setupInputData",
                  XAOD_MESSAGE( "Return code: %i" ), status );
         delete m_vecs[ auxid ];
         m_vecs[ auxid ] = 0;
         delete m_branches[ auxid ];
         m_branches[ auxid ] = 0;
         return StatusCode::FAILURE;
      }
 
      // Get the current entry:
      m_branches[ auxid ]->getEntry();
 
      // Remember which variable got created:
      m_auxIDs.insert( auxid );
 
      // Check if we just replaced a generic object:
      if( isRegisteredType( auxid ) ) {
         // The name of the variable we just created:
         const std::string auxname =
            SG::AuxTypeRegistry::instance().getName( auxid );
         // Check if there's another variable with this name already:
         for( auxid_t i = 0; i < m_vecs.size(); ++i ) {
            // Check if we have this aux ID:
            if( ! m_vecs[ i ] ) continue;
            // Ingore the object that we *just* created:
            if( i == auxid ) continue;
            // The name of the variable:
            const std::string testname =
               SG::AuxTypeRegistry::instance().getName( i );
            // Check if it has the same name:
            if( testname != auxname ) continue;
            // Check that the other one is a non-registered type:
            if( isRegisteredType( i ) ) {
               ::Error( "xAOD::TAuxStore::setupInputData",
                        XAOD_MESSAGE( "Internal logic error!" ) );
               continue;
            }
            // Okay, we do need to remove this object:
            delete m_vecs[ i ]; delete m_branches[ i ];
            m_vecs[ i ] = 0; m_branches[ i ] = 0;
            m_auxIDs.erase( i );
         }
      }
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

setupOutputData()

StatusCode xAOD::TAuxStore::setupOutputData ( auxid_t  auxid )

private

Connect a variable to the output tree.

This function is used internally to create a "simple" output branch with the contents of a single auxiliary variable.

Parameters

auxid

The ID of the variable to create an output branch for

Returns

kTRUE if the operation was successful, kFALSE if not

Definition at line 1106 of file TAuxStore.cxx.

                                                        {
 
      // Check whether we need to do anything:
      if( ! m_outTree ) return StatusCode::SUCCESS;
 
      // Check if the variable needs to be written out:
      if( ! isAuxIDSelected( auxid ) ) return StatusCode::SUCCESS;
 
      // Make sure that containers are large enough:
      if( m_vecs.size() <= auxid ) {
         m_vecs.resize( auxid + 1 );
      }
      if( m_branches.size() <= auxid ) {
         m_branches.resize( auxid + 1 );
      }
      if( m_branchesWritten.size() <= auxid ) {
         m_branchesWritten.resize( auxid + 1 );
      }
 
      // Check if this auxiliary variable is already in the output:
      if( m_branchesWritten[ auxid ] ) return StatusCode::SUCCESS;
 
      // Check if the variable was put into the transient store as a
      // decoration, and now needs to be put into the output file:
      if( ( ! m_vecs[ auxid ] ) && m_transientStore &&
          ( m_transientStore->getAuxIDs().test( auxid ) ) ) {
 
         // Get the variable from the transient store:
         const void* pptr = m_transientStore->getData( auxid );
         if( ! pptr ) {
            ::Fatal( "xAOD::TAuxStore::setupOutputData",
                     XAOD_MESSAGE( "Internal logic error detected" ) );
            return StatusCode::FAILURE;
         }
 
         // The registry:
         SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
 
         // Create the new object:
         m_vecs[ auxid ] = reg.makeVector( auxid, m_size, m_size ).release();
         void* ptr = m_vecs[ auxid ]->toPtr();
         if( ! ptr ) {
            ::Error( "xAOD::TAuxStore::setupOutputData",
                     XAOD_MESSAGE( "Couldn't create decoration in memory "
                                   "for writing" ) );
            return StatusCode::FAILURE;
         }
 
         // Get the type of this variable:
         const std::type_info* type = reg.getType( auxid );
         if( ! type ) {
            ::Error( "xAOD::TAuxStore::setupOutputData",
                     XAOD_MESSAGE( "Couldn't get the type of transient "
                                   "variable %i" ),
                     static_cast< int >( auxid ) );
            return StatusCode::FAILURE;
         }
         // Now get the factory for this variable:
         const SG::IAuxTypeVectorFactory* factory =
            reg.getFactory( auxid );
         if( ! factory ) {
            ::Error( "xAOD::TAuxStore::setupOutputData",
                     XAOD_MESSAGE( "No factory found for transient variable "
                                   "%i" ), static_cast< int >( auxid ) );
            return StatusCode::FAILURE;
         }
 
         // Finally, do the copy:
         factory->copy( auxid,
                        SG::AuxVectorInterface( *this ), 0,
                        SG::AuxVectorInterface( *m_transientStore ), 0,
                        m_size );
 
         // And now remember that this is a decoration:
         if( m_isDecoration.size() <= auxid ) {
            m_isDecoration.resize( auxid + 1 );
         }
         m_isDecoration[ auxid ] = ::kTRUE;
      }
 
      // Check if we know about this variable to be on the input,
      // but haven't connected to it yet:
      if( ( m_auxIDs.test( auxid ) ) &&
          ( ! m_vecs[ auxid ] ) && ( ! m_branches[ auxid ] ) ) {
         RETURN_CHECK( "xAOD::TAuxStore::setupOutputData",
                       setupInputData( auxid ) );
      }
 
      // Check that we know the store's type:
      if( ( m_structMode != kContainerStore ) &&
          ( m_structMode != kObjectStore ) ) {
         ::Error( "xAOD::TAuxStore::setupOutputData",
                  XAOD_MESSAGE( "Structure mode unknown for variable %s" ),
                  SG::AuxTypeRegistry::instance().getName( auxid ).c_str() );
         return StatusCode::FAILURE;
      }
 
      // Check if the variable exists already in memory:
      if( ! m_vecs[ auxid ] ) {
         m_vecs[ auxid ] =
            SG::AuxTypeRegistry::instance().makeVector( auxid, (size_t)0, (size_t)0 ).release();
         if( m_structMode == kObjectStore ) {
            m_vecs[ auxid ]->resize( 1 );
         }
      }
 
      // Check if the branch handle exists already:
      if( ! m_branches[ auxid ] ) {
         // Get the property type:
         const std::type_info* brType =
            ( m_structMode == kContainerStore ?
              SG::AuxTypeRegistry::instance().getVecType( auxid ) :
              SG::AuxTypeRegistry::instance().getType( auxid ) );
         // Create the handle object:
         bool primitiveBranch = (strlen( brType->name() ) == 1);
         m_branches[ auxid ] =
            new TBranchHandle( kFALSE, ( strlen( brType->name() ) == 1 ),
                               (primitiveBranch ?
                                brType :
                                m_vecs[ auxid ]->objType() ),
                               ( m_structMode == kObjectStore ?
                                 m_vecs[ auxid ]->toPtr() :
                                 m_vecs[ auxid ]->toVector() ),
                               auxid, &m_prefix );
      }
 
      // Construct a name for the branch:
      const TString brName =
         m_dynPrefix + SG::AuxTypeRegistry::instance().getName( auxid );
 
      // If the output branch exists already, assume that it was us making
      // it:
      ::TBranch* br = m_outTree->GetBranch( brName );
      if( br ) {
         // Apparently a branch that was already set up for copying as a basic
         // variable, now got accessed explicitly. So let's update the output
         // branch to point to this new location now.
         br->SetAddress( m_branches[ auxid ]->outputObjectPtr() );
         // Update the cache. Notice that the "write status" of the typeless
         // auxiliary ID is not turned off. But it shouldn't matter, as the
         // variable will not be accessed in a typeless way anymore.
         m_branchesWritten[ auxid ] = true;
         // Return gracefully:
         return StatusCode::SUCCESS;
      }
 
      // Check that we know the type of the branch:
      const std::type_info* brType = m_branches[ auxid ]->typeInfo();
      if( ! brType ) {
         ::Error( "xAOD::TAuxStore::setupOutputData",
                  XAOD_MESSAGE( "There's an internal logic error in the "
                                "code" ) );
         return StatusCode::FAILURE;
      }
      const std::string brTypeName = Utils::getTypeName( *brType );
 
      // Decide if this is a primitive branch:
      const Bool_t primitiveBranch = ( strlen( brType->name() ) == 1 );
 
      // Let's create the branch now:
      if( primitiveBranch ) {
 
         // Get the "ROOT type" belonging to this primitive:
         const char rootType = Utils::rootType( brType->name()[ 0 ] );
         if( rootType == '\0' ) {
            ::Error( "xAOD::TAuxStore::setupOutputData",
                     XAOD_MESSAGE( "Type not known for variable \"%s\" "
                                   "of type \"%s\"" ),
                     brName.Data(), brTypeName.c_str() );
            return StatusCode::FAILURE;
         }
 
         // Construct the type description:
         std::ostringstream typeDesc;
         typeDesc << brName << "/" << rootType;
 
         // Create the branch:
         br = m_outTree->Branch( brName,
                                 m_branches[ auxid ]->outputObjectPtr(),
                                 typeDesc.str().c_str(), m_basketSize );
 
      } else {
 
         // Access the dictionary for the type:
         TClass* cl = TClass::GetClass( *brType );
         if( ! cl ) {
            cl = TClass::GetClass( brTypeName.c_str() );
         }
         if( ! cl ) {
            ::Error( "xAOD::TAuxStore::setupOutputData",
                     XAOD_MESSAGE( "Couldn't find dictionary for type: %s" ),
                     brTypeName.c_str() );
            return StatusCode::FAILURE;
         }
         if( ! cl->GetStreamerInfo() ) {
            ::Error( "xAOD::TAuxStore::setupOutputData",
                     XAOD_MESSAGE( "No streamer info available for type %s" ),
                     cl->GetName() );
            return StatusCode::FAILURE;
         }
 
         // Create the branch:
         br = m_outTree->Branch( brName, cl->GetName(),
                                 m_branches[ auxid ]->outputObjectPtr(),
                                 m_basketSize, m_splitLevel );
      }
 
      // Check if we succeeded:
      if( ! br ) {
         ::Error( "xAOD::TAuxStore::setupOutputData",
                  XAOD_MESSAGE( "Failed creating branch \"%s\" of type "
                                "\"%s\"" ),
                  brName.Data(), brTypeName.c_str() );
         return StatusCode::FAILURE;
      }
 
      // If this is not the first event, fill up the branch with dummy
      // info:
      for( Long64_t i = 0; i < m_outTree->GetEntries(); ++i ) {
         br->Fill();
      }
 
      // Update the cache:
      m_branchesWritten[ auxid ] = true;
 
      // Also, remember that we now handle this variable:
      m_auxIDs.insert( auxid );
 
      // We were successful:
      return StatusCode::SUCCESS;
   }

shift()

void xAOD::TAuxStore::shift ( size_t  pos, ptrdiff_t  offs  )

overridevirtual

Shift the contents of the stored arrays.

Implements SG::IAuxStore.

Definition at line 618 of file TAuxStore.cxx.

                                                     {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // A sanity check:
      if( m_structMode == kObjectStore ) {
         ::Error( "xAOD::TAuxStore::shift",
                  XAOD_MESSAGE( "Should not have been called for single-object "
                                "store" ) );
         return;
      }
 
      // Adjust the size of the container:
      if( ( static_cast< std::size_t >( std::abs( offs ) ) > m_size ) &&
          ( offs < 0 ) ) {
         m_size = 0;
      } else {
         m_size += offs;
      }
 
      std::vector< SG::IAuxTypeVector* >::iterator itr = m_vecs.begin();
      std::vector< SG::IAuxTypeVector* >::iterator end = m_vecs.end();
      for( ; itr != end; ++itr ) {
         if( *itr ) ( *itr )->shift( pos, offs );
      }
      if( m_transientStore ) {
         m_transientStore->shift( pos, offs );
      }
 
      return;
   }

size()

size_t xAOD::TAuxStore::size ( ) const

overridevirtual

Return the number of elements in the store.

Implements SG::IConstAuxStore.

Definition at line 463 of file TAuxStore.cxx.

                                {
 
      // First, try to find a managed vector in the store:
      for( SG::auxid_t id : m_auxIDs) {
         // Make sure that we are still within the bounds of our vector:
         if( id >= m_vecs.size() ) break;
         // Skip non-existent objects:
         if( ! m_vecs[ id ] ) continue;
         // Ask the vector for its size:
         const size_t size = m_vecs[ id ]->size();
         // Only accept a non-zero size. Not sure why...
         if( size > 0 ) {
            return size;
         }
      }
 
      // Check if we have a transient store, and get the size from that:
      if( m_transientStore ) {
         return m_transientStore->size();
      }
 
      // Apparently the store is empty:
      return 0;
   }

splitLevel()

Int_t xAOD::TAuxStore::splitLevel

(

)

const

Get the split level of the output branches.

Definition at line 150 of file TAuxStore.cxx.

                                     {
 
      return m_splitLevel;
   }

structMode()

TAuxStore::EStructMode xAOD::TAuxStore::structMode

(

)

const

Get what structure mode the object was constructed with.

Definition at line 87 of file TAuxStore.cxx.

                                                    {
 
      return m_structMode;
   }

writeTo()

StatusCode xAOD::TAuxStore::writeTo

(

::TTree *

tree

)

Connect the object to an output TTree.

This function is called by the infrastructure to connect the object to an output TTree.

Parameters

tree	Pointer to the TTree that is being written to

Definition at line 208 of file TAuxStore.cxx.

                                              {
 
      // Look for any auxiliary branches that have not been connected to yet:
      RETURN_CHECK( "xAOD::TAuxStore::writeTo", scanInputTree() );
 
      // Store the TTree pointer:
      m_outTree = tree;
 
      // Create all the variables that we already know about. Notice that the
      // code makes a copy of the auxid set on purpose. Because the underlying
      // AuxSelection object gets modified while doing the for loop.
      const auxid_set_t selAuxIDs = getSelectedAuxIDs();
      for (SG::auxid_t id : selAuxIDs) {
         RETURN_CHECK( "xAOD::TAuxStore::writeTo", setupOutputData( id ) );
      }
 
      return StatusCode::SUCCESS;
   }

Friends And Related Function Documentation

TEvent

friend class TEvent

friend

Make TEvent a friend of this class.

Definition at line 49 of file TAuxStore.h.

Member Data Documentation

m_auxIDs

auxid_set_t xAOD::TAuxStore::m_auxIDs

private

Internal list of variable IDs handled currently by the object.

Definition at line 230 of file TAuxStore.h.

m_basketSize

::Int_t xAOD::TAuxStore::m_basketSize

private

The basket size for the output branches.

Definition at line 212 of file TAuxStore.h.

m_branches

std::vector< TBranchHandle* > xAOD::TAuxStore::m_branches

private

Branches reading the various auxiliary variables.

Definition at line 299 of file TAuxStore.h.

m_branchesWritten

std::vector< bool > xAOD::TAuxStore::m_branchesWritten

private

"Write status" of the different variables

Definition at line 301 of file TAuxStore.h.

m_dynPrefix

std::string xAOD::TAuxStore::m_dynPrefix

private

Dynamic prefix for the branch names.

Definition at line 204 of file TAuxStore.h.

m_inputScanned

::Bool_t xAOD::TAuxStore::m_inputScanned

private

"Scan status" of the input TTree

Definition at line 222 of file TAuxStore.h.

m_inTree

::TTree* xAOD::TAuxStore::m_inTree

private

The TTree being read from.

Definition at line 217 of file TAuxStore.h.

m_isDecoration

std::vector< ::Bool_t > xAOD::TAuxStore::m_isDecoration

private

Flags items as decorations.

Definition at line 239 of file TAuxStore.h.

m_locked

::Bool_t xAOD::TAuxStore::m_locked

private

Is this container locked?

Definition at line 237 of file TAuxStore.h.

m_missingBranches

std::vector< bool > xAOD::TAuxStore::m_missingBranches

private

Mark branches we've found to be missing.

(Because TTree::GetBranch is very expensive.)

Definition at line 304 of file TAuxStore.h.

m_mutex1

mutex_t xAOD::TAuxStore::m_mutex1

mutableprivate

Mutexes object used for multithreaded synchronisation.

Definition at line 246 of file TAuxStore.h.

m_mutex2

mutex_t xAOD::TAuxStore::m_mutex2

private

Definition at line 246 of file TAuxStore.h.

m_outTree

::TTree* xAOD::TAuxStore::m_outTree

private

The TTree being written to.

Definition at line 219 of file TAuxStore.h.

m_prefix

std::string xAOD::TAuxStore::m_prefix

private

Static prefix for the branch names.

Definition at line 202 of file TAuxStore.h.

m_selection

AuxSelection xAOD::TAuxStore::m_selection

private

Object helping to select which auxiliary variables to write.

Definition at line 225 of file TAuxStore.h.

m_size

std::size_t xAOD::TAuxStore::m_size

private

The current size of the container being described.

Definition at line 234 of file TAuxStore.h.

m_splitLevel

::Int_t xAOD::TAuxStore::m_splitLevel

private

The split level for the output branches.

Definition at line 214 of file TAuxStore.h.

m_structMode

EStructMode xAOD::TAuxStore::m_structMode

private

The "structural" mode of the object.

Definition at line 210 of file TAuxStore.h.

m_topStore

::Bool_t xAOD::TAuxStore::m_topStore

private

Flag stating whether this is a "top store".

Definition at line 207 of file TAuxStore.h.

m_transientStore

SG::AuxStoreInternal* xAOD::TAuxStore::m_transientStore

private

Store for the in-memory-only variables.

Definition at line 227 of file TAuxStore.h.

m_vecs

std::vector< SG::IAuxTypeVector* > xAOD::TAuxStore::m_vecs

private

Variables handled currently by the object.

Definition at line 232 of file TAuxStore.h.

supportsThinning

constexpr bool SG::IAuxStore::supportsThinning = true

staticconstexprinherited

Mark that this type supports thinning operations.

See AthContainers/supportsThinning.h and AthenaPoolCnvSvc/T_AthenaPoolCnv.h. Helps guide which pool converter template will be used. If false, the default pool converter will be used rather than the aux store-specific one. Ordinary xAOD type should not touch this, but may be overridden in a derived class to handle certain special cases.

Definition at line 189 of file IAuxStore.h.

---

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

• TAuxStore.h
• TAuxStore.cxx