ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
MuonR4::EtaHoughTransformAlg Class Reference

Algorithm to handle the eta hough transform. More...

#include <EtaHoughTransformAlg.h>

Inheritance diagram for MuonR4::EtaHoughTransformAlg:
Collaboration diagram for MuonR4::EtaHoughTransformAlg:

Public Member Functions

virtual ~EtaHoughTransformAlg ()=default
 
virtual StatusCode initialize () override
 
virtual 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, V, H > &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 HoughSetupForBucket = HoughEventData::HoughSetupForBucket
 
typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

void preProcess (const EventContext &ctx, const ActsGeometryContext &gctx, const SpacePointContainer &spacePoints, HoughEventData &data) const
 pre-processing method called once per event. More...
 
void prepareHoughPlane (HoughEventData &data) const
 prepare the accumulator and the peak finder once per event More...
 
void processBucket (const EventContext &ctx, HoughEventData &data, HoughSetupForBucket &currentBucket) const
 process a bucket. More...
 
void fillFromSpacePoint (HoughEventData &data, const MuonR4::HoughHitType &SP) const
 fill the accumulator from a given space point. More...
 
bool passSeedQuality (const HoughSetupForBucket &currentBucket, const MuonR4::ActsPeakFinderForMuon::Maximum &maximum) const
 apply quality cuts on a given maximum More...
 
void extendWithPhiHits (std::vector< HoughHitType > &hitList, HoughSetupForBucket &bucket) const
 extend a maximum with all compatible (pure) phi hits. More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Static Private Member Functions

static bool isPrecisionHit (const HoughHitType &hit)
 Returns whether the hit is a precision hit or not. More...
 

Private Attributes

DoubleProperty m_targetResoTanTheta {this, "ResolutionTargetTanTheta", 0.05}
 
DoubleProperty m_targetResoIntercept {this, "ResolutionTargetIntercept", 10.}
 
DoubleProperty m_minSigmasSearchTanTheta {this, "minSigmasSearchTanTheta", 2.0}
 
DoubleProperty m_minSigmasSearchIntercept {this, "minSigmasSearchIntercept", 2.0}
 
DoubleProperty m_peakThreshold {this, "peakThreshold", 2.5}
 
DoubleProperty m_minMaxDistTheta {this, "MaximumSeparationTheta", 0.}
 
DoubleProperty m_minMaxDistIntercept {this, "MaximumSeparationIntercept", 15.}
 
DoubleProperty m_peakFractionCutOff {this, "PeakFractionCutOff", 0.6}
 
UnsignedIntegerProperty m_nPrecHitCut {this, "nMinPrecHits", 3}
 
IntegerProperty m_nBinsTanTheta {this, "nBinsTanTheta", 7}
 
IntegerProperty m_nBinsIntercept {this, "nBinsIntercept", 15}
 
BooleanProperty m_downWeightMultiplePrd {this, "downWeightPrdMultiplicity", false}
 
ServiceHandle< Muon::IMuonIdHelperSvcm_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
 Handle to the IdHelperSvc. More...
 
SG::ReadHandleKey< SpacePointContainerm_spacePointKey {this, "SpacePointContainer", "MuonSpacePoints"}
 
SG::WriteHandleKey< EtaHoughMaxContainerm_maxima {this, "EtaHoughMaxContainer", "MuonHoughStationMaxima"}
 
SG::ReadHandleKey< ActsGeometryContextm_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
 
ToolHandle< MuonValR4::IPatternVisualizationToolm_visionTool {this, "VisualizationTool", ""}
 Pattern visualization tool. More...
 
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

Algorithm to handle the eta hough transform.

This algorithm is responsible for the initial eta hough transform from space-points created in an upstream alg. It will write HoughMaxima into the event store for downstream use.

Definition at line 29 of file EtaHoughTransformAlg.h.

Member Typedef Documentation

◆ HoughSetupForBucket

Definition at line 39 of file EtaHoughTransformAlg.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ~EtaHoughTransformAlg()

virtual MuonR4::EtaHoughTransformAlg::~EtaHoughTransformAlg ( )
virtualdefault

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality
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 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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, V, H > &  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, V, H > &  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, V, H > &  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, V, H > &  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 MuonR4::EtaHoughTransformAlg::execute ( const EventContext &  ctx) const
overridevirtual

read the PRDs

pre-populate the event data - sort PRDs by station

book the hough plane

now perform the actual HT for each station

Definition at line 72 of file EtaHoughTransformAlg.cxx.

72  {
73 
75  const SpacePointContainer* spacePoints{nullptr};
77 
78  // book the output container
80  ATH_CHECK(writeMaxima.record(std::make_unique<EtaHoughMaxContainer>()));
81 
82  const ActsGeometryContext* gctx{nullptr};
83  ATH_CHECK(SG::get(gctx, m_geoCtxKey, ctx));
84 
86 
88  preProcess(ctx, *gctx, *spacePoints, data);
89 
93  for (auto& [station, stationHoughBuckets] : data.houghSetups) {
94  // reset the list of maxima
95  for (auto& bucket : stationHoughBuckets) {
96  processBucket(ctx, data, bucket);
97  }
98  for (HoughMaximum& max : data.maxima) {
99  writeMaxima->push_back(std::make_unique<HoughMaximum>(std::move(max)));
100  }
101  data.maxima.clear();
102  }
103  std::stable_sort(writeMaxima->begin(), writeMaxima->end(),
104  [](const HoughMaximum* a, const HoughMaximum* b){
105  return (*a->parentBucket()) < (*b->parentBucket());
106  });
107  return StatusCode::SUCCESS;
108 }

◆ extendWithPhiHits()

void MuonR4::EtaHoughTransformAlg::extendWithPhiHits ( std::vector< HoughHitType > &  hitList,
HoughSetupForBucket bucket 
) const
private

extend a maximum with all compatible (pure) phi hits.

Parameters
hitListlist of hits to extend
bucketthe bucket to take the phi hits from

Definition at line 470 of file EtaHoughTransformAlg.cxx.

471  {
472  for (const SpacePointBucket::value_type& hit : *bucket.bucket) {
473  if (!hit->measuresEta()) {
474  hitList.push_back(hit.get());
475  }
476  }
477 }

◆ 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 & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

