ATLAS Offline Software
Public Types | Public Member Functions | Static Public Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
xAOD::EventInfoAuxContainer_v1 Class Referenceabstract

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...
 
template<class T , class ALLOC = std::allocator<T>>
using LinkedVariable_t = AuxVariable_t< T, ALLOC >
 
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 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 , typename ALLOC >
auxid_t getAuxID (const std::string &name, std::vector< T, ALLOC > &, 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 >
auxid_t getAuxID (const std::string &name, SG::PackedContainer< 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 , 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 195 of file AuxContainerBase.h.

◆ guard_t

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

Definition at line 247 of file AuxContainerBase.h.

◆ LinkedVariable_t

template<class T , class ALLOC = std::allocator<T>>
using xAOD::AuxContainerBase::LinkedVariable_t = AuxVariable_t<T, ALLOC>
inherited

Definition at line 197 of file AuxContainerBase.h.

◆ mutex_t

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

Mutex for multithread synchronization.

Definition at line 246 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.

66  {
67  AST_ObjectStore = 0,
68  AST_ContainerStore = 1
69  };

Constructor & Destructor Documentation

◆ EventInfoAuxContainer_v1()

xAOD::EventInfoAuxContainer_v1::EventInfoAuxContainer_v1 ( )

Default constructor.

Definition at line 10 of file EventInfoAuxContainer_v1.cxx.

11  : AuxContainerBase(),
12  m_decorFlags (SG::auxid_set_size_hint)
13  {
14 
15  // Basic event information:
16  AUX_VARIABLE( runNumber );
17  AUX_VARIABLE( eventNumber );
18  AUX_VARIABLE( lumiBlock );
19  AUX_VARIABLE( timeStamp );
20  AUX_VARIABLE( timeStampNSOffset );
21  AUX_VARIABLE( bcid );
22  AUX_VARIABLE( detectorMask0 );
23  AUX_VARIABLE( detectorMask1 );
24  AUX_VARIABLE( detectorMask2 );
25  AUX_VARIABLE( detectorMask3 );
26 
27  // Event type information:
28  AUX_VARIABLE( detDescrTags );
29  AUX_VARIABLE( eventTypeBitmask );
30 
31  // Detector flags:
32 #define DET_FLAG(VAR) \
33  AUX_VARIABLE( VAR, SG::AuxTypeRegistry::Flags::Atomic ); \
34  do { \
35  static const auxid_t auxid = \
36  getAuxID( #VAR, VAR, \
37  SG::AuxTypeRegistry::Flags::Atomic ); \
38  m_decorFlags.insert( auxid ); \
39  } while( false )
40 
41  DET_FLAG( pixelFlags );
42  DET_FLAG( sctFlags );
43  DET_FLAG( trtFlags );
44  DET_FLAG( larFlags );
45  DET_FLAG( tileFlags );
46  DET_FLAG( muonFlags );
47  DET_FLAG( forwardDetFlags );
48  DET_FLAG( coreFlags );
49  DET_FLAG( backgroundFlags );
50  DET_FLAG( lumiFlags );
51 #undef DET_FLAG
52 
53  // MC information:
54  AUX_VARIABLE( mcChannelNumber );
55  AUX_VARIABLE( mcEventNumber );
56  AUX_VARIABLE( mcEventWeights );
57 
58  // Pileup information:
59  AUX_VARIABLE( pileUpMixtureIDLowBits );
60  AUX_VARIABLE( pileUpMixtureIDHighBits );
61  }

Member Function Documentation

◆ clearDecorations()

bool xAOD::AuxContainerBase::clearDecorations ( )
overridevirtualinherited

Clear all decorations.

Implements SG::IConstAuxStore.

Definition at line 357 of file AuxContainerBase.cxx.

357  {
358 
359  // Guard against multi-threaded execution:
360  guard_t guard( m_mutex );
361 
362  // Clear the decorations from the dynamic store:
363  bool anycleared = false;
364  if( m_store ) {
365  anycleared = m_store->clearDecorations();
366  }
367  // Early exit if there were no decorations.
368  if (!anycleared) return false;
369 
370  // Construct the list of managed auxiliary variables from scratch after
371  // the cleanup:
372  auxid_set_t ids;
373  for( auxid_t auxid = 0; auxid < m_vecs.size(); ++auxid ) {
374  if( m_vecs[ auxid ] ) {
375  ids.insert( auxid );
376  }
377  }
378  if( m_store ) {
379  ids.insert (m_store->getAuxIDs());
380  }
381  m_auxids = ids;
382 
383  return true;
384  }

◆ getAuxID() [1/2]

template<typename T >
auxid_t xAOD::AuxContainerBase::getAuxID ( const std::string &  name,
SG::PackedContainer< 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.

◆ 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,
const SG::auxid_t  linkedVariable = SG::null_auxid 
)
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 275 of file AuxContainerBase.cxx.

275  {
276 
277  // Return the full list of IDs:
278  return getWritableAuxIDs();
279  }

◆ 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 230 of file AuxContainerBase.cxx.

230  {
231 
232  const SG::IAuxTypeVector* v = getVector( auxid );
233  if( v ) {
234  return v->toPtr();
235  }
236  return nullptr;
237  }

◆ 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 462 of file AuxContainerBase.cxx.

463  {
464 
465  // Guard against multi-threaded execution:
466  guard_t guard( m_mutex );
467 
468  if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
469 
470  if( m_store ) {
471  void* result = m_store->getData( auxid, size, capacity );
472  if( result ) {
473  m_auxids.insert( auxid );
474  const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
475  auxid_t linked_id = r.linkedVariable( auxid );
476  if (linked_id != SG::null_auxid) {
477  m_auxids.insert( linked_id );
478  }
479  }
480  return result;
481  } else {
482  std::cout << "ERROR xAOD::AuxContainerBase::getData "
483  << "Unknown variable ("
484  << SG::AuxTypeRegistry::instance().getName( auxid )
485  << ") requested" << std::endl;
486  return nullptr;
487  }
488  }
489  m_vecs[ auxid ]->reserve( capacity );
490  if (m_vecs[ auxid ]->size() < size) {
491  m_vecs[ auxid ]->resize( size );
492  }
493 
494  return m_vecs[ auxid ]->toPtr();
495  }

◆ 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
auxidThe identifier of the desired aux data item.
sizeThe current size of the container (in case the data item does not already exist).
capacityThe 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.

74  {
75  if (m_decorFlags.test (auxid)) {
76  return AuxContainerBase::getData (auxid, size, capacity);
77  }
78 
79  return AuxContainerBase::getDecoration (auxid, size, capacity);
80  }

◆ getDecorIDs()

const AuxContainerBase::auxid_set_t & xAOD::AuxContainerBase::getDecorIDs ( ) const
overridevirtualinherited

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

Implements SG::IConstAuxStore.

Definition at line 282 of file AuxContainerBase.cxx.

282  {
283 
284  if( m_store ) {
285  return m_store->getDecorIDs();
286  }
287  static const auxid_set_t empty;
288  return empty;
289  }

◆ 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 701 of file AuxContainerBase.cxx.

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

◆ 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 659 of file AuxContainerBase.cxx.

659  {
660 
661  // Guard against multi-threaded execution:
662  guard_t guard( m_mutex );
663 
664  // If the variable is not static, look for it in the dynamic store:
665  if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
666  if( m_storeIO ) {
667  return m_storeIO->getIOData( auxid );
668  } else {
669  std::cout << "ERROR xAOD::AuxContainerBase::getIOData "
670  << "Unknown variable ("
671  << SG::AuxTypeRegistry::instance().getName( auxid )
672  << ") requested" << std::endl;
673  return nullptr;
674  }
675  }
676 
677  // Update the statistics for this variable. The dynamic store registers
678  // its own variable accesses.
679  IOStats::instance().stats().readBranch( m_name, auxid );
680 
681  return m_vecs[ auxid ]->toVector();
682  }

