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

#include <TrackToTrackParticleCnvAlg.h>

Inheritance diagram for ActsTrk::TrackToTrackParticleCnvAlg:
Collaboration diagram for ActsTrk::TrackToTrackParticleCnvAlg:

Public Member Functions

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

enum  expressionStrategy { expressionStrategy::DontRecalculate, expressionStrategy::BeamLine, expressionStrategy::Vertex }
 
using Stepper = Acts::EigenStepper<>
 
using Navigator = Acts::Navigator
 
using Propagator = Acts::Propagator< Stepper, Navigator >
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

Acts::BoundTrackParameters parametersAtPerigee (const EventContext &ctx, const typename ActsTrk::TrackContainer::ConstTrackProxy &track, const Acts::PerigeeSurface &perigee_surface) const
 
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 std::shared_ptr< Acts::PerigeeSurface > makePerigeeSurface (const InDet::BeamSpotData *beamspotptr)
 
static std::shared_ptr< Acts::PerigeeSurface > makePerigeeSurface (const xAOD::Vertex &)
 
static xAOD::ParticleHypothesis convertParticleHypothesis (Acts::PdgParticle abs_pdg_id)
 
static void initParticleHypothesisMap ()
 

Private Attributes

ToolHandle< IActsExtrapolationTool > m_extrapolationTool {this, "ExtrapolationTool", ""}
 
PublicToolHandle< ActsTrk::ITrackingGeometryTool > m_trackingGeometryTool {this, "TrackingGeometryTool", "ActsTrackingGeometryTool"}
 
SG::ReadHandleKeyArray< ActsTrk::TrackContainer > m_tracksContainerKey {this, "ACTSTracksLocation", {},"Track collection (ActsTrk variant)"}
 
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot or empty." }
 
SG::ReadCondHandleKey< AtlasFieldCacheCondObj > m_fieldCacheCondObjInputKey {this,"AtlasFieldCacheCondObj","fieldCondObj", "Name of the Magnetic Field conditions object key" }
 
SG::ReadCondHandleKeyArray< InDetDD::SiDetectorElementCollection > m_siDetEleCollKey {this, "SiDetectorElementCollections", {}, "Pixel and strip element collections to get geometry information about measurements."}
 
Gaudi::Property< std::vector< unsigned int > > m_siDetEleCollToMeasurementType {this, "SiDetEleCollToMeasurementType",{}, "One value per si detector collection: Pixel = 1, Strip = 2"}
 
SG::ReadHandleKey< xAOD::VertexContainer > m_vertexHandle {this, "VertexContainerKey", "", "Name of the Primary Vertex Container"}
 
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_trackParticlesOutKey {this, "TrackParticlesOutKey","", "Name of the produced track particle collection" }
 
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer > m_decorator_actsTracks {this, "ActsTrackLink", "actsTrack"}
 
Gaudi::Property< double > m_paramExtrapolationParLimit {this, "ExtrapolationPathLimit",std::numeric_limits<double>::max(), "PathLimit for extrapolating track parameters." }
 
Gaudi::Property< bool > m_firstAndLastParamOnly {this, "FirstAndLastParameterOnly",true, "Only convert the first and the last parameter." }
 
Gaudi::Property< bool > m_computeExpectedLayerPattern {this, "ComputeExpectedLayerPattern",true, "Compute the expected layer pattern. CPU expensive" }
 
Gaudi::Property< bool > m_expectIfPixelContributes {this, "expectIfPixelContribution",true, "Only expect pixel hits if there are pixel hits on track." }
 
Gaudi::Property< double > m_pixelExpectLayerPathLimitInMM
 
Gaudi::Property< std::string > m_perigeeExpression {this, "PerigeeExpression", "DontRecalculate"}
 
expressionStrategy m_expression_strategy {expressionStrategy::BeamLine}
 
std::unique_ptr< Propagator > m_propagator
 
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
 

Static Private Attributes

static std::vector< std::pair< Acts::PdgParticle, xAOD::ParticleHypothesis > > s_actsHypothesisToxAOD ATLAS_THREAD_SAFE
 

Detailed Description

Definition at line 50 of file TrackToTrackParticleCnvAlg.h.

Member Typedef Documentation

◆ Navigator

using ActsTrk::TrackToTrackParticleCnvAlg::Navigator = Acts::Navigator
private

Definition at line 63 of file TrackToTrackParticleCnvAlg.h.

◆ Propagator

using ActsTrk::TrackToTrackParticleCnvAlg::Propagator = Acts::Propagator<Stepper, Navigator>
private

Definition at line 64 of file TrackToTrackParticleCnvAlg.h.

◆ Stepper

using ActsTrk::TrackToTrackParticleCnvAlg::Stepper = Acts::EigenStepper<>
private

Definition at line 62 of file TrackToTrackParticleCnvAlg.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ expressionStrategy

enum ActsTrk::TrackToTrackParticleCnvAlg::expressionStrategy
strongprivate
Enumerator
DontRecalculate 
BeamLine 
Vertex 

Definition at line 113 of file TrackToTrackParticleCnvAlg.h.

113 {DontRecalculate, BeamLine, Vertex};

Constructor & Destructor Documentation

◆ TrackToTrackParticleCnvAlg()

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

Definition at line 124 of file TrackToTrackParticleCnvAlg.cxx.

126  : AthReentrantAlgorithm(name, pSvcLocator)
127  {
128  }

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 }

◆ convertParticleHypothesis()

xAOD::ParticleHypothesis ActsTrk::TrackToTrackParticleCnvAlg::convertParticleHypothesis ( Acts::PdgParticle  abs_pdg_id)
inlinestaticprivate

Definition at line 125 of file TrackToTrackParticleCnvAlg.h.

125  {
126  std::vector<std::pair<Acts::PdgParticle, xAOD::ParticleHypothesis> >::const_iterator
127  iter = std::find_if(s_actsHypothesisToxAOD.begin(),
128  s_actsHypothesisToxAOD.end(),
129  [abs_pdg_id](const std::pair<Acts::PdgParticle, xAOD::ParticleHypothesis> &elm) {
130  return abs_pdg_id == elm.first;
131  });
132  return (iter != s_actsHypothesisToxAOD.end() ? iter->second : xAOD::noHypothesis);
133 }

◆ 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;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, 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 ActsTrk::TrackToTrackParticleCnvAlg::execute ( const EventContext &  ctx) const
overridevirtual

Definition at line 201 of file TrackToTrackParticleCnvAlg.cxx.

