xAOD::EventInfoAuxContainer_v1 Class Reference

Auxiliary information about the pileup events. More...

#include <EventInfoAuxContainer_v1.h>

Inheritance diagram for xAOD::EventInfoAuxContainer_v1:

Collaboration diagram for xAOD::EventInfoAuxContainer_v1:

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

Public Member Functions
	EventInfoAuxContainer_v1 ()
	Default constructor. More...
virtual void *	getDecoration (SG::auxid_t auxid, size_t size, size_t capacity) override
	Return the data vector for one aux data decoration item. More...
virtual bool	isDecoration (auxid_t auxid) const override
	Test if a particular variable is tagged as a decoration. More...
virtual void	lockDecoration (SG::auxid_t auxid) override
	Lock a decoration. More...
void	toTransient ()
	Called after one of these objects is 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...
template<typename T , typename ALLOC >
auxid_t	getAuxID (const std::string &name, std::vector< T, ALLOC > &, SG::AuxVarFlags flags=SG::AuxVarFlags::None)
	Get the auxiliary ID for one of the persistent variables. More...
template<typename T >
auxid_t	getAuxID (const std::string &name, SG::PackedContainer< T > &, SG::AuxTypeRegistry::Flags flags=SG::AuxTypeRegistry::Flags::None)
	Get the auxiliary ID for one of the persistent variables. More...
template<typename T , typename ALLOC >
void	regAuxVar (auxid_t auxid, const std::string &name, std::vector< T, ALLOC > &vec)
	Register one of the persistent variables internally. More...
template<typename T >
void	regAuxVar (auxid_t auxid, const std::string &name, SG::PackedContainer< T > &vec)
	Register one of the persistent variables internally. 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 for multithread synchronization. More...
typedef AthContainers_detail::lock_guard< mutex_t >	guard_t

Private Member Functions
template<typename ELT , typename CONT >
void	regAuxVar1 (auxid_t auxid, const std::string &name, CONT &vec)
	Common code between regAuxVar cases. More...

Private Attributes
CxxUtils::ConcurrentBitset	m_decorFlags
	Keep track of the event status flags. More...
auxid_set_t	m_auxids
	Internal list of all available variables. More...
std::vector< SG::IAuxTypeVector * >	m_vecs
	Internal list of all managed variables. More...
SG::IAuxStore *	m_store
	Internal dynamic auxiliary store object. More...
SG::IAuxStoreIO *	m_storeIO
	The IO interface to the internal auxiliary store. More...
bool	m_ownsStore
	Flag deciding if the object owns the dynamic store or not. More...
bool	m_locked
	Has the container been locked? More...
mutex_t	m_mutex
std::string	m_name
	Name of the container in memory. Set externally. More...
CxxUtils::CachedPointer< std::pmr::memory_resource > m_memResource	ATLAS_THREAD_SAFE
	Memory resource to use for this container. More...
Basic event information
std::vector< uint32_t >	runNumber
std::vector< uint64_t >	eventNumber
std::vector< uint32_t >	lumiBlock
std::vector< uint32_t >	timeStamp
std::vector< uint32_t >	timeStampNSOffset
std::vector< uint32_t >	bcid
std::vector< uint32_t >	detectorMask0
std::vector< uint32_t >	detectorMask1
std::vector< uint32_t >	detectorMask2
std::vector< uint32_t >	detectorMask3
Event type information
std::vector< std::vector< std::pair< std::string, std::string > > >	detDescrTags
std::vector< uint32_t >	eventTypeBitmask
Detector flags
std::vector< uint32_t >	pixelFlags
std::vector< uint32_t >	sctFlags
std::vector< uint32_t >	trtFlags
std::vector< uint32_t >	larFlags
std::vector< uint32_t >	tileFlags
std::vector< uint32_t >	muonFlags
std::vector< uint32_t >	forwardDetFlags
std::vector< uint32_t >	coreFlags
std::vector< uint32_t >	backgroundFlags
std::vector< uint32_t >	lumiFlags
Monte-Carlo information
std::vector< uint32_t >	mcChannelNumber
std::vector< uint64_t >	mcEventNumber
std::vector< std::vector< float > >	mcEventWeights
Pileup information
std::vector< uint64_t >	pileUpMixtureIDLowBits
std::vector< uint64_t >	pileUpMixtureIDHighBits

Detailed Description

Auxiliary information about the pileup events.

This object describes the "static" auxiliary information about all the pileup events.

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

Revision

636390

Date

