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

Temporary container used until we have I/O for AuxStoreInternal. More...

#include <TrackParticleAuxContainer_v4.h>

Inheritance diagram for xAOD::TrackParticleAuxContainer_v4:
Collaboration diagram for xAOD::TrackParticleAuxContainer_v4:

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

 TrackParticleAuxContainer_v4 ()
 Default constructor. More...
 
void dump () const
 Dumps contents (for debugging) More...
 
void toTransient ()
 Function implementing soft schema evolution for the class. 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_tguard_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

std::vector< floatradiusOfFirstHit
 
std::vector< uint64_tidentifierOfFirstHit
 
std::vector< floatbeamlineTiltX
 
std::vector< floatbeamlineTiltY
 
std::vector< uint32_thitPattern
 
std::vector< floatTRTTrackOccupancy
 
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::IAuxStorem_store
 Internal dynamic auxiliary store object. More...
 
SG::IAuxStoreIOm_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...
 
Defining parameters (perigee)
std::vector< floatd0
 
std::vector< floatz0
 
std::vector< floatphi
 
std::vector< floattheta
 
std::vector< floatqOverP
 
std::vector< std::vector< float > > definingParametersCovMatrix
 
std::vector< floatvx
 
std::vector< floatvy
 
std::vector< floatvz
 
Fit quality functions
std::vector< floatchiSquared
 
std::vector< floatnumberDoF
 
TrackInfo functions
std::vector< uint8_ttrackFitter
 
std::vector< uint8_tparticleHypothesis
 
std::vector< uint8_ttrackProperties
 
std::vector< uint64_tpatternRecoInfo
 
TrackSummary information
std::vector< uint8_tnumberOfContribPixelLayers
 
std::vector< uint8_tnumberOfInnermostPixelLayerHits
 
std::vector< uint8_tnumberOfInnermostPixelLayerOutliers
 
std::vector< uint8_tnumberOfInnermostPixelLayerSharedHits
 
std::vector< uint8_tnumberOfInnermostPixelLayerSplitHits
 
std::vector< uint8_texpectInnermostPixelLayerHit
 
std::vector< uint8_tnumberOfNextToInnermostPixelLayerHits
 
std::vector< uint8_tnumberOfNextToInnermostPixelLayerOutliers
 
std::vector< uint8_tnumberOfNextToInnermostPixelLayerSharedHits
 
std::vector< uint8_tnumberOfNextToInnermostPixelLayerSplitHits
 
std::vector< uint8_texpectNextToInnermostPixelLayerHit
 
std::vector< uint8_tnumberOfPixelHits
 
std::vector< uint8_tnumberOfPixelOutliers
 
std::vector< uint8_tnumberOfPixelHoles
 
std::vector< uint8_tnumberOfPixelSharedHits
 
std::vector< uint8_tnumberOfPixelSplitHits
 
std::vector< uint8_tnumberOfGangedPixels
 
std::vector< uint8_tnumberOfGangedFlaggedFakes
 
std::vector< uint8_tnumberOfPixelDeadSensors
 
std::vector< uint8_tnumberOfPixelSpoiltHits
 
std::vector< uint8_tnumberOfDBMHits
 
std::vector< uint8_tnumberOfSCTHits
 
std::vector< uint8_tnumberOfSCTOutliers
 
std::vector< uint8_tnumberOfSCTHoles
 
std::vector< uint8_tnumberOfSCTDoubleHoles
 
std::vector< uint8_tnumberOfSCTSharedHits
 
std::vector< uint8_tnumberOfSCTDeadSensors
 
std::vector< uint8_tnumberOfSCTSpoiltHits
 
std::vector< uint8_tnumberOfTRTHits
 
std::vector< uint8_tnumberOfTRTOutliers
 
std::vector< uint8_tnumberOfTRTHoles
 
std::vector< uint8_tnumberOfTRTHighThresholdHits
 
std::vector< uint8_tnumberOfTRTHighThresholdHitsTotal
 
std::vector< uint8_tnumberOfTRTHighThresholdOutliers
 
std::vector< uint8_tnumberOfTRTDeadStraws
 
std::vector< uint8_tnumberOfTRTTubeHits
 
std::vector< uint8_tnumberOfTRTXenonHits
 
std::vector< uint8_tnumberOfTRTSharedHits
 
std::vector< uint8_tnumberOfPrecisionLayers
 
std::vector< uint8_tnumberOfPrecisionHoleLayers
 
std::vector< uint8_tnumberOfPhiLayers
 
std::vector< uint8_tnumberOfPhiHoleLayers
 
std::vector< uint8_tnumberOfTriggerEtaLayers
 
std::vector< uint8_tnumberOfTriggerEtaHoleLayers
 
std::vector< uint8_tnumberOfOutliersOnTrack
 
