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 {}
Gaudi::Property< std::string > m_goodMagMapFile
std::unique_ptr< const TgcL0GoodMagMap > m_goodMagMap {}

Detailed Description

Definition at line 22 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 99 of file TgcL0FloatingCandidateBuilderTool.cxx.

101 {
102 return build(rdos, candidates, nullptr, ctx);
103}
L0Muon::TgcL0FloatingCandidateBuilderTool::build
StatusCode build(const TgcRdoContainer &rdos, TgcL0CandidateContainer &candidates, const EventContext &ctx) const override
Build candidates from TGC RDO data.
Definition TgcL0FloatingCandidateBuilderTool.cxx:99

◆ 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 105 of file TgcL0FloatingCandidateBuilderTool.cxx.

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

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

◆ m_detectorManagerKey

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

Definition at line 45 of file TgcL0FloatingCandidateBuilderTool.h.

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

◆ m_goodMagMap

std::unique_ptr<const TgcL0GoodMagMap> L0Muon::TgcL0FloatingCandidateBuilderTool::m_goodMagMap {}
private

Definition at line 76 of file TgcL0FloatingCandidateBuilderTool.h.

76{};

◆ m_goodMagMapFile

Gaudi::Property<std::string> L0Muon::TgcL0FloatingCandidateBuilderTool::m_goodMagMapFile
private
Initial value:
{
this, "GoodMagMapFile",
"L0MuonS1TGC/Floating/eta30_phi20_rel95_physicaldtheta_v2_goodmag_eta20_phi18_slope0p090_v4/"
"TgcL0PoorMagneticFieldMap.txt",
"ASCII GoodMag map path relative to the GroupData development "
"directory"}

Definition at line 70 of file TgcL0FloatingCandidateBuilderTool.h.

70 {
71 this, "GoodMagMapFile",
72 "L0MuonS1TGC/Floating/eta30_phi20_rel95_physicaldtheta_v2_goodmag_eta20_phi18_slope0p090_v4/"
73 "TgcL0PoorMagneticFieldMap.txt",
74 "ASCII GoodMag map path relative to the GroupData development "
75 "directory"};

◆ m_idHelperSvc

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

Definition at line 41 of file TgcL0FloatingCandidateBuilderTool.h.

41 {
42 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 58 of file TgcL0FloatingCandidateBuilderTool.h.

58 {
59 this, "MaxCandidatesPerLocalBin", 8U,
60 "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 48 of file TgcL0FloatingCandidateBuilderTool.h.

48 {
49 this, "MaxPivotWireStripDeltaEta", -1.F,
50 "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 51 of file TgcL0FloatingCandidateBuilderTool.h.

51 {
52 this, "MaxPivotWireStripDeltaPhi", 0.35F,
53 "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 54 of file TgcL0FloatingCandidateBuilderTool.h.

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

◆ m_ptCalibrationFile

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

Definition at line 62 of file TgcL0FloatingCandidateBuilderTool.h.

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

◆ m_ptLut

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

Definition at line 68 of file TgcL0FloatingCandidateBuilderTool.h.

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