◆ 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 684 of file AuxContainerBase.cxx.

684  {
685 
686  // Guard against multi-threaded execution:
687  guard_t guard( m_mutex );
688 
689  // If the variable is not static, ask the dynamic store:
690  if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
691  if( m_storeIO ) {
692  return m_storeIO->getIOType( auxid );
693  }
694  }
695 
696  // Fall back on getting the information from the registry:
697  return SG::AuxTypeRegistry::instance().getVecType( auxid );
698  }

◆ 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 721 of file AuxContainerBase.cxx.

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

◆ getStore() [1/2]

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

Implements SG::IAuxStoreHolder.

Definition at line 181 of file AuxContainerBase.cxx.

182  {
183  return m_store;
184  }

◆ getStore() [2/2]

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

Get the currently used internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 154 of file AuxContainerBase.cxx.

155  {
156  return m_store;
157  }

◆ 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.

92 { return AST_ContainerStore; }

◆ getVector()

const SG::IAuxTypeVector * xAOD::AuxContainerBase::getVector ( SG::auxid_t  auxid) const
finaloverridevirtualinherited

Return vector interface for one aux data item.

Implements SG::IConstAuxStore.

Definition at line 239 of file AuxContainerBase.cxx.

239  {
240 
241  // Guard against multi-threaded execution:
242  guard_t guard( m_mutex );
243 
244  if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
245  if( m_store ) {
246  const SG::IAuxTypeVector* result = m_store->getVector( auxid );
247  if( result ) {
248  auxid_set_t& auxids_nc ATLAS_THREAD_SAFE =
249  const_cast<auxid_set_t&> (m_auxids);
250  auxids_nc.insert( auxid );
251  const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
252  auxid_t linked_id = r.linkedVariable( auxid );
253  if (linked_id != SG::null_auxid) {
254  auxids_nc.insert( linked_id );
255  }
256  }
257  return result;
258  } else {
259  std::cout << "ERROR xAOD::AuxContainerBase::getData "
260  << "Unknown variable ("
261  << SG::AuxTypeRegistry::instance().getName( auxid )
262  << ") requested" << std::endl;
263  return nullptr;
264  }
265  }
266 
267  // Update the statistics for this variable. The dynamic store registers
268  // its own variable accesses.
269  IOStats::instance().stats().readBranch( m_name, auxid );
270 
271  return m_vecs[ auxid ];
272  }

