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...
 
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 bool insertMove (size_t pos, IAuxStore &other, const SG::auxid_set_t &ignore=SG::auxid_set_t())=0
 Move all elements from other to this store. More...
 
template<typename T , typename ALLOC >
auxid_t getAuxID (const std::string &name, std::vector< T, ALLOC > &, SG::AuxVarFlags flags=SG::AuxVarFlags::None)
 Get the auxiliary ID for one of the persistent variables. More...
 
template<typename T >
auxid_t getAuxID (const std::string &name, SG::PackedContainer< T > &, SG::AuxTypeRegistry::Flags flags=SG::AuxTypeRegistry::Flags::None)
 Get the auxiliary ID for one of the persistent variables. More...
 
template<typename T , typename ALLOC >
void regAuxVar (auxid_t auxid, const std::string &name, std::vector< T, ALLOC > &vec)
 Register one of the persistent variables internally. More...
 
template<typename T >
void regAuxVar (auxid_t auxid, const std::string &name, SG::PackedContainer< T > &vec)
 Register one of the persistent variables internally. More...
 

Static Public Attributes

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

Private Types

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

Private Member Functions

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

Private Attributes

auxid_set_t m_auxids
 Internal list of all available variables. More...
 
std::vector< SG::IAuxTypeVector * > m_vecs
 Internal list of all managed variables. More...
 
SG::IAuxStore * m_store
 Internal dynamic auxiliary store object. More...
 
SG::IAuxStoreIO * m_storeIO
 The IO interface to the internal auxiliary store. More...
 
bool m_ownsStore
 Flag deciding if the object owns the dynamic store or not. More...
 
bool m_locked
 Has the container been locked? More...
 
mutex_t m_mutex
 
std::string m_name
 Name of the container in memory. Set externally. More...
 
CxxUtils::CachedPointer< std::pmr::memory_resource > m_memResource ATLAS_THREAD_SAFE
 Memory resource to use for this container. More...
 
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 183 of file AuxContainerBase.h.

◆ guard_t

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

Definition at line 231 of file AuxContainerBase.h.

◆ mutex_t

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

Mutex for multithread synchronization.

Definition at line 230 of file AuxContainerBase.h.

Member Enumeration Documentation

◆ AuxStoreType

enum SG::IAuxStoreHolder::AuxStoreType
inherited

Type of the auxiliary store.

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

Enumerator
AST_ObjectStore 

The store describes a single object.

AST_ContainerStore 

The store describes a container.

Definition at line 66 of file IAuxStoreHolder.h.

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

325  {
326 
327  // Guard against multi-threaded execution:
328  guard_t guard( m_mutex );
329 
330  // Clear the decorations from the dynamic store:
331  bool anycleared = false;
332  if( m_store ) {
333  anycleared = m_store->clearDecorations();
334  }
335  // Early exit if there were no decorations.
336  if (!anycleared) return false;
337 
338  // Construct the list of managed auxiliary variables from scratch after
339  // the cleanup:
340  auxid_set_t ids;
341  for( auxid_t auxid = 0; auxid < m_vecs.size(); ++auxid ) {
342  if( m_vecs[ auxid ] ) {
343  ids.insert( auxid );
344  }
345  }
346  if( m_store ) {
347  ids.insert (m_store->getAuxIDs());
348  }
349  m_auxids = ids;
350 
351  return true;
352  }

◆ getAuxID() [1/2]

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

Get the auxiliary ID for one of the persistent variables.

◆ getAuxID() [2/2]

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

Get the auxiliary ID for one of the persistent variables.

◆ getAuxIDs()

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

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

Implements SG::IConstAuxStore.

Definition at line 258 of file AuxContainerBase.cxx.

258  {
259 
260  // Return the full list of IDs:
261  return getWritableAuxIDs();
262  }

◆ getData() [1/3]

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

Get a pointer to a given array.

Implements SG::IConstAuxStore.

Definition at line 227 of file AuxContainerBase.cxx.

