ATLAS Offline Software
Public Member Functions | Private Member Functions | Private Attributes | List of all members
MuTagAmbiguitySolverTool Class Reference

#include <MuTagAmbiguitySolverTool.h>

Inheritance diagram for MuTagAmbiguitySolverTool:
Collaboration diagram for MuTagAmbiguitySolverTool:

Public Member Functions

 MuTagAmbiguitySolverTool (const std::string &t, const std::string &n, const IInterface *p)
 
virtual ~MuTagAmbiguitySolverTool ()=default
 
virtual StatusCode initialize () override
 
virtual std::vector< MuonCombined::MuonSegmentInfo > solveAmbiguities (const EventContext &ctx, std::vector< MuonCombined::MuonSegmentInfo > mtos) const override
 
virtual std::vector< MuonCombined::MuonSegmentInfo > selectBestMuTaggedSegments (const EventContext &ctx, const std::vector< MuonCombined::MuonSegmentInfo > &mtss) const override
 

Private Member Functions

int ambiguousSegment (const EventContext &ctx, const Muon::MuonSegment &seg1, const Muon::MuonSegment &seg2) const
 
virtual double Rseg (unsigned int nseg) const override
 What are these hardcoded constants about? d + a / (1 + exp()) More...
 

Private Attributes

ServiceHandle< Muon::IMuonEDMHelperSvc > m_edmHelperSvc
 Pointer on IMuonEDMHelperSvc. More...
 
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
 
PublicToolHandle< Muon::MuonEDMPrinterTool > m_muonPrinter {this,"Printer", ""}
 Pointer on MuonEDMPrinterTool. More...
 
ToolHandle< Muon::IMuonSegmentMatchingTool > m_segmentMatchingTool
 Pointer on MuonSegmentMatchingTool. More...
 
Gaudi::Property< bool > m_hitOverlapMatching {this, "DoHitOverlapMatching", true}
 for segments in a SL overlap in the same station layer, check whether from same particle More...
 
Gaudi::Property< bool > m_slOverlapMatching {"ResolveSLOverlaps", false}
 reject Endcap Outer one station layer tags (without EI or EM) More...
 
Gaudi::Property< bool > m_rejectOuterEndcap {this, "RejectOuterEndcap", true}
 reject one station tags with phi hits and a fabs(MatchPhi = minPullPhi) > 3 More...
 
Gaudi::Property< bool > m_rejectMatchPhi {this, "RejectMatchPhi", true}
 

Detailed Description

Definition at line 24 of file MuTagAmbiguitySolverTool.h.

Constructor & Destructor Documentation

◆ MuTagAmbiguitySolverTool()

MuTagAmbiguitySolverTool::MuTagAmbiguitySolverTool ( const std::string &  t,
const std::string &  n,
const IInterface *  p 
)

Definition at line 18 of file MuTagAmbiguitySolverTool.cxx.

18 : base_class{t, n, p} {}

◆ ~MuTagAmbiguitySolverTool()

virtual MuTagAmbiguitySolverTool::~MuTagAmbiguitySolverTool ( )
virtualdefault

Member Function Documentation

◆ ambiguousSegment()

int MuTagAmbiguitySolverTool::ambiguousSegment ( const EventContext &  ctx,
const Muon::MuonSegment &  seg1,
const Muon::MuonSegment &  seg2 
) const
private

Definition at line 228 of file MuTagAmbiguitySolverTool.cxx.

