xAOD::MuonAuxContainer_v5 Class Reference

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

#include <MuonAuxContainer_v5.h>

Inheritance diagram for xAOD::MuonAuxContainer_v5:

Collaboration diagram for xAOD::MuonAuxContainer_v5:

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...
enum	AuxStoreType { AST_ObjectStore = 0, AST_ContainerStore = 1 }
	Type of the auxiliary store. More...

Public Member Functions
	MuonAuxContainer_v5 ()
	Default constructor. More...
virtual const void *	getData (SG::auxid_t auxid) const=0
	Pick up the const version from the base class. 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)
	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::AuxTypeRegistry::Flags flags=SG::AuxTypeRegistry::Flags::None)
	Get the auxiliary ID for one of the persistent variables. More...
template<typename T , typename ALLOC >
void	regAuxVar (auxid_t auxid, const std::string &name, std::vector< T, ALLOC > &vec)
	Register one of the persistent variables internally. More...
template<typename T >
void	regAuxVar (auxid_t auxid, const std::string &name, SG::PackedContainer< T > &vec)
	Register one of the persistent variables internally. More...

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

Private Types
typedef AthContainers_detail::mutex	mutex_t
	Mutex for multithread synchronization. More...
typedef AthContainers_detail::lock_guard< mutex_t >	guard_t

Private Member Functions
template<typename ELT , typename CONT >
void	regAuxVar1 (auxid_t auxid, const std::string &name, CONT &vec)
	Common code between regAuxVar cases. More...

Private Attributes
auxid_set_t	m_auxids
	Internal list of all available variables. More...
std::vector< SG::IAuxTypeVector * >	m_vecs
	Internal list of all managed variables. More...
SG::IAuxStore *	m_store
	Internal dynamic auxiliary store object. More...
SG::IAuxStoreIO *	m_storeIO
	The IO interface to the internal auxiliary store. More...
bool	m_ownsStore
	Flag deciding if the object owns the dynamic store or not. More...
bool	m_locked
	Has the container been locked? More...
mutex_t	m_mutex
std::string	m_name
	Name of the container in memory. Set externally. More...
CxxUtils::CachedPointer< std::pmr::memory_resource > m_memResource	ATLAS_THREAD_SAFE
	Memory resource to use for this container. More...
