Inhomogeneous Magnetic Field, main branch (2025.06.23.) (#1033)

* Switch to the v10 data file(s).

* Introduced a generic traccc::bfield type.

Along with an additional type definition for inhomogeneous
fields to use in host code.

* Introduced I/O code for inhomogeneous magnetic fields.

Along with a trivial unit test for the code.

* Added inhomogeneous field host algorithms.

* Adapted all clients to the modified host algorithm APIs.

* Added inhomogeneous field CUDA algorithms.

* Adapted all clients to the modified CUDA algorithm APIs.

* Added inhomogeneous field SYCL algorithms.

* Adapted all clients to the modified SYCL algorithm APIs.

* Added inhomogeneous field support to the Alpaka algorithms.

But didn't actually implement the support in the device code yet.

* Adapted all clients to the modified Alpaka algorithm APIs.

* Made the GitLab CI use Ubuntu 24.04 based images.

The same ones that the GitLab CI has been using since a while.
In order to avoid issues with too old GCC versions.

Author: krasznaa

.gitlab-ci.yml

@@ -12,6 +12,10 @@ stages:
 # Base job template.
 .base_template: &base_job
   before_script:
+    - apt install -y zstd
+    - curl --retry 5 --retry-delay 10 --output deps.tar.zst https://acts.web.cern.ch/ACTS/ci/ubuntu-24.04/deps.v6.tar.zst
+    - tar -xf deps.tar.zst -C /usr/local --strip-components=1
+    - rm deps.tar.zst
     - git clone $CLONE_URL src
     - git -C src checkout $HEAD_SHA
     - source ./src/.github/ci_setup.sh ${TRACCC_BUILD_TYPE}
@@ -54,15 +58,15 @@ stages:
 # CUDA build job.
 build:cuda:
   <<: *build_job
-  image: ghcr.io/acts-project/ubuntu2204_cuda:56
+  image: ghcr.io/acts-project/ubuntu2404_cuda:69
   variables:
     TRACCC_BUILD_TYPE: CUDA
     TRACCC_BUILD_PRESET: cuda-fp32
 
 # CUDA test job.
 test:cuda:
   <<: *nvidia_test_job
-  image: ghcr.io/acts-project/ubuntu2204_cuda:56
+  image: ghcr.io/acts-project/ubuntu2404_cuda:69
   variables:
     TRACCC_BUILD_TYPE: CUDA
   dependencies:
@@ -71,7 +75,7 @@ test:cuda:
 # SYCL build job (with an Intel backend).
 build:sycl_intel:
   <<: *build_job
-  image: ghcr.io/acts-project/ubuntu2404_oneapi:56
+  image: ghcr.io/acts-project/ubuntu2404_oneapi:69
   variables:
     TRACCC_BUILD_TYPE: SYCL
     TRACCC_BUILD_PRESET: sycl-fp32
@@ -81,7 +85,7 @@ build:sycl_intel:
 # SYCL test job (with an Intel backend).
 test:sycl_intel:
   <<: *intel_test_job
-  image: ghcr.io/acts-project/ubuntu2404_oneapi:56
+  image: ghcr.io/acts-project/ubuntu2404_oneapi:69
   variables:
     TRACCC_BUILD_TYPE: SYCL
     ONEAPI_DEVICE_SELECTOR: opencl:*
@@ -91,7 +95,7 @@ test:sycl_intel:
 # SYCL build job (with an NVIDIA backend).
 build:sycl_nvidia:
   <<: *build_job
-  image: ghcr.io/acts-project/ubuntu2204_cuda_oneapi:56
+  image: ghcr.io/acts-project/ubuntu2404_cuda_oneapi:69
   variables:
     TRACCC_BUILD_TYPE: SYCL
     TRACCC_BUILD_PRESET: sycl-fp32
@@ -102,7 +106,7 @@ build:sycl_nvidia:
 # SYCL test job (with an NVIDIA backend).
 test:sycl_nvidia:
   <<: *nvidia_test_job
-  image: ghcr.io/acts-project/ubuntu2204_cuda_oneapi:56
+  image: ghcr.io/acts-project/ubuntu2404_cuda_oneapi:69
   variables:
     TRACCC_BUILD_TYPE: SYCL
     ONEAPI_DEVICE_SELECTOR: cuda:*

benchmarks/cpu/toy_detector_cpu.cpp

@@ -49,7 +49,7 @@ BENCHMARK_DEFINE_F(ToyDetectorBenchmark, CPU)(benchmark::State& state) {
         sim_dir + "toy_detector_surface_grids.json");
 
     // B field
-    auto field = traccc::construct_const_bfield<scalar_type>(B);
+    const traccc::bfield field{traccc::construct_const_bfield<scalar_type>(B)};
 
     // Algorithms
     traccc::host::seeding_algorithm sa(seeding_cfg, grid_cfg, filter_cfg,

benchmarks/cuda/toy_detector_cuda.cpp

@@ -56,8 +56,8 @@ BENCHMARK_DEFINE_F(ToyDetectorBenchmark, CUDA)(benchmark::State& state) {
         sim_dir + "toy_detector_surface_grids.json");
 
     // B field
-    b_field_t field = traccc::construct_const_bfield<
-        traccc::default_detector::host::scalar_type>(B);
+    const traccc::bfield field{traccc::construct_const_bfield<
+        traccc::default_detector::host::scalar_type>(B)};
 
     // Algorithms
     traccc::cuda::seeding_algorithm sa_cuda(seeding_cfg, grid_cfg, filter_cfg,

core/CMakeLists.txt

@@ -72,8 +72,8 @@ traccc_add_library( traccc_core core TYPE SHARED
   "include/traccc/finding/details/combinatorial_kalman_filter.hpp"
   "include/traccc/finding/combinatorial_kalman_filter_algorithm.hpp"
   "src/finding/combinatorial_kalman_filter_algorithm.cpp"
-  "src/finding/combinatorial_kalman_filter_algorithm_constant_field_default_detector.cpp"
-  "src/finding/combinatorial_kalman_filter_algorithm_constant_field_telescope_detector.cpp"
+  "src/finding/combinatorial_kalman_filter_algorithm_default_detector.cpp"
+  "src/finding/combinatorial_kalman_filter_algorithm_telescope_detector.cpp"
   # Fitting algorithmic code
   "include/traccc/fitting/kalman_filter/gain_matrix_updater.hpp"
   "include/traccc/fitting/kalman_filter/kalman_actor.hpp"
@@ -85,8 +85,8 @@ traccc_add_library( traccc_core core TYPE SHARED
   "include/traccc/fitting/details/kalman_fitting.hpp"
   "include/traccc/fitting/kalman_fitting_algorithm.hpp"
   "src/fitting/kalman_fitting_algorithm.cpp"
-  "src/fitting/kalman_fitting_algorithm_constant_field_default_detector.cpp"
-  "src/fitting/kalman_fitting_algorithm_constant_field_telescope_detector.cpp"
+  "src/fitting/kalman_fitting_algorithm_default_detector.cpp"
+  "src/fitting/kalman_fitting_algorithm_telescope_detector.cpp"
   # Seed finding algorithmic code.
   "include/traccc/seeding/detail/lin_circle.hpp"
   "include/traccc/seeding/detail/doublet.hpp"

core/include/traccc/finding/combinatorial_kalman_filter_algorithm.hpp

@@ -32,15 +32,11 @@ namespace traccc::host {
 ///
 class combinatorial_kalman_filter_algorithm
     : public algorithm<edm::track_candidate_collection<default_algebra>::host(
-          const default_detector::host&,
-          const covfie::field<const_bfield_backend_t<
-              default_detector::host::scalar_type>>::view_t&,
+          const default_detector::host&, const bfield&,
           const measurement_collection_types::const_view&,
           const bound_track_parameters_collection_types::const_view&)>,
       public algorithm<edm::track_candidate_collection<default_algebra>::host(
-          const telescope_detector::host&,
-          const covfie::field<traccc::const_bfield_backend_t<
-              telescope_detector::host::scalar_type>>::view_t&,
+          const telescope_detector::host&, const bfield&,
           const measurement_collection_types::const_view&,
           const bound_track_parameters_collection_types::const_view&)>,
       public messaging {
@@ -59,35 +55,31 @@ class combinatorial_kalman_filter_algorithm
     /// Execute the algorithm
     ///
     /// @param det          The (default) detector object
-    /// @param field        The (constant) magnetic field object
+    /// @param field        The magnetic field object
     /// @param measurements All measurements in an event
     /// @param seeds        All seeds in an event to start the track finding
     ///                     with
     ///
     /// @return A container of the found track candidates
     ///
     output_type operator()(
-        const default_detector::host& det,
-        const covfie::field<traccc::const_bfield_backend_t<
-            default_detector::host::scalar_type>>::view_t& field,
+        const default_detector::host& det, const bfield& field,
         const measurement_collection_types::const_view& measurements,
         const bound_track_parameters_collection_types::const_view& seeds)
         const override;
 
     /// Execute the algorithm
     ///
     /// @param det          The (telescope) detector object
-    /// @param field        The (constant) magnetic field object
+    /// @param field        The magnetic field object
     /// @param measurements All measurements in an event
     /// @param seeds        All seeds in an event to start the track finding
     ///                     with
     ///
     /// @return A container of the found track candidates
     ///
     output_type operator()(
-        const telescope_detector::host& det,
-        const covfie::field<traccc::const_bfield_backend_t<
-            telescope_detector::host::scalar_type>>::view_t& field,
+        const telescope_detector::host& det, const bfield& field,
         const measurement_collection_types::const_view& measurements,
         const bound_track_parameters_collection_types::const_view& seeds)
         const override;

core/include/traccc/fitting/kalman_fitting_algorithm.hpp

@@ -30,14 +30,10 @@ namespace traccc::host {
 /// Kalman filter based track fitting algorithm
 class kalman_fitting_algorithm
     : public algorithm<track_state_container_types::host(
-          const default_detector::host&,
-          const covfie::field<const_bfield_backend_t<
-              default_detector::host::scalar_type>>::view_t&,
+          const default_detector::host&, const bfield&,
           const edm::track_candidate_container<default_algebra>::const_view&)>,
       public algorithm<track_state_container_types::host(
-          const telescope_detector::host&,
-          const covfie::field<const_bfield_backend_t<
-              telescope_detector::host::scalar_type>>::view_t&,
+          const telescope_detector::host&, const bfield&,
           const edm::track_candidate_container<default_algebra>::const_view&)>,
       public messaging {
 
@@ -59,30 +55,26 @@ class kalman_fitting_algorithm
     /// Execute the algorithm
     ///
     /// @param det             The (default) detector object
-    /// @param field           The (constant) magnetic field object
+    /// @param field           The magnetic field object
     /// @param track_candidates All track candidates to fit
     ///
     /// @return A container of the fitted track states
     ///
     output_type operator()(
-        const default_detector::host& det,
-        const covfie::field<traccc::const_bfield_backend_t<
-            default_detector::host::scalar_type>>::view_t& field,
+        const default_detector::host& det, const bfield& field,
         const edm::track_candidate_container<default_algebra>::const_view&
             track_candidates) const override;
 
     /// Execute the algorithm
     ///
     /// @param det             The (telescope) detector object
-    /// @param field           The (constant) magnetic field object
+    /// @param field           The magnetic field object
     /// @param track_candidates All track candidates to fit
     ///
     /// @return A container of the fitted track states
     ///
     output_type operator()(
-        const telescope_detector::host& det,
-        const covfie::field<traccc::const_bfield_backend_t<
-            telescope_detector::host::scalar_type>>::view_t& field,
+        const telescope_detector::host& det, const bfield& field,
         const edm::track_candidate_container<default_algebra>::const_view&
             track_candidates) const override;
 

core/include/traccc/utils/bfield.hpp

@@ -7,16 +7,100 @@
 
 #pragma once
 
+// Local include(s).
+#include "traccc/definitions/primitives.hpp"
+
+// Covfie include(s).
 #include <covfie/core/backend/primitive/constant.hpp>
+#include <covfie/core/backend/transformer/affine.hpp>
+#include <covfie/core/backend/transformer/linear.hpp>
+#include <covfie/core/backend/transformer/strided.hpp>
 #include <covfie/core/field.hpp>
 #include <covfie/core/vector.hpp>
 
+// System include(s).
+#include <any>
+
 namespace traccc {
+
+/// Typeless, owning, host-only magnetic field object
+class bfield {
+
+    public:
+    /// Default constructor
+    bfield() = default;
+
+    /// Constructor from a specific b-field object
+    ///
+    /// @tparam bfield_backend_t The backend type of the b-field object
+    /// @param obj The b-field object to construct from
+    ///
+    template <typename bfield_backend_t>
+    explicit bfield(covfie::field<bfield_backend_t>&& obj)
+        : m_field(std::move(obj)) {}
+
+    /// Set a specific b-field object
+    ///
+    /// @tparam bfield_backend_t The backend type of the b-field object
+    /// @param obj The b-field object to set
+    ///
+    template <typename bfield_backend_t>
+    void set(covfie::field<bfield_backend_t>&& obj) {
+        m_field = std::move(obj);
+    }
+
+    /// Check if the b-field is of a certain type
+    ///
+    /// @tparam bfield_backend_t The covfie backend type to check
+    /// @return @c true if the b-field is of the specified type,
+    ///         @c false otherwise
+    ///
+    template <typename bfield_backend_t>
+    bool is() const {
+        return (m_field.type() == typeid(covfie::field<bfield_backend_t>));
+    }
+
+    /// Get a b-field view object as a specific type
+    ///
+    /// @tparam bfield_backend_t The covfie backend type to use
+    /// @return The b-field view object of the specified type
+    ///
+    template <typename bfield_backend_t>
+    typename covfie::field<bfield_backend_t>::view_t as() const {
+        return typename covfie::field<bfield_backend_t>::view_t{
+            std::any_cast<const covfie::field<bfield_backend_t>&>(m_field)};
+    }
+
+    /// Get the b-field object as a specific type
+    ///
+    /// @tparam bfield_backend_t The covfie backend type to use
+    /// @return The b-field object cast to the specified type
+    ///
+    template <typename bfield_backend_t>
+    const covfie::field<bfield_backend_t>& get_covfie_field() const {
+        return std::any_cast<const covfie::field<bfield_backend_t>&>(m_field);
+    }
+
+    private:
+    /// The actualy covfie b-field object
+    std::any m_field;
+
+};  // class bfield
+
+/// Constant magnetic field backend type
 template <typename scalar_t>
 using const_bfield_backend_t =
     ::covfie::backend::constant<::covfie::vector::vector_d<scalar_t, 3>,
                                 ::covfie::vector::vector_d<scalar_t, 3>>;
 
+/// Inhomogeneous magnetic field backend type
+template <typename scalar_t>
+using inhom_bfield_backend_t =
+    covfie::backend::affine<covfie::backend::linear<covfie::backend::strided<
+        covfie::vector::vector_d<std::size_t, 3>,
+        covfie::backend::array<covfie::vector::vector_d<scalar_t, 3>>>>>;
+
+/// Construct a constant magnetic field object
 template <typename scalar_t>
 ::covfie::field<const_bfield_backend_t<scalar_t>> construct_const_bfield(
     scalar_t x, scalar_t y, scalar_t z) {
@@ -26,6 +110,7 @@ ::covfie::field<const_bfield_backend_t<scalar_t>> construct_const_bfield(
                                                                        z})};
 }
 
+/// Construct a constant magnetic field object
 template <typename scalar_t>
 ::covfie::field<const_bfield_backend_t<scalar_t>> construct_const_bfield(
     const vector3& v) {