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

Auxiliary container for muon SA containers. More...

#include <L2StandAloneMuonAuxContainer_v1.h>

Inheritance diagram for xAOD::L2StandAloneMuonAuxContainer_v1:
Collaboration diagram for xAOD::L2StandAloneMuonAuxContainer_v1:

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_v1 ()
 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 > slopeInner
 Slope and intercept at inner. More...
 
std::vector< float > interceptInner
 
std::vector< float > deltaR
 
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 > 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< uint32_t > roiEta
 
std::vector< uint32_t > roiPhi
 
std::vector< float > ptBarrelRadius
 pT from different algorithms More...
 
std::vector< float > ptBarrelSagitta
 
std::vector< float > ptEndcapAlpha
 
std::vector< float > ptEndcapBeta
 
std::vector< float > ptEndcapRadius
 
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 > tgcPt
 TGC fit results. More...
 
std::vector< float > tgcInnEta
 
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 > rpc1x
 RPC fit results. More...
 
std::vector< float > rpc1y
 
std::vector< float > rpc1z
 
std::vector< float > rpc2x
 
std::vector< float > rpc2y
 
std::vector< float > rpc2z
 
std::vector< float > rpc3x
 
std::vector< float > rpc3y
 
std::vector< float > rpc3z
 
std::vector< int > extensionCapacity
 Size of hit strages. More...
 
std::vector< int > robCapacity
 
std::vector< int > csmCapacity
 
std::vector< int > lvl1EmuCapacity
 
std::vector< int > rpcHitsCapacity
 
std::vector< int > tgcHitsCapacity
 
std::vector< int > mdtHitsCapacity
 
std::vector< std::vector< uint32_t > > extension0
 Extensions. More...
 
std::vector< std::vector< uint32_t > > extension1
 
std::vector< std::vector< uint32_t > > extension2
 
std::vector< std::vector< uint32_t > > extension3
 
std::vector< std::vector< uint32_t > > extension4
 
std::vector< std::vector< uint32_t > > extension5
 
std::vector< std::vector< uint32_t > > extension6
 
std::vector< std::vector< uint32_t > > extension7
 
std::vector< std::vector< uint32_t > > extension8
 
std::vector< std::vector< uint32_t > > extension9
 
std::vector< std::vector< uint32_t > > lvl1Emulation
 Level 1 emulation info. More...
 
std::vector< std::vector< uint32_t > > robId
 ROB info. More...
 
std::vector< std::vector< uint32_t > > removedRobId
 
std::vector< std::vector< uint32_t > > csmId
 CSM info. More...
 
std::vector< std::vector< uint32_t > > csmSize
 
std::vector< std::vector< uint32_t > > csmError
 
std::vector< std::vector< uint32_t > > removedCsmId
 
std::vector< std::vector< uint32_t > > padHitOnlineId
 RPC pad hits. More...
 
std::vector< std::vector< uint32_t > > padHitCode
 
std::vector< std::vector< float > > padHitX
 
std::vector< std::vector< float > > padHitY
 
std::vector< std::vector< float > > padHitZ
 
std::vector< std::vector< float > > padHitR
 
std::vector< std::vector< float > > padHitP
 
std::vector< std::vector< float > > tgcInnRhoHitPhi
 TGC hits. More...
 
std::vector< std::vector< float > > tgcInnRhoHitR
 
std::vector< std::vector< float > > tgcInnRhoHitZ
 
std::vector< std::vector< float > > tgcInnRhoHitWidth
 
std::vector< std::vector< uint32_t > > tgcInnRhoHitInSeg
 
std::vector< std::vector< float > > tgcInnPhiHitPhi
 
std::vector< std::vector< float > > tgcInnPhiHitR
 
std::vector< std::vector< float > > tgcInnPhiHitZ
 
std::vector< std::vector< float > > tgcInnPhiHitWidth
 
std::vector< std::vector< uint32_t > > tgcInnPhiHitInSeg
 
std::vector< std::vector< float > > tgcMidRhoHitPhi
 
std::vector< std::vector< float > > tgcMidRhoHitR
 
std::vector< std::vector< float > > tgcMidRhoHitZ
 
std::vector< std::vector< float > > tgcMidRhoHitWidth
 
std::vector< std::vector< uint32_t > > tgcMidRhoHitInSeg
 
std::vector< std::vector< float > > tgcMidPhiHitPhi
 
std::vector< std::vector< float > > tgcMidPhiHitR
 
std::vector< std::vector< float > > tgcMidPhiHitZ
 
std::vector< std::vector< float > > tgcMidPhiHitWidth
 
std::vector< std::vector< uint32_t > > tgcMidPhiHitInSeg
 
std::vector< std::vector< uint32_t > > mdtHitOnlineId
 MDT hits. More...
 
std::vector< std::vector< uint32_t > > mdtHitOfflineId
 
std::vector< std::vector< uint32_t > > mdtHitChamber
 
std::vector< std::vector< float > > mdtHitR
 
std::vector< std::vector< float > > mdtHitZ
 
std::vector< std::vector< float > > mdtHitResidual
 
std::vector< std::vector< float > > mdtHitTime
 
std::vector< std::vector< float > > mdtHitSpace
 
std::vector< std::vector< float > > mdtHitSigma
 

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_v1.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_v1()

xAOD::L2StandAloneMuonAuxContainer_v1::L2StandAloneMuonAuxContainer_v1 ( )

Default constructor.

Definition at line 10 of file L2StandAloneMuonAuxContainer_v1.cxx.

