Auxiliary container for muon SA containers. More...

#include <L2StandAloneMuonAuxContainer_v2.h>

Inheritance diagram for xAOD::L2StandAloneMuonAuxContainer_v2:

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
	L2StandAloneMuonAuxContainer_v2 ()
	Default constructor.
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 > &vec)
	Register one of the persistent variables internally.
template<typename T>
void	regAuxVar (auxid_t auxid, const std::string &name, SG::PackedContainer< T > &vec)
	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 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 &vec)
	Common code between regAuxVar cases.

Private Attributes
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.
4-momentum variables
std::vector< float >	pt
std::vector< float >	phi
std::vector< float >	eta
L2 muon specific variables
Outputs of L2 muon standalone algorithm
std::vector< uint32_t >	roiWord
std::vector< int >	sAddress
std::vector< float >	rMS
	Position at MS.
std::vector< float >	etaMS
std::vector< float >	phiMS
std::vector< float >	dirPhiMS
std::vector< float >	zMS
std::vector< float >	dirZMS
std::vector< float >	beta
std::vector< float >	barrelRadius
	Input measurements to be converted to pT by LUT.
std::vector< float >	barrelSagitta
std::vector< float >	endcapAlpha
std::vector< float >	endcapBeta
std::vector< float >	endcapRadius
std::vector< float >	etaMap
	eta, phi as input to LUT
std::vector< float >	phiMap
std::vector< int >	etaBin
std::vector< int >	phiBin
std::vector< int >	isTgcFailure
	Flag for RGC and RPC availabilities.
std::vector< int >	isRpcFailure
std::vector< float >	deltaPt
	Error of pt, eta and phi.
std::vector< float >	deltaPtParm1
std::vector< float >	deltaPtParm2
std::vector< float >	deltaPtParm3
std::vector< float >	deltaEta
std::vector< float >	deltaPhi
std::vector< std::vector< float > >	superPointR
	Station fit results (superpoints)
std::vector< std::vector< float > >	superPointZ
std::vector< std::vector< float > >	superPointSlope
std::vector< std::vector< float > >	superPointIntercept
std::vector< std::vector< float > >	superPointChi2
std::vector< std::vector< float > >	trackPositionR
	Track positions.
std::vector< std::vector< float > >	trackPositionZ
std::vector< std::vector< float > >	trackPositionEta
std::vector< std::vector< float > >	trackPositionPhi
std::vector< int >	algoId
	Detailed information.
std::vector< uint32_t >	teId
std::vector< uint32_t >	lvl1Id
std::vector< uint32_t >	lumiBlock
std::vector< uint32_t >	muonDetMask
std::vector< uint32_t >	roiId
std::vector< uint32_t >	roiSystem
std::vector< uint32_t >	roiSubsystem
std::vector< uint32_t >	roiSector
std::vector< uint32_t >	roiNumber
std::vector< uint32_t >	roiThreshold
std::vector< float >	roiEta
std::vector< float >	roiPhi
std::vector< float >	tgcPt
	pT from different algorithms
std::vector< float >	ptBarrelRadius
std::vector< float >	ptBarrelSagitta
std::vector< float >	ptEndcapAlpha
std::vector< float >	ptEndcapBeta
std::vector< float >	ptEndcapRadius
std::vector< float >	ptCSC
std::vector< std::vector< int > >	chamberType1Normal
	Road information Chamber type.
std::vector< std::vector< int > >	chamberType1Overlap
std::vector< std::vector< int > >	chamberType2Normal
std::vector< std::vector< int > >	chamberType2Overlap
std::vector< std::vector< float > >	roadAwNormal
	Slope.
std::vector< std::vector< float > >	roadAwOverlap
std::vector< std::vector< float > >	roadBwNormal
	Intercept.
std::vector< std::vector< float > >	roadBwOverlap
std::vector< std::vector< float > >	zMinNormal
	Z.
std::vector< std::vector< float > >	zMinOverlap
std::vector< std::vector< float > >	zMaxNormal
std::vector< std::vector< float > >	zMaxOverlap
std::vector< std::vector< float > >	rMinNormal
	R.
std::vector< std::vector< float > >	rMinOverlap
std::vector< std::vector< float > >	rMaxNormal
std::vector< std::vector< float > >	rMaxOverlap
std::vector< std::vector< float > >	etaMinNormal
	Eta.
std::vector< std::vector< float > >	etaMinOverlap
std::vector< std::vector< float > >	etaMaxNormal
std::vector< std::vector< float > >	etaMaxOverlap
std::vector< float >	tgcInnEta
	TGC fit results.