iParticle values
std::vector< float >	pt
std::vector< float >	eta
std::vector< float >	phi
std::vector< float >	charge
Muon summary information
std::vector< uint16_t >	allAuthors
std::vector< uint16_t >	author
std::vector< uint16_t >	muonType
std::vector< uint8_t >	quality
TrackSummary and MuonTrackSummary information
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 >	primarySector
std::vector< uint8_t >	secondarySector
std::vector< uint8_t >	innerSmallHits
std::vector< uint8_t >	innerLargeHits
std::vector< uint8_t >	middleSmallHits
std::vector< uint8_t >	middleLargeHits
std::vector< uint8_t >	outerSmallHits
std::vector< uint8_t >	outerLargeHits
std::vector< uint8_t >	extendedSmallHits
std::vector< uint8_t >	extendedLargeHits
std::vector< uint8_t >	innerSmallHoles
std::vector< uint8_t >	innerLargeHoles
std::vector< uint8_t >	middleSmallHoles
std::vector< uint8_t >	middleLargeHoles
std::vector< uint8_t >	outerSmallHoles
std::vector< uint8_t >	outerLargeHoles
std::vector< uint8_t >	extendedSmallHoles
std::vector< uint8_t >	extendedLargeHoles
std::vector< uint8_t >	phiLayer1Hits
std::vector< uint8_t >	phiLayer2Hits
std::vector< uint8_t >	phiLayer3Hits
std::vector< uint8_t >	phiLayer4Hits
std::vector< uint8_t >	etaLayer1Hits
std::vector< uint8_t >	etaLayer2Hits
std::vector< uint8_t >	etaLayer3Hits
std::vector< uint8_t >	etaLayer4Hits
std::vector< uint8_t >	phiLayer1Holes
std::vector< uint8_t >	phiLayer2Holes
std::vector< uint8_t >	phiLayer3Holes
std::vector< uint8_t >	phiLayer4Holes
std::vector< uint8_t >	etaLayer1Holes
std::vector< uint8_t >	etaLayer2Holes
std::vector< uint8_t >	etaLayer3Holes
std::vector< uint8_t >	etaLayer4Holes
std::vector< uint8_t >	phiLayer1RPCHits
std::vector< uint8_t >	phiLayer2RPCHits
std::vector< uint8_t >	phiLayer3RPCHits
std::vector< uint8_t >	phiLayer4RPCHits
std::vector< uint8_t >	etaLayer1RPCHits
std::vector< uint8_t >	etaLayer2RPCHits
std::vector< uint8_t >	etaLayer3RPCHits
std::vector< uint8_t >	etaLayer4RPCHits
std::vector< uint8_t >	phiLayer1RPCHoles
std::vector< uint8_t >	phiLayer2RPCHoles
std::vector< uint8_t >	phiLayer3RPCHoles
std::vector< uint8_t >	phiLayer4RPCHoles
std::vector< uint8_t >	etaLayer1RPCHoles
std::vector< uint8_t >	etaLayer2RPCHoles
std::vector< uint8_t >	etaLayer3RPCHoles
std::vector< uint8_t >	etaLayer4RPCHoles
std::vector< uint8_t >	phiLayer1TGCHits
std::vector< uint8_t >	phiLayer2TGCHits
std::vector< uint8_t >	phiLayer3TGCHits
std::vector< uint8_t >	phiLayer4TGCHits
std::vector< uint8_t >	etaLayer1TGCHits
std::vector< uint8_t >	etaLayer2TGCHits
std::vector< uint8_t >	etaLayer3TGCHits
std::vector< uint8_t >	etaLayer4TGCHits
std::vector< uint8_t >	phiLayer1TGCHoles
std::vector< uint8_t >	phiLayer2TGCHoles
std::vector< uint8_t >	phiLayer3TGCHoles
std::vector< uint8_t >	phiLayer4TGCHoles
std::vector< uint8_t >	etaLayer1TGCHoles
std::vector< uint8_t >	etaLayer2TGCHoles
std::vector< uint8_t >	etaLayer3TGCHoles
std::vector< uint8_t >	etaLayer4TGCHoles
std::vector< uint8_t >	phiLayer1STGCHits
std::vector< uint8_t >	phiLayer2STGCHits
std::vector< uint8_t >	etaLayer1STGCHits
std::vector< uint8_t >	etaLayer2STGCHits
std::vector< uint8_t >	phiLayer1STGCHoles
std::vector< uint8_t >	phiLayer2STGCHoles
std::vector< uint8_t >	etaLayer1STGCHoles
std::vector< uint8_t >	etaLayer2STGCHoles
std::vector< uint8_t >	MMHits
std::vector< uint8_t >	MMHoles
std::vector< uint8_t >	cscEtaHits
std::vector< uint8_t >	cscUnspoiledEtaHits
Links
std::vector< ElementLink< TrackParticleContainer > >	inDetTrackParticleLink
std::vector< ElementLink< TrackParticleContainer > >	muonSpectrometerTrackParticleLink
std::vector< ElementLink< TrackParticleContainer > >	extrapolatedMuonSpectrometerTrackParticleLink
std::vector< ElementLink< TrackParticleContainer > >	msOnlyExtrapolatedMuonSpectrometerTrackParticleLink
std::vector< ElementLink< TrackParticleContainer > >	combinedTrackParticleLink
std::vector< ElementLink< CaloClusterContainer > >	clusterLink
std::vector< std::vector< ElementLink< MuonSegmentContainer > > >	muonSegmentLinks
Energy loss
std::vector< uint8_t >	energyLossType
Param defs
std::vector< float >	spectrometerFieldIntegral
std::vector< float >	scatteringCurvatureSignificance
std::vector< float >	scatteringNeighbourSignificance
std::vector< float >	momentumBalanceSignificance
std::vector< float >	segmentDeltaEta
std::vector< float >	segmentDeltaPhi
std::vector< float >	segmentChi2OverDoF
std::vector< float >	t0
std::vector< float >	beta
std::vector< float >	annBarrel
std::vector< float >	annEndCap
std::vector< float >	innAngle
std::vector< float >	midAngle
std::vector< float >	msInnerMatchChi2
std::vector< float >	meanDeltaADCCountsMDT
std::vector< float >	CaloLRLikelihood
std::vector< float >	CaloMuonScore
std::vector< float >	EnergyLoss
std::vector< float >	ParamEnergyLoss
std::vector< float >	MeasEnergyLoss
std::vector< float >	EnergyLossSigma
std::vector< float >	ParamEnergyLossSigmaPlus
std::vector< float >	ParamEnergyLossSigmaMinus
std::vector< float >	MeasEnergyLossSigma
std::vector< int >	msInnerMatchDOF
std::vector< int >	msOuterMatchDOF
std::vector< int >	CaloMuonIDTag

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 Muon EDM. Will be exchanged for a generic auxiliary container type (AuxStoreInternal) later on.

Author

Edward Moyse

Definition at line 31 of file MuonAuxContainer_v5.h.

Member Typedef Documentation

auxid_set_t

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

inherited

The aux ID set type definition.

Definition at line 65 of file AuxContainerBase.h.

auxid_t

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

inherited

The aux ID type definition.

Definition at line 63 of file AuxContainerBase.h.

AuxVariable_t

template<class T , class ALLOC = std::allocator<T>>

using xAOD::AuxContainerBase::AuxVariable_t = std::vector<T, ALLOC>

inherited

Declare how to wrap variables for this sort of base.

Definition at line 183 of file AuxContainerBase.h.

guard_t

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

privateinherited

Definition at line 231 of file AuxContainerBase.h.

mutex_t

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

privateinherited

Mutex for multithread synchronization.

Definition at line 230 of file AuxContainerBase.h.

Member Enumeration Documentation

AuxStoreType

enum SG::IAuxStoreHolder::AuxStoreType

inherited

Type of the auxiliary store.

In the xAOD EDM we use auxiliary store objects in some cases to describe a single object, and in most cases to describe a container of objects. This enumeration declares which type the object implementing this interface is.

Enumerator
AST_ObjectStore	The store describes a single object.
AST_ContainerStore	The store describes a container.

Definition at line 66 of file IAuxStoreHolder.h.

                        {
         AST_ObjectStore    = 0, 
         AST_ContainerStore = 1  
      };

Constructor & Destructor Documentation

MuonAuxContainer_v5()

xAOD::MuonAuxContainer_v5::MuonAuxContainer_v5

