Merge branch 'main' into chi2-move

Core/include/Acts/Propagator/Propagator.hpp

@@ -29,7 +29,7 @@
 
 #include <cmath>
 #include <functional>
-#include <memory>
+#include <optional>
 #include <type_traits>
 
 #include <boost/algorithm/string.hpp>
@@ -46,11 +46,11 @@ struct PropagatorResult : private detail::Extendable<result_list...> {
   /// Accessor to additional propagation quantities
   using detail::Extendable<result_list...>::get;
 
-  /// Final track parameters - initialized to null pointer
-  std::unique_ptr<parameters_t> endParameters = nullptr;
+  /// Final track parameters
+  std::optional<parameters_t> endParameters = std::nullopt;
 
   /// Full transport jacobian
-  std::unique_ptr<BoundMatrix> transportJacobian = nullptr;
+  std::optional<BoundMatrix> transportJacobian = std::nullopt;
 
   /// Number of propagation steps that were carried out
   unsigned int steps = 0;

Core/include/Acts/Propagator/Propagator.ipp

@@ -160,15 +160,11 @@ auto Acts::Propagator<S, N>::propagate(
   if (result.ok()) {
     /// Convert into return type and fill the result object
     auto curvState = m_stepper.curvilinearState(state.stepping);
-    auto& curvParameters = std::get<CurvilinearTrackParameters>(curvState);
     // Fill the end parameters
-    inputResult.endParameters =
-        std::make_unique<CurvilinearTrackParameters>(std::move(curvParameters));
+    inputResult.endParameters = std::get<CurvilinearTrackParameters>(curvState);
     // Only fill the transport jacobian when covariance transport was done
     if (state.stepping.covTransport) {
-      auto& tJacobian = std::get<Jacobian>(curvState);
-      inputResult.transportJacobian =
-          std::make_unique<Jacobian>(std::move(tJacobian));
+      inputResult.transportJacobian = std::get<Jacobian>(curvState);
     }
     return Result<ResultType>::success(std::forward<ResultType>(inputResult));
   } else {
@@ -258,15 +254,11 @@ auto Acts::Propagator<S, N>::propagate(
 
     const auto& bs = *bsRes;
 
-    auto& boundParams = std::get<BoundTrackParameters>(bs);
     // Fill the end parameters
-    inputResult.endParameters =
-        std::make_unique<BoundTrackParameters>(std::move(boundParams));
+    inputResult.endParameters = std::get<BoundTrackParameters>(bs);
     // Only fill the transport jacobian when covariance transport was done
     if (state.stepping.covTransport) {
-      auto& tJacobian = std::get<Jacobian>(bs);
-      inputResult.transportJacobian =
-          std::make_unique<Jacobian>(std::move(tJacobian));
+      inputResult.transportJacobian = std::get<Jacobian>(bs);
     }
     return Result<ResultType>::success(std::forward<ResultType>(inputResult));
   } else {

Core/include/Acts/Seeding/SeedConfirmationRangeConfig.hpp

@@ -23,11 +23,19 @@ struct SeedConfirmationRangeConfig {
   // compatible top required
   float rMaxSeedConf =
       std::numeric_limits<float>::max();  // Acts::UnitConstants::mm
+
   // number of compatible top SPs of seed if bottom radius is larger than
   // rMaxSeedConf
   size_t nTopForLargeR = 0;
   // number of compatible top SPs of seed if bottom radius is smaller than
   // rMaxSeedConf
   size_t nTopForSmallR = 0;
+
+  // minimum radius for bottom SP in seed confirmation
+  float seedConfMinBottomRadius = 60. * Acts::UnitConstants::mm;
+  // maximum zOrigin in seed confirmation
+  float seedConfMaxZOrigin = 150. * Acts::UnitConstants::mm;
+  // minimum impact parameter for seed confirmation
+  float minImpactSeedConf = 1. * Acts::UnitConstants::mm;
 };
 }  // namespace Acts

Core/include/Acts/Seeding/SeedFilter.ipp

@@ -31,6 +31,23 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(
     std::vector<std::pair<
         float, std::unique_ptr<const InternalSeed<external_spacepoint_t>>>>&
         outCont) const {
+  // seed confirmation
+  SeedConfirmationRangeConfig seedConfRange;
+  if (m_cfg.seedConfirmation) {
+    // check if bottom SP is in the central or forward region
+    seedConfRange =
+        (bottomSP.z() > m_cfg.centralSeedConfirmationRange.zMaxSeedConf ||
+         bottomSP.z() < m_cfg.centralSeedConfirmationRange.zMinSeedConf)
+            ? m_cfg.forwardSeedConfirmationRange
+            : m_cfg.centralSeedConfirmationRange;
+    // set the minimum number of top SP depending on whether the bottom SP is
+    // in the central or forward region
+    seedFilterState.nTopSeedConf =
+        bottomSP.radius() > seedConfRange.rMaxSeedConf
+            ? seedConfRange.nTopForLargeR
+            : seedConfRange.nTopForSmallR;
+  }
+
   size_t maxWeightSeedIndex = 0;
   bool maxWeightSeed = false;
   float weightMax = -std::numeric_limits<float>::max();
@@ -133,10 +150,11 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(
           (seedFilterState.numQualitySeeds and deltaSeedConf == 0)) {
         continue;
       }
-      bool seedRangeCuts = bottomSP.radius() < m_cfg.seedConfMinBottomRadius ||
-                           std::abs(zOrigin) > m_cfg.seedConfMaxZOrigin;
+      bool seedRangeCuts =
+          bottomSP.radius() < seedConfRange.seedConfMinBottomRadius ||
+          std::abs(zOrigin) > seedConfRange.seedConfMaxZOrigin;
       if (seedRangeCuts and deltaSeedConf == 0 and
-          impact > m_cfg.minImpactSeedConf) {
+          impact > seedConfRange.minImpactSeedConf) {
         continue;
       }
 

Core/include/Acts/Seeding/SeedFilterConfig.hpp

@@ -53,12 +53,6 @@ struct SeedFilterConfig {
   SeedConfirmationRangeConfig centralSeedConfirmationRange;
   // contains parameters for forward seed confirmation
   SeedConfirmationRangeConfig forwardSeedConfirmationRange;
-  // minimum radius for bottom SP in seed confirmation
-  float seedConfMinBottomRadius = 60. * Acts::UnitConstants::mm;
-  // maximum zOrigin in seed confirmation
-  float seedConfMaxZOrigin = 150. * Acts::UnitConstants::mm;
-  // minimum impact parameter for seed confirmation
-  float minImpactSeedConf = 1. * Acts::UnitConstants::mm;
 
   // maximum number of lower quality seeds in seed confirmation
   int maxSeedsPerSpMConf = std::numeric_limits<int>::max();
@@ -76,9 +70,6 @@ struct SeedFilterConfig {
     SeedFilterConfig config = *this;
     config.deltaRMin /= 1_mm;
     config.deltaInvHelixDiameter /= 1. / 1_mm;
-    config.seedConfMinBottomRadius /= 1_mm;
-    config.seedConfMaxZOrigin /= 1_mm;
-    config.minImpactSeedConf /= 1_mm;
 
     return config;
   }

Core/include/Acts/TrackFitting/GaussianSumFitter.hpp

@@ -474,7 +474,7 @@ struct GaussianSumFitter {
       ACTS_VERBOSE("+-----------------------------------------------+");
       ACTS_VERBOSE("| Gsf: Do propagation back to reference surface |");
       ACTS_VERBOSE("+-----------------------------------------------+");
-      auto lastResult = [&]() -> Result<std::unique_ptr<BoundTrackParameters>> {
+      auto lastResult = [&]() -> Result<std::optional<BoundTrackParameters>> {
         const auto& [surface, lastSmoothedState] =
             std::get<1>(smoothResult).front();
 

Core/include/Acts/Vertexing/AdaptiveMultiVertexFitter.ipp

@@ -206,7 +206,7 @@ Acts::Result<void> Acts::
       return res.error();
     }
     // Set ip3dParams for current trackAtVertex
-    currentVtxInfo.ip3dParams.emplace(trk, *(res.value()));
+    currentVtxInfo.ip3dParams.emplace(trk, res.value());
   }
   return {};
 }
@@ -236,7 +236,7 @@ Acts::AdaptiveMultiVertexFitter<input_track_t, linearizer_t>::
         return res.error();
       }
       // Set ip3dParams for current trackAtVertex
-      currentVtxInfo.ip3dParams.emplace(trk, *(res.value()));
+      currentVtxInfo.ip3dParams.emplace(trk, res.value());
     }
     // Set compatibility with current vertex
     auto compRes = m_cfg.ipEst.get3dVertexCompatibility(
@@ -342,4 +342,4 @@ void Acts::AdaptiveMultiVertexFitter<
       }
     }
   }
-}
+}

