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