ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Private Attributes | List of all members
L0Muon::TgcL0FloatingCandidateBuilderTool Class Referencefinal

#include <TgcL0FloatingCandidateBuilderTool.h>

Inheritance diagram for L0Muon::TgcL0FloatingCandidateBuilderTool:
Collaboration diagram for L0Muon::TgcL0FloatingCandidateBuilderTool:

Public Member Functions

StatusCode initialize () override
StatusCode build (const TgcRdoContainer &rdos, TgcL0CandidateContainer &candidates, const EventContext &ctx) const override
 Build candidates from TGC RDO data.
StatusCode build (const TgcRdoContainer &rdos, TgcL0CandidateContainer &candidates, TgcL0SegmentContainer *segments, const EventContext &ctx) const override
 Build candidates from TGC RDO data.

Private Attributes

ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
SG::ReadCondHandleKey< Muon::TgcCablingMap > m_cablingKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_detectorManagerKey
Gaudi::Property< float > m_maxPivotWireStripDeltaEta
Gaudi::Property< float > m_maxPivotWireStripDeltaPhi
Gaudi::Property< unsigned int > m_maxSegmentCombinationsPerGroup
Gaudi::Property< unsigned int > m_maxCandidatesPerLocalBin
Gaudi::Property< std::string > m_ptCalibrationFile
std::unique_ptr< const TgcL0FloatingPtLut > m_ptLut {}

Detailed Description

Definition at line 21 of file TgcL0FloatingCandidateBuilderTool.h.

Member Function Documentation

◆ build() [1/2]

StatusCode L0Muon::TgcL0FloatingCandidateBuilderTool::build ( const TgcRdoContainer & rdos,
TgcL0CandidateContainer & candidates,
const EventContext & ctx ) const
override

Build candidates from TGC RDO data.

Parameters
rdosInput TGC RDO container.
candidatesOutput candidate collection.
ctxEvent context.

Definition at line 85 of file TgcL0FloatingCandidateBuilderTool.cxx.

87 {
88 return build(rdos, candidates, nullptr, ctx);
89}
L0Muon::TgcL0FloatingCandidateBuilderTool::build
StatusCode build(const TgcRdoContainer &rdos, TgcL0CandidateContainer &candidates, const EventContext &ctx) const override
Build candidates from TGC RDO data.
Definition TgcL0FloatingCandidateBuilderTool.cxx:85

◆ build() [2/2]

StatusCode L0Muon::TgcL0FloatingCandidateBuilderTool::build ( const TgcRdoContainer & rdos,
TgcL0CandidateContainer & candidates,
TgcL0SegmentContainer * segments,
const EventContext & ctx ) const
override

Build candidates from TGC RDO data.

Parameters
rdosInput TGC RDO container.
candidatesOutput candidate collection.
ctxEvent context.

Definition at line 91 of file TgcL0FloatingCandidateBuilderTool.cxx.

