Auxiliary information about the event. More...

#include <EventAuxInfo_v3.h>

Inheritance diagram for xAOD::EventAuxInfo_v3:

Collaboration diagram for xAOD::EventAuxInfo_v3:

Public Types
typedef SG::auxid_t	auxid_t
	The aux ID type definition.
typedef SG::auxid_set_t	auxid_set_t
	The aux ID set type definition.
template<class T, class ALLOC = std::allocator<T>>
using	AuxVariable_t = T
	Declare how to wrap variables for this sort of base.
template<class T, class ALLOC = std::allocator<T>>
using	LinkedVariable_t = std::vector<T, ALLOC>
enum	AuxStoreType { AST_ObjectStore = 0 , AST_ContainerStore = 1 }
	Type of the auxiliary store. More...

Public Member Functions
	EventAuxInfo_v3 ()
	Default constructor.
virtual void *	getDecoration (SG::auxid_t auxid, size_t size, size_t capacity) override
	Return the data vector for one aux data decoration item.
virtual bool	isDecoration (auxid_t auxid) const override
	Test if a particular variable is tagged as a decoration.
virtual void	lockDecoration (SG::auxid_t auxid) override
	Lock a decoration.
void	toTransient ()
	Called after one of these objects is read.
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.
template<typename T>
auxid_t	getAuxID (const std::string &name, T &, SG::AuxVarFlags flags=SG::AuxVarFlags::None, const SG::auxid_t linkedVariable=SG::null_auxid)
	Get the auxiliary ID for one of the persistent variables.
template<typename T>
void	regAuxVar (auxid_t auxid, const std::string &name, T &info)
	Register one of the persistent variables internally.
Functions implementing the SG::IAuxStoreHolder interface
virtual SG::IAuxStore *	getStore () override
	Get the currently used internal store object.
virtual const SG::IAuxStore *	getStore () const override
	Get the currently used internal store object.
virtual void	setStore (SG::IAuxStore *store) override
	Set a different internal store object.
virtual AuxStoreType	getStoreType () const override
	Return the type of the store object.
Functions implementing the SG::IConstAuxStore interface
virtual const void *	getData (auxid_t auxid) const override
	Get a pointer to a given array.
virtual const SG::IAuxTypeVector *	getVector (SG::auxid_t auxid) const override final
	Return vector interface for one aux data item.
virtual const auxid_set_t &	getAuxIDs () const override
	Get the types(names) of variables handled by this container.
virtual const auxid_set_t &	getDecorIDs () const override
	Get the types(names) of decorations handled by this container.
virtual void	lock () override
	Lock the container.
virtual bool	clearDecorations () override
	Clear all decorations.
virtual size_t	size () const override
	Get the size of the container.
virtual const SG::IAuxTypeVector *	linkedVector (SG::auxid_t auxid) const override
	Return interface for a linked variable.
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.
virtual SG::IAuxTypeVector *	linkedVector (SG::auxid_t auxid) override
	Return interface for a linked variable.
virtual const auxid_set_t &	getWritableAuxIDs () const override
	Return a set of writable data identifiers.
virtual bool	resize (size_t size) override
	Resize the arrays to a given size.
virtual void	reserve (size_t size) override
	Reserve a given size for the arrays.
virtual void	shift (size_t pos, ptrdiff_t offs) override
	Shift the contents of the stored arrays.
virtual bool	insertMove (size_t pos, IAuxStore &other, const SG::auxid_set_t &ignore) override
	Insert contents of another store via move.
virtual bool	setOption (auxid_t id, const SG::AuxDataOption &option) override
	Make an option setting on an aux variable.
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.
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.
virtual const auxid_set_t &	getDynamicAuxIDs () const override
	Get the types(names) of variables created dynamically.
virtual SG::auxid_set_t	getSelectedAuxIDs () const override
	Get the IDs of the selected dynamic Aux variables (for writing)
Functions managing the instance name of the container
const char *	name () const
	Get the name of the container instance.
void	setName (const char *name)
	Set the name of the container instance.

Public Attributes
CxxUtils::ConcurrentBitset	m_decorFlags
	Keep track of the event status flags.
Basic event information
uint32_t	runNumber
uint64_t	eventNumber
uint32_t	lumiBlock
uint32_t	timeStamp
uint32_t	timeStampNSOffset
uint32_t	bcid
uint32_t	detectorMask0
uint32_t	detectorMask1
uint32_t	detectorMask2
uint32_t	detectorMask3
Event type information
std::vector< std::pair< std::string, std::string > >	detDescrTags
uint32_t	eventTypeBitmask
Trigger related information
uint32_t	statusElement
uint32_t	extendedLevel1ID
uint16_t	level1TriggerType
std::vector< std::string >	streamTagNames
std::vector< std::string >	streamTagTypes
std::vector< char >	streamTagObeysLumiblock
Detector flags
uint32_t	pixelFlags
uint32_t	sctFlags
uint32_t	trtFlags
uint32_t	larFlags
uint32_t	tileFlags
uint32_t	muonFlags
uint32_t	forwardDetFlags
uint32_t	coreFlags
uint32_t	backgroundFlags
uint32_t	lumiFlags

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

