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

Auxiliary container for muon SA containers. More...

#include <L2StandAloneMuonAuxContainer_v2.h>

Inheritance diagram for xAOD::L2StandAloneMuonAuxContainer_v2:
Collaboration diagram for xAOD::L2StandAloneMuonAuxContainer_v2:

Public Types

typedef SG::auxid_t auxid_t
 The aux ID type definition. More...
 
typedef SG::auxid_set_t auxid_set_t
 The aux ID set type definition. More...
 
template<class T , class ALLOC = std::allocator<T>>
using AuxVariable_t = std::vector< T, ALLOC >
 Declare how to wrap variables for this sort of base. More...
 
template<class T , class ALLOC = std::allocator<T>>
using LinkedVariable_t = AuxVariable_t< T, ALLOC >
 
enum  AuxStoreType { AST_ObjectStore = 0, AST_ContainerStore = 1 }
 Type of the auxiliary store. More...
 

Public Member Functions

 L2StandAloneMuonAuxContainer_v2 ()
 Default constructor. More...
 
virtual const void * getData (SG::auxid_t auxid) const=0
 Pick up the const version from the base class. More...
 
virtual const IAuxTypeVector * linkedVector (SG::auxid_t) const
 Return interface for a linked variable. More...
 
virtual bool insertMove (size_t pos, IAuxStore &other, const SG::auxid_set_t &ignore=SG::auxid_set_t())=0
 Move all elements from other to this store. More...
 
template<typename T , typename ALLOC >
auxid_t getAuxID (const std::string &name, std::vector< T, ALLOC > &, SG::AuxVarFlags flags=SG::AuxVarFlags::None, const SG::auxid_t linkedVariable=SG::null_auxid)
 Get the auxiliary ID for one of the persistent variables. More...
 
template<typename T >
auxid_t getAuxID (const std::string &name, SG::PackedContainer< T > &, SG::AuxVarFlags flags=SG::AuxVarFlags::None, const SG::auxid_t linkedVariable=SG::null_auxid)
 Get the auxiliary ID for one of the persistent variables. More...
 
template<typename T , typename ALLOC >
void regAuxVar (auxid_t auxid, const std::string &name, std::vector< T, ALLOC > &vec)
 Register one of the persistent variables internally. More...
 
template<typename T >
void regAuxVar (auxid_t auxid, const std::string &name, SG::PackedContainer< T > &vec)
 Register one of the persistent variables internally. More...
 

Static Public Attributes

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

Private Types

typedef AthContainers_detail::mutex mutex_t
 Mutex for multithread synchronization. More...
 
typedef AthContainers_detail::lock_guard< mutex_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...
 
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. More...
 
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. More...
 
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 More...
 
std::vector< float > phiMap
 
std::vector< int > etaBin
 
std::vector< int > phiBin
 
std::vector< int > isTgcFailure
 Flag for RGC and RPC availabilities. More...
 
std::vector< int > isRpcFailure
 
std::vector< float > deltaPt
 Error of pt, eta and phi. More...
 
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) More...
 
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. More...
 
std::vector< std::vector< float > > trackPositionZ
 
std::vector< std::vector< float > > trackPositionEta
 
std::vector< std::vector< float > > trackPositionPhi
 
std::vector< int > algoId
 Detailed information. More...
 
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 More...
 
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. More...
 
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. More...
 
std::vector< std::vector< float > > roadAwOverlap
 
std::vector< std::vector< float > > roadBwNormal
 Intercept. More...
 
std::vector< std::vector< float > > roadBwOverlap
 
std::vector< std::vector< float > > zMinNormal
 Z. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
std::vector< int > tgcHitsCapacity
 
std::vector< int > mdtHitsCapacity
 
std::vector< int > cscHitsCapacity
 
std::vector< std::vector< uint32_t > > rpcHitLayer
 RPC pad hits. More...
 
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. More...
 
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. More...
 
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. More...
 
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 65 of file AuxContainerBase.h.

◆ auxid_t

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

The aux ID type definition.

Definition at line 63 of file AuxContainerBase.h.

◆ AuxVariable_t

template<class T , class ALLOC = std::allocator<T>>
using xAOD::AuxContainerBase::AuxVariable_t = std::vector<T, ALLOC>
inherited

Declare how to wrap variables for this sort of base.

Definition at line 195 of file AuxContainerBase.h.

◆ guard_t

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

Definition at line 247 of file AuxContainerBase.h.

◆ LinkedVariable_t

template<class T , class ALLOC = std::allocator<T>>
using xAOD::AuxContainerBase::LinkedVariable_t = AuxVariable_t<T, ALLOC>
inherited

Definition at line 197 of file AuxContainerBase.h.

◆ mutex_t

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

Mutex for multithread synchronization.

Definition at line 246 of file AuxContainerBase.h.

Member Enumeration Documentation

◆ AuxStoreType

enum SG::IAuxStoreHolder::AuxStoreType
inherited

Type of the auxiliary store.

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

Enumerator
AST_ObjectStore 

The store describes a single object.

AST_ContainerStore 

The store describes a container.

Definition at line 66 of file IAuxStoreHolder.h.

66  {
67  AST_ObjectStore = 0,
68  AST_ContainerStore = 1
69  };

Constructor & Destructor Documentation

◆ L2StandAloneMuonAuxContainer_v2()

xAOD::L2StandAloneMuonAuxContainer_v2::L2StandAloneMuonAuxContainer_v2 ( )

Default constructor.

Definition at line 12 of file L2StandAloneMuonAuxContainer_v2.cxx.

