ATLAS Offline Software
Classes | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
MuonInDetToMuonSystemExtensionAlg Class Reference

The MuonInDetToMuonSystemExtensionAlg processes further the InDetCandidates created by the MuonCombinedInDetCandidateAlg. More...

#include <MuonInDetToMuonSystemExtensionAlg.h>

Inheritance diagram for MuonInDetToMuonSystemExtensionAlg:
Collaboration diagram for MuonInDetToMuonSystemExtensionAlg:

Classes

struct  InDetCandidateCache
 
struct  MuidCoCache
 Helper struct to cache the MuidCo track and it's associated segments while keeping the association InDetCandidate <– > muidCo Tag. More...
 

Public Member Functions

 MuonInDetToMuonSystemExtensionAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
 ~MuonInDetToMuonSystemExtensionAlg ()=default
 
StatusCode initialize () override
 
StatusCode execute (const EventContext &ctx) const override
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) 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 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
 

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

using MuidCoVector = std::vector< MuidCoCache >
 
typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

StatusCode selectCandidates (const EventContext &ctx, InDetCandidateCache &cache) const
 Select the MuidCo candidates and put the associated id tracks on a black list. More...
 
StatusCode findHitSectors (const EventContext &ctx, InDetCandidateCache &output_cache) const
 Find the sectors in the MS with muon signals. More...
 
StatusCode findSegments (const EventContext &ctx, InDetCandidateCache &output_cache) const
 Select good segments. More...
 
bool hasMatchingSegment (const MuonCombined::InDetCandidate &id_cand, const InDetCandidateCache &cache) const
 Searches for segments within theta < 0.2 && sharing the same sector. More...
 
bool hasMatchingSeed (const MuonCombined::InDetCandidate &id_cand, const InDetCandidateCache &cache) const
 Searches for hough seeds within theta < 0.2 && sharing the same sector. More...
 
StatusCode create (const EventContext &ctx, InDetCandidateCache &cache) const
 Create the InDetCandidaes with system extensions. More...
 
StatusCode createStaus (const EventContext &ctx, const InDetCandidateCollection *ext_candidates, const MuidCoVector &tag_map) const
 
void maskHits (const Muon::MuonSegment *muon_seg, InDetCandidateCache &output_cache) const
 Mask the hits of the corresponding muon segment as used. 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

SG::ReadHandleKey< InDetCandidateCollectionm_inputCandidate {this, "InputInDetCandidates", "InDetCandidates"}
 
SG::WriteHandleKey< InDetCandidateCollectionm_bulkInDetCandKey {this, "WriteInDetCandidates", "InDetCandidatesSystemExtened"}
 Collection of InDet candidates written for MuGirl and MuonSegmentTag. More...
 
SG::WriteHandleKey< InDetCandidateCollectionm_stauInDetCandKey {this, "WriteStauCandidates", ""}
 Collection of InDet candidates written for MuGirlStau. More...
 
SG::ReadHandleKey< Muon::HoughDataPerSectorVecm_houghDataPerSectorVecKey
 Use the hough data to find sectors in the speectrometer traversed by a muon. More...
 
SG::ReadHandleKey< Trk::SegmentCollectionm_segmentKey
 Let's exploit the segments to get rid of as much tracks as possible. More...
 
PublicToolHandle< Muon::IMuonSegmentSelectionToolm_segmentSelector
 
ToolHandle< Muon::IMuonSystemExtensionToolm_muonSystemExtensionTool {this, "MuonSystemExtensionTool", "", "Muon system extension tool"}
 The system extension tool extrapolates the candidate through the spectrometer. More...
 
SG::ReadHandleKey< MuonCombined::InDetCandidateToTagMapm_combTagMap {this, "CombinedTagMap", "muidcoTagMap", "Combined muon tag map"}
 That is the collection of MuidCo candidates. More...
 
ServiceHandle< Muon::IMuonIdHelperSvcm_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
 
ServiceHandle< Muon::IMuonEDMHelperSvcm_edmHelperSvc
 
Gaudi::Property< bool > m_restrictExtension {this, "UseOnlyHitSectors", false}
 Restrict the extrapolation of ID tracks to sectors in the MS where at least a hit is recorded. More...
 
Gaudi::Property< int > m_houghMin {this, "minHoughHits", 4, "Minimum number of hits required for a hough maximum to be accepted"}
 The hough maxima always contain at least 2 hits. More...
 
Gaudi::Property< int > m_segmentQuality {this, "segQuality", 1, "Quality cut on the segment."}
 
Gaudi::Property< bool > m_excludeNSW {this, "noNSWforSeeding", false, "Ignore hits/segments from the NSW"}
 Prelimnary studies have shown that the NSWs generate a massive amount of fake candidates. More...
 
Gaudi::Property< float > m_extThreshold {this, "ExtensionPtThreshold", 2500}
 Minimum pt threshold of the IdCandidate to be extrapolated through the spectrometer. More...
 
Gaudi::Property< bool > m_extendSAF {this, "ExtendSAF", false}
 Shall SAF tracks be equiped with a muon system extension used by MuGirl later. More...
 
Gaudi::Property< bool > m_extendBulk {this, "ExtendBulk", true}
 Shall ordinary ID tracks be equiped with a muon system extension used by MuGirl later. More...
 
const Muon::MuonSectorMapping m_sector_mapping {}
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. 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

The MuonInDetToMuonSystemExtensionAlg processes further the InDetCandidates created by the MuonCombinedInDetCandidateAlg.

The idea is that the latter is only selecting the Id tracks based on the outcome of the Id selection tool and whether a CaloExtension could be successfully attached. This information is full sufficient to run the MuonCombinedAlg and the MuonCalo algorithms, but not the SegmentTagging or muGirl. InDetCandidates, not combined to a full muon track by MuidCo (STACO generates to much noise) are copied and then equipped with the muonSystem extension.

Definition at line 34 of file MuonInDetToMuonSystemExtensionAlg.h.

Member Typedef Documentation

◆ MuidCoVector

Definition at line 76 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ MuonInDetToMuonSystemExtensionAlg()