Private Types
typedef AthContainers_detail::mutex	mutex_t
	Mutex for multithread synchronization.
typedef AthContainers_detail::lock_guard< mutex_t >	guard_t

Private Attributes
auxid_set_t	m_auxids
	Internal list of all available variables.
std::vector< SG::IAuxTypeVector * >	m_vecs
	Internal list of all managed variables.
SG::IAuxStore *	m_store
	Internal dynamic auxiliary store object.
SG::IAuxStoreIO *	m_storeIO
	The IO interface to the internal auxiliary store.
bool	m_ownsStore
	Flag deciding if the object owns the dynamic store or not.
bool	m_locked
	Has the container been locked?
mutex_t	m_mutex
std::string	m_name
	Name of the container in memory. Set externally.

Detailed Description

Auxiliary information about the event.

This object describes the "static" auxiliary information about an event.

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 28 of file EventAuxInfo_v3.h.

Member Typedef Documentation

◆ auxid_set_t

typedef SG::auxid_set_t xAOD::AuxInfoBase::auxid_set_t

inherited

The aux ID set type definition.

Definition at line 51 of file AuxInfoBase.h.

◆ auxid_t

typedef SG::auxid_t xAOD::AuxInfoBase::auxid_t

inherited

The aux ID type definition.

Definition at line 49 of file AuxInfoBase.h.

◆ AuxVariable_t

template<class T, class ALLOC = std::allocator<T>>

using xAOD::AuxInfoBase::AuxVariable_t = T

inherited

Declare how to wrap variables for this sort of base.

Definition at line 175 of file AuxInfoBase.h.

◆ guard_t

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

privateinherited

Definition at line 208 of file AuxInfoBase.h.

◆ LinkedVariable_t

template<class T, class ALLOC = std::allocator<T>>

using xAOD::AuxInfoBase::LinkedVariable_t = std::vector<T, ALLOC>

inherited

Definition at line 177 of file AuxInfoBase.h.

◆ mutex_t

typedef AthContainers_detail::mutex xAOD::AuxInfoBase::mutex_t

privateinherited

Mutex for multithread synchronization.

Definition at line 207 of file AuxInfoBase.h.

Member Enumeration Documentation

◆ AuxStoreType

enum SG::IAuxStoreHolder::AuxStoreType

inherited

Type of the auxiliary store.

In the xAOD EDM we use auxiliary store objects in some cases to describe a single object, and in most cases to describe a container of objects. This enumeration declares which type the object implementing this interface is.

Enumerator
AST_ObjectStore	The store describes a single object.
AST_ContainerStore	The store describes a container.

Definition at line 66 of file IAuxStoreHolder.h.

                        {
         AST_ObjectStore    = 0, 
         AST_ContainerStore = 1  
      };

Constructor & Destructor Documentation

◆ EventAuxInfo_v3()

xAOD::EventAuxInfo_v3::EventAuxInfo_v3 ( )

Default constructor.