13  : AuxContainerBase() {
14 
15  AUX_VARIABLE( pt );
16  AUX_VARIABLE( phi );
17  AUX_VARIABLE( eta );
18 
19  AUX_VARIABLE( roiWord );
20  AUX_VARIABLE( sAddress );
21  AUX_VARIABLE( rMS );
22  AUX_VARIABLE( etaMS );
23  AUX_VARIABLE( phiMS );
24  AUX_VARIABLE( dirPhiMS );
25  AUX_VARIABLE( zMS );
26  AUX_VARIABLE( dirZMS );
27  AUX_VARIABLE( beta );
28 
29  AUX_VARIABLE( barrelRadius );
30  AUX_VARIABLE( barrelSagitta );
31 
32  AUX_VARIABLE( endcapAlpha );
33  AUX_VARIABLE( endcapBeta );
34  AUX_VARIABLE( endcapRadius );
35 
36  AUX_VARIABLE( etaMap );
37  AUX_VARIABLE( phiMap );
38  AUX_VARIABLE( etaBin );
39  AUX_VARIABLE( phiBin );
40 
41  AUX_VARIABLE( isTgcFailure );
42  AUX_VARIABLE( isRpcFailure );
43 
44  AUX_VARIABLE( deltaPt );
45  AUX_VARIABLE( deltaPtParm1 );
46  AUX_VARIABLE( deltaPtParm2 );
47  AUX_VARIABLE( deltaPtParm3 );
48  AUX_VARIABLE( deltaEta );
49  AUX_VARIABLE( deltaPhi );
50 
51  AUX_VARIABLE( superPointR );
52  AUX_VARIABLE( superPointZ );
53  AUX_VARIABLE( superPointSlope );
54  AUX_VARIABLE( superPointIntercept );
55  AUX_VARIABLE( superPointChi2 );
56 
57  AUX_VARIABLE( trackPositionR );
58  AUX_VARIABLE( trackPositionZ );
59  AUX_VARIABLE( trackPositionEta );
60  AUX_VARIABLE( trackPositionPhi );
61 
62  AUX_VARIABLE( algoId );
63  AUX_VARIABLE( teId );
64  AUX_VARIABLE( lvl1Id );
65  AUX_VARIABLE( lumiBlock );
66  AUX_VARIABLE( muonDetMask );
67  AUX_VARIABLE( roiId );
68  AUX_VARIABLE( roiSystem );
69  AUX_VARIABLE( roiSubsystem );
70  AUX_VARIABLE( roiSector );
71  AUX_VARIABLE( roiNumber );
72  AUX_VARIABLE( roiThreshold );
73  AUX_VARIABLE( roiEta );
74  AUX_VARIABLE( roiPhi );
75 
76  AUX_VARIABLE( tgcPt );
77  AUX_VARIABLE( ptBarrelRadius );
78  AUX_VARIABLE( ptBarrelSagitta );
79  AUX_VARIABLE( ptEndcapAlpha );
80  AUX_VARIABLE( ptEndcapBeta );
81  AUX_VARIABLE( ptEndcapRadius );
82  AUX_VARIABLE( ptCSC );
83 
84  AUX_VARIABLE( chamberType1Normal );
85  AUX_VARIABLE( chamberType1Overlap );
86  AUX_VARIABLE( chamberType2Normal );
87  AUX_VARIABLE( chamberType2Overlap );
88 
89  AUX_VARIABLE( roadAwNormal );
90  AUX_VARIABLE( roadAwOverlap );
91 
92  AUX_VARIABLE( roadBwNormal );
93  AUX_VARIABLE( roadBwOverlap );
94 
95  AUX_VARIABLE( zMinNormal );
96  AUX_VARIABLE( zMinOverlap );
97  AUX_VARIABLE( zMaxNormal );
98  AUX_VARIABLE( zMaxOverlap );
99 
100  AUX_VARIABLE( rMinNormal );
101  AUX_VARIABLE( rMinOverlap );
102  AUX_VARIABLE( rMaxNormal );
103  AUX_VARIABLE( rMaxOverlap );
104 
105  AUX_VARIABLE( etaMinNormal );
106  AUX_VARIABLE( etaMinOverlap );
107  AUX_VARIABLE( etaMaxNormal );
108  AUX_VARIABLE( etaMaxOverlap );
109 
110  AUX_VARIABLE( tgcInnEta );
111  AUX_VARIABLE( tgcInnPhi );
112  AUX_VARIABLE( tgcInnR );
113  AUX_VARIABLE( tgcInnZ );
114 
115  AUX_VARIABLE( tgcInnRhoStd );
116  AUX_VARIABLE( tgcInnRhoN );
117  AUX_VARIABLE( tgcInnPhiStd );
118  AUX_VARIABLE( tgcInnPhiN );
119 
120  AUX_VARIABLE( tgcMid1Eta );
121  AUX_VARIABLE( tgcMid1Phi );
122  AUX_VARIABLE( tgcMid1R );
123  AUX_VARIABLE( tgcMid1Z );
124 
125  AUX_VARIABLE( tgcMid2Eta );
126  AUX_VARIABLE( tgcMid2Phi );
127  AUX_VARIABLE( tgcMid2R );
128  AUX_VARIABLE( tgcMid2Z );
129 
130  AUX_VARIABLE( tgcMidRhoChi2 );
131  AUX_VARIABLE( tgcMidRhoN );
132  AUX_VARIABLE( tgcMidPhiChi2 );
133  AUX_VARIABLE( tgcMidPhiN );
134 
135  AUX_VARIABLE( rpcFitInnPhi );
136  AUX_VARIABLE( rpcFitInnSlope );
137  AUX_VARIABLE( rpcFitInnOffset );
138 
139  AUX_VARIABLE( rpcFitMidPhi );
140  AUX_VARIABLE( rpcFitMidSlope );
141  AUX_VARIABLE( rpcFitMidOffset );
142 
143  AUX_VARIABLE( rpcFitOutPhi );
144  AUX_VARIABLE( rpcFitOutSlope );
145  AUX_VARIABLE( rpcFitOutOffset );
146 
147  AUX_VARIABLE( rpcHitsCapacity );
148  AUX_VARIABLE( tgcHitsCapacity );
149  AUX_VARIABLE( mdtHitsCapacity );
150  AUX_VARIABLE( cscHitsCapacity );
151 
152  AUX_VARIABLE( rpcHitLayer );
153  AUX_VARIABLE( rpcHitMeasuresPhi );
154  AUX_VARIABLE( rpcHitX );
155  AUX_VARIABLE( rpcHitY );
156  AUX_VARIABLE( rpcHitZ );
157  AUX_VARIABLE( rpcHitTime );
158  AUX_VARIABLE( rpcHitDistToEtaReadout );
159  AUX_VARIABLE( rpcHitDistToPhiReadout );
160  AUX_VARIABLE( rpcHitStationName );
161 
162  AUX_VARIABLE( tgcHitEta );
163  AUX_VARIABLE( tgcHitPhi );
164  AUX_VARIABLE( tgcHitR );
165  AUX_VARIABLE( tgcHitZ );
166  AUX_VARIABLE( tgcHitWidth );
167  AUX_VARIABLE( tgcHitStationNum );
168  AUX_VARIABLE( tgcHitIsStrip );
169  AUX_VARIABLE( tgcHitBCTag );
170  AUX_VARIABLE( tgcHitInRoad );
171 
172  AUX_VARIABLE( mdtHitOnlineId );
173  AUX_VARIABLE( mdtHitIsOutlier );
174  AUX_VARIABLE( mdtHitChamberId );
175  AUX_VARIABLE( mdtHitR );
176  AUX_VARIABLE( mdtHitZ );
177  AUX_VARIABLE( mdtHitPhi );
178  AUX_VARIABLE( mdtHitResidual );
179  AUX_VARIABLE( mdtHitTime );
180  AUX_VARIABLE( mdtHitSpace );
181  AUX_VARIABLE( mdtHitSigma );
182 
183  AUX_VARIABLE( cscHitIsOutlier );
184  AUX_VARIABLE( cscHitChamberId );
185  AUX_VARIABLE( cscHitStationName );
186  AUX_VARIABLE( cscHitStationEta );
187  AUX_VARIABLE( cscHitStationPhi );
188  AUX_VARIABLE( cscHitChamberLayer );
189  AUX_VARIABLE( cscHitWireLayer );
190  AUX_VARIABLE( cscHitMeasuresPhi );
191  AUX_VARIABLE( cscHitStrip );
192  AUX_VARIABLE( cscHitEta );
193  AUX_VARIABLE( cscHitPhi );
194  AUX_VARIABLE( cscHitR );
195  AUX_VARIABLE( cscHitZ );
196  AUX_VARIABLE( cscHitCharge );
197  AUX_VARIABLE( cscHitTime );
198  AUX_VARIABLE( cscHitResidual );
199 
200  AUX_VARIABLE( stgcClusterLayer );
201  AUX_VARIABLE( stgcClusterIsOutlier );
202  AUX_VARIABLE( stgcClusterType );
203  AUX_VARIABLE( stgcClusterEta );
204  AUX_VARIABLE( stgcClusterPhi );
205  AUX_VARIABLE( stgcClusterR );
206  AUX_VARIABLE( stgcClusterZ );
207  AUX_VARIABLE( stgcClusterResidualR );
208  AUX_VARIABLE( stgcClusterResidualPhi );
209  AUX_VARIABLE( stgcClusterStationEta );
210  AUX_VARIABLE( stgcClusterStationPhi );
211  AUX_VARIABLE( stgcClusterStationName );
212 
213  AUX_VARIABLE( mmClusterLayer );
214  AUX_VARIABLE( mmClusterIsOutlier );
215  AUX_VARIABLE( mmClusterEta );
216  AUX_VARIABLE( mmClusterPhi );
217  AUX_VARIABLE( mmClusterR );
218  AUX_VARIABLE( mmClusterZ );
219  AUX_VARIABLE( mmClusterResidualR );
220  AUX_VARIABLE( mmClusterResidualPhi );
221  AUX_VARIABLE( mmClusterStationEta );
222  AUX_VARIABLE( mmClusterStationPhi );
223  AUX_VARIABLE( mmClusterStationName );
224 
225  }

Member Function Documentation

◆ clearDecorations()

bool xAOD::AuxContainerBase::clearDecorations ( )
overridevirtualinherited

Clear all decorations.

Implements SG::IConstAuxStore.

Definition at line 359 of file AuxContainerBase.cxx.

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

◆ getAuxID() [1/2]

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

Get the auxiliary ID for one of the persistent variables.

◆ getAuxID() [2/2]

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

Get the auxiliary ID for one of the persistent variables.

◆ getAuxIDs()

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

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

Implements SG::IConstAuxStore.

Definition at line 277 of file AuxContainerBase.cxx.

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

◆ getData() [1/3]

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

Get a pointer to a given array.

Implements SG::IConstAuxStore.

Definition at line 232 of file AuxContainerBase.cxx.

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

◆ getData() [2/3]

void * xAOD::AuxContainerBase::getData ( auxid_t  auxid,
size_t  size,
size_t  capacity 
)
overridevirtualinherited

Get a pointer to a given array, creating the array if necessary.