◆ getWritableAuxIDs()

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

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 498 of file AuxContainerBase.cxx.

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

◆ 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 584 of file AuxContainerBase.cxx.

586  {
587  // Guard against multi-threaded execution:
588  guard_t guard( m_mutex );
589 
590  // This operation is not allowed on a locked container:
591  if( m_locked ) {
592  throw SG::ExcStoreLocked( "insertMove" );
593  }
594 
595  bool nomove = true;
596  size_t other_size = other.size();
597 
598  SG::auxid_set_t ignore = ignore_in;
599 
600  // Do the operation on the static variables:
601  for (SG::auxid_t id : m_auxids) {
602  SG::IAuxTypeVector* v_dst = nullptr;
603  if (id < m_vecs.size())
604  v_dst = m_vecs[id];
605  // Skip linked vars --- they should be taken care of by the parent var.
606  if (v_dst && !v_dst->isLinked()) {
607  ignore.insert (id);
608  if (other.getData (id)) {
609  void* src_ptr = other.getData (id, other_size, other_size);
610  if (src_ptr) {
611  if (!v_dst->insertMove (pos, src_ptr, 0, other_size,
612  other))
613  nomove = false;
614  }
615  }
616  else {
617  const void* orig = v_dst->toPtr();
618  v_dst->shift (pos, other_size);
619  if (orig != v_dst->toPtr())
620  nomove = false;
621  }
622  }
623  }
624 
625  // Do the operation on the dynamic variables:
626  if( m_store ) {
627  if (!m_store->insertMove( pos, other, ignore ))
628  nomove = false;
629 
630  // Notice any new variables added as a result of this.
631  m_auxids.insert (m_store->getAuxIDs());
632  }
633 
634  return nomove;
635  }

◆ 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
posThe starting index of the insertion.
otherStore from which to do the move.
ignoreSet 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
auxidThe identifier of the desired aux data item.

Reimplemented from xAOD::AuxContainerBase.

Definition at line 87 of file EventInfoAuxContainer_v1.cxx.

88  {
89  if (m_decorFlags.test (auxid)) {
90  return true;
91  }
92 
93  return AuxContainerBase::isDecoration (auxid);
94  }

◆ linkedVector() [1/3]

const SG::IAuxTypeVector * xAOD::AuxContainerBase::linkedVector ( SG::auxid_t  auxid) const
overridevirtualinherited

Return interface for a linked variable.

Reimplemented from SG::IConstAuxStore.

Definition at line 396 of file AuxContainerBase.cxx.

397  {
398  const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
399  auxid_t linked_id = r.linkedVariable( auxid );
400  if (linked_id != SG::null_auxid) {
401  guard_t guard( m_mutex );
402  if (linked_id < m_vecs.size() && m_vecs[ linked_id ]) {
403  return m_vecs[ linked_id ];
404  }
405  if (m_store) {
406  return CxxUtils::as_const_ptr(m_store)->linkedVector( auxid );
407  }
408  }
409  return nullptr;
410  }

◆ linkedVector() [2/3]

SG::IAuxTypeVector * xAOD::AuxContainerBase::linkedVector ( SG::auxid_t  auxid)
overridevirtualinherited

Return interface for a linked variable.

Reimplemented from SG::IAuxStore.

Definition at line 413 of file AuxContainerBase.cxx.

414  {
415  const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
416  auxid_t linked_id = r.linkedVariable( auxid );
417  if (linked_id != SG::null_auxid) {
418  guard_t guard( m_mutex );
419  if (linked_id < m_vecs.size() && m_vecs[ linked_id ]) {
420  return m_vecs[ linked_id ];
421  }
422  if (m_store) {
423  return m_store->linkedVector( auxid );
424  }
425  }
426  return nullptr;
427  }

◆ linkedVector() [3/3]

virtual const IAuxTypeVector* SG::IConstAuxStore::linkedVector
inlineinherited

