xAOD::CTPResultAuxInfo_v1 Class Reference

Auxiliary store for CTPResult_v1. More...

#include <CTPResultAuxInfo_v1.h>

Inheritance diagram for xAOD::CTPResultAuxInfo_v1:

Collaboration diagram for xAOD::CTPResultAuxInfo_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 = T
	Declare how to wrap variables for this sort of base. More...
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
	CTPResultAuxInfo_v1 ()
	Default constuctor. More...
virtual const void *	getData (SG::auxid_t auxid) const=0
	Pick up the const version from the base class. More...
virtual const IAuxTypeVector *	linkedVector (SG::auxid_t) const
	Return interface for a linked variable. 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 >
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. More...
template<typename T >
void	regAuxVar (auxid_t auxid, const std::string &name, T &info)
	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 Attributes
uint32_t	numberOfBunches
uint32_t	l1AcceptBunchPosition
uint32_t	ctpVersionNumber
uint32_t	headerMarker
uint32_t	headerSize
uint32_t	headerFormatVersion
uint32_t	sourceID
uint32_t	runNumber
uint32_t	L1ID
uint32_t	BCID
uint32_t	triggerType
uint32_t	eventType
uint32_t	timeNanoSec
uint32_t	timeSec
uint32_t	turnCounter
std::vector< std::vector< uint32_t > >	tipWords
std::vector< std::vector< uint32_t > >	tbpWords
std::vector< std::vector< uint32_t > >	tapWords
std::vector< std::vector< uint32_t > >	tavWords
std::vector< uint32_t >	additionalWords
uint32_t	errorStatus
uint32_t	infoStatus
uint32_t	numStatusWords
uint32_t	numDataWords
uint32_t	statusPosition
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...

Detailed Description

Auxiliary store for CTPResult_v1.

Stores data equivalent to the ROD data fragment such as the header, payload and trailer words. Trigger bits for CTP result stored using CTPBunchCrossing struct.

Definition at line 28 of file CTPResultAuxInfo_v1.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 55 of file AuxInfoBase.h.

auxid_t

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

inherited

The aux ID type definition.

Definition at line 53 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 179 of file AuxInfoBase.h.

guard_t

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

privateinherited

Definition at line 212 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 181 of file AuxInfoBase.h.

mutex_t

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

privateinherited

Mutex for multithread synchronization.

Definition at line 211 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

CTPResultAuxInfo_v1()

xAOD::CTPResultAuxInfo_v1::CTPResultAuxInfo_v1

(

)

Default constuctor.

Definition at line 10 of file CTPResultAuxInfo_v1.cxx.

    : AuxInfoBase() {
   
    AUX_VARIABLE( numberOfBunches );
    AUX_VARIABLE( l1AcceptBunchPosition );
    AUX_VARIABLE( ctpVersionNumber );
    AUX_VARIABLE( headerMarker );
    AUX_VARIABLE( headerSize );
    AUX_VARIABLE( headerFormatVersion );
    AUX_VARIABLE( sourceID );
    AUX_VARIABLE( runNumber );
    AUX_VARIABLE( L1ID );
    AUX_VARIABLE( BCID );
    AUX_VARIABLE( triggerType );
    AUX_VARIABLE( eventType );
    AUX_VARIABLE( timeSec );
    AUX_VARIABLE( timeNanoSec );
    AUX_VARIABLE( turnCounter );
    AUX_VARIABLE( tipWords );
    AUX_VARIABLE( tbpWords );
    AUX_VARIABLE( tapWords );
    AUX_VARIABLE( tavWords );
    AUX_VARIABLE( additionalWords );
    AUX_VARIABLE( errorStatus );
    AUX_VARIABLE( infoStatus );
    AUX_VARIABLE( numStatusWords );
    AUX_VARIABLE( numDataWords );
    AUX_VARIABLE( statusPosition );
  }

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/3]

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/3]

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();
   }

getData() [3/3]

virtual const void* SG::IConstAuxStore::getData

inherited

Pick up the const version from the base class.

getDecoration()

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

overridevirtualinherited

Get a pointer to a given array, as a decoration.

Implements SG::IConstAuxStore.

