ATLAS Offline Software
IterativePriVtxFinderTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "src/IterativePriVtxFinderTool.h"
6 
7 // ATHENA
8 #include "GaudiKernel/IInterface.h"
9 #include "TrkParticleBase/LinkToTrackParticleBase.h"
10 #include "TrkLinks/LinkToXAODTrackParticle.h"
11 #include "xAODTracking/TrackParticleContainer.h"
12 
13 // PACKAGE
14 #include "ActsGeometry/ActsTrackingGeometrySvc.h"
15 #include "ActsGeometry/ActsTrackingGeometryTool.h"
16 
17 // ACTS
18 #include "Acts/Propagator/Navigator.hpp"
19 #include "Acts/Propagator/EigenStepper.hpp"
20 #include "Acts/Propagator/Propagator.hpp"
21 #include "Acts/Utilities/AnnealingUtility.hpp"
22 #include "Acts/Vertexing/TrackAtVertex.hpp"
23 
24 // STL
25 #include <iostream>
26 #include <memory>
27 
28 namespace
29 {
30  // Helper struct for vertex signal compatibility
31  struct VertexAndSignalComp {
32  xAOD::Vertex* first;
33  double second;
34  VertexAndSignalComp(xAOD::Vertex* p1, double p2)
35  : first(p1), second(p2) {}
36  bool
37  operator < (const VertexAndSignalComp& other) const
38  {return second > other.second;}
39  };
40  } //anonymous namespace
41 
42 ActsTrk::IterativePriVtxFinderTool::IterativePriVtxFinderTool(const std::string& type,
43  const std::string& name,
44  const IInterface* parent)
45  : base_class(type, name, parent)
46 {}
47 
48 StatusCode
49 ActsTrk::IterativePriVtxFinderTool::initialize()
50 {
51  using namespace std::literals::string_literals;
52 
53  ATH_CHECK(m_beamSpotKey.initialize());
54  ATH_CHECK(m_trkFilter.retrieve());
55 
56  m_logger = makeActsAthenaLogger(this, "Acts");
57 
58  ATH_MSG_INFO("Initializing ACTS Iterative Vertex Finder tool");
59  ATH_CHECK( m_trackingGeometryTool.retrieve() );
60  std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry
61  = m_trackingGeometryTool->trackingGeometry();
62 
63  ATH_CHECK( m_extrapolationTool.retrieve() );
64 
65  Acts::Navigator navigator( Acts::Navigator::Config{ trackingGeometry },
66  logger().cloneWithSuffix("Navigator"));
67 
68  m_bField = std::make_shared<ATLASMagneticFieldWrapper>();
69  auto stepper = Acts::EigenStepper<>(m_bField);
70  m_propagator = std::make_shared<Propagator>(std::move(stepper),
71  std::move(navigator),
72  logger().cloneWithSuffix("Prop"));
73  // IP Estimator
74  Acts::ImpactPointEstimator::Config ipEstCfg(m_bField, m_propagator);
75  ipEstCfg.maxIterations = m_ipEstMaxIterations;
76  ipEstCfg.precision = m_ipEstPrecision;
77  Acts::ImpactPointEstimator ipEst(ipEstCfg,
78  logger().cloneWithSuffix("ImpactPointEstimator"));
79 
80  // Linearizer for Acts::BoundParameters type test
81  TrackLinearizer::Config ltConfig;
82  ltConfig.bField = m_bField;
83  ltConfig.propagator = m_propagator;
84  m_linearizer.emplace(ltConfig, logger().cloneWithSuffix("Linearizer"));
85 
86  // Full Billoir Vertex fitter setup
87  VertexFitter::Config fitterCfg;
88  fitterCfg.maxIterations = m_fitterMaxIterations;
89  fitterCfg.extractParameters.connect<&TrackWrapper::extractParameters>();
90  fitterCfg.trackLinearizer.connect<&TrackLinearizer::linearizeTrack>(&*m_linearizer);
91  VertexFitter fitter(fitterCfg, logger().cloneWithSuffix("Fitter"));
92 
93 
94  // Seed finder setup
95  // Set up Gaussian track density
96  Acts::GaussianTrackDensity::Config trackDensityConfig;
97  trackDensityConfig.d0MaxSignificance = m_gaussianMaxD0Significance;
98  trackDensityConfig.z0MaxSignificance = m_gaussianMaxZ0Significance;
99  trackDensityConfig.extractParameters.connect<&TrackWrapper::extractParameters>();
100  Acts::GaussianTrackDensity trackDensity(trackDensityConfig);
101 
102  // Vertex seed finder
103  VertexSeedFinder::Config seedFinderConfig{trackDensity};
104  auto seedFinder = std::make_shared<VertexSeedFinder>(seedFinderConfig);
105 
106  // Iterative Vertex Finder setup
107  VertexFinder::Config finderConfig(std::move(fitter),
108  std::move(seedFinder),
109  ipEst);
110  finderConfig.significanceCutSeeding = m_significanceCutSeeding;
111  finderConfig.maximumChi2cutForSeeding = m_maximumChi2cutForSeeding;
112  finderConfig.maxVertices = m_maxVertices;
113  finderConfig.createSplitVertices = m_createSplitVertices;
114  finderConfig.splitVerticesTrkInvFraction = m_splitVerticesTrkInvFraction;
115  finderConfig.reassignTracksAfterFirstFit = m_reassignTracksAfterFirstFit;
116  finderConfig.doMaxTracksCut = m_doMaxTracksCut;
117  finderConfig.maxTracks = m_maxTracks;
118  finderConfig.cutOffTrackWeight = m_cutOffTrackWeight;
119  finderConfig.extractParameters.connect<&TrackWrapper::extractParameters>();
120  finderConfig.trackLinearizer.connect<&TrackLinearizer::linearizeTrack>(&*m_linearizer);
121  m_vertexFinder = std::make_shared<VertexFinder>(std::move(finderConfig), logger().cloneWithSuffix("Finder"));
122 
123  ATH_MSG_INFO("ACTS Iterative Vertex Finder tool successfully initialized");
124  return StatusCode::SUCCESS;
125 }
126 
127 std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*>
128 ActsTrk::IterativePriVtxFinderTool::findVertex(const EventContext& ctx,
129  const TrackCollection* trackTES) const
130 {
131 
132  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx};
133  const Trk::RecVertex& beamposition(beamSpotHandle->beamVtx());
134 
135  std::vector<std::unique_ptr<Trk::ITrackLink>> selectedTracks;
136 
137  typedef DataVector<Trk::Track>::const_iterator TrackDataVecIter;
138 
139  bool selectionPassed;
140  for (TrackDataVecIter itr = (*trackTES).begin(); itr != (*trackTES).end(); ++itr) {
141  if (m_useBeamConstraint) {
142  selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &beamposition));
143  } else {
144  Trk::Vertex null(Amg::Vector3D(0, 0, 0));
145  selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &null));
146  }
147  if (selectionPassed) {
148  ElementLink<TrackCollection> link;
149  link.setElement(*itr);
150  auto trkPtr = std::make_unique<Trk::LinkToTrack>(link);
151  trkPtr->setStorableObject(*trackTES);
152  selectedTracks.push_back(std::move(trkPtr));
153  }
154  }
155 
156  std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> returnContainers = findVertex(ctx, std::move(selectedTracks));
157 
158  return returnContainers;
159 }
160 
161 std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*>
162 ActsTrk::IterativePriVtxFinderTool::findVertex(const EventContext& ctx,
163  const xAOD::TrackParticleContainer* trackParticles) const
164 {
165 
166  std::vector<std::unique_ptr<Trk::ITrackLink>> selectedTracks;
167  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx};
168  xAOD::Vertex beamposition;
169  beamposition.makePrivateStore();
170  beamposition.setPosition(beamSpotHandle->beamVtx().position());
171  beamposition.setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
172 
173  typedef DataVector<xAOD::TrackParticle>::const_iterator TrackParticleDataVecIter;
174 
175  bool selectionPassed;
176  for (TrackParticleDataVecIter itr = (*trackParticles).begin(); itr != (*trackParticles).end(); ++itr) {
177  if (m_useBeamConstraint) {
178  selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &beamposition));
179  } else {
180  xAOD::Vertex null;
181  null.makePrivateStore();
182  null.setPosition(Amg::Vector3D(0, 0, 0));
183  AmgSymMatrix(3) vertexError;
184  vertexError.setZero();
185  null.setCovariancePosition(vertexError);
186  selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &null));
187  }
188 
189  if (selectionPassed) {
190  ElementLink<xAOD::TrackParticleContainer> link;
191  link.setElement(*itr);
192  auto trkPtr = std::make_unique<Trk::LinkToXAODTrackParticle>(link);
193  trkPtr->setStorableObject(*trackParticles);
194  selectedTracks.push_back(std::move(trkPtr));
195  }
196  }
197 
198  std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> returnContainers = findVertex(ctx, std::move(selectedTracks));
199 
200  return returnContainers;
201 }
202 
203 std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*>
204 ActsTrk::IterativePriVtxFinderTool::findVertex(const EventContext& ctx,
205  const std::vector<std::unique_ptr<Trk::ITrackLink>>& trackVector) const
206 {
207 
208  using namespace Acts::UnitLiterals;
209 
210  // Vertex finding algorithm begins
211  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx};
212 
213  // The output vertex containers
214  xAOD::VertexContainer* theVertexContainer = new xAOD::VertexContainer;
215  xAOD::VertexAuxContainer* theVertexAuxContainer = new xAOD::VertexAuxContainer;
216  theVertexContainer->setStore(theVertexAuxContainer);
217 
218  // bail out early with only Dummy vertex if multiplicity cut is applied and exceeded
219  if((m_doMaxTracksCut && (trackVector.size() > m_maxTracks)) || trackVector.empty()) {
220  ATH_MSG_WARNING(trackVector.size()
221  << " tracks - exceeds maximum (" << m_maxTracks
222  << "), skipping vertexing and returning only dummy...");
223  xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
224  theVertexContainer->push_back(
225  dummyxAODVertex); // have to add vertex to container here first so it can use its aux store
226  dummyxAODVertex->setPosition(beamSpotHandle->beamVtx().position());
227  dummyxAODVertex->setCovariancePosition(
228  beamSpotHandle->beamVtx().covariancePosition());
229  dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
230  dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
231  return std::make_pair(theVertexContainer, theVertexAuxContainer);
232  }
233 
234  const Acts::Vector3& beamSpotPos = beamSpotHandle->beamVtx().position();
235  Acts::Vertex beamSpotConstraintVtx(beamSpotPos);
236  beamSpotConstraintVtx.setCovariance(beamSpotHandle->beamVtx().covariancePosition());
237 
238  std::shared_ptr<Acts::PerigeeSurface> perigeeSurface =
239  Acts::Surface::makeShared<Acts::PerigeeSurface>((trackVector[0])->parameters()->associatedSurface().transform());
240 
241  // Get the magnetic field context
242  Acts::MagneticFieldContext magFieldContext = m_extrapolationTool->getMagneticFieldContext(ctx);
243 
244  const auto& geoContext
245  = m_trackingGeometryTool->getGeometryContext(ctx).context();
246 
247  // Convert tracks to Acts::BoundParameters
248  std::vector<TrackWrapper> allTracks;
249 
250  for (const auto& trk : trackVector) {
251 
252  const auto& trkParams = trk->parameters();
253  const auto& params = trkParams->parameters();
254 
255  Acts::BoundVector actsParams;
256  actsParams << params(0), params(1), params(2), params(3), params(4)*1./(1_MeV), 0.;
257 
258  if(trkParams->covariance() == nullptr){
259  continue;
260  }
261  auto cov = *(trkParams->covariance());
262 
263  // TODO: check if the following works as well:
264  // cov->col(4) *= 1./1_MeV;
265  // cov->row(4) *= 1./1_MeV;
266  Acts::BoundSquareMatrix covMat;
267  covMat << cov(0,0) , cov(0,1) , cov(0,2) , cov(0,3) , cov(0,4) *1./(1_MeV), 0
268  , cov(1,0) , cov(1,1) , cov(1,2) , cov(1,3) , cov(1,4) *1./(1_MeV) , 0
269  , cov(2,0) , cov(2,1) , cov(2,2) , cov(2,3) , cov(2,4) *1./(1_MeV) , 0
270  , cov(3,0) , cov(3,1) , cov(3,2) , cov(3,3) , cov(3,4) *1./(1_MeV) , 0
271  , cov(4,0) *1./(1_MeV) , cov(4,1) *1./(1_MeV) , cov(4,2) *1./(1_MeV) , cov(4,3) *1./(1_MeV) , cov(4,4) *1./(1_MeV*1_MeV), 0
272  , 0. , 0. , 0. , 0., 0., 1.;
273 
274  allTracks.emplace_back(trk.get(),Acts::BoundTrackParameters(perigeeSurface, actsParams, covMat, Acts::ParticleHypothesis::pion()));
275  }
276 
277  std::vector<Acts::InputTrack> allTrackPtrs;
278  allTrackPtrs.reserve(allTracks.size());
279 
280 for(const auto& trk : allTracks){
281  allTrackPtrs.emplace_back(&trk);
282  }
283 
284  Acts::VertexingOptions vertexingOptions(geoContext,
285  magFieldContext);
286 
287  if(!m_useBeamConstraint){
288  beamSpotConstraintVtx.setPosition(Acts::Vector3::Zero());
289  beamSpotConstraintVtx.setCovariance(Acts::ActsSquareMatrix<3>::Zero());
290  }
291  vertexingOptions.useConstraintInFit = m_useBeamConstraint;
292 
293  //Adding 4th dimensional timing info to vertex constraint as needed by ACTS
294  Acts::Vector4 vtxConstraintPos;
295  Acts::SquareMatrix4 vtxConstraintCov;
296 
297  auto beamSpotCov = beamSpotHandle->beamVtx().covariancePosition();
298 
299  vtxConstraintPos << beamSpotPos(0), beamSpotPos(1), beamSpotPos(2), 0.;
300  vtxConstraintCov << beamSpotCov(0,0), beamSpotCov(0,1), beamSpotCov(0,2), 0.
301  , beamSpotCov(1,0), beamSpotCov(1,1), beamSpotCov(1,2), 0.
302  , beamSpotCov(2,0), beamSpotCov(2,1), beamSpotCov(2,2), 0.
303  , 0., 0., 0., 1.;
304 
305  vertexingOptions.constraint.setFullPosition(vtxConstraintPos);
306  vertexingOptions.constraint.setFullCovariance(vtxConstraintCov);
307 
308  auto finderState = m_vertexFinder->makeState(magFieldContext);
309 
310  auto findResult = m_vertexFinder->find(allTrackPtrs, vertexingOptions, finderState);
311 
312  if(!findResult.ok()){
313  xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
314  theVertexContainer->push_back(dummyxAODVertex);
315  dummyxAODVertex->setPosition(beamSpotHandle->beamVtx().position());
316  dummyxAODVertex->setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
317  dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
318  dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
319 
320  return std::make_pair(theVertexContainer, theVertexAuxContainer);
321  }
322 
323  std::vector<Acts::Vertex> allVertices = *findResult;
324 
325  for(const auto& vtx : allVertices){
326  xAOD::Vertex* xAODVtx = new xAOD::Vertex;
327  xAODVtx->makePrivateStore();
328  xAODVtx->setPosition(vtx.position());
329  xAODVtx->setCovariancePosition(vtx.covariance());
330  xAODVtx->setFitQuality(vtx.fitQuality().first, vtx.fitQuality().second);
331 
332  const auto& tracks = vtx.tracks();
333  std::vector<Trk::VxTrackAtVertex>* trkAtVtxVec = &(xAODVtx->vxTrackAtVertex());
334  for(const auto& trk : tracks){
335 
336  Trk::Perigee* fittedPerigee = actsBoundToTrkPerigee(trk.fittedParams, beamSpotPos);
337  //Trk::Perigee* originalPerigee = actsBoundToTrkPerigee((trk.originalParams)->parameters(), beamSpotPos);
338  const TrackWrapper* originalParams = trk.originalParams.template as<TrackWrapper>();
339 
340  //Trk::VxTrackAtVertex trkAtVtx(trk.chi2Track, fittedPerigee, originalPerigee);
341  Trk::VxTrackAtVertex trkAtVtx(originalParams->trackLink()->clone());
342  trkAtVtx.setPerigeeAtVertex(fittedPerigee);
343  trkAtVtx.setTrackQuality(Trk::FitQuality(trk.chi2Track, trk.ndf));
344  trkAtVtx.setVtxCompatibility(trk.vertexCompatibility);
345  trkAtVtx.setWeight(trk.trackWeight);
346  trkAtVtxVec->push_back(trkAtVtx);
347 
348  const Trk::LinkToXAODTrackParticle* linkToXAODTP =
349  dynamic_cast<const Trk::LinkToXAODTrackParticle*>(originalParams->trackLink());
350  if (linkToXAODTP) {
351  xAODVtx->addTrackAtVertex(*linkToXAODTP, trk.trackWeight);
352  }
353  }
354 
355  theVertexContainer->push_back(xAODVtx);
356  }
357 
358  if (!m_createSplitVertices) {
359  if (!theVertexContainer->empty()) {
360  xAOD::Vertex* primaryVtx = theVertexContainer->front();
361  if (!primaryVtx->vxTrackAtVertex().empty()) {
362  primaryVtx->setVertexType((xAOD::VxType::VertexType)Trk::PriVtx);
363  xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
364  theVertexContainer->push_back(dummyxAODVertex);
365  dummyxAODVertex->setPosition(primaryVtx->position());
366  dummyxAODVertex->setCovariancePosition(primaryVtx->covariancePosition());
367  dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
368  dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
369  } else {
370  primaryVtx->setVertexType(xAOD::VxType::NoVtx);
371  }
372  } else {
373  xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
374  theVertexContainer->push_back(dummyxAODVertex);
375  dummyxAODVertex->setPosition(beamSpotHandle->beamVtx().position());
376  dummyxAODVertex->setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
377  dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
378  dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
379  }
380 
381  // loop over the pile up to set it as pile up (EXCLUDE first and last
382  // vertex, do not do that in split mode)
383  for (unsigned int i = 0; i < theVertexContainer->size() - 1; i++) {
384 
385  ATH_MSG_DEBUG(
386  " Vtx: " << i << " x= " << (*theVertexContainer)[i]->position().x()
387  << " y= " << (*theVertexContainer)[i]->position().y() << " z= "
388  << (*theVertexContainer)[i]->position().z() << " ntracks= "
389  << (*theVertexContainer)[i]->vxTrackAtVertex().size()
390  << " chi2= " << (*theVertexContainer)[i]->chiSquared()
391  << " ndf = " << (*theVertexContainer)[i]->numberDoF());
392  if (i > 0) {
393  (*theVertexContainer)[i]->setVertexType(xAOD::VxType::PileUp);
394  }
395  }
396  }
397 
398  return std::make_pair(theVertexContainer, theVertexAuxContainer);
399 }
400 
401 Trk::Perigee*
402 ActsTrk::IterativePriVtxFinderTool::actsBoundToTrkPerigee(const Acts::BoundTrackParameters& bound,
403  const Acts::Vector3& surfCenter) const {
404  using namespace Acts::UnitLiterals;
405  AmgSymMatrix(5) cov = AmgSymMatrix(5)(bound.covariance()->block<5,5>(0,0));
406  cov.col(Trk::qOverP) *= 1_MeV;
407  cov.row(Trk::qOverP) *= 1_MeV;
408  Acts::ActsVector<5> params = bound.parameters().head<5>();
409  params[Trk::qOverP] *= 1_MeV;
410 
411  return new Trk::Perigee(params, Trk::PerigeeSurface(surfCenter), std::move(cov));
412 }
operator<
bool operator<(const DataVector< T > &a, const DataVector< T > &b)
Vector ordering relation.
LArSamples::FitterData::fitter
const ShapeFitter * fitter
Definition: ShapeFitter.cxx:23
Trk::Vertex
Definition: Tracking/TrkEvent/VxVertex/VxVertex/Vertex.h:26
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
xAOD::Vertex_v1::setPosition
void setPosition(const Amg::Vector3D &position)
Sets the 3-position.
ActsTrk::IterativePriVtxFinderTool::initialize
virtual StatusCode initialize() override
Definition: IterativePriVtxFinderTool.cxx:49
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
xAOD::Vertex_v1::setFitQuality
void setFitQuality(float chiSquared, float numberDoF)
Set the 'Fit Quality' information.
Definition: Vertex_v1.cxx:150
xAOD::VertexAuxContainer_v1
Temporary container used until we have I/O for AuxStoreInternal.
Definition: VertexAuxContainer_v1.h:32
Trk::VxTrackAtVertex
The VxTrackAtVertex is a common class for all present TrkVertexFitters The VxTrackAtVertex is designe...
Definition: VxTrackAtVertex.h:77
xAOD::Vertex
Vertex_v1 Vertex
Define the latest version of the vertex class.
Definition: Event/xAOD/xAODTracking/xAODTracking/Vertex.h:16
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Trk::PerigeeSurface
Definition: PerigeeSurface.h:43
IterativePriVtxFinderTool.h
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
ActsTrk::IterativePriVtxFinderTool::VertexFitter
Acts::FullBilloirVertexFitter VertexFitter
Definition: IterativePriVtxFinderTool.h:121
ActsTrk::IterativePriVtxFinderTool::TrackWrapper::trackLink
const Trk::ITrackLink * trackLink() const
Definition: IterativePriVtxFinderTool.h:71
plotBeamSpotVxVal.cov
cov
Definition: plotBeamSpotVxVal.py:201
Trk::Perigee
ParametersT< 5, Charged, PerigeeSurface > Perigee
Definition: Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h:29
Trk::VxTrackAtVertex::setVtxCompatibility
void setVtxCompatibility(const double)
xAOD::pion
@ pion
Definition: TrackingPrimitives.h:196
bound
@ bound
Definition: L1CaloPprPlotManager.h:74
ActsTrk::IterativePriVtxFinderTool::TrackWrapper
Definition: IterativePriVtxFinderTool.h:62
xAOD::Vertex_v1::position
const Amg::Vector3D & position() const
Returns the 3-pos.
xAOD::VertexContainer
VertexContainer_v1 VertexContainer
Definition of the current "Vertex container version".
Definition: VertexContainer.h:14
x
#define x
Trk::VxTrackAtVertex::setWeight
void setWeight(const double)
Set method for a weight.
xAOD::VxType::NoVtx
@ NoVtx
Dummy vertex. TrackParticle was not used in vertex fit.
Definition: TrackingPrimitives.h:570
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:52
Trk::RecVertex
Trk::RecVertex inherits from Trk::Vertex.
Definition: RecVertex.h:44
xAOD::VxType::VertexType
VertexType
Vertex types.
Definition: TrackingPrimitives.h:569
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
xAOD::Vertex_v1::setVertexType
void setVertexType(VxType::VertexType vType)
Set the type of the vertex.
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
ActsTrk::IterativePriVtxFinderTool::actsBoundToTrkPerigee
Trk::Perigee * actsBoundToTrkPerigee(const Acts::BoundTrackParameters &bound, const Acts::Vector3 &surfCenter) const
Definition: IterativePriVtxFinderTool.cxx:402
xAOD::Vertex_v1::addTrackAtVertex
void addTrackAtVertex(const ElementLink< TrackParticleContainer > &tr, float weight=1.0)
Add a new track to the vertex.
Definition: Vertex_v1.cxx:314
LinkToXAODTrackParticle.h
xAOD::VertexAuxContainer
VertexAuxContainer_v1 VertexAuxContainer
Definition of the current jet auxiliary container.
Definition: VertexAuxContainer.h:19
lumiFormat.i
int i
Definition: lumiFormat.py:92
z
#define z
ActsTrackingGeometryTool.h
Trk::VxTrackAtVertex::setTrackQuality
void setTrackQuality(const FitQuality &trkQuality)
Set methods for various components.
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
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
DataVector::front
const T * front() const
Access the first element in the collection as an rvalue.
test_pyathena.parent
parent
Definition: test_pyathena.py:15
Trk::LinkToXAODTrackParticle
Element link to XAOD TrackParticle.
Definition: LinkToXAODTrackParticle.h:33
ActsTrk::IterativePriVtxFinderTool::IterativePriVtxFinderTool
IterativePriVtxFinderTool(const std::string &type, const std::string &name, const IInterface *parent)
Constructor.
Definition: IterativePriVtxFinderTool.cxx:42
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Trk::FitQuality
Class to represent and store fit qualities from track reconstruction in terms of and number of degre...
Definition: FitQuality.h:97
DataVector< Trk::Track >
LinkToTrackParticleBase.h
xAOD::VxType::PileUp
@ PileUp
Pile-up vertex.
Definition: TrackingPrimitives.h:573
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::AuxElement::makePrivateStore
void makePrivateStore()
Create a new (empty) private store for this object.
Definition: AuxElement.cxx:172
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
IDTPM::chiSquared
float chiSquared(const U &p)
Definition: TrackParametersHelper.h:136
InDetDD::other
@ other
Definition: InDetDD_Defs.h:16
y
#define y
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
DeMoScan.first
bool first
Definition: DeMoScan.py:534
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:73
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
Trk::PriVtx
@ PriVtx
Primary Vertex.
Definition: VertexType.h:27
xAOD::Vertex_v1::vxTrackAtVertex
std::vector< Trk::VxTrackAtVertex > & vxTrackAtVertex()
Non-const access to the VxTrackAtVertex vector.
Definition: Vertex_v1.cxx:181
PowhegControl_ttFCNC_NLO.params
params
Definition: PowhegControl_ttFCNC_NLO.py:226
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
xAOD::Vertex_v1::setCovariancePosition
void setCovariancePosition(const AmgSymMatrix(3)&covariancePosition)
Sets the vertex covariance matrix.
Trk::VxTrackAtVertex::setPerigeeAtVertex
void setPerigeeAtVertex(TrackParameters *perigee)
Setting up parameters at vertex.
Definition: VxTrackAtVertex.cxx:396
ActsTrackingGeometrySvc.h
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
TrackParticleContainer.h
python.iconfTool.gui.pad.logger
logger
Definition: pad.py:14
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
ActsTrk::IterativePriVtxFinderTool::findVertex
virtual std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * > findVertex(const EventContext &ctx, const TrackCollection *trackTES) const override
Definition: IterativePriVtxFinderTool.cxx:128
Generated on Tue Jul 2 2024 21:18:07 for ATLAS Offline Software by   doxygen 1.8.18