Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
MdtDataPreparator.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 "MdtDataPreparator.h"
6 
7 #include "AthenaBaseComps/AthMsgStreamMacros.h"
8 #include "Identifier/Identifier.h"
9 #include "Identifier/IdentifierHash.h"
10 #include "MuonReadoutGeometry/MuonDetectorManager.h"
11 #include "MuonReadoutGeometry/MdtReadoutElement.h"
12 
13 #include "MdtRegionDefiner.h"
14 
15 #include "xAODTrigMuon/TrigMuonDefs.h"
16 
17 #include "TrigSteeringEvent/TrigRoiDescriptor.h"
18 
19 #include "MuonReadoutGeometry/MuonStation.h"
20 
21 #include "GeoModelUtilities/GeoGetIds.h"
22 #include "MuonIdHelpers/MdtIdHelper.h"
23 #include <unordered_set>
24 namespace {
25  // the tube number of a tube in a tubeLayer in encoded in the GeoSerialIdentifier (modulo maxNTubesPerLayer)
26  constexpr unsigned int maxNTubesPerLayer = MdtIdHelper::maxNTubesPerLayer;
27 }
28 
29 // --------------------------------------------------------------------------------
30 // --------------------------------------------------------------------------------
31 
32 StatusCode TrigL2MuonSA::MdtDataPreparator::initialize()
33 {
34 
35  // Locate RegionSelector
36  ATH_CHECK( m_regionSelector.retrieve());
37 
38  ATH_CHECK( m_mdtRegionDefiner.retrieve() );
39  ATH_MSG_DEBUG("Retrieved service " << m_mdtRegionDefiner);
40 
41  ATH_CHECK( m_idHelperSvc.retrieve() );
42  ATH_CHECK(m_mdtPrepContainerKey.initialize());
43 
44  if(!m_isPhase2){
45 
46  const MuonGM::MuonDetectorManager* muonDetMgr=nullptr;
47  ATH_CHECK( detStore()->retrieve(muonDetMgr) );
48  ATH_MSG_DEBUG("Retrieved GeoModel from DetectorStore.");
49 
50  if(m_idHelperSvc->mdtIdHelper().stationNameIndex("BMG") != -1){ //if we have BMGs
51 
52  ATH_MSG_INFO("Processing configuration for layouts with BMG chambers.");
53  m_BMGid = m_idHelperSvc->mdtIdHelper().stationNameIndex("BMG");
54  for(int phi=6; phi<8; phi++) { // phi sectors - BMGs are ony in (6 aka 12) and (7 aka 14)
55  for(int eta=1; eta<4; eta++) { // eta sectors - BMGs are in eta 1 to 3
56  for(int side=-1; side<2; side+=2) { // side - both sides have BMGs
57  if( !muonDetMgr->getMuonStation("BMG", side*eta, phi) ) continue;
58  for(int roe=1; roe<=( muonDetMgr->getMuonStation("BMG", side*eta, phi) )->nMuonReadoutElements(); roe++) { // iterate on readout elemets
59  const MuonGM::MdtReadoutElement* mdtRE =
60  dynamic_cast<const MuonGM::MdtReadoutElement*> ( ( muonDetMgr->getMuonStation("BMG", side*eta, phi) )->getMuonReadoutElement(roe) ); // has to be an MDT
61  if(mdtRE) initDeadChannels(mdtRE);
62  }
63  }
64  }
65  }
66  }
67  }
68  return StatusCode::SUCCESS;
69 }
70 
71 // --------------------------------------------------------------------------------
72 // --------------------------------------------------------------------------------
73 
74 StatusCode TrigL2MuonSA::MdtDataPreparator::prepareData(
75  const TrigRoiDescriptor* p_roids,
76  const TrigL2MuonSA::RpcFitResult& rpcFitResult,
77  TrigL2MuonSA::MuonRoad& muonRoad,
78  TrigL2MuonSA::MdtRegion& mdtRegion,
79  TrigL2MuonSA::MdtHits& mdtHits_normal) const
80 {
81  // define regions
82  ATH_CHECK( m_mdtRegionDefiner->getMdtRegions(p_roids, rpcFitResult, muonRoad, mdtRegion) );
83 
84  ATH_CHECK( getMdtHits(p_roids, muonRoad, mdtHits_normal) );
85 
86  return StatusCode::SUCCESS;
87 }
88 
89 // --------------------------------------------------------------------------------
90 // --------------------------------------------------------------------------------
91 
92 StatusCode TrigL2MuonSA::MdtDataPreparator::prepareData(
93  const TrigRoiDescriptor* p_roids,
94  const TrigL2MuonSA::TgcFitResult& tgcFitResult,
95  TrigL2MuonSA::MuonRoad& muonRoad,
96  TrigL2MuonSA::MdtRegion& mdtRegion,
97  TrigL2MuonSA::MdtHits& mdtHits_normal) const
98 {
99  // define regions
100  ATH_CHECK( m_mdtRegionDefiner->getMdtRegions(p_roids, tgcFitResult, muonRoad, mdtRegion) );
101 
102  ATH_CHECK( getMdtHits(p_roids, muonRoad, mdtHits_normal) );
103 
104  return StatusCode::SUCCESS;
105 }
106 
107 
108 // --------------------------------------------------------------------------------
109 // --------------------------------------------------------------------------------
110 
111 StatusCode TrigL2MuonSA::MdtDataPreparator::getMdtHits(
112  const TrigRoiDescriptor* p_roids,
113  TrigL2MuonSA::MuonRoad& muonRoad,
114  TrigL2MuonSA::MdtHits& mdtHits_normal) const
115 {
116 
117  // preload ROBs
118  std::vector<uint32_t> v_robIds;
119  std::vector<IdentifierHash> mdtHashList;
120  const EventContext& ctx = Gaudi::Hive::currentContext();
121 
122  if (m_use_RoIBasedDataAccess) {
123 
124  ATH_MSG_DEBUG("Use RoI based data access");
125 
126  const IRoiDescriptor* iroi = (IRoiDescriptor*) p_roids;
127 
128  m_regionSelector->lookup( ctx )->HashIDList(*iroi, mdtHashList);
129  ATH_MSG_DEBUG("mdtHashList.size()=" << mdtHashList.size());
130 
131  m_regionSelector->lookup( ctx )->ROBIDList(*iroi, v_robIds);
132 
133  } else {
134 
135  ATH_MSG_DEBUG("Use full data access");
136 
137  TrigRoiDescriptor fullscan_roi( true );
138  m_regionSelector->lookup( ctx )->HashIDList(fullscan_roi, mdtHashList);
139  ATH_MSG_DEBUG("mdtHashList.size()=" << mdtHashList.size());
140 
141  m_regionSelector->lookup( ctx )->ROBIDList(fullscan_roi, v_robIds);
142  }
143 
144  ATH_CHECK( collectMdtHitsFromPrepData(ctx, mdtHashList, mdtHits_normal, muonRoad) );
145 
146  return StatusCode::SUCCESS;
147 }
148 
149 // --------------------------------------------------------------------------------
150 // --------------------------------------------------------------------------------
151 
152 StatusCode TrigL2MuonSA::MdtDataPreparator::collectMdtHitsFromPrepData(const EventContext& ctx,
153  const std::vector<IdentifierHash>& v_idHash,
154  TrigL2MuonSA::MdtHits& mdtHits,
155  const TrigL2MuonSA::MuonRoad& muonRoad) const
156 {
157 
158  // Get MDT container
159  if (v_idHash.empty()) {
160  ATH_MSG_DEBUG("Hash list is empty");
161  return StatusCode::SUCCESS;
162  }
163  SG::ReadHandle mdtPrds{m_mdtPrepContainerKey, ctx};
164  ATH_CHECK(mdtPrds.isPresent());
165 
166  // Get MDT collections
168  std::vector<const Muon::MdtPrepDataCollection*> mdtCols{};
169  mdtCols.reserve(v_idHash.size());
170 
171  for(const IdentifierHash& id : v_idHash) {
172 
173  auto MDTcoll = mdtPrds->indexFindPtr(id);
174 
175  if( MDTcoll == nullptr ) {
176  ATH_MSG_DEBUG("MDT prep data collection not found in Hash ID" << (int)id);
177  continue;
178  }
179 
180  if( MDTcoll->size() == 0 ) {
181  ATH_MSG_DEBUG("MDT prep data collection is empty in Hash ID" << (int)id);
182  continue;
183  }
184 
185  mdtCols.push_back(MDTcoll);
186 
187  ATH_MSG_DEBUG("Selected Mdt Collection: "
188  << m_idHelperSvc->toStringChamber(MDTcoll->identify())
189  << " with size " << MDTcoll->size()
190  << "in Hash ID" << (int)id);
191  }
192 
193  for( const Muon::MdtPrepDataCollection* mdtCol : mdtCols ){
194 
195  mdtHits.reserve( mdtHits.size() + mdtCol->size() );
196  for( const Muon::MdtPrepData* mdt : *mdtCol ) {
197 
198  const MuonGM::MdtReadoutElement* mdtReadout = mdt->detectorElement();
199 
200  const MuonGM::MuonStation* muonStation = mdtReadout->parentMuonStation();
201 
202  int StationPhi = mdtReadout->getStationPhi();
203  int StationEta = mdtReadout->getStationEta();
204  int MultiLayer = mdtReadout->getMultilayer();
205  double cXmid{0.}, cYmid{0.}, cAmid{0.}, cPhip{0.};
206 
207  Identifier id = mdt->identify();
208  int adc = mdt->adc();
209  int drift = mdt->tdc();
210 
211  int TubeLayers = mdtReadout->getNLayers();
212  int TubeLayer = m_idHelperSvc->mdtIdHelper().tubeLayer(id);
213  if(TubeLayer > TubeLayers) TubeLayer -= TubeLayers;
214  int Layer = (MultiLayer-1)*TubeLayers + TubeLayer;
215  int Tube = m_idHelperSvc->mdtIdHelper().tube(id);
216 
217  double OrtoRadialPos = mdtReadout->getStationS();
218  std::string chamberType = mdtReadout->getStationType();
219  char st = chamberType[1];
220 
221  int chamber = 0;
222  if (chamberType[0]=='E') {
224  if (st=='I') chamber = xAOD::L2MuonParameters::Chamber::EndcapInner;
225  if (st=='M') chamber = xAOD::L2MuonParameters::Chamber::EndcapMiddle;
226  if (st=='O') chamber = xAOD::L2MuonParameters::Chamber::EndcapOuter;
227  if (st=='E') chamber = xAOD::L2MuonParameters::Chamber::EndcapExtra;
228  }
229  else {
231  if (st=='I') chamber = xAOD::L2MuonParameters::Chamber::BarrelInner;
232  if (st=='M') chamber = xAOD::L2MuonParameters::Chamber::BarrelMiddle;
233  if (st=='O') chamber = xAOD::L2MuonParameters::Chamber::BarrelOuter;
234  if (st=='E' && chamberType[2]=='E') chamber = xAOD::L2MuonParameters::Chamber::BEE;
235  if (st=='M' && chamberType[2]=='E') chamber = xAOD::L2MuonParameters::Chamber::BME;
236  if (st=='M' && chamberType[2]=='G') chamber = xAOD::L2MuonParameters::Chamber::Backup;
237  }
238 
239  double R = -99999., Z = -99999.;
240  if(m_idHelperSvc->mdtIdHelper().stationName(id) == m_BMGid && m_DeadChannels.count(id)) {
241  ATH_MSG_DEBUG("Skipping tube with identifier " << m_idHelperSvc->toString(id) );
242  continue;
243  }
244  R = mdtReadout->center(TubeLayer, Tube).perp();
245  Z = mdtReadout->center(TubeLayer, Tube).z();
246 
247  Amg::Transform3D trans = muonStation->getNominalAmdbLRSToGlobal();
248  if(muonStation->endcap()==0){
249  cXmid = (trans.translation()).z();
250  double halfRadialThicknessOfMultilayer = muonStation->RsizeMdtStation()/2.;
251  cYmid = ((trans.translation()).perp()+halfRadialThicknessOfMultilayer);
252  }
253  else{
254  cXmid = (trans.translation()).perp();
255  double halfZThicknessOfMultilayer = muonStation->ZsizeMdtStation()/2.;
256  cYmid = (trans.translation()).z();
257  if(cYmid>0) cYmid += halfZThicknessOfMultilayer;
258  else cYmid -= halfZThicknessOfMultilayer;
259  }
260  cPhip = (trans.translation()).phi();
261 
262  double dphi = 0;
263  double cphi = muonRoad.phi[chamber][0];
264  if( cPhip*cphi>0 ) {
265  dphi = std::abs(cPhip - cphi);
266  }
267  else {
268  if(std::abs(cphi) > M_PI/2.) {
269  double phi1 = (cPhip>0.)? cPhip-M_PI : cPhip+M_PI;
270  double phi2 = (cphi >0.)? cphi -M_PI : cphi +M_PI;
271  dphi = std::abs(phi1) + std::abs(phi2);
272  }
273  else {
274  dphi = std::abs(cPhip) + std::abs(cphi);
275  }
276  }
277 
278  if(muonStation->endcap()==1) R = R *std::hypot(1, std::tan(dphi));
279 
280  Amg::Vector3D OrigOfMdtInAmdbFrame = muonStation->getBlineFixedPointInAmdbLRS() ;
281  double Rmin =(trans*OrigOfMdtInAmdbFrame).perp();
282 
283  float cInCo = 1./std::cos(std::abs(std::atan(OrtoRadialPos/Rmin)));
284  float cPhi0 = cPhip - std::atan(OrtoRadialPos/Rmin);
285  if(cPhi0 > M_PI) cPhip -= 2*M_PI;
286  if(cPhip<0. && (std::abs(M_PI+cPhip) < 0.05) ) cPhip = M_PI;
287 
288  ATH_MSG_DEBUG(" ...MDT hit Z/R/chamber/MultiLater/TubeLayer/Tube/Layer/adc/tdc = "
289  << Z << "/" << R << "/" << chamber << "/" << MultiLayer << "/" << TubeLayer << "/"
290  << Tube << "/" << Layer << "/" << adc << "/" << drift);
291 
292  // no residual check for the moment
293  // (residual check at pattern finder)
294  if(Layer!=0 && Tube !=0) {
295 
296  // create the new digit
297  TrigL2MuonSA::MdtHitData tmp;
298  tmp.name = m_idHelperSvc->mdtIdHelper().stationName(id);
299  tmp.StationEta = StationEta;
300  tmp.StationPhi = StationPhi;
301  tmp.Multilayer = MultiLayer;
302  tmp.Layer = Layer - 1;
303  tmp.TubeLayer = TubeLayer;
304  tmp.Tube = Tube;
305  tmp.cYmid = cYmid;
306  tmp.cXmid = cXmid;
307  tmp.cAmid = cAmid;
308  tmp.cPhip = cPhip;
309  tmp.cInCo = cInCo;
310  tmp.cPhi0 = cPhi0;
311  for(unsigned int i=0; i<4; i++) { tmp.cType[i] = chamberType[i]; }
312  tmp.Z = Z;
313  tmp.R = R;
314  tmp.DriftTime = drift;
315  tmp.Adc = adc;
316  tmp.LeadingCoarseTime = (drift>>5) & 0xfff;
317  tmp.LeadingFineTime = drift & 0x1f;
318  tmp.Chamber = chamber;
319  tmp.readEle = mdtReadout;
320  tmp.Id = id;
321 
322  mdtHits.push_back(std::move(tmp));
323  }
324  } // end of MdtPrepDataCollection loop
325  } // end of MdtPrepDataCollection vector loop
326 
327  return StatusCode::SUCCESS;
328 }
329 
330 // --------------------------------------------------------------------------------
331 // --------------------------------------------------------------------------------
332 
333 void TrigL2MuonSA::MdtDataPreparator::initDeadChannels(const MuonGM::MdtReadoutElement* mydetEl) {
334  PVConstLink cv = mydetEl->getMaterialGeom(); // it is "Multilayer"
335  int nGrandchildren = cv->getNChildVols();
336  if(nGrandchildren <= 0) return;
337 
338  std::vector<int> tubes;
339  geoGetIds ([&] (int id) { tubes.push_back (id); }, cv);
340  std::sort (tubes.begin(), tubes.end());
341 
342  Identifier detElId = mydetEl->identify();
343 
344  int name = m_idHelperSvc->mdtIdHelper().stationName(detElId);
345  int eta = m_idHelperSvc->mdtIdHelper().stationEta(detElId);
346  int phi = m_idHelperSvc->mdtIdHelper().stationPhi(detElId);
347  int ml = m_idHelperSvc->mdtIdHelper().multilayer(detElId);
348 
349  std::vector<int>::iterator it = tubes.begin();
350  for(int layer = 1; layer <= mydetEl->getNLayers(); layer++){
351  for(int tube = 1; tube <= mydetEl->getNtubesperlayer(); tube++){
352  int want_id = layer*maxNTubesPerLayer + tube;
353  if (it != tubes.end() && *it == want_id) {
354  ++it;
355  }
356  else {
357  it = std::lower_bound (tubes.begin(), tubes.end(), want_id);
358  if (it != tubes.end() && *it == want_id) {
359  ++it;
360  }
361  else {
362  Identifier deadTubeId = m_idHelperSvc->mdtIdHelper().channelID( name, eta, phi, ml, layer, tube );
363  m_DeadChannels.insert(deadTubeId);
364  ATH_MSG_VERBOSE("adding dead tube (" << tube << "), layer(" << layer
365  << "), phi(" << phi << "), eta(" << eta << "), name(" << name
366  << "), multilayerId(" << ml << ") and identifier " << deadTubeId <<" .");
367  }
368  }
369  }
370  }
371 }
372 
373 // --------------------------------------------------------------------------------
374 // --------------------------------------------------------------------------------
MdtRegionDefiner.h
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
MdtReadoutElement.h
MuonGM::MdtReadoutElement::getNLayers
int getNLayers() const
Returns the number of tube layers inside the multilayer.
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
MuonGM::MuonReadoutElement::getStationS
double getStationS() const
Seems to be exclusively used by the MDTs --> Move it to MdtReadoutElement.
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:202
AthMsgStreamMacros.h
MuonGM::MdtReadoutElement::center
virtual const Amg::Vector3D & center(const Identifier &) const override final
Return the center of the surface associated with this identifier In the case of silicon it returns th...
perp
Scalar perp() const
perp method - perpenticular length
Definition: AmgMatrixBasePlugin.h:44
TrigL2MuonSA::RpcFitResult
Definition: RpcFitResult.h:14
calibdata.chamber
chamber
Definition: calibdata.py:32
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
TrigL2MuonSA::MdtDataPreparator::prepareData
StatusCode prepareData(const TrigRoiDescriptor *p_roids, const TrigL2MuonSA::RpcFitResult &rpcFitResult, TrigL2MuonSA::MuonRoad &muonRoad, TrigL2MuonSA::MdtRegion &mdtRegion, TrigL2MuonSA::MdtHits &mdtHits_normal) const
Definition: MdtDataPreparator.cxx:74
xAOD::L2MuonParameters::BEE
@ BEE
BEE measurement point.
Definition: TrigMuonDefs.h:24
xAOD::L2MuonParameters::EndcapExtra
@ EndcapExtra
Extra station in the endcap spectrometer.
Definition: TrigMuonDefs.h:22
TrigL2MuonSA::TgcFitResult
Definition: TgcFitResult.h:11
MdtDataPreparator.h
TrigL2MuonSA::MdtHits
std::vector< MdtHitData > MdtHits
Definition: MdtData.h:57
TrigL2MuonSA::MdtHitData
Definition: MdtData.h:18
skel.it
it
Definition: skel.GENtoEVGEN.py:407
xAOD::L2MuonParameters::BME
@ BME
BME measurement point.
Definition: TrigMuonDefs.h:25
M_PI
#define M_PI
Definition: ActiveFraction.h:11
TrigL2MuonSA::MdtDataPreparator::m_mdtRegionDefiner
ToolHandle< MdtRegionDefiner > m_mdtRegionDefiner
Definition: MdtDataPreparator.h:89
TrigL2MuonSA::MdtDataPreparator::m_isPhase2
Gaudi::Property< bool > m_isPhase2
Definition: MdtDataPreparator.h:96
xAOD::L2MuonParameters::BarrelInner
@ BarrelInner
Inner station in the barrel spectrometer.
Definition: TrigMuonDefs.h:16
TrigRoiDescriptor
nope - should be used for standalone also, perhaps need to protect the class def bits #ifndef XAOD_AN...
Definition: TrigRoiDescriptor.h:56
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
MuonGM::MuonStation::endcap
bool endcap() const
Definition: MuonStation.cxx:384
GeoGetIds.h
Visitor to collect all IDs under a GeoModel node.
TrigL2MuonSA::MdtDataPreparator::m_mdtPrepContainerKey
SG::ReadHandleKey< Muon::MdtPrepDataContainer > m_mdtPrepContainerKey
Definition: MdtDataPreparator.h:93
python.RingerConstants.Layer
Layer
Definition: RingerConstants.py:42
Muon::TubeLayer
HedgehogBoard::TubeLayer TubeLayer
Definition: HedgehogBoard.cxx:27
TrigL2MuonSA::MdtRegion
Definition: MdtRegion.h:14
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
TrigL2MuonSA::MdtDataPreparator::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MdtDataPreparator.h:83
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
TRT::Hit::side
@ side
Definition: HitInfo.h:83
TrigL2MuonSA::MdtDataPreparator::m_regionSelector
ToolHandle< IRegSelTool > m_regionSelector
Definition: MdtDataPreparator.h:86
MuonGM::MdtReadoutElement
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MdtReadoutElement.h:51
lumiFormat.i
int i
Definition: lumiFormat.py:85
TrigL2MuonSA::MuonRoad
Definition: MuonRoad.h:20
z
#define z
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
IRoiDescriptor
Describes the API of the Region of Ineterest geometry.
Definition: IRoiDescriptor.h:23
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
MuonGM::MuonReadoutElement::parentMuonStation
const MuonStation * parentMuonStation() const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonReadoutElement.cxx:136
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
MuonGM::MuonStation
Definition: MuonStation.h:51
MdtIdHelper.h
MuonGM::MuonStation::getNominalAmdbLRSToGlobal
const Amg::Transform3D & getNominalAmdbLRSToGlobal() const
Definition: MuonStation.h:195
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
MuonGM::MdtReadoutElement::getMultilayer
int getMultilayer() const
Returns the multilayer represented by the readout element.
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
Muon::MuonPrepDataCollection
Template to hold collections of MuonPrepRawData objects.
Definition: MuonPrepDataCollection.h:46
TrigL2MuonSA::MdtDataPreparator::initialize
virtual StatusCode initialize() override
Definition: MdtDataPreparator.cxx:32
TrigL2MuonSA::MdtDataPreparator::initDeadChannels
void initDeadChannels(const MuonGM::MdtReadoutElement *mydetEl)
Definition: MdtDataPreparator.cxx:333
TrigL2MuonSA::MuonRoad::phi
double phi[N_STATION][N_SECTOR]
Definition: MuonRoad.h:83
xAOD::L2MuonParameters::EndcapMiddle
@ EndcapMiddle
Middle station in the endcap spectrometer.
Definition: TrigMuonDefs.h:20
TrigL2MuonSA::MdtDataPreparator::collectMdtHitsFromPrepData
StatusCode collectMdtHitsFromPrepData(const EventContext &ctx, const std::vector< IdentifierHash > &v_idHash, TrigL2MuonSA::MdtHits &mdtHits, const TrigL2MuonSA::MuonRoad &muonRoad) const
Definition: MdtDataPreparator.cxx:152
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
IdentifierHash.h
TrigL2MuonSA::MdtDataPreparator::m_BMGid
int m_BMGid
Definition: MdtDataPreparator.h:99
Muon::MdtPrepData
Class to represent measurements from the Monitored Drift Tubes.
Definition: MdtPrepData.h:33
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
MuonDetectorManager.h
TrigMuonDefs.h
MuonGM::MuonDetectorManager::getMuonStation
const MuonStation * getMuonStation(const std::string &stName, int eta, int phi) const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:137
geoGetIds
void geoGetIds(FUNCTION f, const GeoGraphNode *node, int depthLimit=1)
Template helper for running the visitor.
Definition: GeoGetIds.h:82
MuonGM::MuonStation::RsizeMdtStation
double RsizeMdtStation() const
Definition: MuonStation.cxx:296
TrigL2MuonSA::MdtDataPreparator::getMdtHits
StatusCode getMdtHits(const TrigRoiDescriptor *p_roids, TrigL2MuonSA::MuonRoad &muonRoad, TrigL2MuonSA::MdtHits &mdtHits_normal) const
Definition: MdtDataPreparator.cxx:111
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:50
xAOD::L2MuonParameters::EndcapInner
@ EndcapInner
Inner station in the endcap spectrometer.
Definition: TrigMuonDefs.h:19
xAOD::L2MuonParameters::BarrelOuter
@ BarrelOuter
Outer station in the barrel spectrometer.
Definition: TrigMuonDefs.h:18
MuonGM::MuonReadoutElement::getStationType
std::string getStationType() const
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:189
MuonGM::MuonReadoutElement::identify
Identifier identify() const override final
Returns the ATLAS Identifier of the MuonReadOutElement.
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:184
Rmin
double Rmin
Definition: LArDetectorConstructionTBEC.cxx:56
TrigRoiDescriptor.h
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
MdtIdHelper::maxNTubesPerLayer
static constexpr int maxNTubesPerLayer
The maxNTubesPerLayer represents the absolute maximum of tubes which are built into a single multilay...
Definition: MdtIdHelper.h:68
MuonGM::MuonStation::getBlineFixedPointInAmdbLRS
const Amg::Vector3D & getBlineFixedPointInAmdbLRS() const
Definition: MuonStation.cxx:81
MuonGM::MdtReadoutElement::getNtubesperlayer
int getNtubesperlayer() const
Returns the number of tubes in each tube layer.
MuonStation.h
xAOD::L2MuonParameters::Backup
@ Backup
Backup.
Definition: TrigMuonDefs.h:26
MuonGM::MuonStation::ZsizeMdtStation
double ZsizeMdtStation() const
Definition: MuonStation.cxx:333
xAOD::L2MuonParameters::BarrelMiddle
@ BarrelMiddle
Middle station in the barrel spectrometer.
Definition: TrigMuonDefs.h:17
calibdata.tube
tube
Definition: calibdata.py:31
xAOD::L2MuonParameters::EndcapOuter
@ EndcapOuter
Outer station in the endcap spectrometer.
Definition: TrigMuonDefs.h:21
Muon::HedgehogBoard::TubeLayer::tube
uint8_t tube
Tube number [1- 24/numTubeLayers()].
Definition: HedgehogBoard.h:59
MuonGM::MuonReadoutElement::getStationPhi
int getStationPhi() const
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:194
MuonGM::MuonReadoutElement::getStationEta
int getStationEta() const
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:193
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Wed Apr 16 2025 21:14:39 for ATLAS Offline Software by   doxygen 1.8.18