228  {
229  // first check pointer
230  if (&seg1 == &seg2) return 1;
231 
232  // check whether the segments are in the same station layer
233  Identifier ch1 = m_edmHelperSvc->chamberId(seg1);
234  Identifier ch2 = m_edmHelperSvc->chamberId(seg2);
235  Muon::MuonStationIndex::StIndex st1 = m_idHelperSvc->stationIndex(ch1);
236  Muon::MuonStationIndex::StIndex st2 = m_idHelperSvc->stationIndex(ch2);
237  if (st1 != st2) return 0;
238 
239  // check whether the segments are in the same chamber layer (small/large)
240  Muon::MuonStationIndex::ChIndex chI1 = m_idHelperSvc->chamberIndex(ch1);
241  Muon::MuonStationIndex::ChIndex chI2 = m_idHelperSvc->chamberIndex(ch2);
242  if (chI1 != chI2) {
243  // only match if segments both MDT or both CSC
244  if (m_idHelperSvc->isMdt(ch1) == m_idHelperSvc->isMdt(ch2)) {
245  // make sure segments are in same sector or neighbouring one
246  int sector1 = m_idHelperSvc->sector(ch1);
247  int sector2 = m_idHelperSvc->sector(ch2);
248  bool sectorOk = false;
249  if (sector1 == sector2) sectorOk = true;
250  if (std::abs(sector1 - sector2) == 1) sectorOk = true;
251  if ((sector1 == 16 && sector2 == 1) || (sector1 == 1 && sector2 == 16)) sectorOk = true;
252 
253  if (sectorOk) {
254  // check whether the two segments actually belong to the same particle
255  bool match = m_segmentMatchingTool->match(ctx, seg1, seg2);
256  if (match) {
257  ATH_MSG_VERBOSE("Found matching segment pair: " << std::endl
258  << m_muonPrinter->print(seg1) << std::endl
259  << m_muonPrinter->print(seg2));
260  // if overlap matching enabled flag as ambiguous
261  if (m_slOverlapMatching) return 2;
262  }
263  }
264  }
265  } else {
266  // the segments are in the same chamber, calculate hit overlap
267  Muon::MuonSegmentKey key1;
268  key1.calculateKeys(seg1.containedMeasurements(),
269  2); // the '2' means that the code will ignore the sign of the drift radii
270  Muon::MuonSegmentKey key2;
271  key2.calculateKeys(seg2.containedMeasurements(), 2);
272 
273  Muon::CompareMuonSegmentKeys compareSegments{};
274  Muon::CompareMuonSegmentKeys::OverlapResult result = compareSegments(key1, key2);
275 
276  if (compareSegments.intersectionSize > 0) {
277  // if hit overlap matching enables flag as ambiguous
278  if (m_hitOverlapMatching) {
279  if (msgLvl(MSG::VERBOSE))
280  msg(MSG::VERBOSE) << " found overlapping segment pair: " << compareSegments.print(result) << std::endl
281  << m_muonPrinter->print(seg1) << std::endl
282  << m_muonPrinter->print(seg2) << endmsg;
283  return 3;
284  }
285  }
286  }
287 
288  return 0;
289 }

◆ initialize()

StatusCode MuTagAmbiguitySolverTool::initialize ( )
overridevirtual

Definition at line 21 of file MuTagAmbiguitySolverTool.cxx.

21  {
22  ATH_CHECK(m_edmHelperSvc.retrieve());
23  ATH_CHECK(m_muonPrinter.retrieve());
24  ATH_CHECK(m_idHelperSvc.retrieve());
25  ATH_CHECK(m_segmentMatchingTool.retrieve());
26  return StatusCode::SUCCESS;
27 }

◆ Rseg()

double MuTagAmbiguitySolverTool::Rseg ( unsigned int  nseg) const
overrideprivatevirtual

What are these hardcoded constants about? d + a / (1 + exp())

Definition at line 352 of file MuTagAmbiguitySolverTool.cxx.

352  {
353  constexpr float a_seg{3.61883f}, b_seg{20.4547f}, c_seg{1.f / 0.132675f}, d_seg{0.102262f};
354  return (a_seg / (1. + std::exp(b_seg - nseg * c_seg)) + d_seg);
355 }

◆ selectBestMuTaggedSegments()

std::vector< MuonCombined::MuonSegmentInfo > MuTagAmbiguitySolverTool::selectBestMuTaggedSegments ( const EventContext &  ctx,
const std::vector< MuonCombined::MuonSegmentInfo > &  mtss 
) const
overridevirtual

Definition at line 291 of file MuTagAmbiguitySolverTool.cxx.