Core/include/Acts/Vertexing/HelicalTrackLinearizer.ipp

@@ -29,30 +29,29 @@ Acts::Result<Acts::LinearizedTrack> Acts::
                            ? NavigationDirection::Forward
                            : NavigationDirection::Backward;
 
-  const BoundTrackParameters* endParams = nullptr;
   // Do the propagation to linPointPos
   auto result = m_cfg.propagator->propagate(params, *perigeeSurface, pOptions);
-  if (result.ok()) {
-    endParams = (*result).endParameters.get();
-  } else {
+  if (not result.ok()) {
     return result.error();
   }
 
-  BoundVector paramsAtPCA = endParams->parameters();
+  const auto& endParams = *result->endParameters;
+
+  BoundVector paramsAtPCA = endParams.parameters();
   Vector4 positionAtPCA = Vector4::Zero();
   {
-    auto pos = endParams->position(gctx);
+    auto pos = endParams.position(gctx);
     positionAtPCA[ePos0] = pos[ePos0];
     positionAtPCA[ePos1] = pos[ePos1];
     positionAtPCA[ePos2] = pos[ePos2];
-    positionAtPCA[eTime] = endParams->time();
+    positionAtPCA[eTime] = endParams.time();
   }
-  BoundSymMatrix parCovarianceAtPCA = endParams->covariance().value();
+  BoundSymMatrix parCovarianceAtPCA = endParams.covariance().value();
 
   if (parCovarianceAtPCA.determinant() <= 0) {
     // Use the original parameters
     paramsAtPCA = params.parameters();
-    auto pos = endParams->position(gctx);
+    auto pos = endParams.position(gctx);
     positionAtPCA[ePos0] = pos[ePos0];
     positionAtPCA[ePos1] = pos[ePos1];
     positionAtPCA[ePos2] = pos[ePos2];

Core/include/Acts/Vertexing/ImpactPointEstimator.hpp

@@ -112,11 +112,10 @@ class ImpactPointEstimator {
   /// @param state The state object
   ///
   /// @return New track params
-  Result<std::unique_ptr<const BoundTrackParameters>>
-  estimate3DImpactParameters(const GeometryContext& gctx,
-                             const Acts::MagneticFieldContext& mctx,
-                             const BoundTrackParameters& trkParams,
-                             const Vector3& vtxPos, State& state) const;
+  Result<BoundTrackParameters> estimate3DImpactParameters(
+      const GeometryContext& gctx, const Acts::MagneticFieldContext& mctx,
+      const BoundTrackParameters& trkParams, const Vector3& vtxPos,
+      State& state) const;
 
   /// @brief Estimates the compatibility of a
   /// track to a vertex position based on the 3d

Core/include/Acts/Vertexing/ImpactPointEstimator.ipp

@@ -35,7 +35,7 @@ Acts::ImpactPointEstimator<input_track_t, propagator_t, propagator_options_t>::
 
 template <typename input_track_t, typename propagator_t,
           typename propagator_options_t>
-Acts::Result<std::unique_ptr<const Acts::BoundTrackParameters>>
+Acts::Result<Acts::BoundTrackParameters>
 Acts::ImpactPointEstimator<input_track_t, propagator_t, propagator_options_t>::
     estimate3DImpactParameters(const GeometryContext& gctx,
                                const Acts::MagneticFieldContext& mctx,
@@ -79,7 +79,7 @@ Acts::ImpactPointEstimator<input_track_t, propagator_t, propagator_options_t>::
   // Do the propagation to linPointPos
   auto result = m_cfg.propagator->propagate(trkParams, *planeSurface, pOptions);
   if (result.ok()) {
-    return std::move((*result).endParameters);
+    return *result->endParameters;
   } else {
     return result.error();
   }

Examples/Python/python/acts/examples/itk.py

@@ -314,13 +314,19 @@ def itkSeedingAlgConfig(inputSpacePointsType):
         rMaxSeedConf=140 * u.mm,
         nTopForLargeR=1,
         nTopForSmallR=2,
+        seedConfMinBottomRadius=60.0 * u.mm,
+        seedConfMaxZOrigin=150.0 * u.mm,
+        minImpactSeedConf=1.0 * u.mm,
     )  # contains parameters for seed confirmation
     forwardSeedConfirmationRange = acts.SeedConfirmationRangeConfig(
         zMinSeedConf=-3000 * u.mm,
         zMaxSeedConf=3000 * u.mm,
         rMaxSeedConf=140 * u.mm,
         nTopForLargeR=1,
         nTopForSmallR=2,
+        seedConfMinBottomRadius=60.0 * u.mm,
+        seedConfMaxZOrigin=150.0 * u.mm,
+        minImpactSeedConf=1.0 * u.mm,
     )
     compatSeedWeight = 100
     curvatureSortingInFilter = True

Examples/Python/src/TrackFinding.cpp

@@ -129,6 +129,9 @@ void addTrackFinding(Context& ctx) {
     ACTS_PYTHON_MEMBER(rMaxSeedConf);
     ACTS_PYTHON_MEMBER(nTopForLargeR);
     ACTS_PYTHON_MEMBER(nTopForSmallR);
+    ACTS_PYTHON_MEMBER(seedConfMinBottomRadius);
+    ACTS_PYTHON_MEMBER(seedConfMaxZOrigin);
+    ACTS_PYTHON_MEMBER(minImpactSeedConf);
     ACTS_PYTHON_STRUCT_END();
     patchKwargsConstructor(c);
   }

Tests/UnitTests/Core/Propagator/ExtrapolatorTests.cpp

@@ -109,8 +109,8 @@ BOOST_DATA_TEST_CASE(
   options.maxStepSize = 10_cm;
   options.pathLimit = 25_cm;
 
-  BOOST_CHECK(epropagator.propagate(start, options).value().endParameters !=
-              nullptr);
+  BOOST_CHECK(
+      epropagator.propagate(start, options).value().endParameters.has_value());
 }
 
 // This test case checks that no segmentation fault appears
@@ -176,7 +176,7 @@ BOOST_DATA_TEST_CASE(
     const auto& cresult = epropagator.propagate(start, *csurface, optionsEmpty)
                               .value()
                               .endParameters;
-    BOOST_CHECK(cresult != nullptr);
+    BOOST_CHECK(cresult.has_value());
   }
 }