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

Auxiliary store for xAOD::RingSetConfContainer. More...

#include <RingSetConfAuxContainer_v1.h>

Inheritance diagram for xAOD::RingSetConfAuxContainer_v1:
Collaboration diagram for xAOD::RingSetConfAuxContainer_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

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

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

xAOD::RingSetConfAuxContainer_v1 constructors

std::vector< unsigned > nRings
 
std::vector< std::vector< unsigned > > layers
 RingSet CaloSample layers used to build this RingSet. More...
 
std::vector< float > etaWidth
 Ring width in eta. More...
 
std::vector< float > phiWidth
 Ring width in phi. More...
 
std::vector< float > cellMaxDEtaDist
 Maximun distance cell in eta to seed. More...
 
std::vector< float > cellMaxDPhiDist
 Maximun distance cell in phi to seed. More...
 
std::vector< unsigned > calJointLayer
 The Calorimeter Joint Layer (see CaloRingsDefs.h) More...
 
std::vector< unsigned > calJointSection
 The Calorimeter Joint Section (see CaloRingsDefs.h) More...
 
std::vector< char > doEtaAxesDivision
 Ring division in eta. More...
 
std::vector< char > doPhiAxesDivision
 Ring division in phi. More...
 
std::vector< unsigned > layerStartIdx
 Hold the start of this layer on a vectorized representation: More...
 
std::vector< unsigned > layerEndIdx
 Hold the end of this layer on a vectorized representation: More...
 
std::vector< unsigned > sectionStartIdx
 Hold the start of this section on a vectorized representation: More...
 
std::vector< unsigned > sectionEndIdx
 Hold the end of this section on a vectorized representation: More...
 
 RingSetConfAuxContainer_v1 ()
 

Detailed Description

Auxiliary store for xAOD::RingSetConfContainer.

Definition at line 17 of file RingSetConfAuxContainer_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

◆ RingSetConfAuxContainer_v1()

xAOD::RingSetConfAuxContainer_v1::RingSetConfAuxContainer_v1 ( )

Ringset number of Rings

RingSet CaloSample layers used to build this RingSet

Ring width in eta

Ring width in phi

Maximun cell distance in eta to seed

Maximun cell distance in phi to seed

The Calorimeter Joint Layer (see CaloRingsDefs.h)

The Calorimeter Joint Section (see CaloRingsDefs.h)

Ring division in eta

Ring division in phi

Hold the start of this layer on a vectorized representation:

Hold the end of this layer on a vectorized representation:

Hold the start of this section on a vectorized representation:

Hold the end of this section on a vectorized representation:

Definition at line 11 of file RingSetConfAuxContainer_v1.cxx.

12  : AuxContainerBase() {
13 
15  AUX_VARIABLE(nRings);
17  AUX_VARIABLE(layers);
19  AUX_VARIABLE(etaWidth);
21  AUX_VARIABLE(phiWidth);
23  AUX_VARIABLE(cellMaxDEtaDist);
25  AUX_VARIABLE(cellMaxDPhiDist);
27  AUX_VARIABLE(calJointLayer);
29  AUX_VARIABLE(calJointSection);
31  AUX_VARIABLE(doEtaAxesDivision);
33  AUX_VARIABLE(doPhiAxesDivision);
35  AUX_VARIABLE(layerStartIdx);
37  AUX_VARIABLE(layerEndIdx);
39  AUX_VARIABLE(sectionStartIdx);
41  AUX_VARIABLE(sectionEndIdx);
42 
43 }

Member Function Documentation

◆ clearDecorations()

bool xAOD::AuxContainerBase::clearDecorations ( )
overridevirtualinherited

Clear all decorations.

Implements SG::IConstAuxStore.

Definition at line 356 of file AuxContainerBase.cxx.

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

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

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

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

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

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

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

◆ getData() [3/3]

virtual const void* SG::IConstAuxStore::getData
inherited

Pick up the const version from the base class.

◆ getDecoration()

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

Definition at line 299 of file AuxContainerBase.cxx.