std::vector< uint8_tstandardDeviationOfChi2OS
 
std::vector< floateProbabilityComb
 
std::vector< floateProbabilityHT
 
std::vector< floatpixeldEdx
 
std::vector< uint8_tnumberOfUsedHitsdEdx
 
std::vector< uint8_tnumberOfIBLOverflowsdEdx
 

Detailed Description

Temporary container used until we have I/O for AuxStoreInternal.

This class is meant to serve as a temporary way to provide an auxiliary store with Athena I/O capabilities for the TrackParticle EDM. Will be exchanged for a generic auxiliary container type (AuxStoreInternal) later on.

Author
Edward Moyse

Definition at line 37 of file TrackParticleAuxContainer_v4.h.

Member Typedef Documentation

◆ auxid_set_t

The aux ID set type definition.

Definition at line 65 of file AuxContainerBase.h.

◆ auxid_t

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

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

Constructor & Destructor Documentation

◆ TrackParticleAuxContainer_v4()

xAOD::TrackParticleAuxContainer_v4::TrackParticleAuxContainer_v4 ( )

Default constructor.

Definition at line 11 of file TrackParticleAuxContainer_v4.cxx.

12  : AuxContainerBase() {
13 
14  AUX_VARIABLE( d0 );
15  AUX_VARIABLE( z0 );
16  AUX_VARIABLE( phi );
19 
21 
22  AUX_VARIABLE( vx );
23  AUX_VARIABLE( vy );
24  AUX_VARIABLE( vz );
25 
28 
31 
33 
35 
37 
40 
45 
46  // TrackSummary information
47 #ifndef XAODTRACKPARTICLE_SUMMARYDYNAMIC
48  // uint8_ts
93 
96  // Floats
99  // AUX_VARIABLE( eProbabilityToT );
100  // AUX_VARIABLE( eProbabilityBrem );
102 #endif
103 
104  //Links
106 
107  }

Member Function Documentation

◆ clearDecorations()

bool xAOD::AuxContainerBase::clearDecorations ( )
overridevirtualinherited

Clear all decorations.

Implements SG::IConstAuxStore.

Definition at line 359 of file AuxContainerBase.cxx.

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

◆ dump()

void xAOD::TrackParticleAuxContainer_v4::dump ( ) const

Dumps contents (for debugging)

Definition at line 109 of file TrackParticleAuxContainer_v4.cxx.

109  {
110  std::cout<<" Dumping TrackParticleAuxContainer_v4"<<std::endl;
111  std::cout<<"d0:";
112  std::copy(d0.begin(), d0.end(),
113  std::ostream_iterator<float>(std::cout, ", "));
114  std::cout<<"z0:";
115  std::copy(z0.begin(), z0.end(),
116  std::ostream_iterator<float>(std::cout, ", "));
117  std::cout<<"phi:";
118  std::copy(phi.begin(), phi.end(),
119  std::ostream_iterator<float>(std::cout, ", "));
120  std::cout<<"theta:";
121  std::copy(theta.begin(), theta.end(),
122  std::ostream_iterator<float>(std::cout, ", "));
123  std::cout<<"qOverP:";
124  std::copy(qOverP.begin(), qOverP.end(),
125  std::ostream_iterator<float>(std::cout, ", "));
126  std::cout<<"definingParametersCovMatrix: ";
127  for (unsigned int i=0; i<definingParametersCovMatrix.size();++i){
129  std::ostream_iterator<float>(std::cout, ", "));
130  std::cout<<std::endl;
131  }
132  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

◆ getStore() [1/2]

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

Implements SG::IAuxStoreHolder.

Definition at line 183 of file AuxContainerBase.cxx.

184  {
185  return m_store;
186  }

◆ getStore() [2/2]

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

Get the currently used internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 156 of file AuxContainerBase.cxx.

157  {
158  return m_store;
159  }

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

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

◆ getWritableAuxIDs()

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

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 500 of file AuxContainerBase.cxx.

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

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

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

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

294  {
295  guard_t guard( m_mutex );
296  if (m_store) {
297  return m_store->isDecoration (auxid);
298  }
299  return false;
300  }

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

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

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

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

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

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

◆ lockDecoration()

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

Lock a decoration.

Implements SG::IConstAuxStore.

Reimplemented in xAOD::EventInfoAuxContainer_v1.

Definition at line 389 of file AuxContainerBase.cxx.

390  {
391  guard_t guard (m_mutex);
392  if (m_store) {
393  m_store->lockDecoration (auxid);
394  }
395  }

◆ memResource()

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

Return the memory resource to use.

Definition at line 161 of file AuxContainerBase.cxx.

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

◆ name()

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

Get the name of the container instance.

Definition at line 745 of file AuxContainerBase.cxx.