227  {
228 
229  // Guard against multi-threaded execution:
230  guard_t guard( m_mutex );
231 
232  if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
233  if( m_store ) {
234  const void* result = m_store->getData( auxid );
235  if( result ) {
236  auxid_set_t& auxids_nc ATLAS_THREAD_SAFE =
237  const_cast<auxid_set_t&> (m_auxids);
238  auxids_nc.insert( auxid );
239  }
240  return result;
241  } else {
242  std::cout << "ERROR xAOD::AuxContainerBase::getData "
243  << "Unknown variable ("
244  << SG::AuxTypeRegistry::instance().getName( auxid )
245  << ") requested" << std::endl;
246  return nullptr;
247  }
248  }
249 
250  // Update the statistics for this variable. The dynamic store registers
251  // its own variable accesses.
252  IOStats::instance().stats().readBranch( m_name, auxid );
253 
254  return m_vecs[ auxid ]->toPtr();
255  }

◆ getData() [2/3]

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

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

Implements SG::IAuxStore.

Definition at line 395 of file AuxContainerBase.cxx.

396  {
397 
398  // Guard against multi-threaded execution:
399  guard_t guard( m_mutex );
400 
401  if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
402 
403  if( m_store ) {
404  void* result = m_store->getData( auxid, size, capacity );
405  if( result ) {
406  m_auxids.insert( auxid );
407  }
408  return result;
409  } else {
410  std::cout << "ERROR xAOD::AuxContainerBase::getData "
411  << "Unknown variable ("
412  << SG::AuxTypeRegistry::instance().getName( auxid )
413  << ") requested" << std::endl;
414  return nullptr;
415  }
416  }
417  m_vecs[ auxid ]->reserve( capacity );
418  m_vecs[ auxid ]->resize( size );
419 
420  return m_vecs[ auxid ]->toPtr();
421  }

◆ getData() [3/3]

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

Pick up the const version from the base class.

◆ getDecoration()

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

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

Implements SG::IConstAuxStore.

Reimplemented in xAOD::EventInfoAuxContainer_v1.

Definition at line 273 of file AuxContainerBase.cxx.

274  {
275  {
276  // Guard against multi-threaded execution:
277  guard_t guard( m_mutex );
278 
279  // Check if we have it as a static variable:
280  if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
281  // If not, but we have a dynamic store, push it in there:
282  if( m_store ) {
283  void* result = m_store->getDecoration( auxid, size, capacity );
284  if( result ) {
285  m_auxids.insert( auxid );
286  }
287  return result;
288  }
289  // If we don't have a dynamic store, complain:
290  else {
291  std::cout << "ERROR xAOD::AuxContainerBase::getDecoration "
292  << "Can't provide variable "
293  << SG::AuxTypeRegistry::instance().getName( auxid )
294  << std::endl;
295  return nullptr;
296  }
297  }
298 
299  // If the container is locked, static variables can't be accessed this
300  // way:
301  if( m_locked ) {
302  throw SG::ExcStoreLocked( auxid );
303  }
304  }
305 
306  // If the container is not locked, then fall back on the normal accessor
307  // function:
308  return getData( auxid, size, capacity );
309  }

◆ getDynamicAuxIDs()

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

Get the types(names) of variables created dynamically.

Implements SG::IAuxStoreIO.

Definition at line 628 of file AuxContainerBase.cxx.

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

◆ getIOData()

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

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

Implements SG::IAuxStoreIO.

Definition at line 586 of file AuxContainerBase.cxx.

586  {
587 
588  // Guard against multi-threaded execution:
589  guard_t guard( m_mutex );
590 
591  // If the variable is not static, look for it in the dynamic store:
592  if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
593  if( m_storeIO ) {
594  return m_storeIO->getIOData( auxid );
595  } else {
596  std::cout << "ERROR xAOD::AuxContainerBase::getIOData "
597  << "Unknown variable ("
598  << SG::AuxTypeRegistry::instance().getName( auxid )
599  << ") requested" << std::endl;
600  return nullptr;
601  }
602  }
603 
604  // Update the statistics for this variable. The dynamic store registers
605  // its own variable accesses.
606  IOStats::instance().stats().readBranch( m_name, auxid );
607 
608  return m_vecs[ auxid ]->toVector();
609  }

◆ getIOType()

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

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

Implements SG::IAuxStoreIO.

Definition at line 611 of file AuxContainerBase.cxx.