202  {
203  SG::WriteHandle<xAOD::TrackParticleContainer> wh_track_particles( m_trackParticlesOutKey, ctx);
204  if (wh_track_particles.record(std::make_unique<xAOD::TrackParticleContainer>(),
205  std::make_unique<xAOD::TrackParticleAuxContainer>()).isFailure()) {
206  ATH_MSG_ERROR("Failed to record track particle container with key " << m_trackParticlesOutKey.key() );
207  return StatusCode::FAILURE;
208  }
209 
210  SG::WriteDecorHandle<xAOD::TrackParticleContainer, ElementLink<ActsTrk::TrackContainer>> trackLink(m_decorator_actsTracks, ctx);
211 
212  xAOD::TrackParticleContainer *track_particles = wh_track_particles.ptr();
213 
214  const InDet::BeamSpotData *beamspot_data {nullptr};
215  const xAOD::VertexContainer *vertexContainer {nullptr};
216  const xAOD::Vertex* primaryVertex {nullptr};
217 
218  if (m_expression_strategy == expressionStrategy::BeamLine) {
219  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle = SG::makeHandle( m_beamSpotKey, ctx );
220  ATH_CHECK(beamSpotHandle.isValid());
221  beamspot_data = beamSpotHandle.cptr();
222  }
223 
224  if (m_expression_strategy == expressionStrategy::Vertex) {
225  SG::ReadHandle<xAOD::VertexContainer> vertexHandle = SG::makeHandle( m_vertexHandle, ctx );
226  ATH_CHECK( vertexHandle.isValid() );
227  vertexContainer = vertexHandle.cptr();
228  if (vertexContainer->size() == 0) {
229  ATH_MSG_ERROR("Retrieved an empty vertex container. This is totally wrong!");
230  return StatusCode::FAILURE;
231  }
232 
233  for(const xAOD::Vertex* vtx : *vertexContainer) {
234  if(vtx->vertexType() == xAOD::VxType::PriVtx) {
235  primaryVertex = vtx;
236  break;
237  }
238  }
239 
240  if (not primaryVertex) {
241  ATH_MSG_WARNING("Requested to compute track particles wrt primary vertex, but no primary vertex is found. Using dummy vertex");
242  primaryVertex = vertexContainer->front();
243  }
244  }
245 
246  std::size_t nTracks = 0ul;
247  std::vector<const ActsTrk::TrackContainer *> trackContainers;
248  for (const SG::ReadHandleKey<ActsTrk::TrackContainer>& handleKey : m_tracksContainerKey) {
249  SG::ReadHandle<ActsTrk::TrackContainer> handle = SG::makeHandle( handleKey, ctx );
250  ATH_CHECK(handle.isValid());
251  trackContainers.push_back( handle.cptr() );
252  nTracks += trackContainers.back()->size();
253  }
254 
255  // Fast Insertion Trick
256  std::vector<xAOD::TrackParticle*> toAddParticles;
257  toAddParticles.reserve(nTracks);
258  for (std::size_t i(0); i<nTracks; ++i) {
259  toAddParticles.push_back( new xAOD::TrackParticle() );
260  }
261  track_particles->insert(track_particles->end(),
262  toAddParticles.begin(),
263  toAddParticles.end());
264 
265  SG::ReadCondHandle<AtlasFieldCacheCondObj> fieldHandle = SG::makeHandle( m_fieldCacheCondObjInputKey, ctx );
266  ATH_CHECK(fieldHandle.isValid());
267  const AtlasFieldCacheCondObj *field_cond_data = fieldHandle.cptr();
268  MagField::AtlasFieldCache fieldCache;
269  field_cond_data->getInitializedCache(fieldCache);
270 
271  const ActsGeometryContext &gctx = m_trackingGeometryTool->getNominalGeometryContext();
272  std::shared_ptr<Acts::PerigeeSurface> perigee_surface {nullptr};
273  if (m_expression_strategy == expressionStrategy::BeamLine) {
274  perigee_surface = makePerigeeSurface(beamspot_data);
275  } else if (m_expression_strategy == expressionStrategy::Vertex) {
276  perigee_surface = makePerigeeSurface(*primaryVertex);
277  }
278 
279  std::array<const InDetDD::SiDetectorElementCollection *,ActsTrk::detail::to_underlying(xAOD::UncalibMeasType::nTypes)> siDetEleColl {};
280  for (unsigned int idx=0; idx <m_siDetEleCollToMeasurementType.size(); ++idx ) {
281  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> detHandle = SG::makeHandle( m_siDetEleCollKey[idx], ctx );
282  ATH_CHECK(detHandle.isValid());
283  siDetEleColl[m_siDetEleCollToMeasurementType[idx] ] = detHandle.cptr();
284  }
285 
286  static const std::array<unsigned short, ActsTrk::detail::to_underlying(xAOD::UncalibMeasType::nTypes)>
287  measurementToSummaryType ATLAS_THREAD_SAFE (makeMeasurementToSummaryTypeMap());
288 
289 
290 
291  // re-used temporaries
292  std::vector<float> tmp_cov_vector;
293  std::vector<ActsTrk::TrackStateBackend::ConstTrackStateProxy::IndexType > tmp_param_state_idx;
294  tmp_param_state_idx.reserve(30);
295  Amg::Vector3D magnFieldVect;
296  std::vector<std::vector<float>> parametersVec;
297  ActsTrk::detail::HitSummaryData hitInfo;
298 
299  unsigned int converted_track_states=0;
300 
301  std::size_t particleCounter = 0ul;
302  using namespace Acts::UnitLiterals;
303  for (const ActsTrk::TrackContainer *tracksContainer : trackContainers) {
304 
305  bool precalculatedLayerPattern = detail::ExpectedLayerPatternHelper::exists(*tracksContainer);
306 
307  for (const typename ActsTrk::TrackContainer::ConstTrackProxy track : *tracksContainer) {
308  xAOD::TrackParticle *track_particle = track_particles->at(particleCounter++);
309 
310  // convert defining parameters
311  // @TODO add support for other modes available in the legacy converter : wrt a vertex, origin, beamspot ?
312  Acts::BoundTrackParameters perigeeParam = [&] {
313  if (m_expression_strategy == expressionStrategy::DontRecalculate) {
314  // If the strategy is "DontRecalculate", we will take the reference surface as is
315  // from the track finding without modification. Consult track finding configuration to
316  // find out what that is.
317  return track.createParametersAtReference();
318  }
319  else {
320  return parametersAtPerigee(ctx, track, *perigee_surface);
321  }
322  }();
323 
324  Acts::BoundVector boundParams = perigeeParam.parameters();
325  track_particle->setDefiningParameters(boundParams[Acts::eBoundLoc0],
326  boundParams[Acts::eBoundLoc1],
327  boundParams[Acts::eBoundPhi],
328  boundParams[Acts::eBoundTheta],
329  boundParams[Acts::eBoundQOverP] * 1_MeV);
330 
331  if (perigeeParam.covariance().has_value()) {
332  // only use the 5x5 sub-matrix of the full covariance matrix
333  lowerTriangleToVectorScaleLastRow(perigeeParam.covariance().value(),tmp_cov_vector,5, 1_MeV);
334  track_particle->setDefiningParametersCovMatrixVec(tmp_cov_vector);
335  }
336  // optional beam tilt
337  if (beamspot_data) {
338  track_particle->setBeamlineTiltX(beamspot_data->beamTilt(0));
339  track_particle->setBeamlineTiltY(beamspot_data->beamTilt(1));
340  }
341 
342  // fit info, quality
343  track_particle->setFitQuality(track.chi2(), track.nDoF());
344  track_particle->setPatternRecognitionInfo( (1ul << xAOD::SiSPSeededFinder) );
345  track_particle->setTrackFitter(xAOD::KalmanFitter);
346 
347  const Acts::ParticleHypothesis &hypothesis = track.particleHypothesis();
348  track_particle->setParticleHypothesis(convertParticleHypothesis( hypothesis.absolutePdg() ));
349  constexpr float inv_1_MeV = 1/1_MeV;
350  // gather track state indices for parameter conversion
351  // @TODO add support for muons
352 
353  // xAOD::UncalibMeasType::underlying_type is expected to be the number of UncalibMeasTypes
354  std::array<std::array<uint8_t, ActsTrk::detail::to_underlying(ActsTrk::detail::HitCategory::N)>,
355  ActsTrk::detail::to_underlying(xAOD::UncalibMeasType::nTypes)> specialHitCounts{};
356 
357  ActsTrk::detail::SumOfValues chi2_stat;
358  gatherTrackSummaryData(*tracksContainer,
359  track,
360  siDetEleColl,
361  measurementToSummaryType,
362  chi2_stat,
363  hitInfo,
364  tmp_param_state_idx,
365  specialHitCounts);
366 
367  // Muon
368  // MdtDriftCircleType = 3
369  // RpcStripType = 4,
370  // TgcStripType = 5,
371  // MMClusterType = 6,
372  // sTgcStripType = 7,
373 
374  // pixel summaries
375  std::array< std::tuple< uint8_t, uint8_t, uint8_t, bool >, 4> copy_summary {
376  std::make_tuple(static_cast<uint8_t>(ActsTrk::detail::HitSummaryData::pixelTotal),
377  static_cast<uint8_t>(xAOD::numberOfContribPixelLayers),
378  static_cast<uint8_t>(xAOD::numberOfPixelHits),
379  false),
380 
381  std::make_tuple(static_cast<uint8_t>(ActsTrk::detail::HitSummaryData::pixelBarrelFlat),
382  static_cast<uint8_t>(xAOD::numberOfContribPixelBarrelFlatLayers),
383  static_cast<uint8_t>(xAOD::numberOfPixelBarrelFlatHits),
384  true),
385 
386  std::make_tuple(static_cast<uint8_t>(ActsTrk::detail::HitSummaryData::pixelBarrelInclined),
387  static_cast<uint8_t>(xAOD::numberOfContribPixelBarrelInclinedLayers),
388  static_cast<uint8_t>(xAOD::numberOfPixelBarrelInclinedHits),
389  true),
390 
391  std::make_tuple(static_cast<uint8_t>(ActsTrk::detail::HitSummaryData::pixelEndcap),
392  static_cast<uint8_t>(xAOD::numberOfContribPixelEndcap),
393  static_cast<uint8_t>(xAOD::numberOfPixelEndcapHits),\
394  true) };
395 
396  for (auto [src_region, dest_xaod_summary_layer, dest_xaod_summary_hits, add_outlier] : copy_summary ) {
397  setSummaryValue(*track_particle,
398  hitInfo.contributingLayers( static_cast<ActsTrk::detail::HitSummaryData::DetectorRegion>(src_region)),
399  static_cast<xAOD::SummaryType>(dest_xaod_summary_layer));
400  setSummaryValue(*track_particle,
401  hitInfo.contributingHits(static_cast<ActsTrk::detail::HitSummaryData::DetectorRegion>(src_region))
402  + ( add_outlier
403  ? hitInfo.contributingOutlierHits(static_cast<ActsTrk::detail::HitSummaryData::DetectorRegion>(src_region))
404  : 0),
405  static_cast<xAOD::SummaryType>(dest_xaod_summary_hits));
406  }
407  setSummaryValue(*track_particle,
408  hitInfo.sum<ActsTrk::detail::HitSummaryData::Hit>(ActsTrk::detail::HitSummaryData::pixelEndcap,0)
409  +hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelEndcap,0),
410  xAOD::numberOfInnermostPixelLayerEndcapHits);
411  setSummaryValue(*track_particle,
412  hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelEndcap,0),
413  xAOD::numberOfInnermostPixelLayerEndcapOutliers);
414  setSummaryValue(*track_particle,
415  hitInfo.sum<ActsTrk::detail::HitSummaryData::Hit>(ActsTrk::detail::HitSummaryData::pixelEndcap,1)
416  +hitInfo.sum<ActsTrk::detail::HitSummaryData::Hit>(ActsTrk::detail::HitSummaryData::pixelEndcap,2)
417  +hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelEndcap,1)
418  +hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelEndcap,2),
419  xAOD::numberOfNextToInnermostPixelLayerEndcapHits);
420  setSummaryValue(*track_particle,
421  hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelEndcap,1)
422  +hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelEndcap,2),
423  xAOD::numberOfNextToInnermostPixelLayerEndcapOutliers);
424  setSummaryValue(*track_particle,
425  hitInfo.contributingOutlierHits(ActsTrk::detail::HitSummaryData::pixelTotal),
426  xAOD::numberOfPixelOutliers);
427  setSummaryValue(*track_particle,
428  specialHitCounts[ActsTrk::detail::to_underlying(xAOD::UncalibMeasType::PixelClusterType)][ActsTrk::detail::HitCategory::Hole],
429  xAOD::numberOfPixelHoles);
430  setSummaryValue(*track_particle,
431  hitInfo.sum<ActsTrk::detail::HitSummaryData::SharedHit>(ActsTrk::detail::HitSummaryData::pixelEndcap, 0),
432  xAOD::numberOfInnermostPixelLayerSharedEndcapHits);
433  setSummaryValue(*track_particle,
434  hitInfo.sum<ActsTrk::detail::HitSummaryData::SharedHit>(ActsTrk::detail::HitSummaryData::pixelEndcap, 1)
435  +hitInfo.sum<ActsTrk::detail::HitSummaryData::SharedHit>(ActsTrk::detail::HitSummaryData::pixelEndcap, 2),
436  xAOD::numberOfNextToInnermostPixelLayerSharedEndcapHits);
437  setSummaryValue(*track_particle,
438  hitInfo.contributingSharedHits(ActsTrk::detail::HitSummaryData::pixelTotal),
439  xAOD::numberOfPixelSharedHits);
440 
441 
442  std::array<unsigned int,4> expect_layer_pattern{};
443  if (precalculatedLayerPattern) {
444  // We have a pre-calculated layer pattern from track finding, use as is
445  expect_layer_pattern = detail::ExpectedLayerPatternHelper::get(track);
446  }
447  else {
448  // Only check if computeExpectedLayerPattern is true. TODO:: move this computation to the track finding to avoid calling propagator steps here.
449  // Do not expect pixel hits if there are not contributing pixel hits in the flat barrel and expectIfPixelContributes is true
450  expect_layer_pattern = (m_computeExpectedLayerPattern.value()
451  && (!m_expectIfPixelContributes.value()
452  || hitInfo.contributingLayers(ActsTrk::detail::HitSummaryData::pixelTotal))
453  ? detail::expectedLayerPattern(ctx,
454  *m_extrapolationTool,
455  perigeeParam,
456  m_pixelExpectLayerPathLimitInMM.value() * Acts::UnitConstants::mm)
457  : std::array<unsigned int,4> {0u,0u, 0u,0u} );
458  }
459 
460  // @TODO consider end-caps for inner most pixel hits ?
461  setSummaryValue(*track_particle,
462  static_cast<uint8_t>((expect_layer_pattern[0] & (1<<0)) != 0 ),
463  xAOD::expectInnermostPixelLayerHit);
464  setSummaryValue(*track_particle,
465  static_cast<uint8_t>((expect_layer_pattern[0] & (1<<1)) != 0 ),
466  xAOD::expectNextToInnermostPixelLayerHit);
467  setSummaryValue(*track_particle,
468  static_cast<unsigned int >(hitInfo.sum<ActsTrk::detail::HitSummaryData::Hit>(ActsTrk::detail::HitSummaryData::pixelBarrelFlat,0)),
469  xAOD::numberOfInnermostPixelLayerHits);
470  setSummaryValue(*track_particle,
471  static_cast<unsigned int >(hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelBarrelFlat,0)),
472  xAOD::numberOfInnermostPixelLayerOutliers);
473  setSummaryValue(*track_particle,
474  static_cast<unsigned int >(hitInfo.sum<ActsTrk::detail::HitSummaryData::Hit>(ActsTrk::detail::HitSummaryData::pixelBarrelFlat,1)),
475  xAOD::numberOfNextToInnermostPixelLayerHits);
476  setSummaryValue(*track_particle,
477  static_cast<unsigned int >(hitInfo.sum<ActsTrk::detail::HitSummaryData::Outlier>(ActsTrk::detail::HitSummaryData::pixelBarrelFlat,1)),
478  xAOD::numberOfNextToInnermostPixelLayerOutliers);
479  setSummaryValue(*track_particle,
480  static_cast<unsigned int >(hitInfo.sum<ActsTrk::detail::HitSummaryData::SharedHit>(ActsTrk::detail::HitSummaryData::pixelBarrelFlat,0)),
481  xAOD::numberOfInnermostPixelLayerSharedHits);
482  setSummaryValue(*track_particle,
483  static_cast<unsigned int >(hitInfo.sum<ActsTrk::detail::HitSummaryData::SharedHit>(ActsTrk::detail::HitSummaryData::pixelBarrelFlat,1)),
484  xAOD::numberOfNextToInnermostPixelLayerSharedHits);
485 
486  // Strip summaries
487  setSummaryValue(*track_particle,
488  hitInfo.contributingHits( ActsTrk::detail::HitSummaryData::stripTotal ),
489  xAOD::numberOfSCTHits);
490  setSummaryValue(*track_particle,
491  hitInfo.contributingOutlierHits( ActsTrk::detail::HitSummaryData::stripTotal ),
492  xAOD::numberOfSCTOutliers);
493  setSummaryValue(*track_particle,
494  hitInfo.contributingSharedHits( ActsTrk::detail::HitSummaryData::stripTotal ),
495  xAOD::numberOfSCTSharedHits);
496  setSummaryValue(*track_particle,
497  specialHitCounts[ActsTrk::detail::to_underlying(xAOD::UncalibMeasType::StripClusterType)][ActsTrk::detail::HitCategory::Hole],
498  xAOD::numberOfSCTHoles);
499 
500  double biased_chi2_variance = chi2_stat.biasedVariance();
501  setSummaryValue(*track_particle,
502  static_cast<uint8_t> (biased_chi2_variance>0.
503  ? std::min(static_cast<unsigned int>(std::sqrt(biased_chi2_variance) * 100),255u)
504  : 0u),
505  xAOD::standardDeviationOfChi2OS);
506 
507  setSummaryValue(*track_particle,
508  hitInfo.contributingOutlierHits( ActsTrk::detail::HitSummaryData::pixelTotal )
509  +hitInfo.contributingOutlierHits( ActsTrk::detail::HitSummaryData::stripTotal ),
510  xAOD::numberOfOutliersOnTrack);
511 
512 
513  // @TODO slect states for which parameters are stored
514  if (m_firstAndLastParamOnly && tmp_param_state_idx.size()>2) {
515  tmp_param_state_idx[1]=tmp_param_state_idx.back();
516  tmp_param_state_idx.erase(tmp_param_state_idx.begin()+2,tmp_param_state_idx.end());
517  }
518 
519  // store track parameters and covariances for slected states
520  parametersVec.clear();
521  parametersVec.reserve(tmp_param_state_idx.size());
522 
523  for(std::vector<ActsTrk::TrackStateBackend::ConstTrackStateProxy::IndexType>::const_reverse_iterator
524  idx_iter = tmp_param_state_idx.rbegin();
525  idx_iter != tmp_param_state_idx.rend();
526  ++idx_iter) {
527  // for(ActsTrk::TrackStateBackend::ConstTrackStateProxy::IndexType idx : tmp_param_state_idx) {
528  ActsTrk::TrackStateBackend::ConstTrackStateProxy
529  state = tracksContainer->trackStateContainer().getTrackState(*idx_iter);
530  const Acts::BoundTrackParameters actsParam = track.createParametersFromState(state);
531 
532  Acts::Vector3 position = actsParam.position(gctx.context());
533  Acts::Vector3 momentum = actsParam.momentum();
534 
535  // scaling from Acts momentume units (GeV) to Athena Units (MeV)
536  for (unsigned int i=0; i<momentum.rows(); ++i) {
537  momentum(i) *= inv_1_MeV;
538  }
539 
540 
541  if (actsParam.covariance()) {
542  Acts::MagneticFieldContext mfContext = m_extrapolationTool->getMagneticFieldContext(ctx);
543  Acts::GeometryContext tgContext = gctx.context();
544 
545  magnFieldVect.setZero();
546  fieldCache.getField(position.data(), magnFieldVect.data());
547  // scaling from Athena magnetic field units kT to Acts units T
548  {
549  using namespace Acts::UnitLiterals;
550  magnFieldVect *= 1000_T;
551  }
552 
553  auto curvilinear_cov_result = ActsTrk::detail::convertActsBoundCovToCurvilinearParam(tgContext, actsParam, magnFieldVect, hypothesis);
554  if (curvilinear_cov_result.has_value()) {
555  Acts::BoundSquareMatrix &curvilinear_cov = curvilinear_cov_result.value();
556 
557  // convert q/p components from GeV (Acts) to MeV (Athena)
558  for (unsigned int col_i=0; col_i<4; ++col_i) {
559  curvilinear_cov(col_i,4) *= 1_MeV;
560  curvilinear_cov(4,col_i) *= 1_MeV;
561  }
562  curvilinear_cov(4,4) *= (1_MeV * 1_MeV);
563 
564  std::size_t param_idx = parametersVec.size();
565  // only use the 5x5 sub-matrix of the full covariance matrix
566  lowerTriangleToVector(curvilinear_cov,tmp_cov_vector,5);
567  if (tmp_cov_vector.size() != 15) {
568  ATH_MSG_ERROR("Invalid size of lower triangle cov " << tmp_cov_vector.size() << " != 15"
569  << " input matrix : " << curvilinear_cov.rows() << " x " << curvilinear_cov.cols() );
570  }
571  track_particle->setTrackParameterCovarianceMatrix(param_idx, tmp_cov_vector);
572  }
573  }
574  parametersVec.emplace_back(std::vector<float>{
575  static_cast<float>(position[0]),static_cast<float>(position[1]),static_cast<float>(position[2]),
576  static_cast<float>(momentum[0]),static_cast<float>(momentum[1]),static_cast<float>(momentum[2]) });
577  ++converted_track_states;
578 
579 
580  }
581  for (const std::vector<float> &param : parametersVec) {
582  if (param.size() != 6) {
583  ATH_MSG_ERROR("Invalid size of param element " << param.size() << " != 6" );
584  }
585  }
586 
587  track_particle->setTrackParameters(parametersVec);
588 
589  // add element to link to the correspond track
590  trackLink(*track_particle)
591  = ElementLink<ActsTrk::TrackContainer>( tracksContainer,
592  track.index() );
593  ATH_CHECK( (trackLink(*track_particle)).isValid() );
594  }
595  }
596  ATH_MSG_DEBUG( "Converted " << nTracks << " acts tracks into " << track_particles->size()
597  << " track particles with parameters for " << converted_track_states << " track states.");
598 
599  return StatusCode::SUCCESS;
600  }

