ATLAS Offline Software
MsTrackTester.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 #include "MsTrackTester.h"
5 
6 #include "StoreGate/ReadHandle.h"
7 #include "MuonTrackEvent/TrackingHelpers.h"
8 #include "MuonTruthHelpers/MuonSimHitHelpers.h"
9 #include "MuonDetDescrUtils/MuonSectorMapping.h"
10 #include "MuonPRDTestR4/TrackContainerModule.h"
11 #include "MuonTesterTree/MuonTesterTreeDict.h"
12 #include "xAODTruth/xAODTruthHelpers.h"
13 
14 #include "Acts/Definitions/Units.hpp"
15 
16 #include <format>
17 
18 using namespace MuonVal;
19 using namespace MuonPRDTest;
20 using namespace MuonR4;
21 using namespace Acts::UnitLiterals;
22 
23 namespace {
24  using SegLink_t = ElementLink<xAOD::MuonSegmentContainer>;
25  using SegLinkVec_t = std::vector<SegLink_t>;
26  static const SG::ConstAccessor<SegLinkVec_t> acc_truthSegLinks{"truthSegmentLinks"};
27  constexpr double MeVtoGeV = 1.e-3;
28 
29  using Location = MsTrackSeeder::Location;
30 
31 
32  constexpr int overlapSector(const int sec1 , const int sec2) {
33  constexpr int nSec = Muon::MuonStationIndex::numberOfSectors();
34  if (sec2 > sec1) return overlapSector(sec2, sec1);
35  if (sec1 == 1 && sec2 == nSec) return 0;
36  return sec1 + sec2;
37  }
38 
39 }
40 
41 namespace MuonValR4 {
42  std::optional<MsTrackSeed> MsTrackTester::makeSeedFromTruth(const ActsTrk::GeometryContext& gctx,
43  const xAOD::TruthParticle& truthMuon) const {
44  int secMax{-1}, secMin{100};
45  std::vector<const xAOD::MuonSegment*> matchedSegs = MuonR4::getTruthSegments(truthMuon);
46  if (matchedSegs.empty()) {
47  return std::nullopt;
48  }
49  for (const xAOD::MuonSegment* seg : matchedSegs) {
50  secMax = std::max(secMax, seg->sector());
51  secMin = std::min(secMin, seg->sector());
52  }
53  const int orSec = overlapSector(secMax, secMin);
55  MsTrackSeed barrelSeed{Location::Barrel, orSec};
56  MsTrackSeed endcapSeed{Location::Endcap, orSec};
57  for (const xAOD::MuonSegment* seg : matchedSegs) {
58  barrelSeed.addSegment(seg);
59  endcapSeed.addSegment(seg);
60  }
61  barrelSeed.setPosition(matchedSegs[0]->position());
62  endcapSeed.setPosition(matchedSegs[0]->position());
63  const auto [barrelLength, barrelTheta] = calcSeedLength(gctx, barrelSeed);
64  const auto [endcapLength, endcapTheta] = calcSeedLength(gctx, endcapSeed);
65  ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Constructed new seed from truth muon wih pT:"
66  <<(truthMuon.pt()/ Gaudi::Units::GeV)<<" [GeV], eta: "<<truthMuon.eta()
67  <<", phi: "<<(truthMuon.phi() / 1._degree)<<", q: "<<truthMuon.charge()
68  <<", matchedSeg: "<<matchedSegs.size()<< " barrel (L/theta): "<<barrelLength
69  <<"/"<<(barrelTheta / 1._degree)<<" - endcap (L/theta): "
70  <<endcapLength<<"/"<<(endcapTheta / 1._degree)<<"\n"<<barrelSeed);
71  if (barrelLength < 0 && endcapLength < 0) {
72  ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - Invalid seed");
73  return std::nullopt;
74  }
75  return barrelLength < 0 || std::abs(endcapLength) < barrelLength
76  ? endcapSeed : barrelSeed;
77  }
78 
79  std::pair<double, double> MsTrackTester::calcSeedLength(const ActsTrk::GeometryContext& gctx,
80  const MuonR4::MsTrackSeed& seed) const {
81  double maxL{-1.*Gaudi::Units::km}, minL{1.*Gaudi::Units::km},
82  maxTheta{-M_PI}, minTheta{M_PI};
83  for (const xAOD::MuonSegment* seg : seed.segments()) {
84  const auto secProj = m_seeder->projectorFromSeed(*seg, seed);
85  const Amg::Vector2D projPos{m_seeder->expressOnCylinder(gctx, *seg, seed.location(), secProj)};
86  if (!m_seeder->withinBounds(projPos, seed.location())) {
87  continue;
88  }
89  const double projected = projPos[seed.location()==Location::Barrel];
90  const double theta = seg->direction().theta();
91  minL = std::min(minL, projected);
92  maxL = std::max(maxL, projected);
93  minTheta = std::min(minTheta, theta);
94  maxTheta = std::max(maxTheta, theta);
95  }
96  return std::make_pair(maxL - minL, maxTheta - minTheta);
97  }
98  StatusCode MsTrackTester::initialize() {
99  ATH_CHECK(m_truthSegmentKey.initialize(m_isMC));
100  ATH_CHECK(m_truthKey.initialize(m_isMC));
101  ATH_CHECK(m_msTrkSeedKey.initialize());
102  ATH_CHECK(m_recoSegmentKey.initialize());
103  ATH_CHECK(m_segSelector.retrieve());
104  ATH_CHECK(m_geoCtxKey.initialize());
105  ATH_CHECK(m_fieldCacheKey.initialize());
106  ATH_CHECK(m_legacyTrackKey.initialize(false));
107  ATH_CHECK(detStore()->retrieve(m_detMgr));
108 
109  MsTrackSeeder::Config seederCfg{};
110  seederCfg.detMgr = m_detMgr;
111  seederCfg.seedHalfLength = 2.*Gaudi::Units::m;
112  seederCfg.endcapDiscRadius = 40.*Gaudi::Units::m;
113  m_seeder = std::make_unique<MuonR4::MsTrackSeeder>(name(), std::move(seederCfg));
114 
115  int evOpts{0};
116 
117  m_recoSegs = std::make_unique<SegmentVariables>(m_tree, m_recoSegmentKey.key(), "Segments", msgLevel());
118  m_recoSegs->addVariable(std::make_unique<MuonVal::GenericAuxDecorationBranch<unsigned short>>(m_tree,
119  "Segments_passSeedQual",[this](const SG::AuxElement* aux){
120  const auto* seg = static_cast<const xAOD::MuonSegment*>(aux);
121  return m_segSelector->passSeedingQuality(Gaudi::Hive::currentContext(),
122  *MuonR4::detailedSegment(*seg)); }));
123  m_recoSegs->addVariable(std::make_unique<MuonVal::GenericAuxDecorationBranch<unsigned short>>(m_tree,
124  "Segments_passTrackQual",[this](const SG::AuxElement* aux){
125  const auto* seg = static_cast<const xAOD::MuonSegment*>(aux);
126  return m_segSelector->passTrackQuality(Gaudi::Hive::currentContext(),
127  *MuonR4::detailedSegment(*seg));
128  }));
129  if (m_isMC) {
130  evOpts |= EventInfoBranch::isMC;
131  m_recoSegs->addVariable(std::make_unique<MuonVal::GenericAuxDecorationBranch<unsigned short>>(m_tree,
132  "Segments_truthSegLink",[this](const SG::AuxElement* aux){
133  const auto* seg = static_cast<const xAOD::MuonSegment*>(aux);
134  const xAOD::MuonSegment* truthS = MuonR4::getMatchedTruthSegment(*seg);
135  const unsigned linkIdx = truthS ? m_truthSegs->push_back(*truthS) : -1;
137  if (truthS) {
138  m_truthSegToRecoLink.push_back(linkIdx, m_recoSegs->push_back(*seg));
139  const xAOD::TruthParticle* truthMuon = MuonR4::getTruthMatchedParticle(*truthS);
140  if (truthMuon){
141  m_truthTrks->push_back(truthMuon);
142  m_truthMuRecoSegLinks[m_truthTrks->find(truthMuon)].push_back(m_recoSegs->push_back(*seg));
143  }
144  }
145  return linkIdx;
146  }));
147 
148  m_truthSegs = std::make_unique<SegmentVariables>(m_tree, m_truthSegmentKey.key(), "TruthSegments", msgLevel());
149 
150  m_truthSegs->addVariable(std::make_unique<MuonVal::GenericAuxDecorationBranch<unsigned short>>(m_tree,
151  "TruthSegments_truthLink",[this](const SG::AuxElement* aux){
152  const auto* seg = static_cast<const xAOD::MuonSegment*>(aux);
153  const xAOD::TruthParticle* truthP = MuonR4::getTruthMatchedParticle(*seg);
154  m_truthTrks->push_back(truthP);
155  unsigned short linkIdx = m_truthTrks->find(truthP);
156  return linkIdx;
157  }));
158  m_truthSegs->addVariable(std::make_unique<MuonVal::GenericAuxDecorationBranch<unsigned short>>(m_tree,
159  "TruthSegments_hasBarrelProj", [this](const SG::AuxElement* aux){
160  const auto* seg = static_cast<const xAOD::MuonSegment*>(aux);
161  const ActsTrk::GeometryContext* gctx{nullptr};
162  SG::get(gctx, m_geoCtxKey, Gaudi::Hive::currentContext()).ignore();
163  using enum MuonR4::MsTrackSeeder::SectorProjector;
164  for (const auto proj : {leftOverlap, center, rightOverlap}) {
165  const Amg::Vector2D projPos{m_seeder->expressOnCylinder(*gctx, *seg, Location::Barrel, proj)};
166  if (m_seeder->withinBounds(projPos, Location::Barrel)) {
167  return 1;
168  }
169  }
170  return 0;
171  }));
172 
173  m_truthSegs->addVariable(std::make_unique<MuonVal::GenericAuxDecorationBranch<unsigned short>>(m_tree,
174  "TruthSegments_hasEndcapProj", [this](const SG::AuxElement* aux){
175  const auto* seg = static_cast<const xAOD::MuonSegment*>(aux);
176  const ActsTrk::GeometryContext* gctx{nullptr};
177  SG::get(gctx, m_geoCtxKey, Gaudi::Hive::currentContext()).ignore();
178  using enum MuonR4::MsTrackSeeder::SectorProjector;
179  for (const auto proj : {leftOverlap, center, rightOverlap}) {
180  const Amg::Vector2D projPos{m_seeder->expressOnCylinder(*gctx, *seg, Location::Endcap, proj)};
181  if (m_seeder->withinBounds(projPos, Location::Endcap)) {
182  return 1;
183  }
184  }
185  return 0;
186  }));
187  m_tree.addBranch(m_truthSegs);
188 
189  m_truthTrks = std::make_unique<IParticleFourMomBranch>(m_tree, "TruthMuons");
190  m_tree.addBranch(m_truthTrks);
191  m_trkTruthLinks.emplace_back(m_truthSegmentKey, "truthParticleLink");
192  m_trkTruthLinks.emplace_back(m_truthKey, "truthSegmentLinks");
193  m_trkTruthLinks.emplace_back(m_recoSegmentKey, "truthSegmentLink");
194  }
195 
196  m_tree.addBranch(m_recoSegs);
197  m_tree.addBranch(std::make_unique<EventInfoBranch>(m_tree, evOpts));
198  m_tree.addBranch(std::make_unique<TrackContainerModule>(m_tree, "MsTracks", msgLevel()));
199 
200  if(!m_legacyTrackKey.empty()) {
201  m_legacyTrks = std::make_unique<IParticleFourMomBranch>(m_tree, "LegacyMSTrks");
202  m_legacyTrks->addVariable(std::make_unique<TrackChi2Branch>(*m_legacyTrks));
203  if (m_isMC) {
204  BilateralLinkerBranch::connectCollections(m_legacyTrks, m_truthTrks, [](const xAOD::IParticle* trk){
205  return xAOD::TruthHelpers::getTruthParticle(*trk); }, "truth", "LegacyMS");
206  }
207  m_tree.addBranch(m_legacyTrks);
208  }
209 
210  ATH_CHECK(m_trkTruthLinks.initialize());
211  ATH_CHECK(m_tree.init(this));
212  return StatusCode::SUCCESS;
213  }
214  StatusCode MsTrackTester::execute() {
215  const EventContext& ctx{Gaudi::Hive::currentContext()};
216 
217  const xAOD::TrackParticleContainer* legacyTrks{nullptr};
218  ATH_CHECK(SG::get(legacyTrks, m_legacyTrackKey, ctx));
219  if (legacyTrks){
220  for (const xAOD::TrackParticle* track : *legacyTrks) {
221  m_legacyTrks->push_back(track);
222  }
223  }
225  const xAOD::MuonSegmentContainer* recoSegments{nullptr};
226  ATH_CHECK(SG::get(recoSegments, m_recoSegmentKey, ctx));
227  if (recoSegments->empty()){
228  return StatusCode::SUCCESS;
229  }
230  const MuonR4::MsTrackSeedContainer* trkSeeds{nullptr};
231  ATH_CHECK(SG::get(trkSeeds, m_msTrkSeedKey, ctx));
232  const ActsTrk::GeometryContext* gctx{nullptr};
233  ATH_CHECK(SG::get(gctx, m_geoCtxKey, ctx));
234  const AtlasFieldCacheCondObj* magCache{nullptr};
235  ATH_CHECK(SG::get(magCache, m_fieldCacheKey, ctx));
236 
237  std::map<const xAOD::TruthParticle*, std::vector<unsigned>> truthToSeedMatchCounter{};
238  for (const MuonR4::MsTrackSeed& seed : *trkSeeds) {
239  unsigned int seedIdx = m_seedPos.size();
240  m_seedPos += seed.position();
241  m_seedType+= Acts::toUnderlying(seed.location());
242 
243  ATH_MSG_VERBOSE(" Dump new seed: "<<seed);
244  for (const xAOD::MuonSegment* seg : seed.segments()){
245  m_seedRecoSegMatch[seedIdx].push_back(m_recoSegs->push_back(*seg));
246  if (const xAOD::MuonSegment* truthSeg = MuonR4::getMatchedTruthSegment(*seg);
247  truthSeg != nullptr) {
248  std::vector<unsigned>& matchCounter = truthToSeedMatchCounter[MuonR4::getTruthMatchedParticle(*truthSeg)];
249  if (seedIdx >= matchCounter.size()) {
250  matchCounter.resize(seedIdx +1);
251  }
252  ++matchCounter[seedIdx];
253  }
254  }
255  const auto[seedLength, theta] = calcSeedLength(*gctx, seed);
256  m_seedLength+= seedLength;
257  m_seedThetaCone+=theta;
258  m_seedQP += m_seeder->estimateQtimesP(*gctx, *magCache, seed) / Gaudi::Units::GeV;
259  }
260  for (const xAOD::MuonSegment* seg : *recoSegments) {
261  m_recoSegs->push_back(*seg);
262  }
264  const xAOD::MuonSegmentContainer* truthSegs{nullptr};
265  ATH_CHECK(SG::get(truthSegs, m_truthSegmentKey, ctx));
266  if (truthSegs) {
267  for (const xAOD::MuonSegment* seg : *truthSegs) {
268  ATH_MSG_VERBOSE(std::format( "Dump truth segment: {:}{:}{:}{:} @{:}, eta: {:.2f}, phi {:.2f}",
269  chName(seg->chamberIndex()), std::abs(seg->etaIndex()),
270  seg->etaIndex() > 0 ? 'A' : 'C', seg->sector(),
271  Amg::toString(seg->position()),
272  seg->direction().eta(), seg->direction().phi() / 1._degree));
273 
274  m_truthSegs->push_back(*seg);
275  }
276  if (truthSegs->size()) {
277  m_truthSegToRecoLink[truthSegs->size()-1];
278  }
279  }
281  const xAOD::TruthParticleContainer* truthMuons{nullptr};
282  ATH_CHECK(SG::get(truthMuons, m_truthKey, ctx));
283  if (truthMuons && truthMuons->size()) {
285  m_truthMuToSeedIdx[truthMuons->size() -1];
286  m_truthMuToSeedCounter[truthMuons->size() -1];
287  m_truthMuTruthSegLinks[truthMuons->size() -1];
288  m_truthMuRecoSegLinks[truthMuons->size() -1];
289 
290  for (const xAOD::TruthParticle* truth : *truthMuons) {
291  ATH_MSG_DEBUG("Truth muon: pT: "<<(truth->pt() *MeVtoGeV)<<", eta: "<<truth->eta()
292  <<", phi: "<<(truth->phi() / 1._degree)<<", q: "<<truth->charge());
293 
294  m_truthTrks->push_back(*truth);
295  unsigned truthIdx = m_truthTrks->find(truth);
296  std::vector<unsigned>& matchCounter = truthToSeedMatchCounter[truth];
297  std::vector<unsigned>::iterator maxSeed = matchCounter.begin();
299  while ( (maxSeed = std::ranges::max_element(matchCounter))!=matchCounter.end() && (*maxSeed) > 0) {
300  m_truthMuToSeedIdx[truthIdx].push_back(std::distance(matchCounter.begin(), maxSeed));
301  m_truthMuToSeedCounter[truthIdx].push_back(*maxSeed);
302  (*maxSeed) = 0;
303  }
304 
305  std::vector<unsigned short>& truthSegLinks = m_truthMuTruthSegLinks[truthIdx];
306  const std::vector<const xAOD::MuonSegment*> truthSegs = getTruthSegments(*truth);
307  m_truthMuTruthNSegs += truthSegs.size();
308  for (const xAOD::MuonSegment* truthSeg: truthSegs) {
309  truthSegLinks.push_back(m_truthSegs->push_back(*truthSeg));
310  }
311 
312  auto truthSeed = makeSeedFromTruth(*gctx, *truth);
313  if (!truthSeed) {
314  m_truthMuonsSeedLength[truthIdx] = -1;
315  m_truthMuonsSeedCone[truthIdx] = -1;
316  m_truthMuonQP[truthIdx] =0;
317  } else {
318  const auto [length, cone] = calcSeedLength(*gctx, *truthSeed);
319  m_truthMuonsSeedLength[truthIdx] = length;
320  m_truthMuonsSeedCone [truthIdx] = cone;
321  m_truthMuonQP[truthIdx] = m_seeder->estimateQtimesP(*gctx, *magCache, *truthSeed) / Gaudi::Units::GeV;
322  }
323 
324  }
325  }
326  ATH_CHECK(m_tree.fill(ctx));
327  return StatusCode::SUCCESS;
328  }
329  StatusCode MsTrackTester::finalize() {
330  ATH_CHECK(m_tree.write());
331  return StatusCode::SUCCESS;
332  }
333 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
MuonSimHitHelpers.h
python.tests.PyTestsLib.finalize
def finalize(self)
_info( "content of StoreGate..." ) self.sg.dump()
Definition: PyTestsLib.py:50
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
DetType::Endcap
@ Endcap
Definition: DetType.h:14
vtune_athena.format
format
Definition: vtune_athena.py:14
MuonR4::getTruthMatchedParticle
const xAOD::TruthParticle * getTruthMatchedParticle(const xAOD::MuonSegment &segment)
Returns the particle truth-matched to the segment.
Definition: MuonSimHitHelpers.cxx:107
AtlasFieldCacheCondObj
Definition: AtlasFieldCacheCondObj.h:19
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
MuonVal::EventInfoBranch::isMC
@ isMC
Flag determining whether the branch is simulation.
Definition: EventInfoBranch.h:20
SG::AuxElement
Base class for elements of a container that can have aux data.
Definition: AuxElement.h:483
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
MuonVal::GenericAuxDecorationBranch
Generic branch object where the information is evaluated by a std::function instead reading it from t...
Definition: AuxElementBranch.h:33
MuonR4::MsTrackSeed
Definition: MsTrackSeed.h:18
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
initialize
void initialize()
Definition: run_EoverP.cxx:894
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
M_PI
#define M_PI
Definition: ActiveFraction.h:11
CP::MeVtoGeV
constexpr float MeVtoGeV
Definition: IsolationCloseByCorrectionTool.cxx:38
MuonTesterTreeDict.h
xAOD::MuonSegment_v1
Class describing a MuonSegment.
Definition: MuonSegment_v1.h:33
MuonR4::getMatchedTruthSegment
const xAOD::MuonSegment * getMatchedTruthSegment(const xAOD::MuonSegment &segment)
Returns the truth-matched segment.
Definition: MuonSimHitHelpers.cxx:118
MsTrackTester.h
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
xAODTruthHelpers.h
Muon::MuonStationIndex::numberOfSectors
constexpr unsigned numberOfSectors()
return total number of sectors
Definition: MuonStationIndex.h:118
MuonR4::MsTrackSeed::Location
Location
Enum defining whether the seed is made in the endcap / barrel.
Definition: MsTrackSeed.h:21
DetType::Barrel
@ Barrel
Definition: DetType.h:14
MuonR4::detailedSegment
const Segment * detailedSegment(const xAOD::MuonSegment &seg)
Helper function to navigate from the xAOD::MuonSegment to the MuonR4::Segment.
Definition: TrackingHelpers.cxx:22
LArG4FSStartPointFilterLegacy.execute
execute
Definition: LArG4FSStartPointFilterLegacy.py:20
MuonR4::getTruthSegments
std::vector< const xAOD::MuonSegment * > getTruthSegments(const xAOD::TruthParticle &truthMuon)
Returns the segments associated to the truth muon.
Definition: MuonSimHitHelpers.cxx:128
Amg::toString
std::string toString(const Translation3D &translation, int precision=4)
GeoPrimitvesToStringConverter.
Definition: GeoPrimitivesToStringConverter.h:40
SG::get
const T * get(const ReadCondHandleKey< T > &key, const EventContext &ctx)
Convenience function to retrieve an object given a ReadCondHandleKey.
Definition: ReadCondHandle.h:283
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
Muon::MuonStationIndex::chName
const std::string & chName(ChIndex index)
convert ChIndex into a string
Definition: MuonStationIndex.cxx:119
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::TruthParticle_v1
Class describing a truth particle in the MC record.
Definition: TruthParticle_v1.h:37
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ActsTrk::GeometryContext
Definition: GeometryContext.h:28
python.SystemOfUnits.km
float km
Definition: SystemOfUnits.py:110
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
MuonVal::BilateralLinkerBranch::connectCollections
static bool connectCollections(ParticleBranch_ptr primColl, ParticleBranch_ptr secondColl, Linker_t fromPrimToSec, const std::string &altPrimName="", const std::string &altSecName="")
Definition: LinkerBranch.cxx:33
make_coralServer_rep.proj
proj
Definition: make_coralServer_rep.py:48
MuonValR4
Lightweight algorithm to read xAOD MDT sim hits and (fast-digitised) drift circles from SG and fill a...
Definition: IPatternVisualizationTool.h:23
TrackingHelpers.h
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
MuonVal
Class to store array like branches into the n-tuples.
Definition: HitValAlg.cxx:19
MuonR4::MsTrackSeeder::Config::detMgr
const MuonGMR4::MuonDetectorManager * detMgr
Detector manager to fetch the sector enevelope transforms.
Definition: MsTrackSeeder.h:46
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
xAOD::TruthHelpers::getTruthParticle
const xAOD::TruthParticle * getTruthParticle(const xAOD::IParticle &p)
Return the truthParticle associated to the given IParticle (if any)
Definition: xAODTruthHelpers.cxx:25
python.TruthMuonD3PDObject.truthMuon
truthMuon
Definition: TruthMuonD3PDObject.py:51
MuonR4
This header ties the generic definitions in this package.
Definition: HoughEventData.h:16
TrackContainerModule.h
MuonR4::SegLinkVec_t
std::vector< SegLink_t > SegLinkVec_t
Definition: MeasurementMarkerAlg.cxx:15
MuonSectorMapping.h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
MuonR4::MsTrackSeedContainer
std::vector< MsTrackSeed > MsTrackSeedContainer
Definition: MsTrackSeed.h:63
MuonPRDTest
Definition: MuonHitTesterAlg.h:15
MuonR4::MsTrackSeeder::SectorProjector
SectorProjector
Enumeration to select the sector projection.
Definition: MsTrackSeeder.h:60
MuonR4::MsTrackSeeder::Config
Configuration object.
Definition: MsTrackSeeder.h:32
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:44
ReadHandle.h
Handle class for reading from StoreGate.
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
python.SystemOfUnits.m
float m
Definition: SystemOfUnits.py:106
Generated on Wed Nov 5 2025 21:15:05 for ATLAS Offline Software by   doxygen 1.8.18