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.
typedef SG::auxid_set_t	auxid_set_t
	The aux ID set type definition.
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.
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.
void	dump () const
	Dumps contents (for debugging).
void	toTransient ()
	Function implementing soft schema evolution for the class.
virtual void	toTransient (const EventContext &ctx) override
	Perform processing on aux variable objects just after reading to make them usable as transient objects.
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.
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.
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.
template<typename T, typename ALLOC>
void	regAuxVar (auxid_t auxid, const std::string &name, std::vector< T, ALLOC > &vecvec)
	Register one of the persistent variables internally.
template<typename T>
void	regAuxVar (auxid_t auxid, const std::string &name, SG::PackedContainer< T > &vecvec)
	Register one of the persistent variables internally.
Functions implementing the SG::IAuxStoreHolder interface
virtual SG::IAuxStore *	getStore () override
	Get the currently used internal store object.
virtual const SG::IAuxStore *	getStore () const override
virtual void	setStore (SG::IAuxStore *store) override
	Set a different internal store object.
virtual AuxStoreType	getStoreType () const override
	Return the type of the store object.
std::pmr::memory_resource *	memResource ()
	Return the memory resource to use.
Functions implementing the SG::IConstAuxStore interface
virtual const void *	getData (auxid_t auxid) const override
	Get a pointer to a given array.
virtual const SG::IAuxTypeVector *	getVector (SG::auxid_t auxid) const override final
	Return vector interface for one aux data item.
virtual const auxid_set_t &	getAuxIDs () const override
	Get the types(names) of variables handled by this container.
virtual const auxid_set_t &	getDecorIDs () const override
	Get the types(names) of decorations handled by this container.
virtual SG::auxid_set_t	getCopyIDs (bool warnUnlocked=false) const override
	Get the set of variables that we should deep copy.
virtual bool	isDecoration (auxid_t auxid) const override
	Test if a variable is a decoration.
virtual void *	getDecoration (auxid_t auxid, size_t size, size_t capacity) override
	Get a pointer to a given array, as a decoration.
virtual void	lock () override
	Lock the container.
virtual bool	clearDecorations () override
	Clear all decorations.
virtual size_t	size () const override
	Get the size of the container.
virtual void	lockDecoration (SG::auxid_t auxid) override
	Lock a decoration.
virtual const SG::IAuxTypeVector *	linkedVector (SG::auxid_t auxid) const override
	Return interface for a linked variable.
Functions implementing the SG::IAuxStore interface
virtual void *	getData (auxid_t auxid, size_t size, size_t capacity) override
	Get a pointer to a given array, creating the array if necessary.
virtual SG::IAuxTypeVector *	linkedVector (SG::auxid_t auxid) override
	Return interface for a linked variable.
virtual const auxid_set_t &	getWritableAuxIDs () const override
	Return a set of writable data identifiers.
virtual bool	resize (size_t size) override
	Resize the arrays to a given size.
virtual void	reserve (size_t size) override
	Reserve a given size for the arrays.
virtual void	shift (size_t pos, ptrdiff_t offs) override
	Shift the contents of the stored arrays.
virtual bool	insertMove (size_t pos, IAuxStore &other, const SG::auxid_set_t &ignore) override
	Insert contents of another store via move.
virtual bool	setOption (auxid_t id, const SG::AuxDataOption &option) override
	Make an option setting on an aux variable.
Functions implementing the SG::IAuxStoreIO interface
virtual const void *	getIOData (auxid_t auxid) const override
	Get a pointer to the data being stored for one aux data item.
virtual const std::type_info *	getIOType (auxid_t auxid) const override
	Return the type of the data to be stored for one aux data item.
virtual const auxid_set_t &	getDynamicAuxIDs () const override
	Get the types(names) of variables created dynamically.
virtual SG::auxid_set_t	getSelectedAuxIDs () const override
	Get the IDs of the selected dynamic Aux variables (for writing).
Functions managing the instance name of the container
const char *	name () const
	Get the name of the container instance.
void	setName (const char *name)
	Set the name of the container instance.

Static Public Attributes
static constexpr bool	supportsThinning = true
	Mark that this type supports thinning operations.

Private Types
typedef AthContainers_detail::mutex	mutex_t
	Mutex for multithread synchronization.
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 &vecvec)
	Common code between regAuxVar cases.

Private Attributes
std::vector< float >	radiusOfFirstHit
std::vector< uint64_t >	identifierOfFirstHit
std::vector< float >	beamlineTiltX
std::vector< float >	beamlineTiltY
std::vector< uint32_t >	hitPattern
std::vector< float >	TRTTrackOccupancy
auxid_set_t	m_auxids
	Internal list of all available variables.
std::vector< SG::IAuxTypeVector * >	m_vecs
	Internal list of all managed variables.
SG::IAuxStore *	m_store
	Internal dynamic auxiliary store object.
SG::IAuxStoreIO *	m_storeIO
	The IO interface to the internal auxiliary store.
bool	m_ownsStore
	Flag deciding if the object owns the dynamic store or not.
bool	m_locked
	Has the container been locked?
mutex_t	m_mutex
std::string	m_name
	Name of the container in memory. Set externally.
CxxUtils::CachedPointer< std::pmr::memory_resource > m_memResource	ATLAS_THREAD_SAFE
	Memory resource to use for this container.
