Loading [MathJax]/jax/input/TeX/config.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
AdaptiveMultiPriVtxFinderTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "src/AdaptiveMultiPriVtxFinderTool.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/Surfaces/PerigeeSurface.hpp"
23 #include "Acts/Vertexing/TrackAtVertex.hpp"
24 
25 #include "Acts/Vertexing/GaussianGridTrackDensity.hpp"
26 #include "Acts/Vertexing/GridDensityVertexFinder.hpp"
27 #include "Acts/Vertexing/GaussianTrackDensity.hpp"
28 
29 
30 // STL
31 #include <iostream>
32 #include <memory>
33 
34 namespace
35 {
36  // Helper struct for vertex signal compatibility
37  struct VertexAndSignalComp {
38  xAOD::Vertex* first;
39  double second;
40  VertexAndSignalComp(xAOD::Vertex* p1, double p2)
41  : first(p1), second(p2) {}
42  bool
43  operator < (const VertexAndSignalComp& other) const
44  {return second > other.second;}
45  };
46 } //anonymous namespace
47 
48 ActsTrk::AdaptiveMultiPriVtxFinderTool::AdaptiveMultiPriVtxFinderTool(const std::string& type,
49  const std::string& name,
50  const IInterface* parent)
51  : base_class(type, name, parent)
52 {}
53 
54 StatusCode
55 ActsTrk::AdaptiveMultiPriVtxFinderTool::initialize()
56 {
57  using namespace std::literals::string_literals;
58 
59  ATH_CHECK(m_beamSpotKey.initialize());
60  ATH_CHECK(m_trkFilter.retrieve());
61 
62  ATH_MSG_INFO("Initializing ACTS AMVF tool");
63  ATH_CHECK( m_trackingGeometryTool.retrieve() );
64  std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry
65  = m_trackingGeometryTool->trackingGeometry();
66 
67  ATH_CHECK( m_extrapolationTool.retrieve() );
68 
69  // Logger
70  m_logger = makeActsAthenaLogger(this, "Acts");
71 
72  Acts::Navigator navigator( Acts::Navigator::Config{ trackingGeometry },
73  logger().cloneWithSuffix("Navigator"));
74 
75  auto bField = std::make_shared<ATLASMagneticFieldWrapper>();
76  auto stepper = Acts::EigenStepper<>(bField);
77  m_propagator = std::make_shared<Propagator>(std::move(stepper),
78  std::move(navigator),
79  logger().cloneWithSuffix("Prop"));
80 
81  // IP Estimator
82  Acts::ImpactPointEstimator::Config ipEstCfg(bField, m_propagator);
83  ipEstCfg.maxIterations = m_ipEstMaxIterations;
84  ipEstCfg.precision = m_ipEstPrecision;
85  Acts::ImpactPointEstimator ipEst(ipEstCfg,
86  logger().cloneWithSuffix("ImpactPointEstimator"));
87 
88  Acts::AnnealingUtility::Config annealingConfig;
89  annealingConfig.setOfTemperatures = m_annealingTemps;
90  annealingConfig.cutOff = m_annealingCutOff;
91  Acts::AnnealingUtility annealingUtility(annealingConfig);
92 
93  // Linearizer for Acts::BoundParameters type test
94  TrackLinearizer::Config ltConfig;
95  ltConfig.bField = bField;
96  ltConfig.propagator = m_propagator;
97  m_linearizer.emplace(ltConfig, logger().cloneWithSuffix("Linearizer"));
98 
99  // Vertex fitter configuration
100  VertexFitter::Config fitterCfg(ipEst);
101  fitterCfg.annealingTool = annealingUtility;
102  fitterCfg.maxIterations = m_fitterMaxIterations;
103  fitterCfg.maxDistToLinPoint = m_fitterMaxDistToLinPoint;
104  fitterCfg.minWeight = m_minWeightFitter;
105  fitterCfg.maxRelativeShift = m_fitterMaxRelativeShift;
106  fitterCfg.doSmoothing = m_fitterDoSmoothing;
107  fitterCfg.extractParameters.connect<&TrackWrapper::extractParameters>();
108  fitterCfg.trackLinearizer.connect<&TrackLinearizer::linearizeTrack>(&*m_linearizer);
109  VertexFitter fitter(fitterCfg, logger().cloneWithSuffix("Fitter"));
110 
111  std::string seederType = m_seederType;
112 
113  if (seederType == "Grid") {
114  Acts::GaussianGridTrackDensity::Config trackDensityConfig;
115  trackDensityConfig.mainGridSize = m_gridMainGridSize;
116  trackDensityConfig.trkGridSize = m_gridTrkGridSize;
117  trackDensityConfig.useHighestSumZPosition = m_gridUseHighestSumZPosition;
118  Acts::GaussianGridTrackDensity trackDensity(trackDensityConfig);
119 
120  Acts::GridDensityVertexFinder::Config gridSeedFinderConfig(trackDensity);
121  gridSeedFinderConfig.extractParameters.connect<&TrackWrapper::extractParameters>();
122  gridSeedFinderConfig.maxD0TrackSignificance = m_gridMaxD0Significance;
123  gridSeedFinderConfig.maxZ0TrackSignificance = m_gridMaxZ0Significance;
124 
125  Acts::GridDensityVertexFinder gridSeedFinder(gridSeedFinderConfig);
126 
127  VertexFinder::Config finderConfig(
128  std::move(fitter),
129  std::make_shared<Acts::GridDensityVertexFinder>(gridSeedFinder),
130  ipEst,
131  bField
132  );
133 
134  initializeVertexFinder(finderConfig);
135  }
136  else if (seederType == "Gaussian") {
137  Acts::GaussianTrackDensity::Config trackDensityConfig;
138  trackDensityConfig.d0MaxSignificance = m_gaussianMaxD0Significance;
139  trackDensityConfig.z0MaxSignificance = m_gaussianMaxZ0Significance;
140  trackDensityConfig.extractParameters.connect<&TrackWrapper::extractParameters>();
141 
142  Acts::GaussianTrackDensity trackDensity(trackDensityConfig);
143  VertexSeedFinder::Config seedFinderConfig(trackDensity);
144  auto seedFinder = std::make_shared<VertexSeedFinder>(seedFinderConfig);
145 
146  VertexFinder::Config finderConfig(
147  std::move(fitter),
148  seedFinder,
149  ipEst,
150  bField
151  );
152 
153  initializeVertexFinder(finderConfig);
154  }
155  else {
156  ATH_MSG_ERROR("Unknown seederType '" << seederType << "'.");
157  return StatusCode::FAILURE;
158  }
159 
160  ATH_MSG_INFO("ACTS AMVF tool successfully initialized");
161  return StatusCode::SUCCESS;
162  }
163 
164  void
165  ActsTrk::AdaptiveMultiPriVtxFinderTool::initializeVertexFinder(VertexFinder::Config& finderConfig)
166  {
167 
168  finderConfig.tracksMaxZinterval = m_tracksMaxZinterval;
169  finderConfig.tracksMaxSignificance = m_tracksMaxSignificance;
170  finderConfig.maxVertexChi2 = m_maxVertexChi2;
171  finderConfig.doRealMultiVertex = m_doRealMultiVertex;
172  finderConfig.useFastCompatibility = m_useFastCompatibility;
173  finderConfig.maxMergeVertexSignificance = m_maxMergeVertexSignificance;
174  finderConfig.minWeight = m_minWeight;
175  finderConfig.maxIterations = m_maxIterations;
176  finderConfig.addSingleTrackVertices = m_addSingleTrackVertices;
177  finderConfig.doFullSplitting = m_doFullSplitting;
178  finderConfig.maximumVertexContamination = m_maximumVertexContamination;
179  finderConfig.initialVariances = Acts::Vector4::Constant(m_looseConstrValue);
180  finderConfig.useVertexCovForIPEstimation = m_useVertexCovForIPEstimation;
181  finderConfig.useSeedConstraint = m_useSeedConstraint;
182 
183  finderConfig.extractParameters.connect<&TrackWrapper::extractParameters>();
184 
185  m_vertexFinder = std::make_shared<VertexFinder>(
186  std::move(finderConfig),
187  logger().cloneWithSuffix("Finder"));
188 }
189 
190 std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*>
191 ActsTrk::AdaptiveMultiPriVtxFinderTool::findVertex(const EventContext& ctx,
192  const TrackCollection* trackTES) const
193 {
194  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx};
195  const Trk::RecVertex& beamposition(beamSpotHandle->beamVtx());
196 
197  std::vector<std::unique_ptr<Trk::ITrackLink>> selectedTracks;
198 
199  typedef DataVector<Trk::Track>::const_iterator TrackDataVecIter;
200 
201  bool selectionPassed;
202  for (TrackDataVecIter itr = (*trackTES).begin(); itr != (*trackTES).end(); ++itr) {
203  if (m_useBeamConstraint) {
204  selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &beamposition));
205  } else {
206  Trk::Vertex null(Amg::Vector3D(0, 0, 0));
207  selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &null));
208  }
209  if (selectionPassed) {
210  ElementLink<TrackCollection> link;
211  link.setElement(*itr);
212  auto trkPtr = std::make_unique<Trk::LinkToTrack>(link);
213  trkPtr->setStorableObject(*trackTES);
214  selectedTracks.push_back(std::move(trkPtr));
215  }
216  }
217 
218  std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> returnContainers = findVertex(ctx, std::move(selectedTracks));
219 
220  return returnContainers;
221 }
222 
223 std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*>
224 ActsTrk::AdaptiveMultiPriVtxFinderTool::findVertex(const EventContext& ctx,
225  const xAOD::TrackParticleContainer* trackParticles) const
226 {
227 
228  std::vector<std::unique_ptr<Trk::ITrackLink>> selectedTracks;
229  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx};
230  xAOD::Vertex beamposition;
231  beamposition.makePrivateStore();
232  beamposition.setPosition(beamSpotHandle->beamVtx().position());
233  beamposition.setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
234 
235  typedef DataVector<xAOD::TrackParticle>::const_iterator TrackParticleDataVecIter;
236 
237  bool selectionPassed;
238  for (TrackParticleDataVecIter itr = (*trackParticles).begin(); itr != (*trackParticles).end(); ++itr) {
239  if (m_useBeamConstraint) {
240  selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &beamposition));
241  } else {
242  xAOD::Vertex null;
243  null.makePrivateStore();
244  null.setPosition(Amg::Vector3D(0, 0, 0));
245  AmgSymMatrix(3) vertexError;
246  vertexError.setZero();
247  null.setCovariancePosition(vertexError);
248  selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &null));
249  }
250 
251  if (selectionPassed) {
252  ElementLink<xAOD::TrackParticleContainer> link;
253  link.setElement(*itr);
254  auto trkPtr = std::make_unique<Trk::LinkToXAODTrackParticle>(link);
255  trkPtr->setStorableObject(*trackParticles);
256  selectedTracks.push_back(std::move(trkPtr));
257  }
258  }
259 
260  std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> returnContainers = findVertex(ctx, std::move(selectedTracks));
261 
262  return returnContainers;
263 }
264 
265 
266 std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*>
267 ActsTrk::AdaptiveMultiPriVtxFinderTool::findVertex(const EventContext& ctx,
268  const std::vector<std::unique_ptr<Trk::ITrackLink>>& trackVector) const
269 {
270  using namespace Acts::UnitLiterals; // !!!
271 
272  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx};
273  const Acts::Vector3& beamSpotPos = beamSpotHandle->beamVtx().position();
274  Acts::Vertex beamSpotConstraintVtx(beamSpotPos);
275  beamSpotConstraintVtx.setCovariance(beamSpotHandle->beamVtx().covariancePosition());
276 
277  // Get the magnetic field context
278  Acts::MagneticFieldContext magFieldContext = m_extrapolationTool->getMagneticFieldContext(ctx);
279 
280  const auto& geoContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
281 
282  // The output vertex containers
283  xAOD::VertexContainer* theVertexContainer = new xAOD::VertexContainer;
284  xAOD::VertexAuxContainer* theVertexAuxContainer = new xAOD::VertexAuxContainer;
285  theVertexContainer->setStore(theVertexAuxContainer);
286 
287  if(trackVector.empty()){
288  xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
289  theVertexContainer->push_back(dummyxAODVertex);
290  dummyxAODVertex->setPosition(beamSpotHandle->beamVtx().position());
291  dummyxAODVertex->setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
292  dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
293 
294  return std::make_pair(theVertexContainer, theVertexAuxContainer);
295  }
296 
297  std::shared_ptr<Acts::PerigeeSurface> perigeeSurface =
298  Acts::Surface::makeShared<Acts::PerigeeSurface>((trackVector[0])->parameters()->associatedSurface().transform());
299 
300  // Convert tracks to Acts::BoundParameters
301  std::vector<TrackWrapper> allTracks;
302 
303  for (const auto& trk : trackVector) {
304  const auto& trkParams = trk->parameters();
305  const auto& params = trkParams->parameters();
306 
307  Acts::BoundVector actsParams;
308  actsParams << params(0), params(1), params(2), params(3), params(4)*1./(1_MeV), 0.;
309 
310  if(trkParams->covariance() == nullptr){
311  continue;
312  }
313 
314  auto cov = *(trkParams->covariance());
315 
316  // TODO: check if the following works as well:
317  // cov->col(4) *= 1./1_MeV;
318  // cov->row(4) *= 1./1_MeV;
319  Acts::BoundSquareMatrix covMat;
320  covMat << cov(0,0) , cov(0,1) , cov(0,2) , cov(0,3) , cov(0,4) *1./(1_MeV), 0
321  , cov(1,0) , cov(1,1) , cov(1,2) , cov(1,3) , cov(1,4) *1./(1_MeV) , 0
322  , cov(2,0) , cov(2,1) , cov(2,2) , cov(2,3) , cov(2,4) *1./(1_MeV) , 0
323  , cov(3,0) , cov(3,1) , cov(3,2) , cov(3,3) , cov(3,4) *1./(1_MeV) , 0
324  , 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
325  , 0. , 0. , 0. , 0., 0., 1.;
326 
327  allTracks.emplace_back(trk.get(),Acts::BoundTrackParameters(perigeeSurface, actsParams, covMat, Acts::ParticleHypothesis::pion()));
328  }
329 
330  std::vector<Acts::InputTrack> allTrackPtrs;
331  allTrackPtrs.reserve(allTracks.size());
332 
333  for(const auto& trk : allTracks){
334  allTrackPtrs.emplace_back(&trk);
335  }
336 
337  Acts::VertexingOptions vertexingOptions( geoContext, magFieldContext );
338 
339  if(!m_useBeamConstraint){
340  beamSpotConstraintVtx.setPosition(Acts::Vector3::Zero());
341  Amg::MatrixX looseConstraintCovariance(3, 3);
342  looseConstraintCovariance.setIdentity();
343  looseConstraintCovariance = looseConstraintCovariance * 1e+8;
344  beamSpotConstraintVtx.setCovariance(looseConstraintCovariance);
345  }
346 
347  vertexingOptions.useConstraintInFit = m_useBeamConstraint;
348  vertexingOptions.constraint = beamSpotConstraintVtx;
349 
350  auto finderState = m_vertexFinder->makeState(magFieldContext);
351 
352  auto findResult = m_vertexFinder->find(allTrackPtrs, vertexingOptions, finderState);
353 
354  if(!findResult.ok()){
355  xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
356  theVertexContainer->push_back(dummyxAODVertex);
357  dummyxAODVertex->setPosition(beamSpotHandle->beamVtx().position());
358  dummyxAODVertex->setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
359  dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
360  return std::make_pair(theVertexContainer, theVertexAuxContainer);
361  }
362 
363  std::vector<Acts::Vertex> allVertices = *findResult;
364 
365  std::vector<VertexAndSignalComp> vtxList;
366 
367  // Reserve memory for all vertices
368  vtxList.reserve(allVertices.size());
369 
370  for(const auto& vtx : allVertices){
371  //skip the vertex with negative covariance
372  if(vtx.covariance()(0,0)<0||vtx.covariance()(1,1)<0||vtx.covariance()(2,2)<0)
373  continue;
374  xAOD::Vertex* xAODVtx = new xAOD::Vertex;
375  xAODVtx->makePrivateStore();
376  xAODVtx->setPosition(vtx.position());
377  xAODVtx->setCovariancePosition(vtx.covariance());
378  xAODVtx->setFitQuality(vtx.fitQuality().first, vtx.fitQuality().second);
379 
380  const auto& tracks = vtx.tracks();
381  std::vector<Trk::VxTrackAtVertex>* trkAtVtxVec = &(xAODVtx->vxTrackAtVertex());
382  for(const auto& trk : tracks){
383 
384  // Clean up incompatible tracks
385  if ((trk.vertexCompatibility > m_maxVertexChi2 && m_useFastCompatibility) ||
386  ((trk.trackWeight < m_minWeight
387  || trk.chi2Track > m_maxVertexChi2)
388  && !m_useFastCompatibility)) {
389  continue;
390  }
391 
392  const TrackWrapper* originalParams = trk.originalParams.template as<TrackWrapper>();
393 
394  Trk::Perigee* fittedPerigee = actsBoundToTrkPerigee(trk.fittedParams, beamSpotPos);
395  Trk::VxTrackAtVertex trkAtVtx(originalParams->trackLink()->clone());
396  trkAtVtx.setPerigeeAtVertex(fittedPerigee);
397  trkAtVtx.setTrackQuality(Trk::FitQuality(trk.chi2Track, trk.ndf));
398  trkAtVtx.setVtxCompatibility(trk.vertexCompatibility);
399  trkAtVtx.setWeight(trk.trackWeight);
400  trkAtVtxVec->push_back(trkAtVtx);
401 
402  const Trk::LinkToXAODTrackParticle* linkToXAODTP =
403  dynamic_cast<const Trk::LinkToXAODTrackParticle*>(originalParams->trackLink());
404  if (linkToXAODTP) {
405  xAODVtx->addTrackAtVertex(*linkToXAODTP, trk.trackWeight);
406  }
407  }
408  // Find signal compatibility
409  double sigComp = estimateSignalCompatibility(xAODVtx);
410  // Insert vertex at correct position according to sigComp value
411  VertexAndSignalComp vertexAndSig(xAODVtx, sigComp);
412  auto it = std::lower_bound( vtxList.begin(), vtxList.end(), vertexAndSig );
413  vtxList.insert( it, vertexAndSig );
414  }
415 
416  for(unsigned int i = 0; i < vtxList.size(); i++){
417  auto vtx = vtxList[i].first;
418  theVertexContainer->push_back(vtx);
419  if(i == 0){
420  vtx->setVertexType(xAOD::VxType::PriVtx);
421  }
422  else{
423  vtx->setVertexType(xAOD::VxType::PileUp);
424  }
425  }
426 
427  // Add dummy vertex to collection
428  xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
429  theVertexContainer->push_back(dummyxAODVertex);
430 
431  if(!vtxList.empty()){
432  // If HS vertex exists, create dummy with same position/covariance
433  xAOD::Vertex* primaryVtx = theVertexContainer->front();
434  dummyxAODVertex->setPosition(primaryVtx->position());
435  dummyxAODVertex->setCovariancePosition(primaryVtx->covariancePosition());
436  dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
437  }
438  else{
439  dummyxAODVertex->setPosition(beamSpotHandle->beamVtx().position());
440  dummyxAODVertex->setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
441  dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
442  }
443 
444  return std::make_pair(theVertexContainer, theVertexAuxContainer);
445 }
446 
447 
448 Trk::Perigee*
449 ActsTrk::AdaptiveMultiPriVtxFinderTool::actsBoundToTrkPerigee(const Acts::BoundTrackParameters& bound,
450  const Acts::Vector3& surfCenter) const
451 {
452  using namespace Acts::UnitLiterals;
453  AmgSymMatrix(5) cov = AmgSymMatrix(5)(bound.covariance()->block<5,5>(0,0));
454  cov.col(Trk::qOverP) *= 1_MeV;
455  cov.row(Trk::qOverP) *= 1_MeV;
456  Acts::ActsVector<5> params = bound.parameters().head<5>();
457  params[Trk::qOverP] *= 1_MeV;
458 
459  return new Trk::Perigee(params, Trk::PerigeeSurface(surfCenter), std::move(cov));
460 }
461 
462 double
463 ActsTrk::AdaptiveMultiPriVtxFinderTool::estimateSignalCompatibility(xAOD::Vertex* vtx) const
464 {
465  double totalPt2 = 0;
466  unsigned int nTracks = 0;
467 
468  for(const auto& trk : vtx->vxTrackAtVertex()){
469  if ((trk.vtxCompatibility() < m_finalCutMaxVertexChi2 && m_useFastCompatibility) ||
470  (trk.weight() > m_minWeight
471  && trk.trackQuality().chiSquared() < m_finalCutMaxVertexChi2
472  && !m_useFastCompatibility)) {
473  const Trk::TrackParameters* perigee = nullptr;
474  if (trk.perigeeAtVertex() != nullptr) {
475  perigee = trk.perigeeAtVertex();
476  } else {
477  ATH_MSG_VERBOSE("Only initialPerigee is available");
478  perigee = trk.initialPerigee();
479  }
480  if (perigee == nullptr) {
481  ATH_MSG_ERROR("Neutrals are not supported. Skipping track in pT calculation...");
482  continue;
483  }
484  totalPt2 +=
485  std::pow(std::fabs(1. / perigee->parameters()[Trk::qOverP]) * std::sin(perigee->parameters()[Trk::theta]), 2);
486  nTracks += 1;
487  }
488  }
489  return totalPt2 * std::sqrt((double) nTracks);
490 }
operator<
bool operator<(const DataVector< T > &a, const DataVector< T > &b)
Vector ordering relation.
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
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.
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
Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition: EventPrimitives.h:27
ActsTrk::AdaptiveMultiPriVtxFinderTool::AdaptiveMultiPriVtxFinderTool
AdaptiveMultiPriVtxFinderTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: AdaptiveMultiPriVtxFinderTool.cxx:48
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
ActsTrk::AdaptiveMultiPriVtxFinderTool::TrackWrapper
Definition: AdaptiveMultiPriVtxFinderTool.h:58
Trk::PerigeeSurface
Definition: PerigeeSurface.h:43
ActsTrk::detail::Navigator
Acts::Navigator Navigator
Definition: Tracking/Acts/ActsTrackReconstruction/src/detail/Definitions.h:32
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
TRTCalib_cfilter.p1
p1
Definition: TRTCalib_cfilter.py:130
skel.it
it
Definition: skel.GENtoEVGEN.py:407
plotBeamSpotVxVal.cov
cov
Definition: plotBeamSpotVxVal.py:201
Trk::VxTrackAtVertex::setVtxCompatibility
void setVtxCompatibility(const double)
xAOD::pion
@ pion
Definition: TrackingPrimitives.h:197
xAOD::Vertex_v1::position
const Amg::Vector3D & position() const
Returns the 3-pos.
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
xAOD::VertexContainer
VertexContainer_v1 VertexContainer
Definition of the current "Vertex container version".
Definition: VertexContainer.h:14
Trk::Perigee
ParametersT< TrackParametersDim, Charged, PerigeeSurface > Perigee
Definition: Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h:33
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:571
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:50
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
Trk::RecVertex
Trk::RecVertex inherits from Trk::Vertex.
Definition: RecVertex.h:44
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.
TRTCalib_cfilter.p2
p2
Definition: TRTCalib_cfilter.py:131
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
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
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:85
ActsTrk::AdaptiveMultiPriVtxFinderTool::VertexFitter
Acts::AdaptiveMultiVertexFitter VertexFitter
Definition: AdaptiveMultiPriVtxFinderTool.h:120
ActsTrackingGeometryTool.h
Trk::VxTrackAtVertex::setTrackQuality
void setTrackQuality(const FitQuality &trkQuality)
Set methods for various components.
Trk::theta
@ theta
Definition: ParamDefs.h:66
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
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
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
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
Trk::ParametersBase
Definition: ParametersBase.h:55
ActsTrk::AdaptiveMultiPriVtxFinderTool::estimateSignalCompatibility
double estimateSignalCompatibility(xAOD::Vertex *vtx) const
Definition: AdaptiveMultiPriVtxFinderTool.cxx:463
DataVector< Trk::Track >
LinkToTrackParticleBase.h
xAOD::VxType::PileUp
@ PileUp
Pile-up vertex.
Definition: TrackingPrimitives.h:574
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
AdaptiveMultiPriVtxFinderTool.h
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:192
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
ActsTrk::AdaptiveMultiPriVtxFinderTool::initializeVertexFinder
void initializeVertexFinder(VertexFinder::Config &finderConfig)
Definition: AdaptiveMultiPriVtxFinderTool.cxx:165
InDetDD::other
@ other
Definition: InDetDD_Defs.h:16
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
DeMoScan.first
bool first
Definition: DeMoScan.py:536
ActsTrk::AdaptiveMultiPriVtxFinderTool::initialize
virtual StatusCode initialize() override
Definition: AdaptiveMultiPriVtxFinderTool.cxx:55
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:67
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
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
ActsTrk::AdaptiveMultiPriVtxFinderTool::TrackWrapper::trackLink
const Trk::ITrackLink * trackLink() const
Definition: AdaptiveMultiPriVtxFinderTool.h:67
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
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
ActsTrk::AdaptiveMultiPriVtxFinderTool::findVertex
virtual std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * > findVertex(const EventContext &ctx, const TrackCollection *trackTES) const override
Definition: AdaptiveMultiPriVtxFinderTool.cxx:191
TrackParticleContainer.h
python.iconfTool.gui.pad.logger
logger
Definition: pad.py:14
ActsTrk::AdaptiveMultiPriVtxFinderTool::actsBoundToTrkPerigee
Trk::Perigee * actsBoundToTrkPerigee(const Acts::BoundTrackParameters &bound, const Acts::Vector3 &surfCenter) const
Definition: AdaptiveMultiPriVtxFinderTool.cxx:449
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
Generated on Wed Mar 26 2025 21:06:49 for ATLAS Offline Software by   doxygen 1.8.18