B-Field Rewrite / Cleanup, main branch (2025.07.10.) (#1069)

* Re-wrote magnetic field handling in the project's libraries.

* Adapted the examples to traccc::magnetic_field.

* Adapted the tests and benchmarks to traccc::magnetic_field.

Author: krasznaa

benchmarks/common/benchmarks/toy_detector_benchmark.hpp

@@ -6,6 +6,7 @@
  */
 
 // Traccc include(s).
+#include "traccc/bfield/construct_const_bfield.hpp"
 #include "traccc/definitions/common.hpp"
 #include "traccc/finding/finding_config.hpp"
 #include "traccc/fitting/fitting_config.hpp"
@@ -17,7 +18,6 @@
 #include "traccc/simulation/measurement_smearer.hpp"
 #include "traccc/simulation/simulator.hpp"
 #include "traccc/simulation/smearing_writer.hpp"
-#include "traccc/utils/bfield.hpp"
 
 // Detray include(s).
 #include <detray/io/frontend/detector_writer.hpp>
@@ -92,7 +92,7 @@ class ToyDetectorBenchmark : public benchmark::Fixture {
             detray::build_toy_detector<algebra_type>(host_mr, get_toy_config());
 
         // B field
-        b_field_t field = traccc::construct_const_bfield<scalar_type>(B);
+        const auto field = traccc::construct_const_bfield(B);
 
         // Origin of particles
         using generator_type = detray::random_track_generator<
@@ -123,7 +123,8 @@ class ToyDetectorBenchmark : public benchmark::Fixture {
 
         auto sim = traccc::simulator<detector_type, b_field_t, generator_type,
                                      writer_type>(
-            traccc::muon<scalar_type>(), n_events, det, field,
+            traccc::muon<scalar_type>(), n_events, det,
+            field.as_field<traccc::const_bfield_backend_t<scalar_type>>(),
             std::move(generator), std::move(smearer_writer_cfg), full_path);
 
         // Same propagation configuration for sim and reco

benchmarks/cpu/toy_detector_cpu.cpp

@@ -6,6 +6,7 @@
  */
 
 // Traccc core include(s).
+#include "traccc/bfield/construct_const_bfield.hpp"
 #include "traccc/geometry/detector.hpp"
 
 // Traccc algorithm include(s).
@@ -49,7 +50,7 @@ BENCHMARK_DEFINE_F(ToyDetectorBenchmark, CPU)(benchmark::State& state) {
         sim_dir + "toy_detector_surface_grids.json");
 
     // B field
-    const traccc::bfield field{traccc::construct_const_bfield<scalar_type>(B)};
+    const auto field = traccc::construct_const_bfield(B);
 
     // Algorithms
     traccc::host::seeding_algorithm sa(seeding_cfg, grid_cfg, filter_cfg,

benchmarks/cuda/toy_detector_cuda.cpp

@@ -6,6 +6,7 @@
  */
 
 // Project include(s).
+#include "traccc/bfield/construct_const_bfield.hpp"
 #include "traccc/cuda/finding/combinatorial_kalman_filter_algorithm.hpp"
 #include "traccc/cuda/fitting/kalman_fitting_algorithm.hpp"
 #include "traccc/cuda/seeding/seeding_algorithm.hpp"
@@ -56,8 +57,7 @@ BENCHMARK_DEFINE_F(ToyDetectorBenchmark, CUDA)(benchmark::State& state) {
         sim_dir + "toy_detector_surface_grids.json");
 
     // B field
-    const traccc::bfield field{traccc::construct_const_bfield<
-        traccc::default_detector::host::scalar_type>(B)};
+    const auto field = traccc::construct_const_bfield(B);
 
     // Algorithms
     traccc::cuda::seeding_algorithm sa_cuda(seeding_cfg, grid_cfg, filter_cfg,

core/CMakeLists.txt

@@ -35,6 +35,13 @@ traccc_add_library( traccc_core core TYPE SHARED
   "include/traccc/edm/track_candidate_collection.hpp"
   "include/traccc/edm/impl/track_candidate_collection.ipp"
   "include/traccc/edm/track_candidate_container.hpp"
+  # Magnetic field description.
+  "include/traccc/bfield/magnetic_field_types.hpp"
+  "include/traccc/bfield/magnetic_field.hpp"
+  "include/traccc/bfield/impl/magnetic_field.ipp"
+  "include/traccc/bfield/construct_const_bfield.hpp"
+  "include/traccc/bfield/impl/construct_const_bfield.ipp"
+  "src/bfield/construct_const_bfield.cpp"
   # Geometry description.
   "include/traccc/geometry/detector.hpp"
   "include/traccc/geometry/module_map.hpp"

core/include/traccc/bfield/construct_const_bfield.hpp

@@ -0,0 +1,36 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2025 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Local include(s).
+#include "traccc/bfield/magnetic_field.hpp"
+#include "traccc/definitions/primitives.hpp"
+
+namespace traccc {
+
+/// Construct a constant magnetic field object
+///
+/// @tparam scalar_t The scalar type to construct the field with
+///
+/// @param x The X component of the constant field
+/// @param y The Y component of the constant field
+/// @param z The Z component of the constant field
+///
+template <typename scalar_t>
+magnetic_field construct_const_bfield(scalar_t x, scalar_t y, scalar_t z);
+
+/// Construct a constant magnetic field object
+///
+/// @param v The 3-vector describing the constant field
+///
+magnetic_field construct_const_bfield(const vector3& v);
+
+}  // namespace traccc
+
+// Include the implementation.
+#include "traccc/bfield/impl/construct_const_bfield.ipp"

core/include/traccc/bfield/impl/construct_const_bfield.ipp

@@ -0,0 +1,27 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2025 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Local include(s).
+#include "traccc/bfield/magnetic_field_types.hpp"
+
+// Covfie include(s).
+#include <covfie/core/field.hpp>
+
+namespace traccc {
+
+template <typename scalar_t>
+magnetic_field construct_const_bfield(scalar_t x, scalar_t y, scalar_t z) {
+
+    return magnetic_field{::covfie::field<const_bfield_backend_t<scalar_t>>{
+        ::covfie::make_parameter_pack(
+            typename const_bfield_backend_t<scalar_t>::configuration_t{x, y,
+                                                                       z})}};
+}
+
+}  // namespace traccc

core/include/traccc/bfield/impl/magnetic_field.ipp

@@ -0,0 +1,38 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2025 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+namespace traccc {
+
+template <covfie::concepts::field_backend bfield_backend_t>
+magnetic_field::magnetic_field(covfie::field<bfield_backend_t>&& obj)
+    : m_field(std::move(obj)) {}
+
+template <covfie::concepts::field_backend bfield_backend_t>
+void magnetic_field::set(covfie::field<bfield_backend_t>&& obj) {
+    m_field = std::move(obj);
+}
+
+template <covfie::concepts::field_backend bfield_backend_t>
+bool magnetic_field::is() const {
+    return (m_field.type() == typeid(covfie::field<bfield_backend_t>));
+}
+
+template <covfie::concepts::field_backend bfield_backend_t>
+typename covfie::field<bfield_backend_t>::view_t magnetic_field::as_view()
+    const {
+    return typename covfie::field<bfield_backend_t>::view_t{
+        std::any_cast<const covfie::field<bfield_backend_t>&>(m_field)};
+}
+
+template <covfie::concepts::field_backend bfield_backend_t>
+const covfie::field<bfield_backend_t>& magnetic_field::as_field() const {
+    return std::any_cast<const covfie::field<bfield_backend_t>&>(m_field);
+}
+
+}  // namespace traccc

core/include/traccc/bfield/magnetic_field.hpp

@@ -0,0 +1,76 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2025 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Covfie include(s).
+#include <covfie/core/concepts.hpp>
+#include <covfie/core/field.hpp>
+
+// System include(s).
+#include <any>
+
+namespace traccc {
+
+/// Typeless, owning, host-only magnetic field object
+class magnetic_field {
+
+    public:
+    /// Default constructor
+    magnetic_field() = 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 <covfie::concepts::field_backend bfield_backend_t>
+    explicit magnetic_field(covfie::field<bfield_backend_t>&& 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 <covfie::concepts::field_backend bfield_backend_t>
+    void set(covfie::field<bfield_backend_t>&& 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 <covfie::concepts::field_backend bfield_backend_t>
+    bool is() const;
+
+    /// 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 <covfie::concepts::field_backend bfield_backend_t>
+    typename covfie::field<bfield_backend_t>::view_t as_view() const;
+
+    /// 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 <covfie::concepts::field_backend bfield_backend_t>
+    const covfie::field<bfield_backend_t>& as_field() const;
+
+    private:
+    /// The actualy covfie b-field object
+    std::any m_field;
+
+};  // class magnetic_field
+
+}  // namespace traccc
+
+// Include the implementation.
+#include "traccc/bfield/impl/magnetic_field.ipp"

core/include/traccc/bfield/magnetic_field_types.hpp

@@ -0,0 +1,53 @@
+/** TRACCC library, part of the ACTS project (R&D line)
+ *
+ * (c) 2025 CERN for the benefit of the ACTS project
+ *
+ * Mozilla Public License Version 2.0
+ */
+
+#pragma once
+
+// Covfie include(s).
+#include <covfie/core/backend/primitive/constant.hpp>
+#include <covfie/core/backend/transformer/affine.hpp>
+#include <covfie/core/backend/transformer/clamp.hpp>
+#include <covfie/core/backend/transformer/linear.hpp>
+#include <covfie/core/backend/transformer/strided.hpp>
+#include <covfie/core/concepts.hpp>
+#include <covfie/core/vector.hpp>
+
+namespace traccc {
+
+/// 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>>;
+// Test that the type is a valid backend for a field
+static_assert(covfie::concepts::field_backend<const_bfield_backend_t<float>>,
+              "const_bfield_backend_t is not a valid field backend type");
+
+namespace host {
+
+/// Inhomogeneous magnetic field used for IO
+template <typename scalar_t>
+using inhom_io_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>>>>>;
+// Test that the type is a valid backend for a field
+static_assert(covfie::concepts::field_backend<inhom_io_bfield_backend_t<float>>,
+              "inhom_io_bfield_backend_t is not a valid field backend type");
+
+/// Inhomogeneous magnetic field backend type
+template <typename scalar_t>
+using inhom_bfield_backend_t = covfie::backend::affine<
+    covfie::backend::linear<covfie::backend::clamp<covfie::backend::strided<
+        covfie::vector::vector_d<std::size_t, 3>,
+        covfie::backend::array<covfie::vector::vector_d<scalar_t, 3>>>>>>;
+// Test that the type is a valid backend for a field
+static_assert(covfie::concepts::field_backend<inhom_bfield_backend_t<float>>,
+              "inhom_bfield_backend_t is not a valid field backend type");
+
+}  // namespace host
+}  // namespace traccc

core/include/traccc/finding/combinatorial_kalman_filter_algorithm.hpp

@@ -8,13 +8,13 @@
 #pragma once
 
 // Project include(s).
+#include "traccc/bfield/magnetic_field.hpp"
 #include "traccc/edm/measurement.hpp"
 #include "traccc/edm/track_candidate_collection.hpp"
 #include "traccc/edm/track_parameters.hpp"
 #include "traccc/finding/finding_config.hpp"
 #include "traccc/geometry/detector.hpp"
 #include "traccc/utils/algorithm.hpp"
-#include "traccc/utils/bfield.hpp"
 #include "traccc/utils/messaging.hpp"
 
 // VecMem include(s).
@@ -32,11 +32,11 @@ namespace traccc::host {
 ///
 class combinatorial_kalman_filter_algorithm
     : public algorithm<edm::track_candidate_collection<default_algebra>::host(
-          const default_detector::host&, const bfield&,
+          const default_detector::host&, const magnetic_field&,
           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 bfield&,
+          const telescope_detector::host&, const magnetic_field&,
           const measurement_collection_types::const_view&,
           const bound_track_parameters_collection_types::const_view&)>,
       public messaging {
@@ -55,31 +55,31 @@ class combinatorial_kalman_filter_algorithm
     /// Execute the algorithm
     ///
     /// @param det          The (default) detector object
-    /// @param field        The magnetic field object
+    /// @param bfield       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 bfield& field,
+        const default_detector::host& det, const magnetic_field& bfield,
         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 magnetic field object
+    /// @param bfield       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 bfield& field,
+        const telescope_detector::host& det, const magnetic_field& bfield,
         const measurement_collection_types::const_view& measurements,
         const bound_track_parameters_collection_types::const_view& seeds)
         const override;