Defining parameters (perigee)
std::vector< float >	d0
std::vector< float >	z0
std::vector< float >	phi
std::vector< float >	theta
std::vector< float >	qOverP
std::vector< std::vector< float > >	definingParametersCovMatrix
std::vector< float >	vx
std::vector< float >	vy
std::vector< float >	vz
Fit quality functions
std::vector< float >	chiSquared
std::vector< float >	numberDoF
TrackInfo functions
std::vector< uint8_t >	trackFitter
std::vector< uint8_t >	particleHypothesis
std::vector< uint8_t >	trackProperties
std::vector< uint64_t >	patternRecoInfo
TrackSummary information
std::vector< uint8_t >	numberOfContribPixelLayers
std::vector< uint8_t >	numberOfInnermostPixelLayerHits
std::vector< uint8_t >	numberOfInnermostPixelLayerOutliers
std::vector< uint8_t >	numberOfInnermostPixelLayerSharedHits
std::vector< uint8_t >	numberOfInnermostPixelLayerSplitHits
std::vector< uint8_t >	expectInnermostPixelLayerHit
std::vector< uint8_t >	numberOfNextToInnermostPixelLayerHits
std::vector< uint8_t >	numberOfNextToInnermostPixelLayerOutliers
std::vector< uint8_t >	numberOfNextToInnermostPixelLayerSharedHits
std::vector< uint8_t >	numberOfNextToInnermostPixelLayerSplitHits
std::vector< uint8_t >	expectNextToInnermostPixelLayerHit
std::vector< uint8_t >	numberOfPixelHits
std::vector< uint8_t >	numberOfPixelOutliers
std::vector< uint8_t >	numberOfPixelHoles
std::vector< uint8_t >	numberOfPixelSharedHits
std::vector< uint8_t >	numberOfPixelSplitHits
std::vector< uint8_t >	numberOfGangedPixels
std::vector< uint8_t >	numberOfGangedFlaggedFakes
std::vector< uint8_t >	numberOfPixelDeadSensors
std::vector< uint8_t >	numberOfPixelSpoiltHits
std::vector< uint8_t >	numberOfDBMHits
std::vector< uint8_t >	numberOfSCTHits
std::vector< uint8_t >	numberOfSCTOutliers
std::vector< uint8_t >	numberOfSCTHoles
std::vector< uint8_t >	numberOfSCTDoubleHoles
std::vector< uint8_t >	numberOfSCTSharedHits
std::vector< uint8_t >	numberOfSCTDeadSensors
std::vector< uint8_t >	numberOfSCTSpoiltHits
std::vector< uint8_t >	numberOfTRTHits
std::vector< uint8_t >	numberOfTRTOutliers
std::vector< uint8_t >	numberOfTRTHoles
std::vector< uint8_t >	numberOfTRTHighThresholdHits
std::vector< uint8_t >	numberOfTRTHighThresholdHitsTotal
std::vector< uint8_t >	numberOfTRTHighThresholdOutliers
std::vector< uint8_t >	numberOfTRTDeadStraws
std::vector< uint8_t >	numberOfTRTTubeHits
std::vector< uint8_t >	numberOfTRTXenonHits
std::vector< uint8_t >	numberOfTRTSharedHits
std::vector< uint8_t >	numberOfPrecisionLayers
std::vector< uint8_t >	numberOfPrecisionHoleLayers
std::vector< uint8_t >	numberOfPhiLayers
std::vector< uint8_t >	numberOfPhiHoleLayers
std::vector< uint8_t >	numberOfTriggerEtaLayers
std::vector< uint8_t >	numberOfTriggerEtaHoleLayers
std::vector< uint8_t >	numberOfOutliersOnTrack
std::vector< uint8_t >	standardDeviationOfChi2OS
std::vector< float >	eProbabilityComb
std::vector< float >	eProbabilityHT
std::vector< float >	pixeldEdx
std::vector< uint8_t >	numberOfUsedHitsdEdx
std::vector< uint8_t >	numberOfIBLOverflowsdEdx

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

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

inherited

The aux ID set type definition.

Definition at line 61 of file AuxContainerBase.h.

◆ auxid_t

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

inherited

The aux ID type definition.

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

◆ guard_t

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

privateinherited

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

◆ mutex_t

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

privateinherited

Mutex for multithread synchronization.

Definition at line 249 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 68 of file IAuxStoreHolder.h.

                        {
         AST_ObjectStore    = 0, 
         AST_ContainerStore = 1  
      };

Constructor & Destructor Documentation

◆ TrackParticleAuxContainer_v4()

xAOD::TrackParticleAuxContainer_v4::TrackParticleAuxContainer_v4 ( )

Default constructor.

