Merge branch 'main' into feat/gsf-collect-mat-stats

.zenodo.json

@@ -42,7 +42,7 @@
       "name": "Xiaocong Ai"
     },
     {
-      "affiliation": "Universitaet Freiburg",
+      "affiliation": "Universitaet Regensburg",
       "name": "Benjamin Huth"
     },
     {
@@ -113,6 +113,11 @@
       "name": "Stephen Nicholas Swatman",
       "orcid": "0000-0002-3747-3229"
     }
+    {
+      "affiliation": "CERN / TU Wien",
+      "name": "Felix Russo",
+      "orcid": "0009-0005-8975-2245"
+    }
   ],
   "access_right": "open",
   "related_identifiers": [

AUTHORS

@@ -15,6 +15,7 @@ The following people have contributed to the project (in alphabetical order):
 - Fabian Klimpel, CERN
 - Robert Langenberg, UMass
 - Alexander J. Pfleger, CERN, University of Graz
+- Felix Russo, CERN, TU Wien
 - Andreas Salzburger, CERN
 - Bastian Schlag, CERN, JGU Mainz
 - Andreas Stefl, CERN, TU Wien

CITATION.cff

@@ -86,6 +86,10 @@ authors:
   family-names: Swatman
   affiliation: CERN / University of Amsterdam
   orcid: https://orcid.org/0000-0002-3747-3229
+- given-names: Felix
+  family-names: Russo
+  affiliation: CERN / TU Wien
+  orcid: https://orcid.org/0009-0005-8975-2245
 version: 10.0.0
 date-released: 2021-07-28
 repository-code: https://github.com/acts-project/acts

Core/include/Acts/Detector/LayerStructureBuilder.hpp

@@ -86,6 +86,9 @@ class LayerStructureBuilder : public IInternalStructureBuilder {
     std::vector<ProtoSupport> supports = {};
     /// Definition of Binnings
     std::vector<ProtoBinning> binnings = {};
+    /// Minimum number of surfaces to build an internal structure
+    /// - otherwise the tryAll options is used
+    unsigned int nMinimalSurfaces = 4u;
     /// Polyhedron approximations
     unsigned int nSegments = 1u;
     /// Extra information, mainly for screen output

Core/include/Acts/Propagator/AtlasStepper.hpp

@@ -422,15 +422,14 @@ class AtlasStepper {
     detail::updateSingleStepSize<AtlasStepper>(state, oIntersection, release);
   }
 
-  /// Set Step size - explicitly with a double
+  /// Update step size - explicitly with a double
   ///
   /// @param [in,out] state The stepping state (thread-local cache)
   /// @param [in] stepSize The step size value
   /// @param [in] stype The step size type to be set
   /// @param release [in] Do we release the step size?
-  void setStepSize(State& state, double stepSize,
-                   ConstrainedStep::Type stype = ConstrainedStep::actor,
-                   bool release = true) const {
+  void updateStepSize(State& state, double stepSize,
+                      ConstrainedStep::Type stype, bool release = true) const {
     state.previousStepSize = state.stepSize.value();
     state.stepSize.update(stepSize, stype, release);
   }
@@ -446,8 +445,9 @@ class AtlasStepper {
   /// Release the Step size
   ///
   /// @param [in,out] state The stepping state (thread-local cache)
-  void releaseStepSize(State& state) const {
-    state.stepSize.release(ConstrainedStep::actor);
+  /// @param [in] stype The step size type to be released
+  void releaseStepSize(State& state, ConstrainedStep::Type stype) const {
+    state.stepSize.release(stype);
   }
 
   /// Output the Step Size - single component

Core/include/Acts/Propagator/DirectNavigator.hpp

@@ -331,7 +331,6 @@ class DirectNavigator {
             state.navigation.navSurfaces.end()) {
           ACTS_VERBOSE("Next surface candidate is  "
                        << (*state.navigation.navSurfaceIter)->geometryId());
-          stepper.releaseStepSize(state.stepping);
         }
       } else if (surfaceStatus == Intersection3D::Status::reachable) {
         ACTS_VERBOSE("Next surface reachable at distance  "

Core/include/Acts/Propagator/EigenStepper.hpp

@@ -272,15 +272,14 @@ class EigenStepper {
     detail::updateSingleStepSize<EigenStepper>(state, oIntersection, release);
   }
 
-  /// Set Step size - explicitly with a double
+  /// Update step size - explicitly with a double
   ///
   /// @param state [in,out] The stepping state (thread-local cache)
   /// @param stepSize [in] The step size value
   /// @param stype [in] The step size type to be set
   /// @param release [in] Do we release the step size?
-  void setStepSize(State& state, double stepSize,
-                   ConstrainedStep::Type stype = ConstrainedStep::actor,
-                   bool release = true) const {
+  void updateStepSize(State& state, double stepSize,
+                      ConstrainedStep::Type stype, bool release = true) const {
     state.previousStepSize = state.stepSize.value();
     state.stepSize.update(stepSize, stype, release);
   }
@@ -296,8 +295,9 @@ class EigenStepper {
   /// Release the Step size
   ///
   /// @param state [in,out] The stepping state (thread-local cache)
-  void releaseStepSize(State& state) const {
-    state.stepSize.release(ConstrainedStep::actor);
+  /// @param [in] stype The step size type to be released
+  void releaseStepSize(State& state, ConstrainedStep::Type stype) const {
+    state.stepSize.release(stype);
   }
 
   /// Output the Step Size - single component

Core/include/Acts/Propagator/MultiEigenStepperLoop.hpp

@@ -675,17 +675,16 @@ class MultiEigenStepperLoop
     }
   }
 
-  /// Set Step size - explicitly with a double
+  /// Update step size - explicitly with a double
   ///
   /// @param state [in,out] The stepping state (thread-local cache)
   /// @param stepSize [in] The step size value
   /// @param stype [in] The step size type to be set
   /// @param release [in] Do we release the step size?
-  void setStepSize(State& state, double stepSize,
-                   ConstrainedStep::Type stype = ConstrainedStep::actor,
-                   bool release = true) const {
+  void updateStepSize(State& state, double stepSize,
+                      ConstrainedStep::Type stype, bool release = true) const {
     for (auto& component : state.components) {
-      SingleStepper::setStepSize(component.state, stepSize, stype, release);
+      SingleStepper::updateStepSize(component.state, stepSize, stype, release);
     }
   }
 
@@ -708,9 +707,10 @@ class MultiEigenStepperLoop
   /// Release the step-size for all components
   ///
   /// @param state [in,out] The stepping state (thread-local cache)
-  void releaseStepSize(State& state) const {
+  /// @param [in] stype The step size type to be released
+  void releaseStepSize(State& state, ConstrainedStep::Type stype) const {
     for (auto& component : state.components) {
-      SingleStepper::releaseStepSize(component.state);
+      SingleStepper::releaseStepSize(component.state, stype);
     }
   }
 

Core/include/Acts/Propagator/Navigator.hpp

@@ -420,7 +420,7 @@ class Navigator {
                    << "No further navigation action, proceed to target.");
       // Set navigation break and release the navigation step size
       state.navigation.navigationBreak = true;
-      stepper.releaseStepSize(state.stepping);
+      stepper.releaseStepSize(state.stepping, ConstrainedStep::actor);
     }
 
     // Navigator target always resets the current surface
@@ -536,7 +536,6 @@ class Navigator {
               << "No more volume to progress to, stopping navigation.");
           // Navigation break & release navigation stepping
           state.navigation.navigationBreak = true;
-          stepper.releaseStepSize(state.stepping);
           return;
         } else {
           ACTS_VERBOSE(volInfo(state) << "Volume updated.");
@@ -562,7 +561,6 @@ class Navigator {
       }
       // Set navigation break and release the navigation step size
       state.navigation.navigationBreak = true;
-      stepper.releaseStepSize(state.stepping);
     } else {
       ACTS_VERBOSE(volInfo(state)
                    << "Status could not be determined - good luck.");
@@ -649,7 +647,7 @@ class Navigator {
                      << "Start is target layer, nothing left to do.");
         // set the navigation break
         state.navigation.navigationBreak = true;
-        stepper.releaseStepSize(state.stepping);
+        stepper.releaseStepSize(state.stepping, ConstrainedStep::actor);
       }
       return startResolved;
     }
@@ -934,15 +932,15 @@ class Navigator {
       ACTS_VERBOSE(volInfo(state)
                    << "No sufficient information to resolve boundary, "
                       "stopping navigation.");
-      stepper.releaseStepSize(state.stepping);
+      stepper.releaseStepSize(state.stepping, ConstrainedStep::actor);
       return false;
     } else if (state.navigation.currentVolume ==
                state.navigation.targetVolume) {
       ACTS_VERBOSE(volInfo(state)
                    << "In target volume: no need to resolve boundary, "
                       "stopping navigation.");
       state.navigation.navigationBreak = true;
-      stepper.releaseStepSize(state.stepping);
+      stepper.releaseStepSize(state.stepping, ConstrainedStep::actor);
       return true;
     }
 
@@ -1275,7 +1273,7 @@ class Navigator {
     // Screen output - no layer candidates found
     ACTS_VERBOSE(volInfo(state) << "No compatible layer candidates found.");
     // Release the step size
-    stepper.releaseStepSize(state.stepping);
+    stepper.releaseStepSize(state.stepping, ConstrainedStep::actor);
     return false;
   }
 

Core/include/Acts/Propagator/Propagator.ipp

@@ -7,6 +7,7 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "Acts/EventData/TrackParametersConcept.hpp"
+#include "Acts/Propagator/ConstrainedStep.hpp"
 #include "Acts/Propagator/PropagatorError.hpp"
 #include "Acts/Propagator/detail/LoopProtection.hpp"
 
@@ -58,6 +59,9 @@ auto Acts::Propagator<S, N>::propagate_impl(propagator_state_t& state,
         // pass error to caller
         return res.error();
       }
+      // release actor and aborter constrains after step was performed
+      m_stepper.releaseStepSize(state.stepping, ConstrainedStep::actor);
+      m_stepper.releaseStepSize(state.stepping, ConstrainedStep::aborter);
       // Post-stepping:
       // navigator post step call - action list - aborter list
       state.stage = PropagatorStage::postStep;

Core/include/Acts/Propagator/StandardAborters.hpp

@@ -58,8 +58,8 @@ struct PathLimitReached {
       navigator.targetReached(state.navigation, true);
       return true;
     }
-    stepper.setStepSize(state.stepping, distance, ConstrainedStep::aborter,
-                        false);
+    stepper.updateStepSize(state.stepping, distance, ConstrainedStep::aborter,
+                           false);
     ACTS_VERBOSE("PathLimit aborter | "
                  << "Target stepSize (path limit) updated to "
                  << stepper.outputStepSize(state.stepping));
@@ -126,8 +126,8 @@ struct SurfaceReached {
       if (intersection &&
           detail::checkIntersection(intersection.intersection(), pLimit, oLimit,
                                     tolerance, logger)) {
-        stepper.setStepSize(state.stepping, intersection.pathLength(),
-                            ConstrainedStep::aborter, false);
+        stepper.updateStepSize(state.stepping, intersection.pathLength(),
+                               ConstrainedStep::aborter, false);
         ACTS_VERBOSE(
             "SurfaceReached aborter | "
             "Target stepSize (surface) updated to "

Core/include/Acts/Propagator/StepperConcept.hpp

@@ -54,7 +54,7 @@ METHOD_TRAIT(covariance_transport_curvilinear_t,
              transportCovarianceToCurvilinear);
 METHOD_TRAIT(step_t, step);
 METHOD_TRAIT(update_surface_status_t, updateSurfaceStatus);
-METHOD_TRAIT(set_step_size_t, setStepSize);
+METHOD_TRAIT(update_step_size_t, updateStepSize);
 METHOD_TRAIT(get_step_size_t, getStepSize);
 METHOD_TRAIT(release_step_size_t, releaseStepSize);
 METHOD_TRAIT(output_step_size_t, outputStepSize);
@@ -126,11 +126,11 @@ constexpr bool MultiStepperStateConcept= require<
         static_assert(covariance_transport_exists, "covarianceTransport method not found");
         constexpr static bool update_surface_exists = has_method<const S, Intersection3D::Status, update_surface_status_t, state&, const Surface&, std::uint8_t, Direction, const BoundaryCheck&, ActsScalar, const Logger&>;
         static_assert(update_surface_exists, "updateSurfaceStatus method not found");
-        constexpr static bool set_step_size_exists = has_method<const S, void, set_step_size_t, state&, double, ConstrainedStep::Type, bool>;
-        static_assert(set_step_size_exists, "setStepSize method not found");
+        constexpr static bool update_step_size_exists = has_method<const S, void, update_step_size_t, state&, double, ConstrainedStep::Type, bool>;
+        static_assert(update_step_size_exists, "updateStepSize method not found");
         constexpr static bool get_step_size_exists = has_method<const S, double, get_step_size_t, const state &, ConstrainedStep::Type>;
         static_assert(get_step_size_exists, "getStepSize method not found");
-        constexpr static bool release_step_size_exists = has_method<const S, void, release_step_size_t, state&>;
+        constexpr static bool release_step_size_exists = has_method<const S, void, release_step_size_t, state&, ConstrainedStep::Type>;
         static_assert(release_step_size_exists, "releaseStepSize method not found");
         constexpr static bool output_step_size_exists = has_method<const S, std::string, output_step_size_t, const state&>;
         static_assert(output_step_size_exists, "outputStepSize method not found");
@@ -151,7 +151,7 @@ constexpr bool MultiStepperStateConcept= require<
                                               curvilinear_state_method_exists,
                                               covariance_transport_exists,
                                               update_surface_exists,
-                                              set_step_size_exists,
+                                              update_step_size_exists,
                                               release_step_size_exists,
                                               output_step_size_exists>;
 

Core/include/Acts/Propagator/StraightLineStepper.hpp

@@ -263,15 +263,15 @@ class StraightLineStepper {
                                                       release);
   }
 
-  /// Set Step size - explicitly with a double
+  /// Update step size - explicitly with a double
   ///
   /// @param state [in,out] The stepping state (thread-local cache)
   /// @param stepSize [in] The step size value
   /// @param stype [in] The step size type to be set
   /// @param release [in] Do we release the step size?
-  void setStepSize(State& state, double stepSize,
-                   ConstrainedStep::Type stype = ConstrainedStep::actor,
-                   bool release = true) const {
+  void updateStepSize(State& state, double stepSize,
+                      ConstrainedStep::Type stype = ConstrainedStep::actor,
+                      bool release = true) const {
     state.previousStepSize = state.stepSize.value();
     state.stepSize.update(stepSize, stype, release);
   }
@@ -286,9 +286,10 @@ class StraightLineStepper {
 
   /// Release the Step size
   ///
-  /// @param state [in,out] The stepping state (thread-local cache)
-  void releaseStepSize(State& state) const {
-    state.stepSize.release(ConstrainedStep::actor);
+  /// @param [in,out] state The stepping state (thread-local cache)
+  /// @param [in] stype The step size type to be released
+  void releaseStepSize(State& state, ConstrainedStep::Type stype) const {
+    state.stepSize.release(stype);
   }
 
   /// Output the Step Size - single component

Core/include/Acts/Propagator/detail/SteppingHelper.hpp

@@ -59,7 +59,8 @@ Acts::Intersection3D::Status updateSingleSurfaceStatus(
       detail::checkIntersection(sIntersection.intersection(), pLimit, oLimit,
                                 surfaceTolerance, logger)) {
     ACTS_VERBOSE("Surface is reachable");
-    stepper.setStepSize(state, sIntersection.pathLength());
+    stepper.updateStepSize(state, sIntersection.pathLength(),
+                           ConstrainedStep::actor);
     return Intersection3D::Status::reachable;
   }
 

Core/include/Acts/Seeding/SeedFinderConfig.hpp

@@ -13,7 +13,9 @@
 #include "Acts/Seeding/SeedConfirmationRangeConfig.hpp"
 #include "Acts/Utilities/Delegate.hpp"
 
+#include <limits>
 #include <memory>
+#include <vector>
 
 namespace Acts {
 

Core/include/Acts/Surfaces/ConeSurface.hpp

@@ -18,7 +18,9 @@
 #include "Acts/Surfaces/ConeBounds.hpp"
 #include "Acts/Surfaces/RegularSurface.hpp"
 #include "Acts/Surfaces/Surface.hpp"
+#include "Acts/Surfaces/SurfaceConcept.hpp"
 #include "Acts/Utilities/BinningType.hpp"
+#include "Acts/Utilities/Concepts.hpp"
 #include "Acts/Utilities/Result.hpp"
 #include "Acts/Utilities/detail/RealQuadraticEquation.hpp"
 
@@ -278,4 +280,6 @@ class ConeSurface : public RegularSurface {
       const Vector3& direction) const;
 };
 
+ACTS_STATIC_CHECK_CONCEPT(RegularSurfaceConcept, ConeSurface);
+
 }  // namespace Acts

Core/include/Acts/Surfaces/CylinderSurface.hpp

@@ -18,7 +18,9 @@
 #include "Acts/Surfaces/CylinderBounds.hpp"
 #include "Acts/Surfaces/RegularSurface.hpp"
 #include "Acts/Surfaces/Surface.hpp"
+#include "Acts/Surfaces/SurfaceConcept.hpp"
 #include "Acts/Utilities/BinningType.hpp"
+#include "Acts/Utilities/Concepts.hpp"
 #include "Acts/Utilities/Result.hpp"
 #include "Acts/Utilities/detail/RealQuadraticEquation.hpp"
 
@@ -285,4 +287,6 @@ class CylinderSurface : public RegularSurface {
       const Vector3& direction) const;
 };
 
+ACTS_STATIC_CHECK_CONCEPT(RegularSurfaceConcept, CylinderSurface);
+
 }  // namespace Acts

Core/include/Acts/Surfaces/DiscSurface.hpp

@@ -18,7 +18,9 @@
 #include "Acts/Surfaces/InfiniteBounds.hpp"
 #include "Acts/Surfaces/RegularSurface.hpp"
 #include "Acts/Surfaces/Surface.hpp"
+#include "Acts/Surfaces/SurfaceConcept.hpp"
 #include "Acts/Utilities/BinningType.hpp"
+#include "Acts/Utilities/Concepts.hpp"
 #include "Acts/Utilities/Result.hpp"
 
 #include <cmath>
@@ -328,4 +330,7 @@ class DiscSurface : public RegularSurface {
  protected:
   std::shared_ptr<const DiscBounds> m_bounds;  ///< bounds (shared)
 };
+
+ACTS_STATIC_CHECK_CONCEPT(RegularSurfaceConcept, DiscSurface);
+
 }  // end of namespace Acts