◆ 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()) {
94  return m_extendedExtraObjects;
95  }
96  return BaseAlg::extraOutputDeps();
97 }

◆ 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 ActsTrk::TrackToTrackParticleCnvAlg::initialize ( )
overridevirtual

Definition at line 130 of file TrackToTrackParticleCnvAlg.cxx.

131  {
132  std::vector<std::string> supportedStrategies {"BeamLine", "Vertex"};
133  bool isAllowedStrategy = false;
134  for (const std::string& strategy : supportedStrategies) {
135  if (m_perigeeExpression != strategy) continue;
136  isAllowedStrategy = true;
137  break;
138  }
139  ATH_MSG_DEBUG("- perigeeExpression: " << m_perigeeExpression.value());
140  if (not isAllowedStrategy) {
141  ATH_MSG_ERROR("Wrong configuration of the Track to Track Particle Cnv algorithm: perigeeExpression is not supported");
142  return StatusCode::FAILURE;
143  }
144 
145  if (m_perigeeExpression == "BeamLine") m_expression_strategy = expressionStrategy::BeamLine;
146  else if (m_perigeeExpression == "Vertex") m_expression_strategy = expressionStrategy::Vertex;
147  else if (m_perigeeExpression == "DontRecalculate") m_expression_strategy = expressionStrategy::DontRecalculate;
148  else return StatusCode::FAILURE;
149 
150  ATH_CHECK(m_trackingGeometryTool.retrieve());
151  ATH_CHECK( m_tracksContainerKey.initialize() );
152  ATH_CHECK( m_trackParticlesOutKey.initialize() );
153  ATH_CHECK( m_beamSpotKey.initialize(m_expression_strategy == expressionStrategy::BeamLine) );
154  ATH_CHECK( m_vertexHandle.initialize(m_expression_strategy == expressionStrategy::Vertex) );
155  ATH_CHECK( m_fieldCacheCondObjInputKey.initialize() );
156 
157  m_decorator_actsTracks = m_trackParticlesOutKey.key() + "." + m_decorator_actsTracks.key();
158  ATH_CHECK(m_decorator_actsTracks.initialize());
159 
160  ATH_CHECK( m_extrapolationTool.retrieve() ); // for extrapolation to beamline
161 
162  // propagator for conversion to curvilnear parameters
163  {
164  auto logger = makeActsAthenaLogger(this, "Prop");
165 
166  Navigator::Config cfg{m_trackingGeometryTool->trackingGeometry()};
167  cfg.resolvePassive = false;
168  cfg.resolveMaterial = true;
169  cfg.resolveSensitive = true;
170  auto navigtor_logger = logger->cloneWithSuffix("Navigator");
171  m_propagator = std::make_unique<Propagator>(Stepper(std::make_shared<ATLASMagneticFieldWrapper>()),
172  Navigator(cfg,std::move(navigtor_logger)),
173  std::move(logger));
174  }
175 
176  // for layer/module-type information per hit
177  ATH_CHECK( m_siDetEleCollKey.initialize() );
178  if (m_siDetEleCollToMeasurementType.size() == m_siDetEleCollKey.size()) {
179  unsigned int collection_idx=0;
180  for (int type : m_siDetEleCollToMeasurementType ) {
181  if (type <1 || type >2) {
182  ATH_MSG_ERROR("Invalid measurement type (" << type << ") given for collection " << collection_idx << " : "
183  << m_siDetEleCollKey[collection_idx].key()
184  << ". Expected 1 for pixel, 2 for strips.");
185  return StatusCode::FAILURE;
186  }
187  ++collection_idx;
188  }
189  }
190  else {
191  ATH_MSG_ERROR("Expected exactly one value in SiDetEleCollToMeasurementType per SiDetectorElementCollection. But got "
192  << m_siDetEleCollToMeasurementType.size() << " instead of " << m_siDetEleCollKey.size() << ".");
193  return StatusCode::FAILURE;
194  }
195 
196  initParticleHypothesisMap();
197 
198  return StatusCode::SUCCESS;
199  }

