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 EventContext& ctx,
149  const xAOD::MuonRoI* p_roi,
150  const TrigRoiDescriptor* p_roids,
151  const bool insideOut,
152  TrigL2MuonSA::RpcHits& rpcHits,
153  TrigL2MuonSA::MuonRoad& muonRoad,
154  TrigL2MuonSA::MdtRegion& mdtRegion,
155  TrigL2MuonSA::RpcFitResult& rpcFitResult,
156  TrigL2MuonSA::MdtHits& mdtHits,
157  const bool dynamicDeltaRpc) const
158 {
159 
160  ATH_MSG_DEBUG("RoI eta/phi=" << p_roi->eta() << "/" << p_roi->phi());
161 
162  StatusCode sc = StatusCode::SUCCESS;
163 
164  //Storing rpc hits by each layers and eta/phi strip for creating road
165  //RpcLayerHits class is defined in RpcPatFinder.h
166  TrigL2MuonSA::RpcLayerHits rpcLayerHits;
167  rpcLayerHits.clear();
168 
169  if(m_use_rpc && !insideOut) {
170 
171  sc = m_rpcDataPreparator->prepareData(ctx,
172  p_roids,
173  rpcHits,
174  rpcLayerHits,
175  &m_rpcPatFinder,
176  dynamicDeltaRpc);
177 
178  if (!sc.isSuccess()) {
179  ATH_MSG_DEBUG("Error in RPC data prepapration. Continue using RoI");
180  }
181  } else {
182  ATH_MSG_DEBUG("Skip RpcDataPreparator");
183  }
184 
185  LVL1::TrigT1MuonRecRoiData data;
186  sc = m_recRPCRoiTool->roiData(p_roi->roiWord(),data);
187  if (!sc.isSuccess()){
188  ATH_MSG_WARNING("Error in roiWord decode");
189  return sc;
190  }
191  double roiEtaMinLow = 0.;
192  double roiEtaMaxLow = 0.;
193  double roiEtaMinHigh = 0.;
194  double roiEtaMaxHigh = 0.;
195  if(!m_recRPCRoiTool->etaDimLow(data, roiEtaMinLow, roiEtaMaxLow)) {
196  roiEtaMinLow = p_roids->eta();
197  roiEtaMaxLow = p_roids->eta();
198  }
199  if(!m_recRPCRoiTool->etaDimHigh(data, roiEtaMinHigh, roiEtaMaxHigh)) {
200  roiEtaMinHigh = p_roids->eta();
201  roiEtaMaxHigh = p_roids->eta();
202  }
203 
204  ATH_MSG_DEBUG("nr of RPC hits=" << rpcHits.size());
205 
206  sc = m_rpcRoadDefiner->defineRoad(ctx,
207  p_roi,
208  insideOut,
209  muonRoad,
210  rpcLayerHits,
211  &m_rpcPatFinder,
212  rpcFitResult,
213  roiEtaMinLow,
214  roiEtaMaxLow,
215  roiEtaMinHigh,
216  roiEtaMaxHigh);
217  if (!sc.isSuccess()) {
218  ATH_MSG_WARNING("Error in road definition.");
219  return sc;
220  }
221 
222  sc = m_mdtDataPreparator->prepareData(ctx,
223  p_roids,
224  rpcFitResult,
225  muonRoad,
226  mdtRegion,
227  mdtHits);
228 
229 
230  if (!sc.isSuccess()) {
231  ATH_MSG_WARNING("Error in MDT data preparation.");
232  return sc;
233  }
234  ATH_MSG_DEBUG("nr of MDT hits=" << mdtHits.size());
235 
236  return StatusCode::SUCCESS;
237 }
238 
239 //for multi-track SA mode
240 //do Rpc clustering and create multi muon candidate
241 // --------------------------------------------------------------------------------
242 // --------------------------------------------------------------------------------
243 
244 StatusCode TrigL2MuonSA::MuFastDataPreparator::prepareData(const EventContext& ctx,
245  const xAOD::MuonRoI* p_roi,
246  const TrigRoiDescriptor* p_roids,
247  std::vector<TrigL2MuonSA::MuonRoad>& clusterRoad,
248  std::vector<TrigL2MuonSA::RpcFitResult>& clusterFitResults,
249  TrigL2MuonSA::MdtHits& mdtHits,
250  std::vector<TrigL2MuonSA::MdtHits>& mdtHits_cluster_normal,
251  const bool dynamicDeltaRpc) const
252 {
253 
254  ATH_MSG_DEBUG("RoI eta/phi=" << p_roi->eta() << "/" << p_roi->phi());
255  //RpcLayerClusters class is defined in ClusterPatFinder.h
256  TrigL2MuonSA::RpcLayerClusters rpcLayerClusters;
257  rpcLayerClusters.clear();
258 
259  // for MdtDataPreparator's input
260  TrigL2MuonSA::MdtRegion mdtRegion;
261  mdtRegion.Clear();
262 
263  StatusCode sc = StatusCode::SUCCESS;
264 
265  if(!m_use_rpc){
266 
267  } else {
268 
269  sc = m_rpcDataPreparator->prepareData(ctx,
270  p_roids,
271  rpcLayerClusters,
272  &m_clusterPatFinder,
273  dynamicDeltaRpc);
274 
275  if (!sc.isSuccess()) {
276  ATH_MSG_DEBUG("Error in RPC data prepapration and clustering. Continue using RoI");
277  return sc;
278  }
279  }
280 
281  LVL1::TrigT1MuonRecRoiData data;
282  sc = m_recRPCRoiTool->roiData(p_roi->roiWord(),data);
283  if (!sc.isSuccess()){
284  ATH_MSG_WARNING("Error in roiWord decode");
285  return sc;
286  }
287  double roiEtaMinLow = 0.;
288  double roiEtaMaxLow = 0.;
289  double roiEtaMinHigh = 0.;
290  double roiEtaMaxHigh = 0.;
291  if(!m_recRPCRoiTool->etaDimLow(data, roiEtaMinLow, roiEtaMaxLow)) {
292  roiEtaMinLow = p_roids->eta();
293  roiEtaMaxLow = p_roids->eta();
294  }
295  if(!m_recRPCRoiTool->etaDimHigh(data, roiEtaMinHigh, roiEtaMaxHigh)) {
296  roiEtaMinHigh = p_roids->eta();
297  roiEtaMaxHigh = p_roids->eta();
298  }
299 
300  sc = m_clusterRoadDefiner->defineRoad(ctx,
301  p_roi,
302  clusterRoad,
303  rpcLayerClusters,
304  &m_clusterPatFinder,
305  clusterFitResults,
306  roiEtaMinLow,
307  roiEtaMaxLow,
308  roiEtaMinHigh,
309  roiEtaMaxHigh);
310  if (!sc.isSuccess()) {
311  ATH_MSG_WARNING("Error in clusterRoad definition.");
312  return sc;
313 
314  }
315  if(!clusterRoad.empty()){
316  sc = m_mdtDataPreparator->prepareData(ctx,
317  p_roids,
318  clusterFitResults.back(),
319  clusterRoad.back(),
320  mdtRegion,
321  mdtHits);
322 
323  if (!sc.isSuccess()) {
324  ATH_MSG_WARNING("Error in MDT data preparation.");
325  return sc;
326  }
327 
328  ATH_MSG_DEBUG("nr of MDT (normal) hits=" << mdtHits.size());
329 
330  for(unsigned int i_road = 0; i_road < clusterRoad.size(); i_road++){
331  TrigL2MuonSA::MdtHits mdt_normal;
332  for(unsigned int i_hit = 0; i_hit < mdtHits.size(); i_hit++){
333  unsigned int chamber = mdtHits[i_hit].Chamber;
334 
335  if (chamber >= xAOD::L2MuonParameters::MaxChamber) continue;
336  double Z = mdtHits[i_hit].Z;
337  double R = mdtHits[i_hit].R;
338  double residual = 999999;
339  unsigned int clusterRoadID = 9999;
340  for(unsigned int j_road = 0; j_road < clusterRoad.size(); j_road++){
341  double aw = clusterRoad.at(j_road).aw[chamber][0];
342  double bw = clusterRoad.at(j_road).bw[chamber][0];
343  double tmp_residual;
344  const double ZERO_LIMIT = 1e-4;
345  if( std::abs(aw) < ZERO_LIMIT ){
346  tmp_residual = R-bw;
347  } else {
348  double ia = 1/aw;
349  double iaq = ia*ia;
350  double dz = Z - (R-bw)*ia;
351  tmp_residual = dz/std::sqrt(1.+iaq);
352  }
353  if(std::abs(residual) > std::abs(tmp_residual)){
354  residual = tmp_residual;
355  clusterRoadID = j_road;
356  }
357  }
358  if(clusterRoadID == i_road){
359  mdt_normal.push_back(mdtHits[i_hit]);
360  }
361  }
362  mdtHits_cluster_normal.push_back(mdt_normal);
363  }
364  }
365 
366  return StatusCode::SUCCESS;
367 }
368 
369 // --------------------------------------------------------------------------------
370 // --------------------------------------------------------------------------------
371 
372 StatusCode TrigL2MuonSA::MuFastDataPreparator::prepareData(const EventContext& ctx,
373  const xAOD::MuonRoI* p_roi,
374  const TrigRoiDescriptor* p_roids,
375  const bool insideOut,
376  TrigL2MuonSA::TgcHits& tgcHits,
377  TrigL2MuonSA::MuonRoad& muonRoad,
378  TrigL2MuonSA::MdtRegion& mdtRegion,
379  TrigL2MuonSA::TgcFitResult& tgcFitResult,
380  TrigL2MuonSA::MdtHits& mdtHits,
381  TrigL2MuonSA::CscHits& cscHits,
382  TrigL2MuonSA::StgcHits& stgcHits,
383  TrigL2MuonSA::MmHits& mmHits) const
384 {
385  StatusCode sc = StatusCode::SUCCESS;
386  ATH_MSG_DEBUG("RoI eta/phi=" << p_roi->eta() << "/" << p_roi->phi());
387 
388  if(!insideOut) {
389  sc = m_tgcDataPreparator->prepareData(ctx, p_roi, tgcHits);
390  } else {
391  ATH_MSG_DEBUG("Skip TgcDataPreparator");
392  }
393 
394  if (!sc.isSuccess()) {
395  ATH_MSG_DEBUG("Error in TGC data preparation. Continue using RoI");
396  }
397  ATH_MSG_DEBUG("nr of TGC hits=" << tgcHits.size());
398 
399  sc = m_tgcRoadDefiner->defineRoad(ctx,
400  p_roids,
401  insideOut,
402  tgcHits,
403  muonRoad,
404  tgcFitResult);
405  if (!sc.isSuccess()) {
406  ATH_MSG_WARNING("Error in road definition.");
407  return sc;
408  }
409 
410  sc = m_mdtDataPreparator->prepareData(ctx,
411  p_roids,
412  tgcFitResult,
413  muonRoad,
414  mdtRegion,
415  mdtHits);
416 
417  if (!sc.isSuccess()) {
418  ATH_MSG_WARNING("Error in MDT data preparation.");
419  return sc;
420  }
421  ATH_MSG_DEBUG("nr of MDT (normal) hits=" << mdtHits.size());
422 
423  if(!m_cscDataPreparator.empty()) {
424  sc = m_cscDataPreparator->prepareData(ctx, muonRoad, cscHits);
425  if (!sc.isSuccess()) {
426  ATH_MSG_WARNING("Error in CSC data preparation.");
427  return sc;
428  }
429  ATH_MSG_DEBUG("nr of CSC hits=" << cscHits.size());
430  }
431 
432  if(m_use_stgc && !m_stgcDataPreparator.empty()){
433  sc = m_stgcDataPreparator->prepareData(ctx, p_roids, stgcHits);
434  if (!sc.isSuccess()) {
435  ATH_MSG_WARNING("Error in sTGC data preparation.");
436  return sc;
437  }
438  ATH_MSG_DEBUG("nr of sTGC hits=" << stgcHits.size());
439  }
440 
441  if(m_use_mm && !m_mmDataPreparator.empty()){
442  sc = m_mmDataPreparator->prepareData(ctx, p_roids, mmHits);
443  if (!sc.isSuccess()) {
444  ATH_MSG_WARNING("Error in MM data preparation.");
445  return sc;
446  }
447  ATH_MSG_DEBUG("nr of MM hits=" << mmHits.size());
448  }
449 
450  return StatusCode::SUCCESS;
451 }
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::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
TrigL2MuonSA::MuFastDataPreparator::prepareData
StatusCode prepareData(const EventContext &ctx, 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
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 Mon Sep 29 2025 21:15:10 for ATLAS Offline Software by   doxygen 1.8.18