Definition at line 10 of file EventAuxInfo_v3.cxx.

     : AuxInfoBase(),
       runNumber(0),
       eventNumber(0),
       lumiBlock(0),
       timeStamp(0),
       timeStampNSOffset(0),
       bcid(0),
       detectorMask0(0),
       detectorMask1(0),
       detectorMask2(0),
       detectorMask3(0),
       eventTypeBitmask(0),
       statusElement(0),
       extendedLevel1ID(0),
       level1TriggerType(0),
       pixelFlags(0),
       sctFlags(0),
       trtFlags(0),
       larFlags(0),
       tileFlags(0),
       muonFlags(0),
       forwardDetFlags(0),
       coreFlags(0),
       backgroundFlags(0),
       lumiFlags(0),
       m_decorFlags (SG::auxid_set_size_hint)
   {
 
      // Basic event information:
      AUX_VARIABLE( runNumber );
      AUX_VARIABLE( eventNumber );
      AUX_VARIABLE( lumiBlock );
      AUX_VARIABLE( timeStamp );
      AUX_VARIABLE( timeStampNSOffset );
      AUX_VARIABLE( bcid );
      AUX_VARIABLE( detectorMask0 );
      AUX_VARIABLE( detectorMask1 );
      AUX_VARIABLE( detectorMask2 );
      AUX_VARIABLE( detectorMask3 );
 
      // Event type information:
      AUX_VARIABLE( detDescrTags );
      AUX_VARIABLE( eventTypeBitmask );
 
      // Trigger related information:
      AUX_VARIABLE( statusElement );
      AUX_VARIABLE( extendedLevel1ID );
      AUX_VARIABLE( level1TriggerType );
      AUX_VARIABLE( streamTagNames );
      AUX_VARIABLE( streamTagTypes );
      AUX_VARIABLE( streamTagObeysLumiblock );
 
      // Detector flags:
#define DET_FLAG(VAR)                                                   \
      AUX_VARIABLE( VAR, SG::AuxTypeRegistry::Flags::Atomic );          \
      do {                                                              \
         static const auxid_t auxid =                                   \
            getAuxID( #VAR, VAR,                                        \
                      SG::AuxTypeRegistry::Flags::Atomic );             \
         m_decorFlags.insert( auxid );                                  \
      } while( false )
 
      DET_FLAG( pixelFlags );
      DET_FLAG( sctFlags );
      DET_FLAG( trtFlags );
      DET_FLAG( larFlags );
      DET_FLAG( tileFlags );
      DET_FLAG( muonFlags );
      DET_FLAG( forwardDetFlags );
      DET_FLAG( coreFlags );
      DET_FLAG( backgroundFlags );
      DET_FLAG( lumiFlags );
#undef DET_FLAG
   }

Member Function Documentation

◆ clearDecorations()

bool xAOD::AuxInfoBase::clearDecorations ( )

overridevirtualinherited

Clear all decorations.

Implements SG::IConstAuxStore.

Definition at line 322 of file AuxInfoBase.cxx.

                                      {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Clear the decorations that are in the dynamic store:
      bool anycleared = false;
      if( m_store ) {
         anycleared = m_store->clearDecorations();
      }
      // Early exit if there were no decorations.
      if (!anycleared) return false;
 
      // Reconstruct the list of managed auxiliary IDs from scratch:
      auxid_set_t ids;
      for( auxid_t auxid = 0; auxid < m_vecs.size(); ++auxid ) {
         if( m_vecs[ auxid ] ) {
            ids.insert( auxid );
         }
      }
      if( m_store ) {
        ids.insert (m_store->getAuxIDs());
      }
      m_auxids = std::move(ids);
      
      return true;
   }

◆ getAuxID()

template<typename T>

auxid_t xAOD::AuxInfoBase::getAuxID	(	const std::string &	name,
		T &	,
		SG::AuxVarFlags	flags = SG::AuxVarFlags::None,
		const SG::auxid_t	linkedVariable = SG::null_auxid )

inherited

Get the auxiliary ID for one of the persistent variables.

◆ getAuxIDs()

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

overridevirtualinherited

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

Implements SG::IConstAuxStore.

Definition at line 249 of file AuxInfoBase.cxx.

                                {
 
      // Return the full list of IDs:
      return getWritableAuxIDs();
   }

◆ getData() [1/2]

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

overridevirtualinherited

Get a pointer to a given array.

Implements SG::IConstAuxStore.

Definition at line 195 of file AuxInfoBase.cxx.

                                                         {
 
      const SG::IAuxTypeVector* v = getVector( auxid );
      if( v ) {
         return v->toPtr();
      }
      return nullptr;
   }

◆ getData() [2/2]

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

overridevirtualinherited

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

Implements SG::IAuxStore.

Definition at line 424 of file AuxInfoBase.cxx.

                                                 {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
 
         if( m_store ) {
            void* result = m_store->getData( auxid, size, capacity );
            if( result ) {
               m_auxids.insert( auxid );
               const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
               auxid_t linked_id = r.linkedVariable( auxid );
               if (linked_id != SG::null_auxid) {
                  m_auxids.insert( linked_id );
               }
            }
            return result;
         } else {
            std::cout << "ERROR xAOD::AuxInfoBase::getData "
                      << "Unknown variable ("
                      << SG::AuxTypeRegistry::instance().getName( auxid )
                      << ") requested" << std::endl;
            return nullptr;
         }
      }
      m_vecs[ auxid ]->reserve( capacity );
      if (m_vecs[ auxid ]->size() < size) {
         m_vecs[ auxid ]->resize( size );
      }
 
      return m_vecs[ auxid ]->toPtr();
   }

◆ getDecoration()

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

overridevirtual

Return the data vector for one aux data decoration item.

Parameters

auxid	The identifier of the desired aux data item.
size	The current size of the container (in case the data item does not already exist).
capacity	The current capacity of the container (in case the data item does not already exist).