std::vector< float >	tgcInnPhi
std::vector< float >	tgcInnR
std::vector< float >	tgcInnZ
std::vector< float >	tgcMid1Eta
std::vector< float >	tgcMid1Phi
std::vector< float >	tgcMid1R
std::vector< float >	tgcMid1Z
std::vector< float >	tgcMid2Eta
std::vector< float >	tgcMid2Phi
std::vector< float >	tgcMid2R
std::vector< float >	tgcMid2Z
std::vector< float >	tgcInnRhoStd
std::vector< long >	tgcInnRhoN
std::vector< float >	tgcInnPhiStd
std::vector< long >	tgcInnPhiN
std::vector< float >	tgcMidRhoChi2
std::vector< long >	tgcMidRhoN
std::vector< float >	tgcMidPhiChi2
std::vector< long >	tgcMidPhiN
std::vector< float >	rpcFitInnPhi
	RPC fit results.
std::vector< float >	rpcFitInnSlope
std::vector< float >	rpcFitInnOffset
std::vector< float >	rpcFitMidPhi
std::vector< float >	rpcFitMidSlope
std::vector< float >	rpcFitMidOffset
std::vector< float >	rpcFitOutPhi
std::vector< float >	rpcFitOutSlope
std::vector< float >	rpcFitOutOffset
std::vector< int >	rpcHitsCapacity
	Size of hit strages.
std::vector< int >	tgcHitsCapacity
std::vector< int >	mdtHitsCapacity
std::vector< int >	cscHitsCapacity
std::vector< std::vector< uint32_t > >	rpcHitLayer
	RPC pad hits.
std::vector< std::vector< uint32_t > >	rpcHitMeasuresPhi
std::vector< std::vector< float > >	rpcHitX
std::vector< std::vector< float > >	rpcHitY
std::vector< std::vector< float > >	rpcHitZ
std::vector< std::vector< float > >	rpcHitTime
std::vector< std::vector< float > >	rpcHitDistToEtaReadout
std::vector< std::vector< float > >	rpcHitDistToPhiReadout
std::vector< std::vector< std::string > >	rpcHitStationName
std::vector< std::vector< float > >	tgcHitEta
	TGC hits.
std::vector< std::vector< float > >	tgcHitPhi
std::vector< std::vector< float > >	tgcHitR
std::vector< std::vector< float > >	tgcHitZ
std::vector< std::vector< float > >	tgcHitWidth
std::vector< std::vector< int > >	tgcHitStationNum
std::vector< std::vector< bool > >	tgcHitIsStrip
std::vector< std::vector< int > >	tgcHitBCTag
std::vector< std::vector< bool > >	tgcHitInRoad
std::vector< std::vector< uint32_t > >	mdtHitOnlineId
	MDT hits.
std::vector< std::vector< int > >	mdtHitIsOutlier
std::vector< std::vector< int > >	mdtHitChamberId
std::vector< std::vector< float > >	mdtHitR
std::vector< std::vector< float > >	mdtHitZ
std::vector< std::vector< float > >	mdtHitPhi
std::vector< std::vector< float > >	mdtHitResidual
std::vector< std::vector< float > >	mdtHitTime
std::vector< std::vector< float > >	mdtHitSpace
std::vector< std::vector< float > >	mdtHitSigma
std::vector< std::vector< int > >	cscHitIsOutlier
	CSC hits.
std::vector< std::vector< int > >	cscHitChamberId
std::vector< std::vector< uint32_t > >	cscHitStationName
std::vector< std::vector< int > >	cscHitStationEta
std::vector< std::vector< int > >	cscHitStationPhi
std::vector< std::vector< int > >	cscHitChamberLayer
std::vector< std::vector< int > >	cscHitWireLayer
std::vector< std::vector< int > >	cscHitMeasuresPhi
std::vector< std::vector< int > >	cscHitStrip
std::vector< std::vector< float > >	cscHitEta
std::vector< std::vector< float > >	cscHitPhi
std::vector< std::vector< float > >	cscHitR
std::vector< std::vector< float > >	cscHitZ
std::vector< std::vector< int > >	cscHitCharge
std::vector< std::vector< float > >	cscHitTime
std::vector< std::vector< float > >	cscHitResidual
std::vector< std::vector< unsigned int > >	stgcClusterLayer
std::vector< std::vector< int > >	stgcClusterIsOutlier
std::vector< std::vector< int > >	stgcClusterType
std::vector< std::vector< float > >	stgcClusterEta
std::vector< std::vector< float > >	stgcClusterPhi
std::vector< std::vector< float > >	stgcClusterR
std::vector< std::vector< float > >	stgcClusterZ
std::vector< std::vector< float > >	stgcClusterResidualR
std::vector< std::vector< float > >	stgcClusterResidualPhi
std::vector< std::vector< int > >	stgcClusterStationEta
std::vector< std::vector< int > >	stgcClusterStationPhi
std::vector< std::vector< int > >	stgcClusterStationName
std::vector< std::vector< unsigned int > >	mmClusterLayer
std::vector< std::vector< int > >	mmClusterIsOutlier
std::vector< std::vector< float > >	mmClusterEta
std::vector< std::vector< float > >	mmClusterPhi
std::vector< std::vector< float > >	mmClusterR
std::vector< std::vector< float > >	mmClusterZ
std::vector< std::vector< float > >	mmClusterResidualR
std::vector< std::vector< float > >	mmClusterResidualPhi
std::vector< std::vector< int > >	mmClusterStationEta
std::vector< std::vector< int > >	mmClusterStationPhi
std::vector< std::vector< int > >	mmClusterStationName