◆ initParticleHypothesisMap()

void ActsTrk::TrackToTrackParticleCnvAlg::initParticleHypothesisMap ( )
staticprivate

Definition at line 110 of file TrackToTrackParticleCnvAlg.cxx.

110  {
111  if (s_actsHypothesisToxAOD.empty()) {
112  s_actsHypothesisToxAOD.reserve(7);
113  s_actsHypothesisToxAOD.push_back( std::make_pair( Acts::eElectron , xAOD::electron) );
114  s_actsHypothesisToxAOD.push_back( std::make_pair( Acts::eMuon , xAOD::muon) );
115  s_actsHypothesisToxAOD.push_back( std::make_pair( Acts::ePionPlus , xAOD::pion) );
116  s_actsHypothesisToxAOD.push_back( std::make_pair( Acts::eProton , xAOD::proton) );
117  s_actsHypothesisToxAOD.push_back( std::make_pair( Acts::ePionZero , xAOD::pi0) );
118  s_actsHypothesisToxAOD.push_back( std::make_pair( Acts::eNeutron , xAOD::neutron) );
119  s_actsHypothesisToxAOD.push_back( std::make_pair( Acts::eGamma , xAOD::photon) );
120  }
121  }

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

◆ makePerigeeSurface() [1/2]

std::shared_ptr< Acts::PerigeeSurface > ActsTrk::TrackToTrackParticleCnvAlg::makePerigeeSurface ( const InDet::BeamSpotData *  beamspotptr)
staticprivate