Reimplemented from xAOD::AuxInfoBase.

Definition at line 95 of file EventAuxInfo_v3.cxx.

   {
     if (m_decorFlags.test (auxid)) {
       return AuxInfoBase::getData (auxid, size, capacity);
     }
 
     return AuxInfoBase::getDecoration (auxid, size, capacity);
   }

◆ getDecorIDs()

const AuxInfoBase::auxid_set_t & xAOD::AuxInfoBase::getDecorIDs ( ) const

overridevirtualinherited

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

Implements SG::IConstAuxStore.

Definition at line 256 of file AuxInfoBase.cxx.

                                  {
 
      if( m_store ) {
         return m_store->getDecorIDs();
      }
      static const auxid_set_t empty;
      return empty;
   }

◆ getDynamicAuxIDs()

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

overridevirtualinherited

Get the types(names) of variables created dynamically.

Implements SG::IAuxStoreIO.

Definition at line 636 of file AuxInfoBase.cxx.

                                       {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // All the variables handled by the internal store are dynamic
      // if such a store exists:
      if( m_storeIO ) {
         // I mean, all the variables. Not just the ones reported as dynamic
         // by the internal object. Because the internal object may be something
         // that was put into this one in order to achieve data slimming.
         return m_store->getAuxIDs();
      }
 
      // In case we don't use an internal store, there are no dynamic
      // variables:
      static const auxid_set_t dummy (0);
      return dummy;
   }

◆ getIOData()

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

overridevirtualinherited

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

Implements SG::IAuxStoreIO.

Definition at line 585 of file AuxInfoBase.cxx.

                                                           {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         if( m_storeIO ) {
            return m_storeIO->getIOData( auxid );
         } else {
            std::cout << "ERROR xAOD::AuxInfoBase::getIOData "
                      << "Unknown variable ("
                      << SG::AuxTypeRegistry::instance().getName( auxid )
                      << ") requested" << std::endl;
            return nullptr;
         }
      }
 
      // Update the statistics for this variable. The dynamic store registers
      // its own variable accesses.
      IOStats::instance().stats().readBranch( m_name, auxid );
 
      if( m_vecs[ auxid ]->isLinked() )
         return m_vecs[ auxid ]->toVector();
      else
         return m_vecs[ auxid ]->toPtr();
   }

◆ getIOType()

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

overridevirtualinherited

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

Implements SG::IAuxStoreIO.

Definition at line 612 of file AuxInfoBase.cxx.

                                                                   {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         if( m_storeIO ) {
            return m_storeIO->getIOType( auxid );
         } else {
            std::cout << "ERROR xAOD::AuxInfoBase::getIOType "
                      << "Unknown variable ("
                      << SG::AuxTypeRegistry::instance().getName( auxid )
                      << ") requested" << std::endl;
            return nullptr;
         }
      }
 
      if( m_vecs[ auxid ]->isLinked() )
         return SG::AuxTypeRegistry::instance().getType( auxid );
      else
         return SG::AuxTypeRegistry::instance().getVecType( auxid );
   }

◆ getSelectedAuxIDs()

AuxInfoBase::auxid_set_t xAOD::AuxInfoBase::getSelectedAuxIDs ( ) const

overridevirtualinherited

Get the IDs of the selected dynamic Aux variables (for writing)

Reimplemented from SG::IAuxStoreIO.

Definition at line 657 of file AuxInfoBase.cxx.

                                        {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // All the variables handled by the internal store are dynamic
      // if such a store exists:
      if( m_storeIO ) {
         // I mean, all the variables. Not just the ones reported as dynamic
         // by the internal object. Because the internal object may be something
         // that was put into this one in order to achieve data slimming.
         return m_store->getAuxIDs();
      }
 
      // In case we don't use an internal store, there are no dynamic
      // variables:
      return auxid_set_t();
   }

◆ getStore() [1/2]

const SG::IAuxStore * xAOD::AuxInfoBase::getStore ( ) const

overridevirtualinherited

Get the currently used internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 146 of file AuxInfoBase.cxx.

   {
      return m_store;
   }

◆ getStore() [2/2]

SG::IAuxStore * xAOD::AuxInfoBase::getStore ( )

overridevirtualinherited

Get the currently used internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 140 of file AuxInfoBase.cxx.

   {
      return m_store;
   }

◆ getStoreType()

virtual AuxStoreType xAOD::AuxInfoBase::getStoreType ( ) const

inlineoverridevirtualinherited

Return the type of the store object.

Implements SG::IAuxStoreHolder.

Definition at line 75 of file AuxInfoBase.h.

75{ return AST_ObjectStore; }