2014-12-16 22:52:18 +0100 (Tue, 16 Dec 2014)

Definition at line 31 of file EventInfoAuxContainer_v1.h.

Member Typedef Documentation

auxid_set_t

typedef SG::auxid_set_t xAOD::AuxContainerBase::auxid_set_t

inherited

The aux ID set type definition.

Definition at line 65 of file AuxContainerBase.h.

auxid_t

typedef SG::auxid_t xAOD::AuxContainerBase::auxid_t

inherited

The aux ID type definition.

Definition at line 63 of file AuxContainerBase.h.

AuxVariable_t

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

using xAOD::AuxContainerBase::AuxVariable_t = std::vector<T, ALLOC>

inherited

Declare how to wrap variables for this sort of base.

Definition at line 183 of file AuxContainerBase.h.

guard_t

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

privateinherited

Definition at line 231 of file AuxContainerBase.h.

mutex_t

typedef AthContainers_detail::mutex xAOD::AuxContainerBase::mutex_t

privateinherited

Mutex for multithread synchronization.

Definition at line 230 of file AuxContainerBase.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

EventInfoAuxContainer_v1()

xAOD::EventInfoAuxContainer_v1::EventInfoAuxContainer_v1

(

)

Default constructor.

Definition at line 10 of file EventInfoAuxContainer_v1.cxx.

      : AuxContainerBase(),
        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 );
 
      // 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
 
      // MC information:
      AUX_VARIABLE( mcChannelNumber );
      AUX_VARIABLE( mcEventNumber );
      AUX_VARIABLE( mcEventWeights );
      
      // Pileup information:
      AUX_VARIABLE( pileUpMixtureIDLowBits );
      AUX_VARIABLE( pileUpMixtureIDHighBits );
   }

Member Function Documentation

clearDecorations()

bool xAOD::AuxContainerBase::clearDecorations ( )

overridevirtualinherited

Clear all decorations.

Implements SG::IConstAuxStore.

Definition at line 325 of file AuxContainerBase.cxx.

                                           {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Clear the decorations from the dynamic store:
      bool anycleared = false;
      if( m_store ) {
         anycleared = m_store->clearDecorations();
      }
      // Early exit if there were no decorations.
      if (!anycleared) return false;
 
      // Construct the list of managed auxiliary variables from scratch after
      // the cleanup:
      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 = ids;
 
      return true;
   }

getAuxID() [1/2]

template<typename T >

auxid_t xAOD::AuxContainerBase::getAuxID ( const std::string &  name, SG::PackedContainer< T > &  , SG::AuxTypeRegistry::Flags  flags = SG::AuxTypeRegistry::Flags::None  )

inherited

Get the auxiliary ID for one of the persistent variables.

getAuxID() [2/2]

template<typename T , typename ALLOC >

auxid_t xAOD::AuxContainerBase::getAuxID ( const std::string &  name, std::vector< T, ALLOC > &  , SG::AuxVarFlags  flags = SG::AuxVarFlags::None  )

inherited

Get the auxiliary ID for one of the persistent variables.

getAuxIDs()

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

overridevirtualinherited

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

Implements SG::IConstAuxStore.

Definition at line 258 of file AuxContainerBase.cxx.

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

getData() [1/3]

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

overridevirtualinherited

Get a pointer to a given array.

Implements SG::IConstAuxStore.

Definition at line 227 of file AuxContainerBase.cxx.

                                                              {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         if( m_store ) {
            const void* result = m_store->getData( auxid );
            if( result ) {
              auxid_set_t& auxids_nc ATLAS_THREAD_SAFE =
                const_cast<auxid_set_t&> (m_auxids);
              auxids_nc.insert( auxid );
            }
            return result;
         } else {
            std::cout << "ERROR xAOD::AuxContainerBase::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 ]->toPtr();
   }

getData() [2/3]

void * xAOD::AuxContainerBase::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 395 of file AuxContainerBase.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 );
            }
            return result;
         } else {
            std::cout << "ERROR xAOD::AuxContainerBase::getData "
                      << "Unknown variable ("
                      << SG::AuxTypeRegistry::instance().getName( auxid )
                      << ") requested" << std::endl;
            return nullptr;
         }
      }
      m_vecs[ auxid ]->reserve( capacity );
      m_vecs[ auxid ]->resize( size );
 
      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::EventInfoAuxContainer_v1::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::AuxContainerBase.

Definition at line 71 of file EventInfoAuxContainer_v1.cxx.

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

