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

#include <MuonCreatorAlg.h>

Inheritance diagram for MuonCreatorAlg:
Collaboration diagram for MuonCreatorAlg:

Public Member Functions

 MuonCreatorAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
 ~MuonCreatorAlg ()=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 > &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

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

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

ToolHandle< MuonCombined::IMuonCreatorToolm_muonCreatorTool
 
SG::WriteHandleKey< xAOD::MuonContainerm_muonCollectionName {this, "MuonContainerLocation", "Muons", "Muon Container"}
 
SG::WriteHandleKey< xAOD::SlowMuonContainerm_slowMuonCollectionName
 
SG::WriteHandleKey< xAOD::TrackParticleContainerm_combinedCollectionName {this, "CombinedLocation", "CombinedMuon", "Combined muons"}
 
SG::WriteHandleKey< TrackCollectionm_combinedTrkCollectionName {this, "CombinedTrackLocation", "CombinedMuon", "Combined muon tracks"}
 
SG::WriteHandleKey< xAOD::TrackParticleContainerm_extrapolatedCollectionName
 
SG::WriteHandleKey< TrackCollectionm_extrapolatedTrkCollectionName
 
SG::WriteHandleKey< xAOD::TrackParticleContainerm_msOnlyExtrapolatedCollectionName
 
SG::WriteHandleKey< TrackCollectionm_msOnlyExtrapolatedTrkCollectionName
 
SG::ReadHandleKey< InDetCandidateCollectionm_indetCandidateCollectionName
 
SG::ReadHandleKeyArray< MuonCandidateCollectionm_muonCandidateKeys
 
SG::ReadHandleKeyArray< MuonCombined::InDetCandidateToTagMapm_tagMaps
 
SG::ReadHandleKey< MuonCombined::MuonTagToSegMapm_segAssocMapKey {this, "TagToSegmentKey", "MuonTagSegMap"}
 
SG::ReadHandleKey< xAOD::MuonSegmentContainerm_segContainerName {this, "SegmentContainerName", "MuonSegments", "Segments"}
 
SG::WriteHandleKey< xAOD::CaloClusterContainerm_clusterContainerName
 
SG::WriteHandleKey< CaloClusterCellLinkContainerm_clusterContainerLinkName
 
Gaudi::Property< bool > m_buildSlowMuon {this, "BuildSlowMuon", false}
 
Gaudi::Property< bool > m_doSA {this, "CreateSAmuons", false}
 
Gaudi::Property< bool > m_makeClusters {this, "MakeClusters", true}
 
ToolHandle< GenericMonitoringToolm_monTool {this, "MonTool", "", "Monitoring tool"}
 
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

Definition at line 28 of file MuonCreatorAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ MuonCreatorAlg()

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

Definition at line 30 of file MuonCreatorAlg.cxx.

30 : AthReentrantAlgorithm(name, pSvcLocator) {}

◆ ~MuonCreatorAlg()

MuonCreatorAlg::~MuonCreatorAlg ( )
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 }

◆ 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 MuonCreatorAlg::execute ( const EventContext &  ctx) const
overridevirtual

Use the ConstDataVector pipe all MuonCandidate collections into a single vector

Definition at line 72 of file MuonCreatorAlg.cxx.