(

)

Default constructor.

Definition at line 10 of file MuonAuxContainer_v5.cxx.

      : AuxContainerBase() {
 
        // iParticle
        AUX_VARIABLE( pt );
        AUX_VARIABLE( eta );
        AUX_VARIABLE( phi );
        AUX_VARIABLE(charge);
 
 
        // Muon summary
        AUX_VARIABLE( allAuthors );
        AUX_VARIABLE( author );
        AUX_VARIABLE( muonType );
        AUX_VARIABLE( quality ); //quality, passesIDCuts and passesHighPtCuts are packed in here.
 
        // Energyloss
        AUX_VARIABLE( energyLossType );
 
        // Muon-specific track summary (the other track summary information is retrieved from the TrackParticle)
        AUX_VARIABLE( numberOfPrecisionLayers );
        AUX_VARIABLE( numberOfPrecisionHoleLayers );
        AUX_VARIABLE( numberOfPhiLayers );
        AUX_VARIABLE( numberOfPhiHoleLayers );
        AUX_VARIABLE( numberOfTriggerEtaLayers );
        AUX_VARIABLE( numberOfTriggerEtaHoleLayers );
        AUX_VARIABLE( primarySector );
        AUX_VARIABLE( secondarySector );
 
        AUX_VARIABLE( innerSmallHits );
        AUX_VARIABLE( innerLargeHits );
        AUX_VARIABLE( middleSmallHits );
        AUX_VARIABLE( middleLargeHits );
        AUX_VARIABLE( outerSmallHits );
        AUX_VARIABLE( outerLargeHits );
        AUX_VARIABLE( extendedSmallHits );
        AUX_VARIABLE( extendedLargeHits );
 
        AUX_VARIABLE( innerSmallHoles );
        AUX_VARIABLE( innerLargeHoles );
        AUX_VARIABLE( middleSmallHoles );
        AUX_VARIABLE( middleLargeHoles );
        AUX_VARIABLE( outerSmallHoles );
        AUX_VARIABLE( outerLargeHoles );
        AUX_VARIABLE( extendedSmallHoles );
        AUX_VARIABLE( extendedLargeHoles );
 
        AUX_VARIABLE( phiLayer1Hits );
        AUX_VARIABLE( phiLayer2Hits );
        AUX_VARIABLE( phiLayer3Hits );
        AUX_VARIABLE( phiLayer4Hits );
 
        AUX_VARIABLE( etaLayer1Hits );
        AUX_VARIABLE( etaLayer2Hits );
        AUX_VARIABLE( etaLayer3Hits );
        AUX_VARIABLE( etaLayer4Hits );
 
        AUX_VARIABLE( phiLayer1Holes );
        AUX_VARIABLE( phiLayer2Holes );
        AUX_VARIABLE( phiLayer3Holes );
        AUX_VARIABLE( phiLayer4Holes );
 
        AUX_VARIABLE( etaLayer1Holes );
        AUX_VARIABLE( etaLayer2Holes );
        AUX_VARIABLE( etaLayer3Holes );
        AUX_VARIABLE( etaLayer4Holes );
 
        AUX_VARIABLE( phiLayer1RPCHits );
        AUX_VARIABLE( phiLayer2RPCHits );
        AUX_VARIABLE( phiLayer3RPCHits );
        AUX_VARIABLE( phiLayer4RPCHits );
 
        AUX_VARIABLE( etaLayer1RPCHits );
        AUX_VARIABLE( etaLayer2RPCHits );
        AUX_VARIABLE( etaLayer3RPCHits );
        AUX_VARIABLE( etaLayer4RPCHits );
 
        AUX_VARIABLE( phiLayer1RPCHoles );
        AUX_VARIABLE( phiLayer2RPCHoles );
        AUX_VARIABLE( phiLayer3RPCHoles );
        AUX_VARIABLE( phiLayer4RPCHoles );
 
        AUX_VARIABLE( etaLayer1RPCHoles );
        AUX_VARIABLE( etaLayer2RPCHoles );
        AUX_VARIABLE( etaLayer3RPCHoles );
        AUX_VARIABLE( etaLayer4RPCHoles );
 
        AUX_VARIABLE( phiLayer1TGCHits );
        AUX_VARIABLE( phiLayer2TGCHits );
        AUX_VARIABLE( phiLayer3TGCHits );
        AUX_VARIABLE( phiLayer4TGCHits );
 
        AUX_VARIABLE( etaLayer1TGCHits );
        AUX_VARIABLE( etaLayer2TGCHits );
        AUX_VARIABLE( etaLayer3TGCHits );
        AUX_VARIABLE( etaLayer4TGCHits );
 
        AUX_VARIABLE( phiLayer1TGCHoles );
        AUX_VARIABLE( phiLayer2TGCHoles );
        AUX_VARIABLE( phiLayer3TGCHoles );
        AUX_VARIABLE( phiLayer4TGCHoles );
 
        AUX_VARIABLE( etaLayer1TGCHoles );
        AUX_VARIABLE( etaLayer2TGCHoles );
        AUX_VARIABLE( etaLayer3TGCHoles );
        AUX_VARIABLE( etaLayer4TGCHoles );
 
        // New Small Wheel
        // STGC
        AUX_VARIABLE( phiLayer1STGCHits );
        AUX_VARIABLE( phiLayer2STGCHits );
 
        AUX_VARIABLE( etaLayer1STGCHits );
        AUX_VARIABLE( etaLayer2STGCHits );
 
    AUX_VARIABLE( phiLayer1STGCHoles );
        AUX_VARIABLE( phiLayer2STGCHoles );
 
    AUX_VARIABLE( etaLayer1STGCHoles );
    AUX_VARIABLE( etaLayer2STGCHoles );
 
        // MM
    AUX_VARIABLE( MMHits );
    AUX_VARIABLE( MMHoles );
        // Note: there is currently no MuonStationIndex for the two MM layers
    // In the future it might be needed to add them in order to have
        // separate counters as follows
        // AUX_VARIABLE( Layer1MMHits );
        // AUX_VARIABLE( Layer2MMHits );
        // AUX_VARIABLE( Layer1MMHoles );
    // AUX_VARIABLE( Layer2MMHoles );
 
    AUX_VARIABLE( cscEtaHits );
    AUX_VARIABLE( cscUnspoiledEtaHits );
 
        // Links
        AUX_VARIABLE( inDetTrackParticleLink );
        AUX_VARIABLE( muonSpectrometerTrackParticleLink );
        AUX_VARIABLE( extrapolatedMuonSpectrometerTrackParticleLink );
        AUX_VARIABLE( msOnlyExtrapolatedMuonSpectrometerTrackParticleLink );
        AUX_VARIABLE( combinedTrackParticleLink );
        AUX_VARIABLE( clusterLink );
        AUX_VARIABLE( muonSegmentLinks );
        
        // Paramdefs 
        AUX_VARIABLE(spectrometerFieldIntegral      );
        AUX_VARIABLE(scatteringCurvatureSignificance);
        AUX_VARIABLE(scatteringNeighbourSignificance);
        AUX_VARIABLE(momentumBalanceSignificance    );
        AUX_VARIABLE(segmentDeltaEta                );
        AUX_VARIABLE(segmentDeltaPhi                );
        AUX_VARIABLE(segmentChi2OverDoF             );
        AUX_VARIABLE(t0                             );
        AUX_VARIABLE(beta                           );
        AUX_VARIABLE(annBarrel                      );
        AUX_VARIABLE(annEndCap                      );
        AUX_VARIABLE(innAngle                       );
        AUX_VARIABLE(midAngle                       );
        AUX_VARIABLE(msInnerMatchChi2               );
        AUX_VARIABLE(meanDeltaADCCountsMDT          );
        AUX_VARIABLE(CaloLRLikelihood               );
    AUX_VARIABLE(CaloMuonScore                  );
    AUX_VARIABLE(EnergyLoss                     );
        AUX_VARIABLE(ParamEnergyLoss                );
        AUX_VARIABLE(MeasEnergyLoss                 );
        AUX_VARIABLE(EnergyLossSigma                );
        AUX_VARIABLE(ParamEnergyLossSigmaPlus       );
        AUX_VARIABLE(ParamEnergyLossSigmaMinus      );
        AUX_VARIABLE(MeasEnergyLossSigma            );
        AUX_VARIABLE(msInnerMatchDOF                );
        AUX_VARIABLE(msOuterMatchDOF                );
        AUX_VARIABLE(CaloMuonIDTag                  );
   }