getDynamicAuxIDs()

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

overridevirtualinherited

Get the types(names) of variables created dynamically.

Implements SG::IAuxStoreIO.

Definition at line 628 of file AuxContainerBase.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::AuxContainerBase::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 586 of file AuxContainerBase.cxx.

                                                                {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // If the variable is not static, look for it in the dynamic store:
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         if( m_storeIO ) {
            return m_storeIO->getIOData( auxid );
         } else {
            std::cout << "ERROR xAOD::AuxContainerBase::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 );
 
      return m_vecs[ auxid ]->toVector();
   }

getIOType()

const std::type_info * xAOD::AuxContainerBase::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 611 of file AuxContainerBase.cxx.

                                                                        {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // If the variable is not static, ask the dynamic store:
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         if( m_storeIO ) {
            return m_storeIO->getIOType( auxid );
         }
      }
 
      // Fall back on getting the information from the registry:
      return SG::AuxTypeRegistry::instance().getVecType( auxid );
   }

getSelectedAuxIDs()

AuxContainerBase::auxid_set_t xAOD::AuxContainerBase::getSelectedAuxIDs ( ) const

overridevirtualinherited

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

Reimplemented from SG::IAuxStoreIO.

Definition at line 648 of file AuxContainerBase.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::AuxContainerBase::getStore ( ) const

overridevirtualinherited

Implements SG::IAuxStoreHolder.

Definition at line 178 of file AuxContainerBase.cxx.

   {
      return m_store;
   }

getStore() [2/2]

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

overridevirtualinherited

Get the currently used internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 151 of file AuxContainerBase.cxx.

   {
      return m_store;
   }

getStoreType()

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

inlineoverridevirtualinherited

Return the type of the store object.

Implements SG::IAuxStoreHolder.

Definition at line 92 of file AuxContainerBase.h.

{ return AST_ContainerStore; }

getWritableAuxIDs()

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

overridevirtualinherited

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 424 of file AuxContainerBase.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]

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

overridevirtualinherited

Insert contents of another store via move.

Definition at line 510 of file AuxContainerBase.cxx.

                                                                       {
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // This operation is not allowed on a locked container:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "insertMove" );
      }
 
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      bool nomove = true;
      size_t other_size = other.size();
 
      SG::auxid_set_t ignore = ignore_in;
      
      // Do the operation on the static variables:
      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;
          }
        }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
        if (!m_store->insertMove( pos, other, ignore ))
          nomove = false;
 
        // Notice any new variables added as a result of this.
        m_auxids.insert (m_store->getAuxIDs());
      }
 
      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.

isDecoration()

bool xAOD::EventInfoAuxContainer_v1::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::AuxContainerBase.

Definition at line 87 of file EventInfoAuxContainer_v1.cxx.

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

lock()

void xAOD::AuxContainerBase::lock ( )

overridevirtualinherited

Lock the container.

Implements ILockable.

Definition at line 311 of file AuxContainerBase.cxx.

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

lockDecoration()

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

overridevirtual

Lock a decoration.

Parameters

auxid

Identifier of the decoration to lock.

Reimplemented from xAOD::AuxContainerBase.

Definition at line 101 of file EventInfoAuxContainer_v1.cxx.

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

memResource()

std::pmr::memory_resource * xAOD::AuxContainerBase::memResource ( )

inherited

Return the memory resource to use.

Definition at line 156 of file AuxContainerBase.cxx.

   {
      const std::pmr::memory_resource* cptr = m_memResource.get();
      std::pmr::memory_resource* ptr ATLAS_THREAD_SAFE  = const_cast<std::pmr::memory_resource*>( cptr );
      if( !ptr ) {
#ifndef XAOD_STANDALONE
         const EventContext& ctx = Gaudi::Hive::currentContext();
         if( Atlas::hasExtendedEventContext( ctx ) ) {
            ptr = Atlas::getExtendedEventContext( ctx ).memResource();
         }
         if( !ptr )
#endif
         {
            ptr = std::pmr::get_default_resource();
         }
         if( ptr ) {
           m_memResource.set( ptr );
         }
      }
      return ptr;
   }

name()

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

inherited

Get the name of the container instance.

Definition at line 670 of file AuxContainerBase.cxx.

                                            {
 
      return m_name.c_str();
   }

regAuxVar() [1/2]

template<typename T >

void xAOD::AuxContainerBase::regAuxVar ( auxid_t  auxid, const std::string &  name, SG::PackedContainer< T > &  vec  )

inherited