90 {
91  // If we didn't find any symlinks to add, just return the collection
92  // from the base class. Otherwise, return the extended collection.
93  if (!m_extendedExtraObjects.empty()) {
95  }
96  return BaseAlg::extraOutputDeps();
97 }

◆ fillFromSpacePoint()

void MuonR4::EtaHoughTransformAlg::fillFromSpacePoint ( HoughEventData data,
const MuonR4::HoughHitType SP 
) const
private

fill the accumulator from a given space point.

Parameters
dataevent data object
SPspace point to fill from

Definition at line 440 of file EtaHoughTransformAlg.cxx.

440  {
441 
442  using namespace std::placeholders;
443  double w = 1.0;
444  // convert Gaudi::property to double to avoid deep copy in std::bind expression
445  double resolutionTarget = m_targetResoIntercept;
446  // downweight RPC measurements in the barrel relative to MDT
448  w = 0.5;
449  }
451  // if invalid time, do not count this hit towards a potential peak.
452  // The hits will still be included in a potential maximum formed by valid hits,
453  // for later recovery.
454  if (!isPrecisionHit(SP)) w = 0;
455  const auto* dc = static_cast<const xAOD::MdtDriftCircle*>(SP->primaryMeasurement());
456  // dummy index for precision layer counting within the hough plane
457  const unsigned precisionLayerIndex = (dc->readoutElement()->multilayer() * 10 + dc->tubeLayer());
458  data.houghPlane->fill<HoughHitType>(SP, data.currAxisRanges, HoughHelpers::Eta::houghParamMdtLeft,
459  std::bind(HoughHelpers::Eta::houghWidthMdt, _1, _2, resolutionTarget), SP, precisionLayerIndex, w);
460  data.houghPlane->fill<HoughHitType>(SP, data.currAxisRanges, HoughHelpers::Eta::houghParamMdtRight,
461  std::bind(HoughHelpers::Eta::houghWidthMdt, _1, _2, resolutionTarget), SP, precisionLayerIndex, w);
462  } else {
463  if (SP->measuresEta()) {
464  data.houghPlane->fill<HoughHitType>(SP, data.currAxisRanges, HoughHelpers::Eta::houghParamStrip,
465  std::bind(HoughHelpers::Eta::houghWidthStrip, _1, _2, resolutionTarget), SP, 0, w * (
466  m_downWeightMultiplePrd ? 1.0 / SP->nEtaInstanceCounts() : 1.));
467  }
468  }
469 }

◆ filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

96  {
97  return execState( ctx ).filterPassed();
98  }

◆ initialize()

StatusCode MuonR4::EtaHoughTransformAlg::initialize ( )
overridevirtual

Definition at line 64 of file EtaHoughTransformAlg.cxx.

64  {
67  ATH_CHECK(m_maxima.initialize());
68  ATH_CHECK(m_idHelperSvc.retrieve());
69  ATH_CHECK(m_visionTool.retrieve(EnableTool{!m_visionTool.empty()}));
70  return StatusCode::SUCCESS;
71 }

◆ 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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

52 {
53  // Reentrant algorithms are clonable.
54  return true;
55 }

◆ isPrecisionHit()

bool MuonR4::EtaHoughTransformAlg::isPrecisionHit ( const HoughHitType hit)
staticprivate

Returns whether the hit is a precision hit or not.

Definition at line 152 of file EtaHoughTransformAlg.cxx.

152  {
153  switch (hit->type()){
155  const auto* dc = static_cast<const xAOD::MdtDriftCircle*>(hit->primaryMeasurement());
157  }
159  return hit->measuresEta();
160  }
162  const auto* meas = static_cast<const xAOD::sTgcMeasurement*>(hit->primaryMeasurement());
163  return meas->channelType() == sTgcIdHelper::sTgcChannelTypes::Strip;
164  } default:
165  break;
166  }
167  return false;
168 }

◆ 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.

◆ passSeedQuality()

bool MuonR4::EtaHoughTransformAlg::passSeedQuality ( const HoughSetupForBucket currentBucket,
const MuonR4::ActsPeakFinderForMuon::Maximum &  maximum 
) const
private

apply quality cuts on a given maximum

Determine the minimal & maximal possible position along the tube / strip

Calculate the width / tube length at the centre crossing point (maximum.x -> tanTheta, maximum.y -> y0)

Definition at line 182 of file EtaHoughTransformAlg.cxx.