11  : AuxContainerBase() {
12 
13  AUX_VARIABLE( pt );
14  AUX_VARIABLE( phi );
15  AUX_VARIABLE( eta );
16 
17  AUX_VARIABLE( roiWord );
18  AUX_VARIABLE( sAddress );
19  AUX_VARIABLE( rMS );
20  AUX_VARIABLE( etaMS );
21  AUX_VARIABLE( phiMS );
22  AUX_VARIABLE( dirPhiMS );
23  AUX_VARIABLE( zMS );
24  AUX_VARIABLE( dirZMS );
25  AUX_VARIABLE( beta );
26 
27  AUX_VARIABLE( barrelRadius );
28  AUX_VARIABLE( barrelSagitta );
29 
30  AUX_VARIABLE( endcapAlpha );
31  AUX_VARIABLE( endcapBeta );
32  AUX_VARIABLE( endcapRadius );
33 
34  AUX_VARIABLE( slopeInner );
35  AUX_VARIABLE( interceptInner );
36  AUX_VARIABLE( deltaR );
37 
38  AUX_VARIABLE( etaMap );
39  AUX_VARIABLE( phiMap );
40  AUX_VARIABLE( etaBin );
41  AUX_VARIABLE( phiBin );
42 
43  AUX_VARIABLE( isTgcFailure );
44  AUX_VARIABLE( isRpcFailure );
45 
46  AUX_VARIABLE( deltaPt );
47  AUX_VARIABLE( deltaEta );
48  AUX_VARIABLE( deltaPhi );
49 
50  AUX_VARIABLE( superPointR );
51  AUX_VARIABLE( superPointZ );
52  AUX_VARIABLE( superPointSlope );
53  AUX_VARIABLE( superPointIntercept );
54  AUX_VARIABLE( superPointChi2 );
55 
56  AUX_VARIABLE( trackPositionR );
57  AUX_VARIABLE( trackPositionZ );
58  AUX_VARIABLE( trackPositionEta );
59  AUX_VARIABLE( trackPositionPhi );
60 
61  AUX_VARIABLE( algoId );
62  AUX_VARIABLE( teId );
63  AUX_VARIABLE( lvl1Id );
64  AUX_VARIABLE( lumiBlock );
65  AUX_VARIABLE( muonDetMask );
66  AUX_VARIABLE( roiId );
67  AUX_VARIABLE( roiSystem );
68  AUX_VARIABLE( roiSubsystem );
69  AUX_VARIABLE( roiSector );
70  AUX_VARIABLE( roiNumber );
71  AUX_VARIABLE( roiThreshold );
72  //AUX_VARIABLE( roiEta );
73  //AUX_VARIABLE( roiPhi );
74  static const auxid_t etaId = getAuxID( "roiEtaUint", roiEta );
75  regAuxVar( etaId, "roiEtaUint", roiEta );
76  static const auxid_t phiId = getAuxID( "roiPhiUint", roiPhi );
77  regAuxVar( phiId, "roiPhiUint", roiPhi );
78 
79  AUX_VARIABLE( ptBarrelRadius );
80  AUX_VARIABLE( ptBarrelSagitta );
81  AUX_VARIABLE( ptEndcapAlpha );
82  AUX_VARIABLE( ptEndcapBeta );
83  AUX_VARIABLE( ptEndcapRadius );
84 
85  AUX_VARIABLE( chamberType1Normal );
86  AUX_VARIABLE( chamberType1Overlap );
87  AUX_VARIABLE( chamberType2Normal );
88  AUX_VARIABLE( chamberType2Overlap );
89 
90  AUX_VARIABLE( roadAwNormal );
91  AUX_VARIABLE( roadAwOverlap );
92 
93  AUX_VARIABLE( roadBwNormal );
94  AUX_VARIABLE( roadBwOverlap );
95 
96  AUX_VARIABLE( zMinNormal );
97  AUX_VARIABLE( zMinOverlap );
98  AUX_VARIABLE( zMaxNormal );
99  AUX_VARIABLE( zMaxOverlap );
100 
101  AUX_VARIABLE( rMinNormal );
102  AUX_VARIABLE( rMinOverlap );
103  AUX_VARIABLE( rMaxNormal );
104  AUX_VARIABLE( rMaxOverlap );
105 
106  AUX_VARIABLE( etaMinNormal );
107  AUX_VARIABLE( etaMinOverlap );
108  AUX_VARIABLE( etaMaxNormal );
109  AUX_VARIABLE( etaMaxOverlap );
110 
111  AUX_VARIABLE( tgcPt );
112 
113  AUX_VARIABLE( tgcInnEta );
114  AUX_VARIABLE( tgcInnPhi );
115  AUX_VARIABLE( tgcInnR );
116  AUX_VARIABLE( tgcInnZ );
117 
118  AUX_VARIABLE( tgcInnRhoStd );
119  AUX_VARIABLE( tgcInnRhoN );
120  AUX_VARIABLE( tgcInnPhiStd );
121  AUX_VARIABLE( tgcInnPhiN );
122 
123  AUX_VARIABLE( tgcMid1Eta );
124  AUX_VARIABLE( tgcMid1Phi );
125  AUX_VARIABLE( tgcMid1R );
126  AUX_VARIABLE( tgcMid1Z );
127 
128  AUX_VARIABLE( tgcMid2Eta );
129  AUX_VARIABLE( tgcMid2Phi );
130  AUX_VARIABLE( tgcMid2R );
131  AUX_VARIABLE( tgcMid2Z );
132 
133  AUX_VARIABLE( tgcMidRhoChi2 );
134  AUX_VARIABLE( tgcMidRhoN );
135  AUX_VARIABLE( tgcMidPhiChi2 );
136  AUX_VARIABLE( tgcMidPhiN );
137 
138  AUX_VARIABLE( rpc1x );
139  AUX_VARIABLE( rpc1y );
140  AUX_VARIABLE( rpc1z );
141 
142  AUX_VARIABLE( rpc2x );
143  AUX_VARIABLE( rpc2y );
144  AUX_VARIABLE( rpc2z );
145 
146  AUX_VARIABLE( rpc3x );
147  AUX_VARIABLE( rpc3y );
148  AUX_VARIABLE( rpc3z );
149 
150  AUX_VARIABLE( extensionCapacity );
151  AUX_VARIABLE( robCapacity );
152  AUX_VARIABLE( csmCapacity );
153  AUX_VARIABLE( lvl1EmuCapacity );
154  AUX_VARIABLE( rpcHitsCapacity );
155  AUX_VARIABLE( tgcHitsCapacity );
156  AUX_VARIABLE( mdtHitsCapacity );
157 
158  AUX_VARIABLE( extension0 );
159  AUX_VARIABLE( extension1 );
160  AUX_VARIABLE( extension2 );
161  AUX_VARIABLE( extension3 );
162  AUX_VARIABLE( extension4 );
163  AUX_VARIABLE( extension5 );
164  AUX_VARIABLE( extension6 );
165  AUX_VARIABLE( extension7 );
166  AUX_VARIABLE( extension8 );
167  AUX_VARIABLE( extension9 );
168 
169  AUX_VARIABLE( lvl1Emulation );
170 
171  AUX_VARIABLE( robId );
172  AUX_VARIABLE( removedRobId );
173 
174  AUX_VARIABLE( csmId );
175  AUX_VARIABLE( csmSize );
176  AUX_VARIABLE( csmError );
177  AUX_VARIABLE( removedCsmId );
178 
179  AUX_VARIABLE( padHitOnlineId );
180  AUX_VARIABLE( padHitCode );
181  AUX_VARIABLE( padHitX );
182  AUX_VARIABLE( padHitY );
183  AUX_VARIABLE( padHitZ );
184  AUX_VARIABLE( padHitR );
185  AUX_VARIABLE( padHitP );
186 
187  AUX_VARIABLE( tgcInnRhoHitPhi );
188  AUX_VARIABLE( tgcInnRhoHitR );
189  AUX_VARIABLE( tgcInnRhoHitZ );
190  AUX_VARIABLE( tgcInnRhoHitWidth );
191  AUX_VARIABLE( tgcInnRhoHitInSeg );
192  AUX_VARIABLE( tgcInnPhiHitPhi );
193  AUX_VARIABLE( tgcInnPhiHitR );
194  AUX_VARIABLE( tgcInnPhiHitZ );
195  AUX_VARIABLE( tgcInnPhiHitWidth );
196  AUX_VARIABLE( tgcInnPhiHitInSeg );
197  AUX_VARIABLE( tgcMidRhoHitPhi );
198  AUX_VARIABLE( tgcMidRhoHitR );
199  AUX_VARIABLE( tgcMidRhoHitZ );
200  AUX_VARIABLE( tgcMidRhoHitWidth );
201  AUX_VARIABLE( tgcMidRhoHitInSeg );
202  AUX_VARIABLE( tgcMidPhiHitPhi );
203  AUX_VARIABLE( tgcMidPhiHitR );
204  AUX_VARIABLE( tgcMidPhiHitZ );
205  AUX_VARIABLE( tgcMidPhiHitWidth );
206  AUX_VARIABLE( tgcMidPhiHitInSeg );
207 
208  AUX_VARIABLE( mdtHitOnlineId );
209  AUX_VARIABLE( mdtHitOfflineId );
210  //AUX_VARIABLE( mdtHitChamber );
211  AUX_VARIABLE( mdtHitR );
212  AUX_VARIABLE( mdtHitZ );
213  AUX_VARIABLE( mdtHitResidual );
214  AUX_VARIABLE( mdtHitTime );
215  AUX_VARIABLE( mdtHitSpace );
216  AUX_VARIABLE( mdtHitSigma );
217  }

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_v1::algoId
private

Detailed information.

Definition at line 97 of file L2StandAloneMuonAuxContainer_v1.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_v1::barrelRadius
private

Input measurements to be converted to pT by LUT.

Definition at line 60 of file L2StandAloneMuonAuxContainer_v1.h.

◆ barrelSagitta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::barrelSagitta
private

Definition at line 61 of file L2StandAloneMuonAuxContainer_v1.h.

◆ beta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::beta
private

Definition at line 58 of file L2StandAloneMuonAuxContainer_v1.h.

◆ chamberType1Normal

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v1::chamberType1Normal
private

Road information Chamber type.

Definition at line 120 of file L2StandAloneMuonAuxContainer_v1.h.

◆ chamberType1Overlap

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v1::chamberType1Overlap
private

Definition at line 121 of file L2StandAloneMuonAuxContainer_v1.h.

◆ chamberType2Normal

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v1::chamberType2Normal
private

Definition at line 122 of file L2StandAloneMuonAuxContainer_v1.h.

◆ chamberType2Overlap

std::vector< std::vector< int > > xAOD::L2StandAloneMuonAuxContainer_v1::chamberType2Overlap
private

Definition at line 123 of file L2StandAloneMuonAuxContainer_v1.h.

◆ csmCapacity

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v1::csmCapacity
private

Definition at line 190 of file L2StandAloneMuonAuxContainer_v1.h.

◆ csmError

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::csmError
private

Definition at line 218 of file L2StandAloneMuonAuxContainer_v1.h.

◆ csmId

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::csmId
private

CSM info.

Definition at line 216 of file L2StandAloneMuonAuxContainer_v1.h.

◆ csmSize

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::csmSize
private

Definition at line 217 of file L2StandAloneMuonAuxContainer_v1.h.

◆ deltaEta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::deltaEta
private

Definition at line 80 of file L2StandAloneMuonAuxContainer_v1.h.

◆ deltaPhi

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::deltaPhi
private

Definition at line 81 of file L2StandAloneMuonAuxContainer_v1.h.

◆ deltaPt

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::deltaPt
private

Error of pt, eta and phi.

Definition at line 79 of file L2StandAloneMuonAuxContainer_v1.h.

◆ deltaR

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::deltaR
private

