ActsTrk::IterativePriVtxFinderTool Class Reference

#include <IterativePriVtxFinderTool.h>

Inheritance diagram for ActsTrk::IterativePriVtxFinderTool:

Collaboration diagram for ActsTrk::IterativePriVtxFinderTool:

Classes
class	TrackWrapper

Public Member Functions
virtual StatusCode	initialize () override
	IterativePriVtxFinderTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor.
virtual std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * >	findVertex (const EventContext &ctx, const TrackCollection *trackTES) const override
virtual std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * >	findVertex (const EventContext &ctx, const xAOD::TrackParticleContainer *trackParticles) const override

Private Types
using	Propagator = Acts::Propagator<Acts::EigenStepper<>, Acts::Navigator>
using	TrackLinearizer = Acts::HelicalTrackLinearizer
using	VertexFitter = Acts::FullBilloirVertexFitter
using	VertexSeedFinder = Acts::TrackDensityVertexFinder
using	VertexFinder = Acts::IterativeVertexFinder

Private Member Functions
const Acts::Logger &	logger () const
std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * >	findVertex (const EventContext &ctx, const std::vector< std::unique_ptr< Trk::ITrackLink > > &trackVector) const
Trk::Perigee *	actsBoundToTrkPerigee (const Acts::BoundTrackParameters &bound, const Acts::Vector3 &surfCenter) const
virtual const ActsTrk::ITrackingGeometryTool *	trackingGeometryTool () const

Private Attributes
std::unique_ptr< const Acts::Logger >	m_logger {nullptr}
	logging instance
std::shared_ptr< VertexFinder >	m_vertexFinder = nullptr
std::shared_ptr< ATLASMagneticFieldWrapper >	m_bField = nullptr
std::shared_ptr< Propagator >	m_propagator = nullptr
std::optional< TrackLinearizer >	m_linearizer = std::nullopt
PublicToolHandle< ITrackingGeometryTool >	m_trackingGeometryTool {this, "TrackingGeometryTool", "", "ActsTrackingGeometryTool"}
ToolHandle< IExtrapolationTool >	m_extrapolationTool {this, "ExtrapolationTool", "", "ActsExtrapolationTool"}
ToolHandle< InDet::IInDetTrackSelectionTool >	m_trkFilter {this, "TrackSelector", "", "InDetTrackSelectionTool"}
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}
UnsignedIntegerProperty	m_fitterMaxIterations {this, "fitterMaxIterations", 5, "Vertex fitter max. iterations"}
BooleanProperty	m_useBeamConstraint {this, "useBeamConstraint", true, "Use beam constraint"}
DoubleProperty	m_significanceCutSeeding {this, "significanceCutSeeding", 10, "Seeding Cut Significance"}
DoubleProperty	m_maximumChi2cutForSeeding {this, "maximumChi2cutForSeeding", 36., "Max. Chi2 cut for seeding"}
UnsignedIntegerProperty	m_maxVertices {this, "maxVertices", 50, "Max number of vertices"}
BooleanProperty	m_createSplitVertices {this, "createSplitVertices", false, "Create split vertices or not"}
UnsignedIntegerProperty	m_splitVerticesTrkInvFraction {this, "splitVerticesTrkInvFraction", 2, "Track Inv. fraction for split vertices"}
BooleanProperty	m_reassignTracksAfterFirstFit {this, "reassignTracksAfterFirstFit", false, "Whether re-assign tracks after first vertex fit or not"}
BooleanProperty	m_doMaxTracksCut {this, "doMaxTracksCut", false, "Whether use max. tracks cut or not"}
UnsignedIntegerProperty	m_maxTracks {this, "maxTracks", 5000, "Max. number of tracks to use for vertex finding"}
DoubleProperty	m_cutOffTrackWeight {this, "cutOffTrackWeight", 0.01, "Min. track weight allowed"}
DoubleProperty	m_gaussianMaxD0Significance {this, "gaussianMaxD0Significance", 3.5, "Gaussian seeder max d0 track significance"}
DoubleProperty	m_gaussianMaxZ0Significance {this, "gaussianMaxDZSignificance", 12.0, "Gaussian seeder max z0 track significance"}
UnsignedIntegerProperty	m_ipEstMaxIterations {this, "ipEstMaxIterations", 20, "IpEstimator max. iterations"}
DoubleProperty	m_ipEstPrecision {this, "ipEstPrecision", 1e-10, "IpEstimator precision"}