Implements SG::IAuxStore.

Definition at line 464 of file AuxContainerBase.cxx.

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

◆ getData() [3/3]

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

Pick up the const version from the base class.

◆ getDecoration()

void * xAOD::AuxContainerBase::getDecoration ( auxid_t  auxid,
size_t  size,
size_t  capacity 
)
overridevirtualinherited

Get a pointer to a given array, as a decoration.

Implements SG::IConstAuxStore.

Reimplemented in xAOD::EventInfoAuxContainer_v1.

Definition at line 302 of file AuxContainerBase.cxx.

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

◆ getDecorIDs()

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

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

Implements SG::IConstAuxStore.

Definition at line 284 of file AuxContainerBase.cxx.

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

◆ getDynamicAuxIDs()

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

Get the types(names) of variables created dynamically.

Implements SG::IAuxStoreIO.

Definition at line 703 of file AuxContainerBase.cxx.

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

◆ getIOData()

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

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

Implements SG::IAuxStoreIO.

Definition at line 661 of file AuxContainerBase.cxx.

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

◆ getIOType()

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

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

Implements SG::IAuxStoreIO.

Definition at line 686 of file AuxContainerBase.cxx.

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

◆ getSelectedAuxIDs()

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

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

Reimplemented from SG::IAuxStoreIO.

Definition at line 723 of file AuxContainerBase.cxx.

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

◆ getStore() [1/2]

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

Implements SG::IAuxStoreHolder.

Definition at line 183 of file AuxContainerBase.cxx.

184  {
185  return m_store;
186  }

◆ getStore() [2/2]

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

Get the currently used internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 156 of file AuxContainerBase.cxx.

157  {
158  return m_store;
159  }

◆ getStoreType()

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

Return the type of the store object.

Implements SG::IAuxStoreHolder.

Definition at line 92 of file AuxContainerBase.h.

92 { return AST_ContainerStore; }

◆ getVector()

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

Return vector interface for one aux data item.

Implements SG::IConstAuxStore.

Definition at line 241 of file AuxContainerBase.cxx.

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

◆ getWritableAuxIDs()

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

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 500 of file AuxContainerBase.cxx.

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

◆ insertMove() [1/2]

bool xAOD::AuxContainerBase::insertMove ( size_t  pos,
IAuxStore &  other,
const SG::auxid_set_t &  ignore 
)
overridevirtualinherited

Insert contents of another store via move.

Definition at line 586 of file AuxContainerBase.cxx.

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

◆ insertMove() [2/2]

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

Move all elements from other to this store.

Parameters
posThe starting index of the insertion.
otherStore from which to do the move.
ignoreSet of variables that should not be added to the store.

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

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

Implemented in SG::AuxStoreInternal.

◆ isDecoration()

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

Test if a variable is a decoration.

Implements SG::IConstAuxStore.

Reimplemented in xAOD::EventInfoAuxContainer_v1.

Definition at line 293 of file AuxContainerBase.cxx.

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

◆ linkedVector() [1/3]

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

Return interface for a linked variable.

Reimplemented from SG::IConstAuxStore.

Definition at line 398 of file AuxContainerBase.cxx.

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

◆ linkedVector() [2/3]

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

Return interface for a linked variable.

Reimplemented from SG::IAuxStore.

Definition at line 415 of file AuxContainerBase.cxx.

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

◆ linkedVector() [3/3]

virtual const IAuxTypeVector* SG::IConstAuxStore::linkedVector
inlineinherited

Return interface for a linked variable.

Parameters
auxidThe ID of the parent variable.

If auxid has a linked variable, then return the IAuxTypeVector describing it. Otherwise, return nullptr. May return nullptr unconditionally if this store does not support linked variables.

Definition at line 189 of file IConstAuxStore.h.

190  { return nullptr; }

◆ lock()

void xAOD::AuxContainerBase::lock ( )
overridevirtualinherited

Lock the container.

Implements ILockable.

Definition at line 345 of file AuxContainerBase.cxx.

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

◆ lockDecoration()

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

Lock a decoration.

Implements SG::IConstAuxStore.

Reimplemented in xAOD::EventInfoAuxContainer_v1.

Definition at line 389 of file AuxContainerBase.cxx.

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

◆ memResource()

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

Return the memory resource to use.

Definition at line 161 of file AuxContainerBase.cxx.

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

◆ name()

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

Get the name of the container instance.

Definition at line 745 of file AuxContainerBase.cxx.

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

◆ regAuxVar() [1/2]

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

Register one of the persistent variables internally.

◆ regAuxVar() [2/2]

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

Register one of the persistent variables internally.

◆ regAuxVar1()

template<typename ELT , typename CONT >
void xAOD::AuxContainerBase::regAuxVar1 ( auxid_t  auxid,
const std::string &  name,
CONT &  vec 
)
privateinherited

Common code between regAuxVar cases.

◆ reserve()

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

Reserve a given size for the arrays.

Implements SG::IAuxStore.

Definition at line 535 of file AuxContainerBase.cxx.

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

◆ resize()

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

Resize the arrays to a given size.

Implements SG::IAuxStore.

Definition at line 507 of file AuxContainerBase.cxx.

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

◆ setName()

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

Set the name of the container instance.

Definition at line 750 of file AuxContainerBase.cxx.

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

◆ setOption()

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

Make an option setting on an aux variable.

Reimplemented from SG::IAuxStore.

Definition at line 640 of file AuxContainerBase.cxx.

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

◆ setStore()

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

Set a different internal store object.

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

Note that the object takes ownership of the received store.

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

Implements SG::IAuxStoreHolder.

Definition at line 197 of file AuxContainerBase.cxx.

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

◆ shift()

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

Shift the contents of the stored arrays.

Implements SG::IAuxStore.

Definition at line 560 of file AuxContainerBase.cxx.

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

◆ size()

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

Get the size of the container.

Implements SG::IConstAuxStore.

Definition at line 432 of file AuxContainerBase.cxx.

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

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

◆ m_locked

bool xAOD::AuxContainerBase::m_locked
privateinherited

Has the container been locked?

Definition at line 243 of file AuxContainerBase.h.

◆ m_mutex

mutex_t xAOD::AuxContainerBase::m_mutex
mutableprivateinherited

Definition at line 248 of file AuxContainerBase.h.

◆ m_name

std::string xAOD::AuxContainerBase::m_name
privateinherited

Name of the container in memory. Set externally.

Definition at line 251 of file AuxContainerBase.h.

◆ m_ownsStore

bool xAOD::AuxContainerBase::m_ownsStore
privateinherited

Flag deciding if the object owns the dynamic store or not.

Definition at line 241 of file AuxContainerBase.h.

◆ m_store

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

Internal dynamic auxiliary store object.

Definition at line 237 of file AuxContainerBase.h.

◆ m_storeIO

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

The IO interface to the internal auxiliary store.

Definition at line 239 of file AuxContainerBase.h.

◆ m_vecs

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

Internal list of all managed variables.

Definition at line 234 of file AuxContainerBase.h.

◆ 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

constexpr bool SG::IAuxStore::supportsThinning = true
staticconstexprinherited

Mark that this type supports thinning operations.

See AthContainers/supportsThinning.h and AthenaPoolCnvSvc/T_AthenaPoolCnv.h. Helps guide which pool converter template will be used. If false, the default pool converter will be used rather than the aux store-specific one. Ordinary xAOD type should not touch this, but may be overridden in a derived class to handle certain special cases.

Definition at line 199 of file IAuxStore.h.

◆ teId

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v2::teId
private

Definition at line 97 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcHitBCTag

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitBCTag
private

Definition at line 211 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcHitEta

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitEta
private

TGC hits.

Definition at line 204 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcHitInRoad

std::vector< std::vector< bool > > xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitInRoad
private

Definition at line 212 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcHitIsStrip

std::vector< std::vector< bool > > xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitIsStrip
private

Definition at line 210 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcHitPhi

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitPhi
private

Definition at line 205 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcHitR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitR
private

Definition at line 206 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcHitsCapacity

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitsCapacity
private

Definition at line 188 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcHitStationNum

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitStationNum
private

Definition at line 209 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcHitWidth

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitWidth
private

Definition at line 208 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcHitZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitZ
private

Definition at line 207 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcInnEta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnEta
private

TGC fit results.

Definition at line 148 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcInnPhi

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnPhi
private