72  {
73  std::vector<const MuonCombined::InDetCandidateToTagMap*> tagMaps;
74  tagMaps.reserve(m_tagMaps.size());
75  if (!m_doSA) {
76  for (SG::ReadHandle<MuonCombined::InDetCandidateToTagMap>& h : m_tagMaps.makeHandles(ctx)) tagMaps.push_back(h.cptr());
77  }
78 
79  // Create the xAOD container and its auxiliary store:
81  ATH_CHECK(wh_muons.recordNonConst(std::make_unique<xAOD::MuonContainer>(), std::make_unique<xAOD::MuonAuxContainer>()));
82  ATH_MSG_DEBUG("Recorded Muons with key: " << m_muonCollectionName.key());
84 
85  // Create and record track particles:
86  // combined tracks
89  ATH_CHECK(wh_combtp.record(std::make_unique<xAOD::TrackParticleContainer>(), std::make_unique<xAOD::TrackParticleAuxContainer>()));
90  ATH_CHECK(wh_combtrk.record(std::make_unique<TrackCollection>()));
91  output.combinedTrackParticleContainer = wh_combtp.ptr();
92  output.combinedTrackCollection = wh_combtrk.ptr();
93 
94  // extrapolated tracks
97  ATH_CHECK(wh_extrtp.record(std::make_unique<xAOD::TrackParticleContainer>(), std::make_unique<xAOD::TrackParticleAuxContainer>()));
98  ATH_CHECK(wh_extrtrk.record(std::make_unique<TrackCollection>()));
99  output.extrapolatedTrackParticleContainer = wh_extrtp.ptr();
100  output.extrapolatedTrackCollection = wh_extrtrk.ptr();
101 
102  // msonly tracks
105  ATH_CHECK(wh_msextrtp.record(std::make_unique<xAOD::TrackParticleContainer>(), std::make_unique<xAOD::TrackParticleAuxContainer>()));
106  ATH_CHECK(wh_msextrtrk.record(std::make_unique<TrackCollection>()));
107  output.msOnlyExtrapolatedTrackParticleContainer = wh_msextrtp.ptr();
108  output.msOnlyExtrapolatedTrackCollection = wh_msextrtrk.ptr();
109 
110  // segments
111  if (!m_segContainerName.empty()) {
113  output.xaodSegmentContainer = rh_segment.ptr();
114  }
115  if (!m_segAssocMapKey.empty()) {
117  output.tagToSegmentAssocMap = rh_segAssocMap.ptr();
118  }
119 
120  // calo clusters
121  std::unique_ptr<xAOD::CaloClusterContainer> caloclusters{nullptr};
122  std::unique_ptr<xAOD::CaloClusterAuxContainer> caloclustersaux{nullptr};
123 
124  if (m_makeClusters) {
125  caloclusters = std::make_unique<xAOD::CaloClusterContainer>();
126  caloclustersaux = std::make_unique<xAOD::CaloClusterAuxContainer>();
127  caloclusters->setStore(caloclustersaux.get());
128  output.clusterContainer = caloclusters.get();
129  }
130 
134 
135  if (m_buildSlowMuon) {
137  ATH_CHECK(wh_slowmuon.record(std::make_unique<xAOD::SlowMuonContainer>(), std::make_unique<xAOD::SlowMuonAuxContainer>()));
138  output.slowMuonContainer = wh_slowmuon.ptr();
139  } else {
140  for (SG::ReadHandle<MuonCandidateCollection>& muonCandidateRH : m_muonCandidateKeys.makeHandles(ctx)) {
141  if (!muonCandidateRH.isValid()) {
142  ATH_MSG_ERROR("Could not read " << muonCandidateRH.fullKey());
143  return StatusCode::FAILURE;
144  }
145  muon_candidates.insert(muon_candidates.end(), muonCandidateRH->begin(), muonCandidateRH->end());
146  }
147  }
148  m_muonCreatorTool->create(ctx, muon_candidates.asDataVector(), tagMaps, output);
149 
150  if (m_makeClusters) {
153  std::unique_ptr<CaloClusterCellLinkContainer> clusterlinks = std::make_unique<CaloClusterCellLinkContainer>();
154  auto* sg = wh_clusters.storeHandle().get();
155  for (xAOD::CaloCluster* cl : *output.clusterContainer) { cl->setLink(clusterlinks.get(), sg); }
156  ATH_CHECK(wh_clusterslink.record(std::move(clusterlinks)));
157  ATH_CHECK(wh_clusters.record(std::move(caloclusters), std::move(caloclustersaux)));
158  }
159 
160  //---------------------------------------------------------------------------------------------------------------------//
161  //------------ Monitoring of the reconstructed muons inside the trigger algs ------------//
162  //------------ Author: Laurynas Mince ------------//
163  //------------ Created: 26.07.2019 ------------//
164  //---------------------------------------------------------------------------------------------------------------------//
165 
166  // Only run monitoring for online algorithms
167  if (!m_monTool.name().empty()) {
168  // Monitoring histograms and variables
169  auto muon_n = Monitored::Scalar<int>("muon_n", wh_muons->size());
170  auto muon_pt =
171  Monitored::Collection("muon_pt", *(wh_muons.ptr()), [](auto const& mu) { return mu->pt() * MeVtoGeV; }); // converted to GeV
172  auto muon_eta = Monitored::Collection("muon_eta", *(wh_muons.ptr()), &xAOD::Muon_v1::eta);
173  auto muon_phi = Monitored::Collection("muon_phi", *(wh_muons.ptr()), &xAOD::Muon_v1::phi);
174 
175  std::vector<float> MDT_R, MDT_dR;
176  for( const auto mu : *wh_muons ) {
177  if (!(mu->muonType() == xAOD::Muon::CaloTagged || mu->muonType() == xAOD::Muon::SegmentTagged)) {
178  const Trk::Track* trk = mu->primaryTrackParticle()->track();
179  for (const Trk::TrackStateOnSurface* tsos : *trk->trackStateOnSurfaces()) {
180  const Muon::MdtDriftCircleOnTrack* mdt = dynamic_cast <const Muon::MdtDriftCircleOnTrack*>(tsos->measurementOnTrack());
181  if (!mdt) continue;
182  MDT_R.push_back(std::abs(mdt->driftRadius()));
183  MDT_dR.push_back(Amg::error(mdt->localCovariance(), Trk::locX));
184  }
185  }
186  }
187  auto muon_MDT_R = Monitored::Collection("muon_MDT_R", MDT_R);
188  auto muon_MDT_dR = Monitored::Collection("muon_MDT_dR", MDT_dR);
189 
190  auto satrks_n = Monitored::Scalar<int>("satrks_n", wh_extrtp->size());
191  auto satrks_pt = Monitored::Collection("satrks_pt", *(wh_extrtp.ptr()),
192  [](auto const& satrk) { return satrk->pt() * MeVtoGeV; }); // converted to GeV
193  auto satrks_eta = Monitored::Collection("satrks_eta", *(wh_extrtp.ptr()), &xAOD::TrackParticle_v1::eta);
194  auto satrks_phi = Monitored::Collection("satrks_phi", *(wh_extrtp.ptr()), &xAOD::TrackParticle_v1::phi);
195 
196  auto cbtrks_n = Monitored::Scalar<int>("cbtrks_n", wh_combtp->size());
197  auto cbtrks_pt = Monitored::Collection("cbtrks_pt", *(wh_combtp.ptr()),
198  [](auto const& cbtrk) { return cbtrk->pt() * MeVtoGeV; }); // converted to GeV
199  auto cbtrks_eta = Monitored::Collection("cbtrks_eta", *(wh_combtp.ptr()), &xAOD::TrackParticle_v1::eta);
200  auto cbtrks_phi = Monitored::Collection("cbtrks_phi", *(wh_combtp.ptr()), &xAOD::TrackParticle_v1::phi);
201 
202  if (!m_doSA) {
204 
205  auto idtrks_n = Monitored::Scalar<int>("idtrks_n", indetCandidateCollection->size());
206  auto idtrks_pt = Monitored::Collection("idtrks_pt", *indetCandidateCollection,
207  [](auto const& idtrk) { return idtrk->indetTrackParticle().pt() * MeVtoGeV; });
208  auto idtrks_eta = Monitored::Collection("idtrks_eta", *indetCandidateCollection,
209  [](auto const& idtrk) { return idtrk->indetTrackParticle().eta(); });
210  auto idtrks_phi = Monitored::Collection("idtrks_phi", *indetCandidateCollection,
211  [](auto const& idtrk) { return idtrk->indetTrackParticle().phi(); });
212  auto monitorIt = Monitored::Group(m_monTool, muon_n, muon_pt, muon_eta, muon_phi, muon_MDT_R, muon_MDT_dR, satrks_n, satrks_pt, satrks_eta, satrks_phi,
213  cbtrks_n, cbtrks_pt, cbtrks_eta, cbtrks_phi, idtrks_n, idtrks_pt, idtrks_eta, idtrks_phi);
214  } else
215  auto monitorIt = Monitored::Group(m_monTool, muon_n, muon_pt, muon_eta, muon_phi, muon_MDT_R, muon_MDT_dR, satrks_n, satrks_pt, satrks_eta, satrks_phi,
216  cbtrks_n, cbtrks_pt, cbtrks_eta, cbtrks_phi);
217  }
218 
219  return StatusCode::SUCCESS;
220 }

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