182  {
183 
184  // now we propagate along the seed trajectory and collect crossed volumes
185  int expectedPrecisionChambers{0}, seenPrecisionChambers{0};
186  bool hasTrig = false;
187 
188  std::unordered_set<const MuonGMR4::MuonReadoutElement*> seenChambers{};
189  std::set<std::pair<int,int>> seenLayers;
190  using enum Acts::TrapezoidVolumeBounds::BoundValues;
191  const double halfX = currentBucket.bucket->msSector()->bounds()->get(eHalfLengthXposY);
193  std::array<double, 2> tubeExtend{halfX, -halfX};
194 
195  auto addSeenHit = [&tubeExtend, &seenLayers, &seenChambers](const SpacePoint& sp,
197  const double sensorL,
198  const int mL, const int layer){
199  seenLayers.emplace(mL, layer);
200  seenChambers.insert(re);
201  tubeExtend[0] = std::min(tubeExtend[0], sp.positionInChamber().x() - sensorL);
202  tubeExtend[1] = std::max(tubeExtend[1], sp.positionInChamber().x() + sensorL);
203  };
204  for (const SpacePoint* SP : maximum.hitIdentifiers){
205  ATH_MSG_VERBOSE(__func__<<"() - "<<__LINE__<<" Maximum has associated hit in "
206  << m_idHelperSvc->toStringDetEl(SP->identify()));
207 
208  if (isPrecisionHit(SP)) {
210  const auto* dc = static_cast<const xAOD::MdtDriftCircle*>(SP->primaryMeasurement());
211  const MuonGMR4::MdtReadoutElement* re = dc->readoutElement();
212  addSeenHit(*SP, re, 0.5*re->activeTubeLength(dc->measurementHash()),
213  re->multilayer(), dc->tubeLayer());
214  } else if(SP->type() == xAOD::UncalibMeasType::MMClusterType){
215  const auto* clust = static_cast<const xAOD::MMCluster*>(SP->primaryMeasurement());
216  const MuonGMR4::MmReadoutElement* re = clust->readoutElement();
217  addSeenHit(*SP, re, 0.5*re->stripLayer(clust->measurementHash()).design().stripLength(clust->channelNumber()),
218  re->multilayer(), clust->gasGap());
219  } else if (SP->type() == xAOD::UncalibMeasType::sTgcStripType) {
220  const auto* clust = static_cast<const xAOD::sTgcMeasurement*>(SP->primaryMeasurement());
221  const MuonGMR4::sTgcReadoutElement* re = clust->readoutElement();
222  addSeenHit(*SP, re, 0.5*re->stripLayer(clust->measurementHash()).design().stripLength(clust->channelNumber()),
223  re->multilayer(), clust->gasGap());
224  }
225  } else {
226  seenChambers.insert(xAOD::muonReadoutElement(SP->primaryMeasurement()));
227  }
228  }
229  // loop over all chambers in the bucket
230  for (const auto & muonChamber : currentBucket.bucket->chamberLocations()){
231  // skip any we don't touch
232  if (!passesThrough(muonChamber, maximum.y, maximum.x)) {
233  ATH_MSG_VERBOSE(__func__<<"() - "<<__LINE__<<" maximum does not cross "
234  << m_idHelperSvc->toStringDetEl(muonChamber.readoutEle()->identify()));
235  continue;
236  }
237  ATH_MSG_VERBOSE(__func__<<"() - "<<__LINE__<<" maximum crosses "
238  << m_idHelperSvc->toStringDetEl(muonChamber.readoutEle()->identify())<<", "
239  <<(*muonChamber.bounds())<<", @: "<<Amg::toString(muonChamber.location()));
240  // for MDT multilayers, we increase our expected number of crossed chambers / tubes
241  const ActsTrk::DetectorType type = muonChamber.readoutEle()->detectorType();
242 
243  // now we check if we have a compatible measurement on our seed
244  const bool hasHit = seenChambers.count(muonChamber.readoutEle());
245  const bool precTech = (type == ActsTrk::DetectorType::Mdt || type == ActsTrk::DetectorType::Mm ||
247  if (hasHit) {
248  // if we find an MDT hit, we increment the counter for seen chambers
249  if (precTech) {
250  ++seenPrecisionChambers;
251  } else {
252  hasTrig = true;
253  continue;
254  }
255  } else if (precTech) {
258  const double lowL = muonChamber.width(maximum.y + muonChamber.location().z() * maximum.x);
259  const std::array<double, 2> chambEdges{muonChamber.location().x() - lowL,
260  muonChamber.location().x() + lowL};
261 
262  const double coverage = chamberCoverage(tubeExtend, chambEdges);
263  if (coverage < 0.95){
264  ATH_MSG_VERBOSE(__func__<<"() - "<<__LINE__<<" Reject chamber due to partial coverage: "<<coverage
265  <<", chamb extend: "<<chambEdges[0]<<"-"<<chambEdges[1]
266  <<", tube extend: "<<tubeExtend[0]<<"-"<<tubeExtend[1]
267  <<", "<<(*muonChamber.readoutEle()->msSector()->bounds()));
268  continue;
269  }
270  } else {
271  continue;
272  }
273  ++expectedPrecisionChambers;
274  }
275  // compute the minimum number of requested precision layers
276  // the integer division will round down (resulting cut: 2 for single-ML, 4 for dual-ML)
277  int minLayers = seenLayers.size() / 2 + 1;
278  // require 2 precision chambers with measurements, except if we only cross one precision multilayer in total
279  int minSeenPrecisionChambers = (expectedPrecisionChambers > 1) + 1;
280  // if we have at least one trigger hit, we loosen the requirements on precision hits and chambers
281  if (hasTrig) {
282  minLayers -= 1;
283  minSeenPrecisionChambers = 1;
284  }
285  ATH_MSG_VERBOSE(__func__<<"() - "<<__LINE__<<": "<<currentBucket.bucket->msSector()->identString()<<
286  ", seen prec: "<<seenPrecisionChambers<<", required: "<<minSeenPrecisionChambers
287  <<" -- layers: "<<seenLayers.size()<<", required: "<<minLayers);
288  return seenPrecisionChambers >= minSeenPrecisionChambers && (int)seenLayers.size() >= minLayers;
289 }

◆ prepareHoughPlane()

void MuonR4::EtaHoughTransformAlg::prepareHoughPlane ( HoughEventData data) const
private

prepare the accumulator and the peak finder once per event

Parameters
dataevent data object

Definition at line 170 of file EtaHoughTransformAlg.cxx.

170  {
171  HoughPlaneConfig cfg;
172  cfg.nBinsX = m_nBinsTanTheta;
173  cfg.nBinsY = m_nBinsIntercept;
174  ActsPeakFinderForMuonCfg peakFinderCfg;
175  peakFinderCfg.fractionCutoff = m_peakFractionCutOff;
176  peakFinderCfg.threshold = m_peakThreshold;
177  peakFinderCfg.minSpacingBetweenPeaks = {m_minMaxDistTheta, m_minMaxDistIntercept};
178  data.houghPlane = std::make_unique<HoughPlane>(cfg);
179  data.peakFinder = std::make_unique<ActsPeakFinderForMuon>(peakFinderCfg);
180 }

◆ preProcess()

void MuonR4::EtaHoughTransformAlg::preProcess ( const EventContext &  ctx,
const ActsGeometryContext gctx,
const SpacePointContainer spacePoints,
HoughEventData data 
) const
private

pre-processing method called once per event.

Populates the event data with the space points for each bucket and identifies the optimal search space in each bucket.

Parameters
ctxEventContext to parse to the visualization tool
gctxGeometry context to retrieve global positioning of the chambers
spacePointspoint list from store gate
dataevent data object

Project the hits onto the center (z=0) axis of the chamber, using our guesstimate of tan(theta)

Definition at line 109 of file EtaHoughTransformAlg.cxx.