Detailed Description

Auxiliary container for muon SA containers.

This is a fixed implementation of the muon SA auxiliary store. Defining every possible property that muon SA can have.

Author: Masaki Ishitsuka ishit.nosp@m.suka.nosp@m.@phys.nosp@m..tit.nosp@m.ech.a.nosp@m.c.jp

$Revsision$

Date: 2015-04-18 06:31:23 +0200 (Sat, 18 Apr 2015)

Definition at line 32 of file L2StandAloneMuonAuxContainer_v2.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 191 of file AuxContainerBase.h.

◆ guard_t

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

privateinherited

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

◆ mutex_t

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

privateinherited

Mutex for multithread synchronization.

Definition at line 242 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

◆ L2StandAloneMuonAuxContainer_v2()

xAOD::L2StandAloneMuonAuxContainer_v2::L2StandAloneMuonAuxContainer_v2 ( )

Default constructor.

Definition at line 12 of file L2StandAloneMuonAuxContainer_v2.cxx.

      : AuxContainerBase() {
 
      AUX_VARIABLE( pt );
      AUX_VARIABLE( phi );
      AUX_VARIABLE( eta );
 
      AUX_VARIABLE( roiWord );
      AUX_VARIABLE( sAddress );
      AUX_VARIABLE( rMS );
      AUX_VARIABLE( etaMS );
      AUX_VARIABLE( phiMS );
      AUX_VARIABLE( dirPhiMS );
      AUX_VARIABLE( zMS );
      AUX_VARIABLE( dirZMS );
      AUX_VARIABLE( beta );
 
      AUX_VARIABLE( barrelRadius );
      AUX_VARIABLE( barrelSagitta );
 
      AUX_VARIABLE( endcapAlpha );
      AUX_VARIABLE( endcapBeta );
      AUX_VARIABLE( endcapRadius );
 
      AUX_VARIABLE( etaMap );
      AUX_VARIABLE( phiMap );
      AUX_VARIABLE( etaBin );
      AUX_VARIABLE( phiBin );
 
      AUX_VARIABLE( isTgcFailure );
      AUX_VARIABLE( isRpcFailure );
 
      AUX_VARIABLE( deltaPt );
      AUX_VARIABLE( deltaPtParm1 );
      AUX_VARIABLE( deltaPtParm2 );
      AUX_VARIABLE( deltaPtParm3 );
      AUX_VARIABLE( deltaEta );
      AUX_VARIABLE( deltaPhi );
 
      AUX_VARIABLE( superPointR );
      AUX_VARIABLE( superPointZ );
      AUX_VARIABLE( superPointSlope );
      AUX_VARIABLE( superPointIntercept );
      AUX_VARIABLE( superPointChi2 );
 
      AUX_VARIABLE( trackPositionR );
      AUX_VARIABLE( trackPositionZ );
      AUX_VARIABLE( trackPositionEta );
      AUX_VARIABLE( trackPositionPhi );
 
      AUX_VARIABLE( algoId );
      AUX_VARIABLE( teId );
      AUX_VARIABLE( lvl1Id );
      AUX_VARIABLE( lumiBlock );
      AUX_VARIABLE( muonDetMask );
      AUX_VARIABLE( roiId );
      AUX_VARIABLE( roiSystem );
      AUX_VARIABLE( roiSubsystem );
      AUX_VARIABLE( roiSector );
      AUX_VARIABLE( roiNumber );
      AUX_VARIABLE( roiThreshold );
      AUX_VARIABLE( roiEta );
      AUX_VARIABLE( roiPhi );
 
      AUX_VARIABLE( tgcPt );
      AUX_VARIABLE( ptBarrelRadius );
      AUX_VARIABLE( ptBarrelSagitta );
      AUX_VARIABLE( ptEndcapAlpha );
      AUX_VARIABLE( ptEndcapBeta );
      AUX_VARIABLE( ptEndcapRadius );
      AUX_VARIABLE( ptCSC );
 
      AUX_VARIABLE( chamberType1Normal );
      AUX_VARIABLE( chamberType1Overlap );
      AUX_VARIABLE( chamberType2Normal );
      AUX_VARIABLE( chamberType2Overlap );
 
      AUX_VARIABLE( roadAwNormal );
      AUX_VARIABLE( roadAwOverlap );
 
      AUX_VARIABLE( roadBwNormal );
      AUX_VARIABLE( roadBwOverlap );
 
      AUX_VARIABLE( zMinNormal );
      AUX_VARIABLE( zMinOverlap );
      AUX_VARIABLE( zMaxNormal );
      AUX_VARIABLE( zMaxOverlap );
 
      AUX_VARIABLE( rMinNormal );
      AUX_VARIABLE( rMinOverlap );
      AUX_VARIABLE( rMaxNormal );
      AUX_VARIABLE( rMaxOverlap );
 
      AUX_VARIABLE( etaMinNormal );
      AUX_VARIABLE( etaMinOverlap );
      AUX_VARIABLE( etaMaxNormal );
      AUX_VARIABLE( etaMaxOverlap );
 
      AUX_VARIABLE( tgcInnEta );
      AUX_VARIABLE( tgcInnPhi );
      AUX_VARIABLE( tgcInnR );
      AUX_VARIABLE( tgcInnZ );
 
      AUX_VARIABLE( tgcInnRhoStd );
      AUX_VARIABLE( tgcInnRhoN );
      AUX_VARIABLE( tgcInnPhiStd );
      AUX_VARIABLE( tgcInnPhiN );
 
      AUX_VARIABLE( tgcMid1Eta );
      AUX_VARIABLE( tgcMid1Phi );
      AUX_VARIABLE( tgcMid1R );
      AUX_VARIABLE( tgcMid1Z );
 
      AUX_VARIABLE( tgcMid2Eta );
      AUX_VARIABLE( tgcMid2Phi );
      AUX_VARIABLE( tgcMid2R );
      AUX_VARIABLE( tgcMid2Z );
 
      AUX_VARIABLE( tgcMidRhoChi2 );
      AUX_VARIABLE( tgcMidRhoN );
      AUX_VARIABLE( tgcMidPhiChi2 );
      AUX_VARIABLE( tgcMidPhiN );
 
      AUX_VARIABLE( rpcFitInnPhi );
      AUX_VARIABLE( rpcFitInnSlope );
      AUX_VARIABLE( rpcFitInnOffset );
 
      AUX_VARIABLE( rpcFitMidPhi );
      AUX_VARIABLE( rpcFitMidSlope );
      AUX_VARIABLE( rpcFitMidOffset );
 
      AUX_VARIABLE( rpcFitOutPhi );
      AUX_VARIABLE( rpcFitOutSlope );
      AUX_VARIABLE( rpcFitOutOffset );
 
      AUX_VARIABLE( rpcHitsCapacity );
      AUX_VARIABLE( tgcHitsCapacity );
      AUX_VARIABLE( mdtHitsCapacity );
      AUX_VARIABLE( cscHitsCapacity );
 
      AUX_VARIABLE( rpcHitLayer );
      AUX_VARIABLE( rpcHitMeasuresPhi );
      AUX_VARIABLE( rpcHitX );
      AUX_VARIABLE( rpcHitY );
      AUX_VARIABLE( rpcHitZ );
      AUX_VARIABLE( rpcHitTime );
      AUX_VARIABLE( rpcHitDistToEtaReadout );
      AUX_VARIABLE( rpcHitDistToPhiReadout );
      AUX_VARIABLE( rpcHitStationName );
 
      AUX_VARIABLE( tgcHitEta );
      AUX_VARIABLE( tgcHitPhi );
      AUX_VARIABLE( tgcHitR );
      AUX_VARIABLE( tgcHitZ );
      AUX_VARIABLE( tgcHitWidth );
      AUX_VARIABLE( tgcHitStationNum );
      AUX_VARIABLE( tgcHitIsStrip );
      AUX_VARIABLE( tgcHitBCTag );
      AUX_VARIABLE( tgcHitInRoad );
 
      AUX_VARIABLE( mdtHitOnlineId );
      AUX_VARIABLE( mdtHitIsOutlier );
      AUX_VARIABLE( mdtHitChamberId );
      AUX_VARIABLE( mdtHitR );
      AUX_VARIABLE( mdtHitZ );
      AUX_VARIABLE( mdtHitPhi );
      AUX_VARIABLE( mdtHitResidual );
      AUX_VARIABLE( mdtHitTime );
      AUX_VARIABLE( mdtHitSpace );
      AUX_VARIABLE( mdtHitSigma );
 
      AUX_VARIABLE( cscHitIsOutlier );
      AUX_VARIABLE( cscHitChamberId );
      AUX_VARIABLE( cscHitStationName );
      AUX_VARIABLE( cscHitStationEta );
      AUX_VARIABLE( cscHitStationPhi );
      AUX_VARIABLE( cscHitChamberLayer );
      AUX_VARIABLE( cscHitWireLayer );
      AUX_VARIABLE( cscHitMeasuresPhi );
      AUX_VARIABLE( cscHitStrip );
      AUX_VARIABLE( cscHitEta );
      AUX_VARIABLE( cscHitPhi );
      AUX_VARIABLE( cscHitR );
      AUX_VARIABLE( cscHitZ );
      AUX_VARIABLE( cscHitCharge );
      AUX_VARIABLE( cscHitTime );
      AUX_VARIABLE( cscHitResidual );
 
      AUX_VARIABLE( stgcClusterLayer );
      AUX_VARIABLE( stgcClusterIsOutlier );
      AUX_VARIABLE( stgcClusterType );
      AUX_VARIABLE( stgcClusterEta );
      AUX_VARIABLE( stgcClusterPhi );
      AUX_VARIABLE( stgcClusterR );
      AUX_VARIABLE( stgcClusterZ );
      AUX_VARIABLE( stgcClusterResidualR );
      AUX_VARIABLE( stgcClusterResidualPhi );
      AUX_VARIABLE( stgcClusterStationEta );
      AUX_VARIABLE( stgcClusterStationPhi );
      AUX_VARIABLE( stgcClusterStationName );
 
      AUX_VARIABLE( mmClusterLayer );
      AUX_VARIABLE( mmClusterIsOutlier );
      AUX_VARIABLE( mmClusterEta );
      AUX_VARIABLE( mmClusterPhi );
      AUX_VARIABLE( mmClusterR );
      AUX_VARIABLE( mmClusterZ );
      AUX_VARIABLE( mmClusterResidualR );
      AUX_VARIABLE( mmClusterResidualPhi );
      AUX_VARIABLE( mmClusterStationEta );
      AUX_VARIABLE( mmClusterStationPhi );
      AUX_VARIABLE( mmClusterStationName );
 
   }