611  {
612 
613  // Guard against multi-threaded execution:
614  guard_t guard( m_mutex );
615 
616  // If the variable is not static, ask the dynamic store:
617  if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
618  if( m_storeIO ) {
619  return m_storeIO->getIOType( auxid );
620  }
621  }
622 
623  // Fall back on getting the information from the registry:
624  return SG::AuxTypeRegistry::instance().getVecType( auxid );
625  }

◆ getSelectedAuxIDs()

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

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

Reimplemented from SG::IAuxStoreIO.

Definition at line 648 of file AuxContainerBase.cxx.

648  {
649 
650  // Guard against multi-threaded execution:
651  guard_t guard( m_mutex );
652 
653  // All the variables handled by the internal store are dynamic
654  // if such a store exists:
655  if( m_storeIO ) {
656  // I mean, all the variables. Not just the ones reported as dynamic
657  // by the internal object. Because the internal object may be something
658  // that was put into this one in order to achieve data slimming.
659  return m_store->getAuxIDs();
660  }
661 
662  // In case we don't use an internal store, there are no dynamic
663  // variables:
664  return auxid_set_t();
665  }

◆ getStore() [1/2]

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

Implements SG::IAuxStoreHolder.

Definition at line 178 of file AuxContainerBase.cxx.

179  {
180  return m_store;
181  }

◆ getStore() [2/2]

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

Get the currently used internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 151 of file AuxContainerBase.cxx.

152  {
153  return m_store;
154  }

◆ 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; }

◆ getWritableAuxIDs()

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

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 424 of file AuxContainerBase.cxx.

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

◆ insertMove() [1/2]

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

Insert contents of another store via move.

Definition at line 510 of file AuxContainerBase.cxx.

512  {
513  // Guard against multi-threaded execution:
514  guard_t guard( m_mutex );
515 
516  // This operation is not allowed on a locked container:
517  if( m_locked ) {
518  throw SG::ExcStoreLocked( "insertMove" );
519  }
520 
521  const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
522  bool nomove = true;
523  size_t other_size = other.size();
524 
525  SG::auxid_set_t ignore = ignore_in;
526 
527  // Do the operation on the static variables:
528  for (SG::auxid_t id : m_auxids) {
529  SG::IAuxTypeVector* v_dst = nullptr;
530  if (id < m_vecs.size())
531  v_dst = m_vecs[id];
532  if (v_dst) {
533  ignore.insert (id);
534  if (other.getData (id)) {
535  void* src_ptr = other.getData (id, other_size, other_size);
536  if (src_ptr) {
537  if (!v_dst->insertMove (pos, src_ptr,
538  reinterpret_cast<char*>(src_ptr) + other_size*r.getEltSize(id),
539  other))
540  nomove = false;
541  }
542  }
543  else {
544  const void* orig = v_dst->toPtr();
545  v_dst->shift (pos, other_size);
546  if (orig != v_dst->toPtr())
547  nomove = false;
548  }
549  }
550  }
551 
552  // Do the operation on the dynamic variables:
553  if( m_store ) {
554  if (!m_store->insertMove( pos, other, ignore ))
555  nomove = false;
556 
557  // Notice any new variables added as a result of this.
558  m_auxids.insert (m_store->getAuxIDs());
559  }
560 
561  return nomove;
562  }

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

265  {
266  guard_t guard( m_mutex );
267  if (m_store) {
268  return m_store->isDecoration (auxid);
269  }
270  return false;
271  }

◆ lock()

void xAOD::AuxContainerBase::lock ( )
overridevirtualinherited

Lock the container.

Implements ILockable.

Definition at line 311 of file AuxContainerBase.cxx.

311  {
312 
313  // Guard against multi-threaded execution:
314  guard_t guard( m_mutex );
315 
316  // Lock the object and its dynamic store:
317  m_locked = true;
318  if( m_store ) {
319  m_store->lock();
320  }
321 
322  return;
323  }

◆ lockDecoration()

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

Lock a decoration.

Implements SG::IConstAuxStore.

Reimplemented in xAOD::EventInfoAuxContainer_v1.

Definition at line 355 of file AuxContainerBase.cxx.

356  {
357  guard_t guard (m_mutex);
358  if (m_store) {
359  m_store->lockDecoration (auxid);
360  }
361  }

◆ memResource()

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

Return the memory resource to use.

Definition at line 156 of file AuxContainerBase.cxx.

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