Definition at line 11 of file TrackParticleAuxContainer_v4.cxx.

      : AuxContainerBase() {
 
      AUX_VARIABLE( d0 );
      AUX_VARIABLE( z0 );
      AUX_VARIABLE( phi );
      AUX_VARIABLE( theta );
      AUX_VARIABLE( qOverP );
 
      AUX_VARIABLE( definingParametersCovMatrix );
 
      AUX_VARIABLE( vx );
      AUX_VARIABLE( vy );
      AUX_VARIABLE( vz );
 
      AUX_VARIABLE( radiusOfFirstHit );
      AUX_VARIABLE( identifierOfFirstHit );
      
      AUX_VARIABLE( beamlineTiltX );
      AUX_VARIABLE( beamlineTiltY );
 
      AUX_VARIABLE( hitPattern );
 
      AUX_VARIABLE(  numberOfUsedHitsdEdx );
      
      AUX_VARIABLE(  numberOfIBLOverflowsdEdx );
 
      AUX_VARIABLE( chiSquared          );
      AUX_VARIABLE( numberDoF );
 
      AUX_VARIABLE( trackFitter          );
      AUX_VARIABLE( particleHypothesis );
      AUX_VARIABLE( trackProperties );
      AUX_VARIABLE( patternRecoInfo );
 
      // TrackSummary information
#ifndef XAODTRACKPARTICLE_SUMMARYDYNAMIC
      // uint8_ts
      AUX_VARIABLE( numberOfContribPixelLayers        );
      AUX_VARIABLE( numberOfInnermostPixelLayerHits               );
      AUX_VARIABLE( numberOfInnermostPixelLayerOutliers           );
      AUX_VARIABLE( numberOfInnermostPixelLayerSharedHits         );
      AUX_VARIABLE( numberOfInnermostPixelLayerSplitHits          );
      AUX_VARIABLE( expectInnermostPixelLayerHit                  ); 
      AUX_VARIABLE( numberOfNextToInnermostPixelLayerHits               );
      AUX_VARIABLE( numberOfNextToInnermostPixelLayerOutliers           );
      AUX_VARIABLE( numberOfNextToInnermostPixelLayerSharedHits         );
      AUX_VARIABLE( numberOfNextToInnermostPixelLayerSplitHits          );
      AUX_VARIABLE( expectNextToInnermostPixelLayerHit                  );
      AUX_VARIABLE( numberOfPixelHits                 );
      AUX_VARIABLE( numberOfPixelOutliers             );
      AUX_VARIABLE( numberOfPixelHoles                );
      AUX_VARIABLE( numberOfPixelSharedHits           );
      AUX_VARIABLE( numberOfPixelSplitHits            );
      AUX_VARIABLE( numberOfGangedPixels              );
      AUX_VARIABLE( numberOfGangedFlaggedFakes        );
      AUX_VARIABLE( numberOfPixelDeadSensors          );
      AUX_VARIABLE( numberOfPixelSpoiltHits           );
      AUX_VARIABLE( numberOfDBMHits                   );
      AUX_VARIABLE( numberOfSCTHits                   );
      AUX_VARIABLE( numberOfSCTOutliers               );
      AUX_VARIABLE( numberOfSCTHoles                  );
      AUX_VARIABLE( numberOfSCTDoubleHoles            );
      AUX_VARIABLE( numberOfSCTSharedHits             );
      AUX_VARIABLE( numberOfSCTDeadSensors            );
      AUX_VARIABLE( numberOfSCTSpoiltHits             );
      AUX_VARIABLE( numberOfTRTHits                   );
      AUX_VARIABLE( numberOfTRTOutliers               );
      AUX_VARIABLE( numberOfTRTHoles                  );
      AUX_VARIABLE( numberOfTRTHighThresholdHits      );
      AUX_VARIABLE( numberOfTRTHighThresholdHitsTotal );
      AUX_VARIABLE( numberOfTRTHighThresholdOutliers  );
      AUX_VARIABLE( numberOfTRTDeadStraws             );
      AUX_VARIABLE( numberOfTRTTubeHits               );
      AUX_VARIABLE( numberOfTRTXenonHits              );
      AUX_VARIABLE( numberOfTRTSharedHits              );
      AUX_VARIABLE( numberOfPrecisionLayers );
      AUX_VARIABLE( numberOfPrecisionHoleLayers );
      AUX_VARIABLE( numberOfPhiLayers );
      AUX_VARIABLE( numberOfPhiHoleLayers );
      AUX_VARIABLE( numberOfTriggerEtaLayers );
      AUX_VARIABLE( numberOfTriggerEtaHoleLayers );
 
      AUX_VARIABLE( numberOfOutliersOnTrack           );
      AUX_VARIABLE( standardDeviationOfChi2OS         );
      // Floats
      AUX_VARIABLE( eProbabilityComb                  );
      AUX_VARIABLE( eProbabilityHT                    ); 
      // AUX_VARIABLE( eProbabilityToT                   ); 
      // AUX_VARIABLE( eProbabilityBrem                  );
      AUX_VARIABLE( pixeldEdx                 );
#endif
 
      //Links
      AUX_VARIABLE( TRTTrackOccupancy );
 
   }

Member Function Documentation

◆ clearDecorations()

bool xAOD::AuxContainerBase::clearDecorations ( )

overridevirtualinherited

Clear all decorations.

Definition at line 362 of file AuxContainerBase.cxx.

                                           {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Clear the decorations from the dynamic store:
      bool anycleared = false;
      if( m_store ) {
         anycleared = m_store->clearDecorations();
      }
      // Early exit if there were no decorations.
      if (!anycleared) return false;
 
      // Construct the list of managed auxiliary variables from scratch after
      // the cleanup:
      auxid_set_t ids;
      for( auxid_t auxid = 0; auxid < m_vecs.size(); ++auxid ) {
         if( m_vecs[ auxid ] ) {
            ids.insert( auxid );
         }
      }
      if( m_store ) {
         ids.insert (m_store->getAuxIDs());
      }
      m_auxids = std::move(ids);
 
      return true;
   }

◆ dump()

void xAOD::TrackParticleAuxContainer_v4::dump ( ) const

Dumps contents (for debugging).