Member Function Documentation

clearDecorations()

bool xAOD::AuxContainerBase::clearDecorations ( )

overridevirtualinherited

Clear all decorations.

Implements SG::IConstAuxStore.

Definition at line 325 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 = ids;
 
      return true;
   }

getAuxID() [1/2]

template<typename T >

auxid_t xAOD::AuxContainerBase::getAuxID ( const std::string &  name, SG::PackedContainer< T > &  , SG::AuxTypeRegistry::Flags  flags = SG::AuxTypeRegistry::Flags::None  )

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  )

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

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

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 227 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 void* result = m_store->getData( auxid );
            if( result ) {
              auxid_set_t& auxids_nc ATLAS_THREAD_SAFE =
                const_cast<auxid_set_t&> (m_auxids);
              auxids_nc.insert( auxid );
            }
            return result;
         } else {
            std::cout << "ERROR xAOD::AuxContainerBase::getData "
                      << "Unknown variable ("
                      << SG::AuxTypeRegistry::instance().getName( auxid )
                      << ") requested" << std::endl;
            return nullptr;
         }
      }
 
      // Update the statistics for this variable. The dynamic store registers
      // its own variable accesses.
      IOStats::instance().stats().readBranch( m_name, auxid );
 
      return m_vecs[ auxid ]->toPtr();
   }

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 395 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 );
            }
            return result;
         } else {
            std::cout << "ERROR xAOD::AuxContainerBase::getData "
                      << "Unknown variable ("
                      << SG::AuxTypeRegistry::instance().getName( auxid )
                      << ") requested" << std::endl;
            return nullptr;
         }
      }
      m_vecs[ auxid ]->reserve( capacity );
      m_vecs[ auxid ]->resize( size );
 
      return m_vecs[ auxid ]->toPtr();
   }

getData() [3/3]

virtual const void* SG::IConstAuxStore::getData

inherited

Pick up the const version from the base class.

getDecoration()