Member Function Documentation

◆ clearDecorations()

bool xAOD::AuxContainerBase::clearDecorations ( )

overridevirtualinherited

Clear all decorations.

Implements SG::IConstAuxStore.

Definition at line 359 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;
   }

◆ getAuxID() [1/2]

template<typename T>

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

inherited

Get the auxiliary ID for one of the persistent variables.

◆ getAuxID() [2/2]

template<typename T, typename ALLOC>

auxid_t xAOD::AuxContainerBase::getAuxID	(	const std::string &	name,
		std::vector< T, ALLOC > &	,
		SG::AuxVarFlags	flags = SG::AuxVarFlags::None,
		const SG::auxid_t	linkedVariable = SG::null_auxid )

inherited

Get the auxiliary ID for one of the persistent variables.

◆ getAuxIDs()

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

overridevirtualinherited

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

Implements SG::IConstAuxStore.

Definition at line 277 of file AuxContainerBase.cxx.

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

◆ getData() [1/2]

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

overridevirtualinherited

Get a pointer to a given array.

Implements SG::IConstAuxStore.

Definition at line 232 of file AuxContainerBase.cxx.

                                                              {
 
      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 464 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::cout << "ERROR xAOD::AuxContainerBase::getData "
                      << "Unknown variable ("
                      << SG::AuxTypeRegistry::instance().getName( auxid )
                      << ") requested" << std::endl;
            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.

Implements SG::IConstAuxStore.

Reimplemented in xAOD::EventInfoAuxContainer_v1.

Definition at line 302 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::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 );
   }