292  {
293  ATH_MSG_DEBUG("cleaning set of MTSs");
294 
295  std::vector<MuonCombined::MuonSegmentInfo> outputMTSs;
296  std::vector<bool> accept(mtss.size(), true);
297  for (unsigned int mts1 = 0; mts1 < mtss.size(); ++mts1) {
298  const Muon::MuonSegment* museg1 = mtss[mts1].segment;
299  if (!museg1) {
300  ATH_MSG_DEBUG("MTO doesn't hold a Muon::MuonSegment");
301  continue;
302  }
303 
304  Identifier ch1 = m_edmHelperSvc->chamberId(*museg1);
305  Muon::MuonStationIndex::StIndex st1 = m_idHelperSvc->stationIndex(ch1);
306  int eta1 = m_idHelperSvc->stationEta(ch1);
307 
308  for (unsigned int mts2 = mts1 + 1; mts2 < mtss.size(); ++mts2) {
309  const Muon::MuonSegment* museg2 = mtss[mts2].segment;
310  if (!museg2) {
311  ATH_MSG_DEBUG("MTO doesn't hold a Muon::MuonSegment");
312  continue;
313  }
314 
315  Identifier ch2 = m_edmHelperSvc->chamberId(*museg2);
316  Muon::MuonStationIndex::StIndex st2 = m_idHelperSvc->stationIndex(ch2);
317 
318  if (st1 != st2) continue;
319  int eta2 = m_idHelperSvc->stationEta(ch2);
320  if (eta1 != eta2) continue;
321 
322  if (ambiguousSegment(ctx, *museg1, *museg2)) {
323  if (museg1->numberOfContainedROTs() > museg2->numberOfContainedROTs() - 1) {
324  ATH_MSG_DEBUG("segments in the same station with rots keep First " << museg1->numberOfContainedROTs() << " and "
325  << museg2->numberOfContainedROTs());
326  accept[mts2] = false;
327  } else if (museg1->numberOfContainedROTs() < museg2->numberOfContainedROTs() - 1) {
328  ATH_MSG_DEBUG("segments in the same station with rots keep Second " << museg1->numberOfContainedROTs() << " and "
329  << museg2->numberOfContainedROTs());
330  accept[mts1] = false;
331  } else {
332  double chi2mts1 = std::abs(mtss[mts1].pullCY);
333  double chi2mts2 = std::abs(mtss[mts2].pullCY);
334  ATH_MSG_DEBUG("segments in the same station with MatchLocY " << chi2mts1 << " and " << chi2mts2);
335  if (std::abs(chi2mts1) < std::abs(chi2mts2)) {
336  ATH_MSG_DEBUG("dropping mts " << mts2 << " since he has a larger MatchLocY: " << chi2mts2 << " vs " << chi2mts1);
337  accept[mts2] = false;
338  }
339  if (std::abs(chi2mts1) > std::abs(chi2mts2)) {
340  ATH_MSG_DEBUG("dropping mts " << mts1 << " since he has a larger MatchLocY: " << chi2mts1 << " vs " << chi2mts2);
341  accept[mts1] = false;
342  }
343  }
344  }
345  }
346  if (accept[mts1]) outputMTSs.push_back(mtss[mts1]);
347  }
348  return outputMTSs;
349 }

◆ solveAmbiguities()

std::vector< MuonCombined::MuonSegmentInfo > MuTagAmbiguitySolverTool::solveAmbiguities ( const EventContext &  ctx,
std::vector< MuonCombined::MuonSegmentInfo >  mtos 
) const
overridevirtual

Definition at line 29 of file MuTagAmbiguitySolverTool.cxx.

30  {
31  ATH_MSG_DEBUG("mtos size before any cuts " << mtos.size());
32  // Store the number of segments associated to one track (pointer)
33  for (unsigned int ns1 = 0; ns1 < mtos.size(); ns1++) {
34  ATH_MSG_DEBUG(" index " << ns1 << " nsegments " << mtos[ns1].nsegments << " track pointer " << mtos[ns1].track << " stationLayer "
35  << mtos[ns1].stationLayer << " selected " << mtos[ns1].selected);
36  int nsegments = 1;
37  if (mtos[ns1].selected == 2) continue;
38  for (unsigned int ns2 = ns1 + 1; ns2 < mtos.size(); ns2++) {
39  if (mtos[ns1].track != mtos[ns2].track) break;
40  nsegments++;
41  }
42  ATH_MSG_DEBUG(" ns1 " << ns1 << " nsegments " << nsegments);
43 
44  for (unsigned int ns2 = ns1; ns2 < mtos.size(); ns2++) {
45  if (mtos[ns1].track != mtos[ns2].track) break;
46  mtos[ns2].nsegments = nsegments;
47  mtos[ns2].selected = 2;
48  }
49  ATH_MSG_DEBUG(" Updated index " << ns1 << " nsegments " << mtos[ns1].nsegments << " track pointer " << mtos[ns1].track
50  << " stationLayer " << mtos[ns1].stationLayer << " selected " << mtos[ns1].selected);
51  }
52 
53  // drop CSC single segment
54  for (unsigned int ns1 = 0; ns1 < mtos.size(); ns1++) {
55  if (mtos[ns1].selected == 2) mtos[ns1].selected = 1;
56  if (mtos[ns1].nsegments == 1 && mtos[ns1].stationLayer == 21) {
57  mtos[ns1].selected = 0;
58  mtos[ns1].nsegments = 0;
59  }
60  }
61 
62  // solve ambiguous segments
63  for (unsigned int ns1 = 0; ns1 < mtos.size(); ns1++) {
64  ATH_MSG_DEBUG(" First pass index " << ns1 << " nsegments " << mtos[ns1].nsegments << " track pointer " << mtos[ns1].track
65  << " stationLayer " << mtos[ns1].stationLayer << " selected " << mtos[ns1].selected);
66 
67  for (unsigned int ns2 = ns1 + 1; ns2 < mtos.size(); ns2++) {
68  if (mtos[ns1].segment == mtos[ns2].segment || ambiguousSegment(ctx, *mtos[ns1].segment, *mtos[ns2].segment)) {
69  double R1 = std::abs(mtos[ns1].pullCY * Rseg(mtos[ns1].nsegments));
70  double R2 = std::abs(mtos[ns2].pullCY * Rseg(mtos[ns2].nsegments));
71  ATH_MSG_DEBUG(" Ambiguous segment at index " << ns1 << " and " << ns2);
72  if (R1 > R2) {
73  mtos[ns1].selected = 0;
74  mtos[ns1].nsegments = 0;
75  } else {
76  mtos[ns2].selected = 0;
77  mtos[ns2].nsegments = 0;
78  }
79  }
80  }
81  }
82 
83  // update nsegments
84  for (unsigned int ns1 = 0; ns1 < mtos.size(); ns1++) {
85  int nsegments = 1;
86  if (mtos[ns1].selected == 0) nsegments = 0;
87  if (mtos[ns1].selected == 2) continue;
88  for (unsigned int ns2 = ns1 + 1; ns2 < mtos.size(); ns2++) {
89  if (mtos[ns1].track != mtos[ns2].track) break;
90  if (mtos[ns2].selected != 0) nsegments++;
91  }
92  for (unsigned int ns2 = ns1; ns2 < mtos.size(); ns2++) {
93  if (mtos[ns1].track != mtos[ns2].track) break;
94  mtos[ns2].nsegments = nsegments;
95  mtos[ns2].selected = 2;
96  }
97  ATH_MSG_DEBUG(" Second pass index " << ns1 << " nsegments " << mtos[ns1].nsegments << " track pointer " << mtos[ns1].track
98  << " stationLayer " << mtos[ns1].stationLayer << " selected " << mtos[ns1].selected);
99  ATH_MSG_DEBUG(" ns1 " << ns1 << " nsegments " << nsegments);
100  }
101 
102  // update drop CSC single segment
103  for (unsigned int ns1 = 0; ns1 < mtos.size(); ns1++) {
104  if (mtos[ns1].selected == 2) mtos[ns1].selected = 1;
105  if (mtos[ns1].nsegments == 1 && mtos[ns1].stationLayer == 21) {
106  mtos[ns1].selected = 0;
107  mtos[ns1].nsegments = 0;
108  ATH_MSG_DEBUG(" DROP CSC index " << ns1 << " nsegments " << mtos[ns1].nsegments << " track pointer " << mtos[ns1].track
109  << " stationLayer" << mtos[ns1].stationLayer << " selected " << mtos[ns1].selected);
110  }
111  }
112 
113  // drop single tag with too many holes
114  for (unsigned int ns1 = 0; ns1 < mtos.size(); ns1++) {
115  if (mtos[ns1].nsegments == 1 && mtos[ns1].nholes > 2) {
116  mtos[ns1].selected = 0;
117  mtos[ns1].nsegments = 0;
118  ATH_MSG_DEBUG(" DROP HOLES index " << ns1 << " nsegments " << mtos[ns1].nsegments << " track pointer " << mtos[ns1].track
119  << " stationLayer" << mtos[ns1].stationLayer << " selected " << mtos[ns1].selected);
120  }
121  }
122 
123  // drop single tag without phi match
124  if (m_rejectMatchPhi) {
125  for (unsigned int ns1 = 0; ns1 < mtos.size(); ns1++) {
126  if (mtos[ns1].nsegments == 1 && mtos[ns1].minimumPullPhi > 3 && mtos[ns1].hasPhi > 0) {
127  mtos[ns1].selected = 0;
128  mtos[ns1].nsegments = 0;
129  ATH_MSG_DEBUG(" DROP MatchPhi index " << ns1 << " nsegments " << mtos[ns1].nsegments << " track pointer " << mtos[ns1].track
130  << " stationLayer" << mtos[ns1].stationLayer << " selected " << mtos[ns1].selected);
131  }
132  }
133  }
134 
135  int multiplicity = mtos.size();
136 
137  // drop segments as function of multiplicity and holes
138  if (multiplicity > 50) {
139  for (unsigned int ns1 = 0; ns1 < mtos.size(); ns1++) {
140  if (mtos[ns1].nholes > 1) {
141  mtos[ns1].selected = 0;
142  mtos[ns1].nsegments = 0;
143  ATH_MSG_DEBUG(" DROP multiplicity 50 index " << ns1 << " nsegments " << mtos[ns1].nsegments << " track pointer "
144  << mtos[ns1].track << " stationLayer" << mtos[ns1].stationLayer << " selected "
145  << mtos[ns1].selected);
146  }
147  }
148  } else if (multiplicity > 30) {
149  for (unsigned int ns1 = 0; ns1 < mtos.size(); ns1++) {
150  if (mtos[ns1].nholes > 2) {
151  mtos[ns1].selected = 0;
152  mtos[ns1].nsegments = 0;
153  ATH_MSG_DEBUG(" DROP multiplicity 30 index " << ns1 << " nsegments " << mtos[ns1].nsegments << " track pointer "
154  << mtos[ns1].track << " stationLayer" << mtos[ns1].stationLayer << " selected "
155  << mtos[ns1].selected);
156  }
157  }
158  }
159 
160  // drop single multilayers for single tag
161  for (unsigned int ns1 = 0; ns1 < mtos.size(); ns1++) {
162  if (mtos[ns1].nsegments == 1 && mtos[ns1].nholes > 0 && mtos[ns1].singleML == 1) {
163  mtos[ns1].selected = 0;
164  mtos[ns1].nsegments = 0;
165  ATH_MSG_DEBUG(" DROP single multilayers single tag " << ns1 << " nsegments " << mtos[ns1].nsegments << " track pointer "
166  << mtos[ns1].track << " stationLayer" << mtos[ns1].stationLayer
167  << " selected " << mtos[ns1].selected);
168  }
169  }
170 
171  // drop single multilayer segment for below pT cut
172  double pTmin(2000.);
173  double pTmax(10000.);
174  double pTcut = pTmin;
175  if (multiplicity > 100)
176  pTcut = pTmax;
177  else if (multiplicity < 10)
178  pTcut = pTmin;
179  else
180  pTcut = 2 * ((pTmax - pTmin) / 90.) * multiplicity;
181 
182  for (unsigned int ns1 = 0; ns1 < mtos.size(); ns1++) {
183  const Trk::Perigee* perigee = (mtos[ns1].track)->perigeeParameters();
184  double sintheta = std::sin(perigee->parameters()[Trk::theta]);
185  double OneOverP = std::abs(perigee->parameters()[Trk::qOverP]);
186  double pT = 0.0;
187  if (OneOverP > 0.0) {
188  pT = sintheta / OneOverP;
189  } else {
190  pT = std::hypot(perigee->momentum()[Amg::px], perigee->momentum()[Amg::py]);
191  }
192  if (pT < pTcut) {
193  if (mtos[ns1].nsegments == 1 && mtos[ns1].singleML == 1) {
194  mtos[ns1].selected = 0;
195  mtos[ns1].nsegments = 0;
196  ATH_MSG_DEBUG(" DROP single multilayers low pT " << ns1 << " nsegments " << mtos[ns1].nsegments << " track pointer "
197  << mtos[ns1].track << " stationLayer" << mtos[ns1].stationLayer
198  << " selected " << mtos[ns1].selected);
199  }
200  }
201  }
202 
203  // drop if single tag outer endcap
204  if (m_rejectOuterEndcap) {
205  for (unsigned int ns1 = 0; ns1 < mtos.size(); ns1++) {
206  if (mtos[ns1].nsegments == 1 && mtos[ns1].stationLayer == 13) {
207  mtos[ns1].selected = 0;
208  mtos[ns1].nsegments = 0;
209  ATH_MSG_DEBUG(" DROP single tag OuterEndcap " << ns1 << " nsegments " << mtos[ns1].nsegments << " track pointer "
210  << mtos[ns1].track << " stationLayer" << mtos[ns1].stationLayer
211  << " selected " << mtos[ns1].selected);
212  }
213  }
214  }
215 
216  std::vector<MuonCombined::MuonSegmentInfo> mtosOutput;
217  mtosOutput.reserve(mtos.size());
218 
219  for (unsigned int ns1 = 0; ns1 < mtos.size(); ns1++) {
220  if (mtos[ns1].nsegments > 0) { mtosOutput.push_back(std::move(mtos[ns1])); }
221  }
222 
223  ATH_MSG_DEBUG("mtos size after all cuts " << mtos.size());
224 
225  return mtosOutput;
226 }