300  {
301  {
302  // Guard against multi-threaded execution:
303  guard_t guard( m_mutex );
304 
305  // Check if we have it as a static variable:
306  if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
307  // If not, but we have a dynamic store, push it in there:
308  if( m_store ) {
309  void* result = m_store->getDecoration( auxid, size, capacity );
310  if( result ) {
311  m_auxids.insert( auxid );
312  const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
313  auxid_t linked_id = r.linkedVariable( auxid );
314  if (linked_id != SG::null_auxid) {
315  m_auxids.insert( linked_id );
316  }
317  }
318  return result;
319  }
320  // If we don't have a dynamic store, complain:
321  else {
322  std::cout << "ERROR xAOD::AuxContainerBase::getDecoration "
323  << "Can't provide variable "
324  << SG::AuxTypeRegistry::instance().getName( auxid )
325  << std::endl;
326  return nullptr;
327  }
328  }
329 
330  // If the container is locked, static variables can't be accessed this
331  // way:
332  if( m_locked ) {
333  throw SG::ExcStoreLocked( auxid );
334  }
335  }
336 
337  // If the container is not locked, then fall back on the normal accessor
338  // function:
339  return getData( auxid, size, capacity );
340  }

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

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

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

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

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

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

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

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

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

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

◆ getStore() [1/2]

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

Implements SG::IAuxStoreHolder.

Definition at line 180 of file AuxContainerBase.cxx.

181  {
182  return m_store;
183  }

◆ getStore() [2/2]

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

Get the currently used internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 153 of file AuxContainerBase.cxx.

154  {
155  return m_store;
156  }

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

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

◆ getWritableAuxIDs()

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

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 497 of file AuxContainerBase.cxx.

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

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

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

◆ 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::AuxContainerBase::isDecoration ( auxid_t  auxid) const
overridevirtualinherited

Test if a variable is a decoration.

Implements SG::IConstAuxStore.

Reimplemented in xAOD::EventInfoAuxContainer_v1.

Definition at line 290 of file AuxContainerBase.cxx.

291  {
292  guard_t guard( m_mutex );
293  if (m_store) {
294  return m_store->isDecoration (auxid);
295  }
296  return false;
297  }

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

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

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

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

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

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

◆ lockDecoration()

void xAOD::AuxContainerBase::lockDecoration ( SG::auxid_t  auxid)
overridevirtualinherited

Lock a decoration.

Implements SG::IConstAuxStore.

Reimplemented in xAOD::EventInfoAuxContainer_v1.

Definition at line 386 of file AuxContainerBase.cxx.

387  {
388  guard_t guard (m_mutex);
389  if (m_store) {
390  m_store->lockDecoration (auxid);
391  }
392  }

◆ memResource()

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

Return the memory resource to use.

Definition at line 158 of file AuxContainerBase.cxx.

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

◆ name()

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

Get the name of the container instance.

Definition at line 742 of file AuxContainerBase.cxx.

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

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

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

◆ resize()

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

Resize the arrays to a given size.

Implements SG::IAuxStore.

Definition at line 504 of file AuxContainerBase.cxx.

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

◆ setName()

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

Set the name of the container instance.

Definition at line 747 of file AuxContainerBase.cxx.

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

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

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

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

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

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

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

◆ size()

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

Get the size of the container.

Implements SG::IConstAuxStore.

Definition at line 429 of file AuxContainerBase.cxx.

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

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.

◆ calJointLayer

std::vector<unsigned> xAOD::RingSetConfAuxContainer_v1::calJointLayer
private

The Calorimeter Joint Layer (see CaloRingsDefs.h)

Definition at line 40 of file RingSetConfAuxContainer_v1.h.

◆ calJointSection

std::vector<unsigned> xAOD::RingSetConfAuxContainer_v1::calJointSection
private

The Calorimeter Joint Section (see CaloRingsDefs.h)

Definition at line 42 of file RingSetConfAuxContainer_v1.h.

◆ cellMaxDEtaDist

std::vector<float> xAOD::RingSetConfAuxContainer_v1::cellMaxDEtaDist
private

Maximun distance cell in eta to seed.

Definition at line 36 of file RingSetConfAuxContainer_v1.h.

◆ cellMaxDPhiDist

std::vector<float> xAOD::RingSetConfAuxContainer_v1::cellMaxDPhiDist
private

Maximun distance cell in phi to seed.

