ActsTrackFittingAlgorithm.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file ActsTrackFittingAlgorithm.h

#ifndef TRACKBASE_ACTSTRACKFITTINGALGORITHM_H
#define TRACKBASE_ACTSTRACKFITTINGALGORITHM_H

#include "Calibrator.h"
#include "ResidualOutlierFinder.h"

#include <Acts/EventData/detail/CorrectedTransformationFreeToBound.hpp>
#include <Acts/Geometry/TrackingGeometry.hpp>

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#pragma GCC diagnostic ignored "-Wunused-value"
#include <Acts/TrackFitting/KalmanFitter.hpp>
#pragma GCC diagnostic pop

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wshadow"
#include <Acts/EventData/VectorMultiTrajectory.hpp>
#pragma GCC diagnostic pop
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#include <Acts/Propagator/MultiEigenStepperLoop.hpp>
#pragma GCC diagnostic pop

#include <Acts/EventData/SourceLink.hpp>
#include <Acts/EventData/TrackParameters.hpp>
#include <Acts/EventData/VectorTrackContainer.hpp>

#include <functional>
#include <memory>
#include <vector>

namespace Acts
{
  class TrackingGeometry;
}

class ActsTrackFittingAlgorithm final
{
 public:
  using TrackParameters = ::Acts::BoundTrackParameters;
  using Measurement = ::Acts::BoundVariantMeasurement;
  using MeasurementContainer = std::vector<Measurement>;

  using TrackContainer =
      Acts::TrackContainer<Acts::VectorTrackContainer,
                           Acts::VectorMultiTrajectory, std::shared_ptr>;

  using TrackFitterResult = Acts::Result<TrackContainer::TrackProxy>;

  struct GeneralFitterOptions
  {
    std::reference_wrapper<const Acts::GeometryContext> geoContext;
    std::reference_wrapper<const Acts::MagneticFieldContext> magFieldContext;
    std::reference_wrapper<const Acts::CalibrationContext> calibrationContext;
    const Acts::Surface* referenceSurface = nullptr;
    Acts::PropagatorPlainOptions propOptions;
  };

  class TrackFitterFunction
  {
   public:
    virtual ~TrackFitterFunction() = default;
    virtual TrackFitterResult operator()(
        const std::vector<Acts::SourceLink>&,
        const TrackParameters&, const GeneralFitterOptions&,
        const CalibratorAdapter&,
        TrackContainer&) const = 0;

    virtual void outlierFinder(const ResidualOutlierFinder&) {}
  };

  class DirectedTrackFitterFunction
  {
   public:
    virtual ~DirectedTrackFitterFunction() = default;

    virtual TrackFitterResult operator()(
        const std::vector<Acts::SourceLink>&,
        const TrackParameters&, const GeneralFitterOptions&,
        const std::vector<const Acts::Surface*>&,
        const CalibratorAdapter&,
        TrackContainer&) const = 0;
  };

  struct Config
  {
    bool directNavigation;
    std::shared_ptr<TrackFitterFunction> fit;
    std::shared_ptr<DirectedTrackFitterFunction> dFit;
  };

  ActsTrackFittingAlgorithm(Config config, Acts::Logging::Level level);

  const Config& config() const { return m_cfg; }

  static std::shared_ptr<TrackFitterFunction> makeKalmanFitterFunction(
      std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry,
      std::shared_ptr<const Acts::MagneticFieldProvider> magneticField,
      bool multipleScattering = true, bool energyLoss = true,
      double reverseFilteringMomThreshold = 0.0,
      Acts::FreeToBoundCorrection freeToBoundCorrection =
          Acts::FreeToBoundCorrection(),
      const Acts::Logger& logger = *Acts::getDefaultLogger("Kalman",
                                                           Acts::Logging::FATAL));

  static std::shared_ptr<DirectedTrackFitterFunction> makeDirectedKalmanFitterFunction(
      std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry,
      std::shared_ptr<const Acts::MagneticFieldProvider> magneticField,
      bool multipleScattering = true, bool energyLoss = true,
      double reverseFilteringMomThreshold = 0.0,
      Acts::FreeToBoundCorrection freeToBoundCorrection =
          Acts::FreeToBoundCorrection(),
      const Acts::Logger& logger = *Acts::getDefaultLogger("Kalman",
                                                           Acts::Logging::FATAL));

 private:
  TrackFitterResult fitTrack(
      const std::vector<Acts::SourceLink>& sourceLinks,
      const TrackParameters& initialParameters,
      const GeneralFitterOptions& options,
      const std::vector<const Acts::Surface*>& surfSequence,
      const CalibratorAdapter& calibrator,
      TrackContainer& tracks) const;

  Config m_cfg;
};

inline ActsTrackFittingAlgorithm::TrackFitterResult
ActsTrackFittingAlgorithm::fitTrack(
    const std::vector<Acts::SourceLink>& sourceLinks,
    const TrackParameters& initialParameters,
    const ActsTrackFittingAlgorithm::GeneralFitterOptions& options,
    const std::vector<const Acts::Surface*>& surfSequence,
    const CalibratorAdapter& calibrator,
    TrackContainer& tracks) const
{
  if (m_cfg.directNavigation)
  {
    return (*m_cfg.dFit)(sourceLinks, initialParameters, options, surfSequence, calibrator, tracks);
  }

  return (*m_cfg.fit)(sourceLinks, initialParameters, options, calibrator, tracks);
}

#endif