◆ getVector()

const SG::IAuxTypeVector * xAOD::AuxInfoBase::getVector ( SG::auxid_t auxid ) const

finaloverridevirtualinherited

Return vector interface for one aux data item.

Implements SG::IConstAuxStore.

Definition at line 204 of file AuxInfoBase.cxx.

                                                                       {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         if( m_store ) {
            const SG::IAuxTypeVector* result = m_store->getVector( auxid );
            if( result ) {
               auxid_set_t& auxids_nc ATLAS_THREAD_SAFE =
                 const_cast<auxid_set_t&> (m_auxids);
               auxids_nc.insert( auxid );
               const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
               auxid_t linked_id = r.linkedVariable( auxid );
               if (linked_id != SG::null_auxid) {
                  auxids_nc.insert( linked_id );
               }
            }
            return result;
         } else {
            std::cout << "ERROR xAOD::AuxInfoBase::getData "
                      << "Unknown variable ("
                      << SG::AuxTypeRegistry::instance().getName( auxid )
                      << ") requested" << std::endl;
            return nullptr;
         }
      }
 
      // Update the statistics for this variable. The dynamic store registers
      // its own variable accesses.
      IOStats::instance().stats().readBranch( m_name, auxid );
 
      return m_vecs[ auxid ];
   }

◆ getWritableAuxIDs()

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

overridevirtualinherited

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 460 of file AuxInfoBase.cxx.

                                        {
 
      // Return the full list of known IDs. The constness of this object's
      // members comes from the object being const or not.
      return m_auxids;
   }

◆ insertMove() [1/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.

◆ insertMove() [2/2]

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

overridevirtualinherited

Insert contents of another store via move.

Definition at line 549 of file AuxInfoBase.cxx.

                                                          {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Check if the container is locked:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "insertMove" );
      }
 
      // We are just not allowed to do this...
      throw std::runtime_error( "Calling insertMove on a non-vector" );
 
      return false;
   }

◆ isDecoration()

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

overridevirtual

Test if a particular variable is tagged as a decoration.

Parameters

auxid The identifier of the desired aux data item.

Reimplemented from xAOD::AuxInfoBase.

Definition at line 111 of file EventAuxInfo_v3.cxx.

   {
     if (m_decorFlags.test (auxid)) {
       return true;
     }
 
     return AuxInfoBase::isDecoration (auxid);
   }

◆ linkedVector() [1/2]

const SG::IAuxTypeVector * xAOD::AuxInfoBase::linkedVector ( SG::auxid_t auxid ) const

overridevirtualinherited

Return interface for a linked variable.

Reimplemented from SG::IConstAuxStore.

Definition at line 359 of file AuxInfoBase.cxx.

   {
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      auxid_t linked_id = r.linkedVariable( auxid );
      if (linked_id != SG::null_auxid) {
         guard_t guard( m_mutex );
         if (linked_id < m_vecs.size() && m_vecs[ linked_id ]) {
            return m_vecs[ linked_id ];
         }
         if (m_store) {
            return CxxUtils::as_const_ptr(m_store)->linkedVector( auxid );
         }
      }
      return nullptr;
   }

◆ linkedVector() [2/2]

SG::IAuxTypeVector * xAOD::AuxInfoBase::linkedVector ( SG::auxid_t auxid )

overridevirtualinherited

Return interface for a linked variable.

Reimplemented from SG::IAuxStore.

Definition at line 376 of file AuxInfoBase.cxx.

   {
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      auxid_t linked_id = r.linkedVariable( auxid );
      if (linked_id != SG::null_auxid) {
         guard_t guard( m_mutex );
         if (linked_id < m_vecs.size() && m_vecs[ linked_id ]) {
            return m_vecs[ linked_id ];
         }
         if (m_store) {
            return m_store->linkedVector( auxid );
         }
      }
      return nullptr;
   }

◆ lock()

void xAOD::AuxInfoBase::lock ( )

overridevirtualinherited

Lock the container.

Implements SG::IConstAuxStore.

Definition at line 308 of file AuxInfoBase.cxx.

                          {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Lock the container and the dynamic store:
      m_locked = true;
      if( m_store ) {
         m_store->lock();
      }
 
      return;
   }

◆ lockDecoration()

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

overridevirtual

Lock a decoration.

Parameters

auxid Identifier of the decoration to lock.

Reimplemented from xAOD::AuxInfoBase.

Definition at line 125 of file EventAuxInfo_v3.cxx.

   {
     if (m_decorFlags.test (auxid)) {
       m_decorFlags.reset (auxid);
       return;
     }
 
     AuxInfoBase::lockDecoration (auxid);
   }

◆ name()