Return interface for a linked variable.

Parameters
auxidThe 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.

190  { return nullptr; }

◆ lock()

void xAOD::AuxContainerBase::lock ( )
overridevirtualinherited

Lock the container.

Implements ILockable.

Definition at line 343 of file AuxContainerBase.cxx.

343  {
344 
345  // Guard against multi-threaded execution:
346  guard_t guard( m_mutex );
347 
348  // Lock the object and its dynamic store:
349  m_locked = true;
350  if( m_store ) {
351  m_store->lock();
352  }
353 
354  return;
355  }

◆ lockDecoration()

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

Lock a decoration.

Parameters
auxidIdentifier of the decoration to lock.

Reimplemented from xAOD::AuxContainerBase.

Definition at line 101 of file EventInfoAuxContainer_v1.cxx.

102  {
103  if (m_decorFlags.test (auxid)) {
104  m_decorFlags.reset (auxid);
105  return;
106  }
107 
108  AuxContainerBase::lockDecoration (auxid);
109  }

◆ memResource()

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

Return the memory resource to use.

Definition at line 159 of file AuxContainerBase.cxx.

160  {
161  const std::pmr::memory_resource* cptr = m_memResource.get();
162  std::pmr::memory_resource* ptr ATLAS_THREAD_SAFE = const_cast<std::pmr::memory_resource*>( cptr );
163  if( !ptr ) {
164 #ifndef XAOD_STANDALONE
165  const EventContext& ctx = Gaudi::Hive::currentContext();
166  if( Atlas::hasExtendedEventContext( ctx ) ) {
167  ptr = Atlas::getExtendedEventContext( ctx ).memResource();
168  }
169  if( !ptr )
170 #endif
171  {
172  ptr = std::pmr::get_default_resource();
173  }
174  if( ptr ) {
175  m_memResource.set( ptr );
176  }
177  }
178  return ptr;
179  }

◆ name()

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

Get the name of the container instance.

Definition at line 743 of file AuxContainerBase.cxx.

743  {
744 
745  return m_name.c_str();
746  }

◆ 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 533 of file AuxContainerBase.cxx.

533  {
534 
535  // Guard against multi-threaded execution:
536  guard_t guard( m_mutex );
537 
538  // This operation is not allowed on a locked container:
539  if( m_locked ) {
540  throw SG::ExcStoreLocked( "reserve" );
541  }
542 
543  // Do the operation on the static variables:
544  for (SG::IAuxTypeVector* v : m_vecs) {
545  if(v && !v->isLinked()) {
546  v->reserve( size );
547  }
548  }
549 
550  // Do the operation on the dynamic variables:
551  if( m_store ) {
552  m_store->reserve( size );
553  }
554 
555  return;
556  }

◆ resize()

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

Resize the arrays to a given size.

Implements SG::IAuxStore.

Definition at line 505 of file AuxContainerBase.cxx.

505  {
506 
507  // Guard against multi-threaded execution:
508  guard_t guard( m_mutex );
509 
510  // This operation is not allowed on a locked container:
511  if( m_locked ) {
512  throw SG::ExcStoreLocked( "resize" );
513  }
514 
515  // Do the operation on the static variables:
516  bool nomoves = true;
517  for (SG::IAuxTypeVector* v : m_vecs) {
518  if(v && !v->isLinked()) {
519  if (!v->resize( size ))
520  nomoves = false;
521  }
522  }
523 
524  // Do the operation on the dynamic variables:
525  if( m_store ) {
526  if (!m_store->resize( size ))
527  nomoves = false;
528  }
529 
530  return nomoves;
531  }

◆ setName()

void xAOD::AuxContainerBase::setName ( const char *  name)
inherited

Set the name of the container instance.

Definition at line 748 of file AuxContainerBase.cxx.

748  {
749 
750  m_name = name;
751  return;
752  }

◆ 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 638 of file AuxContainerBase.cxx.

639  {
640 
641  guard_t guard (m_mutex);
642  if (id < m_vecs.size() && m_vecs[id] != nullptr)
643  return m_vecs[id]->setOption (option);
644 
645  if (m_store)
646  return m_store->setOption (id, option);
647  return false;
648  }

◆ 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
storeThe store that should be used for dynamic variable handling inside the object from now on

Implements SG::IAuxStoreHolder.

Definition at line 195 of file AuxContainerBase.cxx.

195  {
196 
197  // Guard against multi-threaded execution:
198  guard_t guard( m_mutex );
199 
200  // Check that no funny business is going on:
201  if( m_store == store ) return;
202 
203  // Clean up the current store object:
204  if( m_store && m_ownsStore ) {
205  m_auxids -= m_store->getAuxIDs();
206  delete m_store;
207  }
208  m_store = nullptr;
209  m_storeIO = nullptr;
210 
211  // Take posession of the new object:
212  m_store = store;
213  m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
214  m_ownsStore = true;
215  if( m_store ) {
216  m_auxids.insert (m_store->getAuxIDs());
217  }
218 
219  return;
220  }