MuonInDetToMuonSystemExtensionAlg::MuonInDetToMuonSystemExtensionAlg ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 31 of file MuonInDetToMuonSystemExtensionAlg.cxx.

31  :
32  AthReentrantAlgorithm(name, pSvcLocator) {}

◆ ~MuonInDetToMuonSystemExtensionAlg()

MuonInDetToMuonSystemExtensionAlg::~MuonInDetToMuonSystemExtensionAlg ( )
default

Member Function Documentation

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const
overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

56 {
57  return 0;
58 }

◆ create()

StatusCode MuonInDetToMuonSystemExtensionAlg::create ( const EventContext &  ctx,
InDetCandidateCache cache 
) const
private

Create the InDetCandidaes with system extensions.

We want these tracks to be extrapolated through the spectrometer reject those no meeting the basic requirements

Prepare the system extension

The candidate already has somehow a system extension --> it's just a matter of copying it

The system extension does not own the MuonEntryLayerIntersection()-> it's fine

If the id candidate has a matching segment, then we know that this track can be potentially reconstructed by MuTagIMO

Definition at line 102 of file MuonInDetToMuonSystemExtensionAlg.cxx.

102  {
104  for (const MuonCombined::InDetCandidate* candidate : *out_cache.input_candidates) {
105  if (out_cache.excluded_trks.count(candidate)) {
106  ATH_MSG_VERBOSE("Inner detector track " << candidate->toString() << " has already been used by MuidCo");
107  continue;
108  }
111  if (candidate->indetTrackParticle().pt() < m_extThreshold || (!m_extendSAF && candidate->isSiliconAssociated()) ||
112  (!m_extendBulk && !candidate->isSiliconAssociated())) {
113  ATH_MSG_VERBOSE("Inner detector track " << candidate->toString() << " is too soft");
114  continue;
115  }
116 
119  cache.candidate = std::make_unique<MuonCombined::InDetCandidate>(candidate->indetTrackParticleLink());
120  cache.candidate->setSiliconAssociated(candidate->isSiliconAssociated());
121  cache.candidate->setExtension(candidate->getCaloExtension());
122 
123  const Muon::MuonSystemExtension* extension = candidate->getExtension();
125  if (extension) {
127  std::vector<Muon::MuonSystemExtension::Intersection> intersects = extension->layerIntersections();
128  cache.candidate->setExtension(
129  std::make_unique<Muon::MuonSystemExtension>(&extension->muonEntryLayerIntersection(), std::move(intersects)));
130  } else {
132  const bool seg_match = !m_restrictExtension || hasMatchingSegment(*candidate, out_cache);
133 
134  if (!seg_match && !hasMatchingSeed(*candidate, out_cache)) continue;
135  cache.useHitSectors = !seg_match;
136  cache.sectorsWithHits = &out_cache.hit_sectors;
137  cache.createSystemExtension = true;
138  cache.requireSystemExtension = true;
139 
140  if (!m_muonSystemExtensionTool->muonSystemExtension(ctx, cache)) {
141  ATH_MSG_VERBOSE("Extension failed");
142  continue;
143  }
144  }
145  out_cache.outputContainer->push_back(std::move(cache.candidate));
146  }
147  if (msgLevel(MSG::DEBUG)) {
148  std::stringstream sstr;
149  for (const MuonCombined::InDetCandidate* extended : *out_cache.outputContainer) {
150  sstr << " * " << extended->toString() << std::endl;
151  }
152  if (!out_cache.excluded_trks.empty()) {
153  sstr << std::endl << " ======== The following tracks were already successfully combined ======== " << std::endl;
154  for (const MuonCombined::InDetCandidate* combined : out_cache.excluded_trks) {
155  sstr << " = " << combined->toString() << std::endl;
156  }
157  }
158  if (out_cache.excluded_trks.size() + out_cache.outputContainer->size() != out_cache.input_candidates->size()) {
159  sstr << std::endl << " ++++++++ The following candidates were not extrapolated ++++++++ " << std::endl;
160  const InDetCandidateCollection::const_iterator begin = out_cache.outputContainer->begin();
161  const InDetCandidateCollection::const_iterator end = out_cache.outputContainer->end();
162 
163  for (const MuonCombined::InDetCandidate* rejected : *out_cache.input_candidates) {
164  if (out_cache.excluded_trks.count(rejected) ||
165  std::find_if(begin, end,
166  [rejected](const MuonCombined::InDetCandidate* extended) { return (*rejected) == (*extended); }) != end)
167  continue;
168  sstr << " + " << rejected->toString() << std::endl;
169  }
170  }
171  ATH_MSG_DEBUG("Extrapolated " << out_cache.outputContainer->size() << " out of " << out_cache.input_candidates->size()
172  << " tracks through the spectrometer" << std::endl
173  << std::endl
174  << sstr.str());
175  }
176  return StatusCode::SUCCESS;
177 }

◆ createStaus()

StatusCode MuonInDetToMuonSystemExtensionAlg::createStaus ( const EventContext &  ctx,
const InDetCandidateCollection ext_candidates,
const MuidCoVector tag_map 
) const
private

This will copy the existing candidates to the new container without calling the system extension tool

For the staus it is quite unclear what is the overlap between MuidCo and MuGirlStau. So in order to be on the safe side we add the MuidCo candidate tracks as well, but we also try to avoid the extrapolator like a cat does for a bubble bath. By taking the perigee parameters of the associated muon segments, we have a much much shorter path to extrapolate the track to the MuonLayerInterSection surfaces.

Definition at line 338 of file MuonInDetToMuonSystemExtensionAlg.cxx.