const char * xAOD::AuxInfoBase::name ( ) const

inherited

Get the name of the container instance.

Definition at line 679 of file AuxInfoBase.cxx.

                                       {
 
      return m_name.c_str();
   }

◆ regAuxVar()

template<typename T>

void xAOD::AuxInfoBase::regAuxVar	(	auxid_t	auxid,
		const std::string &	name,
		T &	info )

inherited

Register one of the persistent variables internally.

◆ reserve()

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

overridevirtualinherited

Reserve a given size for the arrays.

Implements SG::IAuxStore.

Definition at line 501 of file AuxInfoBase.cxx.

                                          {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Check if the container is locked:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "reserve" );
      }
 
      // Do a test already here:
      if( size != 1 ) {
         throw std::runtime_error( "Calling reserve with != 1 on a "
                                   "non-vector" );
      }
 
      // Do the operation on the static variables:
      for (SG::IAuxTypeVector* v : m_vecs) {
         if(v && !v->isLinked()) {
            v->reserve( size );
         }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
         m_store->reserve( size );
      }
 
      return;
   }

◆ resize()

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

overridevirtualinherited

Resize the arrays to a given size.

Implements SG::IAuxStore.

Definition at line 467 of file AuxInfoBase.cxx.

                                         {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Check if the container is locked:
      if( m_locked ) {
        throw SG::ExcStoreLocked( "resize" );
      }
 
      // Do a test already here:
      if( size != 1 ) {
         throw std::runtime_error( "Calling resize with != 1 on a "
                                   "non-vector" );
      }
 
      // Do the operation on the static variables:
      bool nomoves = true;
      for (SG::IAuxTypeVector* v : m_vecs) {
         if(v && !v->isLinked()) {
           if (!v->resize( size ))
             nomoves = false;
         }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
        if (!m_store->resize( size ))
          nomoves = false;
      }
 
      return nomoves;
   }

◆ setName()

void xAOD::AuxInfoBase::setName ( const char * name )

inherited

Set the name of the container instance.

Definition at line 684 of file AuxInfoBase.cxx.

                                               {
 
      m_name = name;
      return;
   }

◆ setOption()

bool xAOD::AuxInfoBase::setOption	(	auxid_t	id,
		const SG::AuxDataOption &	option )

overridevirtualinherited

Make an option setting on an aux variable.

Reimplemented from SG::IAuxStore.

Definition at line 567 of file AuxInfoBase.cxx.

                                                                          {
 
      if (id < m_vecs.size() && m_vecs[id] != nullptr)
         return m_vecs[id]->setOption( option );
      if (m_store)
         return m_store->setOption( id, option );
      return false;
   }

◆ setStore()

void xAOD::AuxInfoBase::setStore ( SG::IAuxStore * store )

overridevirtualinherited

Set a different internal store object.

This function is used by the I/O infrastructure to possibly put a store object into this one, which can interact with dynamic variables directly.

Note that the object takes ownership of the received store.

Parameters

store The store that should be used for dynamic variable handling inside the object from now on

Implements SG::IAuxStoreHolder.

Definition at line 160 of file AuxInfoBase.cxx.

                                                  {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Check that no funny business is going on:
      if( m_store == store ) return;
 
      // Clean up the current store object:
      if( m_store && m_ownsStore ) {
         m_auxids -= m_store->getAuxIDs();
         delete m_store;
      }
      m_store = nullptr;
      m_storeIO = nullptr;
 
      // Take posession of the new object:
      m_store = store;
      m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
      m_ownsStore = true;
      if( m_store ) {
        m_auxids.insert (m_store->getAuxIDs());
      }
 
      return;
   }

◆ shift()

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

overridevirtualinherited

Shift the contents of the stored arrays.

Implements SG::IAuxStore.

Definition at line 532 of file AuxInfoBase.cxx.

                                                  {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Check if the container is locked:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "shift" );
      }
 
      // We are just not allowed to do this...
      throw std::runtime_error( "Calling shift on a non-vector" );
 
      return;
   }

◆ size()

size_t xAOD::AuxInfoBase::size ( ) const

overridevirtualinherited

Get the size of the container.

Implements SG::IConstAuxStore.

Definition at line 393 of file AuxInfoBase.cxx.

                                  {
 
      // Should really always be 1, but do the general thing anyway...
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Try to find a variable:
      for (SG::auxid_t i : m_auxids) {
         if( ( i < m_vecs.size() ) && m_vecs[ i ] && !m_vecs[ i ]->isLinked()) {
            size_t sz = m_vecs[ i ]->size();
            if( sz > 0 ) {
               return sz;
            }
         }
      }
 
      // If we didn't find any statically defined variables, then we just
      // need to claim 1. Because pool::AuxStoreAPR at the moment always
      // returns 0 for the size.
      return 1;
   }