◆ 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 558 of file AuxContainerBase.cxx.

558  {
559 
560  // Guard against multi-threaded execution:
561  guard_t guard( m_mutex );
562 
563  // This operation is not allowed on a locked container:
564  if( m_locked ) {
565  throw SG::ExcStoreLocked( "shift" );
566  }
567 
568  // Do the operation on the static variables:
569  for (SG::IAuxTypeVector* v : m_vecs) {
570  if(v && !v->isLinked()) {
571  v->shift( pos, offs );
572  }
573  }
574 
575  // Do the operation on the dynamic variables:
576  if( m_store ) {
577  m_store->shift( pos, offs );
578  }
579 
580  return;
581  }

◆ size()

size_t xAOD::AuxContainerBase::size ( ) const
overridevirtualinherited

Get the size of the container.

Implements SG::IConstAuxStore.

Definition at line 430 of file AuxContainerBase.cxx.

430  {
431 
432  // Guard against multi-threaded execution:
433  guard_t guard (m_mutex);
434 
435  // Try to find a variable:
436  for (SG::auxid_t i : m_auxids) {
437  if( ( i < m_vecs.size() ) && m_vecs[ i ] && !m_vecs[ i ]->isLinked()) {
438  size_t sz = m_vecs[ i ]->size();
439  if( sz > 0 ) {
440  return sz;
441  }
442  }
443  }
444 
445  // If we didn't find any, let's ask the dynamic store:
446  if( m_store ) {
447  return m_store->size();
448  }
449 
450  // If we don't have any variables, then the size must be null:
451  return 0;
452  }

◆ 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.

118  {
120  static const std::vector<SG::auxid_t> flagIds (m_decorFlags.begin(),
121  m_decorFlags.end());
122 
123  // Check each detector flag. If it has been set to something,
124  // then lock this flag.
125  // This check may be too strict; we'll have to see.
126  size_t sz = size();
127  for (SG::auxid_t id : flagIds) {
128  const uint32_t* flags = reinterpret_cast<const uint32_t*>(getData (id, sz, sz));
129  for (size_t i = 0; i < sz; i++) {
130  if (flags[i] != 0) {
131  m_decorFlags.reset (id);
132  break;
133  }
134  }
135  }
136  }

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 254 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 232 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 243 of file AuxContainerBase.h.

◆ m_mutex

mutex_t xAOD::AuxContainerBase::m_mutex
mutableprivateinherited

Definition at line 248 of file AuxContainerBase.h.

◆ m_name

std::string xAOD::AuxContainerBase::m_name
privateinherited

Name of the container in memory. Set externally.

Definition at line 251 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 241 of file AuxContainerBase.h.

◆ m_store

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

Internal dynamic auxiliary store object.

Definition at line 237 of file AuxContainerBase.h.

◆ m_storeIO

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

The IO interface to the internal auxiliary store.

Definition at line 239 of file AuxContainerBase.h.

◆ m_vecs

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

Internal list of all managed variables.