◆ getDecorIDs()

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

overridevirtualinherited

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

Implements SG::IConstAuxStore.

Definition at line 284 of file AuxContainerBase.cxx.

                                       {
 
      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 703 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 661 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 686 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 723 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 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.

Implements SG::IConstAuxStore.

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::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 ];
   }

◆ getWritableAuxIDs()

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

overridevirtualinherited

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 500 of file AuxContainerBase.cxx.

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

Implemented in SG::AuxStoreInternal.

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

Implements SG::IConstAuxStore.

Reimplemented in xAOD::EventInfoAuxContainer_v1.

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

Reimplemented from SG::IConstAuxStore.

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

Implements SG::IConstAuxStore.

Definition at line 345 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 389 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 745 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 535 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 507 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 750 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 640 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 560 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.

Implements SG::IConstAuxStore.

Definition at line 432 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;
   }

Member Data Documentation

◆ algoId

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v2::algoId

private

Detailed information.

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

◆ barrelRadius

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::barrelRadius

private

Input measurements to be converted to pT by LUT.

Definition at line 60 of file L2StandAloneMuonAuxContainer_v2.h.

◆ barrelSagitta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::barrelSagitta

private

Definition at line 61 of file L2StandAloneMuonAuxContainer_v2.h.

◆ beta

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

private

Definition at line 58 of file L2StandAloneMuonAuxContainer_v2.h.

◆ chamberType1Normal

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::chamberType1Normal

private

Road information Chamber type.

Definition at line 121 of file L2StandAloneMuonAuxContainer_v2.h.

◆ chamberType1Overlap

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::chamberType1Overlap

private

Definition at line 122 of file L2StandAloneMuonAuxContainer_v2.h.

◆ chamberType2Normal

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::chamberType2Normal

private

Definition at line 123 of file L2StandAloneMuonAuxContainer_v2.h.

◆ chamberType2Overlap

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::chamberType2Overlap

private

Definition at line 124 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitChamberId

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitChamberId

private

Definition at line 228 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitChamberLayer

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitChamberLayer

private

Definition at line 232 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitCharge

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitCharge

private

