Clean out sonar clous issues for core (acts-project#840)

Remove some of the issues marked as bugs and remove many issues for the core library.

Author: niermann999

core/include/detray/builders/cylinder_portal_generator.hpp

@@ -128,8 +128,10 @@ class cylinder_portal_generator final
     public:
     /// Save the boundaries of the cylinder after autofitting the portals
     struct boundaries {
-        scalar_t inner_radius{0.f}, outer_radius{0.f}, lower_z{0.f},
-            upper_z{0.f};
+        scalar_t inner_radius{0.f};
+        scalar_t outer_radius{0.f};
+        scalar_t lower_z{0.f};
+        scalar_t upper_z{0.f};
     };
 
     /// Construct from configuration @param cfg

core/include/detray/builders/detail/associator.hpp

@@ -79,7 +79,8 @@ struct center_of_gravity_generic {
         }
         cgs = 1.f / static_cast<scalar>(surface_contour.size()) * cgs;
 
-        std::size_t i, j = 0u;
+        std::size_t i = 0u;
+        std::size_t j = 0u;
         std::size_t num_points = bin_contour.size();
 
         bool inside = false;
@@ -112,7 +113,7 @@ struct edges_intersect_generic {
                     const std::vector<point2_t> &surface_contour) {
 
         auto intersect = [](const point2_t &pi, const point2_t &pj,
-                            const point2_t &pk, const point2_t &pl) -> bool {
+                            const point2_t &pk, const point2_t &pl) {
             scalar d = (pj[0] - pi[0]) * (pl[1] - pk[1]) -
                        (pj[1] - pi[1]) * (pl[0] - pk[0]);
 

core/include/detray/builders/grid_factory.hpp

@@ -66,11 +66,6 @@ class grid_factory {
     explicit grid_factory(vecmem::memory_resource &resource)
         : m_resource(&resource) {}
 
-    /// Print grid - up to three dimensions
-    /// @note will likely become obsolete with the actsvg implementation
-    template <typename grid_t>
-    auto to_string(const grid_t &) const noexcept -> void;
-
     //
     // annulus 2D
     //
@@ -513,8 +508,8 @@ class grid_factory {
         std::enable_if_t<std::is_object_v<typename grid_frame_t::loc_point>,
                          bool> = true>
     auto new_grid(
-        const std::vector<scalar_type> spans,
-        const std::vector<std::size_t> n_bins,
+        const std::vector<scalar_type> &spans,
+        const std::vector<std::size_t> &n_bins,
         const std::vector<std::pair<axis::multi_bin<sizeof...(bound_ts)>,
                                     dindex>> &bin_capacities = {},
         const std::vector<std::vector<scalar_type>> &ax_bin_edges = {},
@@ -539,8 +534,8 @@ class grid_factory {
         std::enable_if_t<std::is_enum_v<typename grid_shape_t::boundaries>,
                          bool> = true>
     auto new_grid(
-        const std::vector<scalar_type> spans,
-        const std::vector<std::size_t> n_bins,
+        const std::vector<scalar_type> &spans,
+        const std::vector<std::size_t> &n_bins,
         const std::vector<std::pair<axis::multi_bin<sizeof...(bound_ts)>,
                                     dindex>> &bin_capacities = {},
         const std::vector<std::vector<scalar_type>> &ax_bin_edges = {},
@@ -705,73 +700,6 @@ class grid_factory {
     vecmem::memory_resource *m_resource{};
 };
 
-template <typename bin_t, template <std::size_t> class serializer_t,
-          typename algebra_t>
-template <typename grid_t>
-auto grid_factory<bin_t, serializer_t, algebra_t>::to_string(
-    const grid_t &gr) const noexcept -> void {
-
-    using entry_t = typename grid_t::bin_type;
-
-    // Loop over the first dimension
-    const auto &ax0 = gr.template get_axis<0>();
-    std::cout << "{";
-    for (unsigned int i{0u}; i < ax0.nbins(); ++i) {
-
-        // Loop over the second dimension
-        if constexpr (grid_t::dim > 1u) {
-            const auto &ax1 = gr.template get_axis<1>();
-            std::cout << "{";
-            for (unsigned int j{0u}; j < ax1.nbins(); ++j) {
-
-                // Loop over the third dimension
-                if constexpr (grid_t::dim > 2) {
-                    const auto &ax2 = gr.template get_axis<2>();
-                    std::cout << "{";
-                    for (unsigned int k{0u}; k < ax2.nbins(); ++k) {
-
-                        // Print the bin content - three dimensions
-                        std::cout << "( ";
-                        for (const auto &entry : gr.bin(i, j, k)) {
-                            if (entry == detail::invalid_value<entry_t>()) {
-                                std::cout << "none ";
-                            } else {
-                                std::cout << entry << " ";
-                            }
-                        }
-                        std::cout << ")";
-                    }
-                    std::cout << "}" << std::endl << std::endl;
-                } else {
-                    // Print the bin content - two dimensions
-                    std::cout << "( ";
-                    for (const auto &entry : gr.bin(i, j)) {
-                        if (entry == detail::invalid_value<entry_t>()) {
-                            std::cout << "none ";
-                        } else {
-                            std::cout << entry << " ";
-                        }
-                    }
-                    std::cout << ")";
-                }
-            }
-            std::cout << "}" << std::endl;
-        } else {
-            // Print the bin content - one dimension
-            std::cout << "( ";
-            for (const auto &entry : gr.bin(i)) {
-                if (entry == detail::invalid_value<entry_t>()) {
-                    std::cout << "none ";
-                } else {
-                    std::cout << entry << " ";
-                }
-            }
-            std::cout << ")" << std::endl;
-        }
-    }
-    std::cout << "}" << std::endl;
-}
-
 // Infer a grid factory type from an already completely assembled grid type
 template <typename grid_t, typename algebra_t = ALGEBRA_PLUGIN<detray::scalar>>
 using grid_factory_type =

core/include/detray/builders/homogeneous_material_factory.hpp

@@ -19,6 +19,7 @@
 #include <cassert>
 #include <memory>
 #include <numeric>
+#include <ranges>
 #include <tuple>
 #include <type_traits>
 #include <vector>
@@ -36,7 +37,7 @@ class material_data {
     DETRAY_HOST
     explicit constexpr material_data(
         const std::size_t sf_idx = detail::invalid_value<std::size_t>())
-        : m_sf_index{sf_idx}, m_mat{}, m_thickness{} {}
+        : m_sf_index{sf_idx} {}
 
     /// Construct from a predefined material
     ///
@@ -97,12 +98,12 @@ class material_data {
     DETRAY_HOST
     void append(material_data &&other) {
         m_mat.reserve(m_mat.size() + other.m_mat.size());
-        std::move(other.m_mat.begin(), other.m_mat.end(),
-                  std::back_inserter(m_mat));
+        std::ranges::move(other.m_mat.begin(), other.m_mat.end(),
+                          std::back_inserter(m_mat));
 
         m_thickness.reserve(m_thickness.size() + other.m_thickness.size());
-        std::move(other.m_thickness.begin(), other.m_thickness.end(),
-                  std::back_inserter(m_thickness));
+        std::ranges::move(other.m_thickness.begin(), other.m_thickness.end(),
+                          std::back_inserter(m_thickness));
     }
 
     /// Append new material
@@ -130,7 +131,7 @@ class material_data {
     /// The material parametrization
     std::vector<material<scalar_t>> m_mat{};
     /// Thickness/radius of the material slab/rod
-    std::vector<scalar_t> m_thickness{0.f};
+    std::vector<scalar_t> m_thickness{};
 };
 
 /// @brief Factory class for homogeneous material.
@@ -203,7 +204,11 @@ class homogeneous_material_factory final
         material_id id, material_data<scalar_type> &&mat_data,
         std::size_t index = detail::invalid_value<std::size_t>()) {
 
-        auto [sf_index, mat, thickness] = mat_data.get_data();
+        auto [sf_index, mat, thickness] = std::move(mat_data).get_data();
+
+        // Only one homogeneous material slab/rod per surface
+        assert(mat.size() == 1u);
+        assert(thickness.size() == 1u);
 
         m_links.push_back(std::make_pair(id, static_cast<dindex>(index)));
         m_indices.push_back(sf_index);

core/include/detray/builders/homogeneous_material_generator.hpp

@@ -159,7 +159,10 @@ class homogeneous_material_generator final
                         err_stream.str());
                     break;
                 }
-            };
+                default: {
+                    break;
+                }
+            }
 
             // Found suitable material for this surface?
             if (mat_ptr == nullptr) {

core/include/detray/builders/material_map_builder.hpp

@@ -112,13 +112,14 @@ class material_map_builder final : public volume_decorator<detector_t> {
         auto vol = tracking_volume{det, this->vol_index()};
         for (const auto& sf_desc : vol.surfaces()) {
 
-            if (!surface_has_map(sf_idx++)) {
+            if (!surface_has_map(sf_idx)) {
+                sf_idx++;
                 continue;
             }
 
             // Construct and append the material map for a given surface shape
             std::array<std::vector<scalar_type>, DIM> axis_spans{};
-            auto axis_spans_itr = m_axis_spans.find(sf_idx - 1u);
+            auto axis_spans_itr = m_axis_spans.find(sf_idx);
             if (axis_spans_itr != m_axis_spans.end()) {
                 axis_spans = axis_spans_itr->second;
             }
@@ -127,12 +128,13 @@ class material_map_builder final : public volume_decorator<detector_t> {
             auto sf = tracking_surface{det, sf_desc};
             [[maybe_unused]] auto [mat_id, mat_idx] = sf.template visit_mask<
                 detail::add_sf_material_map<materials_t>>(
-                m_factory, m_bin_data.at(sf_idx - 1u), m_n_bins.at(sf_idx - 1u),
+                m_factory, m_bin_data.at(sf_idx), m_n_bins.at(sf_idx),
                 axis_spans, det.material_store());
 
             // Make sure the linking was precomputed correctly
             assert(mat_id == sf_desc.material().id());
             assert(mat_idx == sf_desc.material().index());
+            sf_idx++;
         }
 
         // Give the volume to the next decorator
@@ -155,7 +157,8 @@ class material_map_builder final : public volume_decorator<detector_t> {
 
         dindex sf_idx{0u};
         for (auto& sf_desc : this->surfaces()) {
-            if (!surface_has_map(sf_idx++)) {
+            if (!surface_has_map(sf_idx)) {
+                sf_idx++;
                 continue;
             }
 
@@ -168,6 +171,7 @@ class material_map_builder final : public volume_decorator<detector_t> {
             }
 
             sf_desc.material().set_index(mat_type_count.at(id));
+            sf_idx++;
         }
 
         // Current sizes of the material stores
@@ -178,11 +182,13 @@ class material_map_builder final : public volume_decorator<detector_t> {
         // Update the counts with the detector offset
         sf_idx = 0u;
         for (auto& sf_desc : this->surfaces()) {
-            if (!surface_has_map(sf_idx++)) {
+            if (!surface_has_map(sf_idx)) {
+                sf_idx++;
                 continue;
             }
             auto coll_idx{static_cast<std::size_t>(sf_desc.material().id())};
             sf_desc.material() += size_map.at(coll_idx);
+            sf_idx++;
         }
     }
 

core/include/detray/builders/material_map_factory.hpp

@@ -108,7 +108,7 @@ class material_map_factory final : public factory_decorator<detector_t> {
                       std::vector<std::vector<scalar_type>> &&axis_spans,
                       std::vector<index_type> &&indices) {
 
-        auto [sf_index, mat, thickness] = mat_data.get_data();
+        auto [sf_index, mat, thickness] = std::move(mat_data).get_data();
 
         m_links[sf_index] = std::make_pair(id, std::move(indices));
         m_n_bins[sf_index] = std::move(n_bins);

core/include/detray/builders/material_map_generator.hpp

@@ -123,7 +123,7 @@ struct material_map_config {
     bool has_config(mask_id_t map_type, surface_id sf_type) const {
         const auto key =
             std::make_pair(static_cast<unsigned int>(map_type), sf_type);
-        return (m_map_configs.find(key) != m_map_configs.end());
+        return m_map_configs.contains(key);
     }
     template <typename mask_id_t>
     const auto &get_map_config(mask_id_t map_type, surface_id sf_type) const {

core/include/detray/builders/surface_factory.hpp

@@ -150,7 +150,7 @@ class surface_factory : public surface_factory_interface<detector_t> {
                     typename detector_t::geometry_context ctx = {})
         -> dindex_range override {
         // In case the surfaces container is prefilled with other surfaces
-        const dindex surfaces_offset = static_cast<dindex>(surfaces.size());
+        const auto surfaces_offset{static_cast<dindex>(surfaces.size())};
 
         // Nothing to construct
         if (size() == 0u) {

core/include/detray/builders/volume_builder.hpp

@@ -39,8 +39,7 @@ class volume_builder : public volume_builder_interface<detector_t> {
     ///
     /// @param id flags the type of volume geometry (e.g. cylindrical, cuboid)
     /// @param idx the index of the volume in the detector volume container
-    volume_builder(const volume_id id, const dindex idx = 0)
-        : m_has_accel{false}, m_volume{id} {
+    volume_builder(const volume_id id, const dindex idx = 0) : m_volume{id} {
 
         m_volume.set_index(idx);
         m_volume.set_material(volume_type::material_id::e_none, 0u);

core/include/detray/core/detail/container_buffers.hpp

@@ -173,13 +173,11 @@ auto get_buffer(
 
     // TODO: Move this to detray copy util, which bundles vecmem copy object and
     // stream handle and gets this switch case right automatically
-    switch (cpy_type) {
-        case detray::copy::async:
-            cpy(vec_view, buff /*, stream*/);
-            break;
-        default:
-            cpy(vec_view, buff)->wait();
-    };
+    if (cpy_type == detray::copy::async) {
+        cpy(vec_view, buff /*, stream*/);
+    } else {
+        cpy(vec_view, buff)->wait();
+    }
 
     return buff;
 }