◆ initialize()

StatusCode MuonCreatorAlg::initialize ( )
overridevirtual

Definition at line 32 of file MuonCreatorAlg.cxx.

32  {
33  ATH_CHECK(m_muonCreatorTool.retrieve());
34  ATH_CHECK(m_muonCollectionName.initialize());
38  // Can't use a flag in intialize for an array of keys
39  if (!m_doSA) ATH_CHECK(m_tagMaps.initialize());
40  else m_tagMaps.clear();
41  ATH_CHECK(m_segContainerName.initialize(!m_segContainerName.empty()));
58 
59  if (not m_monTool.name().empty()) { ATH_CHECK(m_monTool.retrieve()); }
60  ATH_MSG_INFO("MuonCreatorAlg has been setup successfully");
61  ATH_MSG_INFO(" *** CombinedTrackContainer: " << m_combinedTrkCollectionName);
62  ATH_MSG_INFO(" *** xAOD::CombinedTrackContainer: " << m_combinedCollectionName);
63 
64  ATH_MSG_INFO(" *** xAOD::ExtrpolatedTrackContainer: " << m_extrapolatedCollectionName);
65  ATH_MSG_INFO(" *** ExtrpolatedTrackContainer: " << m_extrapolatedTrkCollectionName);
66  ATH_MSG_INFO(" *** xAOD::MSOnlyTrackContainer: " << m_msOnlyExtrapolatedCollectionName);
67  ATH_MSG_INFO(" *** ExtrpolatedTackContainer: " << m_msOnlyExtrapolatedTrkCollectionName);
68 
69  return StatusCode::SUCCESS;
70 }