339  {
340  if (m_stauInDetCandKey.empty()) {
341  ATH_MSG_VERBOSE("No candidates for stau reconstruction will be written");
342  return StatusCode::SUCCESS;
343  }
344  ATH_MSG_DEBUG("Now find the candidates to be considered for MuGirlStau");
345  InDetCandidateCache stau_cache{};
346  stau_cache.input_candidates = ext_candidates;
347 
349  ATH_CHECK(create(ctx, stau_cache));
355  for (const MuidCoCache& idMuidCo : tag_map) {
357  cache.candidate = std::make_unique<MuonCombined::InDetCandidate>(idMuidCo.id_trk->indetTrackParticleLink());
358  cache.candidate->setSiliconAssociated(idMuidCo.id_trk->isSiliconAssociated());
359  cache.candidate->setExtension(idMuidCo.id_trk->getCaloExtension());
360  cache.useHitSectors = false;
361  cache.createSystemExtension = true;
362  cache.requireSystemExtension = true;
363 
364  if (!m_muonSystemExtensionTool->muonLayerInterSections(ctx, *idMuidCo.cmb_trk, cache)) {
365  ATH_MSG_FATAL("Could not determine the intersections. Although that should be possible");
366  return StatusCode::FAILURE;
367  }
368  stau_cache.outputContainer->push_back(std::move(cache.candidate));
369  }
370 
371  SG::WriteHandle<InDetCandidateCollection> indetCandidateCollection(m_stauInDetCandKey, ctx);
372  // sort candidates beofre storing, otherwise ordering in container of stau segments can be inconsistent
373  std::sort(stau_cache.outputContainer->begin(),stau_cache.outputContainer->end(),[](const MuonCombined::InDetCandidate*a, const MuonCombined::InDetCandidate*b){
374  return a->indetTrackParticle().pt() < b->indetTrackParticle().pt();});
375  ATH_CHECK(indetCandidateCollection.record(std::move(stau_cache.outputContainer)));
376  return StatusCode::SUCCESS;
377 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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; }

◆ execute()

StatusCode MuonInDetToMuonSystemExtensionAlg::execute ( const EventContext &  ctx) const
override

Definition at line 49 of file MuonInDetToMuonSystemExtensionAlg.cxx.

49  {
50  ATH_MSG_DEBUG("Cakes are availablei in "<<ctx.eventID().event_number());
51  InDetCandidateCache output_cache{};
52 
54  if (!input_container.isValid()) {
55  ATH_MSG_FATAL("Failed to retrieve " << m_inputCandidate.fullKey());
56  return StatusCode::FAILURE;
57  }
58  output_cache.input_candidates = input_container.cptr();
59  ATH_CHECK(selectCandidates(ctx, output_cache));
60 
61  if (m_restrictExtension) {
62  ATH_CHECK(findSegments(ctx, output_cache));
63  ATH_CHECK(findHitSectors(ctx, output_cache));
64  }
65 
66  ATH_MSG_DEBUG("Find the inner detector candidates to be used for MuGirl / Segment tagging");
67  ATH_CHECK(create(ctx, output_cache));
69  ATH_CHECK(indetCandidateCollection.record(std::move(output_cache.outputContainer)));
70 
71  ATH_CHECK(createStaus(ctx, indetCandidateCollection.ptr(), output_cache.tag_map));
72 
73  return StatusCode::SUCCESS;
74 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

◆ extraOutputDeps()

const DataObjIDColl & AthReentrantAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 79 of file AthReentrantAlgorithm.cxx.

80 {
81  // If we didn't find any symlinks to add, just return the collection
82  // from the base class. Otherwise, return the extended collection.
83  if (!m_extendedExtraObjects.empty()) {
85  }
86  return Algorithm::extraOutputDeps();
87 }

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

135  {
136  return execState( ctx ).filterPassed();
137  }

◆ findHitSectors()

StatusCode MuonInDetToMuonSystemExtensionAlg::findHitSectors ( const EventContext &  ctx,
InDetCandidateCache output_cache 
) const
private

Find the sectors in the MS with muon signals.

Helper function to cound whether all three stations are actually complete

The phi-hit vector has a size of 3 representing the forward-backward and barrel sections

Hits built into a MuidCo track

Subtract the hits used by MuidCo from the hough seeds

Find the chamber with the largest number of hits

Average the theta

Loop over the maxima & find the hit sectors

Remove all hits from the seed that are built into a segment

If the seed has still more than the minimum. Then let's mark the sector as hit

Cache the eta value additionally

Definition at line 179 of file MuonInDetToMuonSystemExtensionAlg.cxx.

179  {
181  if (!readHandle.isValid()) {
182  ATH_MSG_FATAL("Failed to retrieve the prep data container " << m_houghDataPerSectorVecKey.fullKey());
183  return StatusCode::FAILURE;
184  }
185  const std::vector<Muon::HoughDataPerSec>& hough_data = readHandle->vec;
187  auto count_finished = [&output_cache]() -> unsigned int {
188  unsigned int n{0};
189  for (const auto& sector_hits : output_cache.hit_sectors) { n += sector_hits.second.size() >= num_sectors; }
190  return n;
191  };
192 
195  for (int det_region = 0; det_region < Muon::MuonStationIndex::DetectorRegionIndexMax; ++det_region) {
196  const RegionIndex region_index = static_cast<RegionIndex>(det_region);
198  const LayerIndex layer_index = static_cast<LayerIndex>(layer);
199  const unsigned int hash = Muon::MuonStationIndex::sectorLayerHash(region_index, layer_index);
201  const std::set<Identifier>& masked_hits = output_cache.consumed_hits[hash];
202 
204  auto num_hough_hits = [&masked_hits, this](const std::shared_ptr<MuonHough::MuonLayerHough::Maximum>& hough_maximum) {
205  std::map<Identifier, hough_chamber> chamber_counts;
206  for (const std::shared_ptr<MuonHough::Hit>& hough_hit : hough_maximum->hits) {
207  const Trk::PrepRawData* prep = prepData(hough_hit);
208  const Identifier chId = prep->identify();
209  if (masked_hits.count(chId) || (m_excludeNSW && (m_idHelperSvc->isMM(chId) || m_idHelperSvc->issTgc(chId)))) {
210  ATH_MSG_VERBOSE("Do not reuse hit " << m_idHelperSvc->toString(chId));
211  continue;
212  }
213  ATH_MSG_VERBOSE("Count hough hit " << m_idHelperSvc->toString(chId));
214  // Split the seeds into the chambers
215  hough_chamber& chamber = chamber_counts[m_idHelperSvc->chamberId(chId)];
216  ++chamber.nhits;
217  const Amg::Vector3D glob_pos = prep->detectorElement()->center(chId);
218  chamber.eta += glob_pos.eta();
219  chamber.sectors.insert(m_sector_mapping.getSector(glob_pos.phi()));
220  }
222  hough_chamber N{};
223  for (auto& ch_it : chamber_counts) {
224  if (N.nhits < ch_it.second.nhits) { N = std::move(ch_it.second); }
225  }
227  N.eta /= std::max(N.nhits, 1);
228  return N;
229  };
230 
231  for (const Muon::HoughDataPerSec& sector_data : hough_data) {
232  const Muon::HoughDataPerSec::MaximumVec& eta_hits = sector_data.maxVec[hash];
234  for (const std::shared_ptr<MuonHough::MuonLayerHough::Maximum>& maxima : eta_hits) {
236  const hough_chamber effect_hits = num_hough_hits(maxima);
238  if (m_houghMin > effect_hits.nhits) continue;
239  ATH_MSG_VERBOSE("Hough maximum in " << Muon::MuonStationIndex::regionName(region_index) << ", "
240  << Muon::MuonStationIndex::layerName(layer_index)
241  << ", hits: " << effect_hits.nhits);
242 
243  for (const int sector : effect_hits.sectors) {
244  output_cache.hit_sectors[region_index].insert(sector);
246  output_cache.eta_seeds[sector].push_back(effect_hits.eta);
247  }
248  }
249  if (count_finished() >= RegionIndex::DetectorRegionIndexMax) {
250  ATH_MSG_VERBOSE("The MS is filled up with Hough seeds. We do not need to search for them any longer");
251  break;
252  }
253  }
254  }
255  for (auto& theta_pair : output_cache.eta_seeds) { std::sort(theta_pair.second.begin(), theta_pair.second.end()); }
256  }
257  output_cache.consumed_hits.clear();
258  return StatusCode::SUCCESS;
259 }

