GlobalChiSquareFitterTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ACTSGEOMETRY_GLOBALCHISQUAREFITTERTOOL_H
#define ACTSGEOMETRY_GLOBALCHISQUAREFITTERTOOL_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "TrkEventPrimitives/PdgToParticleHypothesis.h"
#include "TrkFitterInterfaces/ITrackFitter.h"
#include "TrkPrepRawData/PrepRawData.h"
#include "TrkToolInterfaces/IBoundaryCheckTool.h"
#include "TrkToolInterfaces/IExtendedTrackSummaryTool.h"
#include "TrkToolInterfaces/IRIO_OnTrackCreator.h"
#include "src/detail/FitterHelperFunctions.h"
 
 
#include "MuonRecToolInterfacesR4/ISpacePointCalibrator.h"
// ACTS
#include "Acts/EventData/TrackParameters.hpp"
#include "Acts/EventData/TrackProxy.hpp"
#include "Acts/EventData/VectorTrackContainer.hpp"
#include "Acts/Geometry/GeometryIdentifier.hpp"
#include "Acts/MagneticField/MagneticFieldProvider.hpp"
#include "Acts/Propagator/Navigator.hpp"
#include "Acts/Propagator/Propagator.hpp"
#include "Acts/Propagator/SympyStepper.hpp"
#include "Acts/Propagator/StraightLineStepper.hpp"
#include "Acts/Propagator/EigenStepper.hpp"
#include "Acts/TrackFitting/GlobalChiSquareFitter.hpp"
 
// PACKAGE
#include "ActsEvent/TrackContainer.h"
#include "ActsToolInterfaces/IActsToTrkConverterTool.h"
#include "ActsGeometryInterfaces/IExtrapolationTool.h"
#include "ActsGeometryInterfaces/ITrackingGeometryTool.h"
 
#include "ActsCalibrators/TrkMeasurementCalibrator.h"
#include "ActsCalibrators/TrkPrepRawDataCalibrator.h"
#include "ActsCalibrators/TrkMeasSurfaceAccessor.h"
#include "ActsCalibrators/TrkPrepRawDataSurfaceAcc.h"
#include "ActsCalibrators/xAODUncalibMeasSurfAcc.h"
#include "ActsCalibrators/xAODUncalibMeasCalibrator.h"
 
// STL
#include <cmath>   //std::abs
#include <limits>  //for numeric_limits
#include <memory>  //unique_ptr
#include <string>
 
#include "ActsToolInterfaces/IFitterTool.h"
 
 
 
namespace Trk {
class Track;
class PrepRawData;
}  // namespace Trk
 