Definition at line 240 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitEta

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitEta

private

Definition at line 236 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitIsOutlier

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitIsOutlier

private

CSC hits.

Definition at line 227 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitMeasuresPhi

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitMeasuresPhi

private

Definition at line 234 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitPhi

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitPhi

private

Definition at line 237 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitR

private

Definition at line 238 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitResidual

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitResidual

private

Definition at line 242 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitsCapacity

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitsCapacity

private

Definition at line 190 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitStationEta

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitStationEta

private

Definition at line 230 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitStationName

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitStationName

private

Definition at line 229 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitStationPhi

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitStationPhi

private

Definition at line 231 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitStrip

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitStrip

private

Definition at line 235 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitTime

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitTime

private

Definition at line 241 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitWireLayer

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitWireLayer

private

Definition at line 233 of file L2StandAloneMuonAuxContainer_v2.h.

◆ cscHitZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::cscHitZ

private

Definition at line 239 of file L2StandAloneMuonAuxContainer_v2.h.

◆ deltaEta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::deltaEta

private

Definition at line 79 of file L2StandAloneMuonAuxContainer_v2.h.

◆ deltaPhi

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::deltaPhi

private

Definition at line 80 of file L2StandAloneMuonAuxContainer_v2.h.

◆ deltaPt

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::deltaPt

private

Error of pt, eta and phi.

Definition at line 75 of file L2StandAloneMuonAuxContainer_v2.h.

◆ deltaPtParm1

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::deltaPtParm1

private

Definition at line 76 of file L2StandAloneMuonAuxContainer_v2.h.

◆ deltaPtParm2

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::deltaPtParm2

private

Definition at line 77 of file L2StandAloneMuonAuxContainer_v2.h.

◆ deltaPtParm3

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::deltaPtParm3

private

Definition at line 78 of file L2StandAloneMuonAuxContainer_v2.h.

◆ dirPhiMS

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::dirPhiMS

private

Definition at line 55 of file L2StandAloneMuonAuxContainer_v2.h.

◆ dirZMS

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::dirZMS

private

Definition at line 57 of file L2StandAloneMuonAuxContainer_v2.h.

◆ endcapAlpha

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::endcapAlpha

private

Definition at line 62 of file L2StandAloneMuonAuxContainer_v2.h.

◆ endcapBeta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::endcapBeta

private

Definition at line 63 of file L2StandAloneMuonAuxContainer_v2.h.

◆ endcapRadius

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::endcapRadius

private

Definition at line 64 of file L2StandAloneMuonAuxContainer_v2.h.

◆ eta

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

private

Definition at line 43 of file L2StandAloneMuonAuxContainer_v2.h.

◆ etaBin

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v2::etaBin

private

Definition at line 69 of file L2StandAloneMuonAuxContainer_v2.h.

◆ etaMap

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::etaMap

private

eta, phi as input to LUT

Definition at line 67 of file L2StandAloneMuonAuxContainer_v2.h.

◆ etaMaxNormal

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::etaMaxNormal

private

Definition at line 144 of file L2StandAloneMuonAuxContainer_v2.h.

◆ etaMaxOverlap

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::etaMaxOverlap

private

Definition at line 145 of file L2StandAloneMuonAuxContainer_v2.h.

◆ etaMinNormal

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::etaMinNormal

private

Eta.

Definition at line 142 of file L2StandAloneMuonAuxContainer_v2.h.

◆ etaMinOverlap

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::etaMinOverlap

private

Definition at line 143 of file L2StandAloneMuonAuxContainer_v2.h.

◆ etaMS

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::etaMS

private

Definition at line 53 of file L2StandAloneMuonAuxContainer_v2.h.

◆ isRpcFailure

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v2::isRpcFailure

private

Definition at line 73 of file L2StandAloneMuonAuxContainer_v2.h.

◆ isTgcFailure

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v2::isTgcFailure

private

Flag for RGC and RPC availabilities.

Definition at line 72 of file L2StandAloneMuonAuxContainer_v2.h.

◆ lumiBlock

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v2::lumiBlock

private

Definition at line 99 of file L2StandAloneMuonAuxContainer_v2.h.

◆ lvl1Id

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v2::lvl1Id

private

Definition at line 98 of file L2StandAloneMuonAuxContainer_v2.h.

◆ m_auxids

auxid_set_t xAOD::AuxContainerBase::m_auxids

privateinherited

Internal list of all available variables.

Definition at line 228 of file AuxContainerBase.h.

◆ m_locked

bool xAOD::AuxContainerBase::m_locked

privateinherited

Has the container been locked?

Definition at line 239 of file AuxContainerBase.h.

◆ m_mutex

mutex_t xAOD::AuxContainerBase::m_mutex

mutableprivateinherited

Definition at line 244 of file AuxContainerBase.h.

◆ m_name

std::string xAOD::AuxContainerBase::m_name

privateinherited

Name of the container in memory. Set externally.

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

◆ m_store

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