void * xAOD::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 273 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 );
           }
           return result;
         }
         // If we don't have a dynamic store, complain:
         else {
           std::cout << "ERROR xAOD::AuxContainerBase::getDecoration "
                     << "Can't provide variable "
                     << SG::AuxTypeRegistry::instance().getName( auxid )
                     << std::endl;
           return nullptr;
         }
       }
 
       // If the container is locked, static variables can't be accessed this
       // way:
       if( m_locked ) {
         throw SG::ExcStoreLocked( auxid );
       }
     }
 
     // If the container is not locked, then fall back on the normal accessor
     // function:
     return getData( auxid, size, capacity );
   }

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 628 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 ) {
         // 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 586 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::cout << "ERROR xAOD::AuxContainerBase::getIOData "
                      << "Unknown variable ("
                      << SG::AuxTypeRegistry::instance().getName( auxid )
                      << ") requested" << std::endl;
            return nullptr;
         }
      }
 
      // Update the statistics for this variable. The dynamic store registers
      // its own variable accesses.
      IOStats::instance().stats().readBranch( m_name, auxid );
 
      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 611 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 648 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 ) {
         // 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 178 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 151 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 92 of file AuxContainerBase.h.

{ return AST_ContainerStore; }

getWritableAuxIDs()

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

overridevirtualinherited

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 424 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]

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 510 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" );
      }
 
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      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];
        if (v_dst) {
          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,
                                      reinterpret_cast<char*>(src_ptr) + other_size*r.getEltSize(id),
                                      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;
   }

insertMove() [2/2]

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

pure virtualinherited

Move all elements from other to this store.

Parameters

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

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

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

Implemented in SG::AuxStoreInternal.

isDecoration()

bool xAOD::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 264 of file AuxContainerBase.cxx.

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

lock()

void xAOD::AuxContainerBase::lock ( )

overridevirtualinherited

Lock the container.

Implements ILockable.

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

Implements SG::IConstAuxStore.

Reimplemented in xAOD::EventInfoAuxContainer_v1.

Definition at line 355 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 156 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 670 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 459 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:
      std::vector< SG::IAuxTypeVector* >::iterator itr = m_vecs.begin();
      std::vector< SG::IAuxTypeVector* >::iterator end = m_vecs.end();
      for( ; itr != end; ++itr ) {
         if( *itr ) ( *itr )->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 431 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) {
           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 675 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 565 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 192 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 484 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:
      std::vector< SG::IAuxTypeVector* >::iterator itr = m_vecs.begin();
      std::vector< SG::IAuxTypeVector* >::iterator end = m_vecs.end();
      for( ; itr != end; ++itr ) {
         if( *itr ) ( *itr )->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.

Implements SG::IConstAuxStore.

Definition at line 363 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 ] ) {
            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;
   }

Member Data Documentation

allAuthors

std::vector< uint16_t > xAOD::MuonAuxContainer_v5::allAuthors

private

Definition at line 48 of file MuonAuxContainer_v5.h.

annBarrel

std::vector< float> xAOD::MuonAuxContainer_v5::annBarrel

private

Definition at line 200 of file MuonAuxContainer_v5.h.

annEndCap

std::vector< float> xAOD::MuonAuxContainer_v5::annEndCap

private

Definition at line 201 of file MuonAuxContainer_v5.h.

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

author

std::vector< uint16_t> xAOD::MuonAuxContainer_v5::author

private

Definition at line 49 of file MuonAuxContainer_v5.h.

beta

std::vector< float> xAOD::MuonAuxContainer_v5::beta

private

Definition at line 199 of file MuonAuxContainer_v5.h.

CaloLRLikelihood

std::vector< float> xAOD::MuonAuxContainer_v5::CaloLRLikelihood

private

Definition at line 206 of file MuonAuxContainer_v5.h.

CaloMuonIDTag

std::vector< int > xAOD::MuonAuxContainer_v5::CaloMuonIDTag

private

Definition at line 217 of file MuonAuxContainer_v5.h.

CaloMuonScore

std::vector< float> xAOD::MuonAuxContainer_v5::CaloMuonScore

private

Definition at line 207 of file MuonAuxContainer_v5.h.

charge

std::vector< float > xAOD::MuonAuxContainer_v5::charge

private

Definition at line 43 of file MuonAuxContainer_v5.h.

clusterLink

std::vector<ElementLink< CaloClusterContainer > > xAOD::MuonAuxContainer_v5::clusterLink

private

Definition at line 180 of file MuonAuxContainer_v5.h.

combinedTrackParticleLink

std::vector<ElementLink< TrackParticleContainer > > xAOD::MuonAuxContainer_v5::combinedTrackParticleLink

private

Definition at line 179 of file MuonAuxContainer_v5.h.

cscEtaHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::cscEtaHits

private

Definition at line 168 of file MuonAuxContainer_v5.h.

cscUnspoiledEtaHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::cscUnspoiledEtaHits

private

Definition at line 169 of file MuonAuxContainer_v5.h.

EnergyLoss

std::vector< float> xAOD::MuonAuxContainer_v5::EnergyLoss

private

Definition at line 208 of file MuonAuxContainer_v5.h.

EnergyLossSigma

std::vector< float> xAOD::MuonAuxContainer_v5::EnergyLossSigma

private

Definition at line 211 of file MuonAuxContainer_v5.h.

energyLossType

std::vector< uint8_t> xAOD::MuonAuxContainer_v5::energyLossType

private

Definition at line 186 of file MuonAuxContainer_v5.h.

eta

std::vector< float > xAOD::MuonAuxContainer_v5::eta

private

Definition at line 41 of file MuonAuxContainer_v5.h.

etaLayer1Hits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer1Hits

private

Definition at line 89 of file MuonAuxContainer_v5.h.

etaLayer1Holes

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer1Holes

private

Definition at line 99 of file MuonAuxContainer_v5.h.

etaLayer1RPCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer1RPCHits

private

Definition at line 109 of file MuonAuxContainer_v5.h.

etaLayer1RPCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer1RPCHoles

private

Definition at line 119 of file MuonAuxContainer_v5.h.

etaLayer1STGCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer1STGCHits

private

Definition at line 148 of file MuonAuxContainer_v5.h.

etaLayer1STGCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer1STGCHoles

private

Definition at line 154 of file MuonAuxContainer_v5.h.

etaLayer1TGCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer1TGCHits

private

Definition at line 129 of file MuonAuxContainer_v5.h.

etaLayer1TGCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer1TGCHoles

private

Definition at line 139 of file MuonAuxContainer_v5.h.

etaLayer2Hits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer2Hits

private

Definition at line 90 of file MuonAuxContainer_v5.h.

etaLayer2Holes

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer2Holes

private

Definition at line 100 of file MuonAuxContainer_v5.h.

etaLayer2RPCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer2RPCHits

private

Definition at line 110 of file MuonAuxContainer_v5.h.

etaLayer2RPCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer2RPCHoles

private

Definition at line 120 of file MuonAuxContainer_v5.h.

etaLayer2STGCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer2STGCHits

private

Definition at line 149 of file MuonAuxContainer_v5.h.

etaLayer2STGCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer2STGCHoles

private

Definition at line 155 of file MuonAuxContainer_v5.h.

etaLayer2TGCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer2TGCHits

private

Definition at line 130 of file MuonAuxContainer_v5.h.

etaLayer2TGCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer2TGCHoles

private

Definition at line 140 of file MuonAuxContainer_v5.h.

etaLayer3Hits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer3Hits

private

Definition at line 91 of file MuonAuxContainer_v5.h.

etaLayer3Holes

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer3Holes

private

Definition at line 101 of file MuonAuxContainer_v5.h.

etaLayer3RPCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer3RPCHits

private

Definition at line 111 of file MuonAuxContainer_v5.h.

etaLayer3RPCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer3RPCHoles

private

Definition at line 121 of file MuonAuxContainer_v5.h.

etaLayer3TGCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer3TGCHits

private

Definition at line 131 of file MuonAuxContainer_v5.h.

etaLayer3TGCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer3TGCHoles

private

Definition at line 141 of file MuonAuxContainer_v5.h.

etaLayer4Hits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer4Hits

private

Definition at line 92 of file MuonAuxContainer_v5.h.

etaLayer4Holes

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer4Holes

private

Definition at line 102 of file MuonAuxContainer_v5.h.

etaLayer4RPCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer4RPCHits

private

Definition at line 112 of file MuonAuxContainer_v5.h.

etaLayer4RPCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer4RPCHoles

private

Definition at line 122 of file MuonAuxContainer_v5.h.

etaLayer4TGCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer4TGCHits

private

Definition at line 132 of file MuonAuxContainer_v5.h.

etaLayer4TGCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::etaLayer4TGCHoles

private

Definition at line 142 of file MuonAuxContainer_v5.h.

extendedLargeHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::extendedLargeHits

private

Definition at line 73 of file MuonAuxContainer_v5.h.

extendedLargeHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::extendedLargeHoles

private

Definition at line 82 of file MuonAuxContainer_v5.h.

extendedSmallHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::extendedSmallHits

private

Definition at line 72 of file MuonAuxContainer_v5.h.

extendedSmallHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::extendedSmallHoles

private

Definition at line 81 of file MuonAuxContainer_v5.h.

extrapolatedMuonSpectrometerTrackParticleLink

std::vector<ElementLink< TrackParticleContainer > > xAOD::MuonAuxContainer_v5::extrapolatedMuonSpectrometerTrackParticleLink

private

Definition at line 177 of file MuonAuxContainer_v5.h.

inDetTrackParticleLink

std::vector<ElementLink< TrackParticleContainer > > xAOD::MuonAuxContainer_v5::inDetTrackParticleLink

private

Definition at line 175 of file MuonAuxContainer_v5.h.

innAngle

std::vector< float> xAOD::MuonAuxContainer_v5::innAngle

private

Definition at line 202 of file MuonAuxContainer_v5.h.

innerLargeHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::innerLargeHits

private

Definition at line 67 of file MuonAuxContainer_v5.h.

innerLargeHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::innerLargeHoles

private

Definition at line 76 of file MuonAuxContainer_v5.h.

innerSmallHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::innerSmallHits

private

Definition at line 66 of file MuonAuxContainer_v5.h.

innerSmallHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::innerSmallHoles

private

Definition at line 75 of file MuonAuxContainer_v5.h.

m_auxids

auxid_set_t xAOD::AuxContainerBase::m_auxids

privateinherited

Internal list of all available variables.

Definition at line 216 of file AuxContainerBase.h.

m_locked

bool xAOD::AuxContainerBase::m_locked

privateinherited

Has the container been locked?

Definition at line 227 of file AuxContainerBase.h.

m_mutex

mutex_t xAOD::AuxContainerBase::m_mutex

mutableprivateinherited

Definition at line 232 of file AuxContainerBase.h.