Definition at line 109 of file TrackParticleAuxContainer_v4.cxx.

                                                 {
     std::cout<<" Dumping TrackParticleAuxContainer_v4"<<std::endl;
     std::cout<<"d0:";
     std::copy(d0.begin(), d0.end(),
       std::ostream_iterator<float>(std::cout, ", "));
     std::cout<<"z0:";
     std::copy(z0.begin(), z0.end(),
       std::ostream_iterator<float>(std::cout, ", "));
     std::cout<<"phi:";
     std::copy(phi.begin(), phi.end(),
       std::ostream_iterator<float>(std::cout, ", "));
     std::cout<<"theta:";
     std::copy(theta.begin(), theta.end(),
       std::ostream_iterator<float>(std::cout, ", "));
     std::cout<<"qOverP:";
     std::copy(qOverP.begin(), qOverP.end(),
       std::ostream_iterator<float>(std::cout, ", "));
     std::cout<<"definingParametersCovMatrix: ";
     for (unsigned int i=0; i<definingParametersCovMatrix.size();++i){
     std::copy(definingParametersCovMatrix[i].begin(), definingParametersCovMatrix[i].end(),
       std::ostream_iterator<float>(std::cout, ", "));
        std::cout<<std::endl;
     }
   }

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

Definition at line 276 of file AuxContainerBase.cxx.

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

◆ getCopyIDs()

SG::auxid_set_t xAOD::AuxContainerBase::getCopyIDs ( bool warnUnlocked = false ) const

overridevirtualinherited

Get the set of variables that we should deep copy.

Definition at line 292 of file AuxContainerBase.cxx.

   {
     return SG::getCopyIDs (getAuxIDs(), getDecorIDs(), warnUnlocked, {});
   }

◆ getData() [1/2]

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

overridevirtualinherited

Get a pointer to a given array.

Definition at line 232 of file AuxContainerBase.cxx.

                                                              {
 
      const SG::IAuxTypeVector* v = getVector( auxid );
      if( v ) {
         return v->toPtr();
      }
      return nullptr;
   }

◆ getData() [2/2]

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

                                                      {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
 
         if( m_store ) {
            void* result = m_store->getData( auxid, size, capacity );
            if( result ) {
               m_auxids.insert( auxid );
               const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
               auxid_t linked_id = r.linkedVariable( auxid );
               if (linked_id != SG::null_auxid) {
                  m_auxids.insert( linked_id );
               }
            }
            return result;
         } else {
            std::println( "ERROR xAOD::AuxContainerBase::getData "
                          "Unknown variable ({}) requested",
                          SG::AuxTypeRegistry::instance().getName( auxid ) );
            return nullptr;
         }
      }
      m_vecs[ auxid ]->reserve( capacity );
      if (m_vecs[ auxid ]->size() < size) {
         m_vecs[ auxid ]->resize( size );
      }
 
      return m_vecs[ auxid ]->toPtr();
   }

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

Reimplemented in xAOD::EventInfoAuxContainer_v1.

Definition at line 306 of file AuxContainerBase.cxx.

                                                            {
     {
       // Guard against multi-threaded execution:
       guard_t guard( m_mutex );
 
       // Check if we have it as a static variable:
       if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         // If not, but we have a dynamic store, push it in there:
         if( m_store ) {
           void* result = m_store->getDecoration( auxid, size, capacity );
           if( result ) {
              m_auxids.insert( auxid );
              const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
              auxid_t linked_id = r.linkedVariable( auxid );
              if (linked_id != SG::null_auxid) {
                 m_auxids.insert( linked_id );
              }
           }
           return result;
         }
         // If we don't have a dynamic store, complain:
         else {
           std::println( "ERROR xAOD::AuxContainerBase::getDecoration "
                         "Can't provide variable {}",
                         SG::AuxTypeRegistry::instance().getName( auxid ) );
           return nullptr;
         }
       }
 
       // If the container is locked, static variables can't be accessed this
       // way:
       if( m_locked ) {
         throw SG::ExcStoreLocked( auxid );
       }
     }
 
     // If the container is not locked, then fall back on the normal accessor
     // function:
     return getData( auxid, size, capacity );
   }

◆ getDecorIDs()

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

overridevirtualinherited

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

Definition at line 283 of file AuxContainerBase.cxx.

                                       {
 
      if( m_store ) {
         return m_store->getDecorIDs();
      }
      static const auxid_set_t empty;
      return empty;
   }

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

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

◆ getIOData()

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

overridevirtualinherited

Get a pointer to the data being stored for one aux data item.

Implements SG::IAuxStoreIO.

Definition at line 681 of file AuxContainerBase.cxx.

                                                                {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // If the variable is not static, look for it in the dynamic store:
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         if( m_storeIO ) {
            return m_storeIO->getIOData( auxid );
         } else {
            std::println( "ERROR xAOD::AuxContainerBase::getIOData "
                          "Unknown variable ({}) requested",
                          SG::AuxTypeRegistry::instance().getName( auxid ) );
            return nullptr;
         }
      }
 
      // Update the statistics for this variable. The dynamic store registers
      // its own variable accesses.
      IOStats::instance().stats().readBranch( m_name, auxid );
 
      return m_vecs[ auxid ]->toVector();
   }

◆ getIOType()

const std::type_info * xAOD::AuxContainerBase::getIOType ( auxid_t auxid ) const

overridevirtualinherited

Return the type of the data to be stored for one aux data item.

Implements SG::IAuxStoreIO.

Definition at line 705 of file AuxContainerBase.cxx.

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

◆ getSelectedAuxIDs()

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

overridevirtualinherited

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

Reimplemented from SG::IAuxStoreIO.

Definition at line 742 of file AuxContainerBase.cxx.

                                             {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // All the variables handled by the internal store are dynamic
      // if such a store exists:
      if( m_storeIO && m_store) {
         // I mean, all the variables. Not just the ones reported as dynamic
         // by the internal object. Because the internal object may be something
         // that was put into this one in order to achieve data slimming.
         return m_store->getAuxIDs();
      }
 
      // In case we don't use an internal store, there are no dynamic
      // variables:
      return auxid_set_t();
   }