◆ findSegments()

StatusCode MuonInDetToMuonSystemExtensionAlg::findSegments ( const EventContext &  ctx,
InDetCandidateCache output_cache 
) const
private

Select good segments.

Check if the segment is part of a MuidCo muon

Mask all hits from the Hough seeds

Definition at line 260 of file MuonInDetToMuonSystemExtensionAlg.cxx.

260  {
262  if (!segmentContainer.isValid()) {
263  ATH_MSG_FATAL("Failed to retrieve the Muon segment container " << m_segmentKey.fullKey());
264  return StatusCode::FAILURE;
265  }
266  for (const Trk::Segment* trk_segment : *segmentContainer) {
267  // Which in reality is a Muon segment
268  const Muon::MuonSegment* muon_segment = dynamic_cast<const Muon::MuonSegment*>(trk_segment);
269  if (!muon_segment) {
270  ATH_MSG_WARNING("How can it be that a Muon segment is not a muon segment?");
271  continue;
272  }
273  // Check if the segment satisfies the quality criteria
274  if (m_segmentSelector->quality(*muon_segment) < m_segmentQuality) continue;
276  if (output_cache.combined_segs.count(muon_segment)) {
277  ATH_MSG_VERBOSE("Segment was already used in combined fit");
278  continue;
279  }
280  if (m_excludeNSW && std::find_if(muon_segment->containedMeasurements().begin(),muon_segment->containedMeasurements().end(),
281  [this](const Trk::MeasurementBase* meas ){
282  const Identifier meas_id = m_edmHelperSvc->getIdentifier(*meas);
283  return meas_id.is_valid() && (m_idHelperSvc->isMM(meas_id) || m_idHelperSvc->issTgc(meas_id));
284  })!= muon_segment->containedMeasurements().end()) continue;
285 
287  maskHits(muon_segment, output_cache);
288  output_cache.candidate_segments.push_back(muon_segment);
289  }
290  output_cache.combined_segs.clear();
291  return StatusCode::SUCCESS;
292 }

◆ hasMatchingSeed()

bool MuonInDetToMuonSystemExtensionAlg::hasMatchingSeed ( const MuonCombined::InDetCandidate id_cand,
const InDetCandidateCache cache 
) const
private

Searches for hough seeds within theta < 0.2 && sharing the same sector.

Definition at line 322 of file MuonInDetToMuonSystemExtensionAlg.cxx.

323  {
325  const double etaID = ms_entry->position().eta();
326  std::vector<int> id_sectors;
327  m_sector_mapping.getSectors(ms_entry->position().phi(), id_sectors);
328  for (const int& sect : id_sectors) {
329  std::map<int, std::vector<double>>::const_iterator theta_itr = cache.eta_seeds.find(sect);
330  if (theta_itr == cache.eta_seeds.end()) continue;
331  if (std::find_if(theta_itr->second.begin(), theta_itr->second.end(),
332  [&etaID](const double eta_seed) { return std::abs(etaID - eta_seed) < 0.1; }) != theta_itr->second.end())
333  return true;
334  }
335  return false;
336 }

◆ hasMatchingSegment()

bool MuonInDetToMuonSystemExtensionAlg::hasMatchingSegment ( const MuonCombined::InDetCandidate id_cand,
const InDetCandidateCache cache 
) const
private

Searches for segments within theta < 0.2 && sharing the same sector.

Definition at line 293 of file MuonInDetToMuonSystemExtensionAlg.cxx.