m_name

std::string xAOD::AuxContainerBase::m_name

privateinherited

Name of the container in memory. Set externally.

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

m_store

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

privateinherited

Internal dynamic auxiliary store object.

Definition at line 221 of file AuxContainerBase.h.

m_storeIO

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

privateinherited

The IO interface to the internal auxiliary store.

Definition at line 223 of file AuxContainerBase.h.

m_vecs

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

privateinherited

Internal list of all managed variables.

Definition at line 218 of file AuxContainerBase.h.

meanDeltaADCCountsMDT

std::vector< float> xAOD::MuonAuxContainer_v5::meanDeltaADCCountsMDT

private

Definition at line 205 of file MuonAuxContainer_v5.h.

MeasEnergyLoss

std::vector< float> xAOD::MuonAuxContainer_v5::MeasEnergyLoss

private

Definition at line 210 of file MuonAuxContainer_v5.h.

MeasEnergyLossSigma

std::vector< float> xAOD::MuonAuxContainer_v5::MeasEnergyLossSigma

private

Definition at line 214 of file MuonAuxContainer_v5.h.

midAngle

std::vector< float> xAOD::MuonAuxContainer_v5::midAngle

private

Definition at line 203 of file MuonAuxContainer_v5.h.

middleLargeHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::middleLargeHits

private

Definition at line 69 of file MuonAuxContainer_v5.h.

middleLargeHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::middleLargeHoles

private

Definition at line 78 of file MuonAuxContainer_v5.h.

middleSmallHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::middleSmallHits

private

Definition at line 68 of file MuonAuxContainer_v5.h.

middleSmallHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::middleSmallHoles

private

Definition at line 77 of file MuonAuxContainer_v5.h.

MMHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::MMHits

private

Definition at line 158 of file MuonAuxContainer_v5.h.

MMHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::MMHoles

private

Definition at line 159 of file MuonAuxContainer_v5.h.

momentumBalanceSignificance

std::vector< float> xAOD::MuonAuxContainer_v5::momentumBalanceSignificance

private

Definition at line 194 of file MuonAuxContainer_v5.h.

msInnerMatchChi2

std::vector< float> xAOD::MuonAuxContainer_v5::msInnerMatchChi2

private

Definition at line 204 of file MuonAuxContainer_v5.h.

msInnerMatchDOF

std::vector< int > xAOD::MuonAuxContainer_v5::msInnerMatchDOF

private

Definition at line 215 of file MuonAuxContainer_v5.h.

msOnlyExtrapolatedMuonSpectrometerTrackParticleLink

std::vector<ElementLink< TrackParticleContainer > > xAOD::MuonAuxContainer_v5::msOnlyExtrapolatedMuonSpectrometerTrackParticleLink

private

Definition at line 178 of file MuonAuxContainer_v5.h.

msOuterMatchDOF

std::vector< int > xAOD::MuonAuxContainer_v5::msOuterMatchDOF

private

Definition at line 216 of file MuonAuxContainer_v5.h.

muonSegmentLinks

std::vector<std::vector<ElementLink< MuonSegmentContainer > > > xAOD::MuonAuxContainer_v5::muonSegmentLinks

private

Definition at line 181 of file MuonAuxContainer_v5.h.

muonSpectrometerTrackParticleLink

std::vector<ElementLink< TrackParticleContainer > > xAOD::MuonAuxContainer_v5::muonSpectrometerTrackParticleLink

private

Definition at line 176 of file MuonAuxContainer_v5.h.

muonType

std::vector< uint16_t> xAOD::MuonAuxContainer_v5::muonType

private

Definition at line 50 of file MuonAuxContainer_v5.h.

numberOfPhiHoleLayers

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

private

Definition at line 60 of file MuonAuxContainer_v5.h.

numberOfPhiLayers

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

private

Definition at line 59 of file MuonAuxContainer_v5.h.

numberOfPrecisionHoleLayers

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

private

Definition at line 58 of file MuonAuxContainer_v5.h.

numberOfPrecisionLayers

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

private

Definition at line 57 of file MuonAuxContainer_v5.h.

numberOfTriggerEtaHoleLayers

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

private

Definition at line 62 of file MuonAuxContainer_v5.h.

numberOfTriggerEtaLayers

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

private

Definition at line 61 of file MuonAuxContainer_v5.h.

outerLargeHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::outerLargeHits

private

Definition at line 71 of file MuonAuxContainer_v5.h.

outerLargeHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::outerLargeHoles

private

Definition at line 80 of file MuonAuxContainer_v5.h.

outerSmallHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::outerSmallHits

private

Definition at line 70 of file MuonAuxContainer_v5.h.

outerSmallHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::outerSmallHoles

private

Definition at line 79 of file MuonAuxContainer_v5.h.

ParamEnergyLoss

std::vector< float> xAOD::MuonAuxContainer_v5::ParamEnergyLoss

private

Definition at line 209 of file MuonAuxContainer_v5.h.

ParamEnergyLossSigmaMinus

std::vector< float> xAOD::MuonAuxContainer_v5::ParamEnergyLossSigmaMinus

private

Definition at line 213 of file MuonAuxContainer_v5.h.

ParamEnergyLossSigmaPlus

std::vector< float> xAOD::MuonAuxContainer_v5::ParamEnergyLossSigmaPlus

private

Definition at line 212 of file MuonAuxContainer_v5.h.