◆ getStore() [1/2]

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

overridevirtualinherited

Implements SG::IAuxStoreHolder.

Definition at line 183 of file AuxContainerBase.cxx.

   {
      return m_store;
   }

◆ getStore() [2/2]

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

overridevirtualinherited

Get the currently used internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 156 of file AuxContainerBase.cxx.

   {
      return m_store;
   }

◆ getStoreType()

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

inlineoverridevirtualinherited

Return the type of the store object.

Implements SG::IAuxStoreHolder.

Definition at line 88 of file AuxContainerBase.h.

88{ return AST_ContainerStore; }

◆ getVector()

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

finaloverridevirtualinherited

Return vector interface for one aux data item.

Definition at line 241 of file AuxContainerBase.cxx.

                                                                            {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         if( m_store ) {
            const SG::IAuxTypeVector* result = m_store->getVector( auxid );
            if( result ) {
              auxid_set_t& auxids_nc ATLAS_THREAD_SAFE =
                const_cast<auxid_set_t&> (m_auxids);
              auxids_nc.insert( auxid );
              const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
              auxid_t linked_id = r.linkedVariable( auxid );
              if (linked_id != SG::null_auxid) {
                 auxids_nc.insert( linked_id );
              }
            }
            return result;
         } else {
            std::println( "ERROR xAOD::AuxContainerBase::getData "
                          "Unknown variable ({}) requested",
                          SG::AuxTypeRegistry::instance().getName( auxid ) );
            return nullptr;
         }
      }
 
      // Update the statistics for this variable. The dynamic store registers
      // its own variable accesses.
      IOStats::instance().stats().readBranch( m_name, auxid );
 
      return m_vecs[ auxid ];
   }

◆ getWritableAuxIDs()

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

overridevirtualinherited

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 520 of file AuxContainerBase.cxx.

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

◆ insertMove() [1/2]

virtual bool SG::IAuxStore::insertMove	(	size_t	pos,
		IAuxStore &	other,
		const SG::auxid_set_t &	ignore = SG::auxid_set_t() )

pure virtualinherited

Move all elements from other to this store.

Parameters

pos	The starting index of the insertion.
other	Store from which to do the move.
ignore	Set of variables that should not be added to the store.

Let len be the size of other. The store will be increased in size by len elements, with the elements at pos being copied to pos+len. Then, for each auxiliary variable, the entire contents of that variable for other will be moved to this store at index pos. This will be done via move semantics if possible; otherwise, it will be done with a copy. Variables present in this store but not in other will have the corresponding elements default-initialized. Variables in other but not in this store will be added unless they are in ignore.

Returns true if it is known that none of the vectors' memory moved, false otherwise.

◆ insertMove() [2/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 606 of file AuxContainerBase.cxx.

                                                                       {
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // This operation is not allowed on a locked container:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "insertMove" );
      }
 
      bool nomove = true;
      size_t other_size = other.size();
 
      SG::auxid_set_t ignore = ignore_in;
      
      // Do the operation on the static variables:
      for (SG::auxid_t id : m_auxids) {
        SG::IAuxTypeVector* v_dst = nullptr;
        if (id < m_vecs.size())
          v_dst = m_vecs[id];
        // Skip linked vars --- they should be taken care of by the parent var.
        if (v_dst && !v_dst->isLinked()) {
          ignore.insert (id);
          if (other.getData (id)) {
            void* src_ptr = other.getData (id, other_size, other_size);
            if (src_ptr) {
              if (!v_dst->insertMove (pos, src_ptr, 0, other_size,
                                      other))
                nomove = false;
            }
          }
          else {
            const void* orig = v_dst->toPtr();
            v_dst->shift (pos, other_size);
            if (orig != v_dst->toPtr())
              nomove = false;
          }
        }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
        if (!m_store->insertMove( pos, other, ignore ))
          nomove = false;
 
        // Notice any new variables added as a result of this.
        m_auxids.insert (m_store->getAuxIDs());
      }
 
      return nomove;
   }

◆ isDecoration()

bool xAOD::AuxContainerBase::isDecoration ( auxid_t auxid ) const

overridevirtualinherited

Test if a variable is a decoration.

Reimplemented in xAOD::EventInfoAuxContainer_v1.

Definition at line 297 of file AuxContainerBase.cxx.

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

◆ linkedVector() [1/2]

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

overridevirtualinherited

Return interface for a linked variable.

Definition at line 401 of file AuxContainerBase.cxx.

   {
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      auxid_t linked_id = r.linkedVariable( auxid );
      if (linked_id != SG::null_auxid) {
         guard_t guard( m_mutex );
         if (linked_id < m_vecs.size() && m_vecs[ linked_id ]) {
            return m_vecs[ linked_id ];
         }
         if (m_store) {
            return CxxUtils::as_const_ptr(m_store)->linkedVector( auxid );
         }
      }
      return nullptr;
   }

◆ linkedVector() [2/2]

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

overridevirtualinherited

Return interface for a linked variable.

Reimplemented from SG::IAuxStore.

Definition at line 418 of file AuxContainerBase.cxx.

   {
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      auxid_t linked_id = r.linkedVariable( auxid );
      if (linked_id != SG::null_auxid) {
         guard_t guard( m_mutex );
         if (linked_id < m_vecs.size() && m_vecs[ linked_id ]) {
            return m_vecs[ linked_id ];
         }
         if (m_store) {
            return m_store->linkedVector( auxid );
         }
      }
      return nullptr;
   }

◆ lock()

void xAOD::AuxContainerBase::lock ( )

overridevirtualinherited

Lock the container.

