ATLAS Offline Software
MdtDataPreparator.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "MdtDataPreparator.h"
6 
7 #include "Identifier/IdentifierHash.h"
8 #include "MuonReadoutGeometry/MuonDetectorManager.h"
9 #include "MuonReadoutGeometry/MdtReadoutElement.h"
10 
11 #include "MdtRegionDefiner.h"
12 
13 #include "xAODTrigMuon/TrigMuonDefs.h"
14 
15 #include "TrigSteeringEvent/TrigRoiDescriptor.h"
16 
17 #include "MuonReadoutGeometry/MuonStation.h"
18 
19 #include "GeoModelUtilities/GeoGetIds.h"
20 #include "MuonIdHelpers/MdtIdHelper.h"
21 namespace {
22  // the tube number of a tube in a tubeLayer in encoded in the GeoSerialIdentifier (modulo maxNTubesPerLayer)
23  constexpr unsigned int maxNTubesPerLayer = MdtIdHelper::maxNTubesPerLayer;
24 }
25 
26 // --------------------------------------------------------------------------------
27 // --------------------------------------------------------------------------------
28 
29 TrigL2MuonSA::MdtDataPreparator::MdtDataPreparator(const std::string& type,
30  const std::string& name,
31  const IInterface* parent):
32  AthAlgTool(type,name,parent),
33  m_regionSelector("RegSelTool/RegSelTool_MDT",this),
34  m_BMGpresent(false),
35  m_BMGid(-1)
36 {
37  declareProperty("RegSel_MDT", m_regionSelector);
38 }
39 
40 // --------------------------------------------------------------------------------
41 // --------------------------------------------------------------------------------
42 
43 StatusCode TrigL2MuonSA::MdtDataPreparator::initialize()
44 {
45 
46  // Locate RegionSelector
47  ATH_CHECK( m_regionSelector.retrieve());
48 
49  ATH_CHECK( m_mdtRegionDefiner.retrieve() );
50  ATH_MSG_DEBUG("Retrieved service " << m_mdtRegionDefiner);
51 
52  ATH_CHECK(m_muDetMgrKey.initialize());
53 
54  const MuonGM::MuonDetectorManager* muonDetMgr=nullptr;
55  ATH_CHECK( detStore()->retrieve(muonDetMgr) );
56  ATH_MSG_DEBUG("Retrieved GeoModel from DetectorStore.");
57  ATH_CHECK( m_idHelperSvc.retrieve() );
58 
59  m_BMGpresent = m_idHelperSvc->mdtIdHelper().stationNameIndex("BMG") != -1;
60  if(m_BMGpresent){
61  ATH_MSG_INFO("Processing configuration for layouts with BMG chambers.");
62  m_BMGid = m_idHelperSvc->mdtIdHelper().stationNameIndex("BMG");
63  for(int phi=6; phi<8; phi++) { // phi sectors - BMGs are ony in (6 aka 12) and (7 aka 14)
64  for(int eta=1; eta<4; eta++) { // eta sectors - BMGs are in eta 1 to 3
65  for(int side=-1; side<2; side+=2) { // side - both sides have BMGs
66  if( !muonDetMgr->getMuonStation("BMG", side*eta, phi) ) continue;
67  for(int roe=1; roe<=( muonDetMgr->getMuonStation("BMG", side*eta, phi) )->nMuonReadoutElements(); roe++) { // iterate on readout elemets
68  const MuonGM::MdtReadoutElement* mdtRE =
69  dynamic_cast<const MuonGM::MdtReadoutElement*> ( ( muonDetMgr->getMuonStation("BMG", side*eta, phi) )->getMuonReadoutElement(roe) ); // has to be an MDT
70  if(mdtRE) initDeadChannels(mdtRE);
71  }
72  }
73  }
74  }
75  }
76 
77  ATH_CHECK(m_mdtPrepContainerKey.initialize());
78 
79  return StatusCode::SUCCESS;
80 }
81 
82 // --------------------------------------------------------------------------------
83 // --------------------------------------------------------------------------------
84 
85 StatusCode TrigL2MuonSA::MdtDataPreparator::prepareData(const TrigRoiDescriptor* p_roids,
86  const TrigL2MuonSA::RpcFitResult& rpcFitResult,
87  TrigL2MuonSA::MuonRoad& muonRoad,
88  TrigL2MuonSA::MdtRegion& mdtRegion,
89  TrigL2MuonSA::MdtHits& mdtHits_normal) const
90 {
91  // define regions
92  ATH_CHECK( m_mdtRegionDefiner->getMdtRegions(p_roids, rpcFitResult, muonRoad, mdtRegion) );
93 
94  ATH_CHECK( getMdtHits(p_roids, muonRoad, mdtHits_normal) );
95 
96  return StatusCode::SUCCESS;
97 }
98 
99 // --------------------------------------------------------------------------------
100 // --------------------------------------------------------------------------------
101 
102 StatusCode TrigL2MuonSA::MdtDataPreparator::prepareData(const TrigRoiDescriptor* p_roids,
103  const TrigL2MuonSA::TgcFitResult& tgcFitResult,
104  TrigL2MuonSA::MuonRoad& muonRoad,
105  TrigL2MuonSA::MdtRegion& mdtRegion,
106  TrigL2MuonSA::MdtHits& mdtHits_normal) const
107 {
108  // define regions
109  ATH_CHECK( m_mdtRegionDefiner->getMdtRegions(p_roids, tgcFitResult, muonRoad, mdtRegion) );
110 
111  ATH_CHECK( getMdtHits(p_roids, muonRoad, mdtHits_normal) );
112 
113  return StatusCode::SUCCESS;
114 }
115 
116 
117 // --------------------------------------------------------------------------------
118 // --------------------------------------------------------------------------------
119 
120 StatusCode TrigL2MuonSA::MdtDataPreparator::getMdtHits(const TrigRoiDescriptor* p_roids,
121  TrigL2MuonSA::MuonRoad& muonRoad,
122  TrigL2MuonSA::MdtHits& mdtHits_normal) const
123 {
124  SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey};
125  const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
126 
127  // preload ROBs
128  std::vector<uint32_t> v_robIds;
129  std::vector<IdentifierHash> mdtHashList;
130  if (m_use_RoIBasedDataAccess) {
131 
132  ATH_MSG_DEBUG("Use RoI based data access");
133 
134  const IRoiDescriptor* iroi = (IRoiDescriptor*) p_roids;
135 
136  m_regionSelector->HashIDList(*iroi, mdtHashList);
137  ATH_MSG_DEBUG("mdtHashList.size()=" << mdtHashList.size());
138 
139  m_regionSelector->ROBIDList(*iroi, v_robIds);
140 
141  } else {
142 
143  ATH_MSG_DEBUG("Use full data access");
144 
145  TrigRoiDescriptor fullscan_roi( true );
146  m_regionSelector->HashIDList(fullscan_roi, mdtHashList);
147  ATH_MSG_DEBUG("mdtHashList.size()=" << mdtHashList.size());
148 
149  m_regionSelector->ROBIDList(fullscan_roi, v_robIds);
150  }
151 
152  ATH_CHECK( collectMdtHitsFromPrepData(mdtHashList, mdtHits_normal, muonRoad, muDetMgr) );
153 
154  return StatusCode::SUCCESS;
155 }
156 
157 // --------------------------------------------------------------------------------
158 // --------------------------------------------------------------------------------
159 
160 StatusCode TrigL2MuonSA::MdtDataPreparator::collectMdtHitsFromPrepData(const std::vector<IdentifierHash>& v_idHash,
161  TrigL2MuonSA::MdtHits& mdtHits,
162  const TrigL2MuonSA::MuonRoad& muonRoad,
163  const MuonGM::MuonDetectorManager* muDetMgr) const
164 {
165 
166  // Get MDT container
167  if (v_idHash.empty()) {
168  ATH_MSG_DEBUG("Hash list is empty");
169  return StatusCode::SUCCESS;
170  }
171 
172  const Muon::MdtPrepDataContainer* mdtPrds;
173  auto mdtPrepContainerHandle = SG::makeHandle(m_mdtPrepContainerKey);
174  mdtPrds = mdtPrepContainerHandle.cptr();
175  if (!mdtPrepContainerHandle.isValid()) {
176  ATH_MSG_ERROR(" Cannot retrieve MDT PRD Container " << m_mdtPrepContainerKey.key());
177  return StatusCode::FAILURE;
178  }
179 
180  // Get MDT collections
182  std::vector<const Muon::MdtPrepDataCollection*> mdtCols;
183 
184  for(const IdentifierHash& id : v_idHash) {
185 
186  auto MDTcoll = mdtPrds->indexFindPtr(id);
187 
188  if( MDTcoll == nullptr ) {
189  ATH_MSG_DEBUG("MDT prep data collection not found in Hash ID" << (int)id);
190  continue;
191  }
192 
193  if( MDTcoll->size() == 0 ) {
194  ATH_MSG_DEBUG("MDT prep data collection is empty in Hash ID" << (int)id);
195  continue;
196  }
197 
198  mdtCols.push_back(MDTcoll);
199 
200  ATH_MSG_DEBUG("Selected Mdt Collection: "
201  << m_idHelperSvc->mdtIdHelper().show_to_string(MDTcoll->identify())
202  << " with size " << MDTcoll->size()
203  << "in Hash ID" << (int)id);
204  }
205 
206  for( const Muon::MdtPrepDataCollection* mdtCol : mdtCols ){
207 
208  mdtHits.reserve( mdtHits.size() + mdtCol->size() );
209  for( const Muon::MdtPrepData* mdt : *mdtCol ) {
210 
211  const MuonGM::MdtReadoutElement* mdtReadout = mdt->detectorElement();
212  if (!mdtReadout) continue;
213 
214  const MuonGM::MuonStation* muonStation = mdtReadout->parentMuonStation();
215 
216  int StationPhi = mdtReadout->getStationPhi();
217  int StationEta = mdtReadout->getStationEta();
218  int MultiLayer = mdtReadout->getMultilayer();
219  double cXmid;
220  double cYmid;
221  double cAmid = 0;
222  double cPhip;
223 
224  Identifier id = mdt->identify();
225  int adc = mdt->adc();
226  int drift = mdt->tdc();
227 
228  int TubeLayers = mdtReadout->getNLayers();
229  int TubeLayer = m_idHelperSvc->mdtIdHelper().tubeLayer(id);
230  if(TubeLayer > TubeLayers) TubeLayer -= TubeLayers;
231  int Layer = (MultiLayer-1)*TubeLayers + TubeLayer;
232  int Tube = m_idHelperSvc->mdtIdHelper().tube(id);
233 
234  double OrtoRadialPos = mdtReadout->getStationS();
235  std::string chamberType = mdtReadout->getStationType();
236  char st = chamberType[1];
237 
238  int chamber = 0;
239  if (chamberType[0]=='E') {
241  if (st=='I') chamber = xAOD::L2MuonParameters::Chamber::EndcapInner;
242  if (st=='M') chamber = xAOD::L2MuonParameters::Chamber::EndcapMiddle;
243  if (st=='O') chamber = xAOD::L2MuonParameters::Chamber::EndcapOuter;
244  if (st=='E') chamber = xAOD::L2MuonParameters::Chamber::EndcapExtra;
245  } else {
247  if (st=='I') chamber = xAOD::L2MuonParameters::Chamber::BarrelInner;
248  if (st=='M') chamber = xAOD::L2MuonParameters::Chamber::BarrelMiddle;
249  if (st=='O') chamber = xAOD::L2MuonParameters::Chamber::BarrelOuter;
250  if (st=='E' && chamberType[2]=='E') chamber = xAOD::L2MuonParameters::Chamber::BEE;
251  if (st=='M' && chamberType[2]=='E') chamber = xAOD::L2MuonParameters::Chamber::BME;
252  if (st=='M' && chamberType[2]=='G') chamber = xAOD::L2MuonParameters::Chamber::Backup;
253  }
254 
255  double R = -99999., Z = -99999.;
256  if(m_BMGpresent && m_idHelperSvc->mdtIdHelper().stationName(id) == m_BMGid ) {
257  std::map<Identifier, std::vector<Identifier> >::const_iterator myIt = m_DeadChannels.find( muDetMgr->getMdtReadoutElement(id)->identify() );
258  if( myIt != m_DeadChannels.end() ){
259  if( std::find( (myIt->second).begin(), (myIt->second).end(), id) != (myIt->second).end() ) {
260  ATH_MSG_DEBUG("Skipping tube with identifier " << m_idHelperSvc->mdtIdHelper().show_to_string(id) );
261  continue;
262  }
263  }
264  }
265  R = mdtReadout->center(TubeLayer, Tube).perp();
266  Z = mdtReadout->center(TubeLayer, Tube).z();
267 
268  Amg::Transform3D trans = muonStation->getNominalAmdbLRSToGlobal();
269  if(muonStation->endcap()==0){
270  cXmid = (trans.translation()).z();
271  double halfRadialThicknessOfMultilayer = muonStation->RsizeMdtStation()/2.;
272  cYmid = ((trans.translation()).perp()+halfRadialThicknessOfMultilayer);
273  }
274  else{
275  cXmid = (trans.translation()).perp();
276  double halfZThicknessOfMultilayer = muonStation->ZsizeMdtStation()/2.;
277  cYmid = (trans.translation()).z();
278  if(cYmid>0) cYmid += halfZThicknessOfMultilayer;
279  else cYmid -= halfZThicknessOfMultilayer;
280  }
281  cPhip = (trans.translation()).phi();
282 
283  double dphi = 0;
284  double cphi = muonRoad.phi[chamber][0];
285  if( cPhip*cphi>0 ) {
286  dphi = std::abs(cPhip - cphi);
287  } else {
288  if(std::abs(cphi) > M_PI/2.) {
289  double phi1 = (cPhip>0.)? cPhip-M_PI : cPhip+M_PI;
290  double phi2 = (cphi >0.)? cphi -M_PI : cphi +M_PI;
291  dphi = std::abs(phi1) + std::abs(phi2);
292  }
293  else {
294  dphi = std::abs(cPhip) + std::abs(cphi);
295  }
296  }
297 
298  if(muonStation->endcap()==1)
299  R = R *std::hypot(1, std::tan(dphi));
300 
301  Amg::Vector3D OrigOfMdtInAmdbFrame = muonStation->getBlineFixedPointInAmdbLRS() ;
302  double Rmin =(trans*OrigOfMdtInAmdbFrame).perp();
303 
304  float cInCo = 1./std::cos(std::abs(std::atan(OrtoRadialPos/Rmin)));
305  float cPhi0 = cPhip - std::atan(OrtoRadialPos/Rmin);
306  if(cPhi0 > M_PI) cPhip -= 2*M_PI;
307  if(cPhip<0. && (std::abs(M_PI+cPhip) < 0.05) ) cPhip = M_PI;
308 
309  ATH_MSG_DEBUG(" ...MDT hit Z/R/chamber/MultiLater/TubeLayer/Tube/Layer/adc/tdc = "
310  << Z << "/" << R << "/" << chamber << "/" << MultiLayer << "/" << TubeLayer << "/"
311  << Tube << "/" << Layer << "/" << adc << "/" << drift);
312 
313  // no residual check for the moment
314  // (residual check at pattern finder)
315  if(Layer!=0 && Tube !=0) {
316 
317  // create the new digit
318  TrigL2MuonSA::MdtHitData tmp;
319  tmp.name = m_idHelperSvc->mdtIdHelper().stationName(id);
320  tmp.StationEta = StationEta;
321  tmp.StationPhi = StationPhi;
322  tmp.Multilayer = MultiLayer;
323  tmp.Layer = Layer - 1;
324  tmp.TubeLayer = TubeLayer;
325  tmp.Tube = Tube;
326  tmp.cYmid = cYmid;
327  tmp.cXmid = cXmid;
328  tmp.cAmid = cAmid;
329  tmp.cPhip = cPhip;
330  tmp.cInCo = cInCo;
331  tmp.cPhi0 = cPhi0;
332  for(unsigned int i=0; i<4; i++) { tmp.cType[i] = chamberType[i]; }
333  tmp.Z = Z;
334  tmp.R = R;
335  tmp.DriftTime = drift;
336  tmp.Adc = adc;
337  tmp.LeadingCoarseTime = (drift>>5) & 0xfff;
338  tmp.LeadingFineTime = drift & 0x1f;
339  tmp.Chamber = chamber;
340  tmp.readEle = mdtReadout;
341  tmp.Id = id;
342 
343  mdtHits.push_back(std::move(tmp));
344  }
345  } // end of MdtPrepDataCollection loop
346  } // end of MdtPrepDataCollection vector loop
347 
348  return StatusCode::SUCCESS;
349 }
350 
351 // --------------------------------------------------------------------------------
352 // --------------------------------------------------------------------------------
353 
354 void TrigL2MuonSA::MdtDataPreparator::initDeadChannels(const MuonGM::MdtReadoutElement* mydetEl) {
355  PVConstLink cv = mydetEl->getMaterialGeom(); // it is "Multilayer"
356  int nGrandchildren = cv->getNChildVols();
357  if(nGrandchildren <= 0) return;
358 
359  std::vector<int> tubes;
360  geoGetIds ([&] (int id) { tubes.push_back (id); }, &*cv);
361  std::sort (tubes.begin(), tubes.end());
362 
363  Identifier detElId = mydetEl->identify();
364 
365  int name = m_idHelperSvc->mdtIdHelper().stationName(detElId);
366  int eta = m_idHelperSvc->mdtIdHelper().stationEta(detElId);
367  int phi = m_idHelperSvc->mdtIdHelper().stationPhi(detElId);
368  int ml = m_idHelperSvc->mdtIdHelper().multilayer(detElId);
369  std::vector<Identifier> deadTubes;
370 
371  std::vector<int>::iterator it = tubes.begin();
372  for(int layer = 1; layer <= mydetEl->getNLayers(); layer++){
373  for(int tube = 1; tube <= mydetEl->getNtubesperlayer(); tube++){
374  int want_id = layer*maxNTubesPerLayer + tube;
375  if (it != tubes.end() && *it == want_id) {
376  ++it;
377  }
378  else {
379  it = std::lower_bound (tubes.begin(), tubes.end(), want_id);
380  if (it != tubes.end() && *it == want_id) {
381  ++it;
382  }
383  else {
384  Identifier deadTubeId = m_idHelperSvc->mdtIdHelper().channelID( name, eta, phi, ml, layer, tube );
385  deadTubes.push_back( deadTubeId );
386  ATH_MSG_VERBOSE("adding dead tube (" << tube << "), layer(" << layer
387  << "), phi(" << phi << "), eta(" << eta << "), name(" << name
388  << "), multilayerId(" << ml << ") and identifier " << deadTubeId <<" .");
389  }
390  }
391  }
392  }
393  std::sort(deadTubes.begin(), deadTubes.end());
394  m_DeadChannels[detElId] = deadTubes;
395  return;
396 }
397 
398 // --------------------------------------------------------------------------------
399 // --------------------------------------------------------------------------------
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
Muon::MuonPrepDataContainer
Template for Muon PRD containers (which are basically collections of MuonPrepDataCollections).
Definition: MuonPrepDataContainer.h:42
MuonGM::MdtReadoutElement::getNLayers
int getNLayers() const
Returns the number of tube layers inside the multilayer.
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
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
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
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:35
TrigL2MuonSA::RpcFitResult
Definition: RpcFitResult.h:14
calibdata.chamber
chamber
Definition: calibdata.py:32
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
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:85
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:423
xAOD::L2MuonParameters::BME
@ BME
BME measurement point.
Definition: TrigMuonDefs.h:25
M_PI
#define M_PI
Definition: ActiveFraction.h:11
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:369
GeoGetIds.h
Visitor to collect all IDs under a GeoModel node.
TrigL2MuonSA::MdtDataPreparator::MdtDataPreparator
MdtDataPreparator(const std::string &type, const std::string &name, const IInterface *parent)
Definition: MdtDataPreparator.cxx:29
python.RingerConstants.Layer
Layer
Definition: RingerConstants.py:42
TrigL2MuonSA::MdtRegion
Definition: MdtRegion.h:14
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
TRT::Hit::side
@ side
Definition: HitInfo.h:83
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:269
TrigL2MuonSA::MdtDataPreparator::m_regionSelector
ToolHandle< IRegSelTool > m_regionSelector
Definition: MdtDataPreparator.h:91
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
MuonGM::MuonDetectorManager::getMdtReadoutElement
const MdtReadoutElement * getMdtReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:204
MuonGM::MdtReadoutElement
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MdtReadoutElement.h:50
lumiFormat.i
int i
Definition: lumiFormat.py:92
TrigL2MuonSA::MuonRoad
Definition: MuonRoad.h:20
z
#define z
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
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:135
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
MuonGM::MuonStation
Definition: MuonStation.h:51
test_pyathena.parent
parent
Definition: test_pyathena.py:15
MdtIdHelper.h
MuonGM::MuonStation::getNominalAmdbLRSToGlobal
const Amg::Transform3D & getNominalAmdbLRSToGlobal() const
Definition: MuonStation.h:184
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.
TrigL2MuonSA::MdtDataPreparator::collectMdtHitsFromPrepData
StatusCode collectMdtHitsFromPrepData(const std::vector< IdentifierHash > &v_idHash, TrigL2MuonSA::MdtHits &mdtHits, const TrigL2MuonSA::MuonRoad &muonRoad, const MuonGM::MuonDetectorManager *muDetMgr) const
Definition: MdtDataPreparator.cxx:160
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:43
TrigL2MuonSA::MdtDataPreparator::initDeadChannels
void initDeadChannels(const MuonGM::MdtReadoutElement *mydetEl)
Definition: MdtDataPreparator.cxx:354
TrigL2MuonSA::MuonRoad::phi
double phi[N_STATION][N_SECTOR]
Definition: MuonRoad.h:83
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
xAOD::L2MuonParameters::EndcapMiddle
@ EndcapMiddle
Middle station in the endcap spectrometer.
Definition: TrigMuonDefs.h:20
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:191
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
IdentifierHash.h
Muon::MdtPrepData
Class to represent measurements from the Monitored Drift Tubes.
Definition: MdtPrepData.h:37
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
MuonDetectorManager.h
TrigMuonDefs.h
IdentifiableContainerMT::indexFindPtr
virtual const T * indexFindPtr(IdentifierHash hashId) const override final
return pointer on the found entry or null if out of range using hashed index - fast version,...
Definition: IdentifiableContainerMT.h:292
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:297
TrigL2MuonSA::MdtDataPreparator::getMdtHits
StatusCode getMdtHits(const TrigRoiDescriptor *p_roids, TrigL2MuonSA::MuonRoad &muonRoad, TrigL2MuonSA::MdtHits &mdtHits_normal) const
Definition: MdtDataPreparator.cxx:120
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:49
xAOD::L2MuonParameters::EndcapInner
@ EndcapInner
Inner station in the endcap spectrometer.
Definition: TrigMuonDefs.h:19
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
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:54
TrigRoiDescriptor.h
AthAlgTool
Definition: AthAlgTool.h:26
IdentifierHash
Definition: IdentifierHash.h:38
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:329
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
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
Generated on Sun Jun 30 2024 21:21:22 for ATLAS Offline Software by   doxygen 1.8.18