Reimplemented in xAOD::EventAuxInfo_v1, xAOD::EventAuxInfo_v2, and xAOD::EventAuxInfo_v3.

Definition at line 265 of file AuxInfoBase.cxx.

                                                       {
     {
       // Guard against multi-threaded execution:
       guard_t guard( m_mutex );
 
       // Check if we have it as a static variable:
       if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         // If not, but we have a dynamic store, push it in there:
         if( m_store ) {
           void* result = m_store->getDecoration( 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;
         }
         // If we don't have a dynamic store, complain:
         else {
           std::cout << "ERROR xAOD::AuxInfoBase::getDecoration "
                     << "Can't provide variable "
                     << SG::AuxTypeRegistry::instance().getName( auxid )
                     << std::endl;
           return nullptr;
         }
       }
 
       // If the container is locked, static variables can't be accessed this
       // way:
       if( m_locked ) {
         throw SG::ExcStoreLocked( auxid );
       }
     }
 
     // If the container is not locked, then fall back on the normal accessor
     // function:
     return getData( 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 79 of file AuxInfoBase.h.

{ 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]

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;
   }

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::AuxInfoBase::isDecoration ( auxid_t  auxid ) const

overridevirtualinherited

Test if a variable is a decoration.

Implements SG::IConstAuxStore.

Reimplemented in xAOD::EventAuxInfo_v1, xAOD::EventAuxInfo_v2, and xAOD::EventAuxInfo_v3.

Definition at line 239 of file AuxInfoBase.cxx.

   {
     guard_t guard( m_mutex );
     if (m_store) {
       return m_store->isDecoration (auxid);
     }
     return false;
   }

linkedVector() [1/3]

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/3]

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;
   }

linkedVector() [3/3]

virtual const IAuxTypeVector* SG::IConstAuxStore::linkedVector

inlineinherited

Return interface for a linked variable.

Parameters

auxid

The ID of the parent variable.

If auxid has a linked variable, then return the IAuxTypeVector describing it. Otherwise, return nullptr. May return nullptr unconditionally if this store does not support linked variables.

Definition at line 189 of file IConstAuxStore.h.

  { return nullptr; }

lock()

void xAOD::AuxInfoBase::lock ( )

overridevirtualinherited

Lock the container.

Implements ILockable.

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::AuxInfoBase::lockDecoration ( SG::auxid_t  auxid )

overridevirtualinherited

Lock a decoration.

Implements SG::IConstAuxStore.

Reimplemented in xAOD::EventAuxInfo_v1, xAOD::EventAuxInfo_v2, and xAOD::EventAuxInfo_v3.