Definition at line 234 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 199 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:
xAOD::EventInfoAuxContainer_v1::pixelFlags
std::vector< uint32_t > pixelFlags
Definition: EventInfoAuxContainer_v1.h:96
xAOD::AuxContainerBase::m_name
std::string m_name
Name of the container in memory. Set externally.
Definition: AuxContainerBase.h:251
SG::IAuxTypeVector::shift
virtual bool shift(size_t pos, ptrdiff_t offs)=0
Shift the elements of the vector.
SG::IAuxTypeVector::isLinked
bool isLinked() const
Return true if this variable is linked from another one.
Definition: IAuxTypeVector.h:226
SGTest::store
TestStore store
Definition: TestStore.cxx:23
beamspotman.r
def r
Definition: beamspotman.py:676
xAOD::EventInfoAuxContainer_v1::mcEventNumber
std::vector< uint64_t > mcEventNumber
Definition: EventInfoAuxContainer_v1.h:111
DET_FLAG
#define DET_FLAG(VAR)
xAOD::AuxContainerBase::name
const char * name() const
Get the name of the container instance.
Definition: AuxContainerBase.cxx:743
xAOD::EventInfoAuxContainer_v1::eventTypeBitmask
std::vector< uint32_t > eventTypeBitmask
Definition: EventInfoAuxContainer_v1.h:91
SG::IAuxStore::insertMove
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.
xAOD::EventInfoAuxContainer_v1::pileUpMixtureIDLowBits
std::vector< uint64_t > pileUpMixtureIDLowBits
Definition: EventInfoAuxContainer_v1.h:117
xAOD::EventInfoAuxContainer_v1::detectorMask3
std::vector< uint32_t > detectorMask3
Definition: EventInfoAuxContainer_v1.h:84
fitman.sz
sz
Definition: fitman.py:527
get_generator_info.result
result
Definition: get_generator_info.py:21
xAOD::EventInfoAuxContainer_v1::backgroundFlags
std::vector< uint32_t > backgroundFlags
Definition: EventInfoAuxContainer_v1.h:104
SG::IConstAuxStore::getVector
virtual const IAuxTypeVector * getVector(SG::auxid_t auxid) const =0
Return vector interface for one aux data item.
xAOD::EventInfoAuxContainer_v1::m_decorFlags
CxxUtils::ConcurrentBitset m_decorFlags
Keep track of the event status flags.
Definition: EventInfoAuxContainer_v1.h:125
xAOD::IOStats::stats
ReadStats & stats()
Access the object belonging to the current thread.
Definition: IOStats.cxx:17
SG::AuxTypeRegistry::instance
static AuxTypeRegistry & instance()
Return the singleton registry instance.
Definition: AuxTypeRegistry.cxx:639
xAOD::AuxContainerBase::m_store
SG::IAuxStore * m_store
Internal dynamic auxiliary store object.
Definition: AuxContainerBase.h:237
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
AthenaPoolTestRead.flags
flags
Definition: AthenaPoolTestRead.py:8
SG::AuxTypeRegistry::getName
std::string getName(SG::auxid_t auxid) const
Return the name of an aux data item.
Definition: AuxTypeRegistry.cxx:881
xAOD::AuxContainerBase::guard_t
AthContainers_detail::lock_guard< mutex_t > guard_t
Definition: AuxContainerBase.h:247
CxxUtils::ConcurrentBitset::end
const_iterator end() const
Return an end iterator.
SG::ExcStoreLocked
Exception — Attempted to modify auxiliary data in a locked store.
Definition: Control/AthContainers/AthContainers/exceptions.h:183
Atlas::hasExtendedEventContext
bool hasExtendedEventContext(const EventContext &ctx)
Test whether a context object has an extended context installed.
Definition: ExtendedEventContext.cxx:23
xAOD::AuxContainerBase::isDecoration
virtual bool isDecoration(auxid_t auxid) const override
Test if a variable is a decoration.
Definition: AuxContainerBase.cxx:291
xAOD::EventInfoAuxContainer_v1::eventNumber
std::vector< uint64_t > eventNumber
Definition: EventInfoAuxContainer_v1.h:76
xAOD::other
@ other
Definition: TrackingPrimitives.h:509
SG::IAuxTypeVector::insertMove
virtual bool insertMove(size_t pos, void *src, size_t src_pos, size_t src_n, IAuxStore &srcStore)=0
Insert elements into the vector via move semantics.
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
SG::IAuxStoreIO::getIOType
virtual const std::type_info * getIOType(SG::auxid_t auxid) const =0
Return the type of the data to be stored for one aux data item.
xAOD::AuxContainerBase::m_mutex
mutex_t m_mutex
Definition: AuxContainerBase.h:248
empty
bool empty(TH1 *h)
Definition: computils.cxx:295
SG::IConstAuxStore::size
virtual size_t size() const =0
Return the number of elements in the store.
SG::IAuxStore::shift
virtual void shift(size_t pos, ptrdiff_t offs)=0
Shift the elements of the container.
SG::IAuxStore::linkedVector
virtual IAuxTypeVector * linkedVector(SG::auxid_t)
Definition: IAuxStore.h:187
SG::IAuxStoreIO
Interface providing I/O for a generic auxiliary store.
Definition: IAuxStoreIO.h:44
xAOD::EventInfoAuxContainer_v1::detectorMask2
std::vector< uint32_t > detectorMask2
Definition: EventInfoAuxContainer_v1.h:83
SG::AuxTypeRegistry
Handle mappings between names and auxid_t.
Definition: AuxTypeRegistry.h:61
xAOD::EventInfoAuxContainer_v1::runNumber
std::vector< uint32_t > runNumber
Definition: EventInfoAuxContainer_v1.h:75
Atlas::getExtendedEventContext
const ExtendedEventContext & getExtendedEventContext(const EventContext &ctx)
Retrieve an extended context from a context object.
Definition: ExtendedEventContext.cxx:32
xAOD::AuxContainerBase::size
virtual size_t size() const override
Get the size of the container.
Definition: AuxContainerBase.cxx:430
DiTauMassTools::ignore
void ignore(T &&)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:58
SG::IAuxStore::setOption
virtual bool setOption(auxid_t, const AuxDataOption &)
Set an option for a given auxiliary variable.
Definition: IAuxStore.h:173
SG::auxid_t
size_t auxid_t
Identifier for a particular aux data item.
Definition: AuxTypes.h:27
xAOD::EventInfoAuxContainer_v1::coreFlags
std::vector< uint32_t > coreFlags
Definition: EventInfoAuxContainer_v1.h:103
xAOD::EventInfoAuxContainer_v1::timeStampNSOffset
std::vector< uint32_t > timeStampNSOffset
Definition: EventInfoAuxContainer_v1.h:79
SG::IConstAuxStore::clearDecorations
virtual bool clearDecorations()=0
Clear all decorations.
xAOD::EventInfoAuxContainer_v1::lumiFlags
std::vector< uint32_t > lumiFlags
Definition: EventInfoAuxContainer_v1.h:105
xAOD::AuxContainerBase::auxid_set_t
SG::auxid_set_t auxid_set_t
The aux ID set type definition.
Definition: AuxContainerBase.h:65
xAOD::AuxContainerBase::m_auxids
auxid_set_t m_auxids
Internal list of all available variables.
Definition: AuxContainerBase.h:232
xAOD::AuxContainerBase::m_vecs
std::vector< SG::IAuxTypeVector * > m_vecs
Internal list of all managed variables.
Definition: AuxContainerBase.h:234
lumiFormat.i
int i
Definition: lumiFormat.py:85
CxxUtils::ConcurrentBitset::insert
ConcurrentBitset & insert(bit_t bit, bit_t new_nbits=0)
Set a bit to 1.
AUX_VARIABLE
#define AUX_VARIABLE(VAR,...)
Convenience macro for declaring an auxiliary variable.
Definition: AuxVariable.h:23
xAOD::EventInfoAuxContainer_v1::mcEventWeights
std::vector< std::vector< float > > mcEventWeights
Definition: EventInfoAuxContainer_v1.h:112
xAOD::EventInfoAuxContainer_v1::pileUpMixtureIDHighBits
std::vector< uint64_t > pileUpMixtureIDHighBits
Definition: EventInfoAuxContainer_v1.h:118
CxxUtils::ConcurrentBitset::reset
ConcurrentBitset & reset(bit_t bit)
Turn off one bit.
xAOD::EventInfoAuxContainer_v1::sctFlags
std::vector< uint32_t > sctFlags
Definition: EventInfoAuxContainer_v1.h:97
python.xAODType.dummy
dummy
Definition: xAODType.py:4
SG::AuxTypeRegistry::getVecType
const std::type_info * getVecType(SG::auxid_t auxid) const
Return the type of the STL vector used to hold an aux data item.
Definition: AuxTypeRegistry.cxx:936
xAOD::AuxContainerBase::getDecoration
virtual void * getDecoration(auxid_t auxid, size_t size, size_t capacity) override
Get a pointer to a given array, as a decoration.
Definition: AuxContainerBase.cxx:300
xAOD::IOStats::instance
static IOStats & instance()
Singleton object accessor.
Definition: IOStats.cxx:11
CxxUtils::ConcurrentBitset::begin
const_iterator begin() const
Return a begin iterator.
xAOD::EventInfoAuxContainer_v1::timeStamp
std::vector< uint32_t > timeStamp
Definition: EventInfoAuxContainer_v1.h:78
xAOD::EventInfoAuxContainer_v1::detectorMask0
std::vector< uint32_t > detectorMask0
Definition: EventInfoAuxContainer_v1.h:81
xAOD::EventInfoAuxContainer_v1::mcChannelNumber
std::vector< uint32_t > mcChannelNumber
Definition: EventInfoAuxContainer_v1.h:110
xAOD::EventInfoAuxContainer_v1::detectorMask1
std::vector< uint32_t > detectorMask1
Definition: EventInfoAuxContainer_v1.h:82
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:227
python.subdetectors.mmg.ids
ids
Definition: mmg.py:8
xAOD::EventInfoAuxContainer_v1::larFlags
std::vector< uint32_t > larFlags
Definition: EventInfoAuxContainer_v1.h:99
xAOD::AuxContainerBase::getVector
virtual const SG::IAuxTypeVector * getVector(SG::auxid_t auxid) const override final
Return vector interface for one aux data item.
Definition: AuxContainerBase.cxx:239
CxxUtils::as_const_ptr
const T * as_const_ptr(const T *p)
Helper for getting a const version of a pointer.
Definition: as_const_ptr.h:32
xAOD::EventInfoAuxContainer_v1::muonFlags
std::vector< uint32_t > muonFlags
Definition: EventInfoAuxContainer_v1.h:101
xAOD::EventInfoAuxContainer_v1::detDescrTags
std::vector< std::vector< std::pair< std::string, std::string > > > detDescrTags
Definition: EventInfoAuxContainer_v1.h:90
xAOD::AuxContainerBase::getWritableAuxIDs
virtual const auxid_set_t & getWritableAuxIDs() const override
Return a set of writable data identifiers.
Definition: AuxContainerBase.cxx:498
SG::IAuxStoreIO::getIOData
virtual const void * getIOData(SG::auxid_t auxid) const =0
Return a pointer to the data to be stored for one aux data item.
xAOD::AuxContainerBase::getData
virtual const void * getData(auxid_t auxid) const override
Get a pointer to a given array.
Definition: AuxContainerBase.cxx:230
xAOD::ReadStats::readBranch
void readBranch(const std::string &prefix, SG::auxid_t auxid)
Function incrementing the read counter on a specific branch.
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
xAOD::AuxContainerBase::auxid_t
SG::auxid_t auxid_t
The aux ID type definition.
Definition: AuxContainerBase.h:63
python.PyAthena.v
v
Definition: PyAthena.py:154
xAOD::AuxContainerBase::ATLAS_THREAD_SAFE
CxxUtils::CachedPointer< std::pmr::memory_resource > m_memResource ATLAS_THREAD_SAFE
Memory resource to use for this container.
Definition: AuxContainerBase.h:254
xAOD::EventInfoAuxContainer_v1::tileFlags
std::vector< uint32_t > tileFlags
Definition: EventInfoAuxContainer_v1.h:100
SG::IAuxStore::getData
virtual void * getData(auxid_t auxid, size_t size, size_t capacity)=0
Return the data vector for one aux data item.
xAOD::EventInfoAuxContainer_v1::lumiBlock
std::vector< uint32_t > lumiBlock
Definition: EventInfoAuxContainer_v1.h:77
xAOD::AuxContainerBase::m_locked
bool m_locked
Has the container been locked?
Definition: AuxContainerBase.h:243
SG::IAuxTypeVector
Abstract interface for manipulating vectors of arbitrary types.
Definition: IAuxTypeVector.h:42
xAOD::AuxContainerBase::lockDecoration
virtual void lockDecoration(SG::auxid_t auxid) override
Lock a decoration.
Definition: AuxContainerBase.cxx:387
xAOD::AuxContainerBase::m_ownsStore
bool m_ownsStore
Flag deciding if the object owns the dynamic store or not.
Definition: AuxContainerBase.h:241
SG::IConstAuxStore::getDecorIDs
virtual const SG::auxid_set_t & getDecorIDs() const =0
Return a set of identifiers for decorations in this store.
xAOD::EventInfoAuxContainer_v1::trtFlags
std::vector< uint32_t > trtFlags
Definition: EventInfoAuxContainer_v1.h:98
SG::IConstAuxStore::lock
virtual void lock()=0
Lock the container.
xAOD::AuxContainerBase::m_storeIO
SG::IAuxStoreIO * m_storeIO
The IO interface to the internal auxiliary store.
Definition: AuxContainerBase.h:239
xAOD::AuxContainerBase::AuxContainerBase
AuxContainerBase(bool allowDynamicVars=true)
Default constructor.
Definition: AuxContainerBase.cxx:31
SG::IAuxStore::resize
virtual bool resize(size_t sz)=0
Change the size of all aux data vectors.
SG::auxid_set_t
A set of aux data identifiers.
Definition: AuxTypes.h:47
SG::IAuxStoreHolder::AST_ObjectStore
@ AST_ObjectStore
The store describes a single object.
Definition: IAuxStoreHolder.h:67
SG::IConstAuxStore::getAuxIDs
virtual const SG::auxid_set_t & getAuxIDs() const =0
Return a set of identifiers for existing data items in this store.
SG::IAuxTypeVector::toPtr
virtual void * toPtr()=0
Return a pointer to the start of the vector's data.
SG::IAuxStore::reserve
virtual void reserve(size_t sz)=0
Change the capacity of all aux data vectors.
xAOD::EventInfoAuxContainer_v1::bcid
std::vector< uint32_t > bcid
Definition: EventInfoAuxContainer_v1.h:80
SG::IAuxStoreHolder::AST_ContainerStore
@ AST_ContainerStore
The store describes a container.
Definition: IAuxStoreHolder.h:68
xAOD::EventInfoAuxContainer_v1::forwardDetFlags
std::vector< uint32_t > forwardDetFlags
Definition: EventInfoAuxContainer_v1.h:102
CxxUtils::ConcurrentBitset::test
bool test(bit_t bit) const
Test to see if a bit is set.
Generated on Sun Dec 22 2024 22:11:55 for ATLAS Offline Software by   doxygen 1.8.18