112  {
113 
114  ATH_MSG_DEBUG("Load " << spacePoints.size() << " space point buckets");
115  for (const SpacePointBucket* bucket : spacePoints) {
116  if (m_visionTool.isEnabled()) {
117  m_visionTool->visualizeBucket(ctx, *bucket, "bucket");
118  }
119  std::vector<HoughSetupForBucket>& buckets = data.houghSetups[bucket->front()->msSector()];
120  HoughSetupForBucket& hs{buckets.emplace_back(bucket)};
121  const Amg::Transform3D globToLoc{hs.bucket->msSector()->globalToLocalTrans(gctx)};
122  Amg::Vector3D leftSide = globToLoc.translation() - (hs.bucket->coveredMin() * Amg::Vector3D::UnitY());
123  Amg::Vector3D rightSide = globToLoc.translation() - (hs.bucket->coveredMax() * Amg::Vector3D::UnitY());
124 
125  // get the average z of our hits and use it to correct our angle estimate
126  double zmin{1.e9}, zmax{-1.e9};
127  for (const std::shared_ptr<MuonR4::SpacePoint> & sp : *bucket) {
128  zmin = std::min(zmin, sp->positionInChamber().z());
129  zmax = std::max(zmax, sp->positionInChamber().z());
130  }
131  const double z = 0.5*(zmin + zmax);
132 
133  // estimate the angle, adding extra tolerance based on our target resolution
134  const double tanThetaLeft = (leftSide.y() - m_targetResoIntercept) / (leftSide.z() - z) - m_targetResoTanTheta;
135  const double tanThetaRight = (rightSide.y() + m_targetResoIntercept) / (rightSide.z() - z) + m_targetResoTanTheta;
136  hs.searchWindowTanAngle = {tanThetaLeft, tanThetaRight};
137  double ymin{1e9}, ymax{-1e9};
138 
141  for (const std::shared_ptr<MuonR4::SpacePoint> & hit : *bucket){
142  // two estimates: For the two extrema of tan(theta) resulting from the guesstimate
143  double y0l = hit->positionInChamber().y() - hit->positionInChamber().z() * tanThetaLeft;
144  double y0r = hit->positionInChamber().y() - hit->positionInChamber().z() * tanThetaRight;
145  // pick the widest envelope
148  }
149  hs.searchWindowIntercept = {ymin, ymax};
150  }
151 }

◆ processBucket()

void MuonR4::EtaHoughTransformAlg::processBucket ( const EventContext &  ctx,
HoughEventData data,
HoughSetupForBucket currentBucket 
) const
private

process a bucket.

Performs the hough transform in the given bucket and adds the maxima to the event data.

Parameters
ctxEventContext to parse to the visualization tool
dataevent data object
currentBucketbucket to process

tune the search space

Definition at line 292 of file EtaHoughTransformAlg.cxx.