Definition at line 351 of file AuxInfoBase.cxx.

   { 
     guard_t guard (m_mutex);
     if (m_store) {
       m_store->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;
   }

Member Data Documentation

additionalWords

std::vector< uint32_t > xAOD::CTPResultAuxInfo_v1::additionalWords

private

Definition at line 59 of file CTPResultAuxInfo_v1.h.

BCID

uint32_t xAOD::CTPResultAuxInfo_v1::BCID

private

Definition at line 47 of file CTPResultAuxInfo_v1.h.

ctpVersionNumber

uint32_t xAOD::CTPResultAuxInfo_v1::ctpVersionNumber

private

Definition at line 38 of file CTPResultAuxInfo_v1.h.

errorStatus

uint32_t xAOD::CTPResultAuxInfo_v1::errorStatus

private

Definition at line 62 of file CTPResultAuxInfo_v1.h.

eventType

uint32_t xAOD::CTPResultAuxInfo_v1::eventType

private

Definition at line 49 of file CTPResultAuxInfo_v1.h.

headerFormatVersion

uint32_t xAOD::CTPResultAuxInfo_v1::headerFormatVersion

private

Definition at line 43 of file CTPResultAuxInfo_v1.h.

headerMarker

uint32_t xAOD::CTPResultAuxInfo_v1::headerMarker

private

Definition at line 41 of file CTPResultAuxInfo_v1.h.

headerSize

uint32_t xAOD::CTPResultAuxInfo_v1::headerSize

private

Definition at line 42 of file CTPResultAuxInfo_v1.h.

infoStatus

uint32_t xAOD::CTPResultAuxInfo_v1::infoStatus

private

Definition at line 63 of file CTPResultAuxInfo_v1.h.

l1AcceptBunchPosition

uint32_t xAOD::CTPResultAuxInfo_v1::l1AcceptBunchPosition

private

Definition at line 37 of file CTPResultAuxInfo_v1.h.

L1ID

uint32_t xAOD::CTPResultAuxInfo_v1::L1ID

private

Definition at line 46 of file CTPResultAuxInfo_v1.h.

m_auxids

auxid_set_t xAOD::AuxInfoBase::m_auxids

privateinherited

Internal list of all available variables.

Definition at line 197 of file AuxInfoBase.h.

m_locked

bool xAOD::AuxInfoBase::m_locked

privateinherited

Has the container been locked?

Definition at line 208 of file AuxInfoBase.h.

m_mutex

mutex_t xAOD::AuxInfoBase::m_mutex

mutableprivateinherited

Definition at line 213 of file AuxInfoBase.h.

m_name

std::string xAOD::AuxInfoBase::m_name

privateinherited

Name of the container in memory. Set externally.

Definition at line 216 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 206 of file AuxInfoBase.h.

m_store

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

privateinherited

Internal dynamic auxiliary store object.

Definition at line 202 of file AuxInfoBase.h.

m_storeIO

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

privateinherited

The IO interface to the internal auxiliary store.

Definition at line 204 of file AuxInfoBase.h.

m_vecs

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

privateinherited

Internal list of all managed variables.

Definition at line 199 of file AuxInfoBase.h.

numberOfBunches

uint32_t xAOD::CTPResultAuxInfo_v1::numberOfBunches

private

Definition at line 36 of file CTPResultAuxInfo_v1.h.

numDataWords

uint32_t xAOD::CTPResultAuxInfo_v1::numDataWords

private

Definition at line 65 of file CTPResultAuxInfo_v1.h.

numStatusWords

uint32_t xAOD::CTPResultAuxInfo_v1::numStatusWords

private

Definition at line 64 of file CTPResultAuxInfo_v1.h.

runNumber

uint32_t xAOD::CTPResultAuxInfo_v1::runNumber

private

Definition at line 45 of file CTPResultAuxInfo_v1.h.

sourceID

uint32_t xAOD::CTPResultAuxInfo_v1::sourceID

private

Definition at line 44 of file CTPResultAuxInfo_v1.h.

statusPosition

uint32_t xAOD::CTPResultAuxInfo_v1::statusPosition

private

Definition at line 66 of file CTPResultAuxInfo_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 199 of file IAuxStore.h.

tapWords

std::vector< std::vector<uint32_t> > xAOD::CTPResultAuxInfo_v1::tapWords

private

Definition at line 57 of file CTPResultAuxInfo_v1.h.

tavWords

std::vector< std::vector<uint32_t> > xAOD::CTPResultAuxInfo_v1::tavWords

private

Definition at line 58 of file CTPResultAuxInfo_v1.h.

tbpWords

std::vector< std::vector<uint32_t> > xAOD::CTPResultAuxInfo_v1::tbpWords

private

Definition at line 56 of file CTPResultAuxInfo_v1.h.

timeNanoSec

uint32_t xAOD::CTPResultAuxInfo_v1::timeNanoSec

private

Definition at line 52 of file CTPResultAuxInfo_v1.h.

timeSec

uint32_t xAOD::CTPResultAuxInfo_v1::timeSec

private

Definition at line 53 of file CTPResultAuxInfo_v1.h.

tipWords

std::vector< std::vector<uint32_t> > xAOD::CTPResultAuxInfo_v1::tipWords

private

Definition at line 55 of file CTPResultAuxInfo_v1.h.

triggerType

uint32_t xAOD::CTPResultAuxInfo_v1::triggerType

private

Definition at line 48 of file CTPResultAuxInfo_v1.h.

turnCounter

uint32_t xAOD::CTPResultAuxInfo_v1::turnCounter

private

Definition at line 54 of file CTPResultAuxInfo_v1.h.

---

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

• CTPResultAuxInfo_v1.h
• CTPResultAuxInfo_v1.cxx