ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | 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 ()
 
std::vector< MuonCombined::MuonSegmentInfo > solveAmbiguities (const EventContext &ctx, std::vector< MuonCombined::MuonSegmentInfo > mtos) const
 
std::vector< MuonCombined::MuonSegmentInfo > selectBestMuTaggedSegments (const EventContext &ctx, std::vector< MuonCombined::MuonSegmentInfo > mtss) const
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

int ambiguousSegment (const EventContext &ctx, const Muon::MuonSegment &seg1, const Muon::MuonSegment &seg2) const
 
double Rseg (unsigned int nseg) const
 What are these hardcoded constants about? d + a / (1 + exp()) More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

ServiceHandle< Muon::IMuonEDMHelperSvc > m_edmHelperSvc
 Pointer on IMuonEDMHelperSvc. More...
 
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
 
ToolHandle< Muon::MuonEDMPrinterTool > p_muonPrinter
 Pointer on MuonEDMPrinterTool. More...
 
ToolHandle< Muon::IMuonSegmentMatchingTool > p_segmentMatchingTool
 Pointer on MuonSegmentMatchingTool. More...
 
bool m_hitOverlapMatching
 check hit overlap of segments in ambi solving More...
 
bool m_slOverlapMatching
 for segments in a SL overlap in the same station layer, check whether from same particle More...
 
bool m_rejectOuterEndcap
 reject Endcap Outer one station layer tags (without EI or EM) More...
 
bool m_rejectMatchPhi
 reject one station tags with phi hits and a fabs(MatchPhi = minPullPhi) > 3 More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Author
Zdenk.nosp@m.o.va.nosp@m.n.Kes.nosp@m.tere.nosp@m.n@cer.nosp@m.n.ch

Definition at line 32 of file MuTagAmbiguitySolverTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.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  : AthAlgTool(t, n, p) {
19  declareInterface<IMuTagAmbiguitySolverTool>(this);
20  declareProperty("DoHitOverlapMatching", m_hitOverlapMatching = true);
21  declareProperty("ResolveSLOverlaps", m_slOverlapMatching = false);
22  declareProperty("RejectOuterEndcap", m_rejectOuterEndcap = true);
23  declareProperty("RejectMatchPhi", m_rejectMatchPhi = true);
24 }

◆ ~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 238 of file MuTagAmbiguitySolverTool.cxx.

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

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ initialize()

StatusCode MuTagAmbiguitySolverTool::initialize ( )
virtual

Definition at line 26 of file MuTagAmbiguitySolverTool.cxx.