93 {
94
95 const Muon::TgcCablingMap* cabling{};
96 ATH_CHECK(SG::get(cabling, m_cablingKey, ctx));
97
98 SG::ReadCondHandle<MuonGM::MuonDetectorManager> detectorManagerHandle{
99 m_detectorManagerKey, ctx};
100 if (!detectorManagerHandle.isValid()) {
101 ATH_MSG_ERROR("Failed to retrieve " << m_detectorManagerKey.fullKey());
102 return StatusCode::FAILURE;
103 }
104 const MuonGM::MuonDetectorManager* detectorManager =
105 detectorManagerHandle.cptr();
106
107 TgcL0Floating::HitGroups hitGroups;
108 TgcL0Floating::DecodeStatistics statistics;
109 const TgcL0Floating::RdoDecoder decoder;
110 ATH_CHECK(decoder.decode(rdos, *cabling, *m_idHelperSvc, *detectorManager,
111 hitGroups, statistics));
112
113 TgcL0Floating::StationCoincidenceContainer coincidences;
114 const TgcL0Floating::StationCoincidenceBuilder coincidenceBuilder;
115 ATH_CHECK(coincidenceBuilder.build(hitGroups, coincidences));
116
117
118 TgcL0Floating::SegmentReconstructionConfig segmentConfig;
119 segmentConfig.maxPivotWireStripDeltaEta =
120 m_maxPivotWireStripDeltaEta.value();
121 segmentConfig.maxPivotWireStripDeltaPhi =
122 m_maxPivotWireStripDeltaPhi.value();
123 segmentConfig.maxSegmentCombinationsPerGroup =
124 m_maxSegmentCombinationsPerGroup.value();
125 segmentConfig.maxCandidatesPerLocalBin =
126 m_maxCandidatesPerLocalBin.value();
127 TgcL0Floating::SegmentStatistics segmentStatistics;
128 const TgcL0Floating::SegmentReconstruction segmentReconstruction{
129 std::move(segmentConfig)};
130 ATH_CHECK(segmentReconstruction.build(coincidences, candidates,
131 segmentStatistics, segments));
132
133 TgcL0Floating::OverlapClassificationStatistics overlapStatistics;
134 const TgcL0Floating::OverlapClassification overlapClassification;
135 overlapClassification.classify(candidates, overlapStatistics);
136
137 std::size_t nValidPtEstimates = 0U;
138 for (TgcL0Candidate& candidate : candidates) {
139 const TgcL0FloatingPtEvaluation evaluation =
140 m_ptLut->evaluate(candidate.eta, candidate.phi, candidate.deltaTheta);
141 if (!evaluation.ptEstimateValid) continue;
142 candidate.preInnerCoincidencePt = evaluation.ptEstimateGeV;
143 candidate.preInnerCoincidenceThreshold = evaluation.thresholdCode;
144 candidate.charge = evaluation.estimatedCharge;
145 ++nValidPtEstimates;
146 }
147 const std::size_t nInvalidPtEstimates =
148 candidates.size() - nValidPtEstimates;
149 ATH_MSG_DEBUG("Floating-pT evaluation: valid=" << nValidPtEstimates
150 << ", invalid="
151 << nInvalidPtEstimates);
152
153 CoincidenceQualityCounts totalCounts;
154 CoincidenceQualityCounts m1WireCounts;
155 CoincidenceQualityCounts m1StripCounts;
156 CoincidenceQualityCounts m2WireCounts;
157 CoincidenceQualityCounts m2StripCounts;
158 CoincidenceQualityCounts m3WireCounts;
159 CoincidenceQualityCounts m3StripCounts;
160
161 for (const TgcL0Floating::StationCoincidence& coincidence : coincidences) {
162 countCoincidenceQuality(coincidence, totalCounts);
163
164 CoincidenceQualityCounts* stationCounts{nullptr};
165 if (coincidence.station == TgcL0Floating::Station::M1) {
166 stationCounts = coincidence.isStrip ? &m1StripCounts : &m1WireCounts;
167 } else if (coincidence.station == TgcL0Floating::Station::M2) {
168 stationCounts = coincidence.isStrip ? &m2StripCounts : &m2WireCounts;
169 } else if (coincidence.station == TgcL0Floating::Station::M3) {
170 stationCounts = coincidence.isStrip ? &m3StripCounts : &m3WireCounts;
171 }
172 if (stationCounts != nullptr) {
173 countCoincidenceQuality(coincidence, *stationCounts);
174 }
175 }
176
177 ATH_MSG_DEBUG("Decoded " << statistics.nHits << " TGC hits from "
178 << statistics.nRawData << " raw-data words in "
179 << hitGroups.size() << " groups: wire="
180 << statistics.nWireHits << ", strip="
181 << statistics.nStripHits << ", M1="
182 << statistics.nM1Hits << ", M2="
183 << statistics.nM2Hits << ", M3="
184 << statistics.nM3Hits << ", inner="
185 << statistics.nInnerHits << ", unknown="
186 << statistics.nUnknownStation
187 << ", mapping failures="
188 << statistics.nMappingFailures
189 << "; station coincidences="
190 << coincidences.size() << " (3/3="
191 << totalCounts.nThreeOfThree << ", 2/3="
192 << totalCounts.nTwoOfThree << ", 1/3="
193 << totalCounts.nOneOfThree << ", 2/2="
194 << totalCounts.nTwoOfTwo << ", 1/2="
195 << totalCounts.nOneOfTwo << ")");
196
197 ATH_MSG_DEBUG("Station coincidence breakdown: M1 wire=(3/3="
198 << m1WireCounts.nThreeOfThree << ", 2/3="
199 << m1WireCounts.nTwoOfThree << ", 1/3="
200 << m1WireCounts.nOneOfThree << "), M1 strip=(2/2="
201 << m1StripCounts.nTwoOfTwo << ", 1/2="
202 << m1StripCounts.nOneOfTwo << "), M2 wire=(2/2="
203 << m2WireCounts.nTwoOfTwo << ", 1/2="
204 << m2WireCounts.nOneOfTwo << "), M2 strip=(2/2="
205 << m2StripCounts.nTwoOfTwo << ", 1/2="
206 << m2StripCounts.nOneOfTwo << "), M3 wire=(2/2="
207 << m3WireCounts.nTwoOfTwo << ", 1/2="
208 << m3WireCounts.nOneOfTwo << "), M3 strip=(2/2="
209 << m3StripCounts.nTwoOfTwo << ", 1/2="
210 << m3StripCounts.nOneOfTwo << ")");
211
212 ATH_MSG_DEBUG("Segment reconstruction: wire="
213 << segmentStatistics.nWireSegments << ", strip="
214 << segmentStatistics.nStripSegments << ", candidates="
215 << candidates.size() << " (M1M2M3="
216 << segmentStatistics.nM1M2M3Candidates << ", M1M2="
217 << segmentStatistics.nM1M2Candidates << ", M1M3="
218 << segmentStatistics.nM1M3Candidates << ", M2M3="
219 << segmentStatistics.nM2M3Candidates
220 << ", M1only="
221 << segmentStatistics.nM1OnlyPositionCandidates
222 << ", M2only="
223 << segmentStatistics.nM2OnlyPositionCandidates
224 << ", M3only="
225 << segmentStatistics.nM3OnlyPositionCandidates
226 << "), projectionRejected="
227 << segmentStatistics.nRejectedProjectionCombinations
228 << ", projectionDuplicates="
229 << segmentStatistics.nDuplicateProjectionSegments
230 << ", projectionLimited="
231 << segmentStatistics.nLimitedProjectionSegments
232 << ", pairRejected=" << segmentStatistics.nRejectedPairs
233 << ", candidateDuplicates="
234 << segmentStatistics.nDuplicateCandidates
235 << ", localDuplicates="
236 << segmentStatistics.nLocalDuplicateCandidates
237 << ", candidateLimited="
238 << segmentStatistics.nLimitedCandidates);
239
240 ATH_MSG_DEBUG("Overlap classification: groups="
241 << overlapStatistics.nGroups << ", candidates="
242 << overlapStatistics.nCandidates << ", maxMultiplicity="
243 << overlapStatistics.maxMultiplicity);
244
245 for (std::size_t groupId = 1U;
246 groupId <= overlapStatistics.nGroups; ++groupId) {
247 std::vector<std::size_t> memberIndices;
248 for (std::size_t index = 0U; index < candidates.size(); ++index) {
249 if (candidates[index].overlapGroupId == groupId) {
250 memberIndices.emplace_back(index);
251 }
252 }
253 if (memberIndices.empty()) continue;
254 std::ostringstream members;
255 for (std::size_t position = 0U; position < memberIndices.size(); ++position) {
256 if (position != 0U) members << ",";
257 members << memberIndices[position];
258 }
259 ATH_MSG_DEBUG("Overlap group detail: groupId="
260 << groupId << ", multiplicity=" << memberIndices.size()
261 << ", members=[" << members.str() << "]");
262 }
263
264 for (std::size_t candidateIndex = 0; candidateIndex < candidates.size();
265 ++candidateIndex) {
266 const TgcL0Candidate& candidate = candidates[candidateIndex];
267 ATH_MSG_DEBUG("Reconstructed candidate: index="
268 << candidateIndex << ", bcTag=" << candidate.bcTag
269 << ", subdetectorId=" << candidate.subdetectorId
270 << ", triggerSector=" << candidate.sectorId
271 << ", readoutSector=" << candidate.readoutSector
272 << ", stationMask="
273 << static_cast<unsigned int>(candidate.stationMask)
274 << ", wireStationMask="
275 << static_cast<unsigned int>(candidate.wireStationMask)
276 << ", stripStationMask="
277 << static_cast<unsigned int>(candidate.stripStationMask)
278 << ", positionStationMask="
279 << static_cast<unsigned int>(
280 candidate.positionStationMask)
281 << ", eta=" << candidate.eta << ", phi="
282 << candidate.phi << ", deltaTheta="
283 << candidate.deltaTheta << ", deltaPhi="
284 << candidate.deltaPhi << ", preInnerCoincidencePt="
285 << candidate.preInnerCoincidencePt
286 << ", preInnerCoincidenceThreshold="
287 << static_cast<unsigned int>(
288 candidate.preInnerCoincidenceThreshold)
289 << ", charge=" << static_cast<int>(candidate.charge)
290 << ", wireQuality="
291 << static_cast<unsigned int>(candidate.wireQuality)
292 << ", wireQualities=("
293 << static_cast<unsigned int>(candidate.m1WireQuality)
294 << ","
295 << static_cast<unsigned int>(candidate.m2WireQuality)
296 << ","
297 << static_cast<unsigned int>(candidate.m3WireQuality)
298 << "), stripQualities=("
299 << static_cast<unsigned int>(candidate.m1StripQuality)
300 << ","
301 << static_cast<unsigned int>(candidate.m2StripQuality)
302 << ","
303 << static_cast<unsigned int>(candidate.m3StripQuality)
304 << "), chambers=(M1:" << candidate.m1StationEta << "/"
305 << candidate.m1StationPhi << ", M2:"
306 << candidate.m2StationEta << "/" << candidate.m2StationPhi
307 << ", M3:" << candidate.m3StationEta << "/"
308 << candidate.m3StationPhi << "), overlapGroupId="
309 << candidate.overlapGroupId << ", overlapMultiplicity="
310 << static_cast<unsigned int>(candidate.overlapMultiplicity)
311 << ", inChamberOverlap=" << candidate.inChamberOverlap);
312 }
313
314
315
316 return StatusCode::SUCCESS;
317}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
L0Muon::TgcL0FloatingCandidateBuilderTool::m_ptLut
std::unique_ptr< const TgcL0FloatingPtLut > m_ptLut
Definition TgcL0FloatingCandidateBuilderTool.h:67
L0Muon::TgcL0FloatingCandidateBuilderTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition TgcL0FloatingCandidateBuilderTool.h:40
L0Muon::TgcL0FloatingCandidateBuilderTool::m_detectorManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_detectorManagerKey
Definition TgcL0FloatingCandidateBuilderTool.h:44
L0Muon::TgcL0FloatingCandidateBuilderTool::m_cablingKey
SG::ReadCondHandleKey< Muon::TgcCablingMap > m_cablingKey
Definition TgcL0FloatingCandidateBuilderTool.h:42
SG::ReadCondHandle::cptr
const_pointer_type cptr()
Definition ReadCondHandle.h:67
DeMoScan.index
str index
Definition DeMoScan.py:362
L0Muon::TgcL0Floating::HitGroups
std::map< HitGroupKey, HitContainer > HitGroups
Definition TgcL0FloatingData.h:52
L0Muon::TgcL0Floating::StationCoincidenceContainer
std::vector< StationCoincidence > StationCoincidenceContainer
Definition TgcL0FloatingData.h:106
SG::get
const T * get(const ReadCondHandleKey< T > &key, const EventContext &ctx)
Convenience function to retrieve an object given a ReadCondHandleKey.
Definition ReadCondHandle.h:282
Trk::position
const Amg::Vector3D & position() const
Method to retrieve the position of the Intersection.