◆ name()

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

Get the name of the container instance.

Definition at line 670 of file AuxContainerBase.cxx.

670  {
671 
672  return m_name.c_str();
673  }

◆ regAuxVar() [1/2]

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

Register one of the persistent variables internally.

◆ regAuxVar() [2/2]

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

Register one of the persistent variables internally.

◆ regAuxVar1()

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

Common code between regAuxVar cases.

◆ reserve()

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

Reserve a given size for the arrays.

Implements SG::IAuxStore.

Definition at line 459 of file AuxContainerBase.cxx.

459  {
460 
461  // Guard against multi-threaded execution:
462  guard_t guard( m_mutex );
463 
464  // This operation is not allowed on a locked container:
465  if( m_locked ) {
466  throw SG::ExcStoreLocked( "reserve" );
467  }
468 
469  // Do the operation on the static variables:
470  std::vector< SG::IAuxTypeVector* >::iterator itr = m_vecs.begin();
471  std::vector< SG::IAuxTypeVector* >::iterator end = m_vecs.end();
472  for( ; itr != end; ++itr ) {
473  if( *itr ) ( *itr )->reserve( size );
474  }
475 
476  // Do the operation on the dynamic variables:
477  if( m_store ) {
478  m_store->reserve( size );
479  }
480 
481  return;
482  }

◆ resize()

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

Resize the arrays to a given size.

Implements SG::IAuxStore.

Definition at line 431 of file AuxContainerBase.cxx.

431  {
432 
433  // Guard against multi-threaded execution:
434  guard_t guard( m_mutex );
435 
436  // This operation is not allowed on a locked container:
437  if( m_locked ) {
438  throw SG::ExcStoreLocked( "resize" );
439  }
440 
441  // Do the operation on the static variables:
442  bool nomoves = true;
443  for (SG::IAuxTypeVector* v : m_vecs) {
444  if(v) {
445  if (!v->resize( size ))
446  nomoves = false;
447  }
448  }
449 
450  // Do the operation on the dynamic variables:
451  if( m_store ) {
452  if (!m_store->resize( size ))
453  nomoves = false;
454  }
455 
456  return nomoves;
457  }

◆ setName()

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

Set the name of the container instance.

Definition at line 675 of file AuxContainerBase.cxx.

675  {
676 
677  m_name = name;
678  return;
679  }

◆ setOption()

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

Make an option setting on an aux variable.

Reimplemented from SG::IAuxStore.

Definition at line 565 of file AuxContainerBase.cxx.

566  {
567 
568  guard_t guard (m_mutex);
569  if (id < m_vecs.size() && m_vecs[id] != nullptr)
570  return m_vecs[id]->setOption (option);
571 
572  if (m_store)
573  return m_store->setOption (id, option);
574  return false;
575  }

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

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

◆ shift()

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

Shift the contents of the stored arrays.

Implements SG::IAuxStore.

Definition at line 484 of file AuxContainerBase.cxx.

484  {
485 
486  // Guard against multi-threaded execution:
487  guard_t guard( m_mutex );
488 
489  // This operation is not allowed on a locked container:
490  if( m_locked ) {
491  throw SG::ExcStoreLocked( "shift" );
492  }
493 
494  // Do the operation on the static variables:
495  std::vector< SG::IAuxTypeVector* >::iterator itr = m_vecs.begin();
496  std::vector< SG::IAuxTypeVector* >::iterator end = m_vecs.end();
497  for( ; itr != end; ++itr ) {
498  if( *itr ) ( *itr )->shift( pos, offs );
499  }
500 
501  // Do the operation on the dynamic variables:
502  if( m_store ) {
503  m_store->shift( pos, offs );
504  }
505 
506  return;
507  }

◆ size()

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

Get the size of the container.

Implements SG::IConstAuxStore.

Definition at line 363 of file AuxContainerBase.cxx.

363  {
364 
365  // Guard against multi-threaded execution:
366  guard_t guard (m_mutex);
367 
368  // Try to find a variable:
369  for (SG::auxid_t i : m_auxids) {
370  if( ( i < m_vecs.size() ) && m_vecs[ i ] ) {
371  size_t sz = m_vecs[ i ]->size();
372  if( sz > 0 ) {
373  return sz;
374  }
375  }
376  }
377 
378  // If we didn't find any, let's ask the dynamic store:
379  if( m_store ) {
380  return m_store->size();
381  }
382 
383  // If we don't have any variables, then the size must be null:
384  return 0;
385  }

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