◆ toTransient()

void xAOD::EventAuxInfo_v3::toTransient ( )

Called after one of these objects is read.

Locks any detector flag words that appear to have already been set.

List of all detector flag aux IDs.

Definition at line 141 of file EventAuxInfo_v3.cxx.

   {
     static const std::vector<SG::auxid_t> flagIds (m_decorFlags.begin(),
                                                    m_decorFlags.end());
 
     // Check each detector flag.  If it has been set to something,
     // then lock this flag.
     // This check may be too strict; we'll have to see.
     for (SG::auxid_t id : flagIds) {
       if (*reinterpret_cast<const uint32_t*>(getData (id)) != 0) {
         m_decorFlags.reset (id);
       }
     }
   }

Member Data Documentation

◆ backgroundFlags

uint32_t xAOD::EventAuxInfo_v3::backgroundFlags

Definition at line 110 of file EventAuxInfo_v3.h.

◆ bcid

uint32_t xAOD::EventAuxInfo_v3::bcid

Definition at line 77 of file EventAuxInfo_v3.h.

◆ coreFlags

uint32_t xAOD::EventAuxInfo_v3::coreFlags

Definition at line 109 of file EventAuxInfo_v3.h.

◆ detDescrTags

std::vector< std::pair< std::string, std::string > > xAOD::EventAuxInfo_v3::detDescrTags

Definition at line 86 of file EventAuxInfo_v3.h.

◆ detectorMask0

uint32_t xAOD::EventAuxInfo_v3::detectorMask0

Definition at line 78 of file EventAuxInfo_v3.h.

◆ detectorMask1

uint32_t xAOD::EventAuxInfo_v3::detectorMask1

Definition at line 79 of file EventAuxInfo_v3.h.

◆ detectorMask2

uint32_t xAOD::EventAuxInfo_v3::detectorMask2

Definition at line 80 of file EventAuxInfo_v3.h.

◆ detectorMask3

uint32_t xAOD::EventAuxInfo_v3::detectorMask3

Definition at line 81 of file EventAuxInfo_v3.h.

◆ eventNumber

uint64_t xAOD::EventAuxInfo_v3::eventNumber

Definition at line 73 of file EventAuxInfo_v3.h.

◆ eventTypeBitmask

uint32_t xAOD::EventAuxInfo_v3::eventTypeBitmask

Definition at line 87 of file EventAuxInfo_v3.h.

◆ extendedLevel1ID

uint32_t xAOD::EventAuxInfo_v3::extendedLevel1ID

Definition at line 93 of file EventAuxInfo_v3.h.

◆ forwardDetFlags

uint32_t xAOD::EventAuxInfo_v3::forwardDetFlags

Definition at line 108 of file EventAuxInfo_v3.h.

◆ larFlags

uint32_t xAOD::EventAuxInfo_v3::larFlags

Definition at line 105 of file EventAuxInfo_v3.h.

◆ level1TriggerType

uint16_t xAOD::EventAuxInfo_v3::level1TriggerType

Definition at line 94 of file EventAuxInfo_v3.h.

◆ lumiBlock

uint32_t xAOD::EventAuxInfo_v3::lumiBlock

Definition at line 74 of file EventAuxInfo_v3.h.

◆ lumiFlags

uint32_t xAOD::EventAuxInfo_v3::lumiFlags

Definition at line 111 of file EventAuxInfo_v3.h.

◆ m_auxids

auxid_set_t xAOD::AuxInfoBase::m_auxids

privateinherited

Internal list of all available variables.

Definition at line 193 of file AuxInfoBase.h.

◆ m_decorFlags

CxxUtils::ConcurrentBitset xAOD::EventAuxInfo_v3::m_decorFlags

Keep track of the event status flags.

The set bits here correspond to the auxids of all unlocked detector flag words. This is not persistent, but is filled in the constructor and toTransient.

Definition at line 118 of file EventAuxInfo_v3.h.

◆ m_locked

bool xAOD::AuxInfoBase::m_locked

privateinherited

Has the container been locked?

Definition at line 204 of file AuxInfoBase.h.

◆ m_mutex

mutex_t xAOD::AuxInfoBase::m_mutex

mutableprivateinherited

Definition at line 209 of file AuxInfoBase.h.

◆ m_name

std::string xAOD::AuxInfoBase::m_name

privateinherited

Name of the container in memory. Set externally.

Definition at line 212 of file AuxInfoBase.h.

◆ m_ownsStore

bool xAOD::AuxInfoBase::m_ownsStore