Definition at line 149 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcInnPhiN

std::vector< long > xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnPhiN
private

Definition at line 166 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcInnPhiStd

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnPhiStd
private

Definition at line 165 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcInnR

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnR
private

Definition at line 150 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcInnRhoN

std::vector< long > xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnRhoN
private

Definition at line 164 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcInnRhoStd

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnRhoStd
private

Definition at line 163 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcInnZ

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnZ
private

Definition at line 151 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcMid1Eta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid1Eta
private

Definition at line 153 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcMid1Phi

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid1Phi
private

Definition at line 154 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcMid1R

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid1R
private

Definition at line 155 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcMid1Z

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid1Z
private

Definition at line 156 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcMid2Eta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid2Eta
private

Definition at line 158 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcMid2Phi

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid2Phi
private

Definition at line 159 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcMid2R

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid2R
private

Definition at line 160 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcMid2Z

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid2Z
private

Definition at line 161 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcMidPhiChi2

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcMidPhiChi2
private

Definition at line 170 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcMidPhiN

std::vector< long > xAOD::L2StandAloneMuonAuxContainer_v2::tgcMidPhiN
private

Definition at line 171 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcMidRhoChi2

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcMidRhoChi2
private

Definition at line 168 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcMidRhoN

std::vector< long > xAOD::L2StandAloneMuonAuxContainer_v2::tgcMidRhoN
private

Definition at line 169 of file L2StandAloneMuonAuxContainer_v2.h.

◆ tgcPt

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::tgcPt
private

pT from different algorithms

Definition at line 111 of file L2StandAloneMuonAuxContainer_v2.h.

◆ trackPositionEta

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::trackPositionEta
private

Definition at line 92 of file L2StandAloneMuonAuxContainer_v2.h.

◆ trackPositionPhi

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::trackPositionPhi
private

Definition at line 93 of file L2StandAloneMuonAuxContainer_v2.h.

◆ trackPositionR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::trackPositionR
private

Track positions.

Definition at line 90 of file L2StandAloneMuonAuxContainer_v2.h.

◆ trackPositionZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::trackPositionZ
private

Definition at line 91 of file L2StandAloneMuonAuxContainer_v2.h.

◆ zMaxNormal

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::zMaxNormal
private

Definition at line 134 of file L2StandAloneMuonAuxContainer_v2.h.

◆ zMaxOverlap

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::zMaxOverlap
private

Definition at line 135 of file L2StandAloneMuonAuxContainer_v2.h.

◆ zMinNormal

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::zMinNormal
private

Z.

Definition at line 132 of file L2StandAloneMuonAuxContainer_v2.h.

◆ zMinOverlap

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v2::zMinOverlap
private

Definition at line 133 of file L2StandAloneMuonAuxContainer_v2.h.

◆ zMS

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v2::zMS
private

Definition at line 56 of file L2StandAloneMuonAuxContainer_v2.h.