privateinherited

Internal dynamic auxiliary store object.

Definition at line 233 of file AuxContainerBase.h.

◆ m_storeIO

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

privateinherited

The IO interface to the internal auxiliary store.

Definition at line 235 of file AuxContainerBase.h.

◆ m_vecs

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

privateinherited

Internal list of all managed variables.

Definition at line 230 of file AuxContainerBase.h.

◆ mdtHitChamberId

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitChamberId

private

Definition at line 217 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mdtHitIsOutlier

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitIsOutlier

private

Definition at line 216 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mdtHitOnlineId

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitOnlineId

private

MDT hits.

Definition at line 215 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mdtHitPhi

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitPhi

private

Definition at line 220 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mdtHitR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitR

private

Definition at line 218 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mdtHitResidual

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitResidual

private

Definition at line 221 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mdtHitsCapacity

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitsCapacity

private

Definition at line 189 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mdtHitSigma

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitSigma

private

Definition at line 224 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mdtHitSpace

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitSpace

private

Definition at line 223 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mdtHitTime

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitTime

private

Definition at line 222 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mdtHitZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitZ

private

Definition at line 219 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mmClusterEta

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterEta

private

Definition at line 261 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mmClusterIsOutlier

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterIsOutlier

private

Definition at line 260 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mmClusterLayer

std::vector< std::vector< unsigned int > > xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterLayer

private

Definition at line 259 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mmClusterPhi

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterPhi

private

Definition at line 262 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mmClusterR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterR

private

Definition at line 263 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mmClusterResidualPhi

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterResidualPhi

private

Definition at line 266 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mmClusterResidualR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterResidualR

private

Definition at line 265 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mmClusterStationEta

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterStationEta

private

Definition at line 267 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mmClusterStationName

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterStationName

private

Definition at line 269 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mmClusterStationPhi

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterStationPhi

private

Definition at line 268 of file L2StandAloneMuonAuxContainer_v2.h.

◆ mmClusterZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterZ

private

Definition at line 264 of file L2StandAloneMuonAuxContainer_v2.h.

◆ muonDetMask

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v2::muonDetMask

private

Definition at line 100 of file L2StandAloneMuonAuxContainer_v2.h.

◆ phi

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

private

Definition at line 42 of file L2StandAloneMuonAuxContainer_v2.h.

◆ phiBin

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v2::phiBin

private

Definition at line 70 of file L2StandAloneMuonAuxContainer_v2.h.

◆ phiMap

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::phiMap

private

Definition at line 68 of file L2StandAloneMuonAuxContainer_v2.h.

◆ phiMS

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::phiMS

private

Definition at line 54 of file L2StandAloneMuonAuxContainer_v2.h.

◆ pt

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

private

Definition at line 41 of file L2StandAloneMuonAuxContainer_v2.h.

◆ ptBarrelRadius

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::ptBarrelRadius

private

Definition at line 112 of file L2StandAloneMuonAuxContainer_v2.h.

◆ ptBarrelSagitta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::ptBarrelSagitta

private

Definition at line 113 of file L2StandAloneMuonAuxContainer_v2.h.

◆ ptCSC

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::ptCSC

private

Definition at line 117 of file L2StandAloneMuonAuxContainer_v2.h.

◆ ptEndcapAlpha

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::ptEndcapAlpha

private

Definition at line 114 of file L2StandAloneMuonAuxContainer_v2.h.

◆ ptEndcapBeta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::ptEndcapBeta

private

Definition at line 115 of file L2StandAloneMuonAuxContainer_v2.h.

◆ ptEndcapRadius

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::ptEndcapRadius

private

Definition at line 116 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rMaxNormal

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::rMaxNormal

private

Definition at line 139 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rMaxOverlap

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::rMaxOverlap

private

Definition at line 140 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rMinNormal

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::rMinNormal

private

R.

Definition at line 137 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rMinOverlap

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::rMinOverlap

private

Definition at line 138 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rMS

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::rMS

private

Position at MS.

Definition at line 52 of file L2StandAloneMuonAuxContainer_v2.h.

◆ roadAwNormal

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::roadAwNormal

private

Slope.

Definition at line 126 of file L2StandAloneMuonAuxContainer_v2.h.

◆ roadAwOverlap

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::roadAwOverlap

private

Definition at line 127 of file L2StandAloneMuonAuxContainer_v2.h.

◆ roadBwNormal

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::roadBwNormal

private

Intercept.

Definition at line 129 of file L2StandAloneMuonAuxContainer_v2.h.

◆ roadBwOverlap

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::roadBwOverlap

private

Definition at line 130 of file L2StandAloneMuonAuxContainer_v2.h.

◆ roiEta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::roiEta

private

Definition at line 107 of file L2StandAloneMuonAuxContainer_v2.h.

◆ roiId

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v2::roiId

private

Definition at line 101 of file L2StandAloneMuonAuxContainer_v2.h.

◆ roiNumber

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v2::roiNumber