Register one of the persistent variables internally.

regAuxVar() [2/2]

template<typename T , typename ALLOC >

void xAOD::AuxContainerBase::regAuxVar ( auxid_t  auxid, const std::string &  name, std::vector< T, ALLOC > &  vec  )

inherited

Register one of the persistent variables internally.

regAuxVar1()

template<typename ELT , typename CONT >

void xAOD::AuxContainerBase::regAuxVar1 ( auxid_t  auxid, const std::string &  name, CONT &  vec  )

privateinherited

Common code between regAuxVar cases.

reserve()

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

overridevirtualinherited

Reserve a given size for the arrays.

Implements SG::IAuxStore.

Definition at line 459 of file AuxContainerBase.cxx.

                                               {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // This operation is not allowed on a locked container:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "reserve" );
      }
 
      // Do the operation on the static variables:
      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 );
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
         m_store->reserve( size );
      }
 
      return;
   }

resize()

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

overridevirtualinherited

Resize the arrays to a given size.

Implements SG::IAuxStore.

Definition at line 431 of file AuxContainerBase.cxx.

                                              {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // This operation is not allowed on a locked container:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "resize" );
      }
 
      // Do the operation on the static variables:
      bool nomoves = true;
      for (SG::IAuxTypeVector* v : m_vecs) {
         if(v) {
           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::AuxContainerBase::setName ( const char *  name )

inherited

Set the name of the container instance.

Definition at line 675 of file AuxContainerBase.cxx.

                                                    {
 
      m_name = name;
      return;
   }

setOption()

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

overridevirtualinherited

Make an option setting on an aux variable.

Reimplemented from SG::IAuxStore.

Definition at line 565 of file AuxContainerBase.cxx.

                                                                     {
 
      guard_t guard (m_mutex);
      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::AuxContainerBase::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 192 of file AuxContainerBase.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::AuxContainerBase::shift ( size_t  pos, ptrdiff_t  offs  )

overridevirtualinherited

Shift the contents of the stored arrays.

Implements SG::IAuxStore.

Definition at line 484 of file AuxContainerBase.cxx.

                                                            {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // This operation is not allowed on a locked container:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "shift" );
      }
 
      // Do the operation on the static variables:
      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 );
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
         m_store->shift( pos, offs );
      }
 
      return;
   }

size()

size_t xAOD::AuxContainerBase::size ( ) const

overridevirtualinherited

Get the size of the container.

Implements SG::IConstAuxStore.

Definition at line 363 of file AuxContainerBase.cxx.

                                       {
 
      // 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 ] ) {
            size_t sz = m_vecs[ i ]->size();
            if( sz > 0 ) {
               return sz;
            }
         }
      }
 
      // If we didn't find any, let's ask the dynamic store:
      if( m_store ) {
         return m_store->size();
      }
 
      // If we don't have any variables, then the size must be null:
      return 0;
   }

toTransient()

void xAOD::EventInfoAuxContainer_v1::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 117 of file EventInfoAuxContainer_v1.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.
     size_t sz = size();
     for (SG::auxid_t id : flagIds) {
       const uint32_t* flags = reinterpret_cast<const uint32_t*>(getData (id, sz, sz));
       for (size_t i = 0; i < sz; i++) {
         if (flags[i] != 0) {
           m_decorFlags.reset (id);
           break;
         }
       }
     }
   }

Member Data Documentation

ATLAS_THREAD_SAFE

CxxUtils::CachedPointer<std::pmr::memory_resource> m_memResource xAOD::AuxContainerBase::ATLAS_THREAD_SAFE

mutableprivateinherited

Memory resource to use for this container.

Definition at line 238 of file AuxContainerBase.h.

backgroundFlags

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::backgroundFlags

private

Definition at line 104 of file EventInfoAuxContainer_v1.h.

bcid

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::bcid

private

Definition at line 80 of file EventInfoAuxContainer_v1.h.

coreFlags

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::coreFlags

private

Definition at line 103 of file EventInfoAuxContainer_v1.h.

detDescrTags

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

private

Definition at line 90 of file EventInfoAuxContainer_v1.h.

detectorMask0

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::detectorMask0

private

Definition at line 81 of file EventInfoAuxContainer_v1.h.

detectorMask1

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::detectorMask1

private

Definition at line 82 of file EventInfoAuxContainer_v1.h.

detectorMask2

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::detectorMask2

private

Definition at line 83 of file EventInfoAuxContainer_v1.h.

detectorMask3

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::detectorMask3