◆ m_locked

bool xAOD::AuxContainerBase::m_locked
privateinherited

Has the container been locked?

Definition at line 227 of file AuxContainerBase.h.

◆ m_mutex

mutex_t xAOD::AuxContainerBase::m_mutex
mutableprivateinherited

Definition at line 232 of file AuxContainerBase.h.

◆ m_name

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

Name of the container in memory. Set externally.

Definition at line 235 of file AuxContainerBase.h.

◆ m_ownsStore

bool xAOD::AuxContainerBase::m_ownsStore
privateinherited

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

Definition at line 225 of file AuxContainerBase.h.

◆ m_store

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

Internal dynamic auxiliary store object.

Definition at line 221 of file AuxContainerBase.h.

◆ m_storeIO

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

The IO interface to the internal auxiliary store.

Definition at line 223 of file AuxContainerBase.h.

◆ m_vecs

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

Internal list of all managed variables.

Definition at line 218 of file AuxContainerBase.h.

◆ 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 189 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::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
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:235
SG::IAuxTypeVector::shift
virtual bool shift(size_t pos, ptrdiff_t offs)=0
Shift the elements of the vector.
beamspotman.r
def r
Definition: beamspotman.py:676
store
StoreGateSvc * store
Definition: fbtTestBasics.cxx:69
beamspotPlotBcids.sz
sz
Definition: beamspotPlotBcids.py:521
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:670
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
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
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:49
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:221
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:262
xAOD::L2StandAloneMuonAuxContainer_v2::roiNumber
std::vector< uint32_t > roiNumber
Definition: L2StandAloneMuonAuxContainer_v2.h:105
xAOD::AuxContainerBase::guard_t
AthContainers_detail::lock_guard< mutex_t > guard_t
Definition: AuxContainerBase.h:231
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:509
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
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
atn_test_sgProducerConsumerDataPool_jobOptions.end
end
Definition: atn_test_sgProducerConsumerDataPool_jobOptions.py:25
xAOD::L2StandAloneMuonAuxContainer_v2::mdtHitChamberId
std::vector< std::vector< int > > mdtHitChamberId
Definition: L2StandAloneMuonAuxContainer_v2.h:217
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:232
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
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:62
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:363
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:54
SG::IAuxStore::setOption
virtual bool setOption(auxid_t, const AuxDataOption &)
Set an option for a given auxiliary variable.
Definition: IAuxStore.h:176
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:216
xAOD::AuxContainerBase::m_vecs
std::vector< SG::IAuxTypeVector * > m_vecs
Internal list of all managed variables.
Definition: AuxContainerBase.h:218
xAOD::L2StandAloneMuonAuxContainer_v2::rpcFitInnPhi
std::vector< float > rpcFitInnPhi
RPC fit results.
Definition: L2StandAloneMuonAuxContainer_v2.h:174
lumiFormat.i
int i
Definition: lumiFormat.py:92
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
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:22
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
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
python.xAODType.dummy
dummy
Definition: xAODType.py:4
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:313
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:191
python.subdetectors.mmg.ids
ids
Definition: mmg.py:8
xAOD::L2StandAloneMuonAuxContainer_v2::ptEndcapBeta
std::vector< float > ptEndcapBeta
Definition: L2StandAloneMuonAuxContainer_v2.h:115
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:424
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:227
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:18
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:157
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:238
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
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
SG::IAuxTypeVector::insertMove
virtual bool insertMove(size_t pos, void *beg, void *end, IAuxStore &srcStore)=0
Insert elements into the vector via move semantics.
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:227
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:40
xAOD::AuxContainerBase::m_ownsStore
bool m_ownsStore
Flag deciding if the object owns the dynamic store or not.
Definition: AuxContainerBase.h:225
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:223
xAOD::AuxContainerBase::AuxContainerBase
AuxContainerBase(bool allowDynamicVars=true)
Default constructor.
Definition: AuxContainerBase.cxx:28
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 Sun May 19 2024 22:32:06 for ATLAS Offline Software by   doxygen 1.8.18