private

Definition at line 105 of file L2StandAloneMuonAuxContainer_v2.h.

◆ roiPhi

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::roiPhi

private

Definition at line 108 of file L2StandAloneMuonAuxContainer_v2.h.

◆ roiSector

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v2::roiSector

private

Definition at line 104 of file L2StandAloneMuonAuxContainer_v2.h.

◆ roiSubsystem

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v2::roiSubsystem

private

Definition at line 103 of file L2StandAloneMuonAuxContainer_v2.h.

◆ roiSystem

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v2::roiSystem

private

Definition at line 102 of file L2StandAloneMuonAuxContainer_v2.h.

◆ roiThreshold

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v2::roiThreshold

private

Definition at line 106 of file L2StandAloneMuonAuxContainer_v2.h.

◆ roiWord

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v2::roiWord

private

Definition at line 49 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcFitInnOffset

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitInnOffset

private

Definition at line 176 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcFitInnPhi

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitInnPhi

private

RPC fit results.

Definition at line 174 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcFitInnSlope

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitInnSlope

private

Definition at line 175 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcFitMidOffset

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitMidOffset

private

Definition at line 180 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcFitMidPhi

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitMidPhi

private

Definition at line 178 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcFitMidSlope

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitMidSlope

private

Definition at line 179 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcFitOutOffset

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitOutOffset

private

Definition at line 184 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcFitOutPhi

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitOutPhi

private

Definition at line 182 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcFitOutSlope

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitOutSlope

private

Definition at line 183 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcHitDistToEtaReadout

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitDistToEtaReadout

private

Definition at line 199 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcHitDistToPhiReadout

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitDistToPhiReadout

private

Definition at line 200 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcHitLayer

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitLayer

private

RPC pad hits.

Definition at line 193 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcHitMeasuresPhi

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitMeasuresPhi

private

Definition at line 194 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcHitsCapacity

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitsCapacity

private

Size of hit strages.

Definition at line 187 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcHitStationName

std::vector< std::vector< std::string > > xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitStationName

private

Definition at line 201 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcHitTime

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitTime

private

Definition at line 198 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcHitX

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitX

private

Definition at line 195 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcHitY

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitY

private

Definition at line 196 of file L2StandAloneMuonAuxContainer_v2.h.

◆ rpcHitZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitZ

private

Definition at line 197 of file L2StandAloneMuonAuxContainer_v2.h.

◆ sAddress

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v2::sAddress

private

Definition at line 50 of file L2StandAloneMuonAuxContainer_v2.h.

◆ stgcClusterEta

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterEta

private

Definition at line 248 of file L2StandAloneMuonAuxContainer_v2.h.

◆ stgcClusterIsOutlier

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterIsOutlier

private

Definition at line 246 of file L2StandAloneMuonAuxContainer_v2.h.

◆ stgcClusterLayer

std::vector< std::vector< unsigned int > > xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterLayer

private

Definition at line 245 of file L2StandAloneMuonAuxContainer_v2.h.

◆ stgcClusterPhi

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterPhi

private

Definition at line 249 of file L2StandAloneMuonAuxContainer_v2.h.

◆ stgcClusterR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterR

private

Definition at line 250 of file L2StandAloneMuonAuxContainer_v2.h.

◆ stgcClusterResidualPhi

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterResidualPhi

private

Definition at line 253 of file L2StandAloneMuonAuxContainer_v2.h.

◆ stgcClusterResidualR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterResidualR

private

Definition at line 252 of file L2StandAloneMuonAuxContainer_v2.h.

◆ stgcClusterStationEta

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterStationEta

private

Definition at line 254 of file L2StandAloneMuonAuxContainer_v2.h.

◆ stgcClusterStationName

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterStationName

private

Definition at line 256 of file L2StandAloneMuonAuxContainer_v2.h.

◆ stgcClusterStationPhi

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterStationPhi

private

Definition at line 255 of file L2StandAloneMuonAuxContainer_v2.h.

◆ stgcClusterType

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterType

private

Definition at line 247 of file L2StandAloneMuonAuxContainer_v2.h.

◆ stgcClusterZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterZ

private

Definition at line 251 of file L2StandAloneMuonAuxContainer_v2.h.

◆ superPointChi2

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::superPointChi2

private

Definition at line 87 of file L2StandAloneMuonAuxContainer_v2.h.

◆ superPointIntercept

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::superPointIntercept

private

Definition at line 86 of file L2StandAloneMuonAuxContainer_v2.h.

◆ superPointR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::superPointR

private

Station fit results (superpoints)

Definition at line 83 of file L2StandAloneMuonAuxContainer_v2.h.

◆ superPointSlope

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::superPointSlope

private

Definition at line 85 of file L2StandAloneMuonAuxContainer_v2.h.

◆ superPointZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::superPointZ

private

Definition at line 84 of file L2StandAloneMuonAuxContainer_v2.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 199 of file IAuxStore.h.