Detailed Description

Definition at line 58 of file IterativePriVtxFinderTool.h.

Member Typedef Documentation

Propagator

using ActsTrk::IterativePriVtxFinderTool::Propagator = Acts::Propagator<Acts::EigenStepper<>, Acts::Navigator>

private

Definition at line 117 of file IterativePriVtxFinderTool.h.

TrackLinearizer

using ActsTrk::IterativePriVtxFinderTool::TrackLinearizer = Acts::HelicalTrackLinearizer

private

Definition at line 118 of file IterativePriVtxFinderTool.h.

VertexFinder

using ActsTrk::IterativePriVtxFinderTool::VertexFinder = Acts::IterativeVertexFinder

private

Definition at line 121 of file IterativePriVtxFinderTool.h.

VertexFitter

using ActsTrk::IterativePriVtxFinderTool::VertexFitter = Acts::FullBilloirVertexFitter

private

Definition at line 119 of file IterativePriVtxFinderTool.h.

VertexSeedFinder

using ActsTrk::IterativePriVtxFinderTool::VertexSeedFinder = Acts::TrackDensityVertexFinder

private

Definition at line 120 of file IterativePriVtxFinderTool.h.

Constructor & Destructor Documentation

IterativePriVtxFinderTool()

ActsTrk::IterativePriVtxFinderTool::IterativePriVtxFinderTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Constructor.

Definition at line 39 of file IterativePriVtxFinderTool.cxx.

  : base_class(type, name, parent)
{}

Member Function Documentation

actsBoundToTrkPerigee()

Trk::Perigee * ActsTrk::IterativePriVtxFinderTool::actsBoundToTrkPerigee ( const Acts::BoundTrackParameters & bound, const Acts::Vector3 & surfCenter ) const

private

Definition at line 399 of file IterativePriVtxFinderTool.cxx.

                                                                                               {
  using namespace Acts::UnitLiterals;
  AmgSymMatrix(5) cov =  AmgSymMatrix(5)(bound.covariance()->block<5,5>(0,0));
  cov.col(Trk::qOverP) *= 1_MeV;
  cov.row(Trk::qOverP) *= 1_MeV;
  Acts::Vector<5> params = bound.parameters().head<5>();
  params[Trk::qOverP] *= 1_MeV;
 
  return new Trk::Perigee(params, Trk::PerigeeSurface(surfCenter), std::move(cov));
}

findVertex() [1/3]

std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * > ActsTrk::IterativePriVtxFinderTool::findVertex ( const EventContext & ctx, const std::vector< std::unique_ptr< Trk::ITrackLink > > & trackVector ) const

private

Definition at line 201 of file IterativePriVtxFinderTool.cxx.