745  {
746 
747  return m_name.c_str();
748  }

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

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

◆ resize()

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

Resize the arrays to a given size.

Implements SG::IAuxStore.

Definition at line 507 of file AuxContainerBase.cxx.

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

◆ setName()

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

Set the name of the container instance.

Definition at line 750 of file AuxContainerBase.cxx.

750  {
751 
752  m_name = name;
753  return;
754  }

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

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

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

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

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

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

◆ size()

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

Get the size of the container.

Implements SG::IConstAuxStore.

Definition at line 432 of file AuxContainerBase.cxx.

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

◆ toTransient()

void xAOD::TrackParticleAuxContainer_v4::toTransient ( )

Function implementing soft schema evolution for the class.

This function is used to implement simple schema evolution rules that don't warrant creating a _v5 class yet.

Definition at line 136 of file TrackParticleAuxContainer_v4.cxx.

136  {
137 
138  // Make sure that the numberOfDBMHits variable is of the right size:
139  if( numberOfDBMHits.size() != phi.size() ) {
140  numberOfDBMHits.resize( phi.size(), 0 );
141  }
142  if( numberOfTRTHighThresholdHitsTotal.size() != phi.size() ) {
143  numberOfTRTHighThresholdHitsTotal.resize( phi.size(), 0 );
144  }
145 
146  return;
147  }

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.

◆ beamlineTiltX

std::vector< float > xAOD::TrackParticleAuxContainer_v4::beamlineTiltX
private

Definition at line 82 of file TrackParticleAuxContainer_v4.h.

◆ beamlineTiltY

std::vector< float > xAOD::TrackParticleAuxContainer_v4::beamlineTiltY
private

Definition at line 83 of file TrackParticleAuxContainer_v4.h.

◆ chiSquared

std::vector< float > xAOD::TrackParticleAuxContainer_v4::chiSquared
private

Definition at line 89 of file TrackParticleAuxContainer_v4.h.

◆ d0

std::vector< float > xAOD::TrackParticleAuxContainer_v4::d0
private

Definition at line 51 of file TrackParticleAuxContainer_v4.h.

◆ definingParametersCovMatrix

std::vector< std::vector<float> > xAOD::TrackParticleAuxContainer_v4::definingParametersCovMatrix
private

Definition at line 57 of file TrackParticleAuxContainer_v4.h.

◆ eProbabilityComb

std::vector< float > xAOD::TrackParticleAuxContainer_v4::eProbabilityComb
private

Definition at line 152 of file TrackParticleAuxContainer_v4.h.

◆ eProbabilityHT

std::vector< float > xAOD::TrackParticleAuxContainer_v4::eProbabilityHT
private

Definition at line 153 of file TrackParticleAuxContainer_v4.h.

◆ expectInnermostPixelLayerHit

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::expectInnermostPixelLayerHit
private

Definition at line 109 of file TrackParticleAuxContainer_v4.h.

◆ expectNextToInnermostPixelLayerHit

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::expectNextToInnermostPixelLayerHit
private

Definition at line 114 of file TrackParticleAuxContainer_v4.h.

◆ hitPattern

std::vector< uint32_t > xAOD::TrackParticleAuxContainer_v4::hitPattern
private

Definition at line 85 of file TrackParticleAuxContainer_v4.h.

◆ identifierOfFirstHit

std::vector< uint64_t > xAOD::TrackParticleAuxContainer_v4::identifierOfFirstHit
private

Definition at line 80 of file TrackParticleAuxContainer_v4.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.

◆ numberDoF

std::vector< float > xAOD::TrackParticleAuxContainer_v4::numberDoF
private

Definition at line 90 of file TrackParticleAuxContainer_v4.h.

◆ numberOfContribPixelLayers

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfContribPixelLayers
private

Definition at line 104 of file TrackParticleAuxContainer_v4.h.

◆ numberOfDBMHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfDBMHits
private

Definition at line 124 of file TrackParticleAuxContainer_v4.h.

◆ numberOfGangedFlaggedFakes

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfGangedFlaggedFakes
private

Definition at line 121 of file TrackParticleAuxContainer_v4.h.

◆ numberOfGangedPixels

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfGangedPixels
private

Definition at line 120 of file TrackParticleAuxContainer_v4.h.

◆ numberOfIBLOverflowsdEdx

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfIBLOverflowsdEdx
private

Definition at line 158 of file TrackParticleAuxContainer_v4.h.

◆ numberOfInnermostPixelLayerHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfInnermostPixelLayerHits
private

Definition at line 105 of file TrackParticleAuxContainer_v4.h.

◆ numberOfInnermostPixelLayerOutliers

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfInnermostPixelLayerOutliers
private

Definition at line 106 of file TrackParticleAuxContainer_v4.h.

◆ numberOfInnermostPixelLayerSharedHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfInnermostPixelLayerSharedHits
private

Definition at line 107 of file TrackParticleAuxContainer_v4.h.

◆ numberOfInnermostPixelLayerSplitHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfInnermostPixelLayerSplitHits
private

Definition at line 108 of file TrackParticleAuxContainer_v4.h.

◆ numberOfNextToInnermostPixelLayerHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfNextToInnermostPixelLayerHits
private
Todo:
FIXME!Should be bool.

Definition at line 110 of file TrackParticleAuxContainer_v4.h.

◆ numberOfNextToInnermostPixelLayerOutliers

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfNextToInnermostPixelLayerOutliers
private

Definition at line 111 of file TrackParticleAuxContainer_v4.h.

◆ numberOfNextToInnermostPixelLayerSharedHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfNextToInnermostPixelLayerSharedHits
private

Definition at line 112 of file TrackParticleAuxContainer_v4.h.

◆ numberOfNextToInnermostPixelLayerSplitHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfNextToInnermostPixelLayerSplitHits
private

Definition at line 113 of file TrackParticleAuxContainer_v4.h.

◆ numberOfOutliersOnTrack

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfOutliersOnTrack
private

Definition at line 150 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPhiHoleLayers

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfPhiHoleLayers
private

Definition at line 146 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPhiLayers

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfPhiLayers
private

Definition at line 145 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPixelDeadSensors

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfPixelDeadSensors
private

Definition at line 122 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPixelHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfPixelHits
private
Todo:
FIXME!Should be bool.

Definition at line 115 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPixelHoles

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfPixelHoles
private

Definition at line 117 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPixelOutliers

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfPixelOutliers
private

Definition at line 116 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPixelSharedHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfPixelSharedHits
private

Definition at line 118 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPixelSplitHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfPixelSplitHits
private

Definition at line 119 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPixelSpoiltHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfPixelSpoiltHits
private

Definition at line 123 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPrecisionHoleLayers

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfPrecisionHoleLayers
private

Definition at line 144 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPrecisionLayers

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfPrecisionLayers
private

Definition at line 143 of file TrackParticleAuxContainer_v4.h.

◆ numberOfSCTDeadSensors

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfSCTDeadSensors
private

Definition at line 130 of file TrackParticleAuxContainer_v4.h.

◆ numberOfSCTDoubleHoles

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfSCTDoubleHoles
private

Definition at line 128 of file TrackParticleAuxContainer_v4.h.

◆ numberOfSCTHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfSCTHits
private

Definition at line 125 of file TrackParticleAuxContainer_v4.h.

◆ numberOfSCTHoles

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfSCTHoles
private

Definition at line 127 of file TrackParticleAuxContainer_v4.h.

◆ numberOfSCTOutliers

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfSCTOutliers
private

Definition at line 126 of file TrackParticleAuxContainer_v4.h.

◆ numberOfSCTSharedHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfSCTSharedHits
private

Definition at line 129 of file TrackParticleAuxContainer_v4.h.

◆ numberOfSCTSpoiltHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfSCTSpoiltHits
private

Definition at line 131 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTriggerEtaHoleLayers

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfTriggerEtaHoleLayers
private

Definition at line 148 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTriggerEtaLayers

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfTriggerEtaLayers
private

Definition at line 147 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTDeadStraws

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfTRTDeadStraws
private

Definition at line 138 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTHighThresholdHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfTRTHighThresholdHits
private

Definition at line 135 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTHighThresholdHitsTotal

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfTRTHighThresholdHitsTotal
private

Definition at line 136 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTHighThresholdOutliers

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfTRTHighThresholdOutliers
private

Definition at line 137 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfTRTHits
private

Definition at line 132 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTHoles

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfTRTHoles
private

Definition at line 134 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTOutliers

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfTRTOutliers
private

Definition at line 133 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTSharedHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfTRTSharedHits
private

Definition at line 141 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTTubeHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfTRTTubeHits
private

Definition at line 139 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTXenonHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfTRTXenonHits
private

Definition at line 140 of file TrackParticleAuxContainer_v4.h.

◆ numberOfUsedHitsdEdx

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfUsedHitsdEdx
private

Definition at line 157 of file TrackParticleAuxContainer_v4.h.

◆ particleHypothesis

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::particleHypothesis
private

Definition at line 96 of file TrackParticleAuxContainer_v4.h.

◆ patternRecoInfo

std::vector< uint64_t > xAOD::TrackParticleAuxContainer_v4::patternRecoInfo
private

Definition at line 98 of file TrackParticleAuxContainer_v4.h.

◆ phi

std::vector< float > xAOD::TrackParticleAuxContainer_v4::phi
private

Definition at line 53 of file TrackParticleAuxContainer_v4.h.

◆ pixeldEdx

std::vector< float > xAOD::TrackParticleAuxContainer_v4::pixeldEdx
private

Definition at line 156 of file TrackParticleAuxContainer_v4.h.

◆ qOverP

std::vector< float > xAOD::TrackParticleAuxContainer_v4::qOverP
private

Definition at line 55 of file TrackParticleAuxContainer_v4.h.

◆ radiusOfFirstHit

std::vector< float > xAOD::TrackParticleAuxContainer_v4::radiusOfFirstHit
private

Definition at line 79 of file TrackParticleAuxContainer_v4.h.

◆ standardDeviationOfChi2OS

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::standardDeviationOfChi2OS
private

Definition at line 151 of file TrackParticleAuxContainer_v4.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.

◆ theta

std::vector< float > xAOD::TrackParticleAuxContainer_v4::theta
private

Definition at line 54 of file TrackParticleAuxContainer_v4.h.

◆ trackFitter

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::trackFitter
private

Definition at line 95 of file TrackParticleAuxContainer_v4.h.

◆ trackProperties

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::trackProperties
private

Definition at line 97 of file TrackParticleAuxContainer_v4.h.

◆ TRTTrackOccupancy

std::vector< float> xAOD::TrackParticleAuxContainer_v4::TRTTrackOccupancy
private

Definition at line 167 of file TrackParticleAuxContainer_v4.h.

◆ vx

std::vector< float > xAOD::TrackParticleAuxContainer_v4::vx
private

Definition at line 59 of file TrackParticleAuxContainer_v4.h.

◆ vy

std::vector< float > xAOD::TrackParticleAuxContainer_v4::vy
private

Definition at line 60 of file TrackParticleAuxContainer_v4.h.

◆ vz

std::vector< float > xAOD::TrackParticleAuxContainer_v4::vz
private

Definition at line 61 of file TrackParticleAuxContainer_v4.h.

◆ z0

std::vector< float > xAOD::TrackParticleAuxContainer_v4::z0
private

Definition at line 52 of file TrackParticleAuxContainer_v4.h.