Definition at line 602 of file TrackToTrackParticleCnvAlg.cxx.

602  {
603  // @from TrackToVertex::trackAtBeamline
604  Acts::Vector3 beamspot(0., 0., 0.);
605  float tiltx = 0.0;
606  float tilty = 0.0;
607  if (beamspot_data) {
608  beamspot = Acts::Vector3(beamspot_data->beamVtx().position());
609  tiltx = beamspot_data->beamTilt(0);
610  tilty = beamspot_data->beamTilt(1);
611  }
612  Acts::Translation3 translation(beamspot);
613  Acts::Transform3 transform( translation * Acts::RotationMatrix3::Identity() );
614  transform *= Acts::AngleAxis3(tilty, Acts::Vector3(0.,1.,0.));
615  transform *= Acts::AngleAxis3(tiltx, Acts::Vector3(1.,0.,0.));
616  return Acts::Surface::makeShared<Acts::PerigeeSurface>(transform);
617  }

◆ makePerigeeSurface() [2/2]

std::shared_ptr< Acts::PerigeeSurface > ActsTrk::TrackToTrackParticleCnvAlg::makePerigeeSurface ( const xAOD::Vertex &  vertex)
staticprivate

Definition at line 619 of file TrackToTrackParticleCnvAlg.cxx.

619  {
620  Acts::Translation3 translation(Acts::Vector3(vertex.position()));
621  Acts::Transform3 transform( translation * Acts::RotationMatrix3::Identity() );
622  return Acts::Surface::makeShared<Acts::PerigeeSurface>(transform);
623  }

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

◆ parametersAtPerigee()

Acts::BoundTrackParameters ActsTrk::TrackToTrackParticleCnvAlg::parametersAtPerigee ( const EventContext &  ctx,
const typename ActsTrk::TrackContainer::ConstTrackProxy &  track,
const Acts::PerigeeSurface &  perigee_surface 
) const
private

Definition at line 625 of file TrackToTrackParticleCnvAlg.cxx.

627  {
628  const Acts::BoundTrackParameters trackParam = track.createParametersAtReference();
629 
630  std::optional<const Acts::BoundTrackParameters>
631  perigeeParam = m_extrapolationTool->propagate(ctx,
632  trackParam,
633  perigee_surface,
634  Acts::Direction::Backward(), // @TODO try forward if backward fails ?
635  m_paramExtrapolationParLimit.value());
636  if (!perigeeParam.has_value()) {
637  ATH_MSG_WARNING( "Failed to extrapolate to perigee, started from \n" << trackParam << " " << trackParam.referenceSurface().name() );
638 
639  return trackParam;
640  }
641  else {
642  ATH_MSG_DEBUG( "Succeeded to extrapolate to perigee ");
643  return perigeeParam.value();
644  }
645  }