◆ initialize()

StatusCode L0Muon::TgcL0FloatingCandidateBuilderTool::initialize ( )
override

Definition at line 54 of file TgcL0FloatingCandidateBuilderTool.cxx.

54 {
55 ATH_CHECK(m_idHelperSvc.retrieve());
56 ATH_CHECK(m_cablingKey.initialize());
57 ATH_CHECK(m_detectorManagerKey.initialize());
58
59 const std::string calibrationDirectory =
60 PathResolver::find_calib_directory("dev");
61 if (calibrationDirectory.empty()) {
62 ATH_MSG_ERROR("Could not resolve the GroupData development directory");
63 return StatusCode::FAILURE;
64 }
65 const std::string calibrationPath =
66 calibrationDirectory + "/" + m_ptCalibrationFile.value();
67 std::string error;
68 m_ptLut = TgcL0FloatingPtLut::loadAscii(calibrationPath, error);
69 if (!m_ptLut) {
70 ATH_MSG_ERROR("Failed to load Floating-pT calibration: " << error);
71 return StatusCode::FAILURE;
72 }
73 ATH_MSG_INFO("Loaded Floating-pT calibration "
74 << m_ptLut->version() << " from " << calibrationPath
75 << " (eta bins=" << m_ptLut->etaBins()
76 << ", folded-phi bins=" << m_ptLut->phiBinsPerFold()
77 << ", knots=" << m_ptLut->knotCount()
78 << ", mode="
79 << (m_ptLut->isDevelopmentPayload() ? "development"
80 : "production")
81 << ")");
82 return StatusCode::SUCCESS;
83}
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
L0Muon::TgcL0FloatingPtLut::loadAscii
static std::unique_ptr< TgcL0FloatingPtLut > loadAscii(const std::string &calibrationPath, std::string &error)
Load the human-readable calibration payload.
Definition TgcL0FloatingPtLut.cxx:71
PathResolver::find_calib_directory
static std::string find_calib_directory(const std::string &logical_file_name)
Definition PathResolver.cxx:294
get_generator_info.error
error
Definition get_generator_info.py:40