Definition at line 68 of file L2StandAloneMuonAuxContainer_v1.h.

◆ dirPhiMS

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::dirPhiMS
private

Definition at line 55 of file L2StandAloneMuonAuxContainer_v1.h.

◆ dirZMS

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::dirZMS
private

Definition at line 57 of file L2StandAloneMuonAuxContainer_v1.h.

◆ endcapAlpha

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::endcapAlpha
private

Definition at line 62 of file L2StandAloneMuonAuxContainer_v1.h.

◆ endcapBeta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::endcapBeta
private

Definition at line 63 of file L2StandAloneMuonAuxContainer_v1.h.

◆ endcapRadius

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::endcapRadius
private

Definition at line 64 of file L2StandAloneMuonAuxContainer_v1.h.

◆ eta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::eta
private

Definition at line 43 of file L2StandAloneMuonAuxContainer_v1.h.

◆ etaBin

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v1::etaBin
private

Definition at line 73 of file L2StandAloneMuonAuxContainer_v1.h.

◆ etaMap

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::etaMap
private

eta, phi as input to LUT

Definition at line 71 of file L2StandAloneMuonAuxContainer_v1.h.

◆ etaMaxNormal

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::etaMaxNormal
private

Definition at line 143 of file L2StandAloneMuonAuxContainer_v1.h.

◆ etaMaxOverlap

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::etaMaxOverlap
private

Definition at line 144 of file L2StandAloneMuonAuxContainer_v1.h.

◆ etaMinNormal

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::etaMinNormal
private

Eta.

Definition at line 141 of file L2StandAloneMuonAuxContainer_v1.h.

◆ etaMinOverlap

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::etaMinOverlap
private

Definition at line 142 of file L2StandAloneMuonAuxContainer_v1.h.

◆ etaMS

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::etaMS
private

Definition at line 53 of file L2StandAloneMuonAuxContainer_v1.h.

◆ extension0

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::extension0
private

Extensions.

Definition at line 197 of file L2StandAloneMuonAuxContainer_v1.h.

◆ extension1

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::extension1
private

Definition at line 198 of file L2StandAloneMuonAuxContainer_v1.h.

◆ extension2

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::extension2
private

Definition at line 199 of file L2StandAloneMuonAuxContainer_v1.h.

◆ extension3

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::extension3
private

Definition at line 200 of file L2StandAloneMuonAuxContainer_v1.h.

◆ extension4

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::extension4
private

Definition at line 201 of file L2StandAloneMuonAuxContainer_v1.h.

◆ extension5

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::extension5
private

Definition at line 202 of file L2StandAloneMuonAuxContainer_v1.h.

◆ extension6

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::extension6
private

Definition at line 203 of file L2StandAloneMuonAuxContainer_v1.h.

◆ extension7

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::extension7
private

Definition at line 204 of file L2StandAloneMuonAuxContainer_v1.h.

◆ extension8

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::extension8
private

Definition at line 205 of file L2StandAloneMuonAuxContainer_v1.h.

◆ extension9

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::extension9
private

Definition at line 206 of file L2StandAloneMuonAuxContainer_v1.h.

◆ extensionCapacity

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v1::extensionCapacity
private

Size of hit strages.

Definition at line 188 of file L2StandAloneMuonAuxContainer_v1.h.

◆ interceptInner

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::interceptInner
private

Definition at line 67 of file L2StandAloneMuonAuxContainer_v1.h.

◆ isRpcFailure

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v1::isRpcFailure
private

Definition at line 77 of file L2StandAloneMuonAuxContainer_v1.h.

◆ isTgcFailure

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v1::isTgcFailure
private

Flag for RGC and RPC availabilities.

Definition at line 76 of file L2StandAloneMuonAuxContainer_v1.h.

◆ lumiBlock

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v1::lumiBlock
private

Definition at line 100 of file L2StandAloneMuonAuxContainer_v1.h.

◆ lvl1EmuCapacity

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v1::lvl1EmuCapacity
private

Definition at line 191 of file L2StandAloneMuonAuxContainer_v1.h.

◆ lvl1Emulation

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::lvl1Emulation
private

Level 1 emulation info.

Definition at line 209 of file L2StandAloneMuonAuxContainer_v1.h.

◆ lvl1Id

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v1::lvl1Id
private

Definition at line 99 of file L2StandAloneMuonAuxContainer_v1.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.

◆ mdtHitChamber

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitChamber
private

Definition at line 255 of file L2StandAloneMuonAuxContainer_v1.h.

◆ mdtHitOfflineId

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitOfflineId
private

Definition at line 254 of file L2StandAloneMuonAuxContainer_v1.h.

◆ mdtHitOnlineId

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitOnlineId
private

MDT hits.

Definition at line 253 of file L2StandAloneMuonAuxContainer_v1.h.

◆ mdtHitR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitR
private

Definition at line 256 of file L2StandAloneMuonAuxContainer_v1.h.

◆ mdtHitResidual

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitResidual
private

Definition at line 258 of file L2StandAloneMuonAuxContainer_v1.h.

◆ mdtHitsCapacity

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitsCapacity
private

Definition at line 194 of file L2StandAloneMuonAuxContainer_v1.h.

◆ mdtHitSigma

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitSigma
private

Definition at line 261 of file L2StandAloneMuonAuxContainer_v1.h.

◆ mdtHitSpace

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitSpace
private

Definition at line 260 of file L2StandAloneMuonAuxContainer_v1.h.

◆ mdtHitTime

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitTime
private

Definition at line 259 of file L2StandAloneMuonAuxContainer_v1.h.

◆ mdtHitZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitZ
private

Definition at line 257 of file L2StandAloneMuonAuxContainer_v1.h.

◆ muonDetMask

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v1::muonDetMask
private

Definition at line 101 of file L2StandAloneMuonAuxContainer_v1.h.

◆ padHitCode

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::padHitCode
private

Definition at line 223 of file L2StandAloneMuonAuxContainer_v1.h.

◆ padHitOnlineId

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::padHitOnlineId
private

RPC pad hits.

Definition at line 222 of file L2StandAloneMuonAuxContainer_v1.h.

◆ padHitP

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::padHitP
private

Definition at line 228 of file L2StandAloneMuonAuxContainer_v1.h.

◆ padHitR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::padHitR
private

Definition at line 227 of file L2StandAloneMuonAuxContainer_v1.h.

◆ padHitX

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::padHitX
private

Definition at line 224 of file L2StandAloneMuonAuxContainer_v1.h.

◆ padHitY

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::padHitY
private

Definition at line 225 of file L2StandAloneMuonAuxContainer_v1.h.

◆ padHitZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::padHitZ
private

Definition at line 226 of file L2StandAloneMuonAuxContainer_v1.h.

◆ phi

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::phi
private

Definition at line 42 of file L2StandAloneMuonAuxContainer_v1.h.

◆ phiBin

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v1::phiBin
private

Definition at line 74 of file L2StandAloneMuonAuxContainer_v1.h.

◆ phiMap

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::phiMap
private

Definition at line 72 of file L2StandAloneMuonAuxContainer_v1.h.

◆ phiMS

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::phiMS
private

Definition at line 54 of file L2StandAloneMuonAuxContainer_v1.h.

◆ pt

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::pt
private

Definition at line 41 of file L2StandAloneMuonAuxContainer_v1.h.

◆ ptBarrelRadius

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::ptBarrelRadius
private

pT from different algorithms

Definition at line 112 of file L2StandAloneMuonAuxContainer_v1.h.

◆ ptBarrelSagitta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::ptBarrelSagitta
private

Definition at line 113 of file L2StandAloneMuonAuxContainer_v1.h.

◆ ptEndcapAlpha

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::ptEndcapAlpha
private

Definition at line 114 of file L2StandAloneMuonAuxContainer_v1.h.

◆ ptEndcapBeta

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::ptEndcapBeta
private

Definition at line 115 of file L2StandAloneMuonAuxContainer_v1.h.

◆ ptEndcapRadius

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::ptEndcapRadius
private

Definition at line 116 of file L2StandAloneMuonAuxContainer_v1.h.

◆ removedCsmId

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::removedCsmId
private

Definition at line 219 of file L2StandAloneMuonAuxContainer_v1.h.

◆ removedRobId

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::removedRobId
private

Definition at line 213 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rMaxNormal

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::rMaxNormal
private

Definition at line 138 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rMaxOverlap

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::rMaxOverlap
private

Definition at line 139 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rMinNormal

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::rMinNormal
private

R.

Definition at line 136 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rMinOverlap

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::rMinOverlap
private

Definition at line 137 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rMS

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::rMS
private

Position at MS.

Definition at line 52 of file L2StandAloneMuonAuxContainer_v1.h.