Definition at line 348 of file AuxContainerBase.cxx.

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

◆ lockDecoration()

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

overridevirtualinherited

Lock a decoration.

Reimplemented in xAOD::EventInfoAuxContainer_v1.

Definition at line 392 of file AuxContainerBase.cxx.

   { 
     guard_t guard (m_mutex);
     if (m_store) {
       m_store->lockDecoration (auxid);
     }
   }

◆ memResource()

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

inherited

Return the memory resource to use.

Definition at line 161 of file AuxContainerBase.cxx.

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

◆ name()

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

inherited

Get the name of the container instance.

Definition at line 764 of file AuxContainerBase.cxx.

                                            {
 
      return m_name.c_str();
   }

◆ regAuxVar() [1/2]

template<typename T>

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

inherited

Register one of the persistent variables internally.

◆ regAuxVar() [2/2]

template<typename T, typename ALLOC>

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

inherited

Register one of the persistent variables internally.

◆ regAuxVar1()

template<typename ELT, typename CONT>

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

privateinherited

Common code between regAuxVar cases.

◆ reserve()

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

overridevirtualinherited

Reserve a given size for the arrays.

Implements SG::IAuxStore.

Definition at line 555 of file AuxContainerBase.cxx.

                                               {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // This operation is not allowed on a locked container:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "reserve" );
      }
 
      // Do the operation on the static variables:
      for (SG::IAuxTypeVector* v : m_vecs) {
         if(v && !v->isLinked()) {
            v->reserve( size );
         }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
         m_store->reserve( size );
      }
 
      return;
   }

◆ resize()

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

overridevirtualinherited

Resize the arrays to a given size.

Implements SG::IAuxStore.

Definition at line 527 of file AuxContainerBase.cxx.

                                              {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // This operation is not allowed on a locked container:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "resize" );
      }
 
      // Do the operation on the static variables:
      bool nomoves = true;
      for (SG::IAuxTypeVector* v : m_vecs) {
         if(v && !v->isLinked()) {
           if (!v->resize( size ))
             nomoves = false;
         }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
        if (!m_store->resize( size ))
          nomoves = false;
      }
 
      return nomoves;
   }

◆ setName()

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

inherited

Set the name of the container instance.

Definition at line 769 of file AuxContainerBase.cxx.

                                                    {
 
      m_name = name;
      return;
   }

◆ setOption()

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

overridevirtualinherited

Make an option setting on an aux variable.

Reimplemented from SG::IAuxStore.

Definition at line 660 of file AuxContainerBase.cxx.

                                                                     {
 
      guard_t guard (m_mutex);
      if (id < m_vecs.size() && m_vecs[id] != nullptr)
         return m_vecs[id]->setOption (option);
 
      if (m_store)
         return m_store->setOption (id, option);
      return false;
   }

◆ setStore()

void xAOD::AuxContainerBase::setStore ( SG::IAuxStore * store )

overridevirtualinherited

Set a different internal store object.

This function is used by the I/O infrastructure to possibly put a store object into this one, which can interact with dynamic variables directly.

Note that the object takes ownership of the received store.

Parameters

store The store that should be used for dynamic variable handling inside the object from now on

Implements SG::IAuxStoreHolder.

Definition at line 197 of file AuxContainerBase.cxx.

                                                       {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Check that no funny business is going on:
      if( m_store == store ) return;
 
      // Clean up the current store object:
      if( m_store && m_ownsStore ) {
         m_auxids -= m_store->getAuxIDs();
         delete m_store;
      }
      m_store = nullptr;
      m_storeIO = nullptr;
 
      // Take posession of the new object:
      m_store = store;
      m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
      m_ownsStore = true;
      if( m_store ) {
         m_auxids.insert (m_store->getAuxIDs());
      }
 
      return;
   }

◆ shift()

void xAOD::AuxContainerBase::shift	(	size_t	pos,
		ptrdiff_t	offs )

overridevirtualinherited

Shift the contents of the stored arrays.

Implements SG::IAuxStore.

Definition at line 580 of file AuxContainerBase.cxx.

                                                            {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // This operation is not allowed on a locked container:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "shift" );
      }
 
      // Do the operation on the static variables:
      for (SG::IAuxTypeVector* v : m_vecs) {
         if(v && !v->isLinked()) {
            v->shift( pos, offs );
         }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
         m_store->shift( pos, offs );
      }
 
      return;
   }

◆ size()

size_t xAOD::AuxContainerBase::size ( ) const

overridevirtualinherited

Get the size of the container.

Definition at line 453 of file AuxContainerBase.cxx.

                                       {
 
      // Guard against multi-threaded execution:
      guard_t guard (m_mutex);
 
      // Try to find a variable:
      for (SG::auxid_t i : m_auxids) {
         if( ( i < m_vecs.size() ) && m_vecs[ i ] && !m_vecs[ i ]->isLinked()) {
            size_t sz = m_vecs[ i ]->size();
            if( sz > 0 ) {
               return sz;
            }
         }
      }
 
      // If we didn't find any, let's ask the dynamic store:
      if( m_store ) {
         return m_store->size();
      }
 
      // If we don't have any variables, then the size must be null:
      return 0;
   }

◆ toTransient() [1/2]

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.

                                                  {
 
      // Make sure that the numberOfDBMHits variable is of the right size:
      if( numberOfDBMHits.size() != phi.size() ) {
         numberOfDBMHits.resize( phi.size(), 0 );
      }
      if( numberOfTRTHighThresholdHitsTotal.size() != phi.size() ) {
         numberOfTRTHighThresholdHitsTotal.resize( phi.size(), 0 );
      }
 
      return;
   }