294  {
296  const double ThetaID = ms_entry->position().theta();
297  std::vector<int> id_sectors;
298  m_sector_mapping.getSectors(ms_entry->position().phi(), id_sectors);
299  auto sector_match = [&id_sectors, this](const Amg::Vector3D& seg_pos) -> bool {
300  std::vector<int> seg_sectors;
301  m_sector_mapping.getSectors(seg_pos.phi(), seg_sectors);
302  return std::find_if(id_sectors.begin(), id_sectors.end(), [&seg_sectors](const int id_sec) {
303  return std::find(seg_sectors.begin(), seg_sectors.end(), id_sec) != seg_sectors.end();
304  }) != id_sectors.end();
305  };
306  for (const Muon::MuonSegment* itSeg : cache.candidate_segments) {
307  const Amg::Vector3D pos = itSeg->globalPosition();
308  const double dTheta = pos.theta() - ThetaID;
309  const bool theta_match = std::abs(dTheta) < 0.2;
310  if (!theta_match) {
311  ATH_MSG_VERBOSE("dTheta cut failed");
312  continue;
313  }
314  if (!sector_match(pos)) {
315  ATH_MSG_VERBOSE("dPhi cut failed");
316  continue;
317  }
318  return true;
319  }
320  return false;
321 }

◆ initialize()

StatusCode MuonInDetToMuonSystemExtensionAlg::initialize ( )
override

Definition at line 34 of file MuonInDetToMuonSystemExtensionAlg.cxx.