private

Definition at line 84 of file EventInfoAuxContainer_v1.h.

eventNumber

std::vector< uint64_t > xAOD::EventInfoAuxContainer_v1::eventNumber

private

Definition at line 76 of file EventInfoAuxContainer_v1.h.

eventTypeBitmask

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::eventTypeBitmask

private

Definition at line 91 of file EventInfoAuxContainer_v1.h.

forwardDetFlags

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::forwardDetFlags

private

Definition at line 102 of file EventInfoAuxContainer_v1.h.

larFlags

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::larFlags

private

Definition at line 99 of file EventInfoAuxContainer_v1.h.

lumiBlock

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::lumiBlock

private

Definition at line 77 of file EventInfoAuxContainer_v1.h.

lumiFlags

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::lumiFlags

private

Definition at line 105 of file EventInfoAuxContainer_v1.h.

m_auxids

auxid_set_t xAOD::AuxContainerBase::m_auxids

privateinherited

Internal list of all available variables.

Definition at line 216 of file AuxContainerBase.h.

m_decorFlags

CxxUtils::ConcurrentBitset xAOD::EventInfoAuxContainer_v1::m_decorFlags

private

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 125 of file EventInfoAuxContainer_v1.h.

m_locked

bool xAOD::AuxContainerBase::m_locked

privateinherited

Has the container been locked?

Definition at line 227 of file AuxContainerBase.h.

m_mutex

mutex_t xAOD::AuxContainerBase::m_mutex

mutableprivateinherited

Definition at line 232 of file AuxContainerBase.h.

m_name

std::string xAOD::AuxContainerBase::m_name

privateinherited

Name of the container in memory. Set externally.

Definition at line 235 of file AuxContainerBase.h.

m_ownsStore

bool xAOD::AuxContainerBase::m_ownsStore

privateinherited

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

Definition at line 225 of file AuxContainerBase.h.

m_store

SG::IAuxStore* xAOD::AuxContainerBase::m_store

privateinherited

Internal dynamic auxiliary store object.

Definition at line 221 of file AuxContainerBase.h.

m_storeIO

SG::IAuxStoreIO* xAOD::AuxContainerBase::m_storeIO

privateinherited

The IO interface to the internal auxiliary store.

Definition at line 223 of file AuxContainerBase.h.

m_vecs

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

privateinherited

Internal list of all managed variables.

Definition at line 218 of file AuxContainerBase.h.

mcChannelNumber

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::mcChannelNumber

private

Definition at line 110 of file EventInfoAuxContainer_v1.h.

mcEventNumber

std::vector< uint64_t > xAOD::EventInfoAuxContainer_v1::mcEventNumber

private

Definition at line 111 of file EventInfoAuxContainer_v1.h.

mcEventWeights

std::vector< std::vector< float > > xAOD::EventInfoAuxContainer_v1::mcEventWeights

private

Definition at line 112 of file EventInfoAuxContainer_v1.h.

muonFlags

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::muonFlags

private

Definition at line 101 of file EventInfoAuxContainer_v1.h.

pileUpMixtureIDHighBits

std::vector< uint64_t > xAOD::EventInfoAuxContainer_v1::pileUpMixtureIDHighBits

private

Definition at line 118 of file EventInfoAuxContainer_v1.h.

pileUpMixtureIDLowBits

std::vector< uint64_t > xAOD::EventInfoAuxContainer_v1::pileUpMixtureIDLowBits

private

Definition at line 117 of file EventInfoAuxContainer_v1.h.

pixelFlags

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::pixelFlags

private

Definition at line 96 of file EventInfoAuxContainer_v1.h.

runNumber

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::runNumber

private

Definition at line 75 of file EventInfoAuxContainer_v1.h.

sctFlags

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::sctFlags

private

Definition at line 97 of file EventInfoAuxContainer_v1.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.

tileFlags

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::tileFlags

private

Definition at line 100 of file EventInfoAuxContainer_v1.h.

timeStamp

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::timeStamp

private

Definition at line 78 of file EventInfoAuxContainer_v1.h.

timeStampNSOffset

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::timeStampNSOffset

private

Definition at line 79 of file EventInfoAuxContainer_v1.h.

trtFlags

std::vector< uint32_t > xAOD::EventInfoAuxContainer_v1::trtFlags

private

Definition at line 98 of file EventInfoAuxContainer_v1.h.

---

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

• EventInfoAuxContainer_v1.h
• EventInfoAuxContainer_v1.cxx