◆ toTransient() [2/2]

void xAOD::AuxContainerBase::toTransient ( const EventContext & ctx )

overridevirtual

Perform processing on aux variable objects just after reading to make them usable as transient objects.

Reimplemented from xAOD::AuxContainerBase.

Definition at line 165 of file AuxContainerBase.cxx.

   {
      // Guard against multi-threaded execution:
      guard_t guard (m_mutex);
 
      for (SG::IAuxTypeVector* v : m_vecs) {
         if(v) {
           v->toTransient( ctx );
         }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
        m_store->toTransient( ctx );
      }
   }

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 257 of file AuxContainerBase.h.

◆ beamlineTiltX

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

private

Definition at line 83 of file TrackParticleAuxContainer_v4.h.

◆ beamlineTiltY

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

private

Definition at line 84 of file TrackParticleAuxContainer_v4.h.

◆ chiSquared

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

private

Definition at line 90 of file TrackParticleAuxContainer_v4.h.

◆ d0

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

private

Definition at line 52 of file TrackParticleAuxContainer_v4.h.

◆ definingParametersCovMatrix

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

private

Definition at line 58 of file TrackParticleAuxContainer_v4.h.

◆ eProbabilityComb

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

private

Definition at line 153 of file TrackParticleAuxContainer_v4.h.

◆ eProbabilityHT

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

private

Definition at line 154 of file TrackParticleAuxContainer_v4.h.

◆ expectInnermostPixelLayerHit

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

private

Definition at line 110 of file TrackParticleAuxContainer_v4.h.

◆ expectNextToInnermostPixelLayerHit

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

private

Definition at line 115 of file TrackParticleAuxContainer_v4.h.

◆ hitPattern

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

private

Definition at line 86 of file TrackParticleAuxContainer_v4.h.

◆ identifierOfFirstHit

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

private

Definition at line 81 of file TrackParticleAuxContainer_v4.h.

◆ m_auxids

auxid_set_t xAOD::AuxContainerBase::m_auxids

privateinherited

Internal list of all available variables.

Definition at line 235 of file AuxContainerBase.h.

◆ m_locked

bool xAOD::AuxContainerBase::m_locked

privateinherited

Has the container been locked?

Definition at line 246 of file AuxContainerBase.h.

◆ m_mutex

mutex_t xAOD::AuxContainerBase::m_mutex

mutableprivateinherited

Definition at line 251 of file AuxContainerBase.h.

◆ m_name

std::string xAOD::AuxContainerBase::m_name

privateinherited

Name of the container in memory. Set externally.

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

◆ m_store

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

privateinherited

Internal dynamic auxiliary store object.

Definition at line 240 of file AuxContainerBase.h.

◆ m_storeIO

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

privateinherited

The IO interface to the internal auxiliary store.

Definition at line 242 of file AuxContainerBase.h.

◆ m_vecs

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

privateinherited

Internal list of all managed variables.

Definition at line 237 of file AuxContainerBase.h.

◆ numberDoF

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

private

Definition at line 91 of file TrackParticleAuxContainer_v4.h.

◆ numberOfContribPixelLayers

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

private

Definition at line 105 of file TrackParticleAuxContainer_v4.h.

◆ numberOfDBMHits

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

private

Definition at line 125 of file TrackParticleAuxContainer_v4.h.

◆ numberOfGangedFlaggedFakes

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

private

Definition at line 122 of file TrackParticleAuxContainer_v4.h.

◆ numberOfGangedPixels

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

private

Definition at line 121 of file TrackParticleAuxContainer_v4.h.

◆ numberOfIBLOverflowsdEdx

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

private

Definition at line 159 of file TrackParticleAuxContainer_v4.h.

◆ numberOfInnermostPixelLayerHits

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

private

Definition at line 106 of file TrackParticleAuxContainer_v4.h.

◆ numberOfInnermostPixelLayerOutliers

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

private

Definition at line 107 of file TrackParticleAuxContainer_v4.h.

◆ numberOfInnermostPixelLayerSharedHits

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

private

Definition at line 108 of file TrackParticleAuxContainer_v4.h.

◆ numberOfInnermostPixelLayerSplitHits

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

private

Definition at line 109 of file TrackParticleAuxContainer_v4.h.

◆ numberOfNextToInnermostPixelLayerHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfNextToInnermostPixelLayerHits

private

Todo: FIXME!Should be bool.

Definition at line 111 of file TrackParticleAuxContainer_v4.h.

◆ numberOfNextToInnermostPixelLayerOutliers

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

private

Definition at line 112 of file TrackParticleAuxContainer_v4.h.

◆ numberOfNextToInnermostPixelLayerSharedHits

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

private

Definition at line 113 of file TrackParticleAuxContainer_v4.h.

◆ numberOfNextToInnermostPixelLayerSplitHits

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

private

Definition at line 114 of file TrackParticleAuxContainer_v4.h.

◆ numberOfOutliersOnTrack

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

private

Definition at line 151 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPhiHoleLayers

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

private

Definition at line 147 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPhiLayers

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

private

Definition at line 146 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPixelDeadSensors

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

private

Definition at line 123 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPixelHits

std::vector< uint8_t > xAOD::TrackParticleAuxContainer_v4::numberOfPixelHits

private

Todo: FIXME!Should be bool.

Definition at line 116 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPixelHoles

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

private

Definition at line 118 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPixelOutliers

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

private

Definition at line 117 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPixelSharedHits

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

private

Definition at line 119 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPixelSplitHits

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

private

Definition at line 120 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPixelSpoiltHits

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

private