{
 
  using namespace Acts::UnitLiterals;
 
  // Vertex finding algorithm begins 
  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx};
 
  // The output vertex containers
  xAOD::VertexContainer* theVertexContainer = new xAOD::VertexContainer;
  xAOD::VertexAuxContainer* theVertexAuxContainer = new xAOD::VertexAuxContainer;
  theVertexContainer->setStore(theVertexAuxContainer);
            
  // bail out early with only Dummy vertex if multiplicity cut is applied and exceeded
  if((m_doMaxTracksCut && (trackVector.size() > m_maxTracks)) || trackVector.empty()) {
    ATH_MSG_WARNING(trackVector.size()
                    << " tracks - exceeds maximum (" << m_maxTracks
                    << "), skipping vertexing and returning only dummy...");
    xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
    theVertexContainer->push_back(
                  dummyxAODVertex); // have to add vertex to container here first so it can use its aux store
    dummyxAODVertex->setPosition(beamSpotHandle->beamVtx().position());
    dummyxAODVertex->setCovariancePosition(
                       beamSpotHandle->beamVtx().covariancePosition());
    dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
    dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
    return std::make_pair(theVertexContainer, theVertexAuxContainer);
  }
 
  const Acts::Vector3& beamSpotPos = beamSpotHandle->beamVtx().position();
  Acts::Vertex beamSpotConstraintVtx(beamSpotPos);
  beamSpotConstraintVtx.setCovariance(beamSpotHandle->beamVtx().covariancePosition());
 
  std::shared_ptr<Acts::PerigeeSurface> perigeeSurface =
    Acts::Surface::makeShared<Acts::PerigeeSurface>((trackVector[0])->parameters()->associatedSurface().transform());
 
  // Get the magnetic field context
  Acts::MagneticFieldContext magFieldContext = m_extrapolationTool->getMagneticFieldContext(ctx);
 
  const auto& geoContext
    = m_trackingGeometryTool->getGeometryContext(ctx).context();
  
  // Convert tracks to Acts::BoundParameters
  std::vector<TrackWrapper> allTracks;
 
  for (const auto& trk : trackVector) {
 
    const auto& trkParams = trk->parameters();
    const auto& params = trkParams->parameters();
 
    Acts::BoundVector actsParams;
    actsParams << params(0), params(1), params(2), params(3), params(4)*1./(1_MeV), 0.;
 
    if(trkParams->covariance() == nullptr){
      continue;
    }
    auto cov = *(trkParams->covariance());
      
    // TODO: check if the following works as well:
    // cov->col(4) *= 1./1_MeV;
    // cov->row(4) *= 1./1_MeV;
    Acts::BoundMatrix covMat;
    covMat << cov(0,0) , cov(0,1) , cov(0,2) , cov(0,3) , cov(0,4) *1./(1_MeV), 0      
      , cov(1,0) , cov(1,1) , cov(1,2) , cov(1,3) , cov(1,4) *1./(1_MeV) , 0
      , cov(2,0) , cov(2,1) , cov(2,2) , cov(2,3) , cov(2,4) *1./(1_MeV) , 0
      , cov(3,0) , cov(3,1) , cov(3,2) , cov(3,3) , cov(3,4) *1./(1_MeV) , 0 
      , 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
      , 0. , 0. , 0. , 0., 0., 1.;
 
    allTracks.emplace_back(trk.get(),Acts::BoundTrackParameters(perigeeSurface, actsParams, covMat, Acts::ParticleHypothesis::pion()));
  }
  
  std::vector<Acts::InputTrack> allTrackPtrs;
  allTrackPtrs.reserve(allTracks.size());
 
for(const auto& trk : allTracks){
    allTrackPtrs.emplace_back(&trk);
  }
  
  Acts::VertexingOptions vertexingOptions(geoContext,
                            magFieldContext);
 
  if(!m_useBeamConstraint){
    beamSpotConstraintVtx.setPosition(Acts::Vector3::Zero());
    beamSpotConstraintVtx.setCovariance(Acts::SquareMatrix<3>::Zero());
  }
  vertexingOptions.useConstraintInFit = m_useBeamConstraint;
 
  //Adding 4th dimensional timing info to vertex constraint as needed by ACTS
  Acts::Vector4 vtxConstraintPos;
  Acts::SquareMatrix4 vtxConstraintCov;
 
  auto beamSpotCov = beamSpotHandle->beamVtx().covariancePosition();
 
  vtxConstraintPos << beamSpotPos(0), beamSpotPos(1), beamSpotPos(2), 0.;
  vtxConstraintCov << beamSpotCov(0,0), beamSpotCov(0,1), beamSpotCov(0,2), 0.
    , beamSpotCov(1,0), beamSpotCov(1,1), beamSpotCov(1,2), 0.
    , beamSpotCov(2,0), beamSpotCov(2,1), beamSpotCov(2,2), 0.
    , 0., 0., 0., 1.;
                  
  vertexingOptions.constraint.setFullPosition(vtxConstraintPos);
  vertexingOptions.constraint.setFullCovariance(vtxConstraintCov);
 
  auto finderState = m_vertexFinder->makeState(magFieldContext);
 
  auto findResult = m_vertexFinder->find(allTrackPtrs, vertexingOptions, finderState);
 
  if(!findResult.ok()){
    xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
    theVertexContainer->push_back(dummyxAODVertex);
    dummyxAODVertex->setPosition(beamSpotHandle->beamVtx().position());
    dummyxAODVertex->setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
    dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
    dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
 
    return std::make_pair(theVertexContainer, theVertexAuxContainer);
  }
 
  std::vector<Acts::Vertex> allVertices = *findResult;
 
  for(const auto& vtx : allVertices){
    xAOD::Vertex* xAODVtx = new xAOD::Vertex;
    xAODVtx->makePrivateStore();
    xAODVtx->setPosition(vtx.position());
    xAODVtx->setCovariancePosition(vtx.covariance());
    xAODVtx->setFitQuality(vtx.fitQuality().first, vtx.fitQuality().second);
    
    const auto& tracks = vtx.tracks();
    std::vector<Trk::VxTrackAtVertex>* trkAtVtxVec = &(xAODVtx->vxTrackAtVertex());
    for(const auto& trk : tracks){
 
      Trk::Perigee* fittedPerigee = actsBoundToTrkPerigee(trk.fittedParams, beamSpotPos);
      //Trk::Perigee* originalPerigee = actsBoundToTrkPerigee((trk.originalParams)->parameters(), beamSpotPos);
      const TrackWrapper* originalParams = trk.originalParams.template as<TrackWrapper>();
 
      //Trk::VxTrackAtVertex trkAtVtx(trk.chi2Track, fittedPerigee, originalPerigee);
      Trk::VxTrackAtVertex trkAtVtx(originalParams->trackLink()->clone());
      trkAtVtx.setPerigeeAtVertex(fittedPerigee);
      trkAtVtx.setTrackQuality(Trk::FitQuality(trk.chi2Track, trk.ndf));
      trkAtVtx.setVtxCompatibility(trk.vertexCompatibility);
      trkAtVtx.setWeight(trk.trackWeight);
      trkAtVtxVec->push_back(trkAtVtx);
 
      const Trk::LinkToXAODTrackParticle* linkToXAODTP =
        dynamic_cast<const Trk::LinkToXAODTrackParticle*>(originalParams->trackLink());
      if (linkToXAODTP) {
    xAODVtx->addTrackAtVertex(*linkToXAODTP, trk.trackWeight);
      }
    }
 
    theVertexContainer->push_back(xAODVtx);
  }
 
  if (!m_createSplitVertices) {
    if (!theVertexContainer->empty()) {
      xAOD::Vertex* primaryVtx = theVertexContainer->front();
      if (!primaryVtx->vxTrackAtVertex().empty()) {
    primaryVtx->setVertexType((xAOD::VxType::VertexType)Trk::PriVtx);
    xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
    theVertexContainer->push_back(dummyxAODVertex);
    dummyxAODVertex->setPosition(primaryVtx->position());
    dummyxAODVertex->setCovariancePosition(primaryVtx->covariancePosition());
    dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
    dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
      } else {
    primaryVtx->setVertexType(xAOD::VxType::NoVtx);
      }
    } else {
      xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
      theVertexContainer->push_back(dummyxAODVertex);
      dummyxAODVertex->setPosition(beamSpotHandle->beamVtx().position());
      dummyxAODVertex->setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
      dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
      dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
    }
  
    // loop over the pile up to set it as pile up (EXCLUDE first and last
    // vertex, do not do that in split mode)
    for (unsigned int i = 0; i < theVertexContainer->size() - 1; i++) {
 
      ATH_MSG_DEBUG(
        " Vtx: " << i << " x= " << (*theVertexContainer)[i]->position().x()
                 << " y= " << (*theVertexContainer)[i]->position().y() << " z= "
                 << (*theVertexContainer)[i]->position().z() << " ntracks= "
                 << (*theVertexContainer)[i]->vxTrackAtVertex().size()
                 << " chi2= " << (*theVertexContainer)[i]->chiSquared()
                 << " ndf = " << (*theVertexContainer)[i]->numberDoF());
      if (i > 0) {
        (*theVertexContainer)[i]->setVertexType(xAOD::VxType::PileUp);
      }
    }
  }
 
  return std::make_pair(theVertexContainer, theVertexAuxContainer);
}

findVertex() [2/3]

std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * > ActsTrk::IterativePriVtxFinderTool::findVertex ( const EventContext & ctx, const TrackCollection * trackTES ) const

overridevirtual

Definition at line 125 of file IterativePriVtxFinderTool.cxx.

{
 
  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx};
  const Trk::RecVertex& beamposition(beamSpotHandle->beamVtx());
 
  std::vector<std::unique_ptr<Trk::ITrackLink>> selectedTracks;
 
  typedef DataVector<Trk::Track>::const_iterator TrackDataVecIter;
 
  bool selectionPassed;
  for (TrackDataVecIter itr = (*trackTES).begin(); itr != (*trackTES).end(); ++itr) {
    if (m_useBeamConstraint) {
      selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &beamposition));
    } else {
        Trk::Vertex null(Amg::Vector3D(0, 0, 0));
        selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &null));
    }
    if (selectionPassed) {
        ElementLink<TrackCollection> link;
        link.setElement(*itr);
        auto trkPtr = std::make_unique<Trk::LinkToTrack>(link);
        trkPtr->setStorableObject(*trackTES);
        selectedTracks.push_back(std::move(trkPtr));
    }
  }
 
  std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> returnContainers = findVertex(ctx, std::move(selectedTracks));
 
  return returnContainers;
}

findVertex() [3/3]

std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * > ActsTrk::IterativePriVtxFinderTool::findVertex ( const EventContext & ctx, const xAOD::TrackParticleContainer * trackParticles ) const

overridevirtual

Definition at line 159 of file IterativePriVtxFinderTool.cxx.

{
 
  std::vector<std::unique_ptr<Trk::ITrackLink>> selectedTracks;
  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx};
  xAOD::Vertex beamposition;
  beamposition.makePrivateStore();
  beamposition.setPosition(beamSpotHandle->beamVtx().position());
  beamposition.setCovariancePosition(beamSpotHandle->beamVtx().covariancePosition());
 
  typedef DataVector<xAOD::TrackParticle>::const_iterator TrackParticleDataVecIter;
 
  bool selectionPassed;
  for (TrackParticleDataVecIter itr = (*trackParticles).begin(); itr != (*trackParticles).end(); ++itr) {
    if (m_useBeamConstraint) {
      selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &beamposition));
    } else {
        xAOD::Vertex null;
        null.makePrivateStore();
        null.setPosition(Amg::Vector3D(0, 0, 0));
        AmgSymMatrix(3) vertexError;
        vertexError.setZero();
        null.setCovariancePosition(vertexError);
        selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &null));
    }
 
    if (selectionPassed) {
        ElementLink<xAOD::TrackParticleContainer> link;
        link.setElement(*itr);
        auto trkPtr = std::make_unique<Trk::LinkToXAODTrackParticle>(link);
        trkPtr->setStorableObject(*trackParticles);
        selectedTracks.push_back(std::move(trkPtr));
    }
  }
 
  std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> returnContainers = findVertex(ctx, std::move(selectedTracks));
 
  return returnContainers;
}

initialize()

StatusCode ActsTrk::IterativePriVtxFinderTool::initialize ( )

overridevirtual

Definition at line 46 of file IterativePriVtxFinderTool.cxx.

{
  using namespace std::literals::string_literals;
 
  ATH_CHECK(m_beamSpotKey.initialize());
  ATH_CHECK(m_trkFilter.retrieve());
 
  m_logger = makeActsAthenaLogger(this, "Acts");
  
  ATH_MSG_INFO("Initializing ACTS Iterative Vertex Finder tool");
  ATH_CHECK( m_trackingGeometryTool.retrieve() );
  std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry
    = m_trackingGeometryTool->trackingGeometry();
 
  ATH_CHECK( m_extrapolationTool.retrieve() );
 
  Acts::Navigator navigator( Acts::Navigator::Config{ trackingGeometry },
                 logger().cloneWithSuffix("Navigator"));
 
  m_bField = std::make_shared<ATLASMagneticFieldWrapper>();
  auto stepper = Acts::EigenStepper<>(m_bField);
  m_propagator = std::make_shared<Propagator>(std::move(stepper),
                          std::move(navigator),
                          logger().cloneWithSuffix("Prop"));
  // IP Estimator
  Acts::ImpactPointEstimator::Config ipEstCfg(m_bField, m_propagator);
  ipEstCfg.maxIterations = m_ipEstMaxIterations;
  ipEstCfg.precision = m_ipEstPrecision;
  Acts::ImpactPointEstimator ipEst(ipEstCfg,
                   logger().cloneWithSuffix("ImpactPointEstimator"));
 
  // Linearizer for Acts::BoundParameters type test
  TrackLinearizer::Config ltConfig;
  ltConfig.bField = m_bField;
  ltConfig.propagator = m_propagator;
  m_linearizer.emplace(ltConfig, logger().cloneWithSuffix("Linearizer"));
 
  // Full Billoir Vertex fitter setup
  VertexFitter::Config fitterCfg;
  fitterCfg.maxIterations = m_fitterMaxIterations;
  fitterCfg.extractParameters.connect<&TrackWrapper::extractParameters>();
  fitterCfg.trackLinearizer.connect<&TrackLinearizer::linearizeTrack>(&*m_linearizer);
  VertexFitter fitter(fitterCfg, logger().cloneWithSuffix("Fitter"));
 
 
  // Seed finder setup
  // Set up Gaussian track density
  Acts::GaussianTrackDensity::Config trackDensityConfig;
  trackDensityConfig.d0MaxSignificance = m_gaussianMaxD0Significance;
  trackDensityConfig.z0MaxSignificance = m_gaussianMaxZ0Significance;
  trackDensityConfig.extractParameters.connect<&TrackWrapper::extractParameters>();
  Acts::GaussianTrackDensity trackDensity(trackDensityConfig);
 
  // Vertex seed finder
  VertexSeedFinder::Config seedFinderConfig{trackDensity};
  auto seedFinder = std::make_shared<VertexSeedFinder>(seedFinderConfig);
    
  // Iterative Vertex Finder setup
  VertexFinder::Config finderConfig(std::move(fitter), 
                                    std::move(seedFinder), 
                                    ipEst);
  finderConfig.significanceCutSeeding = m_significanceCutSeeding;
  finderConfig.maximumChi2cutForSeeding = m_maximumChi2cutForSeeding;
  finderConfig.maxVertices = m_maxVertices;
  finderConfig.createSplitVertices = m_createSplitVertices;
  finderConfig.splitVerticesTrkInvFraction = m_splitVerticesTrkInvFraction;
  finderConfig.reassignTracksAfterFirstFit = m_reassignTracksAfterFirstFit;
  finderConfig.doMaxTracksCut = m_doMaxTracksCut;
  finderConfig.maxTracks = m_maxTracks;
  finderConfig.cutOffTrackWeight = m_cutOffTrackWeight;
  finderConfig.extractParameters.connect<&TrackWrapper::extractParameters>();
  finderConfig.trackLinearizer.connect<&TrackLinearizer::linearizeTrack>(&*m_linearizer);
  m_vertexFinder = std::make_shared<VertexFinder>(std::move(finderConfig), logger().cloneWithSuffix("Finder")); 
 
  ATH_MSG_INFO("ACTS Iterative Vertex Finder tool successfully initialized");
  return StatusCode::SUCCESS;
}

logger()

const Acts::Logger & ActsTrk::IterativePriVtxFinderTool::logger ( ) const

inlineprivate

Definition at line 102 of file IterativePriVtxFinderTool.h.

{ return *m_logger; }

trackingGeometryTool()

virtual const ActsTrk::ITrackingGeometryTool * ActsTrk::IterativePriVtxFinderTool::trackingGeometryTool ( ) const

inlineprivatevirtual

Definition at line 112 of file IterativePriVtxFinderTool.h.

    {
      return m_trackingGeometryTool.get();
    }

Member Data Documentation

m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> ActsTrk::IterativePriVtxFinderTool::m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}

private

Definition at line 134 of file IterativePriVtxFinderTool.h.

{this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"};

m_bField

std::shared_ptr<ATLASMagneticFieldWrapper> ActsTrk::IterativePriVtxFinderTool::m_bField = nullptr

private

Definition at line 124 of file IterativePriVtxFinderTool.h.

m_createSplitVertices

BooleanProperty ActsTrk::IterativePriVtxFinderTool::m_createSplitVertices {this, "createSplitVertices", false, "Create split vertices or not"}

private

Definition at line 147 of file IterativePriVtxFinderTool.h.

{this, "createSplitVertices", false, "Create split vertices or not"};

m_cutOffTrackWeight

DoubleProperty ActsTrk::IterativePriVtxFinderTool::m_cutOffTrackWeight {this, "cutOffTrackWeight", 0.01, "Min. track weight allowed"}

private

Definition at line 152 of file IterativePriVtxFinderTool.h.

{this, "cutOffTrackWeight", 0.01, "Min. track weight allowed"};

m_doMaxTracksCut

BooleanProperty ActsTrk::IterativePriVtxFinderTool::m_doMaxTracksCut {this, "doMaxTracksCut", false, "Whether use max. tracks cut or not"}

private

Definition at line 150 of file IterativePriVtxFinderTool.h.

{this, "doMaxTracksCut", false, "Whether use max. tracks cut or not"};

m_extrapolationTool

ToolHandle<IExtrapolationTool> ActsTrk::IterativePriVtxFinderTool::m_extrapolationTool {this, "ExtrapolationTool", "", "ActsExtrapolationTool"}

private

Definition at line 132 of file IterativePriVtxFinderTool.h.

{this, "ExtrapolationTool", "", "ActsExtrapolationTool"};

m_fitterMaxIterations

UnsignedIntegerProperty ActsTrk::IterativePriVtxFinderTool::m_fitterMaxIterations {this, "fitterMaxIterations", 5, "Vertex fitter max. iterations"}

private

Definition at line 140 of file IterativePriVtxFinderTool.h.

{this, "fitterMaxIterations", 5, "Vertex fitter max. iterations"};

m_gaussianMaxD0Significance

DoubleProperty ActsTrk::IterativePriVtxFinderTool::m_gaussianMaxD0Significance {this, "gaussianMaxD0Significance", 3.5, "Gaussian seeder max d0 track significance"}

private

Definition at line 155 of file IterativePriVtxFinderTool.h.

{this, "gaussianMaxD0Significance", 3.5, "Gaussian seeder max d0 track significance"};

m_gaussianMaxZ0Significance

DoubleProperty ActsTrk::IterativePriVtxFinderTool::m_gaussianMaxZ0Significance {this, "gaussianMaxDZSignificance", 12.0, "Gaussian seeder max z0 track significance"}

private

Definition at line 156 of file IterativePriVtxFinderTool.h.

{this, "gaussianMaxDZSignificance", 12.0, "Gaussian seeder max z0 track significance"};

m_ipEstMaxIterations

UnsignedIntegerProperty ActsTrk::IterativePriVtxFinderTool::m_ipEstMaxIterations {this, "ipEstMaxIterations", 20, "IpEstimator max. iterations"}

private

Definition at line 159 of file IterativePriVtxFinderTool.h.

{this, "ipEstMaxIterations", 20, "IpEstimator max. iterations"};

m_ipEstPrecision

DoubleProperty ActsTrk::IterativePriVtxFinderTool::m_ipEstPrecision {this, "ipEstPrecision", 1e-10, "IpEstimator precision"}

private

Definition at line 160 of file IterativePriVtxFinderTool.h.

{this, "ipEstPrecision", 1e-10, "IpEstimator precision"};

m_linearizer

std::optional<TrackLinearizer> ActsTrk::IterativePriVtxFinderTool::m_linearizer = std::nullopt

private

Definition at line 129 of file IterativePriVtxFinderTool.h.

m_logger

std::unique_ptr<const Acts::Logger> ActsTrk::IterativePriVtxFinderTool::m_logger {nullptr}

private

logging instance

Definition at line 101 of file IterativePriVtxFinderTool.h.

{nullptr};

m_maximumChi2cutForSeeding

DoubleProperty ActsTrk::IterativePriVtxFinderTool::m_maximumChi2cutForSeeding {this, "maximumChi2cutForSeeding", 36., "Max. Chi2 cut for seeding"}

private

Definition at line 145 of file IterativePriVtxFinderTool.h.

{this, "maximumChi2cutForSeeding", 36., "Max. Chi2 cut for seeding"};

m_maxTracks

UnsignedIntegerProperty ActsTrk::IterativePriVtxFinderTool::m_maxTracks {this, "maxTracks", 5000, "Max. number of tracks to use for vertex finding"}

private

Definition at line 151 of file IterativePriVtxFinderTool.h.

{this, "maxTracks", 5000, "Max. number of tracks to use for vertex finding"};

m_maxVertices

UnsignedIntegerProperty ActsTrk::IterativePriVtxFinderTool::m_maxVertices {this, "maxVertices", 50, "Max number of vertices"}

private

Definition at line 146 of file IterativePriVtxFinderTool.h.

{this, "maxVertices", 50, "Max number of vertices"};

m_propagator

std::shared_ptr<Propagator> ActsTrk::IterativePriVtxFinderTool::m_propagator = nullptr

private

Definition at line 126 of file IterativePriVtxFinderTool.h.

m_reassignTracksAfterFirstFit

BooleanProperty ActsTrk::IterativePriVtxFinderTool::m_reassignTracksAfterFirstFit {this, "reassignTracksAfterFirstFit", false, "Whether re-assign tracks after first vertex fit or not"}

private

Definition at line 149 of file IterativePriVtxFinderTool.h.

{this, "reassignTracksAfterFirstFit", false, "Whether re-assign tracks after first vertex fit or not"};

m_significanceCutSeeding

DoubleProperty ActsTrk::IterativePriVtxFinderTool::m_significanceCutSeeding {this, "significanceCutSeeding", 10, "Seeding Cut Significance"}

private

Definition at line 144 of file IterativePriVtxFinderTool.h.

{this, "significanceCutSeeding", 10, "Seeding Cut Significance"};

m_splitVerticesTrkInvFraction

UnsignedIntegerProperty ActsTrk::IterativePriVtxFinderTool::m_splitVerticesTrkInvFraction {this, "splitVerticesTrkInvFraction", 2, "Track Inv. fraction for split vertices"}

private

Definition at line 148 of file IterativePriVtxFinderTool.h.

{this, "splitVerticesTrkInvFraction", 2, "Track Inv. fraction for split vertices"};

m_trackingGeometryTool

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

private

Definition at line 131 of file IterativePriVtxFinderTool.h.

{this, "TrackingGeometryTool", "", "ActsTrackingGeometryTool"};

m_trkFilter

ToolHandle<InDet::IInDetTrackSelectionTool> ActsTrk::IterativePriVtxFinderTool::m_trkFilter {this, "TrackSelector", "", "InDetTrackSelectionTool"}

private

Definition at line 133 of file IterativePriVtxFinderTool.h.

{this, "TrackSelector", "", "InDetTrackSelectionTool"};

m_useBeamConstraint

BooleanProperty ActsTrk::IterativePriVtxFinderTool::m_useBeamConstraint {this, "useBeamConstraint", true, "Use beam constraint"}

private

Definition at line 143 of file IterativePriVtxFinderTool.h.

{this, "useBeamConstraint", true, "Use beam constraint"};

m_vertexFinder

std::shared_ptr<VertexFinder> ActsTrk::IterativePriVtxFinderTool::m_vertexFinder = nullptr

private

Definition at line 123 of file IterativePriVtxFinderTool.h.

---

The documentation for this class was generated from the following files:

• IterativePriVtxFinderTool.h
• IterativePriVtxFinderTool.cxx