◆ roadAwNormal

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::roadAwNormal
private

Slope.

Definition at line 125 of file L2StandAloneMuonAuxContainer_v1.h.

◆ roadAwOverlap

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::roadAwOverlap
private

Definition at line 126 of file L2StandAloneMuonAuxContainer_v1.h.

◆ roadBwNormal

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::roadBwNormal
private

Intercept.

Definition at line 128 of file L2StandAloneMuonAuxContainer_v1.h.

◆ roadBwOverlap

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::roadBwOverlap
private

Definition at line 129 of file L2StandAloneMuonAuxContainer_v1.h.

◆ robCapacity

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v1::robCapacity
private

Definition at line 189 of file L2StandAloneMuonAuxContainer_v1.h.

◆ robId

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::robId
private

ROB info.

Definition at line 212 of file L2StandAloneMuonAuxContainer_v1.h.

◆ roiEta

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v1::roiEta
private

Definition at line 108 of file L2StandAloneMuonAuxContainer_v1.h.

◆ roiId

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v1::roiId
private

Definition at line 102 of file L2StandAloneMuonAuxContainer_v1.h.

◆ roiNumber

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v1::roiNumber
private

Definition at line 106 of file L2StandAloneMuonAuxContainer_v1.h.

◆ roiPhi

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v1::roiPhi
private

Definition at line 109 of file L2StandAloneMuonAuxContainer_v1.h.

◆ roiSector

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v1::roiSector
private

Definition at line 105 of file L2StandAloneMuonAuxContainer_v1.h.

◆ roiSubsystem

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v1::roiSubsystem
private

Definition at line 104 of file L2StandAloneMuonAuxContainer_v1.h.

◆ roiSystem

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v1::roiSystem
private

Definition at line 103 of file L2StandAloneMuonAuxContainer_v1.h.

◆ roiThreshold

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v1::roiThreshold
private

Definition at line 107 of file L2StandAloneMuonAuxContainer_v1.h.

◆ roiWord

std::vector< uint32_t > xAOD::L2StandAloneMuonAuxContainer_v1::roiWord
private

Definition at line 49 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rpc1x

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::rpc1x
private

RPC fit results.

Definition at line 175 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rpc1y

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::rpc1y
private

Definition at line 176 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rpc1z

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::rpc1z
private

Definition at line 177 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rpc2x

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::rpc2x
private

Definition at line 179 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rpc2y

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::rpc2y
private

Definition at line 180 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rpc2z

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::rpc2z
private

Definition at line 181 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rpc3x

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::rpc3x
private

Definition at line 183 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rpc3y

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::rpc3y
private

Definition at line 184 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rpc3z

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::rpc3z
private

Definition at line 185 of file L2StandAloneMuonAuxContainer_v1.h.

◆ rpcHitsCapacity

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v1::rpcHitsCapacity
private

Definition at line 192 of file L2StandAloneMuonAuxContainer_v1.h.

◆ sAddress

std::vector< int > xAOD::L2StandAloneMuonAuxContainer_v1::sAddress
private

Definition at line 50 of file L2StandAloneMuonAuxContainer_v1.h.

◆ slopeInner

std::vector< float > xAOD::L2StandAloneMuonAuxContainer_v1::slopeInner
private

Slope and intercept at inner.

Definition at line 66 of file L2StandAloneMuonAuxContainer_v1.h.

◆ superPointChi2

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::superPointChi2
private

Definition at line 88 of file L2StandAloneMuonAuxContainer_v1.h.

◆ superPointIntercept

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::superPointIntercept
private

Definition at line 87 of file L2StandAloneMuonAuxContainer_v1.h.

◆ superPointR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::superPointR
private

Station fit results (superpoints)

Definition at line 84 of file L2StandAloneMuonAuxContainer_v1.h.

◆ superPointSlope

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::superPointSlope
private

Definition at line 86 of file L2StandAloneMuonAuxContainer_v1.h.

◆ superPointZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::superPointZ
private

Definition at line 85 of file L2StandAloneMuonAuxContainer_v1.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_v1::teId
private

Definition at line 98 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcHitsCapacity

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

Definition at line 193 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnEta

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

Definition at line 149 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnPhi

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

Definition at line 150 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnPhiHitInSeg

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnPhiHitInSeg
private

Definition at line 240 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnPhiHitPhi

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnPhiHitPhi
private

Definition at line 236 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnPhiHitR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnPhiHitR
private

Definition at line 237 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnPhiHitWidth

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnPhiHitWidth
private

Definition at line 239 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnPhiHitZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnPhiHitZ
private

Definition at line 238 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnPhiN

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

Definition at line 167 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnPhiStd

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

Definition at line 166 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnR

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

Definition at line 151 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnRhoHitInSeg

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnRhoHitInSeg
private

Definition at line 235 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnRhoHitPhi

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnRhoHitPhi
private

TGC hits.

Definition at line 231 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnRhoHitR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnRhoHitR
private

Definition at line 232 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnRhoHitWidth

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnRhoHitWidth
private

Definition at line 234 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnRhoHitZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnRhoHitZ
private

Definition at line 233 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnRhoN

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

Definition at line 165 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnRhoStd

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

Definition at line 164 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcInnZ

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

Definition at line 152 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMid1Eta

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

Definition at line 154 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMid1Phi

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

Definition at line 155 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMid1R

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

Definition at line 156 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMid1Z

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

Definition at line 157 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMid2Eta

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

Definition at line 159 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMid2Phi

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

Definition at line 160 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMid2R

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

Definition at line 161 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMid2Z

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

Definition at line 162 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMidPhiChi2

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

Definition at line 171 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMidPhiHitInSeg

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidPhiHitInSeg
private

Definition at line 250 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMidPhiHitPhi

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidPhiHitPhi
private

Definition at line 246 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMidPhiHitR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidPhiHitR
private

Definition at line 247 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMidPhiHitWidth

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidPhiHitWidth
private

Definition at line 249 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMidPhiHitZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidPhiHitZ
private

Definition at line 248 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMidPhiN

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

Definition at line 172 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMidRhoChi2

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

Definition at line 169 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMidRhoHitInSeg

std::vector< std::vector< uint32_t > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidRhoHitInSeg
private

Definition at line 245 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMidRhoHitPhi

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidRhoHitPhi
private

Definition at line 241 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMidRhoHitR

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidRhoHitR
private

Definition at line 242 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMidRhoHitWidth

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidRhoHitWidth
private

Definition at line 244 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMidRhoHitZ

std::vector< std::vector< float > > xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidRhoHitZ
private

Definition at line 243 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcMidRhoN

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

Definition at line 170 of file L2StandAloneMuonAuxContainer_v1.h.

◆ tgcPt

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

TGC fit results.

Definition at line 147 of file L2StandAloneMuonAuxContainer_v1.h.

◆ trackPositionEta

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

Definition at line 93 of file L2StandAloneMuonAuxContainer_v1.h.

◆ trackPositionPhi

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

Definition at line 94 of file L2StandAloneMuonAuxContainer_v1.h.

◆ trackPositionR

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

Track positions.

Definition at line 91 of file L2StandAloneMuonAuxContainer_v1.h.

◆ trackPositionZ

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

Definition at line 92 of file L2StandAloneMuonAuxContainer_v1.h.

◆ zMaxNormal

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

Definition at line 133 of file L2StandAloneMuonAuxContainer_v1.h.

◆ zMaxOverlap

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

Definition at line 134 of file L2StandAloneMuonAuxContainer_v1.h.

◆ zMinNormal

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

Z.

Definition at line 131 of file L2StandAloneMuonAuxContainer_v1.h.

◆ zMinOverlap

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

Definition at line 132 of file L2StandAloneMuonAuxContainer_v1.h.

◆ zMS

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

Definition at line 56 of file L2StandAloneMuonAuxContainer_v1.h.