The documentation for this class was generated from the following files:
xAOD::L2StandAloneMuonAuxContainer_v2::deltaPhi
std::vector< float > deltaPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:80
xAOD::AuxContainerBase::m_name
std::string m_name
Name of the container in memory. Set externally.
Definition: AuxContainerBase.h:251
SG::IAuxTypeVector::shift
virtual bool shift(size_t pos, ptrdiff_t offs)=0
Shift the elements of the vector.
SG::IAuxTypeVector::isLinked
bool isLinked() const
Return true if this variable is linked from another one.
Definition: IAuxTypeVector.h:226
SGTest::store
TestStore store
Definition: TestStore.cxx:23
beamspotman.r
def r
Definition: beamspotman.py:672
xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnPhi
std::vector< float > tgcInnPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:149
xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnRhoN
std::vector< long > tgcInnRhoN
Definition: L2StandAloneMuonAuxContainer_v2.h:164
xAOD::L2StandAloneMuonAuxContainer_v2::superPointR
std::vector< std::vector< float > > superPointR
Station fit results (superpoints)
Definition: L2StandAloneMuonAuxContainer_v2.h:83
xAOD::L2StandAloneMuonAuxContainer_v2::superPointChi2
std::vector< std::vector< float > > superPointChi2
Definition: L2StandAloneMuonAuxContainer_v2.h:87
xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitSpace
std::vector< std::vector< float > > mdtHitSpace
Definition: L2StandAloneMuonAuxContainer_v2.h:223
xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitPhi
std::vector< std::vector< float > > tgcHitPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:205
xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterStationEta
std::vector< std::vector< int > > stgcClusterStationEta
Definition: L2StandAloneMuonAuxContainer_v2.h:254
xAOD::AuxContainerBase::name
const char * name() const
Get the name of the container instance.
Definition: AuxContainerBase.cxx:745
xAOD::L2StandAloneMuonAuxContainer_v2::endcapAlpha
std::vector< float > endcapAlpha
Definition: L2StandAloneMuonAuxContainer_v2.h:62
SG::IAuxStore::insertMove
virtual bool insertMove(size_t pos, IAuxStore &other, const SG::auxid_set_t &ignore=SG::auxid_set_t())=0
Move all elements from other to this store.
xAOD::L2StandAloneMuonAuxContainer_v2::roiSystem
std::vector< uint32_t > roiSystem
Definition: L2StandAloneMuonAuxContainer_v2.h:102
xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterIsOutlier
std::vector< std::vector< int > > mmClusterIsOutlier
Definition: L2StandAloneMuonAuxContainer_v2.h:260
SG::IConstAuxStore::lockDecoration
virtual void lockDecoration(SG::auxid_t auxid)=0
Lock a decoration.
xAOD::L2StandAloneMuonAuxContainer_v2::deltaPtParm2
std::vector< float > deltaPtParm2
Definition: L2StandAloneMuonAuxContainer_v2.h:77
fitman.sz
sz
Definition: fitman.py:527
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitWireLayer
std::vector< std::vector< int > > cscHitWireLayer
Definition: L2StandAloneMuonAuxContainer_v2.h:233
get_generator_info.result
result
Definition: get_generator_info.py:21
xAOD::L2StandAloneMuonAuxContainer_v2::chamberType1Normal
std::vector< std::vector< int > > chamberType1Normal
Road information Chamber type.
Definition: L2StandAloneMuonAuxContainer_v2.h:121
xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitTime
std::vector< std::vector< float > > rpcHitTime
Definition: L2StandAloneMuonAuxContainer_v2.h:198
SG::IConstAuxStore::getVector
virtual const IAuxTypeVector * getVector(SG::auxid_t auxid) const =0
Return vector interface for one aux data item.
xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitMidPhi
std::vector< float > rpcFitMidPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:178
xAOD::L2StandAloneMuonAuxContainer_v2::superPointZ
std::vector< std::vector< float > > superPointZ
Definition: L2StandAloneMuonAuxContainer_v2.h:84
xAOD::L2StandAloneMuonAuxContainer_v2::ptCSC
std::vector< float > ptCSC
Definition: L2StandAloneMuonAuxContainer_v2.h:117
xAOD::L2StandAloneMuonAuxContainer_v2::roadAwNormal
std::vector< std::vector< float > > roadAwNormal
Slope.
Definition: L2StandAloneMuonAuxContainer_v2.h:126
xAOD::IOStats::stats
ReadStats & stats()
Access the object belonging to the current thread.
Definition: IOStats.cxx:17
xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitX
std::vector< std::vector< float > > rpcHitX
Definition: L2StandAloneMuonAuxContainer_v2.h:195
xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitsCapacity
std::vector< int > tgcHitsCapacity
Definition: L2StandAloneMuonAuxContainer_v2.h:188
xAOD::L2StandAloneMuonAuxContainer_v2::lumiBlock
std::vector< uint32_t > lumiBlock
Definition: L2StandAloneMuonAuxContainer_v2.h:99
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitResidual
std::vector< std::vector< float > > cscHitResidual
Definition: L2StandAloneMuonAuxContainer_v2.h:242
SG::AuxTypeRegistry::instance
static AuxTypeRegistry & instance()
Return the singleton registry instance.
Definition: AuxTypeRegistry.cxx:640
xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitY
std::vector< std::vector< float > > rpcHitY
Definition: L2StandAloneMuonAuxContainer_v2.h:196
xAOD::L2StandAloneMuonAuxContainer_v2::pt
std::vector< float > pt
Definition: L2StandAloneMuonAuxContainer_v2.h:41
xAOD::L2StandAloneMuonAuxContainer_v2::roiSector
std::vector< uint32_t > roiSector
Definition: L2StandAloneMuonAuxContainer_v2.h:104
xAOD::AuxContainerBase::m_store
SG::IAuxStore * m_store
Internal dynamic auxiliary store object.
Definition: AuxContainerBase.h:237
xAOD::L2StandAloneMuonAuxContainer_v2::rMinNormal
std::vector< std::vector< float > > rMinNormal
R.
Definition: L2StandAloneMuonAuxContainer_v2.h:137
xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterStationPhi
std::vector< std::vector< int > > mmClusterStationPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:268
xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterZ
std::vector< std::vector< float > > stgcClusterZ
Definition: L2StandAloneMuonAuxContainer_v2.h:251
xAOD::L2StandAloneMuonAuxContainer_v2::roiThreshold
std::vector< uint32_t > roiThreshold
Definition: L2StandAloneMuonAuxContainer_v2.h:106
xAOD::L2StandAloneMuonAuxContainer_v2::deltaPtParm1
std::vector< float > deltaPtParm1
Definition: L2StandAloneMuonAuxContainer_v2.h:76
SG::AuxTypeRegistry::getName
std::string getName(SG::auxid_t auxid) const
Return the name of an aux data item.
Definition: AuxTypeRegistry.cxx:882
xAOD::L2StandAloneMuonAuxContainer_v2::roiNumber
std::vector< uint32_t > roiNumber
Definition: L2StandAloneMuonAuxContainer_v2.h:105
xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitTime
std::vector< std::vector< float > > mdtHitTime
Definition: L2StandAloneMuonAuxContainer_v2.h:222
xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitPhi
std::vector< std::vector< float > > mdtHitPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:220
SG::ExcStoreLocked
Exception — Attempted to modify auxiliary data in a locked store.
Definition: Control/AthContainers/AthContainers/exceptions.h:183
xAOD::L2StandAloneMuonAuxContainer_v2::rMaxOverlap
std::vector< std::vector< float > > rMaxOverlap
Definition: L2StandAloneMuonAuxContainer_v2.h:140
Atlas::hasExtendedEventContext
bool hasExtendedEventContext(const EventContext &ctx)
Test whether a context object has an extended context installed.
Definition: ExtendedEventContext.cxx:23
xAOD::L2StandAloneMuonAuxContainer_v2::zMaxNormal
std::vector< std::vector< float > > zMaxNormal
Definition: L2StandAloneMuonAuxContainer_v2.h:134
xAOD::L2StandAloneMuonAuxContainer_v2::lvl1Id
std::vector< uint32_t > lvl1Id
Definition: L2StandAloneMuonAuxContainer_v2.h:98
xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterR
std::vector< std::vector< float > > mmClusterR
Definition: L2StandAloneMuonAuxContainer_v2.h:263
xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitStationNum
std::vector< std::vector< int > > tgcHitStationNum
Definition: L2StandAloneMuonAuxContainer_v2.h:209
xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitR
std::vector< std::vector< float > > mdtHitR
Definition: L2StandAloneMuonAuxContainer_v2.h:218
xAOD::other
@ other
Definition: TrackingPrimitives.h:510
xAOD::L2StandAloneMuonAuxContainer_v2::zMS
std::vector< float > zMS
Definition: L2StandAloneMuonAuxContainer_v2.h:56
xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitBCTag
std::vector< std::vector< int > > tgcHitBCTag
Definition: L2StandAloneMuonAuxContainer_v2.h:211
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitMeasuresPhi
std::vector< std::vector< int > > cscHitMeasuresPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:234
xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterStationPhi
std::vector< std::vector< int > > stgcClusterStationPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:255
SG::IAuxTypeVector::insertMove
virtual bool insertMove(size_t pos, void *src, size_t src_pos, size_t src_n, IAuxStore &srcStore)=0
Insert elements into the vector via move semantics.
xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnR
std::vector< float > tgcInnR
Definition: L2StandAloneMuonAuxContainer_v2.h:150
xAOD::L2StandAloneMuonAuxContainer_v2::barrelRadius
std::vector< float > barrelRadius
Input measurements to be converted to pT by LUT.
Definition: L2StandAloneMuonAuxContainer_v2.h:60
xAOD::L2StandAloneMuonAuxContainer_v2::roadAwOverlap
std::vector< std::vector< float > > roadAwOverlap
Definition: L2StandAloneMuonAuxContainer_v2.h:127
xAOD::L2StandAloneMuonAuxContainer_v2::phi
std::vector< float > phi
Definition: L2StandAloneMuonAuxContainer_v2.h:42
xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitOutOffset
std::vector< float > rpcFitOutOffset
Definition: L2StandAloneMuonAuxContainer_v2.h:184
xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitChamberId
std::vector< std::vector< int > > mdtHitChamberId
Definition: L2StandAloneMuonAuxContainer_v2.h:217
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterEta
std::vector< std::vector< float > > mmClusterEta
Definition: L2StandAloneMuonAuxContainer_v2.h:261
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitZ
std::vector< std::vector< float > > cscHitZ
Definition: L2StandAloneMuonAuxContainer_v2.h:239
SG::IAuxStoreIO::getIOType
virtual const std::type_info * getIOType(SG::auxid_t auxid) const =0
Return the type of the data to be stored for one aux data item.
xAOD::AuxContainerBase::m_mutex
mutex_t m_mutex
Definition: AuxContainerBase.h:248
xAOD::L2StandAloneMuonAuxContainer_v2::barrelSagitta
std::vector< float > barrelSagitta
Definition: L2StandAloneMuonAuxContainer_v2.h:61
xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterEta
std::vector< std::vector< float > > stgcClusterEta
Definition: L2StandAloneMuonAuxContainer_v2.h:248
xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterResidualR
std::vector< std::vector< float > > stgcClusterResidualR
Definition: L2StandAloneMuonAuxContainer_v2.h:252
xAOD::L2StandAloneMuonAuxContainer_v2::chamberType2Normal
std::vector< std::vector< int > > chamberType2Normal
Definition: L2StandAloneMuonAuxContainer_v2.h:123
xAOD::L2StandAloneMuonAuxContainer_v2::eta
std::vector< float > eta
Definition: L2StandAloneMuonAuxContainer_v2.h:43
SG::IConstAuxStore::size
virtual size_t size() const =0
Return the number of elements in the store.
SG::IAuxStore::shift
virtual void shift(size_t pos, ptrdiff_t offs)=0
Shift the elements of the container.
xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterPhi
std::vector< std::vector< float > > stgcClusterPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:249
xAOD::L2StandAloneMuonAuxContainer_v2::teId
std::vector< uint32_t > teId
Definition: L2StandAloneMuonAuxContainer_v2.h:97
xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid1Z
std::vector< float > tgcMid1Z
Definition: L2StandAloneMuonAuxContainer_v2.h:156
SG::IAuxStore::linkedVector
virtual IAuxTypeVector * linkedVector(SG::auxid_t)
Definition: IAuxStore.h:187
xAOD::L2StandAloneMuonAuxContainer_v2::trackPositionR
std::vector< std::vector< float > > trackPositionR
Track positions.
Definition: L2StandAloneMuonAuxContainer_v2.h:90
SG::IAuxStoreIO
Interface providing I/O for a generic auxiliary store.
Definition: IAuxStoreIO.h:44
xAOD::L2StandAloneMuonAuxContainer_v2::endcapBeta
std::vector< float > endcapBeta
Definition: L2StandAloneMuonAuxContainer_v2.h:63
xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitStationName
std::vector< std::vector< std::string > > rpcHitStationName
Definition: L2StandAloneMuonAuxContainer_v2.h:201
xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitInnSlope
std::vector< float > rpcFitInnSlope
Definition: L2StandAloneMuonAuxContainer_v2.h:175
SG::AuxTypeRegistry
Handle mappings between names and auxid_t.
Definition: AuxTypeRegistry.h:61
Atlas::getExtendedEventContext
const ExtendedEventContext & getExtendedEventContext(const EventContext &ctx)
Retrieve an extended context from a context object.
Definition: ExtendedEventContext.cxx:32
xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitIsStrip
std::vector< std::vector< bool > > tgcHitIsStrip
Definition: L2StandAloneMuonAuxContainer_v2.h:210
xAOD::AuxContainerBase::size
virtual size_t size() const override
Get the size of the container.
Definition: AuxContainerBase.cxx:432
xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitsCapacity
std::vector< int > mdtHitsCapacity
Definition: L2StandAloneMuonAuxContainer_v2.h:189
DiTauMassTools::ignore
void ignore(T &&)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:58
SG::IAuxStore::setOption
virtual bool setOption(auxid_t, const AuxDataOption &)
Set an option for a given auxiliary variable.
Definition: IAuxStore.h:173
SG::auxid_t
size_t auxid_t
Identifier for a particular aux data item.
Definition: AuxTypes.h:27
xAOD::L2StandAloneMuonAuxContainer_v2::isRpcFailure
std::vector< int > isRpcFailure
Definition: L2StandAloneMuonAuxContainer_v2.h:73
SG::IConstAuxStore::clearDecorations
virtual bool clearDecorations()=0
Clear all decorations.
xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitLayer
std::vector< std::vector< uint32_t > > rpcHitLayer
RPC pad hits.
Definition: L2StandAloneMuonAuxContainer_v2.h:193
xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnPhiN
std::vector< long > tgcInnPhiN
Definition: L2StandAloneMuonAuxContainer_v2.h:166
xAOD::AuxContainerBase::auxid_set_t
SG::auxid_set_t auxid_set_t
The aux ID set type definition.
Definition: AuxContainerBase.h:65
xAOD::AuxContainerBase::m_auxids
auxid_set_t m_auxids
Internal list of all available variables.
Definition: AuxContainerBase.h:232
xAOD::AuxContainerBase::m_vecs
std::vector< SG::IAuxTypeVector * > m_vecs
Internal list of all managed variables.
Definition: AuxContainerBase.h:234
xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitInnPhi
std::vector< float > rpcFitInnPhi
RPC fit results.
Definition: L2StandAloneMuonAuxContainer_v2.h:174
lumiFormat.i
int i
Definition: lumiFormat.py:85
xAOD::L2StandAloneMuonAuxContainer_v2::zMinOverlap
std::vector< std::vector< float > > zMinOverlap
Definition: L2StandAloneMuonAuxContainer_v2.h:133
xAOD::L2StandAloneMuonAuxContainer_v2::etaMS
std::vector< float > etaMS
Definition: L2StandAloneMuonAuxContainer_v2.h:53
guard_t
AthContainers_detail::lock_guard< mutex_t > guard_t
Guard type for multithreaded synchronisation.
Definition: EventIProxyDict.cxx:36
xAOD::L2StandAloneMuonAuxContainer_v2::rMinOverlap
std::vector< std::vector< float > > rMinOverlap
Definition: L2StandAloneMuonAuxContainer_v2.h:138
CxxUtils::ConcurrentBitset::insert
ConcurrentBitset & insert(bit_t bit, bit_t new_nbits=0)
Set a bit to 1.
AUX_VARIABLE
#define AUX_VARIABLE(VAR,...)
Convenience macro for declaring an auxiliary variable.
Definition: AuxVariable.h:23
xAOD::L2StandAloneMuonAuxContainer_v2::dirPhiMS
std::vector< float > dirPhiMS
Definition: L2StandAloneMuonAuxContainer_v2.h:55
xAOD::L2StandAloneMuonAuxContainer_v2::etaMaxOverlap
std::vector< std::vector< float > > etaMaxOverlap
Definition: L2StandAloneMuonAuxContainer_v2.h:145
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitChamberLayer
std::vector< std::vector< int > > cscHitChamberLayer
Definition: L2StandAloneMuonAuxContainer_v2.h:232
xAOD::L2StandAloneMuonAuxContainer_v2::muonDetMask
std::vector< uint32_t > muonDetMask
Definition: L2StandAloneMuonAuxContainer_v2.h:100
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitChamberId
std::vector< std::vector< int > > cscHitChamberId
Definition: L2StandAloneMuonAuxContainer_v2.h:228
xAOD::L2StandAloneMuonAuxContainer_v2::deltaPtParm3
std::vector< float > deltaPtParm3
Definition: L2StandAloneMuonAuxContainer_v2.h:78
xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterStationName
std::vector< std::vector< int > > mmClusterStationName
Definition: L2StandAloneMuonAuxContainer_v2.h:269
xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterType
std::vector< std::vector< int > > stgcClusterType
Definition: L2StandAloneMuonAuxContainer_v2.h:247
xAOD::L2StandAloneMuonAuxContainer_v2::dirZMS
std::vector< float > dirZMS
Definition: L2StandAloneMuonAuxContainer_v2.h:57
xAOD::L2StandAloneMuonAuxContainer_v2::etaMinNormal
std::vector< std::vector< float > > etaMinNormal
Eta.
Definition: L2StandAloneMuonAuxContainer_v2.h:142
xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterStationEta
std::vector< std::vector< int > > mmClusterStationEta
Definition: L2StandAloneMuonAuxContainer_v2.h:267
xAOD::L2StandAloneMuonAuxContainer_v2::roadBwOverlap
std::vector< std::vector< float > > roadBwOverlap
Definition: L2StandAloneMuonAuxContainer_v2.h:130
xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid2Phi
std::vector< float > tgcMid2Phi
Definition: L2StandAloneMuonAuxContainer_v2.h:159
xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid1Eta
std::vector< float > tgcMid1Eta
Definition: L2StandAloneMuonAuxContainer_v2.h:153
xAOD::L2StandAloneMuonAuxContainer_v2::tgcMidRhoN
std::vector< long > tgcMidRhoN
Definition: L2StandAloneMuonAuxContainer_v2.h:169
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitStationName
std::vector< std::vector< uint32_t > > cscHitStationName
Definition: L2StandAloneMuonAuxContainer_v2.h:229
xAOD::L2StandAloneMuonAuxContainer_v2::etaMaxNormal
std::vector< std::vector< float > > etaMaxNormal
Definition: L2StandAloneMuonAuxContainer_v2.h:144
xAOD::L2StandAloneMuonAuxContainer_v2::tgcMidPhiN
std::vector< long > tgcMidPhiN
Definition: L2StandAloneMuonAuxContainer_v2.h:171
xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid2Z
std::vector< float > tgcMid2Z
Definition: L2StandAloneMuonAuxContainer_v2.h:161
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitStrip
std::vector< std::vector< int > > cscHitStrip
Definition: L2StandAloneMuonAuxContainer_v2.h:235
xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnZ
std::vector< float > tgcInnZ
Definition: L2StandAloneMuonAuxContainer_v2.h:151
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitStationEta
std::vector< std::vector< int > > cscHitStationEta
Definition: L2StandAloneMuonAuxContainer_v2.h:230
SG::IConstAuxStore::getDecoration
virtual void * getDecoration(auxid_t auxid, size_t size, size_t capacity)=0
Return the data vector for one aux data decoration item.
xAOD::L2StandAloneMuonAuxContainer_v2::zMaxOverlap
std::vector< std::vector< float > > zMaxOverlap
Definition: L2StandAloneMuonAuxContainer_v2.h:135
xAOD::L2StandAloneMuonAuxContainer_v2::etaMinOverlap
std::vector< std::vector< float > > etaMinOverlap
Definition: L2StandAloneMuonAuxContainer_v2.h:143
xAOD::L2StandAloneMuonAuxContainer_v2::roiWord
std::vector< uint32_t > roiWord
Definition: L2StandAloneMuonAuxContainer_v2.h:49
SG::AuxTypeRegistry::getVecType
const std::type_info * getVecType(SG::auxid_t auxid) const
Return the type of the STL vector used to hold an aux data item.
Definition: AuxTypeRegistry.cxx:937
xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnPhiStd
std::vector< float > tgcInnPhiStd
Definition: L2StandAloneMuonAuxContainer_v2.h:165
xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitEta
std::vector< std::vector< float > > tgcHitEta
TGC hits.
Definition: L2StandAloneMuonAuxContainer_v2.h:204
xAOD::L2StandAloneMuonAuxContainer_v2::rMS
std::vector< float > rMS
Position at MS.
Definition: L2StandAloneMuonAuxContainer_v2.h:52
xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitResidual
std::vector< std::vector< float > > mdtHitResidual
Definition: L2StandAloneMuonAuxContainer_v2.h:221
xAOD::IOStats::instance
static IOStats & instance()
Singleton object accessor.
Definition: IOStats.cxx:11
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitCharge
std::vector< std::vector< int > > cscHitCharge
Definition: L2StandAloneMuonAuxContainer_v2.h:240
xAOD::L2StandAloneMuonAuxContainer_v2::algoId
std::vector< int > algoId
Detailed information.
Definition: L2StandAloneMuonAuxContainer_v2.h:96
xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitOutSlope
std::vector< float > rpcFitOutSlope
Definition: L2StandAloneMuonAuxContainer_v2.h:183
xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid2R
std::vector< float > tgcMid2R
Definition: L2StandAloneMuonAuxContainer_v2.h:160
xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitR
std::vector< std::vector< float > > tgcHitR
Definition: L2StandAloneMuonAuxContainer_v2.h:206
xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterLayer
std::vector< std::vector< unsigned int > > stgcClusterLayer
Definition: L2StandAloneMuonAuxContainer_v2.h:245
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitEta
std::vector< std::vector< float > > cscHitEta
Definition: L2StandAloneMuonAuxContainer_v2.h:236
xAOD::L2StandAloneMuonAuxContainer_v2::ptBarrelRadius
std::vector< float > ptBarrelRadius
Definition: L2StandAloneMuonAuxContainer_v2.h:112
xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnRhoStd
std::vector< float > tgcInnRhoStd
Definition: L2StandAloneMuonAuxContainer_v2.h:163
xAOD::L2StandAloneMuonAuxContainer_v2::superPointIntercept
std::vector< std::vector< float > > superPointIntercept
Definition: L2StandAloneMuonAuxContainer_v2.h:86
xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterIsOutlier
std::vector< std::vector< int > > stgcClusterIsOutlier
Definition: L2StandAloneMuonAuxContainer_v2.h:246
xAOD::L2StandAloneMuonAuxContainer_v2::roiEta
std::vector< float > roiEta
Definition: L2StandAloneMuonAuxContainer_v2.h:107
xAOD::L2StandAloneMuonAuxContainer_v2::etaMap
std::vector< float > etaMap
eta, phi as input to LUT
Definition: L2StandAloneMuonAuxContainer_v2.h:67
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
python.subdetectors.mmg.ids
ids
Definition: mmg.py:8
xAOD::AuxContainerBase::getVector
virtual const SG::IAuxTypeVector * getVector(SG::auxid_t auxid) const override final
Return vector interface for one aux data item.
Definition: AuxContainerBase.cxx:241
xAOD::L2StandAloneMuonAuxContainer_v2::ptEndcapBeta
std::vector< float > ptEndcapBeta
Definition: L2StandAloneMuonAuxContainer_v2.h:115
CxxUtils::as_const_ptr
const T * as_const_ptr(const T *p)
Helper for getting a const version of a pointer.
Definition: as_const_ptr.h:32
xAOD::L2StandAloneMuonAuxContainer_v2::beta
std::vector< float > beta
Definition: L2StandAloneMuonAuxContainer_v2.h:58
xAOD::L2StandAloneMuonAuxContainer_v2::zMinNormal
std::vector< std::vector< float > > zMinNormal
Z.
Definition: L2StandAloneMuonAuxContainer_v2.h:132
xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterResidualPhi
std::vector< std::vector< float > > stgcClusterResidualPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:253
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitStationPhi
std::vector< std::vector< int > > cscHitStationPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:231
xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitZ
std::vector< std::vector< float > > tgcHitZ
Definition: L2StandAloneMuonAuxContainer_v2.h:207
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitR
std::vector< std::vector< float > > cscHitR
Definition: L2StandAloneMuonAuxContainer_v2.h:238
xAOD::AuxContainerBase::getWritableAuxIDs
virtual const auxid_set_t & getWritableAuxIDs() const override
Return a set of writable data identifiers.
Definition: AuxContainerBase.cxx:500
xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterResidualR
std::vector< std::vector< float > > mmClusterResidualR
Definition: L2StandAloneMuonAuxContainer_v2.h:265
SG::IAuxStoreIO::getIOData
virtual const void * getIOData(SG::auxid_t auxid) const =0
Return a pointer to the data to be stored for one aux data item.
xAOD::AuxContainerBase::getData
virtual const void * getData(auxid_t auxid) const override
Get a pointer to a given array.
Definition: AuxContainerBase.cxx:232
xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitDistToPhiReadout
std::vector< std::vector< float > > rpcHitDistToPhiReadout
Definition: L2StandAloneMuonAuxContainer_v2.h:200
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitTime
std::vector< std::vector< float > > cscHitTime
Definition: L2StandAloneMuonAuxContainer_v2.h:241
xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitsCapacity
std::vector< int > rpcHitsCapacity
Size of hit strages.
Definition: L2StandAloneMuonAuxContainer_v2.h:187
xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterStationName
std::vector< std::vector< int > > stgcClusterStationName
Definition: L2StandAloneMuonAuxContainer_v2.h:256
xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterLayer
std::vector< std::vector< unsigned int > > mmClusterLayer
Definition: L2StandAloneMuonAuxContainer_v2.h:259
xAOD::L2StandAloneMuonAuxContainer_v2::superPointSlope
std::vector< std::vector< float > > superPointSlope
Definition: L2StandAloneMuonAuxContainer_v2.h:85
xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid1R
std::vector< float > tgcMid1R
Definition: L2StandAloneMuonAuxContainer_v2.h:155
xAOD::ReadStats::readBranch
void readBranch(const std::string &prefix, SG::auxid_t auxid)
Function incrementing the read counter on a specific branch.
xAOD::L2StandAloneMuonAuxContainer_v2::tgcPt
std::vector< float > tgcPt
pT from different algorithms
Definition: L2StandAloneMuonAuxContainer_v2.h:111
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
xAOD::AuxContainerBase::auxid_t
SG::auxid_t auxid_t
The aux ID type definition.
Definition: AuxContainerBase.h:63
xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterPhi
std::vector< std::vector< float > > mmClusterPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:262
xAOD::L2StandAloneMuonAuxContainer_v2::phiMS
std::vector< float > phiMS
Definition: L2StandAloneMuonAuxContainer_v2.h:54
python.PyAthena.v
v
Definition: PyAthena.py:154
xAOD::AuxContainerBase::ATLAS_THREAD_SAFE
CxxUtils::CachedPointer< std::pmr::memory_resource > m_memResource ATLAS_THREAD_SAFE
Memory resource to use for this container.
Definition: AuxContainerBase.h:254
xAOD::L2StandAloneMuonAuxContainer_v2::phiMap
std::vector< float > phiMap
Definition: L2StandAloneMuonAuxContainer_v2.h:68
xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitMeasuresPhi
std::vector< std::vector< uint32_t > > rpcHitMeasuresPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:194
columnar::empty
bool empty() const noexcept
Definition: ObjectRange.h:163
xAOD::L2StandAloneMuonAuxContainer_v2::ptBarrelSagitta
std::vector< float > ptBarrelSagitta
Definition: L2StandAloneMuonAuxContainer_v2.h:113
xAOD::L2StandAloneMuonAuxContainer_v2::tgcMidRhoChi2
std::vector< float > tgcMidRhoChi2
Definition: L2StandAloneMuonAuxContainer_v2.h:168
xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitZ
std::vector< std::vector< float > > mdtHitZ
Definition: L2StandAloneMuonAuxContainer_v2.h:219
xAOD::L2StandAloneMuonAuxContainer_v2::deltaPt
std::vector< float > deltaPt
Error of pt, eta and phi.
Definition: L2StandAloneMuonAuxContainer_v2.h:75
xAOD::L2StandAloneMuonAuxContainer_v2::ptEndcapAlpha
std::vector< float > ptEndcapAlpha
Definition: L2StandAloneMuonAuxContainer_v2.h:114
xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitZ
std::vector< std::vector< float > > rpcHitZ
Definition: L2StandAloneMuonAuxContainer_v2.h:197
SG::IAuxStore::getData
virtual void * getData(auxid_t auxid, size_t size, size_t capacity)=0
Return the data vector for one aux data item.
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitsCapacity
std::vector< int > cscHitsCapacity
Definition: L2StandAloneMuonAuxContainer_v2.h:190
xAOD::L2StandAloneMuonAuxContainer_v2::tgcMidPhiChi2
std::vector< float > tgcMidPhiChi2
Definition: L2StandAloneMuonAuxContainer_v2.h:170
xAOD::AuxContainerBase::m_locked
bool m_locked
Has the container been locked?
Definition: AuxContainerBase.h:243
xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitOutPhi
std::vector< float > rpcFitOutPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:182
SG::IAuxTypeVector
Abstract interface for manipulating vectors of arbitrary types.
Definition: IAuxTypeVector.h:42
xAOD::AuxContainerBase::m_ownsStore
bool m_ownsStore
Flag deciding if the object owns the dynamic store or not.
Definition: AuxContainerBase.h:241
SG::IConstAuxStore::getDecorIDs
virtual const SG::auxid_set_t & getDecorIDs() const =0
Return a set of identifiers for decorations in this store.
xAOD::L2StandAloneMuonAuxContainer_v2::tgcInnEta
std::vector< float > tgcInnEta
TGC fit results.
Definition: L2StandAloneMuonAuxContainer_v2.h:148
xAOD::L2StandAloneMuonAuxContainer_v2::chamberType1Overlap
std::vector< std::vector< int > > chamberType1Overlap
Definition: L2StandAloneMuonAuxContainer_v2.h:122
xAOD::L2StandAloneMuonAuxContainer_v2::chamberType2Overlap
std::vector< std::vector< int > > chamberType2Overlap
Definition: L2StandAloneMuonAuxContainer_v2.h:124
SG::IConstAuxStore::lock
virtual void lock()=0
Lock the container.
xAOD::L2StandAloneMuonAuxContainer_v2::roadBwNormal
std::vector< std::vector< float > > roadBwNormal
Intercept.
Definition: L2StandAloneMuonAuxContainer_v2.h:129
xAOD::AuxContainerBase::m_storeIO
SG::IAuxStoreIO * m_storeIO
The IO interface to the internal auxiliary store.
Definition: AuxContainerBase.h:239
xAOD::AuxContainerBase::AuxContainerBase
AuxContainerBase(bool allowDynamicVars=true)
Default constructor.
Definition: AuxContainerBase.cxx:33
xAOD::L2StandAloneMuonAuxContainer_v2::isTgcFailure
std::vector< int > isTgcFailure
Flag for RGC and RPC availabilities.
Definition: L2StandAloneMuonAuxContainer_v2.h:72
xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterZ
std::vector< std::vector< float > > mmClusterZ
Definition: L2StandAloneMuonAuxContainer_v2.h:264
xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid1Phi
std::vector< float > tgcMid1Phi
Definition: L2StandAloneMuonAuxContainer_v2.h:154
SG::IAuxStore::resize
virtual bool resize(size_t sz)=0
Change the size of all aux data vectors.
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitPhi
std::vector< std::vector< float > > cscHitPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:237
SG::auxid_set_t
A set of aux data identifiers.
Definition: AuxTypes.h:47
xAOD::L2StandAloneMuonAuxContainer_v2::roiSubsystem
std::vector< uint32_t > roiSubsystem
Definition: L2StandAloneMuonAuxContainer_v2.h:103
xAOD::L2StandAloneMuonAuxContainer_v2::sAddress
std::vector< int > sAddress
Definition: L2StandAloneMuonAuxContainer_v2.h:50
xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitInRoad
std::vector< std::vector< bool > > tgcHitInRoad
Definition: L2StandAloneMuonAuxContainer_v2.h:212
xAOD::L2StandAloneMuonAuxContainer_v2::roiId
std::vector< uint32_t > roiId
Definition: L2StandAloneMuonAuxContainer_v2.h:101
SG::IConstAuxStore::isDecoration
virtual bool isDecoration(auxid_t auxid) const =0
Test if a particular variable is tagged as a decoration.
xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitSigma
std::vector< std::vector< float > > mdtHitSigma
Definition: L2StandAloneMuonAuxContainer_v2.h:224
xAOD::L2StandAloneMuonAuxContainer_v2::phiBin
std::vector< int > phiBin
Definition: L2StandAloneMuonAuxContainer_v2.h:70
xAOD::L2StandAloneMuonAuxContainer_v2::deltaEta
std::vector< float > deltaEta
Definition: L2StandAloneMuonAuxContainer_v2.h:79
xAOD::L2StandAloneMuonAuxContainer_v2::rMaxNormal
std::vector< std::vector< float > > rMaxNormal
Definition: L2StandAloneMuonAuxContainer_v2.h:139
xAOD::L2StandAloneMuonAuxContainer_v2::trackPositionZ
std::vector< std::vector< float > > trackPositionZ
Definition: L2StandAloneMuonAuxContainer_v2.h:91
xAOD::L2StandAloneMuonAuxContainer_v2::tgcHitWidth
std::vector< std::vector< float > > tgcHitWidth
Definition: L2StandAloneMuonAuxContainer_v2.h:208
xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitOnlineId
std::vector< std::vector< uint32_t > > mdtHitOnlineId
MDT hits.
Definition: L2StandAloneMuonAuxContainer_v2.h:215
xAOD::L2StandAloneMuonAuxContainer_v2::cscHitIsOutlier
std::vector< std::vector< int > > cscHitIsOutlier
CSC hits.
Definition: L2StandAloneMuonAuxContainer_v2.h:227
xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitMidSlope
std::vector< float > rpcFitMidSlope
Definition: L2StandAloneMuonAuxContainer_v2.h:179
xAOD::L2StandAloneMuonAuxContainer_v2::ptEndcapRadius
std::vector< float > ptEndcapRadius
Definition: L2StandAloneMuonAuxContainer_v2.h:116
SG::IAuxStoreHolder::AST_ObjectStore
@ AST_ObjectStore
The store describes a single object.
Definition: IAuxStoreHolder.h:67
xAOD::L2StandAloneMuonAuxContainer_v2::etaBin
std::vector< int > etaBin
Definition: L2StandAloneMuonAuxContainer_v2.h:69
xAOD::L2StandAloneMuonAuxContainer_v2::trackPositionEta
std::vector< std::vector< float > > trackPositionEta
Definition: L2StandAloneMuonAuxContainer_v2.h:92
xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitIsOutlier
std::vector< std::vector< int > > mdtHitIsOutlier
Definition: L2StandAloneMuonAuxContainer_v2.h:216
xAOD::L2StandAloneMuonAuxContainer_v2::rpcHitDistToEtaReadout
std::vector< std::vector< float > > rpcHitDistToEtaReadout
Definition: L2StandAloneMuonAuxContainer_v2.h:199
xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitMidOffset
std::vector< float > rpcFitMidOffset
Definition: L2StandAloneMuonAuxContainer_v2.h:180
xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitInnOffset
std::vector< float > rpcFitInnOffset
Definition: L2StandAloneMuonAuxContainer_v2.h:176
SG::IConstAuxStore::getAuxIDs
virtual const SG::auxid_set_t & getAuxIDs() const =0
Return a set of identifiers for existing data items in this store.
xAOD::L2StandAloneMuonAuxContainer_v2::tgcMid2Eta
std::vector< float > tgcMid2Eta
Definition: L2StandAloneMuonAuxContainer_v2.h:158
SG::IAuxTypeVector::toPtr
virtual void * toPtr()=0
Return a pointer to the start of the vector's data.
xAOD::L2StandAloneMuonAuxContainer_v2::mmClusterResidualPhi
std::vector< std::vector< float > > mmClusterResidualPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:266
xAOD::L2StandAloneMuonAuxContainer_v2::endcapRadius
std::vector< float > endcapRadius
Definition: L2StandAloneMuonAuxContainer_v2.h:64
xAOD::L2StandAloneMuonAuxContainer_v2::roiPhi
std::vector< float > roiPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:108
SG::IAuxStore::reserve
virtual void reserve(size_t sz)=0
Change the capacity of all aux data vectors.
SG::IAuxStoreHolder::AST_ContainerStore
@ AST_ContainerStore
The store describes a container.
Definition: IAuxStoreHolder.h:68
xAOD::L2StandAloneMuonAuxContainer_v2::stgcClusterR
std::vector< std::vector< float > > stgcClusterR
Definition: L2StandAloneMuonAuxContainer_v2.h:250
xAOD::L2StandAloneMuonAuxContainer_v2::trackPositionPhi
std::vector< std::vector< float > > trackPositionPhi
Definition: L2StandAloneMuonAuxContainer_v2.h:93
Generated on Fri Oct 24 2025 22:14:11 for ATLAS Offline Software by   doxygen 1.8.18