Definition at line 38 of file RingSetConfAuxContainer_v1.h.

◆ doEtaAxesDivision

std::vector<char> xAOD::RingSetConfAuxContainer_v1::doEtaAxesDivision
private

Ring division in eta.

Definition at line 44 of file RingSetConfAuxContainer_v1.h.

◆ doPhiAxesDivision

std::vector<char> xAOD::RingSetConfAuxContainer_v1::doPhiAxesDivision
private

Ring division in phi.

Definition at line 46 of file RingSetConfAuxContainer_v1.h.

◆ etaWidth

std::vector<float> xAOD::RingSetConfAuxContainer_v1::etaWidth
private

Ring width in eta.

Definition at line 32 of file RingSetConfAuxContainer_v1.h.

◆ layerEndIdx

std::vector<unsigned> xAOD::RingSetConfAuxContainer_v1::layerEndIdx
private

Hold the end of this layer on a vectorized representation:

Definition at line 50 of file RingSetConfAuxContainer_v1.h.

◆ layers

std::vector<std::vector<unsigned> > xAOD::RingSetConfAuxContainer_v1::layers
private

RingSet CaloSample layers used to build this RingSet.

Definition at line 30 of file RingSetConfAuxContainer_v1.h.

◆ layerStartIdx

std::vector<unsigned> xAOD::RingSetConfAuxContainer_v1::layerStartIdx
private

Hold the start of this layer on a vectorized representation:

Definition at line 48 of file RingSetConfAuxContainer_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_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.

◆ nRings

std::vector<unsigned> xAOD::RingSetConfAuxContainer_v1::nRings
private

Ringset number of Rings

Definition at line 28 of file RingSetConfAuxContainer_v1.h.

◆ phiWidth

std::vector<float> xAOD::RingSetConfAuxContainer_v1::phiWidth
private

Ring width in phi.

Definition at line 34 of file RingSetConfAuxContainer_v1.h.

◆ sectionEndIdx

std::vector<unsigned> xAOD::RingSetConfAuxContainer_v1::sectionEndIdx
private

Hold the end of this section on a vectorized representation:

Definition at line 54 of file RingSetConfAuxContainer_v1.h.

◆ sectionStartIdx

std::vector<unsigned> xAOD::RingSetConfAuxContainer_v1::sectionStartIdx
private

Hold the start of this section on a vectorized representation:

Definition at line 52 of file RingSetConfAuxContainer_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.