◆ 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

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

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

Gaudi::Property<bool> MuonCreatorAlg::m_buildSlowMuon {this, "BuildSlowMuon", false}
private

Definition at line 69 of file MuonCreatorAlg.h.

◆ m_clusterContainerLinkName

SG::WriteHandleKey<CaloClusterCellLinkContainer> MuonCreatorAlg::m_clusterContainerLinkName
private
Initial value:
{this, "CaloClusterCellLinkName", "MuonClusterCollection",
"Cluster links"}

Definition at line 66 of file MuonCreatorAlg.h.

◆ m_clusterContainerName

SG::WriteHandleKey<xAOD::CaloClusterContainer> MuonCreatorAlg::m_clusterContainerName
private
Initial value:
{this, "ClusterContainerName", "MuonClusterCollection",
"Clusters"}

Definition at line 64 of file MuonCreatorAlg.h.

◆ m_combinedCollectionName

SG::WriteHandleKey<xAOD::TrackParticleContainer> MuonCreatorAlg::m_combinedCollectionName {this, "CombinedLocation", "CombinedMuon", "Combined muons"}
private

Definition at line 43 of file MuonCreatorAlg.h.

◆ m_combinedTrkCollectionName

SG::WriteHandleKey<TrackCollection> MuonCreatorAlg::m_combinedTrkCollectionName {this, "CombinedTrackLocation", "CombinedMuon", "Combined muon tracks"}
private

Definition at line 44 of file MuonCreatorAlg.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_doSA

Gaudi::Property<bool> MuonCreatorAlg::m_doSA {this, "CreateSAmuons", false}
private

Definition at line 70 of file MuonCreatorAlg.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 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_extrapolatedCollectionName

SG::WriteHandleKey<xAOD::TrackParticleContainer> MuonCreatorAlg::m_extrapolatedCollectionName
private
Initial value:
{this, "ExtrapolatedLocation", "ExtrapolatedMuon",
"Extrapolated muons"}

Definition at line 45 of file MuonCreatorAlg.h.

◆ m_extrapolatedTrkCollectionName

SG::WriteHandleKey<TrackCollection> MuonCreatorAlg::m_extrapolatedTrkCollectionName
private
Initial value:
{this, "ExtrapolatedTrackLocation", "ExtrapolatedMuon",
"Extrapolated muon tracks"}

Definition at line 47 of file MuonCreatorAlg.h.

◆ m_indetCandidateCollectionName

SG::ReadHandleKey<InDetCandidateCollection> MuonCreatorAlg::m_indetCandidateCollectionName
private
Initial value:
{this, "InDetCandidateLocation", "InDetCandidates",
"ID candidates"}

Definition at line 53 of file MuonCreatorAlg.h.

◆ m_makeClusters

Gaudi::Property<bool> MuonCreatorAlg::m_makeClusters {this, "MakeClusters", true}
private

Definition at line 71 of file MuonCreatorAlg.h.

◆ m_monTool