26  {
27  ATH_MSG_INFO("================================");
28  ATH_MSG_INFO("=Proprieties are ");
29  ATH_MSG_INFO("================================");
30 
31  ATH_CHECK(m_edmHelperSvc.retrieve());
32  ATH_CHECK(p_muonPrinter.retrieve());
33  ATH_CHECK(m_idHelperSvc.retrieve());
34  ATH_CHECK(p_segmentMatchingTool.retrieve());
35 
36  return StatusCode::SUCCESS;
37 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

const InterfaceID & IMuTagAmbiguitySolverTool::interfaceID ( )
inlinestaticinherited

Definition at line 39 of file IMuTagAmbiguitySolverTool.h.

39 { return IID_IMuTagAmbiguitySolverTool; }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ Rseg()

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

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

Implements IMuTagAmbiguitySolverTool.

Definition at line 362 of file MuTagAmbiguitySolverTool.cxx.

362  {
363  constexpr float a_seg{3.61883f}, b_seg{20.4547f}, c_seg{1.f / 0.132675f}, d_seg{0.102262f};
364  return (a_seg / (1. + std::exp(b_seg - nseg * c_seg)) + d_seg);
365 }

◆ selectBestMuTaggedSegments()

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

Implements IMuTagAmbiguitySolverTool.

Definition at line 301 of file MuTagAmbiguitySolverTool.cxx.

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

◆ solveAmbiguities()

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

Implements IMuTagAmbiguitySolverTool.

Definition at line 39 of file MuTagAmbiguitySolverTool.cxx.

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

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ 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 48 of file MuTagAmbiguitySolverTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_hitOverlapMatching

bool MuTagAmbiguitySolverTool::m_hitOverlapMatching
private

check hit overlap of segments in ambi solving

Definition at line 71 of file MuTagAmbiguitySolverTool.h.

◆ m_idHelperSvc

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

Definition at line 54 of file MuTagAmbiguitySolverTool.h.

◆ m_rejectMatchPhi

bool MuTagAmbiguitySolverTool::m_rejectMatchPhi
private

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

Definition at line 75 of file MuTagAmbiguitySolverTool.h.

◆ m_rejectOuterEndcap

bool MuTagAmbiguitySolverTool::m_rejectOuterEndcap
private

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

Definition at line 74 of file MuTagAmbiguitySolverTool.h.

◆ m_slOverlapMatching

bool MuTagAmbiguitySolverTool::m_slOverlapMatching
private

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

Definition at line 72 of file MuTagAmbiguitySolverTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ p_muonPrinter

ToolHandle<Muon::MuonEDMPrinterTool> MuTagAmbiguitySolverTool::p_muonPrinter
private
Initial value:
{
this,
"Printer",
"Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
}

Pointer on MuonEDMPrinterTool.

Definition at line 60 of file MuTagAmbiguitySolverTool.h.

◆ p_segmentMatchingTool

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

Pointer on MuonSegmentMatchingTool.

Definition at line 65 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
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
ParticleGun_SamplingFraction.eta2
eta2
Definition: ParticleGun_SamplingFraction.py:96
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
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
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
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
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
MuTagAmbiguitySolverTool::m_hitOverlapMatching
bool m_hitOverlapMatching
check hit overlap of segments in ambi solving
Definition: MuTagAmbiguitySolverTool.h:71
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
module_driven_slicing.key2
key2
Definition: module_driven_slicing.py:159
Muon::CompareMuonSegmentKeys::OverlapResult
OverlapResult
enum for the overlap result
Definition: CompareMuonSegmentKeys.h:16
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
beamspotman.n
n
Definition: beamspotman.py:731
Trk::theta
@ theta
Definition: ParamDefs.h:72
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: TrkEvent/TrkSegment/TrkSegment/Segment.h:166
Amg::px
@ px
Definition: GeoPrimitives.h:38
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MuTagAmbiguitySolverTool::p_muonPrinter
ToolHandle< Muon::MuonEDMPrinterTool > p_muonPrinter
Pointer on MuonEDMPrinterTool.
Definition: MuTagAmbiguitySolverTool.h:60
MuTagAmbiguitySolverTool::m_rejectMatchPhi
bool m_rejectMatchPhi
reject one station tags with phi hits and a fabs(MatchPhi = minPullPhi) > 3
Definition: MuTagAmbiguitySolverTool.h:75
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
MuTagAmbiguitySolverTool::m_slOverlapMatching
bool m_slOverlapMatching
for segments in a SL overlap in the same station layer, check whether from same particle
Definition: MuTagAmbiguitySolverTool.h:72
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
MuTagAmbiguitySolverTool::Rseg
double Rseg(unsigned int nseg) const
What are these hardcoded constants about? d + a / (1 + exp())
Definition: MuTagAmbiguitySolverTool.cxx:362
Amg::py
@ py
Definition: GeoPrimitives.h:39
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
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:238
MuTagAmbiguitySolverTool::m_rejectOuterEndcap
bool m_rejectOuterEndcap
reject Endcap Outer one station layer tags (without EI or EM)
Definition: MuTagAmbiguitySolverTool.h:74
a
TList * a
Definition: liststreamerinfos.cxx:10
h
MuTagAmbiguitySolverTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuTagAmbiguitySolverTool.h:54
MuTagAmbiguitySolverTool::p_segmentMatchingTool
ToolHandle< Muon::IMuonSegmentMatchingTool > p_segmentMatchingTool
Pointer on MuonSegmentMatchingTool.
Definition: MuTagAmbiguitySolverTool.h:65
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:73
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
Muon::MuonStationIndex::ChIndex
ChIndex
enum to classify the different chamber layers in the muon spectrometer
Definition: MuonStationIndex.h:15
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
Muon::MuonStationIndex::StIndex
StIndex
enum to classify the different station layers in the muon spectrometer
Definition: MuonStationIndex.h:23
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
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
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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
fitman.k
k
Definition: fitman.py:528
MuTagAmbiguitySolverTool::m_edmHelperSvc
ServiceHandle< Muon::IMuonEDMHelperSvc > m_edmHelperSvc
Pointer on IMuonEDMHelperSvc.
Definition: MuTagAmbiguitySolverTool.h:48
NSWL1::PadTriggerAdapter::segment
Muon::NSW_PadTriggerSegment segment(const NSWL1::PadTrigger &data)
Definition: PadTriggerAdapter.cxx:5
module_driven_slicing.key1
key1
Definition: module_driven_slicing.py:158
Generated on Fri Jun 28 2024 21:55:33 for ATLAS Offline Software by   doxygen 1.8.18