The documentation for this class was generated from the following files:
xAOD::TrackParticleAuxContainer_v4::numberOfContribPixelLayers
std::vector< uint8_t > numberOfContribPixelLayers
Definition: TrackParticleAuxContainer_v4.h:104
xAOD::TrackParticleAuxContainer_v4::numberOfNextToInnermostPixelLayerHits
std::vector< uint8_t > numberOfNextToInnermostPixelLayerHits
Definition: TrackParticleAuxContainer_v4.h:110
xAOD::AuxContainerBase::m_name
std::string m_name
Name of the container in memory. Set externally.
Definition: AuxContainerBase.h:251
xAOD::TrackParticleAuxContainer_v4::trackProperties
std::vector< uint8_t > trackProperties
Definition: TrackParticleAuxContainer_v4.h:97
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::TrackParticleAuxContainer_v4::eProbabilityHT
std::vector< float > eProbabilityHT
Definition: TrackParticleAuxContainer_v4.h:153
xAOD::AuxContainerBase::name
const char * name() const
Get the name of the container instance.
Definition: AuxContainerBase.cxx:745
xAOD::TrackParticleAuxContainer_v4::numberOfPixelDeadSensors
std::vector< uint8_t > numberOfPixelDeadSensors
Definition: TrackParticleAuxContainer_v4.h:122
xAOD::TrackParticleAuxContainer_v4::TRTTrackOccupancy
std::vector< float > TRTTrackOccupancy
Definition: TrackParticleAuxContainer_v4.h:167
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::TrackParticleAuxContainer_v4::numberOfPixelSplitHits
std::vector< uint8_t > numberOfPixelSplitHits
Definition: TrackParticleAuxContainer_v4.h:119
SG::IConstAuxStore::lockDecoration
virtual void lockDecoration(SG::auxid_t auxid)=0
Lock a decoration.
xAOD::TrackParticleAuxContainer_v4::expectInnermostPixelLayerHit
std::vector< uint8_t > expectInnermostPixelLayerHit
Definition: TrackParticleAuxContainer_v4.h:109
fitman.sz
sz
Definition: fitman.py:527
xAOD::TrackParticleAuxContainer_v4::trackFitter
std::vector< uint8_t > trackFitter
Definition: TrackParticleAuxContainer_v4.h:95
get_generator_info.result
result
Definition: get_generator_info.py:21
xAOD::TrackParticleAuxContainer_v4::numberOfPixelHoles
std::vector< uint8_t > numberOfPixelHoles
Definition: TrackParticleAuxContainer_v4.h:117
xAOD::TrackParticleAuxContainer_v4::pixeldEdx
std::vector< float > pixeldEdx
Definition: TrackParticleAuxContainer_v4.h:156
xAOD::TrackParticleAuxContainer_v4::numberOfPhiLayers
std::vector< uint8_t > numberOfPhiLayers
Definition: TrackParticleAuxContainer_v4.h:145
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:639
xAOD::TrackParticleAuxContainer_v4::numberOfInnermostPixelLayerOutliers
std::vector< uint8_t > numberOfInnermostPixelLayerOutliers
Definition: TrackParticleAuxContainer_v4.h:106
xAOD::TrackParticleAuxContainer_v4::standardDeviationOfChi2OS
std::vector< uint8_t > standardDeviationOfChi2OS
Definition: TrackParticleAuxContainer_v4.h:151
xAOD::AuxContainerBase::m_store
SG::IAuxStore * m_store
Internal dynamic auxiliary store object.
Definition: AuxContainerBase.h:237
xAOD::TrackParticleAuxContainer_v4::numberDoF
std::vector< float > numberDoF
Definition: TrackParticleAuxContainer_v4.h:90
xAOD::TrackParticleAuxContainer_v4::numberOfNextToInnermostPixelLayerSharedHits
std::vector< uint8_t > numberOfNextToInnermostPixelLayerSharedHits
Definition: TrackParticleAuxContainer_v4.h:112
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
xAOD::TrackParticleAuxContainer_v4::numberOfInnermostPixelLayerSplitHits
std::vector< uint8_t > numberOfInnermostPixelLayerSplitHits
Definition: TrackParticleAuxContainer_v4.h:108
SG::ExcStoreLocked
Exception — Attempted to modify auxiliary data in a locked store.
Definition: Control/AthContainers/AthContainers/exceptions.h:183
xAOD::TrackParticleAuxContainer_v4::numberOfDBMHits
std::vector< uint8_t > numberOfDBMHits
Definition: TrackParticleAuxContainer_v4.h:124
xAOD::TrackParticleAuxContainer_v4::numberOfTRTHighThresholdHits
std::vector< uint8_t > numberOfTRTHighThresholdHits
Definition: TrackParticleAuxContainer_v4.h:135
Atlas::hasExtendedEventContext
bool hasExtendedEventContext(const EventContext &ctx)
Test whether a context object has an extended context installed.
Definition: ExtendedEventContext.cxx:23
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
xAOD::TrackParticleAuxContainer_v4::beamlineTiltY
std::vector< float > beamlineTiltY
Definition: TrackParticleAuxContainer_v4.h:83
xAOD::TrackParticleAuxContainer_v4::d0
std::vector< float > d0
Definition: TrackParticleAuxContainer_v4.h:51
xAOD::other
@ other
Definition: TrackingPrimitives.h:510
xAOD::TrackParticleAuxContainer_v4::numberOfSCTSpoiltHits
std::vector< uint8_t > numberOfSCTSpoiltHits
Definition: TrackParticleAuxContainer_v4.h:131
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
xAOD::TrackParticleAuxContainer_v4::numberOfOutliersOnTrack
std::vector< uint8_t > numberOfOutliersOnTrack
Definition: TrackParticleAuxContainer_v4.h:150
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::TrackParticleAuxContainer_v4::eProbabilityComb
std::vector< float > eProbabilityComb
Definition: TrackParticleAuxContainer_v4.h:152
xAOD::TrackParticleAuxContainer_v4::numberOfNextToInnermostPixelLayerSplitHits
std::vector< uint8_t > numberOfNextToInnermostPixelLayerSplitHits
Definition: TrackParticleAuxContainer_v4.h:113
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::TrackParticleAuxContainer_v4::numberOfTRTTubeHits
std::vector< uint8_t > numberOfTRTTubeHits
Definition: TrackParticleAuxContainer_v4.h:139
SG::IAuxStoreIO
Interface providing I/O for a generic auxiliary store.
Definition: IAuxStoreIO.h:44
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
SG::AuxTypeRegistry
Handle mappings between names and auxid_t.
Definition: AuxTypeRegistry.h:61
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:432
DiTauMassTools::ignore
void ignore(T &&)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:58
xAOD::TrackParticleAuxContainer_v4::radiusOfFirstHit
std::vector< float > radiusOfFirstHit
Definition: TrackParticleAuxContainer_v4.h:79
xAOD::TrackParticleAuxContainer_v4::numberOfSCTDeadSensors
std::vector< uint8_t > numberOfSCTDeadSensors
Definition: TrackParticleAuxContainer_v4.h:130
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::TrackParticleAuxContainer_v4::numberOfTriggerEtaLayers
std::vector< uint8_t > numberOfTriggerEtaLayers
Definition: TrackParticleAuxContainer_v4.h:147
xAOD::TrackParticleAuxContainer_v4::identifierOfFirstHit
std::vector< uint64_t > identifierOfFirstHit
Definition: TrackParticleAuxContainer_v4.h:80
xAOD::TrackParticleAuxContainer_v4::theta
std::vector< float > theta
Definition: TrackParticleAuxContainer_v4.h:54
xAOD::TrackParticleAuxContainer_v4::vz
std::vector< float > vz
Definition: TrackParticleAuxContainer_v4.h:61
SG::IConstAuxStore::clearDecorations
virtual bool clearDecorations()=0
Clear all decorations.
xAOD::TrackParticleAuxContainer_v4::numberOfInnermostPixelLayerSharedHits
std::vector< uint8_t > numberOfInnermostPixelLayerSharedHits
Definition: TrackParticleAuxContainer_v4.h:107
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::TrackParticleAuxContainer_v4::numberOfPixelHits
std::vector< uint8_t > numberOfPixelHits
Definition: TrackParticleAuxContainer_v4.h:115
xAOD::TrackParticleAuxContainer_v4::hitPattern
std::vector< uint32_t > hitPattern
Definition: TrackParticleAuxContainer_v4.h:85
xAOD::TrackParticleAuxContainer_v4::numberOfPixelSpoiltHits
std::vector< uint8_t > numberOfPixelSpoiltHits
Definition: TrackParticleAuxContainer_v4.h:123
xAOD::TrackParticleAuxContainer_v4::numberOfUsedHitsdEdx
std::vector< uint8_t > numberOfUsedHitsdEdx
Definition: TrackParticleAuxContainer_v4.h:157
xAOD::TrackParticleAuxContainer_v4::numberOfSCTHoles
std::vector< uint8_t > numberOfSCTHoles
Definition: TrackParticleAuxContainer_v4.h:127
xAOD::TrackParticleAuxContainer_v4::numberOfPrecisionHoleLayers
std::vector< uint8_t > numberOfPrecisionHoleLayers
Definition: TrackParticleAuxContainer_v4.h:144
xAOD::TrackParticleAuxContainer_v4::chiSquared
std::vector< float > chiSquared
Definition: TrackParticleAuxContainer_v4.h:89
xAOD::TrackParticleAuxContainer_v4::numberOfTRTDeadStraws
std::vector< uint8_t > numberOfTRTDeadStraws
Definition: TrackParticleAuxContainer_v4.h:138
xAOD::TrackParticleAuxContainer_v4::numberOfTRTHoles
std::vector< uint8_t > numberOfTRTHoles
Definition: TrackParticleAuxContainer_v4.h:134
xAOD::TrackParticleAuxContainer_v4::qOverP
std::vector< float > qOverP
Definition: TrackParticleAuxContainer_v4.h:55
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:936
xAOD::TrackParticleAuxContainer_v4::numberOfTRTHighThresholdOutliers
std::vector< uint8_t > numberOfTRTHighThresholdOutliers
Definition: TrackParticleAuxContainer_v4.h:137
xAOD::IOStats::instance
static IOStats & instance()
Singleton object accessor.
Definition: IOStats.cxx:11
xAOD::TrackParticleAuxContainer_v4::numberOfPhiHoleLayers
std::vector< uint8_t > numberOfPhiHoleLayers
Definition: TrackParticleAuxContainer_v4.h:146
xAOD::TrackParticleAuxContainer_v4::numberOfGangedPixels
std::vector< uint8_t > numberOfGangedPixels
Definition: TrackParticleAuxContainer_v4.h:120
xAOD::TrackParticleAuxContainer_v4::patternRecoInfo
std::vector< uint64_t > patternRecoInfo
Definition: TrackParticleAuxContainer_v4.h:98
xAOD::TrackParticleAuxContainer_v4::vx
std::vector< float > vx
Definition: TrackParticleAuxContainer_v4.h:59
xAOD::TrackParticleAuxContainer_v4::numberOfPixelSharedHits
std::vector< uint8_t > numberOfPixelSharedHits
Definition: TrackParticleAuxContainer_v4.h:118
xAOD::TrackParticleAuxContainer_v4::numberOfSCTOutliers
std::vector< uint8_t > numberOfSCTOutliers
Definition: TrackParticleAuxContainer_v4.h:126
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:227
xAOD::TrackParticleAuxContainer_v4::z0
std::vector< float > z0
Definition: TrackParticleAuxContainer_v4.h:52
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:241
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::AuxContainerBase::getWritableAuxIDs
virtual const auxid_set_t & getWritableAuxIDs() const override
Return a set of writable data identifiers.
Definition: AuxContainerBase.cxx:500
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:232
xAOD::TrackParticleAuxContainer_v4::numberOfTRTSharedHits
std::vector< uint8_t > numberOfTRTSharedHits
Definition: TrackParticleAuxContainer_v4.h:141
xAOD::TrackParticleAuxContainer_v4::numberOfTriggerEtaHoleLayers
std::vector< uint8_t > numberOfTriggerEtaHoleLayers
Definition: TrackParticleAuxContainer_v4.h:148
xAOD::TrackParticleAuxContainer_v4::numberOfTRTHighThresholdHitsTotal
std::vector< uint8_t > numberOfTRTHighThresholdHitsTotal
Definition: TrackParticleAuxContainer_v4.h:136
xAOD::ReadStats::readBranch
void readBranch(const std::string &prefix, SG::auxid_t auxid)
Function incrementing the read counter on a specific branch.
xAOD::TrackParticleAuxContainer_v4::numberOfTRTHits
std::vector< uint8_t > numberOfTRTHits
Definition: TrackParticleAuxContainer_v4.h:132
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
xAOD::TrackParticleAuxContainer_v4::numberOfNextToInnermostPixelLayerOutliers
std::vector< uint8_t > numberOfNextToInnermostPixelLayerOutliers
Definition: TrackParticleAuxContainer_v4.h:111
xAOD::TrackParticleAuxContainer_v4::phi
std::vector< float > phi
Definition: TrackParticleAuxContainer_v4.h:53
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::TrackParticleAuxContainer_v4::numberOfSCTSharedHits
std::vector< uint8_t > numberOfSCTSharedHits
Definition: TrackParticleAuxContainer_v4.h:129
columnar::empty
bool empty() const noexcept
Definition: ObjectRange.h:129
xAOD::TrackParticleAuxContainer_v4::numberOfInnermostPixelLayerHits
std::vector< uint8_t > numberOfInnermostPixelLayerHits
Definition: TrackParticleAuxContainer_v4.h:105
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::TrackParticleAuxContainer_v4::numberOfGangedFlaggedFakes
std::vector< uint8_t > numberOfGangedFlaggedFakes
Definition: TrackParticleAuxContainer_v4.h:121
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::TrackParticleAuxContainer_v4::vy
std::vector< float > vy
Definition: TrackParticleAuxContainer_v4.h:60
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:33
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::TrackParticleAuxContainer_v4::numberOfSCTDoubleHoles
std::vector< uint8_t > numberOfSCTDoubleHoles
Definition: TrackParticleAuxContainer_v4.h:128
xAOD::TrackParticleAuxContainer_v4::numberOfSCTHits
std::vector< uint8_t > numberOfSCTHits
Definition: TrackParticleAuxContainer_v4.h:125
calibdata.copy
bool copy
Definition: calibdata.py:27
xAOD::TrackParticleAuxContainer_v4::particleHypothesis
std::vector< uint8_t > particleHypothesis
Definition: TrackParticleAuxContainer_v4.h:96
SG::IConstAuxStore::isDecoration
virtual bool isDecoration(auxid_t auxid) const =0
Test if a particular variable is tagged as a decoration.
xAOD::TrackParticleAuxContainer_v4::numberOfTRTOutliers
std::vector< uint8_t > numberOfTRTOutliers
Definition: TrackParticleAuxContainer_v4.h:133
xAOD::TrackParticleAuxContainer_v4::numberOfPixelOutliers
std::vector< uint8_t > numberOfPixelOutliers
Definition: TrackParticleAuxContainer_v4.h:116
xAOD::TrackParticleAuxContainer_v4::definingParametersCovMatrix
std::vector< std::vector< float > > definingParametersCovMatrix
Definition: TrackParticleAuxContainer_v4.h:57
xAOD::TrackParticleAuxContainer_v4::numberOfIBLOverflowsdEdx
std::vector< uint8_t > numberOfIBLOverflowsdEdx
Definition: TrackParticleAuxContainer_v4.h:158
SG::IAuxStoreHolder::AST_ObjectStore
@ AST_ObjectStore
The store describes a single object.
Definition: IAuxStoreHolder.h:67
xAOD::TrackParticleAuxContainer_v4::beamlineTiltX
std::vector< float > beamlineTiltX
Definition: TrackParticleAuxContainer_v4.h:82
xAOD::TrackParticleAuxContainer_v4::expectNextToInnermostPixelLayerHit
std::vector< uint8_t > expectNextToInnermostPixelLayerHit
Definition: TrackParticleAuxContainer_v4.h:114
xAOD::TrackParticleAuxContainer_v4::numberOfPrecisionLayers
std::vector< uint8_t > numberOfPrecisionLayers
Definition: TrackParticleAuxContainer_v4.h:143
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::TrackParticleAuxContainer_v4::numberOfTRTXenonHits
std::vector< uint8_t > numberOfTRTXenonHits
Definition: TrackParticleAuxContainer_v4.h:140