AdaptiveVertexFitter.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRKADAPTIVEFITTERTOOLS_ADAPTIVEVERTEXFITTER_H
#define TRKADAPTIVEFITTERTOOLS_ADAPTIVEVERTEXFITTER_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
#include "TrkVertexFitterInterfaces/IVertexFitter.h"
 
// xAOD includes
#include "xAODTracking/NeutralParticle.h"
#include "xAODTracking/TrackParticle.h"
#include "xAODTracking/Vertex.h"
 
#include "TrkVertexFitterInterfaces/IImpactPoint3dEstimator.h"
#include "TrkVertexFitterInterfaces/IVertexAnnealingMaker.h"
#include "TrkVertexFitterInterfaces/IVertexLinearizedTrackFactory.h"
#include "TrkVertexFitterInterfaces/IVertexSeedFinder.h"
#include "TrkVertexFitterInterfaces/IVertexSmoother.h"
#include "TrkVertexFitterInterfaces/IVertexTrackCompatibilityEstimator.h"
#include "TrkVertexFitterInterfaces/IVertexUpdator.h"
 
namespace Trk {
class Track;
class TrackParticleBase;
class VxTrackAtVertex;

 
class AdaptiveVertexFitter : public extends<AthAlgTool, IVertexFitter>
{
public:
  // The following 'using' can be removed when IVertexFitter::fit has been fully
  // migrated to the one with the EventContext
  using Trk::IVertexFitter::fit;
 
  virtual StatusCode initialize() override;
 
  // same kind error as FullVertexFitter code to be similar in error response -
  // NOT IMPLEMENTED YET enum FitError
  // {FITOK,MATINV,NEGTRCHI2,MAXCHI2,MAXTRCHI2,NOTRKS,NOFIT};

  AdaptiveVertexFitter(const std::string& t, const std::string& n, const IInterface* p);

 
  virtual ~AdaptiveVertexFitter();

  virtual std::unique_ptr<xAOD::Vertex> fit(const EventContext& ctx,
                            const std::vector<const xAOD::TrackParticle*>& vectorTrk,
                            const std::vector<const xAOD::NeutralParticle*>& vectorNeut,
                            const Amg::Vector3D& startingPoint) const override;
  virtual std::unique_ptr<xAOD::Vertex> fit(const EventContext& ctx,
                            const std::vector<const xAOD::TrackParticle*>& vectorTrk,
                            const Amg::Vector3D& startingPoint) const override
  {
    return fit(ctx, vectorTrk, std::vector<const xAOD::NeutralParticle*>(), startingPoint);
  };

  virtual std::unique_ptr<xAOD::Vertex> fit(const EventContext& ctx,
                            const std::vector<const xAOD::TrackParticle*>& vectorTrk,
                            const std::vector<const xAOD::NeutralParticle*>& vectorNeut,
                            const xAOD::Vertex& constraint) const override;
  virtual std::unique_ptr<xAOD::Vertex> fit(const EventContext& ctx,
                            const std::vector<const xAOD::TrackParticle*>& vectorTrk,
                            const xAOD::Vertex& constraint) const override
  {
    return fit(ctx, vectorTrk, std::vector<const xAOD::NeutralParticle*>(), constraint);
  };

  virtual std::unique_ptr<xAOD::Vertex> fit(const EventContext& ctx,
                            const std::vector<const Trk::TrackParameters*>& perigeeList,
                            const std::vector<const Trk::NeutralParameters*>& neutralPerigeeList,
                            const Amg::Vector3D& startingPoint) const override;
  virtual std::unique_ptr<xAOD::Vertex> fit(const EventContext& ctx,
                            const std::vector<const Trk::TrackParameters*>& perigeeList,
                            const Amg::Vector3D& startingPoint) const override;