294  {
296 
297  double chamberCenter = 0.5 * (bucket.searchWindowIntercept.first +
298  bucket.searchWindowIntercept.second);
299  // build a symmetric window around the (geometric) chamber center so that
300  // the bin width is equivalent to our target resolution
301  double searchStart = chamberCenter - 0.5 * data.houghPlane->nBinsY() * m_targetResoIntercept;
302  double searchEnd = chamberCenter + 0.5 * data.houghPlane->nBinsY() * m_targetResoIntercept;
303  // Protection for very wide buckets - if the search space does not cover all
304  // of the bucket, widen the bin size so that we cover everything
305  searchStart = std::min(searchStart, bucket.searchWindowIntercept.first -
307  searchEnd = std::max(searchEnd, bucket.searchWindowIntercept.second +
309  // also treat tan(theta)
310  double tanThetaMean = 0.5 * (bucket.searchWindowTanAngle.first +
311  bucket.searchWindowTanAngle.second);
312  double searchStartTanTheta = tanThetaMean - 0.5 * data.houghPlane->nBinsX() * m_targetResoTanTheta;
313  double searchEndTanTheta = tanThetaMean + 0.5 * data.houghPlane->nBinsX() * m_targetResoTanTheta;
314  searchStartTanTheta = std::min(searchStartTanTheta, bucket.searchWindowTanAngle.first -
316  searchEndTanTheta = std::max(searchEndTanTheta, bucket.searchWindowTanAngle.second +
318 
319  data.currAxisRanges = Acts::HoughTransformUtils::HoughAxisRanges{
320  searchStartTanTheta, searchEndTanTheta, searchStart, searchEnd};
321 
322  data.houghPlane->reset();
323  for (const SpacePointBucket::value_type& hit : *(bucket.bucket)) {
324  fillFromSpacePoint(data, hit.get());
325  }
326  auto maxima = data.peakFinder->findPeaks(*(data.houghPlane), data.currAxisRanges);
327  if (m_visionTool.isEnabled()) {
328  m_visionTool->visualizeAccumulator(ctx, *data.houghPlane, data.currAxisRanges, maxima,
329  "#eta Hough accumulator");
330  }
331  if (maxima.empty()) {
332  ATH_MSG_DEBUG("Station "<<bucket.bucket->msSector()->identString()
333  <<":\n Mean tanTheta was "<<tanThetaMean
334  << " and my intercept "<<chamberCenter
335  <<", with hits in the bucket in "<< bucket.bucket->coveredMin()
336  <<" - "<<bucket.bucket->coveredMax()
337  <<". The bucket found a search range of ("
338  <<bucket.searchWindowTanAngle.first<<" - "
339  <<bucket.searchWindowTanAngle.second<<") and ("
340  <<bucket.searchWindowIntercept.first<<" - "
341  <<bucket.searchWindowIntercept.second
342  <<") , and my final search range is ["
343  <<searchStartTanTheta<<" - "<<searchEndTanTheta
344  <<"] and ["<<searchStart<<" - "<<searchEnd
345  <<"] with "<<m_nBinsTanTheta<<" and "
346  <<m_nBinsIntercept<<" bins.");
347  return;
348  }
349 
350  // remember used hits - assign only to first maximum when counting
351  // precision hits
352  std::set<HoughHitType> seenHits;
353 
354  // now clean up and potentially write the maxima
355  for (const auto& max : maxima) {
356 
357  // precision hit cut, using only the measurements on the hough maximum
358  unsigned int nPrec{0};
359  auto toBins = [&data](double x, double y){
360  return std::make_pair(
361  Acts::HoughTransformUtils::binIndex(data.currAxisRanges.xMin, data.currAxisRanges.xMax, data.houghPlane->nBinsX(), x),
362  Acts::HoughTransformUtils::binIndex(data.currAxisRanges.yMin, data.currAxisRanges.yMax, data.houghPlane->nBinsY(), y)
363  );
364  };
365  auto accumulatorBins = toBins(max.x,max.y);
366  for (const HoughHitType& hit : data.houghPlane->hitIds(accumulatorBins.first, accumulatorBins.second)) {
367  auto res = seenHits.emplace(hit);
368  if (res.second){
369  nPrec += isPrecisionHit(hit);
370  }
371  }
372  if (nPrec < m_nPrecHitCut) {
373  ATH_MSG_VERBOSE("The maximum did not pass the precision hit cut");
374  continue;
375  }
376 
377  // convert the set of hit identifiers from ACTS to the vector we need later
378  std::vector<HoughHitType> hitList{max.hitIdentifiers.begin(), max.hitIdentifiers.end()};
379 
380  // apply a seed quality cut.
381  if (!passSeedQuality(bucket, max)) {
382  // if seed visualisation is enabled, draw the rejected seed
383  if (m_visionTool.isEnabled()) {
384  const HoughMaximum& houghMax{max.x, max.y, 1. *hitList.size(), std::move(hitList), bucket.bucket};
385  const SegmentSeed seed{houghMax};
388  for (auto & chamber : bucket.bucket->chamberLocations()) {
389  primitives.push_back(MuonValR4::drawBox(chamber.minY(), chamber.minZ(),
390  chamber.maxY(), chamber.maxZ(), kGray+2));
391  const Identifier detId{chamber.readoutEle()->identify()};
392  const int eta = m_idHelperSvc->stationEta(detId);
393  std::string chLabel = std::format("{:}{:1d}{:}{:2d}", m_idHelperSvc->stationNameString(detId),
394  std::abs(eta), eta > 0? 'A' : 'C', m_idHelperSvc->stationPhi(detId));
395  switch (chamber.readoutEle()->detectorType()) {
397  chLabel += std::format("M{:1d}", m_idHelperSvc->mdtIdHelper().multilayer(detId));
398  } default:
399  break;
400  }
401  primitives.push_back(MuonValR4::drawLabel(chLabel, chamber.minY(), chamber.maxZ() + 0.02,8));
402  }
403 
404  primitives.push_back(MuonValR4::drawLabel(std::format("Missed seed - score {}, layer score {}, comprising {} measurements ",data.houghPlane->nHits(accumulatorBins.first, accumulatorBins.second),data.houghPlane->nLayers(accumulatorBins.first, accumulatorBins.second),hitList.size()),0.05,0.03,12));
405 
406  primitivesForAcc.push_back(MuonValR4::drawLabel(std::format("Missed seed - score {}, layer score {}, comprising {} measurements ",data.houghPlane->nHits(accumulatorBins.first, accumulatorBins.second),data.houghPlane->nLayers(accumulatorBins.first, accumulatorBins.second),hitList.size()),0.05,0.03,12));
407  m_visionTool->visualizeAccumulator(ctx, *data.houghPlane, data.currAxisRanges, {max},
408  "MissedAccumulator", std::move(primitivesForAcc));
409  m_visionTool->visualizeSeed(ctx, seed, "Missed seed",std::move(primitives));
410  }
411  continue;
412  }
413 
414  // this seed looks good! Let's finalise it
415  size_t nHits = hitList.size();
416  // add phi measurements - will be filtered for compatibility in separate algorithm
417  extendWithPhiHits(hitList, bucket);
418  // sort hits by layer
419  const SpacePointPerLayerSorter sorter{};
420  std::ranges::stable_sort(hitList, sorter);
421  // create hough maximum instance and add it to the event data for later writing!
422  const HoughMaximum& houghMax{data.maxima.emplace_back(max.x, max.y, nHits, std::move(hitList), bucket.bucket)};
423 
424  // if desired, visualise the result
425  if (m_visionTool.isEnabled()) {
426  const SegmentSeed seed{houghMax};
429  for (auto & chamber : bucket.bucket->chamberLocations()){
430  primitives.push_back(MuonValR4::drawBox(chamber.minY(), chamber.minZ(), chamber.maxY(), chamber.maxZ(), kGray+2));
431  }
432  primitives.push_back(MuonValR4::drawLabel(std::format("score {}, layer score {}, comprising {} measurements. wx = {:.2f}, wy = {:.1f} ",data.houghPlane->nHits(accumulatorBins.first, accumulatorBins.second),data.houghPlane->nLayers(accumulatorBins.first, accumulatorBins.second),hitList.size(), max.wx, max.wy),0.05,0.03,12));
433  primitivesForAcc.push_back(MuonValR4::drawLabel(std::format("score {}, layer score {}, comprising {} measurements. wx = {:.2f}, wy = {:.1f} ",data.houghPlane->nHits(accumulatorBins.first, accumulatorBins.second),data.houghPlane->nLayers(accumulatorBins.first, accumulatorBins.second),hitList.size(), max.wx / m_targetResoTanTheta, max.wy / m_targetResoIntercept),0.05,0.03,12));
434 
435  m_visionTool->visualizeAccumulator(ctx, *data.houghPlane, data.currAxisRanges, {max},"#eta Hough accumulator", std::move(primitivesForAcc));
436  m_visionTool->visualizeSeed(ctx, seed, "#eta-HoughSeed", std::move(primitives));
437  }
438  }
439 }

◆ 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  }

◆ setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100  {
101  execState( ctx ).setFilterPassed( state );
102  }

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 85 of file AthCommonReentrantAlgorithm.cxx.

77 {
78  return BaseAlg::sysExecute (ctx);
79 }

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 61 of file AthCommonReentrantAlgorithm.cxx.

107  {
109 
110  if (sc.isFailure()) {
111  return sc;
112  }
113 
114  ServiceHandle<ICondSvc> cs("CondSvc",name());
115  for (auto h : outputHandles()) {
116  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
117  // do this inside the loop so we don't create the CondSvc until needed
118  if ( cs.retrieve().isFailure() ) {
119  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
120  return StatusCode::SUCCESS;
121  }
122  if (cs->regHandle(this,*h).isFailure()) {
123  sc = StatusCode::FAILURE;
124  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
125  << " with CondSvc");
126  }
127  }
128  }
129  return sc;
130 }

