ATLAS Offline Software
Loading...
Searching...
No Matches
MsTrackTester.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
3*/
4#include "MsTrackTester.h"
5
17
20#include "ActsInterop/Logger.h"
22
23#include "Acts/Definitions/Units.hpp"
24#include "Acts/EventData/ParticleHypothesis.hpp"
25#include "Acts/Surfaces/PlaneSurface.hpp"
26#include "Acts/Utilities/Helpers.hpp"
28
29#include <format>
30
31using namespace MuonVal;
32using namespace MuonPRDTest;
33using namespace MuonR4;
34using namespace Acts::UnitLiterals;
35
36namespace {
37 constexpr double MeVtoGeV = 1.e-3;
38 constexpr double toDeg(const double rad) {
39 return rad / 1._degree;
40 }
41 using Location = MsTrackSeed::Location;
42
43 const MuonR4::MuonTag* findTagMatchingToId(const xAOD::TrackParticle& idTrack,
45 const EventContext& ctx) {
46 const MuonR4::MuonTagContainer* muTagCont{nullptr};
47 if(!SG::get(muTagCont, key, ctx).isSuccess()){
48 THROW_EXCEPTION("Failed to retrieve "<<key.fullKey());
49 }
50 if (!muTagCont) {
51 return nullptr;
52 }
53 for (const MuonR4::MuonTag* muTag : *muTagCont) {
54 if (muTag->idTrack() == &idTrack){
55 return muTag;
56 }
57 }
58 return nullptr;
59 }
60
61 bool isOnCaloExit(const Acts::Surface& surf) {
62 return surf.geometryId().volume() == ActsTrk::detail::GeoVolIds::s_caloEnvelopeID;
63 }
64
65 bool isOnCaloExit(const Acts::BoundTrackParameters& pars) {
66 return isOnCaloExit(pars.referenceSurface());
67 }
68
69}
70
71namespace MuonValR4 {
72 std::optional<MsTrackSeed> MsTrackTester::makeSeedFromTruth(const Acts::GeometryContext& tgContext,
73 const xAOD::TruthParticle& truthMuon) const {
74 std::vector<const xAOD::MuonSegment*> matchedSegs = MuonR4::getTruthSegments(truthMuon);
75 if (matchedSegs.empty() || toLayerIndex(matchedSegs.front()->chamberIndex()) == toLayerIndex(matchedSegs.back()->chamberIndex())) {
76 return std::nullopt;
77 }
78 ExpandedSector sector{matchedSegs[0]->position().phi()};
80 MsTrackSeed barrelSeed{Location::Barrel, sector};
81 MsTrackSeed endcapSeed{Location::Endcap, sector};
82 for (const xAOD::MuonSegment* seg : matchedSegs) {
83 barrelSeed.addSegment(seg);
84 endcapSeed.addSegment(seg);
85 }
86 barrelSeed.setPosition(matchedSegs[0]->position());
87 endcapSeed.setPosition(matchedSegs[0]->position());
88 const auto [barrelLength, barrelTheta] = calcSeedLength(tgContext, barrelSeed);
89 const auto [endcapLength, endcapTheta] = calcSeedLength(tgContext, endcapSeed);
90 ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Constructed new seed from truth muon wih pT:"
91 <<(truthMuon.pt()/ Gaudi::Units::GeV)<<" [GeV], eta: "<<truthMuon.eta()
92 <<", phi: "<<toDeg(truthMuon.phi())<<", q: "<<truthMuon.charge()
93 <<", matchedSeg: "<<matchedSegs.size()<< " barrel (L/theta): "<<barrelLength
94 <<"/"<<barrelTheta<<" - endcap (L/theta): "
95 <<endcapLength<<"/"<<endcapTheta<<"\n"<<barrelSeed);
96 if (barrelLength < 0 && endcapLength < 0) {
97 ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - Invalid seed");
98 return std::nullopt;
99 }
100 return barrelLength < 0 || std::abs(endcapLength) < barrelLength
101 ? endcapSeed : barrelSeed;
102 }
103
104 std::pair<double, double> MsTrackTester::calcSeedLength(const Acts::GeometryContext& tgContext,
105 const MuonR4::MsTrackSeed& seed) const {
106 double maxL{-1.*Gaudi::Units::km}, minL{1.*Gaudi::Units::km},
107 maxTheta{-181.}, minTheta{181};
108 for (const xAOD::MuonSegment* seg : seed.segments()) {
109 const Amg::Vector2D projPos{m_seedingTool->expressOnCylinder(tgContext, *seg, seed.location(), seed.sector())};
110 if (!m_seedingTool->withinBounds(projPos, seed.location())) {
111 continue;
112 }
113 const double projected = projPos[seed.location()==Location::Barrel];
114 const double theta = seg->direction().theta();
115 minL = std::min(minL, projected);
116 maxL = std::max(maxL, projected);
117 minTheta = std::min(minTheta, toDeg(theta));
118 maxTheta = std::max(maxTheta, toDeg(theta));
119 }
120 return std::make_pair(maxL - minL, maxTheta - minTheta);
121 }
124 ATH_CHECK(m_truthKey.initialize(m_isMC));
125
126 ATH_CHECK(m_muonKey.initialize());
127 ATH_CHECK(m_msTrkSeedKey.initialize());
128 ATH_CHECK(m_recoSegmentKey.initialize());
129
130 ATH_CHECK(m_summaryTool.retrieve());
131 ATH_CHECK(m_seedingTool.retrieve());
132
133 ATH_CHECK(m_legacyMuonKey.initialize(!m_legacyMuonKey.empty()));
134 ATH_CHECK(m_legacyTrackKey.initialize(!m_legacyMuonKey.empty()));
135 ATH_CHECK(m_legacySegmentKey.initialize(!m_legacyMuonKey.empty()));
136 ATH_CHECK(m_idTrackKey.initialize(m_isMC && m_storeID));
137 ATH_CHECK(m_idTagKey.initialize(!m_idTrackKey.empty()));
138 ATH_CHECK(m_segTagKey.initialize(!m_idTrackKey.empty()));
139
140 ATH_CHECK(m_ctxProvider.initialize());
141 ATH_CHECK(m_extrapolationTool.retrieve(EnableTool{m_storeID || m_isMC}));
142 ATH_CHECK(detStore()->retrieve(m_detMgr));
143 m_logger = makeActsAthenaLogger(this, name());
144
145 int evOpts{0};
146
147 m_recoSegs = std::make_unique<SegmentVariables>(m_tree, m_recoSegmentKey.key(), "Segments", msgLevel());
149 "Segments_passSeedQual",[this](const SG::AuxElement* aux){
150 const auto* seg = static_cast<const xAOD::MuonSegment*>(aux);
151 return m_segSelector->passSeedingQuality(Gaudi::Hive::currentContext(),
152 *seg); }));
154 "Segments_passTrackQual",[this](const SG::AuxElement* aux){
155 const auto* seg = static_cast<const xAOD::MuonSegment*>(aux);
156 return m_segSelector->passTrackQuality(Gaudi::Hive::currentContext(),
157 *seg);
158 }));
159
160
161 if (m_isMC) {
162 evOpts |= EventInfoBranch::isMC;
164 "Segments_truthSegLink",[this](const SG::AuxElement* aux){
165 const auto* seg = static_cast<const xAOD::MuonSegment*>(aux);
167 const unsigned linkIdx = truthS ? m_truthSegs->push_back(*truthS) : -1;
169 if (truthS) {
170 m_truthSegToRecoLink.push_back(linkIdx, m_recoSegs->push_back(*seg));
171 const xAOD::TruthParticle* truthMuon = MuonR4::getTruthMatchedParticle(*truthS);
172 if (truthMuon){
173 m_truthTrks->push_back(truthMuon);
174 m_truthMuRecoSegLinks[m_truthTrks->find(truthMuon)].push_back(m_recoSegs->push_back(*seg));
175 }
176 }
177 return linkIdx;
178 }));
179
180 m_truthSegs = std::make_unique<SegmentVariables>(m_tree, m_truthSegmentKey.key(), "TruthSegments", msgLevel());
181
183 "TruthSegments_truthLink",[this](const SG::AuxElement* aux){
184 const auto* seg = static_cast<const xAOD::MuonSegment*>(aux);
186 m_truthTrks->push_back(truthP);
187 unsigned short linkIdx = m_truthTrks->find(truthP);
188 return linkIdx;
189 }));
190 for (auto loc : {Location::Barrel, Location::Endcap}) {
192 std::format("TruthSegments_has{}Proj", loc), [loc, this](const SG::AuxElement* aux) -> unsigned short {
193
194 const auto* seg = static_cast<const xAOD::MuonSegment*>(aux);
195 const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(Gaudi::Hive::currentContext());
196 ExpandedSector sector{seg->position().phi()};
197 const Amg::Vector2D projPos{m_seedingTool->expressOnCylinder(tgContext, *seg, loc, sector)};
198 return m_seedingTool->withinBounds(projPos, loc);
199 }));
200 }
201
202 m_tree.addBranch(m_truthSegs);
203
204 m_truthTrks = std::make_unique<IParticleFourMomBranch>(m_tree, "TruthMuons");
205 m_truthTrks->addVariable<int>(-1, "truthOrigin");
206 m_truthTrks->addVariable<int>(-1, "truthType");
208 m_truthTrks->addVariable(
210 std::vector<unsigned short>>>(m_tree,
211 std::format("{:}_truthSegLinks", m_truthTrks->name()), [&] (const xAOD::TruthParticle& p){
212 std::vector<unsigned short> idx{};
213 for (const xAOD::MuonSegment* truthSeg: getTruthSegments(p)){
214 idx.push_back(m_truthSegs->push_back(*truthSeg));
215 }
216 return idx;
217 }));
219 m_truthTrks->addVariable(
221 std::format("{:}_nTruthSegments", m_truthTrks->name()), [&] (const xAOD::TruthParticle& p) -> unsigned short {
222 return getTruthSegments(p).size();
223 }));
224
225 m_truthTrks->addVariable(
227 std::format("{:}_eLossInMS", m_truthTrks->name()), [] (const xAOD::TruthParticle& p) -> float {
228 std::vector<const xAOD::MuonSimHit*> allHits{};
229 for (const xAOD::MuonSegment* seg : getTruthSegments(p)){
230 auto hits = getMatchingSimHits(*seg);
231 allHits.insert_range(allHits.end(),getMatchingSimHits(*seg));
232 }
233 if (allHits.empty()) {
234 return 0.;
235 }
236 auto [min, max] = std::ranges::minmax(allHits, [](const xAOD::MuonSimHit* a, const xAOD::MuonSimHit* b){
237 return a->kineticEnergy() < b->kineticEnergy();
238 });
239 return (min->kineticEnergy() - max->kineticEnergy()) / Gaudi::Units::GeV;
240 }));
242 auto cone = std::make_shared<VectorBranch<float>>(m_tree,
243 std::format("{}_seedThetaCone", m_truthTrks->name()));
244 auto qTimesP = std::make_shared<VectorBranch<float>>(m_tree,
245 std::format("{}_qTimesP", m_truthTrks->name()));
246
247 m_tree.addBranch(cone);
248 m_tree.addBranch(qTimesP);
249 m_truthTrks->addVariable(
251 std::format("{:}_seedLength", m_truthTrks->name()), [cone, qTimesP, this] (const xAOD::TruthParticle& p) -> float {
252
253 const EventContext& ctx{Gaudi::Hive::currentContext()};
254 const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(ctx);
255 const Acts::MagneticFieldContext mfContext = m_ctxProvider.getMagneticFieldContext(ctx);
256 MagField::AtlasFieldCache magField{};
257 mfContext.get<const AtlasFieldCacheCondObj*>()->getInitializedCache(magField);
258 auto truthSeed = makeSeedFromTruth(tgContext, p);
259 if (!truthSeed) {
260 cone->push_back(-1);
261 qTimesP->push_back(0);
262 return -1.;
263 }
264 auto [length, theta] = calcSeedLength(tgContext, *truthSeed);
265 cone->push_back(theta);
266 qTimesP->push_back(m_seedingTool->estimateQtimesP(tgContext, *truthSeed, magField) / Gaudi::Units::GeV);
267 return length;
268 }));
269
271 for (const auto var :{ "d0", "z0", "prodZ", "prodR"}) {
272 m_trkTruthLinks.emplace_back(m_truthKey, var);
273 m_truthTrks->addVariable<float>(-99999.f, var);
274
275 }
276 m_tree.addBranch(m_truthTrks);
277 m_trkTruthLinks.emplace_back(m_truthSegmentKey, "truthParticleLink");
278 m_trkTruthLinks.emplace_back(m_truthKey, "truthSegmentLinks");
279 m_trkTruthLinks.emplace_back(m_recoSegmentKey, "truthSegmentLink");
280 m_trkTruthLinks.emplace_back(m_muonKey, "truthParticleLink");
281 }
282
283 m_tree.addBranch(m_recoSegs);
284 m_tree.addBranch(std::make_unique<EventInfoBranch>(m_tree, evOpts));
285
286 static const std::vector<std::string> trackSummaries{
287 // Inner
288 "innerSmallHits", "innerLargeHits", "innerSmallHoles", "innerLargeHoles",
289 "innerClosePrecisionHits",
290 // Middle
291 "middleSmallHits", "middleLargeHits", "middleSmallHoles",
292 "middleLargeHoles", "middleClosePrecisionHits",
293 // Outer
294 "outerSmallHits", "outerLargeHits", "outerSmallHoles", "outerLargeHoles",
295 "outerClosePrecisionHits",
296 // Extended
297 "extendedSmallHits", "extendedLargeHits", "extendedSmallHoles",
298 "extendedLargeHoles", "extendedClosePrecisionHits",
299 "innerTriggerEtaHits", "innerTriggerPhiHits",
300 "middleTriggerEtaHits", "middleTriggerPhiHits",
301 "outerTriggerEtaHits", "outerTriggerPhiHits",
302
303 "innerTriggerEtaHoles", "innerTriggerPhiHoles",
304 "middleTriggerEtaHoles", "middleTriggerPhiHoles",
305 "outerTriggerEtaHoles", "outerTriggerPhiHoles",
306 };
307 if(!m_legacyTrackKey.empty()) {
308 m_legacyTrks = std::make_unique<IParticleFourMomBranch>(m_tree, "LegacyMSTrks");
309 m_legacyTrks->addVariable(std::make_unique<TrackChi2Branch>(*m_legacyTrks));
310 if (m_isMC) {
311 BilateralLinkerBranch::connectCollections(m_legacyTrks, m_truthTrks,
312 [](const xAOD::IParticle* trk){
314 }, "truth", "LegacyMS");
315 }
316 for (const auto& summary : trackSummaries) {
317 m_legacyTrks->addVariable<uint8_t>(-1, summary);
318 }
319 m_tree.addBranch(m_legacyTrks);
320 m_legacyRecoSegs = std::make_unique<SegmentVariables>(m_tree, m_legacySegmentKey.key(), "LegacyRecoSegments", msgLevel());
321 m_tree.addBranch(m_legacyRecoSegs);
322 }
323
324 m_seedSummary = std::make_shared<TrackSummaryModule>(m_tree, "TrkSeed", m_summaryTool.get());
325 m_muonTrks = std::make_shared<IParticleFourMomBranch>(m_tree, "ActsMuons");
326 m_muonTrks->addVariable(std::make_unique<TrackChi2Branch>(*m_muonTrks));
327 m_muonTrks->addVariable<float>(4.5, "segmentDeltaEta");
328 m_muonTrks->addVariable<float>(std::numbers::pi, "segmentDeltaPhi");
329 m_muonTrks->addVariable<float>(-1., "segmentChi2OverDoF");
330
331 using TrkType = xAOD::Muon::TrackParticleType;
332 auto dumpTrack = [&](const std::string& trkName, TrkType type) {
333 auto trkColl = std::make_shared<IParticleFourMomBranch>(m_tree, trkName);
334 trkColl->addVariable(std::make_unique<TrackChi2Branch>(*trkColl));
335 if (type != TrkType::InnerDetectorTrackParticle) {
336 trkColl->addVariable(std::make_unique<TrackFitIterBranch>(*trkColl));
337 }
338 trkColl->addVariable(std::make_unique<MaterialRecorderBranch>(*trkColl));
339 trkColl->addVariable(std::make_unique<EnergyLossBranch>(*trkColl));
340
341 trkColl->addVariable<float>("d0");
342 trkColl->addVariable<float>("z0");
343 if (type != TrkType::InnerDetectorTrackParticle) {
344 for (const auto& summary : trackSummaries) {
345 trkColl->addVariable<uint8_t>(-1, summary);
346 }
347 }
349 [type](const xAOD::IParticle* muonP) -> const xAOD::IParticle* {
350 const auto* muon = dynamic_cast<const xAOD::Muon*>(muonP);
351 if (!muon) {
352 return nullptr;
353 }
354 return muon->trackParticle(type);
355 }, trkName, "muon");
356
357 return trkColl;
358 };
359
360 auto msTracks = dumpTrack("MsTrk", TrkType::MuonSpectrometerTrackParticle);
361 dumpTrack("MeTrk", TrkType::ExtrapolatedMuonSpectrometerTrackParticle);
362 m_idTracks = dumpTrack("IdTrk", TrkType::InnerDetectorTrackParticle);
363
365 {
366 auto& l0{m_tree.newVector<float>(std::format("{:}_caloExitLoc0", m_idTracks->name()))};
367 auto& l1{m_tree.newVector<float>(std::format("{:}_caloExitLoc1", m_idTracks->name()))};
368 auto& theta{m_tree.newVector<float>(std::format("{:}_caloExitTheta", m_idTracks->name()))};
369 auto& phi{m_tree.newVector<float>(std::format("{:}_caloExitPhi", m_idTracks->name()))};
370 auto& mom{m_tree.newVector<float>(std::format("{:}_caloExitMom", m_idTracks->name()))};
371
372 m_idTracks->addVariable(std::make_unique<GenericPartDecorBranch<xAOD::TrackParticle, std::uint8_t>>(m_tree,
373 std::format("{:}_isCandidate", m_idTracks->name()),
374 [this, &l0, &l1, &theta, &phi, &mom] (const xAOD::TrackParticle& idTrack) -> std::uint8_t {
375 const MuonR4::MuonTag* tag = findBaseIdTag(idTrack, Gaudi::Hive::currentContext());
376 std::optional<Acts::BoundTrackParameters> trkPars = tag ? tag->extrapolatedParsID(Acts::hashString("@CaloExit"))
377 : std::nullopt;
378 const std::size_t idx = l0.size();
379 using namespace MuonCombinedR4;
380 l0[idx] = trkPars ? longitudinalParam(*trkPars, logger()) : 1._km;
381 l1[idx] = trkPars ? toDeg(localPolarAngle(*trkPars, logger())) : 360.;
382
383 theta[idx] = trkPars ? toDeg(trkPars->get<Acts::eBoundTheta>()) : 360.;
384 phi[idx] = trkPars ? toDeg(trkPars->get<Acts::eBoundPhi>()) : 360.;
385 mom[idx] = trkPars ? trkPars->absoluteMomentum() : -1._GeV;
386 return trkPars != std::nullopt;
387 }));
388 }
389 {
390 auto& dX0{m_tree.newMatrix<float>(std::format("{:}_segTagDx0", m_idTracks->name()))};
391 auto& dY0{m_tree.newMatrix<float>(std::format("{:}_segTagDy0", m_idTracks->name()))};
392 auto& dTheta{m_tree.newMatrix<float>(std::format("{:}_segTagDtheta", m_idTracks->name()))};
393 auto& dPhi{m_tree.newMatrix<float>(std::format("{:}_segTagDphi", m_idTracks->name()))};
394 auto& segments{m_tree.newMatrix<std::uint8_t>(std::format("{:}_segTagSegments", m_idTracks->name()))};
395 auto& goodExtp{m_tree.newMatrix<std::uint8_t>(std::format("{:}_segTagExtpGood",m_idTracks->name()))};
396 auto& taggedSeg{m_tree.newMatrix<std::uint8_t>(std::format("{:}_segTagOnTag", m_idTracks->name()))};
397 m_idTracks->addVariable(
398 std::make_unique<GenericPartDecorBranch<xAOD::TrackParticle, std::vector<float>>>(m_tree,
399 std::format("{:}_segTagScore", m_idTracks->name()),
400 [&dX0, &dY0, &dTheta, &dPhi, &segments,
401 &goodExtp, &taggedSeg,this] (const xAOD::TrackParticle& idTrack) -> std::vector<float> {
402 auto result = calcSegTagVariables(idTrack, Gaudi::Hive::currentContext());
403
404 segments.push_back(std::move(result.recoSegs));
405 dX0.push_back(std::move(result.deltaX0));
406 dY0.push_back(std::move(result.deltaY0));
407 dTheta.push_back(std::move(result.deltaTheta));
408 dPhi.push_back(std::move(result.deltaPhi));
409 goodExtp.push_back(std::move(result.goodExtp));
410 taggedSeg.push_back(std::move(result.taggedSeg));
411 return std::move(result.matchScores);
412 }));
413 }
414 if (m_isMC) {
415 BilateralLinkerBranch::connectCollections(m_idTracks, m_truthTrks,
416 [this](const xAOD::IParticle* trk) {
417 return truthTreeParticle(*trk, Gaudi::Hive::currentContext());
418 }, "truth", "IdTrack");
419
420 }
421
422 m_muonTrks->addVariable<uint16_t>("allAuthors");
423 m_muonTrks->addVariable<uint16_t>("author");
425 m_muonTrks->addVariable(std::make_unique<GenericPartDecorBranch<xAOD::Muon,
426 std::vector<unsigned short>>>(m_tree,
427 std::format("{:}_segmentLinks", m_muonTrks->name()), [&] (const xAOD::Muon& p){
428 std::vector<unsigned short> idx{};
429 for (unsigned seg = 0 ; seg < p.nMuonSegments(); ++seg) {
430 idx.push_back(m_recoSegs->push_back(*p.muonSegment(seg)));
431 }
432 return idx;
433 }));
435 msTracks->addVariable(std::make_unique<GenericPartDecorBranch<xAOD::TrackParticle, unsigned short>>(m_tree,
436 std::format("{:}_seedLink", msTracks->name()), [&] (const xAOD::TrackParticle& p) -> unsigned short {
437 auto actsTrk = ActsTrk::getActsTrack(p);
438 if (!actsTrk) {
439 THROW_EXCEPTION("Cannot find the associated ms track from the primary track");
440 }
441 return actsTrk->component<std::size_t>("parentSeed");
442 }));
443
444 msTracks->addVariable(std::make_unique<GenericPartDecorBranch<xAOD::TrackParticle, float>>(m_tree,
445 std::format("{:}_loc0", msTracks->name()), [&] (const xAOD::TrackParticle& p){
446 auto actsTrk = ActsTrk::getActsTrack(p);
447 if (!actsTrk) {
448 THROW_EXCEPTION("Cannot find the associated ms track from the primary track");
449 }
450 auto refPars = actsTrk->createParametersAtReference();
451 return isOnCaloExit(refPars) ? MuonCombinedR4::longitudinalParam(refPars, logger())
452 : refPars.get<Acts::eBoundLoc0>();
453 }));
454 msTracks->addVariable(std::make_unique<GenericPartDecorBranch<xAOD::TrackParticle, float>>(m_tree,
455 std::format("{:}_loc1", msTracks->name()), [&] (const xAOD::TrackParticle& p){
456 auto actsTrk = ActsTrk::getActsTrack(p);
457 if (!actsTrk) {
458 THROW_EXCEPTION("Cannot find the associated ms track from the primary track");
459 }
460 auto refPars = actsTrk->createParametersAtReference();
461 return isOnCaloExit(refPars) ? toDeg(MuonCombinedR4::localPolarAngle(refPars, logger()))
462 : refPars.get<Acts::eBoundLoc0>();
463 }));
464 msTracks->addVariable(std::make_unique<GenericPartDecorBranch<xAOD::TrackParticle, std::uint8_t>>(m_tree,
465 std::format("{:}_isOnCaloExit", msTracks->name()), [&] (const xAOD::TrackParticle& p){
466 auto actsTrk = ActsTrk::getActsTrack(p);
467 if (!actsTrk) {
468 THROW_EXCEPTION("Cannot find the associated ms track from the primary track");
469 }
470 return isOnCaloExit(actsTrk->referenceSurface());
471 }));
472 if (m_isMC) {
473 BilateralLinkerBranch::connectCollections(m_muonTrks, m_truthTrks,
474 [](const xAOD::IParticle* trk) -> const xAOD::TruthParticle* {
476 }, "truth", "ActsMuon");
477 }
478
479 for (const auto& summary : trackSummaries) {
480 m_muonTrks->addVariable<uint8_t>(summary);
481 }
482 m_tree.addBranch(m_muonTrks);
483
484 m_tree.addBranch(m_seedSummary);
485
486 ATH_CHECK(m_trkTruthLinks.initialize());
487 ATH_CHECK(m_tree.init(this));
488 return StatusCode::SUCCESS;
489 }
490
492 const EventContext& ctx) const {
494 if (!truthTrk || !m_truthTrks) {
495 return nullptr;
496 }
497 for (const xAOD::IParticle* thisPart : m_truthTrks->getCached(ctx)) {
498 if (thisPart == truthTrk || truthTrk == xAOD::TruthHelpers::getTruthParticle(*thisPart)) {
499 return dynamic_cast<const xAOD::TruthParticle*>(thisPart);
500 }
501 }
502 return nullptr;
503 }
504
506 const EventContext& ctx) const {
507 return findTagMatchingToId(idTrack, m_idTagKey, ctx);
508 }
510 const EventContext& ctx) const {
511 return findTagMatchingToId(idTrack, m_segTagKey, ctx);
512 }
513
514 std::vector<const xAOD::MuonSegment*>
516 const EventContext& ctx) const {
517 std::vector<const xAOD::MuonSegment*> compatibleSegs{};
518 if (const xAOD::TruthParticle* truthPart = truthTreeParticle(idTrack, ctx); truthPart != nullptr) {
519 std::vector<const xAOD::MuonSegment*> truthSegs = getTruthSegments(*truthPart);
520 const xAOD::MuonSegmentContainer* recoSegs{nullptr};
521 SG::get(recoSegs, m_recoSegmentKey, ctx).ignore();
522 std::copy_if(recoSegs->begin(), recoSegs->end(), std::back_inserter(compatibleSegs),
523 [&truthSegs](const xAOD::MuonSegment* recoSeg){
524 return Acts::rangeContainsValue(truthSegs, getMatchedTruthSegment(*recoSeg));
525 });
526 if (!compatibleSegs.empty()) {
527 return compatibleSegs;
528 }
529 }
530
531 const xAOD::MuonContainer* muons{nullptr};
532 SG::get(muons,m_muonKey, ctx).ignore();
533 for (const xAOD::Muon* muon : *muons) {
534 if (muon->trackParticle(xAOD::Muon::TrackParticleType::InnerDetectorTrackParticle) == &idTrack) {
535 for (std::size_t s = 0; s < muon->nMuonSegments() ; ++s) {
536 compatibleSegs.push_back(muon->muonSegment(s));
537 }
538 break;
539 }
540 }
541 return compatibleSegs;
542 }
543
545 return m_detMgr->getSectorEnvelope(segment.chamberIndex(), segment.sector(), segment.etaIndex());
546 }
547
550 const EventContext& ctx) {
551
552 SegmentTagVariables result{};
554 const std::vector<const xAOD::MuonSegment*> compatibleSegs = getAssociatedSegments(idTrack, ctx);
555 if (compatibleSegs.empty()) {
556 return result;
557 }
559 const ActsTrk::CaloExtension* caloExt = ActsTrk::getCaloExtension(idTrack);
560 if (!caloExt) {
561 return result;
562 }
563 std::optional<Acts::BoundTrackParameters> startPars = caloExt->lastParameters();
564 if (!startPars) {
565 return result;
566 }
567
568 const MuonR4::MuonTag* muTag = findMuTagIMO(idTrack, ctx);
569
570 const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(ctx);
571
572 auto nextParameters = [&](const xAOD::MuonSegment& segment) {
574 const MuonGMR4::SpectrometerSector* msSector = getEnvelope(segment);
575 const Acts::Surface& target{msSector->surface()};
576 if (target.geometryId() == startPars->referenceSurface().geometryId()) {
577 return true;
578 }
579 if (muTag) {
580 auto surfPars = muTag->extrapolatedParsID(Acts::toUnderlying(segment.chamberIndex()));
581 if (surfPars) {
582 startPars = surfPars;
583 ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Recycle cached parameters from muTag\n"
584 <<(*startPars));
585 return true;
586 }
587 ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Extrapolation to "<<printID(segment)<<" failed somehow");
588 }
589
590 auto extpPars = m_extrapolationTool->propagate(ctx, *startPars, target);
591 if (!extpPars.ok()) {
592 ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Extrapolation keeps failing");
593 return false;
594 }
595 ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Updated parameters to \n"<<(*extpPars));
596 startPars = *extpPars;
597 return true;
598 };
599
600 const xAOD::MuonSegment* bestSeg{nullptr};
601 float bestMatchScore{std::numeric_limits<float>::max()};
602 Acts::BoundVector bestPars{Acts::BoundVector::Zero()};
603
604 auto dumpBestSeg = [&]() {
605 if (!bestSeg) {
606 return;
607 }
608 result.recoSegs.push_back(m_recoSegs->push_back(*bestSeg));
609 result.matchScores.push_back(bestMatchScore);
610 result.deltaPhi.push_back(toDeg(bestPars[Acts::eBoundPhi]));
611 result.deltaTheta.push_back(toDeg(bestPars[Acts::eBoundTheta]));
612 result.deltaY0.push_back(bestPars[Acts::eBoundLoc1]);
613 result.deltaX0.push_back(bestPars[Acts::eBoundLoc0]);
614 result.goodExtp.push_back(1);
615 result.taggedSeg.push_back(muTag && Acts::rangeContainsValue(muTag->segments(), bestSeg));
616 bestSeg = nullptr;
617 bestMatchScore = std::numeric_limits<float>::max();
618 bestPars = Acts::BoundVector::Zero();
619 };
620
621 for (auto segItr = compatibleSegs.begin(); segItr != compatibleSegs.end(); ) {
622 const xAOD::MuonSegment* testMe{*segItr};
624 if (!nextParameters(*testMe)) {
625 result.recoSegs.push_back(m_recoSegs->push_back(*testMe));
626 result.matchScores.push_back(-1.f);
627 result.deltaX0.push_back(1._m);
628 result.deltaY0.push_back(1._m);
629 result.deltaTheta.push_back(180.);
630 result.deltaPhi.push_back(180.);
631 result.goodExtp.push_back(0);
632 result.taggedSeg.push_back(0);
633 segItr = std::find_if(std::next(segItr),compatibleSegs.end(), [&](const xAOD::MuonSegment* assocSeg){
634 return getEnvelope(*testMe) != getEnvelope(*assocSeg);
635 });
636 } else {
637 ++segItr;
638 }
640 if (bestSeg && getEnvelope(*testMe) != getEnvelope(*bestSeg)) {
641 dumpBestSeg();
642 }
643 const Acts::BoundTrackParameters segmentPars{MuonR4::SegmentFit::boundSegmentPars(tgContext, *m_detMgr, *testMe)};
644 Acts::BoundVector dPars = segmentPars.parameters() - startPars->parameters();
646 if (!testMe->nPhiLayers()) {
647 dPars[Acts::eBoundPhi] = dPars[Acts::eBoundLoc0] = 0.;
648 } else {
649 dPars[Acts::eBoundPhi] = P4Helpers::deltaPhi(dPars[Acts::eBoundPhi], 0.);
650 }
651
652 dPars[Acts::eBoundQOverP] = dPars[Acts::eBoundTime] = 0.;
653 Acts::BoundMatrix covariance{Acts::BoundMatrix::Identity()};
654 covariance(Acts::eBoundLoc0, Acts::eBoundLoc0) = Acts::square(m_toleranceX0.value());
655 covariance(Acts::eBoundLoc1, Acts::eBoundLoc1) = Acts::square(m_toleranceY0.value());
656 covariance(Acts::eBoundTheta, Acts::eBoundTheta) = Acts::square(m_toleranceTheta.value());
657 covariance(Acts::eBoundPhi, Acts::eBoundPhi) = Acts::square(m_tolerancePhi.value());
658 if (startPars->covariance()) {
659 covariance += (*startPars->covariance());
660 }
661 if (segmentPars.covariance()) {
662 covariance += (*segmentPars.covariance());
663 }
664 const float chi2 = dPars.dot(covariance.inverse()*dPars);
665 ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Difference: "<<Acts::toString(dPars)
666 <<", covariance: \n"<<Acts::toString(covariance)<<",\nchi2: "<<chi2);
667 if (chi2 < bestMatchScore) {
668 ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Best parameters on surface thus far");
669 bestMatchScore = chi2;
670 bestSeg = testMe;
671 bestPars = std::move(dPars);
672 }
673 }
674 dumpBestSeg();
675 return result;
676 }
677
678
679 StatusCode MsTrackTester::dumpLegacyTracks(const EventContext& ctx) {
680
681 //This for now is to be able to retrieve the matching between the legacy segments and tracks ...
682 const xAOD::MuonContainer* legacyMuons{nullptr};
683 ATH_CHECK(SG::get(legacyMuons, m_legacyMuonKey, ctx));
684
685 if (!legacyMuons) {
686 return StatusCode::SUCCESS;
687 }
688
689 for (const xAOD::Muon* muon : *legacyMuons) {
690 ATH_MSG_VERBOSE("iMuon " << muon->index() << " pT: "<<(muon->pt() *MeVtoGeV)<<" [GeV], eta: "
691 <<muon->eta() <<", phi: "<<toDeg(muon->phi())<<", q: "<<muon->charge()
692 <<", nSegments: "<<muon->nMuonSegments());
693 const xAOD::TrackParticle* track = muon->trackParticle(xAOD::Muon::TrackParticleType::MuonSpectrometerTrackParticle);
694 if (!track) {
695 continue;
696 }
697 m_summaryTool->copySummary(m_summaryTool->makeSummary(ctx, *track->track()), *track);
698 m_legacyTrks->push_back(track);
699 auto trkIdx = m_legacyTrks->find(track);
700 for (size_t s = 0; s < muon->nMuonSegments(); ++s) {
701 const xAOD::MuonSegment* segment = muon->muonSegment(s);
702 auto segIdx = m_legacyRecoSegs->push_back(*segment);
703 ATH_MSG_VERBOSE(std::format( "Legacy muon-segment link: segment {:} @{:}, eta: {:.2f}, phi {:.2f}",
704 printID(*segment), Amg::toString(segment->position()),
705 segment->direction().eta(), toDeg(segment->direction().phi())));
706 m_legacySegToTrkLinks[segIdx] = trkIdx;
707 }
708 }
709
710 //Dump also legacy segments
711 const xAOD::MuonSegmentContainer* legacyRecoSegs{nullptr};
712 ATH_CHECK(SG::get(legacyRecoSegs, m_legacySegmentKey, ctx));
713
714 if (legacyRecoSegs->size()) {
715 m_legacySegToTrkLinks[legacyRecoSegs->size()-1];
716 for (const xAOD::MuonSegment* seg : *legacyRecoSegs) {
717 //Store all segments
718 m_legacyRecoSegs->push_back(*seg);
719 }
720 }
721
722 const xAOD::TrackParticleContainer* legacyTrks{nullptr};
723 ATH_CHECK(SG::get(legacyTrks, m_legacyTrackKey, ctx));
724
725 for (const xAOD::TrackParticle* track : *legacyTrks) {
726 m_summaryTool->copySummary(m_summaryTool->makeSummary(ctx, *track->track()), *track);
727 m_legacyTrks->push_back(track);
728 }
729
730 return StatusCode::SUCCESS;
731 }
732 StatusCode MsTrackTester::dumpTruthContent(const EventContext& ctx) {
733 if (!m_isMC) {
734 return StatusCode::SUCCESS;
735 }
736 const xAOD::MuonSegmentContainer* truthSegs{nullptr};
737 ATH_CHECK(SG::get(truthSegs, m_truthSegmentKey, ctx));
738
739
740 for (const xAOD::MuonSegment* seg : *truthSegs) {
741 ATH_MSG_VERBOSE("Dump truth segment "<<printID(*seg)<<" @"<<
742 Amg::toString(seg->position())<<", eta: "<<seg->direction().eta()
743 <<", phi: "<<toDeg(seg->direction().phi()));
744 m_truthSegs->push_back(*seg);
745 }
746 if (truthSegs->size()) {
747 m_truthSegToRecoLink[truthSegs->size()-1];
748 }
749
750
751 const xAOD::TruthParticleContainer* truthMuons{nullptr};
752 ATH_CHECK(SG::get(truthMuons, m_truthKey, ctx));
753 const std::size_t nT = truthMuons->size() - 1;
754 if (!truthMuons->empty()) {
759 }
760 for (const xAOD::TruthParticle* truth : *truthMuons) {
761 ATH_MSG_DEBUG("Truth muon: pT: "<<(truth->pt() *MeVtoGeV)
762 <<", eta: "<<truth->eta()<<", phi: "<<toDeg(truth->phi())<<", q: "<<truth->charge()
763 <<", uuid: "<<HepMC::uniqueID(truth));
764 m_truthTrks->push_back(*truth);
765 }
766
767 return StatusCode::SUCCESS;
768 }
769 StatusCode MsTrackTester::dumpRecoContent(const EventContext& ctx) {
770 const xAOD::MuonContainer* muons{nullptr};
771 ATH_CHECK(SG::get(muons, m_muonKey, ctx));
773 const xAOD::MuonSegmentContainer* recoSegments{nullptr};
774 ATH_CHECK(SG::get(recoSegments, m_recoSegmentKey, ctx));
775
776 const MuonR4::MsTrackSeedContainer* trkSeeds{nullptr};
777 ATH_CHECK(SG::get(trkSeeds, m_msTrkSeedKey, ctx));
778
779 const xAOD::TrackParticleContainer* idTracks{nullptr};
780 ATH_CHECK(SG::get(idTracks, m_idTrackKey, ctx));
781
782 const MuonR4::MuonTagContainer* idTags{nullptr};
783 ATH_CHECK(SG::get(idTags, m_idTagKey, ctx));
784
785 const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(ctx);
786 const Acts::MagneticFieldContext mfContext = m_ctxProvider.getMagneticFieldContext(ctx);
787
788 MagField::AtlasFieldCache magField{};
789 mfContext.get<const AtlasFieldCacheCondObj*>()->getInitializedCache(magField);
790
791 std::unordered_map<const xAOD::TruthParticle*,
792 std::vector<unsigned>> truthToSeedMatchCounter{};
793
794 if (!trkSeeds->empty()) {
795 m_seedTruthLink[trkSeeds->size() -1];
796 }
797
798 for (const MuonR4::MsTrackSeed& seed : *trkSeeds) {
799 unsigned int seedIdx = m_seedPos.size();
800 m_seedPos += seed.position();
801 m_seedType+= Acts::toUnderlying(seed.location());
802 m_seedSector += seed.sector().sector();
803 m_seedSummary->push_back(ctx, seed);
804
805 auto startPars = m_seedingTool->estimateStartParameters(ctx, seed);
806 if (startPars.ok()) {
807 m_seedDir += (*startPars).direction();
808 } else {
809 m_seedDir += Amg::Vector3D::UnitZ();
810 }
811 // m_seedDir
812 ATH_MSG_VERBOSE(" Dump new seed: "<<seed);
813 for (const xAOD::MuonSegment* seg : seed.segments()){
814 m_seedRecoSegMatch[seedIdx].push_back(m_recoSegs->push_back(*seg));
815 if (const xAOD::MuonSegment* truthSeg = MuonR4::getMatchedTruthSegment(*seg);
816 truthSeg != nullptr) {
817 std::vector<unsigned>& matchCounter = truthToSeedMatchCounter[MuonR4::getTruthMatchedParticle(*truthSeg)];
818 if (seedIdx >= matchCounter.size()) {
819 matchCounter.resize(seedIdx +1);
820 }
821 ++matchCounter[seedIdx];
822 }
823 }
824 const auto[seedLength, theta] = calcSeedLength(tgContext, seed);
825 m_seedLength+= seedLength;
827 m_seedQP += m_seedingTool->estimateQtimesP(tgContext, seed, magField) / Gaudi::Units::GeV;
828 m_seedGood += startPars.ok();
829 }
831 for (auto& [truthMuon, matches] : truthToSeedMatchCounter) {
832 const unsigned tIndex = m_truthTrks->find(truthMuon);
833 if (tIndex >= m_truthTrks->size()) {
834 continue;
835 }
837 while (std::count_if(matches.begin(), matches.end(),
838 [](const unsigned nMatched){
839 return nMatched > 0;
840 })) {
841 auto bestMatch = std::ranges::max_element(matches);
842 const std::size_t seedIdx = std::distance(matches.begin(), bestMatch);
843 m_truthMuToSeedIdx[tIndex].push_back(seedIdx);
844
845 m_seedTruthLink[seedIdx] = tIndex;
846 m_truthMuToSeedCounter[tIndex].push_back(*bestMatch);
847 (*bestMatch) = 0;
848 }
849 }
850
851 for (const xAOD::Muon* muon : *muons) {
852 m_muonTrks->push_back(muon);
853 }
854
855 for (const xAOD::MuonSegment* seg : *recoSegments) {
856 m_recoSegs->push_back(*seg);
857 }
858
860 if (idTracks) {
861 m_nIdTracks = idTracks->size();
862 for (const xAOD::TrackParticle* idTrk : *idTracks) {
863 if (m_truthTrks->find([idTrk](const xAOD::IParticle* p){
864 return xAOD::TruthHelpers::getTruthParticle(*idTrk) ==
865 xAOD::TruthHelpers::getTruthParticle(*p);
866 }) < m_truthTrks->size()) {
867 m_idTracks->push_back(idTrk);
868 }
869 }
870 }
871 if (idTags) {
872 m_nIdTags = idTags->size();
873 for (const MuonR4::MuonTag* idTag : *idTags) {
875 if (idTag->extrapolatedParsID(Acts::hashString("@CaloExit"))){
876 m_idTracks->push_back(idTag->idTrack());
877 }
878 }
879 }
880 return StatusCode::SUCCESS;
881 }
882 StatusCode MsTrackTester::execute(const EventContext& ctx) {
886
887 ATH_CHECK(m_tree.fill(ctx));
888 return StatusCode::SUCCESS;
889 }
891 ATH_CHECK(m_tree.write());
892 return StatusCode::SUCCESS;
893 }
894}
Scalar phi() const
phi method
Scalar theta() const
theta method
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_DEBUG(x,...)
#define ATH_MSG_WARNING(x,...)
#define ATH_MSG_VERBOSE(x,...)
double length(const pvec &v)
static Double_t a
Handle class for reading from StoreGate.
std::unique_ptr< const Acts::Logger > makeActsAthenaLogger(IMessageSvc *svc, const std::string &name, int level, std::optional< std::string > parent_name)
Definition Logger.cxx:64
#define min(a, b)
Definition cfImp.cxx:40
#define max(a, b)
Definition cfImp.cxx:41
The CaloExtension holds the ID extrapolation states through the calorimeter and the associated CaloCl...
std::optional< Acts::BoundTrackParameters > lastParameters() const
Returns the outermost parameters known to the extension.
const ServiceHandle< StoreGateSvc > & detStore() const
StatusCode addVariable(const std::string &name, T *&ptr, std::string_view docstring="")
Add a variable to the tuple.
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
size_type size() const noexcept
Returns the number of elements in the collection.
bool empty() const noexcept
Returns true if the collection is empty.
Local cache for magnetic field (based on MagFieldServices/AtlasFieldSvcTLS.h).
A spectrometer sector forms the envelope of all chambers that are placed in the same MS sector & laye...
const Acts::PlaneSurface & surface() const
Returns the associated surface.
void addSegment(const xAOD::MuonSegment *seg)
Append a segment to the seed.
Location
Enum defining whether the seed is made in the endcap / barrel.
Definition MsTrackSeed.h:25
void setPosition(Amg::Vector3D &&pos)
set the seed's position
Baseline EDM object to gather all relevant information about a reconstructed muon candidate which can...
Definition MuonTag.h:25
std::optional< Acts::BoundTrackParameters > extrapolatedParsID(const Acts::HashedString &parName) const
Returns the cached extrapolated ID track parameters.
Definition MuonTag.cxx:76
const std::vector< const xAOD::MuonSegment * > & segments() const
Returns the segments associated with the tag.
Definition MuonTag.cxx:12
ToolHandle< MuonR4::ITrackSeedingDiagnosticsTool > m_seedingTool
The track seeding tool to construct the seed candidates and to estimate the initial parameters.
const MuonGMR4::MuonDetectorManager * m_detMgr
The detector manager to fetch the segment surfaces.
MuonVal::ScalarBranch< std::uint16_t > & m_nIdTags
The number of selected ID tracks in the event.
ToolHandle< MuonR4::ITrackSummaryTool > m_summaryTool
Hit summary tool.
StatusCode dumpLegacyTracks(const EventContext &ctx)
Dumps the legacy containers to the TTree.
SegmentKey_t m_legacySegmentKey
Legacy segment container.
const MuonR4::MuonTag * findBaseIdTag(const xAOD::TrackParticle &idTrack, const EventContext &ctx) const
Searches the Id track in the basline collection of all ID tracks selected for the combined muon recon...
const MuonGMR4::SpectrometerSector * getEnvelope(const xAOD::MuonSegment &segment) const
MuonTagKey_t m_idTagKey
The collection of all ID tracks that are selected for combined reconstruction.
TrackKey_t m_idTrackKey
The collection of ID tracks associated with the truth particle.
MuonVal::VectorBranch< unsigned short > & m_legacySegToTrkLinks
Link of the legacy track to the legacy segment.
ParticleBranchPtr_t m_truthTrks
MuonVal::VectorBranch< int > & m_seedSector
Sector of the seed, even center, odd overlap regions, for details see:
MuonVal::VectorBranch< float > & m_seedThetaCone
Maximum angular difference between the segments part of the seed.
ParticleBranchPtr_t m_legacyTrks
Output branches of the legacy MS tracks.
SegmentBranchPtr_t m_truthSegs
SegmentBranchPtr_t m_legacyRecoSegs
MuonVal::ScalarBranch< std::uint16_t > & m_nIdTracks
The number of ID tracks in the event.
MuonVal::MatrixBranch< unsigned short > & m_truthMuRecoSegLinks
Links from the truth muon to the segments.
std::unique_ptr< const Acts::Logger > m_logger
Instance to the Acts logger.
MuonVal::MatrixBranch< unsigned short > & m_truthMuToSeedIdx
Links to all MsTrkSeeds that could be matched to the truthMuon, i.e.
TrackKey_t m_legacyTrackKey
Legacy track reconstruction chain.
std::pair< double, double > calcSeedLength(const Acts::GeometryContext &tgContext, const MuonR4::MsTrackSeed &seed) const
Calculate the length of the seed and the theta deflection angle The length is defined as the spread o...
StatusCode execute(const EventContext &ctx) override final
Execute method.
SegmentTagVariables calcSegTagVariables(const xAOD::TrackParticle &idTrack, const EventContext &ctx)
MuonTagKey_t m_segTagKey
The collection of the original segment tags.
MuonVal::VectorBranch< char > & m_seedType
Is the seed in the encap or in the barrel chambers.
StatusCode dumpRecoContent(const EventContext &ctx)
Dump the reconstructed information.
SG::ReadHandleKey< xAOD::TruthParticleContainer > m_truthKey
Key to the truth particle collection.
Gaudi::Property< double > m_toleranceTheta
Extra tolerance applied on the bending direction when calculating the matching score.
Gaudi::Property< bool > m_isMC
Toggle whether the job runs on MC or not.
ParticleBranchPtr_t m_muonTrks
Stored muon information from the Acts muon reco chain.
MuonVal::MatrixBranch< unsigned short > & m_truthSegToRecoLink
Link of the truth segments to the matchin reco segments.
Gaudi::Property< double > m_toleranceX0
Extra tolerance applied on the non-bending intercept when calculating the matching score.
SegmentBranchPtr_t m_recoSegs
StatusCode dumpTruthContent(const EventContext &ctx)
Dump truth information.
SG::ReadHandleKey< MuonR4::MsTrackSeedContainer > m_msTrkSeedKey
Temporary container write handle to push the seeds to store gate for later efficiency analysis.
Gaudi::Property< bool > m_storeID
Toggle whether to process ID tracks or not.
ToolHandle< ActsTrk::IExtrapolationTool > m_extrapolationTool
Track extrapolation tool.
const xAOD::TruthParticle * truthTreeParticle(const xAOD::IParticle &part, const EventContext &ctx) const
Returns the matched truth particle that is dumped in the tree.
const MuonR4::MuonTag * findMuTagIMO(const xAOD::TrackParticle &idTrack, const EventContext &ctx) const
ParticleBranchPtr_t m_idTracks
Stored ID track information.
StatusCode initialize() override final
MuonVal::MatrixBranch< unsigned short > & m_seedRecoSegMatch
Link of the track seed to the building segment.
MuonVal::VectorBranch< float > & m_seedQP
Estimated momentum times charge from the track seed.
MuonVal::MatrixBranch< unsigned short > & m_truthMuToSeedCounter
Number of matched segments in the seed.
MuonVal::ThreeVectorBranch m_seedPos
Simple seed information.
Gaudi::Property< double > m_tolerancePhi
Extra tolerance applied on the bending direction when calculating the matching score.
MuonKey_t m_legacyMuonKey
Legacy muons.
MuonVal::VectorBranch< float > & m_seedLength
Maximum separation between the segments on the reference plane.
MuonVal::UnitThreeVectorBranch m_seedDir
Seed direction vector.
ToolHandle< MuonR4::ISegmentSelectionTool > m_segSelector
Selection tool to quantify the segment candidate quality.
SegmentKey_t m_recoSegmentKey
Primary segment container.
MuonVal::MuonTesterTree m_tree
The output tree object.
std::vector< const xAOD::MuonSegment * > getAssociatedSegments(const xAOD::TrackParticle &idTrack, const EventContext &ctx) const
Returns the collection of reconstructed segments that can be associated to the id track If the track ...
ActsTrk::ContextUtility m_ctxProvider
Context provider for geometry, magnetic field and calibration contexts.
SegmentKey_t m_truthSegmentKey
Segment from the truth hits.
MuonVal::VectorBranch< char > & m_seedGood
Does the seeding tool construct valid parameters from the seed.
std::optional< MuonR4::MsTrackSeed > makeSeedFromTruth(const Acts::GeometryContext &tgContext, const xAOD::TruthParticle &truthMuon) const
Construct MS track seed from the truth associated segments.
StatusCode finalize() override final
std::shared_ptr< TrackSummaryModule > m_seedSummary
Hit summary on the track seed.
Gaudi::Property< double > m_toleranceY0
Extra tolerance applied on the bending intercept when calculating the matching score.
MuonVal::VectorBranch< unsigned short > & m_seedTruthLink
Link to the truth muon.
MuonKey_t m_muonKey
Dependency on the R4 muon container.
static bool connectCollections(ParticleBranch_ptr primColl, ParticleBranch_ptr secondColl, Linker_t fromPrimToSec, const std::string &altPrimName="", const std::string &altSecName="")
@ isMC
Flag determining whether the branch is simulation.
Generic branch object where the information is evaluated by a std::function instead reading it from t...
Property holding a SG store/key/clid from which a ReadHandle is made.
Class providing the definition of the 4-vector interface.
Amg::Vector3D direction() const
Returns the direction as Amg::Vector.
::Muon::MuonStationIndex::ChIndex chamberIndex() const
Returns the chamber index.
Amg::Vector3D position() const
Returns the position as Amg::Vector.
int etaIndex() const
Returns the eta index, which corresponds to stationEta in the offline identifiers (and the ).
std::uint8_t nPhiLayers() const
Returns the number of trigger phi hits.
double chi2(TH1 *h0, TH1 *h1)
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition hcg.cxx:132
static Root::TMsgLogger logger("iLumiCalc")
constexpr std::size_t s_caloEnvelopeID
Volume Ids ofthe Calorimeter.
const CaloExtension * getCaloExtension(const xAOD::TrackParticle &track)
Retrieve a pointer to the CaloExtension linked with the passed TrackParticle.
std::optional< ActsTrk::TrackContainer::ConstTrackProxy > getActsTrack(const xAOD::TrackParticle &trkPart)
Return the proxy to the Acts track from which the track particle was made frome.
Definition Decoration.cxx:9
std::string toString(const Translation3D &translation, int precision=4)
GeoPrimitvesToStringConverter.
Eigen::Matrix< double, 2, 1 > Vector2D
constexpr float MeVtoGeV
ID3PD * m_tree
Pointer to the ID3PD object used.
for(size_t i=0;i< m_blockFillers.size();i++)
Fill one block.
int uniqueID(const T &p)
double localPolarAngle(const Acts::BoundTrackParameters &pars, const Acts::Logger &logger)
Returns the local angular polar angle of the track parameter.
double longitudinalParam(const Acts::BoundTrackParameters &pars, const Acts::Logger &logger)
Returns the longitudinal local track parameter which is defined as.
Acts::BoundTrackParameters boundSegmentPars(const ActsTrk::GeometryContext &gctx, const MuonGMR4::MuonDetectorManager &detMgr, const xAOD::MuonSegment &segment, const Acts::ParticleHypothesis hypot=Acts::ParticleHypothesis::muon())
Returns the segment parameters as boundTrackParameters.
This header ties the generic definitions in this package.
const xAOD::TruthParticle * getTruthMatchedParticle(const xAOD::MuonSegment &segment)
Returns the particle truth-matched to the segment.
std::vector< MsTrackSeed > MsTrackSeedContainer
Definition MsTrackSeed.h:96
std::string printID(const xAOD::MuonSegment &seg)
Print the chamber ID of a segment, e.g.
std::vector< const xAOD::MuonSimHit * > getMatchingSimHits(const xAOD::MuonSegment &segment)
: Returns all sim hits matched to a xAOD::MuonSegment
std::vector< const xAOD::MuonSegment * > getTruthSegments(const xAOD::TruthParticle &truthMuon)
Returns the segments associated to the truth muon.
DataVector< MuonTag > MuonTagContainer
Definition MuonTag.h:125
const xAOD::MuonSegment * getMatchedTruthSegment(const xAOD::MuonSegment &segment)
Returns the truth-matched segment.
Lightweight algorithm to read xAOD MDT sim hits and (fast-digitised) drift circles from SG and fill a...
Class to store array like branches into the n-tuples.
Definition HitValAlg.cxx:19
LayerIndex toLayerIndex(ChIndex index)
convert ChIndex into LayerIndex
double deltaPhi(double phiA, double phiB)
delta Phi in range [-pi,pi[
Definition P4Helpers.h:34
AuxElement(SG::AuxVectorData *container, size_t index)
Base class for elements of a container that can have aux data.
const T * get(const ReadCondHandleKey< T > &key, const EventContext &ctx)
Convenience function to retrieve an object given a ReadCondHandleKey.
bool dPhi(const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, float &out)
const xAOD::TruthParticle * getTruthParticle(const xAOD::IParticle &p)
Return the truthParticle associated to the given IParticle (if any).
MuonSegmentContainer_v1 MuonSegmentContainer
Definition of the current "MuonSegment container version".
TrackParticle_v1 TrackParticle
Reference the current persistent version:
MuonSimHit_v1 MuonSimHit
Defined the version of the MuonSimHit.
Definition MuonSimHit.h:12
TruthParticle_v1 TruthParticle
Typedef to implementation.
TrackParticleContainer_v1 TrackParticleContainer
Definition of the current "TrackParticle container version".
Muon_v1 Muon
Reference the current persistent version:
Definition Muon.h:13
setWord1 uint16_t
MuonContainer_v1 MuonContainer
Definition of the current "Muon container version".
MuonSegment_v1 MuonSegment
Reference the current persistent version:
TruthParticleContainer_v1 TruthParticleContainer
Declare the latest version of the truth particle container.
#define THROW_EXCEPTION(MESSAGE)
Definition throwExcept.h:10