34  {
36  ATH_CHECK(m_idHelperSvc.retrieve());
37  ATH_CHECK(m_edmHelperSvc.retrieve());
39  ATH_CHECK(m_inputCandidate.initialize());
40  ATH_CHECK(m_bulkInDetCandKey.initialize());
41  ATH_CHECK(m_stauInDetCandKey.initialize(!m_stauInDetCandKey.empty()));
42  if (m_restrictExtension) { ATH_MSG_INFO("Use the Hough seeds to determine the sectors in the MS worth for being extrapolated to"); }
45  if (m_restrictExtension) { ATH_CHECK(m_segmentSelector.retrieve()); }
46  return StatusCode::SUCCESS;
47 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

◆ isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const
overridevirtualinherited

◆ maskHits()

void MuonInDetToMuonSystemExtensionAlg::maskHits ( const Muon::MuonSegment muon_seg,
InDetCandidateCache output_cache 
) const
private

Mask the hits of the corresponding muon segment as used.

Definition at line 379 of file MuonInDetToMuonSystemExtensionAlg.cxx.

379  {
380  const Identifier seg_id = m_edmHelperSvc->chamberId(*muon_seg);
381  const LayerIndex layer_index = m_idHelperSvc->layerIndex(seg_id);
382  const RegionIndex region_index = m_idHelperSvc->regionIndex(seg_id);
383  const unsigned int hash = Muon::MuonStationIndex::sectorLayerHash(region_index, layer_index);
384  std::set<Identifier>& id_set = output_cache.consumed_hits[hash];
385  for (const Trk::MeasurementBase* meas : muon_seg->containedMeasurements()) {
386  const Identifier meas_id = m_edmHelperSvc->getIdentifier(*meas);
387  id_set.insert(meas_id);
388  }
389 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::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< Gaudi::Algorithm >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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  }

◆ selectCandidates()

StatusCode MuonInDetToMuonSystemExtensionAlg::selectCandidates ( const EventContext &  ctx,
InDetCandidateCache cache 
) const
private

Select the MuidCo candidates and put the associated id tracks on a black list.

Definition at line 75 of file MuonInDetToMuonSystemExtensionAlg.cxx.

75  {
77  if (!tag_map.isValid()) {
78  ATH_MSG_FATAL("Failed to retrieve the tag map from " << tag_map.fullKey());
79  return StatusCode::FAILURE;
80  }
81  if (tag_map->empty()) {
82  ATH_MSG_DEBUG("No combined candidates in this event");
83  return StatusCode::SUCCESS;
84  }
85 
86  for (const auto& combined_tags : *tag_map) {
87  if (combined_tags.second->author() != xAOD::Muon::MuidCo) {
88  ATH_MSG_WARNING("Found a non MuidCo tag.... Please check " << combined_tags.second->toString());
89  continue;
90  }
91  const MuonCombined::CombinedFitTag* cmb_tag = dynamic_cast<const MuonCombined::CombinedFitTag*>(combined_tags.second.get());
92  MuidCoCache cache{combined_tags.first, cmb_tag};
93  out_cache.tag_map.push_back(std::move(cache));
94  out_cache.excluded_trks.insert(combined_tags.first);
95  for (const Muon::MuonSegment* muon_seg : cmb_tag->associatedSegments()) {
96  out_cache.combined_segs.insert(muon_seg);
97  maskHits(muon_seg, out_cache);
98  }
99  }
100  return StatusCode::SUCCESS;
101 }

◆ setFilterPassed()

virtual void AthReentrantAlgorithm::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

139  {
140  execState( ctx ).setFilterPassed( state );
141  }

◆ sysExecute()

StatusCode AthReentrantAlgorithm::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 67 of file AthReentrantAlgorithm.cxx.

68 {
69  return Gaudi::Algorithm::sysExecute (ctx);
70 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

96  {
98 
99  if (sc.isFailure()) {
100  return sc;
101  }
102 
103  ServiceHandle<ICondSvc> cs("CondSvc",name());
104  for (auto h : outputHandles()) {
105  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
106  // do this inside the loop so we don't create the CondSvc until needed
107  if ( cs.retrieve().isFailure() ) {
108  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
109  return StatusCode::SUCCESS;
110  }
111  if (cs->regHandle(this,*h).isFailure()) {
112  sc = StatusCode::FAILURE;
113  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
114  << " with CondSvc");
115  }
116  }
117  }
118  return sc;
119 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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_bulkInDetCandKey

SG::WriteHandleKey<InDetCandidateCollection> MuonInDetToMuonSystemExtensionAlg::m_bulkInDetCandKey {this, "WriteInDetCandidates", "InDetCandidatesSystemExtened"}
private

Collection of InDet candidates written for MuGirl and MuonSegmentTag.

Definition at line 46 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_combTagMap

SG::ReadHandleKey<MuonCombined::InDetCandidateToTagMap> MuonInDetToMuonSystemExtensionAlg::m_combTagMap {this, "CombinedTagMap", "muidcoTagMap", "Combined muon tag map"}
private

That is the collection of MuidCo candidates.

Definition at line 63 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_edmHelperSvc

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

Definition at line 67 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_excludeNSW

Gaudi::Property<bool> MuonInDetToMuonSystemExtensionAlg::m_excludeNSW {this, "noNSWforSeeding", false, "Ignore hits/segments from the NSW"}
private

Prelimnary studies have shown that the NSWs generate a massive amount of fake candidates.

Definition at line 113 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_extendBulk

Gaudi::Property<bool> MuonInDetToMuonSystemExtensionAlg::m_extendBulk {this, "ExtendBulk", true}
private

Shall ordinary ID tracks be equiped with a muon system extension used by MuGirl later.

Definition at line 119 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_extendSAF

Gaudi::Property<bool> MuonInDetToMuonSystemExtensionAlg::m_extendSAF {this, "ExtendSAF", false}
private

Shall SAF tracks be equiped with a muon system extension used by MuGirl later.

Definition at line 117 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_extThreshold

Gaudi::Property<float> MuonInDetToMuonSystemExtensionAlg::m_extThreshold {this, "ExtensionPtThreshold", 2500}
private

Minimum pt threshold of the IdCandidate to be extrapolated through the spectrometer.

Definition at line 115 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_houghDataPerSectorVecKey

SG::ReadHandleKey<Muon::HoughDataPerSectorVec> MuonInDetToMuonSystemExtensionAlg::m_houghDataPerSectorVecKey
private
Initial value:
{this, "LayerHoughKey", "HoughDataPerSectorVec",
"HoughDataPerSectorVec key"}

Use the hough data to find sectors in the speectrometer traversed by a muon.

Definition at line 51 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_houghMin

Gaudi::Property<int> MuonInDetToMuonSystemExtensionAlg::m_houghMin {this, "minHoughHits", 4, "Minimum number of hits required for a hough maximum to be accepted"}
private

The hough maxima always contain at least 2 hits.

If a muon track passes through a chamber one expects more than that. Apply a minimum cuts on the hits in the hough maximum to reject background --> needs to be further tuned

Definition at line 109 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonInDetToMuonSystemExtensionAlg::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
private

Definition at line 65 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_inputCandidate

SG::ReadHandleKey<InDetCandidateCollection> MuonInDetToMuonSystemExtensionAlg::m_inputCandidate {this, "InputInDetCandidates", "InDetCandidates"}
private

Definition at line 43 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_muonSystemExtensionTool

ToolHandle<Muon::IMuonSystemExtensionTool> MuonInDetToMuonSystemExtensionAlg::m_muonSystemExtensionTool {this, "MuonSystemExtensionTool", "", "Muon system extension tool"}
private

The system extension tool extrapolates the candidate through the spectrometer.

Definition at line 61 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_restrictExtension

Gaudi::Property<bool> MuonInDetToMuonSystemExtensionAlg::m_restrictExtension {this, "UseOnlyHitSectors", false}
private

Restrict the extrapolation of ID tracks to sectors in the MS where at least a hit is recorded.

Definition at line 106 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_sector_mapping

const Muon::MuonSectorMapping MuonInDetToMuonSystemExtensionAlg::m_sector_mapping {}
private

Definition at line 121 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_segmentKey

SG::ReadHandleKey<Trk::SegmentCollection> MuonInDetToMuonSystemExtensionAlg::m_segmentKey
private
Initial value:
{this, "MuonSegmentLocation", "TrackMuonSegments",
"name of muon segment container"}

Let's exploit the segments to get rid of as much tracks as possible.

Definition at line 54 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_segmentQuality

Gaudi::Property<int> MuonInDetToMuonSystemExtensionAlg::m_segmentQuality {this, "segQuality", 1, "Quality cut on the segment."}
private

Definition at line 111 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_segmentSelector

PublicToolHandle<Muon::IMuonSegmentSelectionTool> MuonInDetToMuonSystemExtensionAlg::m_segmentSelector
private
Initial value:
{this, "MuonSegmentSelectionTool",
"Muon::MuonSegmentSelectionTool/MuonSegmentSelectionTool"}

Definition at line 57 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_stauInDetCandKey

SG::WriteHandleKey<InDetCandidateCollection> MuonInDetToMuonSystemExtensionAlg::m_stauInDetCandKey {this, "WriteStauCandidates", ""}
private

Collection of InDet candidates written for MuGirlStau.

Definition at line 48 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.


The documentation for this class was generated from the following files:
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
MuonInDetToMuonSystemExtensionAlg::m_muonSystemExtensionTool
ToolHandle< Muon::IMuonSystemExtensionTool > m_muonSystemExtensionTool
The system extension tool extrapolates the candidate through the spectrometer.
Definition: MuonInDetToMuonSystemExtensionAlg.h:61
Muon::IMuonSystemExtensionTool::SystemExtensionCache::sectorsWithHits
const std::map< MuonStationIndex::DetectorRegionIndex, std::set< int > > * sectorsWithHits
Cache the sectors which have a recorded hit.
Definition: IMuonSystemExtensionTool.h:47
Muon::MuonStationIndex::LayerIndexMax
@ LayerIndexMax
BEE.
Definition: MuonStationIndex.h:43
MuonInDetToMuonSystemExtensionAlg::m_extThreshold
Gaudi::Property< float > m_extThreshold
Minimum pt threshold of the IdCandidate to be extrapolated through the spectrometer.
Definition: MuonInDetToMuonSystemExtensionAlg.h:115
MuonCombined::InDetCandidate::getExtension
const Muon::MuonSystemExtension * getExtension() const
Definition: InDetCandidate.cxx:46
MuonCombined::CombinedFitTag::associatedSegments
std::vector< const Muon::MuonSegment * > associatedSegments() const override
access to associated segments, empty vector if non available
Definition: CombinedFitTag.cxx:49
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
MuonInDetToMuonSystemExtensionAlg::m_combTagMap
SG::ReadHandleKey< MuonCombined::InDetCandidateToTagMap > m_combTagMap
That is the collection of MuidCo candidates.
Definition: MuonInDetToMuonSystemExtensionAlg.h:63
MuonInDetToMuonSystemExtensionAlg::m_segmentSelector
PublicToolHandle< Muon::IMuonSegmentSelectionTool > m_segmentSelector
Definition: MuonInDetToMuonSystemExtensionAlg.h:57
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
MuonInDetToMuonSystemExtensionAlg::m_extendBulk
Gaudi::Property< bool > m_extendBulk
Shall ordinary ID tracks be equiped with a muon system extension used by MuGirl later.
Definition: MuonInDetToMuonSystemExtensionAlg.h:119
MuonInDetToMuonSystemExtensionAlg::m_houghMin
Gaudi::Property< int > m_houghMin
The hough maxima always contain at least 2 hits.
Definition: MuonInDetToMuonSystemExtensionAlg.h:109
MuonInDetToMuonSystemExtensionAlg::m_bulkInDetCandKey
SG::WriteHandleKey< InDetCandidateCollection > m_bulkInDetCandKey
Collection of InDet candidates written for MuGirl and MuonSegmentTag.
Definition: MuonInDetToMuonSystemExtensionAlg.h:46
calibdata.chamber
chamber
Definition: calibdata.py:32
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Muon::IMuonSystemExtensionTool::SystemExtensionCache::candidate
std::unique_ptr< MuonCombined::InDetCandidate > candidate
Inner detector candidate.
Definition: IMuonSystemExtensionTool.h:44
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
Muon::MuonSectorMapping::getSectors
void getSectors(double phi, std::vector< int > &sectors) const
returns the main sector plus neighboring if the phi position is in an overlap region
Definition: MuonSectorMapping.h:97
AthCommonDataStore::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 > renounce(T &h)
Definition: AthCommonDataStore.h:380
Muon::MuonStationIndex::sectorLayerHash
static unsigned int sectorLayerHash(DetectorRegionIndex detectorRegionIndex, LayerIndex layerIndex)
create a hash out of region and layer
Definition: MuonStationIndex.cxx:226
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
Muon::IMuonSystemExtensionTool::SystemExtensionCache::requireSystemExtension
bool requireSystemExtension
Require that the muon system extension was successful.
Definition: IMuonSystemExtensionTool.h:56
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
MuonInDetToMuonSystemExtensionAlg::m_sector_mapping
const Muon::MuonSectorMapping m_sector_mapping
Definition: MuonInDetToMuonSystemExtensionAlg.h:121
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
MuonCombined::InDetCandidate
Definition: InDetCandidate.h:18
MuonInDetToMuonSystemExtensionAlg::maskHits
void maskHits(const Muon::MuonSegment *muon_seg, InDetCandidateCache &output_cache) const
Mask the hits of the corresponding muon segment as used.
Definition: MuonInDetToMuonSystemExtensionAlg.cxx:379
MuonCombined::InDetCandidate::indetTrackParticleLink
const ElementLink< xAOD::TrackParticleContainer > & indetTrackParticleLink() const
access TrackParticleLink
Definition: InDetCandidate.cxx:33
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Trk::CaloExtension::muonEntryLayerIntersection
const TrackParameters * muonEntryLayerIntersection() const
access to intersection with the muon entry layer return NULL if the intersection failed
Definition: CaloExtension.h:70
Muon::MuonSectorMapping::getSector
int getSector(double phi) const
returns the sector corresponding to the phi position
Definition: MuonSectorMapping.h:86
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
MuonInDetToMuonSystemExtensionAlg::m_segmentQuality
Gaudi::Property< int > m_segmentQuality
Definition: MuonInDetToMuonSystemExtensionAlg.h:111
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
Muon::MuonStationIndex::regionName
static const std::string & regionName(DetectorRegionIndex index)
convert DetectorRegionIndex into a string
Definition: MuonStationIndex.cxx:176
MuonInDetToMuonSystemExtensionAlg::m_stauInDetCandKey
SG::WriteHandleKey< InDetCandidateCollection > m_stauInDetCandKey
Collection of InDet candidates written for MuGirlStau.
Definition: MuonInDetToMuonSystemExtensionAlg.h:48
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthReentrantAlgorithm::AthReentrantAlgorithm
AthReentrantAlgorithm()
Default constructor:
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Muon::MuonSystemExtension::muonEntryLayerIntersection
const Trk::TrackParameters & muonEntryLayerIntersection() const
access to intersection with the muon entry layer
Definition: MuonSystemExtension.h:60
MuonInDetToMuonSystemExtensionAlg::m_restrictExtension
Gaudi::Property< bool > m_restrictExtension
Restrict the extrapolation of ID tracks to sectors in the MS where at least a hit is recorded.
Definition: MuonInDetToMuonSystemExtensionAlg.h:106
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
MuonInDetToMuonSystemExtensionAlg::m_edmHelperSvc
ServiceHandle< Muon::IMuonEDMHelperSvc > m_edmHelperSvc
Definition: MuonInDetToMuonSystemExtensionAlg.h:67
MuonInDetToMuonSystemExtensionAlg::createStaus
StatusCode createStaus(const EventContext &ctx, const InDetCandidateCollection *ext_candidates, const MuidCoVector &tag_map) const
Definition: MuonInDetToMuonSystemExtensionAlg.cxx:338
MuonInDetToMuonSystemExtensionAlg::findSegments
StatusCode findSegments(const EventContext &ctx, InDetCandidateCache &output_cache) const
Select good segments.
Definition: MuonInDetToMuonSystemExtensionAlg.cxx:260
beamspotman.n
n
Definition: beamspotman.py:731
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Muon::IMuonSystemExtensionTool::SystemExtensionCache::createSystemExtension
bool createSystemExtension
Try to create the muon system extension.
Definition: IMuonSystemExtensionTool.h:54
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
Muon::MuonSystemExtension
Tracking class to hold the extrapolation from a particle from the calo entry to the end of muon syste...
Definition: MuonSystemExtension.h:18
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
Trk::Segment
Definition: Tracking/TrkEvent/TrkSegment/TrkSegment/Segment.h:56
MuonInDetToMuonSystemExtensionAlg::selectCandidates
StatusCode selectCandidates(const EventContext &ctx, InDetCandidateCache &cache) const
Select the MuidCo candidates and put the associated id tracks on a black list.
Definition: MuonInDetToMuonSystemExtensionAlg.cxx:75
MuonCombined::CombinedFitTag
TagBase implementation for a combined fit.
Definition: CombinedFitTag.h:24
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Muon::MuonStationIndex::layerName
static const std::string & layerName(LayerIndex index)
convert LayerIndex into a string
Definition: MuonStationIndex.cxx:192
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::ParametersBase
Definition: ParametersBase.h:55
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
MuonInDetToMuonSystemExtensionAlg::hasMatchingSeed
bool hasMatchingSeed(const MuonCombined::InDetCandidate &id_cand, const InDetCandidateCache &cache) const
Searches for hough seeds within theta < 0.2 && sharing the same sector.
Definition: MuonInDetToMuonSystemExtensionAlg.cxx:322
MuonCombined::InDetCandidate::toString
std::string toString() const
print candidate to string
Definition: InDetCandidate.cxx:17
MuonInDetToMuonSystemExtensionAlg::hasMatchingSegment
bool hasMatchingSegment(const MuonCombined::InDetCandidate &id_cand, const InDetCandidateCache &cache) const
Searches for segments within theta < 0.2 && sharing the same sector.
Definition: MuonInDetToMuonSystemExtensionAlg.cxx:293
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
Trk::PrepRawData
Definition: PrepRawData.h:62
Trk::MeasurementBase
Definition: MeasurementBase.h:58
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
MuonInDetToMuonSystemExtensionAlg::findHitSectors
StatusCode findHitSectors(const EventContext &ctx, InDetCandidateCache &output_cache) const
Find the sectors in the MS with muon signals.
Definition: MuonInDetToMuonSystemExtensionAlg.cxx:179
MuonInDetToMuonSystemExtensionAlg::m_excludeNSW
Gaudi::Property< bool > m_excludeNSW
Prelimnary studies have shown that the NSWs generate a massive amount of fake candidates.
Definition: MuonInDetToMuonSystemExtensionAlg.h:113
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
MuonCombined::InDetCandidate::getCaloExtension
const Trk::CaloExtension * getCaloExtension() const
Definition: InDetCandidate.cxx:47
Muon::MuonStationIndex::DetectorRegionIndexMax
@ DetectorRegionIndexMax
Definition: MuonStationIndex.h:50
Muon::HoughDataPerSec
Definition: HoughDataPerSec.h:20
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
MuonInDetToMuonSystemExtensionAlg::m_extendSAF
Gaudi::Property< bool > m_extendSAF
Shall SAF tracks be equiped with a muon system extension used by MuGirl later.
Definition: MuonInDetToMuonSystemExtensionAlg.h:117
Muon::IMuonSystemExtensionTool::SystemExtensionCache
Helper struct to pipe all data needed by the tool to equip the Id track with a MuonSystemExtension.
Definition: IMuonSystemExtensionTool.h:41
MuonInDetToMuonSystemExtensionAlg::m_houghDataPerSectorVecKey
SG::ReadHandleKey< Muon::HoughDataPerSectorVec > m_houghDataPerSectorVecKey
Use the hough data to find sectors in the speectrometer traversed by a muon.
Definition: MuonInDetToMuonSystemExtensionAlg.h:51
MuonInDetToMuonSystemExtensionAlg::create
StatusCode create(const EventContext &ctx, InDetCandidateCache &cache) const
Create the InDetCandidaes with system extensions.
Definition: MuonInDetToMuonSystemExtensionAlg.cxx:102
MuonParameters::MuidCo
@ MuidCo
Definition: MuonParamDefs.h:60
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
a
TList * a
Definition: liststreamerinfos.cxx:10
MuonCombined::InDetCandidate::indetTrackParticle
const xAOD::TrackParticle & indetTrackParticle() const
access TrackParticle
Definition: InDetCandidate.cxx:27
h
MuonInDetToMuonSystemExtensionAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonInDetToMuonSystemExtensionAlg.h:65
MuonCombined::InDetCandidate::isSiliconAssociated
bool isSiliconAssociated() const
Returns true if this candidate was formed from a special far forward InDet track.
Definition: InDetCandidate.cxx:35
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Muon::nsw::STGTPSegments::MergedSegmentProperty::dTheta
@ dTheta
DEBUG
#define DEBUG
Definition: page_access.h:11
Muon::MuonSystemExtension::layerIntersections
const std::vector< Intersection > & layerIntersections() const
access to the intersections with the layers.
Definition: MuonSystemExtension.h:62
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
Muon::MuonSegment::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
global position
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:157
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
Muon::IMuonSystemExtensionTool::SystemExtensionCache::useHitSectors
bool useHitSectors
Switch to restrict the intersection search only to the sectors with hits.
Definition: IMuonSystemExtensionTool.h:52
Muon::MuonSegment
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:45
MuonInDetToMuonSystemExtensionAlg::m_segmentKey
SG::ReadHandleKey< Trk::SegmentCollection > m_segmentKey
Let's exploit the segments to get rid of as much tracks as possible.
Definition: MuonInDetToMuonSystemExtensionAlg.h:54
Trk::TrkDetElementBase::center
virtual const Amg::Vector3D & center() const =0
Return the center of the element.
MuonInDetToMuonSystemExtensionAlg::m_inputCandidate
SG::ReadHandleKey< InDetCandidateCollection > m_inputCandidate
Definition: MuonInDetToMuonSystemExtensionAlg.h:43
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::HoughDataPerSec::MaximumVec
std::vector< std::shared_ptr< MuonHough::MuonLayerHough::Maximum > > MaximumVec
Definition: HoughDataPerSec.h:24
fitman.k
k
Definition: fitman.py:528
Trk::PrepRawData::detectorElement
virtual const TrkDetElementBase * detectorElement() const =0
return the detector element corresponding to this PRD The pointer will be zero if the det el is not d...
ServiceHandle< ICondSvc >
Identifier
Definition: IdentifierFieldParser.cxx:14