◆ 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_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_downWeightMultiplePrd

BooleanProperty MuonR4::EtaHoughTransformAlg::m_downWeightMultiplePrd {this, "downWeightPrdMultiplicity", false}
private

Definition at line 108 of file EtaHoughTransformAlg.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_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_geoCtxKey

SG::ReadHandleKey<ActsGeometryContext> MuonR4::EtaHoughTransformAlg::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
private

Definition at line 117 of file EtaHoughTransformAlg.h.

◆ m_idHelperSvc

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

Handle to the IdHelperSvc.

Definition at line 110 of file EtaHoughTransformAlg.h.

◆ m_maxima

SG::WriteHandleKey<EtaHoughMaxContainer> MuonR4::EtaHoughTransformAlg::m_maxima {this, "EtaHoughMaxContainer", "MuonHoughStationMaxima"}
private

Definition at line 115 of file EtaHoughTransformAlg.h.

◆ m_minMaxDistIntercept

DoubleProperty MuonR4::EtaHoughTransformAlg::m_minMaxDistIntercept {this, "MaximumSeparationIntercept", 15.}
private

Definition at line 96 of file EtaHoughTransformAlg.h.

◆ m_minMaxDistTheta

DoubleProperty MuonR4::EtaHoughTransformAlg::m_minMaxDistTheta {this, "MaximumSeparationTheta", 0.}
private

Definition at line 94 of file EtaHoughTransformAlg.h.

◆ m_minSigmasSearchIntercept

DoubleProperty MuonR4::EtaHoughTransformAlg::m_minSigmasSearchIntercept {this, "minSigmasSearchIntercept", 2.0}
private

Definition at line 90 of file EtaHoughTransformAlg.h.

◆ m_minSigmasSearchTanTheta

DoubleProperty MuonR4::EtaHoughTransformAlg::m_minSigmasSearchTanTheta {this, "minSigmasSearchTanTheta", 2.0}
private

Definition at line 87 of file EtaHoughTransformAlg.h.

◆ m_nBinsIntercept

IntegerProperty MuonR4::EtaHoughTransformAlg::m_nBinsIntercept {this, "nBinsIntercept", 15}
private

Definition at line 105 of file EtaHoughTransformAlg.h.

◆ m_nBinsTanTheta

IntegerProperty MuonR4::EtaHoughTransformAlg::m_nBinsTanTheta {this, "nBinsTanTheta", 7}
private

Definition at line 103 of file EtaHoughTransformAlg.h.

◆ m_nPrecHitCut

UnsignedIntegerProperty MuonR4::EtaHoughTransformAlg::m_nPrecHitCut {this, "nMinPrecHits", 3}
private

Definition at line 100 of file EtaHoughTransformAlg.h.

◆ m_peakFractionCutOff

DoubleProperty MuonR4::EtaHoughTransformAlg::m_peakFractionCutOff {this, "PeakFractionCutOff", 0.6}
private

Definition at line 98 of file EtaHoughTransformAlg.h.

◆ m_peakThreshold

DoubleProperty MuonR4::EtaHoughTransformAlg::m_peakThreshold {this, "peakThreshold", 2.5}
private

Definition at line 92 of file EtaHoughTransformAlg.h.

◆ m_spacePointKey

SG::ReadHandleKey<SpacePointContainer> MuonR4::EtaHoughTransformAlg::m_spacePointKey {this, "SpacePointContainer", "MuonSpacePoints"}
private

Definition at line 113 of file EtaHoughTransformAlg.h.

◆ m_targetResoIntercept

DoubleProperty MuonR4::EtaHoughTransformAlg::m_targetResoIntercept {this, "ResolutionTargetIntercept", 10.}
private

Definition at line 84 of file EtaHoughTransformAlg.h.

◆ m_targetResoTanTheta

DoubleProperty MuonR4::EtaHoughTransformAlg::m_targetResoTanTheta {this, "ResolutionTargetTanTheta", 0.05}
private

Definition at line 82 of file EtaHoughTransformAlg.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.

◆ m_visionTool

ToolHandle<MuonValR4::IPatternVisualizationTool> MuonR4::EtaHoughTransformAlg::m_visionTool {this, "VisualizationTool", ""}
private

Pattern visualization tool.

Definition at line 119 of file EtaHoughTransformAlg.h.