Member Data Documentation

◆ m_edmHelperSvc

ServiceHandle<Muon::IMuonEDMHelperSvc> MuTagAmbiguitySolverTool::m_edmHelperSvc
private
Initial value:
{
this,
"edmHelper",
"Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
"Handle to the service providing the IMuonEDMHelperSvc interface",
}

Pointer on IMuonEDMHelperSvc.

Definition at line 40 of file MuTagAmbiguitySolverTool.h.

◆ m_hitOverlapMatching

Gaudi::Property<bool> MuTagAmbiguitySolverTool::m_hitOverlapMatching {this, "DoHitOverlapMatching", true}
private

for segments in a SL overlap in the same station layer, check whether from same particle

Definition at line 60 of file MuTagAmbiguitySolverTool.h.

◆ m_idHelperSvc

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

Definition at line 46 of file MuTagAmbiguitySolverTool.h.

◆ m_muonPrinter

PublicToolHandle<Muon::MuonEDMPrinterTool> MuTagAmbiguitySolverTool::m_muonPrinter {this,"Printer", ""}
private

Pointer on MuonEDMPrinterTool.

Definition at line 52 of file MuTagAmbiguitySolverTool.h.

◆ m_rejectMatchPhi

Gaudi::Property<bool> MuTagAmbiguitySolverTool::m_rejectMatchPhi {this, "RejectMatchPhi", true}
private