The documentation for this class was generated from the following files:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMid1Eta
std::vector< float > tgcMid1Eta
Definition: L2StandAloneMuonAuxContainer_v1.h:154
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidRhoHitWidth
std::vector< std::vector< float > > tgcMidRhoHitWidth
Definition: L2StandAloneMuonAuxContainer_v1.h:244
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.
xAOD::L2StandAloneMuonAuxContainer_v1::chamberType2Normal
std::vector< std::vector< int > > chamberType2Normal
Definition: L2StandAloneMuonAuxContainer_v1.h:122
xAOD::L2StandAloneMuonAuxContainer_v1::removedCsmId
std::vector< std::vector< uint32_t > > removedCsmId
Definition: L2StandAloneMuonAuxContainer_v1.h:219
beamspotman.r
def r
Definition: beamspotman.py:676
store
StoreGateSvc * store
Definition: fbtTestBasics.cxx:69
xAOD::L2StandAloneMuonAuxContainer_v1::superPointIntercept
std::vector< std::vector< float > > superPointIntercept
Definition: L2StandAloneMuonAuxContainer_v1.h:87
beamspotPlotBcids.sz
sz
Definition: beamspotPlotBcids.py:521
xAOD::L2StandAloneMuonAuxContainer_v1::roadAwOverlap
std::vector< std::vector< float > > roadAwOverlap
Definition: L2StandAloneMuonAuxContainer_v1.h:126
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidPhiHitInSeg
std::vector< std::vector< uint32_t > > tgcMidPhiHitInSeg
Definition: L2StandAloneMuonAuxContainer_v1.h:250
xAOD::L2StandAloneMuonAuxContainer_v1::chamberType2Overlap
std::vector< std::vector< int > > chamberType2Overlap
Definition: L2StandAloneMuonAuxContainer_v1.h:123
xAOD::AuxContainerBase::name
const char * name() const
Get the name of the container instance.
Definition: AuxContainerBase.cxx:670
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_v1::mdtHitR
std::vector< std::vector< float > > mdtHitR
Definition: L2StandAloneMuonAuxContainer_v1.h:256
xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitSpace
std::vector< std::vector< float > > mdtHitSpace
Definition: L2StandAloneMuonAuxContainer_v1.h:260
SG::IConstAuxStore::lockDecoration
virtual void lockDecoration(SG::auxid_t auxid)=0
Lock a decoration.
xAOD::L2StandAloneMuonAuxContainer_v1::trackPositionZ
std::vector< std::vector< float > > trackPositionZ
Definition: L2StandAloneMuonAuxContainer_v1.h:92
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnRhoHitR
std::vector< std::vector< float > > tgcInnRhoHitR
Definition: L2StandAloneMuonAuxContainer_v1.h:232
get_generator_info.result
result
Definition: get_generator_info.py:21
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnPhiHitInSeg
std::vector< std::vector< uint32_t > > tgcInnPhiHitInSeg
Definition: L2StandAloneMuonAuxContainer_v1.h:240
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidRhoHitPhi
std::vector< std::vector< float > > tgcMidRhoHitPhi
Definition: L2StandAloneMuonAuxContainer_v1.h:241
xAOD::L2StandAloneMuonAuxContainer_v1::trackPositionPhi
std::vector< std::vector< float > > trackPositionPhi
Definition: L2StandAloneMuonAuxContainer_v1.h:94
xAOD::L2StandAloneMuonAuxContainer_v1::endcapAlpha
std::vector< float > endcapAlpha
Definition: L2StandAloneMuonAuxContainer_v1.h:62
xAOD::L2StandAloneMuonAuxContainer_v1::extension4
std::vector< std::vector< uint32_t > > extension4
Definition: L2StandAloneMuonAuxContainer_v1.h:201
xAOD::IOStats::stats
ReadStats & stats()
Access the object belonging to the current thread.
Definition: IOStats.cxx:17
xAOD::L2StandAloneMuonAuxContainer_v1::lvl1EmuCapacity
std::vector< int > lvl1EmuCapacity
Definition: L2StandAloneMuonAuxContainer_v1.h:191
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnPhiHitWidth
std::vector< std::vector< float > > tgcInnPhiHitWidth
Definition: L2StandAloneMuonAuxContainer_v1.h:239
xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitOfflineId
std::vector< std::vector< uint32_t > > mdtHitOfflineId
Definition: L2StandAloneMuonAuxContainer_v1.h:254
xAOD::L2StandAloneMuonAuxContainer_v1::roiWord
std::vector< uint32_t > roiWord
Definition: L2StandAloneMuonAuxContainer_v1.h:49
SG::AuxTypeRegistry::instance
static AuxTypeRegistry & instance()
Return the singleton registry instance.
Definition: AuxTypeRegistry.cxx:49
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidRhoN
std::vector< long > tgcMidRhoN
Definition: L2StandAloneMuonAuxContainer_v1.h:170
xAOD::L2StandAloneMuonAuxContainer_v1::ptBarrelSagitta
std::vector< float > ptBarrelSagitta
Definition: L2StandAloneMuonAuxContainer_v1.h:113
xAOD::L2StandAloneMuonAuxContainer_v1::endcapBeta
std::vector< float > endcapBeta
Definition: L2StandAloneMuonAuxContainer_v1.h:63
xAOD::L2StandAloneMuonAuxContainer_v1::dirZMS
std::vector< float > dirZMS
Definition: L2StandAloneMuonAuxContainer_v1.h:57
xAOD::AuxContainerBase::m_store
SG::IAuxStore * m_store
Internal dynamic auxiliary store object.
Definition: AuxContainerBase.h:221
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidPhiHitR
std::vector< std::vector< float > > tgcMidPhiHitR
Definition: L2StandAloneMuonAuxContainer_v1.h:247
xAOD::L2StandAloneMuonAuxContainer_v1::padHitZ
std::vector< std::vector< float > > padHitZ
Definition: L2StandAloneMuonAuxContainer_v1.h:226
xAOD::L2StandAloneMuonAuxContainer_v1::interceptInner
std::vector< float > interceptInner
Definition: L2StandAloneMuonAuxContainer_v1.h:67
xAOD::L2StandAloneMuonAuxContainer_v1::extension7
std::vector< std::vector< uint32_t > > extension7
Definition: L2StandAloneMuonAuxContainer_v1.h:204
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_v1::roadAwNormal
std::vector< std::vector< float > > roadAwNormal
Slope.
Definition: L2StandAloneMuonAuxContainer_v1.h:125
xAOD::AuxContainerBase::guard_t
AthContainers_detail::lock_guard< mutex_t > guard_t
Definition: AuxContainerBase.h:231
SG::ExcStoreLocked
Exception — Attempted to modify auxiliary data in a locked store.
Definition: Control/AthContainers/AthContainers/exceptions.h:183
xAOD::L2StandAloneMuonAuxContainer_v1::rpc1y
std::vector< float > rpc1y
Definition: L2StandAloneMuonAuxContainer_v1.h:176
Atlas::hasExtendedEventContext
bool hasExtendedEventContext(const EventContext &ctx)
Test whether a context object has an extended context installed.
Definition: ExtendedEventContext.cxx:23
xAOD::L2StandAloneMuonAuxContainer_v1::isTgcFailure
std::vector< int > isTgcFailure
Flag for RGC and RPC availabilities.
Definition: L2StandAloneMuonAuxContainer_v1.h:76
xAOD::L2StandAloneMuonAuxContainer_v1::roiSubsystem
std::vector< uint32_t > roiSubsystem
Definition: L2StandAloneMuonAuxContainer_v1.h:104
xAOD::L2StandAloneMuonAuxContainer_v1::superPointChi2
std::vector< std::vector< float > > superPointChi2
Definition: L2StandAloneMuonAuxContainer_v1.h:88
xAOD::L2StandAloneMuonAuxContainer_v1::phiBin
std::vector< int > phiBin
Definition: L2StandAloneMuonAuxContainer_v1.h:74
xAOD::L2StandAloneMuonAuxContainer_v1::rpc1x
std::vector< float > rpc1x
RPC fit results.
Definition: L2StandAloneMuonAuxContainer_v1.h:175
xAOD::L2StandAloneMuonAuxContainer_v1::superPointZ
std::vector< std::vector< float > > superPointZ
Definition: L2StandAloneMuonAuxContainer_v1.h:85
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnZ
std::vector< float > tgcInnZ
Definition: L2StandAloneMuonAuxContainer_v1.h:152
xAOD::L2StandAloneMuonAuxContainer_v1::rpc2z
std::vector< float > rpc2z
Definition: L2StandAloneMuonAuxContainer_v1.h:181
xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitOnlineId
std::vector< std::vector< uint32_t > > mdtHitOnlineId
MDT hits.
Definition: L2StandAloneMuonAuxContainer_v1.h:253
xAOD::other
@ other
Definition: TrackingPrimitives.h:509
xAOD::L2StandAloneMuonAuxContainer_v1::rMS
std::vector< float > rMS
Position at MS.
Definition: L2StandAloneMuonAuxContainer_v1.h:52
xAOD::L2StandAloneMuonAuxContainer_v1::beta
std::vector< float > beta
Definition: L2StandAloneMuonAuxContainer_v1.h:58
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnRhoHitPhi
std::vector< std::vector< float > > tgcInnRhoHitPhi
TGC hits.
Definition: L2StandAloneMuonAuxContainer_v1.h:231
xAOD::L2StandAloneMuonAuxContainer_v1::rMaxOverlap
std::vector< std::vector< float > > rMaxOverlap
Definition: L2StandAloneMuonAuxContainer_v1.h:139
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnPhiHitPhi
std::vector< std::vector< float > > tgcInnPhiHitPhi
Definition: L2StandAloneMuonAuxContainer_v1.h:236
atn_test_sgProducerConsumerDataPool_jobOptions.end
end
Definition: atn_test_sgProducerConsumerDataPool_jobOptions.py:25
xAOD::L2StandAloneMuonAuxContainer_v1::roiEta
std::vector< uint32_t > roiEta
Definition: L2StandAloneMuonAuxContainer_v1.h:108
xAOD::L2StandAloneMuonAuxContainer_v1::roiSystem
std::vector< uint32_t > roiSystem
Definition: L2StandAloneMuonAuxContainer_v1.h:103
xAOD::L2StandAloneMuonAuxContainer_v1::deltaR
std::vector< float > deltaR
Definition: L2StandAloneMuonAuxContainer_v1.h:68
xAOD::L2StandAloneMuonAuxContainer_v1::sAddress
std::vector< int > sAddress
Definition: L2StandAloneMuonAuxContainer_v1.h:50
xAOD::L2StandAloneMuonAuxContainer_v1::rpc2y
std::vector< float > rpc2y
Definition: L2StandAloneMuonAuxContainer_v1.h:180
xAOD::L2StandAloneMuonAuxContainer_v1::trackPositionEta
std::vector< std::vector< float > > trackPositionEta
Definition: L2StandAloneMuonAuxContainer_v1.h:93
xAOD::L2StandAloneMuonAuxContainer_v1::deltaPt
std::vector< float > deltaPt
Error of pt, eta and phi.
Definition: L2StandAloneMuonAuxContainer_v1.h:79
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::L2StandAloneMuonAuxContainer_v1::roiThreshold
std::vector< uint32_t > roiThreshold
Definition: L2StandAloneMuonAuxContainer_v1.h:107
xAOD::AuxContainerBase::m_mutex
mutex_t m_mutex
Definition: AuxContainerBase.h:232
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnPhiN
std::vector< long > tgcInnPhiN
Definition: L2StandAloneMuonAuxContainer_v1.h:167
xAOD::L2StandAloneMuonAuxContainer_v1::dirPhiMS
std::vector< float > dirPhiMS
Definition: L2StandAloneMuonAuxContainer_v1.h:55
xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitTime
std::vector< std::vector< float > > mdtHitTime
Definition: L2StandAloneMuonAuxContainer_v1.h:259
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_v1::csmSize
std::vector< std::vector< uint32_t > > csmSize
Definition: L2StandAloneMuonAuxContainer_v1.h:217
xAOD::L2StandAloneMuonAuxContainer_v1::rpc2x
std::vector< float > rpc2x
Definition: L2StandAloneMuonAuxContainer_v1.h:179
xAOD::L2StandAloneMuonAuxContainer_v1::etaMinOverlap
std::vector< std::vector< float > > etaMinOverlap
Definition: L2StandAloneMuonAuxContainer_v1.h:142
xAOD::L2StandAloneMuonAuxContainer_v1::robCapacity
std::vector< int > robCapacity
Definition: L2StandAloneMuonAuxContainer_v1.h:189
SG::IAuxStoreIO
Interface providing I/O for a generic auxiliary store.
Definition: IAuxStoreIO.h:44
xAOD::L2StandAloneMuonAuxContainer_v1::isRpcFailure
std::vector< int > isRpcFailure
Definition: L2StandAloneMuonAuxContainer_v1.h:77
xAOD::L2StandAloneMuonAuxContainer_v1::zMaxOverlap
std::vector< std::vector< float > > zMaxOverlap
Definition: L2StandAloneMuonAuxContainer_v1.h:134
xAOD::L2StandAloneMuonAuxContainer_v1::padHitY
std::vector< std::vector< float > > padHitY
Definition: L2StandAloneMuonAuxContainer_v1.h:225
SG::AuxTypeRegistry
Handle mappings between names and auxid_t.
Definition: AuxTypeRegistry.h:62
xAOD::L2StandAloneMuonAuxContainer_v1::ptEndcapBeta
std::vector< float > ptEndcapBeta
Definition: L2StandAloneMuonAuxContainer_v1.h:115
Atlas::getExtendedEventContext
const ExtendedEventContext & getExtendedEventContext(const EventContext &ctx)
Retrieve an extended context from a context object.
Definition: ExtendedEventContext.cxx:32
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidPhiHitPhi
std::vector< std::vector< float > > tgcMidPhiHitPhi
Definition: L2StandAloneMuonAuxContainer_v1.h:246
xAOD::L2StandAloneMuonAuxContainer_v1::superPointSlope
std::vector< std::vector< float > > superPointSlope
Definition: L2StandAloneMuonAuxContainer_v1.h:86
xAOD::AuxContainerBase::size
virtual size_t size() const override
Get the size of the container.
Definition: AuxContainerBase.cxx:363
xAOD::L2StandAloneMuonAuxContainer_v1::lvl1Emulation
std::vector< std::vector< uint32_t > > lvl1Emulation
Level 1 emulation info.
Definition: L2StandAloneMuonAuxContainer_v1.h:209
xAOD::L2StandAloneMuonAuxContainer_v1::padHitP
std::vector< std::vector< float > > padHitP
Definition: L2StandAloneMuonAuxContainer_v1.h:228
DiTauMassTools::ignore
void ignore(T &&)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:54
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMid2R
std::vector< float > tgcMid2R
Definition: L2StandAloneMuonAuxContainer_v1.h:161
xAOD::L2StandAloneMuonAuxContainer_v1::csmCapacity
std::vector< int > csmCapacity
Definition: L2StandAloneMuonAuxContainer_v1.h:190
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_v1::tgcInnEta
std::vector< float > tgcInnEta
Definition: L2StandAloneMuonAuxContainer_v1.h:149
xAOD::L2StandAloneMuonAuxContainer_v1::padHitX
std::vector< std::vector< float > > padHitX
Definition: L2StandAloneMuonAuxContainer_v1.h:224
SG::IConstAuxStore::clearDecorations
virtual bool clearDecorations()=0
Clear all decorations.
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnRhoN
std::vector< long > tgcInnRhoN
Definition: L2StandAloneMuonAuxContainer_v1.h:165
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidRhoHitZ
std::vector< std::vector< float > > tgcMidRhoHitZ
Definition: L2StandAloneMuonAuxContainer_v1.h:243
xAOD::L2StandAloneMuonAuxContainer_v1::eta
std::vector< float > eta
Definition: L2StandAloneMuonAuxContainer_v1.h:43
xAOD::L2StandAloneMuonAuxContainer_v1::lumiBlock
std::vector< uint32_t > lumiBlock
Definition: L2StandAloneMuonAuxContainer_v1.h:100
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::L2StandAloneMuonAuxContainer_v1::tgcInnPhiStd
std::vector< float > tgcInnPhiStd
Definition: L2StandAloneMuonAuxContainer_v1.h:166
xAOD::L2StandAloneMuonAuxContainer_v1::etaMaxNormal
std::vector< std::vector< float > > etaMaxNormal
Definition: L2StandAloneMuonAuxContainer_v1.h:143
xAOD::AuxContainerBase::m_vecs
std::vector< SG::IAuxTypeVector * > m_vecs
Internal list of all managed variables.
Definition: AuxContainerBase.h:218
xAOD::AuxContainerBase::regAuxVar
void regAuxVar(auxid_t auxid, const std::string &name, std::vector< T, ALLOC > &vec)
Register one of the persistent variables internally.
lumiFormat.i
int i
Definition: lumiFormat.py:92
xAOD::L2StandAloneMuonAuxContainer_v1::rMinOverlap
std::vector< std::vector< float > > rMinOverlap
Definition: L2StandAloneMuonAuxContainer_v1.h:137
CxxUtils::ConcurrentBitset::insert
ConcurrentBitset & insert(bit_t bit, bit_t new_nbits=0)
Set a bit to 1.
xAOD::L2StandAloneMuonAuxContainer_v1::etaMinNormal
std::vector< std::vector< float > > etaMinNormal
Eta.
Definition: L2StandAloneMuonAuxContainer_v1.h:141
xAOD::L2StandAloneMuonAuxContainer_v1::extension8
std::vector< std::vector< uint32_t > > extension8
Definition: L2StandAloneMuonAuxContainer_v1.h:205
AUX_VARIABLE
#define AUX_VARIABLE(VAR,...)
Convenience macro for declaring an auxiliary variable.
Definition: AuxVariable.h:22
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnRhoStd
std::vector< float > tgcInnRhoStd
Definition: L2StandAloneMuonAuxContainer_v1.h:164
xAOD::L2StandAloneMuonAuxContainer_v1::extension1
std::vector< std::vector< uint32_t > > extension1
Definition: L2StandAloneMuonAuxContainer_v1.h:198
xAOD::L2StandAloneMuonAuxContainer_v1::chamberType1Normal
std::vector< std::vector< int > > chamberType1Normal
Road information Chamber type.
Definition: L2StandAloneMuonAuxContainer_v1.h:120
xAOD::L2StandAloneMuonAuxContainer_v1::etaMap
std::vector< float > etaMap
eta, phi as input to LUT
Definition: L2StandAloneMuonAuxContainer_v1.h:71
xAOD::L2StandAloneMuonAuxContainer_v1::pt
std::vector< float > pt
Definition: L2StandAloneMuonAuxContainer_v1.h:41
xAOD::L2StandAloneMuonAuxContainer_v1::csmId
std::vector< std::vector< uint32_t > > csmId
CSM info.
Definition: L2StandAloneMuonAuxContainer_v1.h:216
xAOD::L2StandAloneMuonAuxContainer_v1::rpc3z
std::vector< float > rpc3z
Definition: L2StandAloneMuonAuxContainer_v1.h:185
python.xAODType.dummy
dummy
Definition: xAODType.py:4
xAOD::L2StandAloneMuonAuxContainer_v1::etaMaxOverlap
std::vector< std::vector< float > > etaMaxOverlap
Definition: L2StandAloneMuonAuxContainer_v1.h:144
xAOD::L2StandAloneMuonAuxContainer_v1::lvl1Id
std::vector< uint32_t > lvl1Id
Definition: L2StandAloneMuonAuxContainer_v1.h:99
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidRhoChi2
std::vector< float > tgcMidRhoChi2
Definition: L2StandAloneMuonAuxContainer_v1.h:169
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.
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_v1::tgcMidPhiN
std::vector< long > tgcMidPhiN
Definition: L2StandAloneMuonAuxContainer_v1.h:172
xAOD::L2StandAloneMuonAuxContainer_v1::extension6
std::vector< std::vector< uint32_t > > extension6
Definition: L2StandAloneMuonAuxContainer_v1.h:203
xAOD::L2StandAloneMuonAuxContainer_v1::zMS
std::vector< float > zMS
Definition: L2StandAloneMuonAuxContainer_v1.h:56
xAOD::L2StandAloneMuonAuxContainer_v1::roiNumber
std::vector< uint32_t > roiNumber
Definition: L2StandAloneMuonAuxContainer_v1.h:106
xAOD::IOStats::instance
static IOStats & instance()
Singleton object accessor.
Definition: IOStats.cxx:11
xAOD::L2StandAloneMuonAuxContainer_v1::csmError
std::vector< std::vector< uint32_t > > csmError
Definition: L2StandAloneMuonAuxContainer_v1.h:218
xAOD::L2StandAloneMuonAuxContainer_v1::muonDetMask
std::vector< uint32_t > muonDetMask
Definition: L2StandAloneMuonAuxContainer_v1.h:101
xAOD::L2StandAloneMuonAuxContainer_v1::rpc3x
std::vector< float > rpc3x
Definition: L2StandAloneMuonAuxContainer_v1.h:183
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidPhiChi2
std::vector< float > tgcMidPhiChi2
Definition: L2StandAloneMuonAuxContainer_v1.h:171
xAOD::L2StandAloneMuonAuxContainer_v1::robId
std::vector< std::vector< uint32_t > > robId
ROB info.
Definition: L2StandAloneMuonAuxContainer_v1.h:212
xAOD::L2StandAloneMuonAuxContainer_v1::barrelSagitta
std::vector< float > barrelSagitta
Definition: L2StandAloneMuonAuxContainer_v1.h:61
xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitsCapacity
std::vector< int > mdtHitsCapacity
Definition: L2StandAloneMuonAuxContainer_v1.h:194
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidRhoHitInSeg
std::vector< std::vector< uint32_t > > tgcMidRhoHitInSeg
Definition: L2StandAloneMuonAuxContainer_v1.h:245
xAOD::L2StandAloneMuonAuxContainer_v1::roiSector
std::vector< uint32_t > roiSector
Definition: L2StandAloneMuonAuxContainer_v1.h:105
xAOD::L2StandAloneMuonAuxContainer_v1::roadBwNormal
std::vector< std::vector< float > > roadBwNormal
Intercept.
Definition: L2StandAloneMuonAuxContainer_v1.h:128
xAOD::L2StandAloneMuonAuxContainer_v1::endcapRadius
std::vector< float > endcapRadius
Definition: L2StandAloneMuonAuxContainer_v1.h:64
xAOD::L2StandAloneMuonAuxContainer_v1::tgcPt
std::vector< float > tgcPt
TGC fit results.
Definition: L2StandAloneMuonAuxContainer_v1.h:147
xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitResidual
std::vector< std::vector< float > > mdtHitResidual
Definition: L2StandAloneMuonAuxContainer_v1.h:258
xAOD::L2StandAloneMuonAuxContainer_v1::roiPhi
std::vector< uint32_t > roiPhi
Definition: L2StandAloneMuonAuxContainer_v1.h:109
xAOD::L2StandAloneMuonAuxContainer_v1::phi
std::vector< float > phi
Definition: L2StandAloneMuonAuxContainer_v1.h:42
xAOD::L2StandAloneMuonAuxContainer_v1::chamberType1Overlap
std::vector< std::vector< int > > chamberType1Overlap
Definition: L2StandAloneMuonAuxContainer_v1.h:121
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:191
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidPhiHitWidth
std::vector< std::vector< float > > tgcMidPhiHitWidth
Definition: L2StandAloneMuonAuxContainer_v1.h:249
xAOD::L2StandAloneMuonAuxContainer_v1::zMinNormal
std::vector< std::vector< float > > zMinNormal
Z.
Definition: L2StandAloneMuonAuxContainer_v1.h:131
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMid2Z
std::vector< float > tgcMid2Z
Definition: L2StandAloneMuonAuxContainer_v1.h:162
python.subdetectors.mmg.ids
ids
Definition: mmg.py:8
xAOD::L2StandAloneMuonAuxContainer_v1::roadBwOverlap
std::vector< std::vector< float > > roadBwOverlap
Definition: L2StandAloneMuonAuxContainer_v1.h:129
xAOD::L2StandAloneMuonAuxContainer_v1::phiMap
std::vector< float > phiMap
Definition: L2StandAloneMuonAuxContainer_v1.h:72
xAOD::L2StandAloneMuonAuxContainer_v1::ptEndcapAlpha
std::vector< float > ptEndcapAlpha
Definition: L2StandAloneMuonAuxContainer_v1.h:114
xAOD::L2StandAloneMuonAuxContainer_v1::trackPositionR
std::vector< std::vector< float > > trackPositionR
Track positions.
Definition: L2StandAloneMuonAuxContainer_v1.h:91
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMid1Phi
std::vector< float > tgcMid1Phi
Definition: L2StandAloneMuonAuxContainer_v1.h:155
xAOD::L2StandAloneMuonAuxContainer_v1::zMaxNormal
std::vector< std::vector< float > > zMaxNormal
Definition: L2StandAloneMuonAuxContainer_v1.h:133
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnPhiHitZ
std::vector< std::vector< float > > tgcInnPhiHitZ
Definition: L2StandAloneMuonAuxContainer_v1.h:238
xAOD::AuxContainerBase::getWritableAuxIDs
virtual const auxid_set_t & getWritableAuxIDs() const override
Return a set of writable data identifiers.
Definition: AuxContainerBase.cxx:424
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_v1::rpc3y
std::vector< float > rpc3y
Definition: L2StandAloneMuonAuxContainer_v1.h:184
xAOD::L2StandAloneMuonAuxContainer_v1::rpcHitsCapacity
std::vector< int > rpcHitsCapacity
Definition: L2StandAloneMuonAuxContainer_v1.h:192
xAOD::L2StandAloneMuonAuxContainer_v1::superPointR
std::vector< std::vector< float > > superPointR
Station fit results (superpoints)
Definition: L2StandAloneMuonAuxContainer_v1.h:84
xAOD::L2StandAloneMuonAuxContainer_v1::etaBin
std::vector< int > etaBin
Definition: L2StandAloneMuonAuxContainer_v1.h:73
xAOD::ReadStats::readBranch
void readBranch(const std::string &prefix, SG::auxid_t auxid)
Function incrementing the read counter on a specific branch.
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_v1::tgcMidRhoHitR
std::vector< std::vector< float > > tgcMidRhoHitR
Definition: L2StandAloneMuonAuxContainer_v1.h:242
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_v1::phiMS
std::vector< float > phiMS
Definition: L2StandAloneMuonAuxContainer_v1.h:54
xAOD::L2StandAloneMuonAuxContainer_v1::padHitCode
std::vector< std::vector< uint32_t > > padHitCode
Definition: L2StandAloneMuonAuxContainer_v1.h:223
xAOD::L2StandAloneMuonAuxContainer_v1::deltaPhi
std::vector< float > deltaPhi
Definition: L2StandAloneMuonAuxContainer_v1.h:81
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_v1::slopeInner
std::vector< float > slopeInner
Slope and intercept at inner.
Definition: L2StandAloneMuonAuxContainer_v1.h:66
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_v1::extension0
std::vector< std::vector< uint32_t > > extension0
Extensions.
Definition: L2StandAloneMuonAuxContainer_v1.h:197
xAOD::L2StandAloneMuonAuxContainer_v1::rMinNormal
std::vector< std::vector< float > > rMinNormal
R.
Definition: L2StandAloneMuonAuxContainer_v1.h:136
xAOD::AuxContainerBase::m_locked
bool m_locked
Has the container been locked?
Definition: AuxContainerBase.h:227
xAOD::L2StandAloneMuonAuxContainer_v1::etaMS
std::vector< float > etaMS
Definition: L2StandAloneMuonAuxContainer_v1.h:53
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_v1::tgcMid1Z
std::vector< float > tgcMid1Z
Definition: L2StandAloneMuonAuxContainer_v1.h:157
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnRhoHitInSeg
std::vector< std::vector< uint32_t > > tgcInnRhoHitInSeg
Definition: L2StandAloneMuonAuxContainer_v1.h:235
SG::IConstAuxStore::lock
virtual void lock()=0
Lock the container.
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMidPhiHitZ
std::vector< std::vector< float > > tgcMidPhiHitZ
Definition: L2StandAloneMuonAuxContainer_v1.h:248
xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitSigma
std::vector< std::vector< float > > mdtHitSigma
Definition: L2StandAloneMuonAuxContainer_v1.h:261
xAOD::AuxContainerBase::m_storeIO
SG::IAuxStoreIO * m_storeIO
The IO interface to the internal auxiliary store.
Definition: AuxContainerBase.h:223
xAOD::L2StandAloneMuonAuxContainer_v1::tgcHitsCapacity
std::vector< int > tgcHitsCapacity
Definition: L2StandAloneMuonAuxContainer_v1.h:193
xAOD::AuxContainerBase::AuxContainerBase
AuxContainerBase(bool allowDynamicVars=true)
Default constructor.
Definition: AuxContainerBase.cxx:28
SG::IAuxStore::resize
virtual bool resize(size_t sz)=0
Change the size of all aux data vectors.
xAOD::L2StandAloneMuonAuxContainer_v1::barrelRadius
std::vector< float > barrelRadius
Input measurements to be converted to pT by LUT.
Definition: L2StandAloneMuonAuxContainer_v1.h:60
SG::auxid_set_t
A set of aux data identifiers.
Definition: AuxTypes.h:47
xAOD::L2StandAloneMuonAuxContainer_v1::padHitR
std::vector< std::vector< float > > padHitR
Definition: L2StandAloneMuonAuxContainer_v1.h:227
xAOD::L2StandAloneMuonAuxContainer_v1::roiId
std::vector< uint32_t > roiId
Definition: L2StandAloneMuonAuxContainer_v1.h:102
SG::IConstAuxStore::isDecoration
virtual bool isDecoration(auxid_t auxid) const =0
Test if a particular variable is tagged as a decoration.
xAOD::L2StandAloneMuonAuxContainer_v1::deltaEta
std::vector< float > deltaEta
Definition: L2StandAloneMuonAuxContainer_v1.h:80
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnRhoHitWidth
std::vector< std::vector< float > > tgcInnRhoHitWidth
Definition: L2StandAloneMuonAuxContainer_v1.h:234
xAOD::L2StandAloneMuonAuxContainer_v1::mdtHitZ
std::vector< std::vector< float > > mdtHitZ
Definition: L2StandAloneMuonAuxContainer_v1.h:257
xAOD::AuxContainerBase::getAuxID
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.
xAOD::L2StandAloneMuonAuxContainer_v1::extensionCapacity
std::vector< int > extensionCapacity
Size of hit strages.
Definition: L2StandAloneMuonAuxContainer_v1.h:188
xAOD::L2StandAloneMuonAuxContainer_v1::ptBarrelRadius
std::vector< float > ptBarrelRadius
pT from different algorithms
Definition: L2StandAloneMuonAuxContainer_v1.h:112
xAOD::L2StandAloneMuonAuxContainer_v1::extension2
std::vector< std::vector< uint32_t > > extension2
Definition: L2StandAloneMuonAuxContainer_v1.h:199
xAOD::L2StandAloneMuonAuxContainer_v1::removedRobId
std::vector< std::vector< uint32_t > > removedRobId
Definition: L2StandAloneMuonAuxContainer_v1.h:213
xAOD::L2StandAloneMuonAuxContainer_v1::padHitOnlineId
std::vector< std::vector< uint32_t > > padHitOnlineId
RPC pad hits.
Definition: L2StandAloneMuonAuxContainer_v1.h:222
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMid2Eta
std::vector< float > tgcMid2Eta
Definition: L2StandAloneMuonAuxContainer_v1.h:159
xAOD::L2StandAloneMuonAuxContainer_v1::rMaxNormal
std::vector< std::vector< float > > rMaxNormal
Definition: L2StandAloneMuonAuxContainer_v1.h:138
SG::IAuxStoreHolder::AST_ObjectStore
@ AST_ObjectStore
The store describes a single object.
Definition: IAuxStoreHolder.h:67
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnR
std::vector< float > tgcInnR
Definition: L2StandAloneMuonAuxContainer_v1.h:151
xAOD::L2StandAloneMuonAuxContainer_v1::extension9
std::vector< std::vector< uint32_t > > extension9
Definition: L2StandAloneMuonAuxContainer_v1.h:206
xAOD::L2StandAloneMuonAuxContainer_v1::ptEndcapRadius
std::vector< float > ptEndcapRadius
Definition: L2StandAloneMuonAuxContainer_v1.h:116
xAOD::L2StandAloneMuonAuxContainer_v1::zMinOverlap
std::vector< std::vector< float > > zMinOverlap
Definition: L2StandAloneMuonAuxContainer_v1.h:132
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_v1::tgcMid2Phi
std::vector< float > tgcMid2Phi
Definition: L2StandAloneMuonAuxContainer_v1.h:160
SG::IAuxTypeVector::toPtr
virtual void * toPtr()=0
Return a pointer to the start of the vector's data.
xAOD::L2StandAloneMuonAuxContainer_v1::algoId
std::vector< int > algoId
Detailed information.
Definition: L2StandAloneMuonAuxContainer_v1.h:97
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnRhoHitZ
std::vector< std::vector< float > > tgcInnRhoHitZ
Definition: L2StandAloneMuonAuxContainer_v1.h:233
xAOD::L2StandAloneMuonAuxContainer_v1::extension5
std::vector< std::vector< uint32_t > > extension5
Definition: L2StandAloneMuonAuxContainer_v1.h:202
xAOD::L2StandAloneMuonAuxContainer_v1::rpc1z
std::vector< float > rpc1z
Definition: L2StandAloneMuonAuxContainer_v1.h:177
SG::IAuxStore::reserve
virtual void reserve(size_t sz)=0
Change the capacity of all aux data vectors.
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnPhiHitR
std::vector< std::vector< float > > tgcInnPhiHitR
Definition: L2StandAloneMuonAuxContainer_v1.h:237
SG::IAuxStoreHolder::AST_ContainerStore
@ AST_ContainerStore
The store describes a container.
Definition: IAuxStoreHolder.h:68
xAOD::L2StandAloneMuonAuxContainer_v1::teId
std::vector< uint32_t > teId
Definition: L2StandAloneMuonAuxContainer_v1.h:98
xAOD::L2StandAloneMuonAuxContainer_v1::extension3
std::vector< std::vector< uint32_t > > extension3
Definition: L2StandAloneMuonAuxContainer_v1.h:200
xAOD::L2StandAloneMuonAuxContainer_v1::tgcMid1R
std::vector< float > tgcMid1R
Definition: L2StandAloneMuonAuxContainer_v1.h:156
xAOD::L2StandAloneMuonAuxContainer_v1::tgcInnPhi
std::vector< float > tgcInnPhi
Definition: L2StandAloneMuonAuxContainer_v1.h:150
Generated on Sun May 19 2024 22:32:06 for ATLAS Offline Software by   doxygen 1.8.18