Merge branch 'main' into feature/bind-measurement-maps

Author: kodiakhq[bot]

Core/include/Acts/TrackFitting/KalmanFitter.hpp

@@ -288,7 +288,7 @@ class KalmanFitter {
     /// Broadcast the result_type
     using result_type = KalmanFitterResult<traj_t>;
 
-    /// The target surface aboter
+    /// The target surface aborter
     SurfaceReached targetReached{std::numeric_limits<double>::lowest()};
 
     /// Allows retrieving measurements for a surface

Core/include/Acts/TrackFitting/ReferenceTrajectoryBuilder.hpp

@@ -3,6 +3,7 @@ acts_add_library(
     src/RefittingCalibrator.cpp
     src/TrackFittingAlgorithm.cpp
     src/KalmanFitterFunction.cpp
+    src/KalmanReferenceTrajectoryFitterFunction.cpp
     src/RefittingAlgorithm.cpp
     src/GsfFitterFunction.cpp
     src/GlobalChiSquareFitterFunction.cpp

Examples/Algorithms/TrackFitting/CMakeLists.txt

@@ -78,13 +78,26 @@ std::shared_ptr<TrackFitterFunction> makeKalmanFitterFunction(
     bool multipleScattering = true, bool energyLoss = true,
     double reverseFilteringMomThreshold = 0.0,
     double reverseFilteringCovarianceScaling = 100.0,
-    Acts::FreeToBoundCorrection freeToBoundCorrection =
+    const Acts::FreeToBoundCorrection& freeToBoundCorrection =
         Acts::FreeToBoundCorrection(),
     double chi2Cut = std::numeric_limits<double>::infinity(),
     bool useJosephFormulation = false,
     const Acts::Logger& logger = *Acts::getDefaultLogger("Kalman",
                                                          Acts::Logging::INFO));
 
+/// Makes a reference trajectory fitter function object using the Kalman Filter
+///
+std::shared_ptr<TrackFitterFunction>
+makeKalmanReferenceTrajectoryFitterFunction(
+    std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry,
+    std::shared_ptr<const Acts::MagneticFieldProvider> magneticField,
+    bool multipleScattering = true, bool energyLoss = true,
+    const Acts::FreeToBoundCorrection& freeToBoundCorrection =
+        Acts::FreeToBoundCorrection(),
+    bool useJosephFormulation = false,
+    const Acts::Logger& logger = *Acts::getDefaultLogger(
+        "KalmanReferenceTrajectory", Acts::Logging::INFO));
+
 /// Available algorithms for the mixture reduction
 enum class MixtureReductionAlgorithm { weightCut, KLDistance, KLDistanceNaive };
 
@@ -117,15 +130,15 @@ std::shared_ptr<TrackFitterFunction> makeGsfFitterFunction(
 /// @param magneticField the magnetic field for the propagator
 /// @param multipleScattering bool
 /// @param energyLoss bool
-/// @param freeToBoundCorrection bool
+/// @param freeToBoundCorrection the correction for free to bound state transformations
 /// @param nUpdateMax max number of iterations during the fit
 /// @param relChi2changeCutOff Check for convergence (abort condition). Set to 0 to skip.
 /// @param logger a logger instance
 std::shared_ptr<TrackFitterFunction> makeGlobalChiSquareFitterFunction(
     std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry,
     std::shared_ptr<const Acts::MagneticFieldProvider> magneticField,
     bool multipleScattering = true, bool energyLoss = true,
-    Acts::FreeToBoundCorrection freeToBoundCorrection =
+    const Acts::FreeToBoundCorrection& freeToBoundCorrection =
         Acts::FreeToBoundCorrection(),
     std::size_t nUpdateMax = 5, double relChi2changeCutOff = 1e-7,
     const Acts::Logger& logger = *Acts::getDefaultLogger("Gx2f",

Examples/Algorithms/TrackFitting/include/ActsExamples/TrackFitting/TrackFitterFunction.hpp

@@ -123,8 +123,9 @@ ActsExamples::makeGlobalChiSquareFitterFunction(
     std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry,
     std::shared_ptr<const Acts::MagneticFieldProvider> magneticField,
     bool multipleScattering, bool energyLoss,
-    Acts::FreeToBoundCorrection freeToBoundCorrection, std::size_t nUpdateMax,
-    double relChi2changeCutOff, const Acts::Logger& logger) {
+    const Acts::FreeToBoundCorrection& freeToBoundCorrection,
+    std::size_t nUpdateMax, double relChi2changeCutOff,
+    const Acts::Logger& logger) {
   // Stepper should be copied into the fitters
   const Stepper stepper(std::move(magneticField));
 

Examples/Algorithms/TrackFitting/src/GlobalChiSquareFitterFunction.cpp

@@ -165,7 +165,7 @@ std::shared_ptr<TrackFitterFunction> ActsExamples::makeKalmanFitterFunction(
     bool multipleScattering, bool energyLoss,
     double reverseFilteringMomThreshold,
     double reverseFilteringCovarianceScaling,
-    Acts::FreeToBoundCorrection freeToBoundCorrection, double chi2Cut,
+    const Acts::FreeToBoundCorrection& freeToBoundCorrection, double chi2Cut,
     bool useJosephFormulation, const Acts::Logger& logger) {
   // Stepper should be copied into the fitters
   const Stepper stepper(std::move(magneticField));

Examples/Algorithms/TrackFitting/src/KalmanFitterFunction.cpp

@@ -0,0 +1,270 @@
+// This file is part of the ACTS project.
+//
+// Copyright (C) 2016 CERN for the benefit of the ACTS project
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+#include "Acts/EventData/MultiTrajectory.hpp"
+#include "Acts/EventData/TrackContainer.hpp"
+#include "Acts/EventData/VectorMultiTrajectory.hpp"
+#include "Acts/EventData/VectorTrackContainer.hpp"
+#include "Acts/EventData/detail/CorrectedTransformationFreeToBound.hpp"
+#include "Acts/Geometry/GeometryIdentifier.hpp"
+#include "Acts/Propagator/DirectNavigator.hpp"
+#include "Acts/Propagator/Navigator.hpp"
+#include "Acts/Propagator/Propagator.hpp"
+#include "Acts/Propagator/SympyStepper.hpp"
+#include "Acts/TrackFitting/GainMatrixUpdater.hpp"
+#include "Acts/TrackFitting/MbfSmoother.hpp"
+#include "Acts/TrackFitting/ReferenceTrajectoryBuilder.hpp"
+#include "Acts/Utilities/Logger.hpp"
+#include "Acts/Utilities/TrackHelpers.hpp"
+#include "ActsExamples/EventData/IndexSourceLink.hpp"
+#include "ActsExamples/EventData/MeasurementCalibration.hpp"
+#include "ActsExamples/EventData/Track.hpp"
+#include "ActsExamples/TrackFitting/RefittingCalibrator.hpp"
+#include "ActsExamples/TrackFitting/TrackFitterFunction.hpp"
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace {
+
+using Stepper = Acts::SympyStepper;
+using Propagator = Acts::Propagator<Stepper, Acts::Navigator>;
+using ReferenceTrajectoryBuilder =
+    Acts::Experimental::ReferenceTrajectoryBuilder<Propagator,
+                                                   Acts::VectorMultiTrajectory>;
+using DirectPropagator = Acts::Propagator<Stepper, Acts::DirectNavigator>;
+using DirectReferenceTrajectoryBuilder =
+    Acts::Experimental::ReferenceTrajectoryBuilder<DirectPropagator,
+                                                   Acts::VectorMultiTrajectory>;
+
+using TrackContainer =
+    Acts::TrackContainer<Acts::VectorTrackContainer,
+                         Acts::VectorMultiTrajectory, std::shared_ptr>;
+
+using namespace ActsExamples;
+
+struct KalmanReferenceTrajectoryFitterFunctionImpl final
+    : public TrackFitterFunction {
+  Propagator extrapolator;
+
+  ReferenceTrajectoryBuilder referenceTrajectoryBuilder;
+  DirectReferenceTrajectoryBuilder directReferenceTrajectoryBuilder;
+
+  Acts::GainMatrixUpdater kfUpdater;
+  Acts::MbfSmoother kfSmoother;
+
+  bool multipleScattering = false;
+  bool energyLoss = false;
+  Acts::FreeToBoundCorrection freeToBoundCorrection;
+
+  IndexSourceLink::SurfaceAccessor slSurfaceAccessor;
+
+  std::unique_ptr<const Acts::Logger> m_smootherLogger;
+  std::unique_ptr<const Acts::Logger> m_extrapolationLogger;
+
+  KalmanReferenceTrajectoryFitterFunctionImpl(
+      Propagator&& ext, ReferenceTrajectoryBuilder&& rtBuilder,
+      DirectReferenceTrajectoryBuilder&& dRtBuilder,
+      const Acts::TrackingGeometry& trkGeo, const Acts::Logger& logger)
+      : extrapolator(std::move(ext)),
+        referenceTrajectoryBuilder(std::move(rtBuilder)),
+        directReferenceTrajectoryBuilder(std::move(dRtBuilder)),
+        slSurfaceAccessor{trkGeo} {
+    m_smootherLogger = logger.cloneWithSuffix("Smoother");
+    m_extrapolationLogger = logger.cloneWithSuffix("Extrapolation");
+  }
+
+  auto makeReferenceTrajectoryBuilderOptions(
+      const GeneralFitterOptions& options) const {
+    Acts::Experimental::ReferenceTrajectoryBuilderOptions<
+        Acts::VectorMultiTrajectory>
+        rtOptions(options.geoContext, options.magFieldContext,
+                  options.propOptions, nullptr);
+
+    rtOptions.multipleScattering = multipleScattering;
+    rtOptions.energyLoss = energyLoss;
+    rtOptions.freeToBoundCorrection = freeToBoundCorrection;
+
+    return rtOptions;
+  }
+
+  TrackFitterResult operator()(const std::vector<Acts::SourceLink>& sourceLinks,
+                               const TrackParameters& initialParameters,
+                               const GeneralFitterOptions& options,
+                               const MeasurementCalibratorAdapter& calibrator,
+                               TrackContainer& tracks) const override {
+    const auto referenceTrajectoryBuilderOptions =
+        makeReferenceTrajectoryBuilderOptions(options);
+
+    Acts::SourceLinkSurfaceAccessor sourceLinkAccessorDelegate;
+    sourceLinkAccessorDelegate
+        .connect<&IndexSourceLink::SurfaceAccessor::operator()>(
+            &slSurfaceAccessor);
+
+    ReferenceTrajectoryBuilder::Calibrator calibratorDelegate;
+    calibratorDelegate.connect<&MeasurementCalibratorAdapter::calibrate>(
+        &calibrator);
+
+    ReferenceTrajectoryBuilder::Updater updaterDelegate;
+    updaterDelegate.connect<
+        &Acts::GainMatrixUpdater::operator()<Acts::VectorMultiTrajectory>>(
+        &kfUpdater);
+
+    auto buildResult = referenceTrajectoryBuilder.build(
+        initialParameters, referenceTrajectoryBuilderOptions, tracks);
+    if (!buildResult.ok()) {
+      return buildResult.error();
+    }
+    auto track = *buildResult;
+
+    referenceTrajectoryBuilder.attachSourceLinks(track, sourceLinks,
+                                                 sourceLinkAccessorDelegate);
+
+    referenceTrajectoryBuilder.calibrateMeasurements(options.geoContext,
+                                                     options.calibrationContext,
+                                                     track, calibratorDelegate);
+
+    auto fitterResult = referenceTrajectoryBuilder.filter(
+        options.geoContext, track, updaterDelegate);
+    if (!fitterResult.ok()) {
+      return fitterResult.error();
+    }
+
+    auto smoothRes =
+        kfSmoother(options.geoContext, tracks.trackStateContainer(),
+                   track.tipIndex(), *m_smootherLogger);
+    if (!smoothRes.ok()) {
+      return smoothRes.error();
+    }
+
+    if (!track.hasReferenceSurface() && options.referenceSurface != nullptr) {
+      typename Propagator::template Options<> extrapolationOptions(
+          options.geoContext, options.magFieldContext);
+      auto extrapolationResult = extrapolateTrackToReferenceSurface(
+          track, *options.referenceSurface, extrapolator, extrapolationOptions,
+          Acts::TrackExtrapolationStrategy::first, *m_extrapolationLogger);
+
+      if (!extrapolationResult.ok()) {
+        return extrapolationResult.error();
+      }
+    }
+
+    Acts::calculateTrackQuantities(track);
+
+    return TrackFitterResult::success(track);
+  }
+
+  TrackFitterResult operator()(
+      const std::vector<Acts::SourceLink>& sourceLinks,
+      const TrackParameters& initialParameters,
+      const GeneralFitterOptions& options,
+      const RefittingCalibrator& calibrator,
+      const std::vector<const Acts::Surface*>& surfaceSequence,
+      TrackContainer& tracks) const override {
+    const auto referenceTrajectoryBuilderOptions =
+        makeReferenceTrajectoryBuilderOptions(options);
+
+    Acts::SourceLinkSurfaceAccessor sourceLinkAccessorDelegate;
+    sourceLinkAccessorDelegate.connect<&RefittingCalibrator::accessSurface>();
+
+    DirectReferenceTrajectoryBuilder::Calibrator calibratorDelegate;
+    calibratorDelegate.connect<&RefittingCalibrator::calibrate>(&calibrator);
+
+    DirectReferenceTrajectoryBuilder::Updater updaterDelegate;
+    updaterDelegate.connect<
+        &Acts::GainMatrixUpdater::operator()<Acts::VectorMultiTrajectory>>(
+        &kfUpdater);
+
+    auto buildResult = directReferenceTrajectoryBuilder.build(
+        initialParameters, referenceTrajectoryBuilderOptions, surfaceSequence,
+        tracks);
+    if (!buildResult.ok()) {
+      return buildResult.error();
+    }
+    auto track = *buildResult;
+
+    directReferenceTrajectoryBuilder.attachSourceLinks(
+        track, sourceLinks, sourceLinkAccessorDelegate);
+
+    directReferenceTrajectoryBuilder.calibrateMeasurements(
+        options.geoContext, options.calibrationContext, track,
+        calibratorDelegate);
+
+    directReferenceTrajectoryBuilder.filter(options.geoContext, track,
+                                            updaterDelegate);
+
+    auto smoothRes = kfSmoother(options.geoContext,
+                                tracks.trackStateContainer(), track.tipIndex());
+    if (!smoothRes.ok()) {
+      return smoothRes.error();
+    }
+
+    if (!track.hasReferenceSurface() && options.referenceSurface != nullptr) {
+      typename Propagator::template Options<> extrapolationOptions(
+          options.geoContext, options.magFieldContext);
+      auto extrapolationResult = extrapolateTrackToReferenceSurface(
+          track, *options.referenceSurface, extrapolator, extrapolationOptions,
+          Acts::TrackExtrapolationStrategy::first);
+
+      if (!extrapolationResult.ok()) {
+        return extrapolationResult.error();
+      }
+    }
+
+    Acts::calculateTrackQuantities(track);
+
+    return TrackFitterResult::success(track);
+  }
+};
+
+}  // namespace
+
+std::shared_ptr<TrackFitterFunction>
+ActsExamples::makeKalmanReferenceTrajectoryFitterFunction(
+    std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry,
+    std::shared_ptr<const Acts::MagneticFieldProvider> magneticField,
+    bool multipleScattering, bool energyLoss,
+    const Acts::FreeToBoundCorrection& freeToBoundCorrection,
+    bool useJosephFormulation, const Acts::Logger& logger) {
+  const Stepper stepper(std::move(magneticField));
+
+  const auto& geo = *trackingGeometry;
+  Acts::Navigator::Config cfg{std::move(trackingGeometry)};
+  cfg.resolvePassive = false;
+  cfg.resolveMaterial = true;
+  cfg.resolveSensitive = true;
+  Acts::Navigator navigator(cfg, logger.cloneWithSuffix("Navigator"));
+  Propagator propagator(stepper, navigator,
+                        logger.cloneWithSuffix("Propagator"));
+  ReferenceTrajectoryBuilder referenceTrajectoryBuilder(
+      std::move(propagator),
+      logger.cloneWithSuffix("ReferenceTrajectoryBuilder"));
+
+  Acts::DirectNavigator directNavigator{
+      logger.cloneWithSuffix("DirectNavigator")};
+  DirectPropagator directPropagator(stepper, std::move(directNavigator),
+                                    logger.cloneWithSuffix("DirectPropagator"));
+  DirectReferenceTrajectoryBuilder directReferenceTrajectoryBuilder(
+      std::move(directPropagator),
+      logger.cloneWithSuffix("DirectReferenceTrajectoryBuilder"));
+
+  Propagator extrapolator(stepper, navigator,
+                          logger.cloneWithSuffix("Extrapolator"));
+
+  auto fitterFunction =
+      std::make_shared<KalmanReferenceTrajectoryFitterFunctionImpl>(
+          std::move(extrapolator), std::move(referenceTrajectoryBuilder),
+          std::move(directReferenceTrajectoryBuilder), geo, logger);
+  fitterFunction->multipleScattering = multipleScattering;
+  fitterFunction->energyLoss = energyLoss;
+  fitterFunction->freeToBoundCorrection = freeToBoundCorrection;
+  fitterFunction->kfUpdater = Acts::GainMatrixUpdater(useJosephFormulation);
+
+  return fitterFunction;
+}

Examples/Algorithms/TrackFitting/src/KalmanReferenceTrajectoryFitterFunction.cpp

@@ -1488,6 +1488,7 @@ def addKalmanTracks(
     calibrator: acts.examples.MeasurementCalibrator = acts.examples.makePassThroughCalibrator(),
     linkForward: bool = False,
     useJosephFormulation: bool = False,
+    useReferenceTrajectory: bool = False,
     logLevel: Optional[acts.logging.Level] = None,
 ) -> None:
     customLogLevel = acts.examples.defaultLogging(s, logLevel)
@@ -1502,6 +1503,21 @@ def addKalmanTracks(
         "chi2Cut": float("inf"),
         "useJosephFormulation": useJosephFormulation,
     }
+    fitFunction = acts.examples.makeKalmanFitterFunction(
+        trackingGeometry, field, **kalmanOptions
+    )
+
+    if useReferenceTrajectory:
+        kalmanOptions = {
+            "multipleScattering": multipleScattering,
+            "energyLoss": energyLoss,
+            "freeToBoundCorrection": acts.examples.FreeToBoundCorrection(False),
+            "level": customLogLevel(),
+            "useJosephFormulation": useJosephFormulation,
+        }
+        fitFunction = acts.examples.makeKalmanReferenceTrajectoryFitterFunction(
+            trackingGeometry, field, **kalmanOptions
+        )
 
     fitAlg = acts.examples.TrackFittingAlgorithm(
         level=customLogLevel(),
@@ -1511,9 +1527,7 @@ def addKalmanTracks(
         inputClusters=clusters if clusters is not None else "",
         outputTracks="kf_tracks",
         pickTrack=-1,
-        fit=acts.examples.makeKalmanFitterFunction(
-            trackingGeometry, field, **kalmanOptions
-        ),
+        fit=fitFunction,
         calibrator=calibrator,
         linkForward=linkForward,
     )