ATLAS Offline Software
MuFastDataPreparator.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "MuFastDataPreparator.h"
6 #include "AthenaBaseComps/AthMsgStreamMacros.h"
7 #include "xAODTrigMuon/TrigMuonDefs.h"
8 
9 // --------------------------------------------------------------------------------
10 // --------------------------------------------------------------------------------
11 
12 TrigL2MuonSA::MuFastDataPreparator::MuFastDataPreparator(const std::string& type,
13  const std::string& name,
14  const IInterface* parent):
15  AthAlgTool(type,name,parent)
16 {
17 }
18 
19 
20 // --------------------------------------------------------------------------------
21 // --------------------------------------------------------------------------------
22 
23 StatusCode TrigL2MuonSA::MuFastDataPreparator::initialize()
24 {
25  ATH_CHECK(m_recRPCRoiTool.retrieve());
26 
27  if (m_use_rpc) {
28  ATH_CHECK(m_rpcDataPreparator.retrieve());
29  ATH_MSG_DEBUG("Retrieved service " << m_rpcDataPreparator);
30  }
31 
32  ATH_CHECK(m_tgcDataPreparator.retrieve());
33  ATH_MSG_DEBUG("Retrieved service " << m_tgcDataPreparator);
34 
35  ATH_CHECK(m_mdtDataPreparator.retrieve());
36  ATH_MSG_DEBUG("Retrieved service " << m_mdtDataPreparator);
37 
38  ATH_CHECK(m_cscDataPreparator.retrieve(DisableTool{m_cscDataPreparator.empty()}));
39  ATH_MSG_DEBUG("Retrieved service " << m_cscDataPreparator);
40 
41  if (m_use_stgc) {
42  ATH_CHECK(m_stgcDataPreparator.retrieve(DisableTool{m_stgcDataPreparator.empty()}));
43  ATH_MSG_DEBUG("Retrieved service " << m_stgcDataPreparator);
44  }
45 
46  if (m_use_mm) {
47  ATH_CHECK(m_mmDataPreparator.retrieve(DisableTool{m_mmDataPreparator.empty()}));
48  ATH_MSG_DEBUG("Retrieved service " << m_mmDataPreparator);
49  }
50 
51  ATH_CHECK(m_rpcRoadDefiner.retrieve());
52  ATH_MSG_DEBUG("Retrieved service " << m_rpcRoadDefiner);
53 
54  ATH_CHECK(m_tgcRoadDefiner.retrieve());
55  ATH_MSG_DEBUG("Retrieved service " << m_tgcRoadDefiner);
56 
57  ATH_CHECK(m_rpcPatFinder.retrieve());
58  ATH_MSG_DEBUG("Retrieved service " << m_rpcPatFinder);
59 
60  ATH_CHECK(m_clusterRoadDefiner.retrieve());
61  ATH_MSG_DEBUG("Retrieved service " << m_clusterRoadDefiner);
62 
63  ATH_CHECK(m_clusterPatFinder.retrieve());
64  ATH_MSG_DEBUG("Retrieved service " << m_clusterPatFinder);
65 
66  return StatusCode::SUCCESS;
67 }
68 
69 // --------------------------------------------------------------------------------
70 // --------------------------------------------------------------------------------
71 
72 StatusCode TrigL2MuonSA::MuFastDataPreparator::setMCFlag(bool use_mcLUT)
73 {
74  m_use_mcLUT = use_mcLUT;
75 
76  if (m_use_mcLUT) {
77  const ServiceHandle<TrigL2MuonSA::PtEndcapLUTSvc> ptEndcapLUTSvc("PtEndcapLUTSvc_MC", name());
78  if ( ptEndcapLUTSvc.retrieve().isFailure() ) {
79  ATH_MSG_DEBUG("Could not retrieve PtEndcapLUTSvc_MC");
80  return StatusCode::FAILURE;
81  }
82  m_tgcRoadDefiner->setPtLUT(&*ptEndcapLUTSvc);
83  } else {
84  const ServiceHandle<TrigL2MuonSA::PtEndcapLUTSvc> ptEndcapLUTSvc("PtEndcapLUTSvc", name());
85  if ( ptEndcapLUTSvc.retrieve().isFailure() ) {
86  ATH_MSG_DEBUG("Could not retrieve PtEndcapLUTSvc");
87  return StatusCode::FAILURE;
88  }
89  m_tgcRoadDefiner->setPtLUT(&*ptEndcapLUTSvc);
90  }
91 
92  return StatusCode::SUCCESS;
93 }
94 
95 // --------------------------------------------------------------------------------
96 // --------------------------------------------------------------------------------
97 
98 void TrigL2MuonSA::MuFastDataPreparator::setRoadWidthForFailure(double rWidth_RPC_Failed,
99  double rWidth_TGC_Failed)
100 {
101  m_rpcRoadDefiner->setRoadWidthForFailure(rWidth_RPC_Failed);
102  m_tgcRoadDefiner->setRoadWidthForFailure(rWidth_TGC_Failed);
103  return;
104 }
105 
106 // --------------------------------------------------------------------------------
107 // --------------------------------------------------------------------------------
108 
109 void TrigL2MuonSA::MuFastDataPreparator::setRpcGeometry(bool use_rpc)
110 {
111  m_rpcRoadDefiner->setRpcGeometry(use_rpc);
112 
113  m_use_rpc = use_rpc;
114  return;
115 }
116 
117 // --------------------------------------------------------------------------------
118 
119 void TrigL2MuonSA::MuFastDataPreparator::setRoIBasedDataAccess(bool use_RoIBasedDataAccess_MDT,
120  bool use_RoIBasedDataAccess_RPC,
121  bool use_RoIBasedDataAccess_TGC,
122  bool use_RoIBasedDataAccess_CSC,
123  bool use_RoIBasedDataAccess_STGC,
124  bool use_RoIBasedDataAccess_MM)
125 {
126  m_mdtDataPreparator ->setRoIBasedDataAccess(use_RoIBasedDataAccess_MDT);
127  m_rpcDataPreparator ->setRoIBasedDataAccess(use_RoIBasedDataAccess_RPC);
128  m_tgcDataPreparator ->setRoIBasedDataAccess(use_RoIBasedDataAccess_TGC);
129  if(!m_cscDataPreparator.empty()) m_cscDataPreparator->setRoIBasedDataAccess(use_RoIBasedDataAccess_CSC);
130  if(!m_stgcDataPreparator.empty()) m_stgcDataPreparator->setRoIBasedDataAccess(use_RoIBasedDataAccess_STGC);
131  if(!m_mmDataPreparator.empty()) m_mmDataPreparator->setRoIBasedDataAccess(use_RoIBasedDataAccess_MM);
132  return;
133 }
134 
135 // --------------------------------------------------------------------------------
136 // --------------------------------------------------------------------------------
137 
138 void TrigL2MuonSA::MuFastDataPreparator::setExtrapolatorTool(ToolHandle<ITrigMuonBackExtrapolator>* backExtrapolator)
139 {
140  m_backExtrapolatorTool = backExtrapolator;
141  m_tgcRoadDefiner->setExtrapolatorTool(m_backExtrapolatorTool);
142  return;
143 }
144 
145 // --------------------------------------------------------------------------------
146 // --------------------------------------------------------------------------------
147 
148 StatusCode TrigL2MuonSA::MuFastDataPreparator::prepareData(const xAOD::MuonRoI* p_roi,
149  const TrigRoiDescriptor* p_roids,
150  const bool insideOut,
151  TrigL2MuonSA::RpcHits& rpcHits,
152  TrigL2MuonSA::MuonRoad& muonRoad,
153  TrigL2MuonSA::MdtRegion& mdtRegion,
154  TrigL2MuonSA::RpcFitResult& rpcFitResult,
155  TrigL2MuonSA::MdtHits& mdtHits,
156  const bool dynamicDeltaRpc) const
157 {
158 
159  ATH_MSG_DEBUG("RoI eta/phi=" << p_roi->eta() << "/" << p_roi->phi());
160 
161  StatusCode sc = StatusCode::SUCCESS;
162 
163  //Storing rpc hits by each layers and eta/phi strip for creating road
164  //RpcLayerHits class is defined in RpcPatFinder.h
165  TrigL2MuonSA::RpcLayerHits rpcLayerHits;
166  rpcLayerHits.clear();
167 
168  if(m_use_rpc && !insideOut) {
169 
170  sc = m_rpcDataPreparator->prepareData(p_roids,
171  rpcHits,
172  rpcLayerHits,
173  &m_rpcPatFinder,
174  dynamicDeltaRpc);
175 
176  if (!sc.isSuccess()) {
177  ATH_MSG_DEBUG("Error in RPC data prepapration. Continue using RoI");
178  }
179  } else {
180  ATH_MSG_DEBUG("Skip RpcDataPreparator");
181  }
182 
183  LVL1::TrigT1MuonRecRoiData data;
184  sc = m_recRPCRoiTool->roiData(p_roi->roiWord(),data);
185  if (!sc.isSuccess()){
186  ATH_MSG_WARNING("Error in roiWord decode");
187  return sc;
188  }
189  double roiEtaMinLow = 0.;
190  double roiEtaMaxLow = 0.;
191  double roiEtaMinHigh = 0.;
192  double roiEtaMaxHigh = 0.;
193  if(!m_recRPCRoiTool->etaDimLow(data, roiEtaMinLow, roiEtaMaxLow)) {
194  roiEtaMinLow = p_roids->eta();
195  roiEtaMaxLow = p_roids->eta();
196  }
197  if(!m_recRPCRoiTool->etaDimHigh(data, roiEtaMinHigh, roiEtaMaxHigh)) {
198  roiEtaMinHigh = p_roids->eta();
199  roiEtaMaxHigh = p_roids->eta();
200  }
201 
202  ATH_MSG_DEBUG("nr of RPC hits=" << rpcHits.size());
203 
204  sc = m_rpcRoadDefiner->defineRoad(p_roi,
205  insideOut,
206  muonRoad,
207  rpcLayerHits,
208  &m_rpcPatFinder,
209  rpcFitResult,
210  roiEtaMinLow,
211  roiEtaMaxLow,
212  roiEtaMinHigh,
213  roiEtaMaxHigh);
214  if (!sc.isSuccess()) {
215  ATH_MSG_WARNING("Error in road definition.");
216  return sc;
217  }
218 
219  sc = m_mdtDataPreparator->prepareData(p_roids,
220  rpcFitResult,
221  muonRoad,
222  mdtRegion,
223  mdtHits);
224 
225 
226  if (!sc.isSuccess()) {
227  ATH_MSG_WARNING("Error in MDT data preparation.");
228  return sc;
229  }
230  ATH_MSG_DEBUG("nr of MDT hits=" << mdtHits.size());
231 
232  return StatusCode::SUCCESS;
233 }
234 
235 //for multi-track SA mode
236 //do Rpc clustering and create multi muon candidate
237 // --------------------------------------------------------------------------------
238 // --------------------------------------------------------------------------------
239 
240 StatusCode TrigL2MuonSA::MuFastDataPreparator::prepareData(const xAOD::MuonRoI* p_roi,
241  const TrigRoiDescriptor* p_roids,
242  std::vector<TrigL2MuonSA::MuonRoad>& clusterRoad,
243  std::vector<TrigL2MuonSA::RpcFitResult>& clusterFitResults,
244  TrigL2MuonSA::MdtHits& mdtHits,
245  std::vector<TrigL2MuonSA::MdtHits>& mdtHits_cluster_normal,
246  const bool dynamicDeltaRpc) const
247 {
248 
249  ATH_MSG_DEBUG("RoI eta/phi=" << p_roi->eta() << "/" << p_roi->phi());
250  //RpcLayerClusters class is defined in ClusterPatFinder.h
251  TrigL2MuonSA::RpcLayerClusters rpcLayerClusters;
252  rpcLayerClusters.clear();
253 
254  // for MdtDataPreparator's input
255  TrigL2MuonSA::MdtRegion mdtRegion;
256  mdtRegion.Clear();
257 
258  StatusCode sc = StatusCode::SUCCESS;
259 
260  if(!m_use_rpc){
261 
262  } else {
263 
264  sc = m_rpcDataPreparator->prepareData(p_roids,
265  rpcLayerClusters,
266  &m_clusterPatFinder,
267  dynamicDeltaRpc);
268 
269  if (!sc.isSuccess()) {
270  ATH_MSG_DEBUG("Error in RPC data prepapration and clustering. Continue using RoI");
271  return sc;
272  }
273  }
274 
275  LVL1::TrigT1MuonRecRoiData data;
276  sc = m_recRPCRoiTool->roiData(p_roi->roiWord(),data);
277  if (!sc.isSuccess()){
278  ATH_MSG_WARNING("Error in roiWord decode");
279  return sc;
280  }
281  double roiEtaMinLow = 0.;
282  double roiEtaMaxLow = 0.;
283  double roiEtaMinHigh = 0.;
284  double roiEtaMaxHigh = 0.;
285  if(!m_recRPCRoiTool->etaDimLow(data, roiEtaMinLow, roiEtaMaxLow)) {
286  roiEtaMinLow = p_roids->eta();
287  roiEtaMaxLow = p_roids->eta();
288  }
289  if(!m_recRPCRoiTool->etaDimHigh(data, roiEtaMinHigh, roiEtaMaxHigh)) {
290  roiEtaMinHigh = p_roids->eta();
291  roiEtaMaxHigh = p_roids->eta();
292  }
293 
294  sc = m_clusterRoadDefiner->defineRoad(p_roi,
295  clusterRoad,
296  rpcLayerClusters,
297  &m_clusterPatFinder,
298  clusterFitResults,
299  roiEtaMinLow,
300  roiEtaMaxLow,
301  roiEtaMinHigh,
302  roiEtaMaxHigh);
303  if (!sc.isSuccess()) {
304  ATH_MSG_WARNING("Error in clusterRoad definition.");
305  return sc;
306 
307  }
308  if(!clusterRoad.empty()){
309  sc = m_mdtDataPreparator->prepareData(p_roids,
310  clusterFitResults.back(),
311  clusterRoad.back(),
312  mdtRegion,
313  mdtHits);
314 
315  if (!sc.isSuccess()) {
316  ATH_MSG_WARNING("Error in MDT data preparation.");
317  return sc;
318  }
319 
320  ATH_MSG_DEBUG("nr of MDT (normal) hits=" << mdtHits.size());
321 
322  for(unsigned int i_road = 0; i_road < clusterRoad.size(); i_road++){
323  TrigL2MuonSA::MdtHits mdt_normal;
324  for(unsigned int i_hit = 0; i_hit < mdtHits.size(); i_hit++){
325  unsigned int chamber = mdtHits[i_hit].Chamber;
326 
327  if (chamber >= xAOD::L2MuonParameters::MaxChamber) continue;
328  double Z = mdtHits[i_hit].Z;
329  double R = mdtHits[i_hit].R;
330  double residual = 999999;
331  unsigned int clusterRoadID = 9999;
332  for(unsigned int j_road = 0; j_road < clusterRoad.size(); j_road++){
333  double aw = clusterRoad.at(j_road).aw[chamber][0];
334  double bw = clusterRoad.at(j_road).bw[chamber][0];
335  double tmp_residual;
336  const double ZERO_LIMIT = 1e-4;
337  if( std::abs(aw) < ZERO_LIMIT ){
338  tmp_residual = R-bw;
339  } else {
340  double ia = 1/aw;
341  double iaq = ia*ia;
342  double dz = Z - (R-bw)*ia;
343  tmp_residual = dz/std::sqrt(1.+iaq);
344  }
345  if(std::abs(residual) > std::abs(tmp_residual)){
346  residual = tmp_residual;
347  clusterRoadID = j_road;
348  }
349  }
350  if(clusterRoadID == i_road){
351  mdt_normal.push_back(mdtHits[i_hit]);
352  }
353  }
354  mdtHits_cluster_normal.push_back(mdt_normal);
355  }
356  }
357 
358  return StatusCode::SUCCESS;
359 }
360 
361 // --------------------------------------------------------------------------------
362 // --------------------------------------------------------------------------------
363 
364 StatusCode TrigL2MuonSA::MuFastDataPreparator::prepareData(const xAOD::MuonRoI* p_roi,
365  const TrigRoiDescriptor* p_roids,
366  const bool insideOut,
367  TrigL2MuonSA::TgcHits& tgcHits,
368  TrigL2MuonSA::MuonRoad& muonRoad,
369  TrigL2MuonSA::MdtRegion& mdtRegion,
370  TrigL2MuonSA::TgcFitResult& tgcFitResult,
371  TrigL2MuonSA::MdtHits& mdtHits,
372  TrigL2MuonSA::CscHits& cscHits,
373  TrigL2MuonSA::StgcHits& stgcHits,
374  TrigL2MuonSA::MmHits& mmHits) const
375 {
376  StatusCode sc = StatusCode::SUCCESS;
377  ATH_MSG_DEBUG("RoI eta/phi=" << p_roi->eta() << "/" << p_roi->phi());
378 
379  if(!insideOut) {
380  sc = m_tgcDataPreparator->prepareData(p_roi,
381  tgcHits);
382  } else {
383  ATH_MSG_DEBUG("Skip TgcDataPreparator");
384  }
385 
386  if (!sc.isSuccess()) {
387  ATH_MSG_DEBUG("Error in TGC data preparation. Continue using RoI");
388  }
389  ATH_MSG_DEBUG("nr of TGC hits=" << tgcHits.size());
390 
391  sc = m_tgcRoadDefiner->defineRoad(p_roids,
392  insideOut,
393  tgcHits,
394  muonRoad,
395  tgcFitResult);
396  if (!sc.isSuccess()) {
397  ATH_MSG_WARNING("Error in road definition.");
398  return sc;
399  }
400 
401  sc = m_mdtDataPreparator->prepareData(p_roids,
402  tgcFitResult,
403  muonRoad,
404  mdtRegion,
405  mdtHits);
406 
407  if (!sc.isSuccess()) {
408  ATH_MSG_WARNING("Error in MDT data preparation.");
409  return sc;
410  }
411  ATH_MSG_DEBUG("nr of MDT (normal) hits=" << mdtHits.size());
412 
413  if(!m_cscDataPreparator.empty()) {
414  sc = m_cscDataPreparator->prepareData(muonRoad,
415  cscHits);
416  if (!sc.isSuccess()) {
417  ATH_MSG_WARNING("Error in CSC data preparation.");
418  return sc;
419  }
420  ATH_MSG_DEBUG("nr of CSC hits=" << cscHits.size());
421  }
422 
423  if(m_use_stgc && !m_stgcDataPreparator.empty()){
424  sc = m_stgcDataPreparator->prepareData(p_roids,
425  stgcHits);
426  if (!sc.isSuccess()) {
427  ATH_MSG_WARNING("Error in sTGC data preparation.");
428  return sc;
429  }
430  ATH_MSG_DEBUG("nr of sTGC hits=" << stgcHits.size());
431  }
432 
433  if(m_use_mm && !m_mmDataPreparator.empty()){
434  sc = m_mmDataPreparator->prepareData(p_roids,
435  mmHits);
436  if (!sc.isSuccess()) {
437  ATH_MSG_WARNING("Error in MM data preparation.");
438  return sc;
439  }
440  ATH_MSG_DEBUG("nr of MM hits=" << mmHits.size());
441  }
442 
443  return StatusCode::SUCCESS;
444 }
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
LVL1::TrigT1MuonRecRoiData
Definition: TrigT1MuonRecRoiData.h:10
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
TrigL2MuonSA::MuFastDataPreparator::setRpcGeometry
void setRpcGeometry(bool use_rpc)
Definition: MuFastDataPreparator.cxx:109
AthMsgStreamMacros.h
TrigL2MuonSA::RpcHits
std::vector< RpcHitData > RpcHits
Definition: RpcData.h:57
TrigL2MuonSA::RpcLayerClusters::clear
void clear()
Definition: ClusterPatFinder.h:63
ClusterSeg::residual
@ residual
Definition: ClusterNtuple.h:20
TrigL2MuonSA::RpcFitResult
Definition: RpcFitResult.h:14
calibdata.chamber
chamber
Definition: calibdata.py:31
TrigL2MuonSA::TgcFitResult
Definition: TgcFitResult.h:11
TrigL2MuonSA::MdtHits
std::vector< MdtHitData > MdtHits
Definition: MdtData.h:56
TrigL2MuonSA::TgcHits
std::vector< TgcHitData > TgcHits
Definition: TgcData.h:43
xAOD::MuonRoI_v1::eta
float eta() const
The pseudorapidity ( ) of the muon candidate.
TrigL2MuonSA::MdtRegion::Clear
void Clear()
Definition: MdtRegion.h:19
TrigRoiDescriptor
nope - should be used for standalone also, perhaps need to protect the class def bits #ifndef XAOD_AN...
Definition: TrigRoiDescriptor.h:56
TrigL2MuonSA::CscHits
std::vector< CscHitData > CscHits
Definition: CscData.h:40
TrigL2MuonSA::MuFastDataPreparator::setMCFlag
StatusCode setMCFlag(bool use_mcLUT)
Definition: MuFastDataPreparator.cxx:72
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
TrigL2MuonSA::MuFastDataPreparator::setRoIBasedDataAccess
void setRoIBasedDataAccess(bool use_RoIBasedDataAccess_MDT, bool use_RoIBasedDataAccess_RPC, bool use_RoIBasedDataAccess_TGC, bool use_RoIBasedDataAccess_CSC, bool use_RoIBasedDataAccess_STGC, bool use_RoIBasedDataAccess_MM)
Definition: MuFastDataPreparator.cxx:119
TrigL2MuonSA::MdtRegion
Definition: MdtRegion.h:15
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
MuFastDataPreparator.h
TrigL2MuonSA::MuonRoad
Definition: MuonRoad.h:20
xAOD::L2MuonParameters::MaxChamber
@ MaxChamber
Number of measurement point definitions.
Definition: TrigMuonDefs.h:27
TrigL2MuonSA::MuFastDataPreparator::MuFastDataPreparator
MuFastDataPreparator(const std::string &type, const std::string &name, const IInterface *parent)
Definition: MuFastDataPreparator.cxx:12
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::MuonRoI_v1
Class describing a LVL1 muon region of interest.
Definition: MuonRoI_v1.h:29
test_pyathena.parent
parent
Definition: test_pyathena.py:15
TrigL2MuonSA::RpcLayerClusters
Definition: ClusterPatFinder.h:58
TrigL2MuonSA::MuFastDataPreparator::initialize
virtual StatusCode initialize() override
Definition: MuFastDataPreparator.cxx:23
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TrigL2MuonSA::MuFastDataPreparator::setExtrapolatorTool
void setExtrapolatorTool(ToolHandle< ITrigMuonBackExtrapolator > *backExtrapolator)
Definition: MuFastDataPreparator.cxx:138
ZERO_LIMIT
const float ZERO_LIMIT
Definition: VP1TriggerHandleL2.cxx:37
TrigL2MuonSA::RpcLayerHits::clear
void clear()
Definition: RpcPatFinder.h:25
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
TrigL2MuonSA::RpcLayerHits
Definition: RpcPatFinder.h:20
TrigL2MuonSA::MuFastDataPreparator::prepareData
StatusCode prepareData(const xAOD::MuonRoI *p_roi, const TrigRoiDescriptor *p_roids, const bool insideOut, TrigL2MuonSA::RpcHits &rpcHits, TrigL2MuonSA::MuonRoad &muonRoad, TrigL2MuonSA::MdtRegion &mdtRegion, TrigL2MuonSA::RpcFitResult &rpcFitResult, TrigL2MuonSA::MdtHits &mdtHits, const bool dynamicDeltaRpc) const
Definition: MuFastDataPreparator.cxx:148
TrigL2MuonSA::MuFastDataPreparator::setRoadWidthForFailure
void setRoadWidthForFailure(double rWidth_RPC_Failed, double rWidth_TGC_Failed)
Definition: MuFastDataPreparator.cxx:98
TrigMuonDefs.h
TrigL2MuonSA::MmHits
std::vector< MmHitData > MmHits
Definition: MmData.h:47
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TrigL2MuonSA::StgcHits
std::vector< StgcHitData > StgcHits
Definition: StgcData.h:49
RoiDescriptor::eta
virtual double eta() const override final
Definition: RoiDescriptor.h:101
AthAlgTool
Definition: AthAlgTool.h:26
xAOD::MuonRoI_v1::roiWord
uint32_t roiWord() const
The "raw" RoI word describing the muon candidate.
ServiceHandle
Definition: ClusterMakerTool.h:37
xAOD::MuonRoI_v1::phi
float phi() const
The azimuthal angle ( ) of the muon candidate.
Generated on Wed Sep 3 2025 21:15:01 for ATLAS Offline Software by   doxygen 1.8.18