◆ 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  {
108  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
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

◆ ATLAS_THREAD_SAFE

std::vector<std::pair<Acts::PdgParticle, xAOD::ParticleHypothesis> > s_actsHypothesisToxAOD ActsTrk::TrackToTrackParticleCnvAlg::ATLAS_THREAD_SAFE
staticprivate

Definition at line 118 of file TrackToTrackParticleCnvAlg.h.

◆ m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> ActsTrk::TrackToTrackParticleCnvAlg::m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot or empty." }
private

Definition at line 80 of file TrackToTrackParticleCnvAlg.h.

◆ m_computeExpectedLayerPattern

Gaudi::Property<bool> ActsTrk::TrackToTrackParticleCnvAlg::m_computeExpectedLayerPattern {this, "ComputeExpectedLayerPattern",true, "Compute the expected layer pattern. CPU expensive" }
private

Definition at line 102 of file TrackToTrackParticleCnvAlg.h.

◆ m_decorator_actsTracks

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::TrackToTrackParticleCnvAlg::m_decorator_actsTracks {this, "ActsTrackLink", "actsTrack"}
private

Definition at line 95 of file TrackToTrackParticleCnvAlg.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_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_expectIfPixelContributes

Gaudi::Property<bool> ActsTrk::TrackToTrackParticleCnvAlg::m_expectIfPixelContributes {this, "expectIfPixelContribution",true, "Only expect pixel hits if there are pixel hits on track." }
private

Definition at line 104 of file TrackToTrackParticleCnvAlg.h.

◆ m_expression_strategy

expressionStrategy ActsTrk::TrackToTrackParticleCnvAlg::m_expression_strategy {expressionStrategy::BeamLine}
private

Definition at line 114 of file TrackToTrackParticleCnvAlg.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_extrapolationTool

ToolHandle<IActsExtrapolationTool> ActsTrk::TrackToTrackParticleCnvAlg::m_extrapolationTool {this, "ExtrapolationTool", ""}
private

Definition at line 72 of file TrackToTrackParticleCnvAlg.h.

◆ m_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> ActsTrk::TrackToTrackParticleCnvAlg::m_fieldCacheCondObjInputKey {this,"AtlasFieldCacheCondObj","fieldCondObj", "Name of the Magnetic Field conditions object key" }
private

Definition at line 82 of file TrackToTrackParticleCnvAlg.h.

◆ m_firstAndLastParamOnly

Gaudi::Property<bool> ActsTrk::TrackToTrackParticleCnvAlg::m_firstAndLastParamOnly {this, "FirstAndLastParameterOnly",true, "Only convert the first and the last parameter." }
private

Definition at line 100 of file TrackToTrackParticleCnvAlg.h.

◆ m_paramExtrapolationParLimit

Gaudi::Property<double> ActsTrk::TrackToTrackParticleCnvAlg::m_paramExtrapolationParLimit {this, "ExtrapolationPathLimit",std::numeric_limits<double>::max(), "PathLimit for extrapolating track parameters." }
private

Definition at line 98 of file TrackToTrackParticleCnvAlg.h.

◆ m_perigeeExpression

Gaudi::Property<std::string> ActsTrk::TrackToTrackParticleCnvAlg::m_perigeeExpression {this, "PerigeeExpression", "DontRecalculate"}
private

Definition at line 111 of file TrackToTrackParticleCnvAlg.h.

◆ m_pixelExpectLayerPathLimitInMM

Gaudi::Property<double> ActsTrk::TrackToTrackParticleCnvAlg::m_pixelExpectLayerPathLimitInMM
private
Initial value:
{this, "PixelExpectLayerPathLimitInMM",1000,
"PathLimit for extrapolating to get the expected pixel layer pattern in mm." }

Definition at line 107 of file TrackToTrackParticleCnvAlg.h.

◆ m_propagator

std::unique_ptr<Propagator> ActsTrk::TrackToTrackParticleCnvAlg::m_propagator
private

Definition at line 116 of file TrackToTrackParticleCnvAlg.h.

◆ m_siDetEleCollKey

SG::ReadCondHandleKeyArray<InDetDD::SiDetectorElementCollection> ActsTrk::TrackToTrackParticleCnvAlg::m_siDetEleCollKey {this, "SiDetectorElementCollections", {}, "Pixel and strip element collections to get geometry information about measurements."}
private

Definition at line 85 of file TrackToTrackParticleCnvAlg.h.

◆ m_siDetEleCollToMeasurementType

Gaudi::Property<std::vector<unsigned int> > ActsTrk::TrackToTrackParticleCnvAlg::m_siDetEleCollToMeasurementType {this, "SiDetEleCollToMeasurementType",{}, "One value per si detector collection: Pixel = 1, Strip = 2"}
private

Definition at line 87 of file TrackToTrackParticleCnvAlg.h.

◆ m_trackingGeometryTool

PublicToolHandle<ActsTrk::ITrackingGeometryTool> ActsTrk::TrackToTrackParticleCnvAlg::m_trackingGeometryTool {this, "TrackingGeometryTool", "ActsTrackingGeometryTool"}
private

Definition at line 75 of file TrackToTrackParticleCnvAlg.h.

◆ m_trackParticlesOutKey

SG::WriteHandleKey<xAOD::TrackParticleContainer> ActsTrk::TrackToTrackParticleCnvAlg::m_trackParticlesOutKey {this, "TrackParticlesOutKey","", "Name of the produced track particle collection" }
private

Definition at line 92 of file TrackToTrackParticleCnvAlg.h.

◆ m_tracksContainerKey

SG::ReadHandleKeyArray<ActsTrk::TrackContainer> ActsTrk::TrackToTrackParticleCnvAlg::m_tracksContainerKey {this, "ACTSTracksLocation", {},"Track collection (ActsTrk variant)"}
private

Definition at line 78 of file TrackToTrackParticleCnvAlg.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vertexHandle

SG::ReadHandleKey<xAOD::VertexContainer> ActsTrk::TrackToTrackParticleCnvAlg::m_vertexHandle {this, "VertexContainerKey", "", "Name of the Primary Vertex Container"}
private

Definition at line 90 of file TrackToTrackParticleCnvAlg.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
xAOD::strategy
strategy
Definition: L2CombinedMuon_v1.cxx:108
xAOD::neutron
@ neutron
for Fatras usage
Definition: TrackingPrimitives.h:201
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition: TrackingPrimitives.h:262
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:196
xAOD::TrackParticle_v1::setTrackFitter
void setTrackFitter(const TrackFitter fitter)
Method for setting the fitter, using the TrackFitter enum.
Definition: TrackParticle_v1.cxx:694
ActsTrk::TrackToTrackParticleCnvAlg::makePerigeeSurface
static std::shared_ptr< Acts::PerigeeSurface > makePerigeeSurface(const InDet::BeamSpotData *beamspotptr)
Definition: TrackToTrackParticleCnvAlg.cxx:602
createLinkingScheme.iter
iter
Definition: createLinkingScheme.py:62
ActsTrk::detail::convertActsBoundCovToCurvilinearParam
std::optional< Acts::BoundMatrix > convertActsBoundCovToCurvilinearParam(const Acts::GeometryContext &tgContext, const Acts::BoundTrackParameters &param, const Acts::Vector3 &magnFieldVect, const Acts::ParticleHypothesis &particle_hypothesis)
Convert the covariance of the given Acts track parameters into curvilinear parameterisation.
Definition: CurvilinearCovarianceHelper.h:61
ActsTrk::TrackContainer
Definition: TrackContainer.h:30
ActsTrk::TrackToTrackParticleCnvAlg::m_expectIfPixelContributes
Gaudi::Property< bool > m_expectIfPixelContributes
Definition: TrackToTrackParticleCnvAlg.h:105
ActsTrk::detail::SumOfValues
Helper class to gather statistics and compute the biased variance.
Definition: HitSummaryDataUtils.h:253
python.SystemOfUnits.mm
float mm
Definition: SystemOfUnits.py:98
xAOD::numberOfSCTSharedHits
@ numberOfSCTSharedHits
number of SCT hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:273
ActsTrk::detail::gatherTrackSummaryData
void gatherTrackSummaryData(const ActsTrk::TrackContainer &tracksContainer, const typename ActsTrk::TrackContainer::ConstTrackProxy &track, const std::array< const InDetDD::SiDetectorElementCollection *, to_underlying(xAOD::UncalibMeasType::nTypes)> &siDetEleColl, const std::array< unsigned short, to_underlying(xAOD::UncalibMeasType::nTypes)> &measurement_to_summary_type, SumOfValues &chi2_stat_out, HitSummaryData &hit_info_out, std::vector< ActsTrk::TrackStateBackend::ConstTrackStateProxy::IndexType > &param_state_idx_out, std::array< std::array< uint8_t, to_underlying(HitCategory::N)>, to_underlying(xAOD::UncalibMeasType::nTypes)> &special_hit_counts_out)
Helper to gather track summary information from the track states of the specified track.
Definition: HitSummaryDataUtils.cxx:15
ActsTrk::detail::HitSummaryData::contributingHits
uint8_t contributingHits(DetectorRegion region) const
return the number of hits in a certain detector region.
Definition: HitSummaryDataUtils.h:196
xAOD::Vertex
Vertex_v1 Vertex
Define the latest version of the vertex class.
Definition: Event/xAOD/xAODTracking/xAODTracking/Vertex.h:16
InDetDD::SiDetectorElementCollection
Definition: SiDetectorElementCollection.h:27
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:558
xAOD::electron
@ electron
Definition: TrackingPrimitives.h:195
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
xAOD::TrackParticle_v1::setTrackParameters
void setTrackParameters(std::vector< std::vector< float > > &parameters)
Set the parameters via the passed vector of vectors.
Definition: TrackParticle_v1.cxx:568
AtlasFieldCacheCondObj
Definition: AtlasFieldCacheCondObj.h:19
ActsTrk::detail::to_underlying
constexpr std::underlying_type< T_EnumClass >::type to_underlying(T_EnumClass an_enum)
Helper to convert class enum into an integer.
Definition: HitSummaryDataUtils.h:24
xAOD::numberOfContribPixelBarrelInclinedLayers
@ numberOfContribPixelBarrelInclinedLayers
number of contributing barrel inclined layers of the pixel detector [unit8_t].
Definition: TrackingPrimitives.h:310
xAOD::numberOfInnermostPixelLayerSharedEndcapHits
@ numberOfInnermostPixelLayerSharedEndcapHits
number of Pixel 0th layer endcap hits shared by several tracks.
Definition: TrackingPrimitives.h:245
xAOD::BeamLine
@ BeamLine
Parameter defined at the Vertex/Beamline.
Definition: TrackingPrimitives.h:212
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
xAOD::UncalibMeasType::StripClusterType
@ StripClusterType
xAOD::short
short
Definition: Vertex_v1.cxx:165
ActsTrk::TrackToTrackParticleCnvAlg::m_trackingGeometryTool
PublicToolHandle< ActsTrk::ITrackingGeometryTool > m_trackingGeometryTool
Definition: TrackToTrackParticleCnvAlg.h:75
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
ActsTrk::TrackToTrackParticleCnvAlg::m_firstAndLastParamOnly
Gaudi::Property< bool > m_firstAndLastParamOnly
Definition: TrackToTrackParticleCnvAlg.h:101
ActsTrk::TrackToTrackParticleCnvAlg::m_expression_strategy
expressionStrategy m_expression_strategy
Definition: TrackToTrackParticleCnvAlg.h:114
ActsTrk::detail::HitSummaryData::Hit
@ Hit
Definition: HitSummaryDataUtils.h:96
ActsTrk::detail::HitSummaryData::contributingSharedHits
uint8_t contributingSharedHits(DetectorRegion region) const
return the number of shared hits in a certain detector region.
Definition: HitSummaryDataUtils.h:212
ActsTrk::detail::HitSummaryData::Outlier
@ Outlier
Definition: HitSummaryDataUtils.h:97
ActsTrk::detail::HitSummaryData::pixelEndcap
@ pixelEndcap
Definition: HitSummaryDataUtils.h:45
ActsTrk::TrackToTrackParticleCnvAlg::parametersAtPerigee
Acts::BoundTrackParameters parametersAtPerigee(const EventContext &ctx, const typename ActsTrk::TrackContainer::ConstTrackProxy &track, const Acts::PerigeeSurface &perigee_surface) const
Definition: TrackToTrackParticleCnvAlg.cxx:625
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::numberOfContribPixelBarrelFlatLayers
@ numberOfContribPixelBarrelFlatLayers
number of contributing barrel flat layers of the pixel detector [unit8_t].
Definition: TrackingPrimitives.h:309
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:210
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
xAOD::pion
@ pion
Definition: TrackingPrimitives.h:197
xAOD::TrackParticle_v1::setDefiningParameters
void setDefiningParameters(float d0, float z0, float phi0, float theta, float qOverP)
Set the defining parameters.
Definition: TrackParticle_v1.cxx:178
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:260
xAOD::expectInnermostPixelLayerHit
@ expectInnermostPixelLayerHit
Do we expect a 0th-layer barrel hit for this track?
Definition: TrackingPrimitives.h:237
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
xAOD::TrackParticle_v1::setTrackParameterCovarianceMatrix
void setTrackParameterCovarianceMatrix(unsigned int index, std::vector< float > &cov)
Set the cov matrix of the parameter at 'index', using a vector of floats.
Definition: TrackParticle_v1.cxx:639
isValid
bool isValid(const T &p)
Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
Definition: AtlasPID.h:872
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
SG::ReadHandleKey< ActsTrk::TrackContainer >
xAOD::noHypothesis
@ noHypothesis
For material collection.
Definition: TrackingPrimitives.h:205
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
xAOD::numberOfInnermostPixelLayerEndcapOutliers
@ numberOfInnermostPixelLayerEndcapOutliers
number of 0th layer endcap outliers
Definition: TrackingPrimitives.h:244
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
xAOD::TrackParticle_v1::setBeamlineTiltY
void setBeamlineTiltY(float tiltY)
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:74
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
makeActsAthenaLogger
std::unique_ptr< const Acts::Logger > makeActsAthenaLogger(IMessageSvc *svc, const std::string &name, int level, std::optional< std::string > parent_name)
Definition: Tracking/Acts/ActsInterop/src/Logger.cxx:64
ActsGeometryContext::context
Acts::GeometryContext context() const
Definition: ActsGeometryContext.h:45
xAOD::TrackParticle_v1::setFitQuality
void setFitQuality(float chiSquared, float numberDoF)
Set the 'Fit Quality' information.
Definition: TrackParticle_v1.cxx:535
xAOD::numberOfContribPixelEndcap
@ numberOfContribPixelEndcap
number of contributing endcap layers of the pixel detector [unit8_t].
Definition: TrackingPrimitives.h:311
xAOD::numberOfInnermostPixelLayerOutliers
@ numberOfInnermostPixelLayerOutliers
number of 0th layer barrel outliers
Definition: TrackingPrimitives.h:239
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
xAOD::numberOfNextToInnermostPixelLayerSharedEndcapHits
@ numberOfNextToInnermostPixelLayerSharedEndcapHits
number of Pixel 1st layer endcap hits shared by several tracks.
Definition: TrackingPrimitives.h:256
xAOD::numberOfInnermostPixelLayerEndcapHits
@ numberOfInnermostPixelLayerEndcapHits
these are the hits in the 0th pixel layer endcap [unit8_t].
Definition: TrackingPrimitives.h:243
xAOD::numberOfPixelSharedHits
@ numberOfPixelSharedHits
number of Pixel all-layer hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:263
AtlasFieldCacheCondObj::getInitializedCache
void getInitializedCache(MagField::AtlasFieldCache &cache) const
get B field cache for evaluation as a function of 2-d or 3-d position.
Definition: AtlasFieldCacheCondObj.h:32
ActsTrk::detail::HitSummaryData
Helper class to gather hit summary information for e.g.
Definition: HitSummaryDataUtils.h:38
ActsTrk::detail::HitSummaryData::contributingOutlierHits
uint8_t contributingOutlierHits(DetectorRegion region) const
return the number of outliers in a certain detector region.
Definition: HitSummaryDataUtils.h:204
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
ActsTrk::TrackToTrackParticleCnvAlg::Navigator
Acts::Navigator Navigator
Definition: TrackToTrackParticleCnvAlg.h:63
xAOD::SummaryType
SummaryType
Enumerates the different types of information stored in Summary.
Definition: TrackingPrimitives.h:229
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::expectNextToInnermostPixelLayerHit
@ expectNextToInnermostPixelLayerHit
Do we expect a 1st-layer barrel hit for this track?
Definition: TrackingPrimitives.h:248
xAOD::numberOfPixelBarrelFlatHits
@ numberOfPixelBarrelFlatHits
these are the pixel hits, in the barrel flat layers [unit8_t].
Definition: TrackingPrimitives.h:312
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
ActsTrk::TrackToTrackParticleCnvAlg::initParticleHypothesisMap
static void initParticleHypothesisMap()
Definition: TrackToTrackParticleCnvAlg.cxx:110
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
lumiFormat.i
int i
Definition: lumiFormat.py:85
ActsTrk::detail::ExpectedLayerPatternHelper::exists
static bool exists(track_container_t &trackContainer)
Definition: ExpectedHitUtils.h:43
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
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:100
ActsTrk::detail::HitSummaryData::contributingLayers
uint8_t contributingLayers(DetectorRegion region) const
return the number of layers contributing to the hit collection in the given detector region.
Definition: HitSummaryDataUtils.h:188
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
ActsTrk::TrackToTrackParticleCnvAlg::m_decorator_actsTracks
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer > m_decorator_actsTracks
Definition: TrackToTrackParticleCnvAlg.h:96
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:572
ActsTrk::detail::HitCategory::N
@ N
Definition: HitSummaryDataUtils.h:32
xAOD::numberOfPixelOutliers
@ numberOfPixelOutliers
these are the pixel outliers, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:261
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
DataVector::insert
iterator insert(iterator position, value_type pElem)
Add a new element to the collection.
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
detail::ul
unsigned long ul
Definition: PrimitiveHelpers.h:46
xAOD::standardDeviationOfChi2OS
@ standardDeviationOfChi2OS
100 times the standard deviation of the chi2 from the surfaces [unit8_t].
Definition: TrackingPrimitives.h:299
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
ActsTrk::detail::HitSummaryData::pixelBarrelFlat
@ pixelBarrelFlat
Definition: HitSummaryDataUtils.h:43
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:271
ActsTrk::TrackToTrackParticleCnvAlg::m_computeExpectedLayerPattern
Gaudi::Property< bool > m_computeExpectedLayerPattern
Definition: TrackToTrackParticleCnvAlg.h:103
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
xAOD::TrackParticle_v1::setParticleHypothesis
void setParticleHypothesis(const ParticleHypothesis hypo)
Method for setting the particle type, using the ParticleHypothesis enum.
Definition: TrackParticle_v1.cxx:724
ActsGeometryContext
Include the GeoPrimitives which need to be put first.
Definition: ActsGeometryContext.h:27
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
xAOD::numberOfNextToInnermostPixelLayerEndcapHits
@ numberOfNextToInnermostPixelLayerEndcapHits
these are the hits in the 0.5th and 1st pixel layer endcap rings [unit8_t].
Definition: TrackingPrimitives.h:254
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
lumiFormat.array
array
Definition: lumiFormat.py:91
ActsTrk::TrackToTrackParticleCnvAlg::m_trackParticlesOutKey
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_trackParticlesOutKey
Definition: TrackToTrackParticleCnvAlg.h:93
ActsTrk::detail::HitSummaryData::sum
uint8_t sum(DetectorRegion region, uint8_t layer) const
return the total number of hits, outliers, and/or shared hits in the givrn detector region and layer.
Definition: HitSummaryDataUtils.h:222
xAOD::UncalibMeasType::nTypes
@ nTypes
xAOD::KalmanFitter
@ KalmanFitter
tracks produced by the Kalman Fitter
Definition: TrackingPrimitives.h:48
xAOD::numberOfNextToInnermostPixelLayerOutliers
@ numberOfNextToInnermostPixelLayerOutliers
number of 1st pixel layer barrel outliers
Definition: TrackingPrimitives.h:250
xAOD::numberOfNextToInnermostPixelLayerHits
@ numberOfNextToInnermostPixelLayerHits
these are the hits in the 1st pixel barrel layer
Definition: TrackingPrimitives.h:249
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
xAOD::proton
@ proton
Definition: TrackingPrimitives.h:199
ActsTrk::TrackToTrackParticleCnvAlg::m_fieldCacheCondObjInputKey
SG::ReadCondHandleKey< AtlasFieldCacheCondObj > m_fieldCacheCondObjInputKey
Definition: TrackToTrackParticleCnvAlg.h:83
ActsTrk::TrackToTrackParticleCnvAlg::expressionStrategy::Vertex
@ Vertex
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
WriteCaloSwCorrections.cfg
cfg
Definition: WriteCaloSwCorrections.py:23
xAOD::ParticleHypothesis
ParticleHypothesis
Definition: TrackingPrimitives.h:193
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
xAOD::pi0
@ pi0
for Fatras usage
Definition: TrackingPrimitives.h:202
ActsTrk::detail::HitSummaryData::stripTotal
@ stripTotal
Definition: HitSummaryDataUtils.h:50
xAOD::numberOfPixelBarrelInclinedHits
@ numberOfPixelBarrelInclinedHits
these are the pixel hits, in the barrel inclined layers [unit8_t].
Definition: TrackingPrimitives.h:313
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
xAOD::TrackParticle_v1::setDefiningParametersCovMatrixVec
void setDefiningParametersCovMatrixVec(const std::vector< float > &cov)
Definition: TrackParticle_v1.cxx:461
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
ActsTrk::detail::HitSummaryData::pixelBarrelInclined
@ pixelBarrelInclined
Definition: HitSummaryDataUtils.h:44
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
xAOD::numberOfOutliersOnTrack
@ numberOfOutliersOnTrack
number of measurements flaged as outliers in TSOS [unit8_t].
Definition: TrackingPrimitives.h:298
InDet::BeamSpotData
Definition: BeamSpotData.h:21
ActsTrk::detail::expectedLayerPattern
std::array< unsigned int, 4 > expectedLayerPattern(const EventContext &ctx, const IActsExtrapolationTool &extrapolator, const Acts::BoundTrackParameters &perigee_parameters, double pathLimit)
Extrapolate from the perigee outwards and gather information which detector layers should have hits.
Definition: ExpectedHitUtils.cxx:14
xAOD::photon
@ photon
Definition: TrackingPrimitives.h:200
a
TList * a
Definition: liststreamerinfos.cxx:10
ActsTrk::TrackToTrackParticleCnvAlg::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition: TrackToTrackParticleCnvAlg.h:81
ActsTrk::TrackToTrackParticleCnvAlg::Stepper
Acts::EigenStepper<> Stepper
Definition: TrackToTrackParticleCnvAlg.h:62
SG::WriteDecorHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
xAOD::numberOfSCTOutliers
@ numberOfSCTOutliers
number of SCT outliers [unit8_t].
Definition: TrackingPrimitives.h:270
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ActsTrk::detail::SumOfValues::biasedVariance
double biasedVariance() const
Definition: HitSummaryDataUtils.h:274
xAOD::numberOfNextToInnermostPixelLayerEndcapOutliers
@ numberOfNextToInnermostPixelLayerEndcapOutliers
number of 1st layer endcap disk outliers
Definition: TrackingPrimitives.h:255
ActsTrk::detail::HitSummaryData::SharedHit
@ SharedHit
Definition: HitSummaryDataUtils.h:99
MagField::AtlasFieldCache
Local cache for magnetic field (based on MagFieldServices/AtlasFieldSvcTLS.h)
Definition: AtlasFieldCache.h:43
ActsTrk::TrackToTrackParticleCnvAlg::m_perigeeExpression
Gaudi::Property< std::string > m_perigeeExpression
Definition: TrackToTrackParticleCnvAlg.h:111
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
ActsTrk::TrackToTrackParticleCnvAlg::m_pixelExpectLayerPathLimitInMM
Gaudi::Property< double > m_pixelExpectLayerPathLimitInMM
Definition: TrackToTrackParticleCnvAlg.h:108
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
xAOD::numberOfInnermostPixelLayerSharedHits
@ numberOfInnermostPixelLayerSharedHits
number of Pixel 0th layer barrel hits shared by several tracks.
Definition: TrackingPrimitives.h:240
xAOD::SiSPSeededFinder
@ SiSPSeededFinder
Tracks from SiSPSeedFinder.
Definition: TrackingPrimitives.h:86
MagField::AtlasFieldCache::getField
void getField(const double *ATH_RESTRICT xyz, double *ATH_RESTRICT bxyz, double *ATH_RESTRICT deriv=nullptr)
get B field value at given position xyz[3] is in mm, bxyz[3] is in kT if deriv[9] is given,...
Definition: AtlasFieldCache.cxx:42
ActsTrk::TrackToTrackParticleCnvAlg::m_propagator
std::unique_ptr< Propagator > m_propagator
Definition: TrackToTrackParticleCnvAlg.h:116
xAOD::numberOfContribPixelLayers
@ numberOfContribPixelLayers
number of contributing layers of the pixel detector [unit8_t].
Definition: TrackingPrimitives.h:231
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:269
xAOD::numberOfPixelEndcapHits
@ numberOfPixelEndcapHits
these are the pixel hits, in the endcap layers [unit8_t].
Definition: TrackingPrimitives.h:314
ActsTrk::TrackToTrackParticleCnvAlg::m_tracksContainerKey
SG::ReadHandleKeyArray< ActsTrk::TrackContainer > m_tracksContainerKey
Definition: TrackToTrackParticleCnvAlg.h:79
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
ActsTrk::TrackToTrackParticleCnvAlg::m_paramExtrapolationParLimit
Gaudi::Property< double > m_paramExtrapolationParLimit
Definition: TrackToTrackParticleCnvAlg.h:99
ActsTrk::TrackToTrackParticleCnvAlg::expressionStrategy::BeamLine
@ BeamLine
ActsTrk::detail::ExpectedLayerPatternHelper::get
static std::array< unsigned int, 4 > get(const track_proxy_t &track)
Definition: ExpectedHitUtils.h:63
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
ActsTrk::TrackToTrackParticleCnvAlg::m_extrapolationTool
ToolHandle< IActsExtrapolationTool > m_extrapolationTool
Definition: TrackToTrackParticleCnvAlg.h:73
ActsTrk::detail::HitCategory::Hole
@ Hole
Definition: HitSummaryDataUtils.h:31
ActsTrk::detail::HitSummaryData::pixelTotal
@ pixelTotal
Definition: HitSummaryDataUtils.h:49
ActsTrk::TrackToTrackParticleCnvAlg::m_vertexHandle
SG::ReadHandleKey< xAOD::VertexContainer > m_vertexHandle
Definition: TrackToTrackParticleCnvAlg.h:91
ActsTrk::TrackToTrackParticleCnvAlg::m_siDetEleCollToMeasurementType
Gaudi::Property< std::vector< unsigned int > > m_siDetEleCollToMeasurementType
Definition: TrackToTrackParticleCnvAlg.h:88
ActsTrk::TrackToTrackParticleCnvAlg::ATLAS_THREAD_SAFE
static std::vector< std::pair< Acts::PdgParticle, xAOD::ParticleHypothesis > > s_actsHypothesisToxAOD ATLAS_THREAD_SAFE
Definition: TrackToTrackParticleCnvAlg.h:118
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
ActsTrk::detail::HitSummaryData::DetectorRegion
DetectorRegion
Regions for which hit counts are computed.
Definition: HitSummaryDataUtils.h:42
ActsTrk::TrackToTrackParticleCnvAlg::m_siDetEleCollKey
SG::ReadCondHandleKeyArray< InDetDD::SiDetectorElementCollection > m_siDetEleCollKey
Definition: TrackToTrackParticleCnvAlg.h:86
xAOD::numberOfNextToInnermostPixelLayerSharedHits
@ numberOfNextToInnermostPixelLayerSharedHits
number of Pixel 1st layer barrel hits shared by several tracks.
Definition: TrackingPrimitives.h:251
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
xAOD::TrackParticle_v1::setBeamlineTiltX
void setBeamlineTiltX(float tiltX)
python.iconfTool.gui.pad.logger
logger
Definition: pad.py:14
ActsTrk::TrackToTrackParticleCnvAlg::expressionStrategy::DontRecalculate
@ DontRecalculate
ActsTrk::TrackToTrackParticleCnvAlg::convertParticleHypothesis
static xAOD::ParticleHypothesis convertParticleHypothesis(Acts::PdgParticle abs_pdg_id)
Definition: TrackToTrackParticleCnvAlg.h:125
xAOD::UncalibMeasType::PixelClusterType
@ PixelClusterType
fitman.k
k
Definition: fitman.py:528
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:238
xAOD::TrackParticle_v1::setPatternRecognitionInfo
void setPatternRecognitionInfo(const std::bitset< xAOD::NumberOfTrackRecoInfo > &patternReco)
Method setting the pattern recognition algorithm, using a bitset.
Definition: TrackParticle_v1.cxx:719
ServiceHandle< ICondSvc >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
SG::ReadCondHandle::cptr
const_pointer_type cptr()
Definition: ReadCondHandle.h:71
Generated on Mon Sep 29 2025 21:59:10 for ATLAS Offline Software by   doxygen 1.8.18