ToolHandle<GenericMonitoringTool> MuonCreatorAlg::m_monTool {this, "MonTool", "", "Monitoring tool"}
private

Definition at line 74 of file MuonCreatorAlg.h.

◆ m_msOnlyExtrapolatedCollectionName

SG::WriteHandleKey<xAOD::TrackParticleContainer> MuonCreatorAlg::m_msOnlyExtrapolatedCollectionName
private
Initial value:
{this, "MSOnlyExtrapolatedLocation",
"MSOnlyExtrapolatedMuon", "MS Extrapolated muons"}

Definition at line 49 of file MuonCreatorAlg.h.

◆ m_msOnlyExtrapolatedTrkCollectionName

SG::WriteHandleKey<TrackCollection> MuonCreatorAlg::m_msOnlyExtrapolatedTrkCollectionName
private
Initial value:
{
this, "MSOnlyExtrapolatedTrackLocation", "MSOnlyExtrapolatedMuonTracks", "MS extrapolated muon tracks"}

Definition at line 51 of file MuonCreatorAlg.h.

◆ m_muonCandidateKeys

SG::ReadHandleKeyArray<MuonCandidateCollection> MuonCreatorAlg::m_muonCandidateKeys
private
Initial value:
{
this, "MuonCandidateLocation", {"MuonCandidates"}, "Muon candidates"}

Definition at line 56 of file MuonCreatorAlg.h.

◆ m_muonCollectionName

SG::WriteHandleKey<xAOD::MuonContainer> MuonCreatorAlg::m_muonCollectionName {this, "MuonContainerLocation", "Muons", "Muon Container"}
private

Definition at line 40 of file MuonCreatorAlg.h.

◆ m_muonCreatorTool

ToolHandle<MuonCombined::IMuonCreatorTool> MuonCreatorAlg::m_muonCreatorTool
private
Initial value:
{this, "MuonCreatorTool", "MuonCombined::MuonCreatorTool/MuonCreatorTool",
"Muon creator tool"}

Definition at line 38 of file MuonCreatorAlg.h.

◆ m_segAssocMapKey

SG::ReadHandleKey<MuonCombined::MuonTagToSegMap> MuonCreatorAlg::m_segAssocMapKey {this, "TagToSegmentKey", "MuonTagSegMap"}
private

Definition at line 61 of file MuonCreatorAlg.h.

◆ m_segContainerName

SG::ReadHandleKey<xAOD::MuonSegmentContainer> MuonCreatorAlg::m_segContainerName {this, "SegmentContainerName", "MuonSegments", "Segments"}
private

Definition at line 62 of file MuonCreatorAlg.h.

◆ m_slowMuonCollectionName

SG::WriteHandleKey<xAOD::SlowMuonContainer> MuonCreatorAlg::m_slowMuonCollectionName
private
Initial value:
{this, "SlowMuonContainerLocation", "SlowMuons",
"Slow Muon Container"}

Definition at line 41 of file MuonCreatorAlg.h.

◆ m_tagMaps

Initial value:
{
this, "TagMaps", {"muidcoTagMap", "stacoTagMap", "muGirlTagMap", "caloTagMap", "segmentTagMap"}, "ID candidate to tag maps"}