namespace ActsTrk {
 
 
 
class GlobalChiSquareFitterTool
    : public extends<AthAlgTool, Trk::ITrackFitter, IFitterTool> {
 public:
 
  using base_class::base_class;
  virtual ~GlobalChiSquareFitterTool() = default;
 
  // standard Athena methods
  virtual StatusCode initialize() override;

  virtual std::unique_ptr<Trk::Track> fit(
      const EventContext& ctx, const Trk::Track&,
      const Trk::RunOutlierRemoval runOutlier = false,
      const Trk::ParticleHypothesis matEffects =
          Trk::nonInteracting) const override;

  virtual std::unique_ptr<Trk::Track> fit(
      const EventContext& ctx, const Trk::PrepRawDataSet&,
      const Trk::TrackParameters&,
      const Trk::RunOutlierRemoval runOutlier = false,
      const Trk::ParticleHypothesis matEffects =
          Trk::nonInteracting) const override;

  virtual std::unique_ptr<Trk::Track> fit(
      const EventContext& ctx, const Trk::MeasurementSet&,
      const Trk::TrackParameters&,
      const Trk::RunOutlierRemoval runOutlier = false,
      const Trk::ParticleHypothesis matEffects =
          Trk::nonInteracting) const override;

  virtual std::unique_ptr<Trk::Track> fit(
      const EventContext& ctx, const Trk::Track&, const Trk::PrepRawDataSet&,
      const Trk::RunOutlierRemoval runOutlier = false,
      const Trk::ParticleHypothesis matEffects =
          Trk::nonInteracting) const override;

  virtual std::unique_ptr<MutableTrackContainer> fit(
      const std::vector<ATLASUncalibSourceLink>& clusterList,
      const Acts::BoundTrackParameters& initialParams,
      const Acts::GeometryContext& tgContext,
      const Acts::MagneticFieldContext& mfContext,
      const Acts::CalibrationContext& calContext,
      const Acts::Surface* targetSurface =
          nullptr  // optional target surface - defaults to perigee in global
                   // origin
  ) const override;

  virtual std::unique_ptr<Trk::Track> fit(
      const EventContext& ctx, const Trk::Track&, const Trk::MeasurementSet&,
      const Trk::RunOutlierRemoval runOutlier = false,
      const Trk::ParticleHypothesis matEffects =
          Trk::nonInteracting) const override;

  virtual std::unique_ptr<Trk::Track> fit(
      const EventContext& ctx, const Trk::Track& intrk1,
      const Trk::Track& intrk2, const Trk::RunOutlierRemoval runOutlier = false,
      const Trk::ParticleHypothesis matEffects =
          Trk::nonInteracting) const override;

  virtual std::unique_ptr<MutableTrackContainer> fit(
      const Seed& seed,
      const Acts::BoundTrackParameters& initialParams,
      const Acts::GeometryContext& tgContext,
      const Acts::MagneticFieldContext& mfContext,
      const Acts::CalibrationContext& calContext,
      const Acts::Surface& targetSurface) const override;
 
 
  virtual StatusCode fit(
    const EventContext& ctx,
    const TrackContainer::ConstTrackProxy& track,          
    MutableTrackContainer& trackContainer,
    const Acts::PerigeeSurface& pSurface) const override;
 

    using StraightPropagator_t = Acts::Propagator<Acts::StraightLineStepper, Acts::Navigator>;
    using CurvedPropagator_t   = Acts::Propagator<Acts::EigenStepper<>, Acts::Navigator>;
 
    using StraightFitter_t = Acts::Experimental::Gx2Fitter<StraightPropagator_t, MutableTrackStateBackend>;
    using CurvedFitter_t   = Acts::Experimental::Gx2Fitter<CurvedPropagator_t, MutableTrackStateBackend>;

    using Gx2FitterOptions_t = Acts::Experimental::Gx2FitterOptions<MutableTrackStateBackend>;
    using Gx2FitterExtension_t = Acts::Experimental::Gx2FitterExtensions<MutableTrackStateBackend>;
   
  private:
   using TrackFitResult_t = IActsToTrkConverterTool::TrackFitResult_t;
    TrackFitResult_t fit(const std::vector<Acts::SourceLink>& soureLinks,
                         const Acts::BoundTrackParameters& initialPars,
                         const Gx2FitterOptions_t& gx2fOptions, 
                         MutableTrackContainer& tracks) const;
    Gx2FitterOptions_t configureFit(const Acts::GeometryContext& tgContext,
                                    const Acts::MagneticFieldContext& mfContext,
                                    const Acts::CalibrationContext& calContext,
                                    const Acts::Surface* surface,
                                    detail::SourceLinkType slType) const;
   
    ToolHandle<ActsTrk::IExtrapolationTool> m_extrapolationTool{this, "ExtrapolationTool", ""};
    PublicToolHandle<ITrackingGeometryTool> m_trackingGeometryTool{this, "TrackingGeometryTool", ""};
    ToolHandle<IActsToTrkConverterTool> m_ATLASConverterTool{this, "ATLASConverterTool", ""};
 
    ToolHandle<MuonR4::ISpacePointCalibrator> m_muonCalibrator{this, "MuonCalibrationTool", ""};
 
    ToolHandle<Trk::IRIO_OnTrackCreator> m_ROTcreator{this, "RotCreatorTool", ""};
    
    Gaudi::Property<double> m_option_outlierChi2Cut{this, "OutlierChi2Cut", 12.5};
    Gaudi::Property<unsigned> m_option_maxPropagationStep{this, "MaxPropagationStep", 5000};
    Gaudi::Property<unsigned> m_option_maxNavSurfaces{this, "MaxSurfacesPerNavStep", 100};
    Gaudi::Property<bool> m_option_includeELoss{this, "IncludeELoss", true};
    Gaudi::Property<bool> m_option_includeScat{this, "IncludeScattering", true};
    Gaudi::Property<bool> m_doReFitFromPRD{this, "DoReFitFromPRD", false};
    Gaudi::Property<bool> m_doStraightLine{this, "DoStraightLine" , false};
    Gaudi::Property<bool> m_doJacobianCorr{this, "DoFreeToBoundCorrection", false };
    Gaudi::Property<unsigned> m_nIterMax{this, "MaxIterations", 5};
    detail::TrkMeasurementCalibrator m_trkMeasCalibrator{};
    detail::TrkPrepRawDataCalibrator m_prdCalibrator{};
    detail::TrkMeasSurfaceAccessor m_trkMeasSurfAcc{};
    detail::TrkPrepRawDataSurfaceAcc m_prdSurfaceAcc{};
    detail::xAODUncalibMeasSurfAcc m_unalibMeasSurfAcc{};
    detail::xAODUncalibMeasCalibrator m_uncalibMeasCalibrator{};
    static constexpr unsigned s_nExtensions = static_cast<unsigned>(detail::SourceLinkType::nTypes);
    std::array<Gx2FitterExtension_t, s_nExtensions>  m_gx2fExtensions{};
    std::unique_ptr<CurvedFitter_t> m_fitter{nullptr};
    std::unique_ptr<StraightFitter_t> m_slFitter{nullptr};
 
    detail::FitterHelperFunctions::ATLASOutlierFinder m_outlierFinder{0};

    const Acts::Logger& logger() const { return *m_logger; }

    std::unique_ptr<const Acts::Logger> m_logger;
 
 
};
 
}  // namespace ActsTrk
#endif