Member Data Documentation

◆ m_cablingKey

SG::ReadCondHandleKey<Muon::TgcCablingMap> L0Muon::TgcL0FloatingCandidateBuilderTool::m_cablingKey
private
Initial value:
{
this, "CablingKey", "MuonTgc_CablingMap"}

Definition at line 42 of file TgcL0FloatingCandidateBuilderTool.h.

42 {
43 this, "CablingKey", "MuonTgc_CablingMap"};

◆ m_detectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> L0Muon::TgcL0FloatingCandidateBuilderTool::m_detectorManagerKey
private
Initial value:
{
this, "DetectorManagerKey", "MuonDetectorManager"}

Definition at line 44 of file TgcL0FloatingCandidateBuilderTool.h.

44 {
45 this, "DetectorManagerKey", "MuonDetectorManager"};

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> L0Muon::TgcL0FloatingCandidateBuilderTool::m_idHelperSvc
private
Initial value:
{
this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Definition at line 40 of file TgcL0FloatingCandidateBuilderTool.h.

40 {
41 this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

◆ m_maxCandidatesPerLocalBin

Gaudi::Property<unsigned int> L0Muon::TgcL0FloatingCandidateBuilderTool::m_maxCandidatesPerLocalBin
private
Initial value:
{
this, "MaxCandidatesPerLocalBin", 8U,
"Maximum candidates retained per old Floating local eta-phi-pivot bin"}

Definition at line 57 of file TgcL0FloatingCandidateBuilderTool.h.

57 {
58 this, "MaxCandidatesPerLocalBin", 8U,
59 "Maximum candidates retained per old Floating local eta-phi-pivot bin"};

◆ m_maxPivotWireStripDeltaEta

Gaudi::Property<float> L0Muon::TgcL0FloatingCandidateBuilderTool::m_maxPivotWireStripDeltaEta
private
Initial value:
{
this, "MaxPivotWireStripDeltaEta", -1.F,
"Maximum auxiliary eta-coordinate difference for same-station wire-strip association; negative disables the check"}

Definition at line 47 of file TgcL0FloatingCandidateBuilderTool.h.

47 {
48 this, "MaxPivotWireStripDeltaEta", -1.F,
49 "Maximum auxiliary eta-coordinate difference for same-station wire-strip association; negative disables the check"};

◆ m_maxPivotWireStripDeltaPhi

Gaudi::Property<float> L0Muon::TgcL0FloatingCandidateBuilderTool::m_maxPivotWireStripDeltaPhi
private
Initial value:
{
this, "MaxPivotWireStripDeltaPhi", 0.35F,
"Maximum auxiliary phi-coordinate difference for same-station wire-strip association; negative disables the check"}

Definition at line 50 of file TgcL0FloatingCandidateBuilderTool.h.

50 {
51 this, "MaxPivotWireStripDeltaPhi", 0.35F,
52 "Maximum auxiliary phi-coordinate difference for same-station wire-strip association; negative disables the check"};

◆ m_maxSegmentCombinationsPerGroup

Gaudi::Property<unsigned int> L0Muon::TgcL0FloatingCandidateBuilderTool::m_maxSegmentCombinationsPerGroup
private
Initial value:
{
this, "MaxSegmentCombinationsPerGroup", 8U,
"Old Floating projection/candidate working-set size per Trigger Sector "
"and BC"}

Definition at line 53 of file TgcL0FloatingCandidateBuilderTool.h.

53 {
54 this, "MaxSegmentCombinationsPerGroup", 8U,
55 "Old Floating projection/candidate working-set size per Trigger Sector "
56 "and BC"};

◆ m_ptCalibrationFile

Gaudi::Property<std::string> L0Muon::TgcL0FloatingCandidateBuilderTool::m_ptCalibrationFile
private
Initial value:
{
this, "PtCalibrationFile",
"L0MuonS1TGC/Floating/eta18_phi8_poormag0p10_v1/"
"TgcL0PtCalibration.txt",
"ASCII Floating-pT calibration path relative to the GroupData "
"development directory"}

Definition at line 61 of file TgcL0FloatingCandidateBuilderTool.h.

61 {
62 this, "PtCalibrationFile",
63 "L0MuonS1TGC/Floating/eta18_phi8_poormag0p10_v1/"
64 "TgcL0PtCalibration.txt",
65 "ASCII Floating-pT calibration path relative to the GroupData "
66 "development directory"};

◆ m_ptLut

std::unique_ptr<const TgcL0FloatingPtLut> L0Muon::TgcL0FloatingCandidateBuilderTool::m_ptLut {}
private

Definition at line 67 of file TgcL0FloatingCandidateBuilderTool.h.

67{};
The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.17.0