The documentation for this class was generated from the following files:
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
beamspotman.r
def r
Definition: beamspotman.py:676
store
StoreGateSvc * store
Definition: fbtTestBasics.cxx:71
xAOD::AuxContainerBase::name
const char * name() const
Get the name of the container instance.
Definition: AuxContainerBase.cxx:742
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.
SG::IConstAuxStore::lockDecoration
virtual void lockDecoration(SG::auxid_t auxid)=0
Lock a decoration.
fitman.sz
sz
Definition: fitman.py:527
xAOD::RingSetConfAuxContainer_v1::nRings
std::vector< unsigned > nRings
Definition: RingSetConfAuxContainer_v1.h:28
get_generator_info.result
result
Definition: get_generator_info.py:21
SG::IConstAuxStore::getVector
virtual const IAuxTypeVector * getVector(SG::auxid_t auxid) const =0
Return vector interface for one aux data item.
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:640
xAOD::RingSetConfAuxContainer_v1::sectionEndIdx
std::vector< unsigned > sectionEndIdx
Hold the end of this section on a vectorized representation:
Definition: RingSetConfAuxContainer_v1.h:54
xAOD::AuxContainerBase::m_store
SG::IAuxStore * m_store
Internal dynamic auxiliary store object.
Definition: AuxContainerBase.h:237
xAOD::RingSetConfAuxContainer_v1::layerStartIdx
std::vector< unsigned > layerStartIdx
Hold the start of this layer on a vectorized representation:
Definition: RingSetConfAuxContainer_v1.h:48
SG::AuxTypeRegistry::getName
std::string getName(SG::auxid_t auxid) const
Return the name of an aux data item.
Definition: AuxTypeRegistry.cxx:882
xAOD::AuxContainerBase::guard_t
AthContainers_detail::lock_guard< mutex_t > guard_t
Definition: AuxContainerBase.h:247
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::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
xAOD::RingSetConfAuxContainer_v1::doEtaAxesDivision
std::vector< char > doEtaAxesDivision
Ring division in eta.
Definition: RingSetConfAuxContainer_v1.h:44
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
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
xAOD::RingSetConfAuxContainer_v1::doPhiAxesDivision
std::vector< char > doPhiAxesDivision
Ring division in phi.
Definition: RingSetConfAuxContainer_v1.h:46
SG::IAuxStoreIO
Interface providing I/O for a generic auxiliary store.
Definition: IAuxStoreIO.h:44
SG::AuxTypeRegistry
Handle mappings between names and auxid_t.
Definition: AuxTypeRegistry.h:61
xAOD::RingSetConfAuxContainer_v1::cellMaxDPhiDist
std::vector< float > cellMaxDPhiDist
Maximun distance cell in phi to seed.
Definition: RingSetConfAuxContainer_v1.h:38
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:429
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
SG::IConstAuxStore::clearDecorations
virtual bool clearDecorations()=0
Clear all decorations.
xAOD::RingSetConfAuxContainer_v1::sectionStartIdx
std::vector< unsigned > sectionStartIdx
Hold the start of this section on a vectorized representation:
Definition: RingSetConfAuxContainer_v1.h:52
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
python.xAODType.dummy
dummy
Definition: xAODType.py:4
SG::IConstAuxStore::getDecoration
virtual void * getDecoration(auxid_t auxid, size_t size, size_t capacity)=0
Return the data vector for one aux data decoration item.
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:937
xAOD::IOStats::instance
static IOStats & instance()
Singleton object accessor.
Definition: IOStats.cxx:11
xAOD::RingSetConfAuxContainer_v1::calJointSection
std::vector< unsigned > calJointSection
The Calorimeter Joint Section (see CaloRingsDefs.h)
Definition: RingSetConfAuxContainer_v1.h:42
xAOD::RingSetConfAuxContainer_v1::layers
std::vector< std::vector< unsigned > > layers
RingSet CaloSample layers used to build this RingSet.
Definition: RingSetConfAuxContainer_v1.h:30
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:220
python.subdetectors.mmg.ids
ids
Definition: mmg.py:8
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:238
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::RingSetConfAuxContainer_v1::calJointLayer
std::vector< unsigned > calJointLayer
The Calorimeter Joint Layer (see CaloRingsDefs.h)
Definition: RingSetConfAuxContainer_v1.h:40
xAOD::AuxContainerBase::getWritableAuxIDs
virtual const auxid_set_t & getWritableAuxIDs() const override
Return a set of writable data identifiers.
Definition: AuxContainerBase.cxx:497
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:229
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
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::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::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.
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:30
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
xAOD::RingSetConfAuxContainer_v1::etaWidth
std::vector< float > etaWidth
Ring width in eta.
Definition: RingSetConfAuxContainer_v1.h:32
SG::IConstAuxStore::isDecoration
virtual bool isDecoration(auxid_t auxid) const =0
Test if a particular variable is tagged as a decoration.
xAOD::RingSetConfAuxContainer_v1::layerEndIdx
std::vector< unsigned > layerEndIdx
Hold the end of this layer on a vectorized representation:
Definition: RingSetConfAuxContainer_v1.h:50
SG::IAuxStoreHolder::AST_ObjectStore
@ AST_ObjectStore
The store describes a single object.
Definition: IAuxStoreHolder.h:67
xAOD::RingSetConfAuxContainer_v1::cellMaxDEtaDist
std::vector< float > cellMaxDEtaDist
Maximun distance cell in eta to seed.
Definition: RingSetConfAuxContainer_v1.h:36
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.
SG::IAuxStoreHolder::AST_ContainerStore
@ AST_ContainerStore
The store describes a container.
Definition: IAuxStoreHolder.h:68
xAOD::RingSetConfAuxContainer_v1::phiWidth
std::vector< float > phiWidth
Ring width in phi.
Definition: RingSetConfAuxContainer_v1.h:34
Generated on Thu Nov 7 2024 22:32:00 for ATLAS Offline Software by   doxygen 1.8.18