The documentation for this class was generated from the following files:
MuonR4::minLayers
constexpr unsigned int minLayers
Definition: CombinatorialNSWSeedFinderAlg.cxx:63
test_pyathena.eta
eta
Definition: test_pyathena.py:10
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
MuonGMR4::MmReadoutElement
Definition: MmReadoutElement.h:18
ymin
double ymin
Definition: listroot.cxx:63
MuonR4::EtaHoughTransformAlg::m_minMaxDistIntercept
DoubleProperty m_minMaxDistIntercept
Definition: EtaHoughTransformAlg.h:96
MuonR4::SpacePoint::type
xAOD::UncalibMeasType type() const
Definition: MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/src/SpacePoint.cxx:71
MuonR4::EtaHoughTransformAlg::m_downWeightMultiplePrd
BooleanProperty m_downWeightMultiplePrd
Definition: EtaHoughTransformAlg.h:108
vtune_athena.format
format
Definition: vtune_athena.py:14
xAOD::MMCluster_v1
Definition: MMCluster_v1.h:20
ActsTrk::DetectorType
DetectorType
Simple enum to Identify the Type of the ACTS sub detector.
Definition: GeometryDefs.h:17
MuonR4::EtaHoughTransformAlg::m_targetResoIntercept
DoubleProperty m_targetResoIntercept
Definition: EtaHoughTransformAlg.h:84
calibdata.chamber
chamber
Definition: calibdata.py:31
PixelAthClusterMonAlgCfg.zmin
zmin
Definition: PixelAthClusterMonAlgCfg.py:169
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
MuonR4::EtaHoughTransformAlg::m_geoCtxKey
SG::ReadHandleKey< ActsGeometryContext > m_geoCtxKey
Definition: EtaHoughTransformAlg.h:117
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
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
xAOD::UncalibMeasType::MMClusterType
@ MMClusterType
MuonGMR4::MuonReadoutElement
The MuonReadoutElement is an abstract class representing the geometry representing the muon detector.
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MuonReadoutElement.h:38
MuonValR4::drawBox
std::unique_ptr< TBox > drawBox(const Amg::Vector3D &boxCenter, const double boxWidth, const double boxHeight, const int color=kGreen+2, const int fillStyle=hollowFilling, const int view=objViewEta)
Creates a box for drawing, e.g strip measurements.
Definition: VisualizationHelpers.cxx:41
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
MuonR4::EtaHoughTransformAlg::passSeedQuality
bool passSeedQuality(const HoughSetupForBucket &currentBucket, const MuonR4::ActsPeakFinderForMuon::Maximum &maximum) const
apply quality cuts on a given maximum
Definition: EtaHoughTransformAlg.cxx:182
postInclude.sorter
sorter
Definition: postInclude.SortInput.py:23
MuonR4::ActsPeakFinderForMuonCfg
Acts::HoughTransformUtils::PeakFinders::IslandsAroundMaxConfig ActsPeakFinderForMuonCfg
Definition: MuonHoughDefs.h:26
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
ActsTrk::DetectorType::sTgc
@ sTgc
Micromegas (NSW)
xAOD::UncalibMeasType::sTgcStripType
@ sTgcStripType
MuonR4::EtaHoughTransformAlg::HoughSetupForBucket
HoughEventData::HoughSetupForBucket HoughSetupForBucket
Definition: EtaHoughTransformAlg.h:39
x
#define x
python.SystemOfUnits.mL
float mL
Definition: SystemOfUnits.py:95
MuonR4::HoughHitType
HoughMaximum::HitType HoughHitType
Definition: MuonHoughDefs.h:18
MuonValR4::drawLabel
std::unique_ptr< TLatex > drawLabel(const std::string &text, const double xPos, const double yPos, const unsigned int fontSize=18)
Create a TLatex label,.
Definition: VisualizationHelpers.cxx:32
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
Muon::MdtStatusDriftTime
@ MdtStatusDriftTime
The tube produced a vaild measurement.
Definition: MdtDriftCircleStatus.h:34
std::stable_sort
void stable_sort(std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, std::reverse_iterator< DataModel_detail::iterator< DVL > > end, Compare comp)
Specialization of stable_sort for DataVector/List.
Definition: DVL_algorithms.h:711
MuonR4::EtaHoughTransformAlg::m_minSigmasSearchTanTheta
DoubleProperty m_minSigmasSearchTanTheta
Definition: EtaHoughTransformAlg.h:87
MuonR4::EtaHoughTransformAlg::m_visionTool
ToolHandle< MuonValR4::IPatternVisualizationTool > m_visionTool
Pattern visualization tool.
Definition: EtaHoughTransformAlg.h:119
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
SpacePoint
Definition: Trigger/TrigAccel/TrigCudaFitter/src/SpacePoint.h:7
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
MuonR4::HoughEventData
HoughEventData_impl< ActsPeakFinderForMuon, ActsPeakFinderForMuonCfg > HoughEventData
Definition: HoughEventData.h:71
MuonR4::HoughHelpers::Eta::houghWidthStrip
double houghWidthStrip(double tanTheta, const MuonR4::HoughHitType &strip, double targetReso)
Uncertainty parametrisation for strip measurements.
Definition: HoughHelperFunctions.cxx:27
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
MuonR4::SpacePoint::primaryMeasurement
const xAOD::UncalibratedMeasurement * primaryMeasurement() const
Definition: MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/src/SpacePoint.cxx:47
MuonR4::HoughHelpers::Eta::houghWidthMdt
double houghWidthMdt(double tanTheta, const MuonR4::HoughHitType &dc, double targetReso)
uncertainty parametrisation for drift circles
Definition: HoughHelperFunctions.cxx:21
MuonR4::EtaHoughTransformAlg::m_minMaxDistTheta
DoubleProperty m_minMaxDistTheta
Definition: EtaHoughTransformAlg.h:94
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
AthCommonDataStore
Definition: AthCommonDataStore.h:52
Amg::toString
std::string toString(const Translation3D &translation, int precision=4)
GeoPrimitvesToStringConverter.
Definition: GeoPrimitivesToStringConverter.h:40
xAOD::sTgcMeasurement_v1::channelType
virtual sTgcChannelTypes channelType() const =0
Returns the channel type of the measurement (Pad/Wire/Strip)
Generate_dsid_ranseed.seed
seed
Definition: Generate_dsid_ranseed.py:10
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
MuonR4::EtaHoughTransformAlg::m_peakThreshold
DoubleProperty m_peakThreshold
Definition: EtaHoughTransformAlg.h:92
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
ActsTrk::DetectorType::Mm
@ Mm
Maybe not needed in the migration.
xAOD::UncalibratedMeasurement_v1::type
virtual xAOD::UncalibMeasType type() const =0
Returns the type of the measurement type as a simple enumeration.
CreatePhysValWebPage.hs
hs
Definition: CreatePhysValWebPage.py:107
z
#define z
SG::get
const T * get(const ReadCondHandleKey< T > &key, const EventContext &ctx)
Convenience function to retrieve an object given a ReadCondHandleKey.
Definition: ReadCondHandle.h:287
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
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
res
std::pair< std::vector< unsigned int >, bool > res
Definition: JetGroupProductTest.cxx:11
MuonR4::passesThrough
bool passesThrough(const SpacePointBucket::chamberLocation &loc, double y0, double tanTheta)
Definition: EtaHoughTransformAlg.cxx:25
PixelAthClusterMonAlgCfg.zmax
zmax
Definition: PixelAthClusterMonAlgCfg.py:169
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MuonR4::EtaHoughTransformAlg::m_nPrecHitCut
UnsignedIntegerProperty m_nPrecHitCut
Definition: EtaHoughTransformAlg.h:100
IDPVM::binIndex
unsigned int binIndex(const T &val, const std::vector< T > &partitions)
general utility function to return bin index given a value and the upper endpoints of each bin
Definition: InDetPhysValMonitoringUtilities.h:43
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
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
MuonR4::EtaHoughTransformAlg::processBucket
void processBucket(const EventContext &ctx, HoughEventData &data, HoughSetupForBucket &currentBucket) const
process a bucket.
Definition: EtaHoughTransformAlg.cxx:292
MuonR4::HoughHelpers::Eta::houghParamMdtLeft
double houghParamMdtLeft(double tanTheta, const MuonR4::HoughHitType &dc)
left-side straight line parametrisation for drift circles
Definition: HoughHelperFunctions.cxx:9
F600IntegrationConfig.spacePoints
spacePoints
Definition: F600IntegrationConfig.py:122
ActsGeometryContext
Include the GeoPrimitives which need to be put first.
Definition: ActsGeometryContext.h:27
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
MuonR4::EtaHoughTransformAlg::m_nBinsIntercept
IntegerProperty m_nBinsIntercept
Definition: EtaHoughTransformAlg.h:105
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
ActsTrk::DetectorType::Mdt
@ Mdt
MuonSpectrometer.
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
MuonValR4::IPatternVisualizationTool::PrimitiveVec
std::vector< PrimitivePtr > PrimitiveVec
Definition: IPatternVisualizationTool.h:31
MuonGMR4::MdtReadoutElement
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MdtReadoutElement.h:18
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
WriteCaloSwCorrections.cfg
cfg
Definition: WriteCaloSwCorrections.py:23
MuonR4::chamberCoverage
constexpr double chamberCoverage(const std::array< double, 2 > &seedEdges, const std::array< double, 2 > &chambEdges)
Calculates how much of the unkknown coordinate along the tube range is covered by the chamber of inte...
Definition: EtaHoughTransformAlg.cxx:43
MuonR4::EtaHoughTransformAlg::m_peakFractionCutOff
DoubleProperty m_peakFractionCutOff
Definition: EtaHoughTransformAlg.h:98
MuonR4::EtaHoughTransformAlg::m_maxima
SG::WriteHandleKey< EtaHoughMaxContainer > m_maxima
Definition: EtaHoughTransformAlg.h:115
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
MuonGMR4::sTgcReadoutElement
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/sTgcReadoutElement.h:20
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
MuonR4::EtaHoughTransformAlg::preProcess
void preProcess(const EventContext &ctx, const ActsGeometryContext &gctx, const SpacePointContainer &spacePoints, HoughEventData &data) const
pre-processing method called once per event.
Definition: EtaHoughTransformAlg.cxx:109
a
TList * a
Definition: liststreamerinfos.cxx:10
MuonR4::EtaHoughTransformAlg::extendWithPhiHits
void extendWithPhiHits(std::vector< HoughHitType > &hitList, HoughSetupForBucket &bucket) const
extend a maximum with all compatible (pure) phi hits.
Definition: EtaHoughTransformAlg.cxx:470
MuonR4::EtaHoughTransformAlg::m_targetResoTanTheta
DoubleProperty m_targetResoTanTheta
Definition: EtaHoughTransformAlg.h:82
y
#define y
h
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
MuonR4::SpacePoint::measuresEta
bool measuresEta() const
: Does the space point contain an eta measurement
Definition: MuonSpectrometer/MuonPhaseII/Event/MuonSpacePoint/src/SpacePoint.cxx:77
MuonR4::EtaHoughTransformAlg::m_spacePointKey
SG::ReadHandleKey< SpacePointContainer > m_spacePointKey
Definition: EtaHoughTransformAlg.h:113
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
MuonR4::EtaHoughTransformAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Handle to the IdHelperSvc.
Definition: EtaHoughTransformAlg.h:110
MuonR4::EtaHoughTransformAlg::isPrecisionHit
static bool isPrecisionHit(const HoughHitType &hit)
Returns whether the hit is a precision hit or not.
Definition: EtaHoughTransformAlg.cxx:152
re
const boost::regex re(r_e)
MuonR4::EtaHoughTransformAlg::m_nBinsTanTheta
IntegerProperty m_nBinsTanTheta
Definition: EtaHoughTransformAlg.h:103
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
xAOD::MdtDriftCircle_v1::status
MdtDriftCircleStatus status() const
Returns the status of the measurement.
MuonR4::EtaHoughTransformAlg::prepareHoughPlane
void prepareHoughPlane(HoughEventData &data) const
prepare the accumulator and the peak finder once per event
Definition: EtaHoughTransformAlg.cxx:170
MuonR4::HoughHelpers::Eta::houghParamMdtRight
double houghParamMdtRight(double tanTheta, const MuonR4::HoughHitType &dc)
right-side straight line parametrisation for drift circles
Definition: HoughHelperFunctions.cxx:13
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
SpacePointContainer
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePointContainer.h:29
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
MuonR4::HoughHelpers::Eta::houghParamStrip
double houghParamStrip(double tanTheta, const MuonR4::HoughHitType &strip)
straight line parametrisation for strip detector measurements
Definition: HoughHelperFunctions.cxx:17
xAOD::MdtDriftCircle_v1
https://gitlab.cern.ch/atlas/athena/-/blob/master/MuonSpectrometer/MuonReconstruction/MuonRecEvent/Mu...
Definition: MdtDriftCircle_v1.h:21
xAOD::muonReadoutElement
const MuonGMR4::MuonReadoutElement * muonReadoutElement(const UncalibratedMeasurement *meas)
Returns the associated readout element to the measurement.
Definition: MuonSpectrometer/MuonPhaseII/Event/xAOD/xAODMuonPrepData/Root/UtilFunctions.cxx:40
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:198
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
xAOD::UncalibMeasType::RpcStripType
@ RpcStripType
xAOD::UncalibMeasType::MdtDriftCircleType
@ MdtDriftCircleType
fitman.k
k
Definition: fitman.py:528
xAOD::sTgcMeasurement_v1
Definition: sTgcMeasurement_v1.h:21
ymax
double ymax
Definition: listroot.cxx:64
ServiceHandle< ICondSvc >
MuonR4::EtaHoughTransformAlg::fillFromSpacePoint
void fillFromSpacePoint(HoughEventData &data, const MuonR4::HoughHitType &SP) const
fill the accumulator from a given space point.
Definition: EtaHoughTransformAlg.cxx:440
MuonR4::EtaHoughTransformAlg::m_minSigmasSearchIntercept
DoubleProperty m_minSigmasSearchIntercept
Definition: EtaHoughTransformAlg.h:90
Identifier
Definition: IdentifierFieldParser.cxx:14