  virtual std::unique_ptr<xAOD::Vertex> fit(const EventContext& ctx,
                            const std::vector<const Trk::TrackParameters*>& perigeeList,
                            const std::vector<const Trk::NeutralParameters*>& neutralPerigeeList,
                            const xAOD::Vertex& constraint) const override;
  virtual std::unique_ptr<xAOD::Vertex> fit(const EventContext& ctx,
                            const std::vector<const Trk::TrackParameters*>& perigeeList,
                            const xAOD::Vertex& constraint) const override;

 
  std::unique_ptr<xAOD::Vertex> fit(const EventContext& ctx,
                    const std::vector<const Trk::Track*>& Vectortrk,
                    const xAOD::Vertex& constraint,
                    const Amg::Vector3D& startingPoint) const;

 
  std::unique_ptr<xAOD::Vertex> fit(const EventContext& ctx,
                    const std::vector<const Trk::TrackParameters*>& perigeeList,
                    const std::vector<const Trk::NeutralParameters*>& neutralPerigeeList,
                    const xAOD::Vertex& constraint,
                    const Amg::Vector3D& startingPoint) const;
  std::unique_ptr<xAOD::Vertex> fit(const EventContext& ctx,
                    const std::vector<const Trk::TrackParameters*>& perigeeList,
                    const xAOD::Vertex& constraint,
                    const Amg::Vector3D& startingPoint) const;

 
  std::unique_ptr<xAOD::Vertex> fit(
    const EventContext& ctx,
    const std::vector<const Trk::TrackParameters*>& perigeeList,
    const std::vector<const Trk::NeutralParameters*>& neutralPerigeeList) const override;
  std::unique_ptr<xAOD::Vertex> fit(const EventContext& ctx,
                    const std::vector<const Trk::TrackParameters*>& perigeeList) const override;

 
  std::unique_ptr<xAOD::Vertex> fit(const EventContext& ctx, const std::vector<const Trk::TrackParticleBase*>& perigeeList) const;
 
private:
  std::unique_ptr<xAOD::Vertex> _fit(
                     const std::vector<const Trk::TrackParameters*>& perigeeList,
                     const std::vector<const Trk::NeutralParameters*>& neutralPerigeeList =
                       std::vector<const Trk::NeutralParameters*>(),
                     const xAOD::Vertex& constraint = xAOD::Vertex(),
                     const Amg::Vector3D& startingPoint = Amg::Vector3D(),
                     bool IsConstraint = false,
                     bool IsStartingPoint = false) const;
  std::unique_ptr<xAOD::Vertex> _fit(
                     const std::vector<const Trk::TrackParameters*>& perigeeList,
                     const xAOD::Vertex& constraint = xAOD::Vertex(),
                     const Amg::Vector3D& startingPoint = Amg::Vector3D(),
                     bool IsConstraint = false,
                     bool IsStartingPoint = false) const;

 
  std::unique_ptr<xAOD::Vertex> _fit(
                     const std::vector<const Trk::Track*>& VectorTrk,
                     const xAOD::Vertex& constraint = xAOD::Vertex(),
                     const Amg::Vector3D& startingPoint = Amg::Vector3D(),
                     bool IsConstraint = false,
                     bool IsStartingPoint = false) const;

 
  std::unique_ptr<xAOD::Vertex> dothefit(const xAOD::Vertex& ConstraintVertex,
                         const Amg::Vector3D& SeedVertex,
                         std::vector<VxTrackAtVertex>& myLinTracks) const;
 
  ToolHandle<Trk::IVertexSeedFinder> m_SeedFinder{
    this,
    "SeedFinder",
    "Trk::CrossDistancesSeedFinder"
  };
  ToolHandle<Trk::IVertexLinearizedTrackFactory> m_LinearizedTrackFactory{
    this,
    "LinearizedTrackFactory",
    "Trk::FullLinearizedTrackFactory"
  };
  ToolHandle<Trk::IVertexTrackCompatibilityEstimator>
    m_TrackCompatibilityEstimator{ this,
                                   "TrackCompatibilityEstimato",
                                   "Trk::Chi2TrackCompatibilityEstimator" };
  ToolHandle<Trk::IImpactPoint3dEstimator> m_ImpactPoint3dEstimator{
    this,
    "ImpactPoint3dEstimator",
    "Trk::ImpactPoint3dEstimator/ImpactPoint3dEstimator"
  };
  ToolHandle<Trk::IVertexUpdator> m_VertexUpdator{ this,
                                                   "VertexUpdator",
                                                   "Trk::KalmanVertexUpdator" };
  ToolHandle<Trk::IVertexSmoother> m_VertexSmoother{
    this,
    "VertexSmoother",
    "Trk::DummyVertexSmoother"
  };
  ToolHandle<Trk::IVertexAnnealingMaker> m_AnnealingMaker{
    this,
    "AnnealingMaker",
    "Trk::DetAnnealingMaker"
  };

 
  long int m_maxIterations;

 
  double m_maxDistToLinPoint;

 
  double m_initialError;

 
  bool m_onlyzseed;

 
  bool m_doSmoothing;
};
}
 
#endif