privateinherited

Flag deciding if the object owns the dynamic store or not.

Definition at line 202 of file AuxInfoBase.h.

◆ m_store

SG::IAuxStore* xAOD::AuxInfoBase::m_store

privateinherited

Internal dynamic auxiliary store object.

Definition at line 198 of file AuxInfoBase.h.

◆ m_storeIO

SG::IAuxStoreIO* xAOD::AuxInfoBase::m_storeIO

privateinherited

The IO interface to the internal auxiliary store.

Definition at line 200 of file AuxInfoBase.h.

◆ m_vecs

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

privateinherited

Internal list of all managed variables.

Definition at line 195 of file AuxInfoBase.h.

◆ muonFlags

uint32_t xAOD::EventAuxInfo_v3::muonFlags

Definition at line 107 of file EventAuxInfo_v3.h.

◆ pixelFlags

uint32_t xAOD::EventAuxInfo_v3::pixelFlags

Definition at line 102 of file EventAuxInfo_v3.h.

◆ runNumber

uint32_t xAOD::EventAuxInfo_v3::runNumber

Definition at line 72 of file EventAuxInfo_v3.h.

◆ sctFlags

uint32_t xAOD::EventAuxInfo_v3::sctFlags

Definition at line 103 of file EventAuxInfo_v3.h.

◆ statusElement

uint32_t xAOD::EventAuxInfo_v3::statusElement

Definition at line 92 of file EventAuxInfo_v3.h.

◆ streamTagNames

std::vector< std::string > xAOD::EventAuxInfo_v3::streamTagNames

Definition at line 95 of file EventAuxInfo_v3.h.

◆ streamTagObeysLumiblock

std::vector< char > xAOD::EventAuxInfo_v3::streamTagObeysLumiblock

Definition at line 97 of file EventAuxInfo_v3.h.

◆ streamTagTypes

std::vector< std::string > xAOD::EventAuxInfo_v3::streamTagTypes

Definition at line 96 of file EventAuxInfo_v3.h.

◆ supportsThinning

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 199 of file IAuxStore.h.

◆ tileFlags

uint32_t xAOD::EventAuxInfo_v3::tileFlags

Definition at line 106 of file EventAuxInfo_v3.h.

◆ timeStamp

uint32_t xAOD::EventAuxInfo_v3::timeStamp

Definition at line 75 of file EventAuxInfo_v3.h.

◆ timeStampNSOffset

uint32_t xAOD::EventAuxInfo_v3::timeStampNSOffset

Definition at line 76 of file EventAuxInfo_v3.h.

◆ trtFlags

uint32_t xAOD::EventAuxInfo_v3::trtFlags

Definition at line 104 of file EventAuxInfo_v3.h.

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

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Private Types

Private Attributes

Detailed Description

Member Typedef Documentation

◆ auxid_set_t

◆ auxid_t

◆ AuxVariable_t

◆ guard_t

◆ LinkedVariable_t

◆ mutex_t

Member Enumeration Documentation

◆ AuxStoreType

Constructor & Destructor Documentation

◆ EventAuxInfo_v3()

Member Function Documentation

◆ clearDecorations()

◆ getAuxID()

◆ getAuxIDs()

◆ getData() [1/2]

◆ getData() [2/2]

◆ getDecoration()

◆ getDecorIDs()

◆ getDynamicAuxIDs()

◆ getIOData()

◆ getIOType()

◆ getSelectedAuxIDs()

◆ getStore() [1/2]

◆ getStore() [2/2]

◆ getStoreType()

◆ getVector()

◆ getWritableAuxIDs()

◆ insertMove() [1/2]

◆ insertMove() [2/2]

◆ isDecoration()

◆ linkedVector() [1/2]

◆ linkedVector() [2/2]

◆ lock()

◆ lockDecoration()

◆ name()

◆ regAuxVar()

◆ reserve()

◆ resize()

◆ setName()

◆ setOption()

◆ setStore()

◆ shift()

◆ size()

◆ toTransient()

Member Data Documentation

◆ backgroundFlags

◆ bcid

◆ coreFlags

◆ detDescrTags

◆ detectorMask0

◆ detectorMask1

◆ detectorMask2

◆ detectorMask3

◆ eventNumber

◆ eventTypeBitmask

◆ extendedLevel1ID

◆ forwardDetFlags

◆ larFlags

◆ level1TriggerType

◆ lumiBlock

◆ lumiFlags

◆ m_auxids

◆ m_decorFlags

◆ m_locked

◆ m_mutex

◆ m_name

◆ m_ownsStore

◆ m_store

◆ m_storeIO

◆ m_vecs

◆ muonFlags

◆ pixelFlags