phi

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

private

Definition at line 42 of file MuonAuxContainer_v5.h.

phiLayer1Hits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer1Hits

private

Definition at line 84 of file MuonAuxContainer_v5.h.

phiLayer1Holes

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer1Holes

private

Definition at line 94 of file MuonAuxContainer_v5.h.

phiLayer1RPCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer1RPCHits

private

Definition at line 104 of file MuonAuxContainer_v5.h.

phiLayer1RPCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer1RPCHoles

private

Definition at line 114 of file MuonAuxContainer_v5.h.

phiLayer1STGCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer1STGCHits

private

Definition at line 145 of file MuonAuxContainer_v5.h.

phiLayer1STGCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer1STGCHoles

private

Definition at line 151 of file MuonAuxContainer_v5.h.

phiLayer1TGCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer1TGCHits

private

Definition at line 124 of file MuonAuxContainer_v5.h.

phiLayer1TGCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer1TGCHoles

private

Definition at line 134 of file MuonAuxContainer_v5.h.

phiLayer2Hits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer2Hits

private

Definition at line 85 of file MuonAuxContainer_v5.h.

phiLayer2Holes

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer2Holes

private

Definition at line 95 of file MuonAuxContainer_v5.h.

phiLayer2RPCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer2RPCHits

private

Definition at line 105 of file MuonAuxContainer_v5.h.

phiLayer2RPCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer2RPCHoles

private

Definition at line 115 of file MuonAuxContainer_v5.h.

phiLayer2STGCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer2STGCHits

private

Definition at line 146 of file MuonAuxContainer_v5.h.

phiLayer2STGCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer2STGCHoles

private

Definition at line 152 of file MuonAuxContainer_v5.h.

phiLayer2TGCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer2TGCHits

private

Definition at line 125 of file MuonAuxContainer_v5.h.

phiLayer2TGCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer2TGCHoles

private

Definition at line 135 of file MuonAuxContainer_v5.h.

phiLayer3Hits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer3Hits

private

Definition at line 86 of file MuonAuxContainer_v5.h.

phiLayer3Holes

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer3Holes

private

Definition at line 96 of file MuonAuxContainer_v5.h.

phiLayer3RPCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer3RPCHits

private

Definition at line 106 of file MuonAuxContainer_v5.h.

phiLayer3RPCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer3RPCHoles

private

Definition at line 116 of file MuonAuxContainer_v5.h.

phiLayer3TGCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer3TGCHits

private

Definition at line 126 of file MuonAuxContainer_v5.h.

phiLayer3TGCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer3TGCHoles

private

Definition at line 136 of file MuonAuxContainer_v5.h.

phiLayer4Hits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer4Hits

private

Definition at line 87 of file MuonAuxContainer_v5.h.

phiLayer4Holes

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer4Holes

private

Definition at line 97 of file MuonAuxContainer_v5.h.

phiLayer4RPCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer4RPCHits

private

Definition at line 107 of file MuonAuxContainer_v5.h.

phiLayer4RPCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer4RPCHoles

private

Definition at line 117 of file MuonAuxContainer_v5.h.

phiLayer4TGCHits

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer4TGCHits

private

Definition at line 127 of file MuonAuxContainer_v5.h.

phiLayer4TGCHoles

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::phiLayer4TGCHoles

private

Definition at line 137 of file MuonAuxContainer_v5.h.

primarySector

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::primarySector

private

Definition at line 63 of file MuonAuxContainer_v5.h.

pt

std::vector< float > xAOD::MuonAuxContainer_v5::pt

private

Definition at line 40 of file MuonAuxContainer_v5.h.

quality

std::vector< uint8_t> xAOD::MuonAuxContainer_v5::quality

private

Definition at line 51 of file MuonAuxContainer_v5.h.

scatteringCurvatureSignificance

std::vector< float> xAOD::MuonAuxContainer_v5::scatteringCurvatureSignificance

private

Definition at line 192 of file MuonAuxContainer_v5.h.

scatteringNeighbourSignificance

std::vector< float> xAOD::MuonAuxContainer_v5::scatteringNeighbourSignificance

private

Definition at line 193 of file MuonAuxContainer_v5.h.

secondarySector

std::vector< uint8_t > xAOD::MuonAuxContainer_v5::secondarySector

private

Definition at line 64 of file MuonAuxContainer_v5.h.

segmentChi2OverDoF

std::vector< float> xAOD::MuonAuxContainer_v5::segmentChi2OverDoF

private

Definition at line 197 of file MuonAuxContainer_v5.h.

segmentDeltaEta

std::vector< float> xAOD::MuonAuxContainer_v5::segmentDeltaEta

private

Definition at line 195 of file MuonAuxContainer_v5.h.

segmentDeltaPhi

std::vector< float> xAOD::MuonAuxContainer_v5::segmentDeltaPhi

private

Definition at line 196 of file MuonAuxContainer_v5.h.

spectrometerFieldIntegral

std::vector< float> xAOD::MuonAuxContainer_v5::spectrometerFieldIntegral

private

Definition at line 191 of file MuonAuxContainer_v5.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 189 of file IAuxStore.h.

t0

std::vector< float> xAOD::MuonAuxContainer_v5::t0

private

Definition at line 198 of file MuonAuxContainer_v5.h.

---

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

• MuonAuxContainer_v5.h
• MuonAuxContainer_v5.cxx