Definition at line 124 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPrecisionHoleLayers

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

private

Definition at line 145 of file TrackParticleAuxContainer_v4.h.

◆ numberOfPrecisionLayers

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

private

Definition at line 144 of file TrackParticleAuxContainer_v4.h.

◆ numberOfSCTDeadSensors

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

private

Definition at line 131 of file TrackParticleAuxContainer_v4.h.

◆ numberOfSCTDoubleHoles

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

private

Definition at line 129 of file TrackParticleAuxContainer_v4.h.

◆ numberOfSCTHits

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

private

Definition at line 126 of file TrackParticleAuxContainer_v4.h.

◆ numberOfSCTHoles

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

private

Definition at line 128 of file TrackParticleAuxContainer_v4.h.

◆ numberOfSCTOutliers

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

private

Definition at line 127 of file TrackParticleAuxContainer_v4.h.

◆ numberOfSCTSharedHits

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

private

Definition at line 130 of file TrackParticleAuxContainer_v4.h.

◆ numberOfSCTSpoiltHits

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

private

Definition at line 132 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTriggerEtaHoleLayers

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

private

Definition at line 149 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTriggerEtaLayers

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

private

Definition at line 148 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTDeadStraws

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

private

Definition at line 139 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTHighThresholdHits

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

private

Definition at line 136 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTHighThresholdHitsTotal

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

private

Definition at line 137 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTHighThresholdOutliers

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

private

Definition at line 138 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTHits

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

private

Definition at line 133 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTHoles

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

private

Definition at line 135 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTOutliers

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

private

Definition at line 134 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTSharedHits

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

private

Definition at line 142 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTTubeHits

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

private

Definition at line 140 of file TrackParticleAuxContainer_v4.h.

◆ numberOfTRTXenonHits

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

private

Definition at line 141 of file TrackParticleAuxContainer_v4.h.

◆ numberOfUsedHitsdEdx

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

private

Definition at line 158 of file TrackParticleAuxContainer_v4.h.

◆ particleHypothesis

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

private

Definition at line 97 of file TrackParticleAuxContainer_v4.h.

◆ patternRecoInfo

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

private

Definition at line 99 of file TrackParticleAuxContainer_v4.h.

◆ phi

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

private

Definition at line 54 of file TrackParticleAuxContainer_v4.h.

◆ pixeldEdx

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

private

Definition at line 157 of file TrackParticleAuxContainer_v4.h.

◆ qOverP

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

private

Definition at line 56 of file TrackParticleAuxContainer_v4.h.

◆ radiusOfFirstHit

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

private

Definition at line 80 of file TrackParticleAuxContainer_v4.h.

◆ standardDeviationOfChi2OS

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

private

Definition at line 152 of file TrackParticleAuxContainer_v4.h.

◆ supportsThinning

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 216 of file IAuxStore.h.

◆ theta

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

private

Definition at line 55 of file TrackParticleAuxContainer_v4.h.

◆ trackFitter

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

private

Definition at line 96 of file TrackParticleAuxContainer_v4.h.

◆ trackProperties

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

private

Definition at line 98 of file TrackParticleAuxContainer_v4.h.

◆ TRTTrackOccupancy

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

private

Definition at line 168 of file TrackParticleAuxContainer_v4.h.

◆ vx

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

private

Definition at line 60 of file TrackParticleAuxContainer_v4.h.

◆ vy

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

private

Definition at line 61 of file TrackParticleAuxContainer_v4.h.

◆ vz

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

private

Definition at line 62 of file TrackParticleAuxContainer_v4.h.

◆ z0

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

private

Definition at line 53 of file TrackParticleAuxContainer_v4.h.

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

Public Types

Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ auxid_set_t

◆ auxid_t

◆ AuxVariable_t

◆ guard_t

◆ LinkedVariable_t

◆ mutex_t

Member Enumeration Documentation

◆ AuxStoreType

Constructor & Destructor Documentation

◆ TrackParticleAuxContainer_v4()

Member Function Documentation

◆ clearDecorations()

◆ dump()

◆ getAuxID() [1/2]

◆ getAuxID() [2/2]

◆ getAuxIDs()

◆ getCopyIDs()

◆ getData() [1/2]

◆ getData() [2/2]

◆ getDecoration()

◆ getDecorIDs()

◆ getDynamicAuxIDs()

◆ getIOData()

◆ getIOType()

◆ getSelectedAuxIDs()

◆ getStore() [1/2]

◆ getStore() [2/2]

◆ getStoreType()

◆ getVector()

◆ getWritableAuxIDs()

◆ insertMove() [1/2]

◆ insertMove() [2/2]

◆ isDecoration()

◆ linkedVector() [1/2]

◆ linkedVector() [2/2]

◆ lock()

◆ lockDecoration()

◆ memResource()

◆ name()

◆ regAuxVar() [1/2]

◆ regAuxVar() [2/2]

◆ regAuxVar1()

◆ reserve()

◆ resize()

◆ setName()

◆ setOption()

◆ setStore()

◆ shift()

◆ size()

◆ toTransient() [1/2]

◆ toTransient() [2/2]

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ beamlineTiltX

◆ beamlineTiltY

◆ chiSquared

◆ d0

◆ definingParametersCovMatrix

◆ eProbabilityComb

◆ eProbabilityHT

◆ expectInnermostPixelLayerHit

◆ expectNextToInnermostPixelLayerHit

◆ hitPattern

◆ identifierOfFirstHit

◆ m_auxids

◆ m_locked

◆ m_mutex

◆ m_name

◆ m_ownsStore

◆ m_store

◆ m_storeIO

◆ m_vecs