Definition at line 58 of file MuonCreatorAlg.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:
MuonCreatorAlg::m_slowMuonCollectionName
SG::WriteHandleKey< xAOD::SlowMuonContainer > m_slowMuonCollectionName
Definition: MuonCreatorAlg.h:41
MuonCreatorAlg::m_msOnlyExtrapolatedTrkCollectionName
SG::WriteHandleKey< TrackCollection > m_msOnlyExtrapolatedTrkCollectionName
Definition: MuonCreatorAlg.h:51
MuonCreatorAlg::m_segContainerName
SG::ReadHandleKey< xAOD::MuonSegmentContainer > m_segContainerName
Definition: MuonCreatorAlg.h:62
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
MuonCreatorAlg::m_muonCollectionName
SG::WriteHandleKey< xAOD::MuonContainer > m_muonCollectionName
Definition: MuonCreatorAlg.h:40
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Trk::locX
@ locX
Definition: ParamDefs.h:37
MuonCreatorAlg::m_clusterContainerLinkName
SG::WriteHandleKey< CaloClusterCellLinkContainer > m_clusterContainerLinkName
Definition: MuonCreatorAlg.h:66
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition: OwnershipPolicy.h:18
MuonCreatorAlg::m_combinedTrkCollectionName
SG::WriteHandleKey< TrackCollection > m_combinedTrkCollectionName
Definition: MuonCreatorAlg.h:44
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Trk::Track::trackStateOnSurfaces
const Trk::TrackStates * trackStateOnSurfaces() const
return a pointer to a const DataVector of const TrackStateOnSurfaces.
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
xAOD::Muon_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
MuonCreatorAlg::m_makeClusters
Gaudi::Property< bool > m_makeClusters
Definition: MuonCreatorAlg.h:71
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::Muon_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
MuonCreatorAlg::m_segAssocMapKey
SG::ReadHandleKey< MuonCombined::MuonTagToSegMap > m_segAssocMapKey
Definition: MuonCreatorAlg.h:61
MuonCreatorAlg::m_muonCreatorTool
ToolHandle< MuonCombined::IMuonCreatorTool > m_muonCreatorTool
Definition: MuonCreatorAlg.h:38
test_pyathena.pt
pt
Definition: test_pyathena.py:11
CP::MeVtoGeV
constexpr float MeVtoGeV
Definition: IsolationCloseByCorrectionTool.cxx:33
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
MuonCreatorAlg::m_doSA
Gaudi::Property< bool > m_doSA
Definition: MuonCreatorAlg.h:70
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
MuonCreatorAlg::m_tagMaps
SG::ReadHandleKeyArray< MuonCombined::InDetCandidateToTagMap > m_tagMaps
Definition: MuonCreatorAlg.h:58
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
MuonCreatorAlg::m_extrapolatedCollectionName
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_extrapolatedCollectionName
Definition: MuonCreatorAlg.h:45
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
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
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
MuonCreatorAlg::m_extrapolatedTrkCollectionName
SG::WriteHandleKey< TrackCollection > m_extrapolatedTrkCollectionName
Definition: MuonCreatorAlg.h:47
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SG::WriteHandle::ptr
pointer_type ptr()
Dereference the pointer.
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
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
Muon::MdtDriftCircleOnTrack::driftRadius
double driftRadius() const
Returns the value of the drift radius.
Definition: MdtDriftCircleOnTrack.h:277
MuonCreatorAlg::m_clusterContainerName
SG::WriteHandleKey< xAOD::CaloClusterContainer > m_clusterContainerName
Definition: MuonCreatorAlg.h:64
MuonCreatorAlg::m_msOnlyExtrapolatedCollectionName
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_msOnlyExtrapolatedCollectionName
Definition: MuonCreatorAlg.h:49
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
Trk::MeasurementBase::localCovariance
const Amg::MatrixX & localCovariance() const
Interface method to get the localError.
Definition: MeasurementBase.h:138
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
merge.output
output
Definition: merge.py:17
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
Trk::TrackStateOnSurface
represents the track state (measurement, material, fit parameters and quality) at a surface.
Definition: TrackStateOnSurface.h:71
MuonCreatorAlg::m_indetCandidateCollectionName
SG::ReadHandleKey< InDetCandidateCollection > m_indetCandidateCollectionName
Definition: MuonCreatorAlg.h:53
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
MuonCreatorAlg::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: MuonCreatorAlg.h:74
Amg::error
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
Definition: EventPrimitivesHelpers.h:40
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
Muon::MdtDriftCircleOnTrack
This class represents the corrected MDT measurements, where the corrections include the effects of wi...
Definition: MdtDriftCircleOnTrack.h:37
MuonCreatorAlg::m_combinedCollectionName
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_combinedCollectionName
Definition: MuonCreatorAlg.h:43
MuonCreatorAlg::m_muonCandidateKeys
SG::ReadHandleKeyArray< MuonCandidateCollection > m_muonCandidateKeys
Definition: MuonCreatorAlg.h:56
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
a
TList * a
Definition: liststreamerinfos.cxx:10
h
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ConstDataVector
DataVector adapter that acts like it holds const pointers.
Definition: ConstDataVector.h:76
MuonCombined::IMuonCreatorTool::OutputData
Definition: IMuonCreatorTool.h:37
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
MuonCreatorAlg::m_buildSlowMuon
Gaudi::Property< bool > m_buildSlowMuon
Definition: MuonCreatorAlg.h:69
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:26
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >