AdaptiveMultiPriVtxFinderTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ACTSTRKPRIVTXFINDERTOOL_ADAPTIVEMULTIPRIVTXFINDERTOOL_H
#define ACTSTRKPRIVTXFINDERTOOL_ADAPTIVEMULTIPRIVTXFINDERTOOL_H
 
// ATHENA
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/ServiceHandle.h"
#include "Gaudi/Property.h"
#include "GaudiKernel/EventContext.h"
#include "BeamSpotConditionsData/BeamSpotData.h"
#include "TrkTrackLink/ITrackLink.h"
#include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
#include "TrkTrack/LinkToTrack.h"
#include "InDetRecToolInterfaces/IVertexFinder.h"
 
// Need to include this early; otherwise, we run into errors with
// ReferenceWrapperAnyCompat in clang builds due the is_constructable
// specialization defined there getting implicitly instantiated earlier.
#include "Acts/Propagator/Propagator.hpp"
#include "ActsInterop/Logger.h"
 
// PACKAGE
#include "ActsGeometryInterfaces/IActsTrackingGeometryTool.h"
#include "ActsGeometryInterfaces/IActsExtrapolationTool.h"
#include "ActsGeometryInterfaces/ActsGeometryContext.h"
#include "ActsGeometry/ATLASMagneticFieldWrapper.h"
 
// ACTS
#include "Acts/Propagator/EigenStepper.hpp"
#include "Acts/Propagator/Propagator.hpp"
#include "Acts/Propagator/Navigator.hpp"
#include "Acts/Definitions/Units.hpp"
#include "Acts/Utilities/Helpers.hpp"
#include "Acts/Vertexing/AdaptiveMultiVertexFinder.hpp"
#include "Acts/Vertexing/AdaptiveMultiVertexFitter.hpp"
#include "Acts/Vertexing/HelicalTrackLinearizer.hpp"
#include "Acts/Vertexing/TrackDensityVertexFinder.hpp"
#include "Acts/Vertexing/TrackAtVertex.hpp"
#include "Acts/Vertexing/Vertex.hpp"
#include "Acts/Vertexing/ImpactPointEstimator.hpp"
 
#include <cmath>
 
namespace Acts {
class Surface;
class BoundaryCheck;
}
 
namespace ActsTrk {
  class AdaptiveMultiPriVtxFinderTool : public extends<AthAlgTool, InDet::IVertexFinder>
  {
 
  // Track wrapper input for the Acts vertexing
  class TrackWrapper {
  public:
    TrackWrapper(const Trk::ITrackLink* trkLink, const Acts::BoundTrackParameters& boundParams)
      : m_trkLink(trkLink)
      , m_boundParams(boundParams)
    {}
 
    const Acts::BoundTrackParameters& parameters() const {return m_boundParams;}
 
    const Trk::ITrackLink* trackLink() const {return m_trkLink;}
 
    static Acts::BoundTrackParameters extractParameters(const Acts::InputTrack& input) {
      return input.template as<TrackWrapper>()->parameters();
    }
 
  private:
    const Trk::ITrackLink* m_trkLink;
    Acts::BoundTrackParameters m_boundParams;
  };
 
  public:
    virtual StatusCode initialize() override;
 
    AdaptiveMultiPriVtxFinderTool(const std::string& type,
                                  const std::string& name,
                                  const IInterface* parent);
 
    using InDet::IVertexFinder::findVertex;
 
    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:
 
    // Overload that takes vector of ITrackLink
    std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*>
    findVertex(const EventContext& ctx, const std::vector<std::unique_ptr<Trk::ITrackLink>>& trackVector) const;
 
    // Convert Acts::BoundTrackParameters -> Trk::Perigee
    Trk::Perigee* actsBoundToTrkPerigee(
    const Acts::BoundTrackParameters& bound, const Acts::Vector3& surfCenter) const;
 
    // Helper to compute "signal compatibility" for sorting vertices
    double estimateSignalCompatibility(xAOD::Vertex* vtx) const;
 
    // Provide access to the geometry tool
    virtual
    const IActsTrackingGeometryTool*
    trackingGeometryTool() const
    {
      return m_trackingGeometryTool.get();
    }
 
    std::unique_ptr<const Acts::Logger> m_logger {nullptr};
    const Acts::Logger &logger() const { return *m_logger; }
    
    using Propagator = Acts::Propagator<Acts::EigenStepper<>, Acts::Navigator>;
    using TrackLinearizer = Acts::HelicalTrackLinearizer;
    using VertexFitter = Acts::AdaptiveMultiVertexFitter;
    using VertexSeedFinder= Acts::TrackDensityVertexFinder;
    using VertexFinder = Acts::AdaptiveMultiVertexFinder;
 
    void initializeVertexFinder(VertexFinder::Config& finderConfig);
 
    std::shared_ptr<VertexFinder> m_vertexFinder = nullptr;
    std::shared_ptr<Propagator> m_propagator = nullptr;
 
    // optional because of late initializatio
    std::optional<TrackLinearizer> m_linearizer = std::nullopt;
 
    ToolHandle<IActsTrackingGeometryTool> m_trackingGeometryTool{this, "TrackingGeometryTool", "", "ActsTrackingGeometryTool"};
    ToolHandle<IActsExtrapolationTool> 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"};
 
 
    // Configuration variables
    // For details check ACTS documentation
    //
    // Annealing tool config
    DoubleArrayProperty m_annealingTemps{this, "annealingTemps", {1.0}, "Annealing temperatures"};
    DoubleProperty m_annealingCutOff{this, "annealingCutOff", 9., "Annealing cut-off value"};
    // Fitter config variables
    UnsignedIntegerProperty m_fitterMaxIterations{this, "fitterMaxIterations", 30, "Vertex fitter max. iterations"};
    DoubleProperty m_fitterMaxDistToLinPoint{this, "fitterMaxDistToLinPoint", 0.5, "Vertex fitter max. distance to LinPoint"};
    DoubleProperty m_fitterMaxRelativeShift{this, "fitterMaxRelativeShift", 0.01, "Vertex fitter max. relative shift"};
    BooleanProperty m_fitterDoSmoothing{this, "fitterDoSmoothing", true, "Vertex fitter doSmoothing"};
    DoubleProperty m_minWeightFitter{this, "minWeightFitter", 0.001, "Min track weight for fitter"};
 
    // Finder config
    BooleanProperty m_useBeamConstraint{this, "useBeamConstraint", true, "Use beam constraint"};
    DoubleProperty m_tracksMaxZinterval{this, "tracksMaxZinterval", 1., "Tracks max. Z-interval"};
    DoubleProperty m_tracksMaxSignificance{this, "tracksMaxSignificance", 5., "Tracks max. significance"};
    DoubleProperty m_maxVertexChi2{this, "maxVertexChi2", 18.42, "Max vertex chi2"};
    BooleanProperty m_doRealMultiVertex{this, "doRealMultiVertex", true, "Do real multivertex fit"};
    BooleanProperty m_useFastCompatibility{this, "useFastCompatibility", true, "Use fast compatibility estimation"};
    DoubleProperty m_maxMergeVertexSignificance{this, "maxMergeVertexSignificance", 3., "Max merge vertex significance"};
    DoubleProperty m_minWeight{this, "minWeight", 0.0001, "Min track weight for finder"};
    UnsignedIntegerProperty m_maxIterations{this, "maxIterations", 100, "Vertex finder max. iterations"};
    BooleanProperty m_addSingleTrackVertices{this, "addSingleTrackVertices", false, "Add single-track vertices"};
    BooleanProperty m_doFullSplitting{this, "doFullSplitting", false, "Do full-splitting"};
    DoubleProperty m_maximumVertexContamination{this, "maximumVertexContamination", 0.5, "Max. vertex contamination"};
    DoubleProperty m_looseConstrValue{this, "looseConstrValue", 1e+8, "Loose constraint value"};
    BooleanProperty m_useVertexCovForIPEstimation{this, "useVertexCovForIPEstimation", false, "Use seed vertex cov for IPEstimation"};
    BooleanProperty m_useSeedConstraint{this, "useSeedConstraint", false, "Use seed constraint in fit"};
    // Final vertex selection variables
    DoubleProperty m_finalCutMaxVertexChi2{this, "finalCutMaxVertexChi2", 18.42, "Final cut max. vertex chi2"};
    // Gaussian seeder finder variables
    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"};
    // Grid seeder finder variables
    UnsignedIntegerProperty m_gridMainGridSize{this, "GridMainGridSize", 20, "Main grid size for Acts::GaussianGridTrackDensity"};
    UnsignedIntegerProperty m_gridTrkGridSize{this, "GridTrkGridSize", 10, "Track grid size for Acts::GaussianGridTrackDensity"};
    BooleanProperty m_gridUseHighestSumZPosition{this, "GridUseHighestSumZPosition", false, "Use highest sum Z position in the grid seeder"};
    // Grid seeder selection thresholds
    DoubleProperty m_gridMaxD0Significance{this, "gridMaxD0Significance", 3.5, "Grid seeder max d0 track significance"};
    DoubleProperty m_gridMaxZ0Significance{this, "gridMaxZ0Significance", 12.0, "Grid seeder max z0 track significance"};
 
    // IP Estimator config
    UnsignedIntegerProperty m_ipEstMaxIterations{this, "ipEstMaxIterations", 20, "IpEstimator max. iterations"};
    DoubleProperty m_ipEstPrecision{this, "ipEstPrecision", 1e-10, "IpEstimator precision"};
    StringProperty m_seederType{this, "seederType", "Gaussian", "type of seeder, \"Grid\" for Grid seeder, other for Gaussian seeder (default)"};
  };
}
 
#endif // ACTSTRKPRIVTXFINDERTOOL_ADAPTIVEMULTIPRIVTXFINDERTOOL_H