Definition at line 66 of file MuTagAmbiguitySolverTool.h.

◆ m_rejectOuterEndcap

Gaudi::Property<bool> MuTagAmbiguitySolverTool::m_rejectOuterEndcap {this, "RejectOuterEndcap", true}
private

reject one station tags with phi hits and a fabs(MatchPhi = minPullPhi) > 3

Definition at line 64 of file MuTagAmbiguitySolverTool.h.

◆ m_segmentMatchingTool

ToolHandle<Muon::IMuonSegmentMatchingTool> MuTagAmbiguitySolverTool::m_segmentMatchingTool
private
Initial value:
{
this,
"MuonSegmentMatchingTool",
"Muon::MuonSegmentMatchingTool/MuonSegmentMatchingTool",
}

Pointer on MuonSegmentMatchingTool.

check hit overlap of segments in ambi solving

Definition at line 53 of file MuTagAmbiguitySolverTool.h.

◆ m_slOverlapMatching

Gaudi::Property<bool> MuTagAmbiguitySolverTool::m_slOverlapMatching {"ResolveSLOverlaps", false}
private

reject Endcap Outer one station layer tags (without EI or EM)

Definition at line 62 of file MuTagAmbiguitySolverTool.h.

The documentation for this class was generated from the following files:
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
get_generator_info.result
result
Definition: get_generator_info.py:21
MuTagAmbiguitySolverTool::m_rejectMatchPhi
Gaudi::Property< bool > m_rejectMatchPhi
Definition: MuTagAmbiguitySolverTool.h:66
ParticleGun_SamplingFraction.eta2
eta2
Definition: ParticleGun_SamplingFraction.py:96
MuTagAmbiguitySolverTool::m_segmentMatchingTool
ToolHandle< Muon::IMuonSegmentMatchingTool > m_segmentMatchingTool
Pointer on MuonSegmentMatchingTool.
Definition: MuTagAmbiguitySolverTool.h:53
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
CutsMETMaker::accept
StatusCode accept(const xAOD::Muon *mu)
Definition: CutsMETMaker.cxx:18
MuTagAmbiguitySolverTool::m_hitOverlapMatching
Gaudi::Property< bool > m_hitOverlapMatching
for segments in a SL overlap in the same station layer, check whether from same particle
Definition: MuTagAmbiguitySolverTool.h:60
xAOD::eta1
setEt setPhi setE277 setWeta2 eta1
Definition: TrigEMCluster_v1.cxx:41
Muon::MuonSegmentKey
Class to cache the identifiers on a segment in sets that can later be used to perform an overlap remo...
Definition: MuonSegmentKey.h:24
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
MuTagAmbiguitySolverTool::m_rejectOuterEndcap
Gaudi::Property< bool > m_rejectOuterEndcap
reject one station tags with phi hits and a fabs(MatchPhi = minPullPhi) > 3
Definition: MuTagAmbiguitySolverTool.h:64
Muon::MuonSegment::numberOfContainedROTs
unsigned int numberOfContainedROTs() const
number of RIO_OnTracks
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:199
IDTrig_MC23a_preInclude.pTmin
pTmin
Definition: IDTrig_MC23a_preInclude.py:8
module_driven_slicing.key2
key2
Definition: module_driven_slicing.py:159
Muon::CompareMuonSegmentKeys::OverlapResult
OverlapResult
enum for the overlap result
Definition: CompareMuonSegmentKeys.h:16
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
beamspotman.n
n
Definition: beamspotman.py:731
MuTagAmbiguitySolverTool::Rseg
virtual double Rseg(unsigned int nseg) const override
What are these hardcoded constants about? d + a / (1 + exp())
Definition: MuTagAmbiguitySolverTool.cxx:352
Trk::theta
@ theta
Definition: ParamDefs.h:66
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Trk::Segment::containedMeasurements
const std::vector< const Trk::MeasurementBase * > & containedMeasurements() const
returns the vector of Trk::MeasurementBase objects
Definition: Tracking/TrkEvent/TrkSegment/TrkSegment/Segment.h:166
Amg::px
@ px
Definition: GeoPrimitives.h:38
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Amg::py
@ py
Definition: GeoPrimitives.h:39
Trk::perigeeParameters
@ perigeeParameters
Definition: MeasurementType.h:19
MuTagAmbiguitySolverTool::ambiguousSegment
int ambiguousSegment(const EventContext &ctx, const Muon::MuonSegment &seg1, const Muon::MuonSegment &seg2) const
Definition: MuTagAmbiguitySolverTool.cxx:228
MuTagAmbiguitySolverTool::m_slOverlapMatching
Gaudi::Property< bool > m_slOverlapMatching
reject Endcap Outer one station layer tags (without EI or EM)
Definition: MuTagAmbiguitySolverTool.h:62
MuTagAmbiguitySolverTool::m_muonPrinter
PublicToolHandle< Muon::MuonEDMPrinterTool > m_muonPrinter
Pointer on MuonEDMPrinterTool.
Definition: MuTagAmbiguitySolverTool.h:52
MuTagAmbiguitySolverTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuTagAmbiguitySolverTool.h:46
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:67
Muon::MuonStationIndex::ChIndex
ChIndex
enum to classify the different chamber layers in the muon spectrometer
Definition: MuonStationIndex.h:15
Muon::MuonStationIndex::StIndex
StIndex
enum to classify the different station layers in the muon spectrometer
Definition: MuonStationIndex.h:23
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
Muon::MuonSegment
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:45
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
Muon::CompareMuonSegmentKeys
Definition: CompareMuonSegmentKeys.h:14
match
bool match(std::string s1, std::string s2)
match the individual directories of two strings
Definition: hcg.cxx:356
MuTagAmbiguitySolverTool::m_edmHelperSvc
ServiceHandle< Muon::IMuonEDMHelperSvc > m_edmHelperSvc
Pointer on IMuonEDMHelperSvc.
Definition: MuTagAmbiguitySolverTool.h:40
NSWL1::PadTriggerAdapter::segment
Muon::NSW_PadTriggerSegment segment(const NSWL1::PadTrigger &data)
Definition: PadTriggerAdapter.cxx:5
Identifier
Definition: IdentifierFieldParser.cxx:14
module_driven_slicing.key1
key1
Definition: module_driven_slicing.py:158
Generated on Fri Jan 10 2025 21:37:15 for ATLAS Offline Software by   doxygen 1.8.18