feat: adding operator== for grids (and material grids) (#884)

This PR adds the necessary operator== to make grids comparable.

It also adds unit tests for the comparisons of grids, particularly for material grids.

Author: asalzburger

core/include/detray/utils/grid/detail/axis.hpp

@@ -83,6 +83,13 @@ struct single_axis {
                                    const vector_type<scalar_type> *edges)
         : m_binning(indx_range, edges) {}
 
+    /// Equality operator
+    ///
+    /// @param rhs is the right-hand side of the comparison
+    ///
+    /// @returns whether the two axes are equal
+    constexpr bool operator==(const single_axis &rhs) const = default;
+
     /// @returns the axis label, i.e. x, y, z, r or phi axis.
     DETRAY_HOST_DEVICE
     constexpr auto label() const -> axis::label { return bounds_type::label; }
@@ -401,6 +408,25 @@ class multi_axis {
                                detray::get_data(m_edges)};
     }
 
+    /// Equality operator
+    ///
+    /// @param rhs the right-hand side of the comparison
+    ///
+    /// @note in the non-owning case, we compare the values not the pointers
+    ///
+    /// @returns whether the two axes are equal
+    DETRAY_HOST_DEVICE constexpr auto operator==(const multi_axis &rhs) const
+        -> bool {
+        if constexpr (!std::is_pointer_v<edge_range_t>) {
+            return m_edge_offsets == rhs.m_edge_offsets &&
+                   m_edges == rhs.m_edges;
+        } else {
+            return m_edge_offsets == rhs.m_edge_offsets &&
+                   *m_edges == *rhs.m_edges;
+        }
+        return false;
+    }
+
     private:
     /// Get the number of bins for a single axis.
     ///

core/include/detray/utils/grid/detail/axis_binning.hpp

@@ -167,6 +167,19 @@ struct regular {
 
         return {min, max};
     }
+
+    /// Equality operator
+    ///
+    /// @param rhs the axis to compare to
+    ///
+    /// @note as we cannot guarantee to have the same pointer for the bin edges,
+    /// we make a fast comparison of the pointer first, but also allow for a
+    /// value based comparison
+    ///
+    /// @returns whether the two axes are equal
+    DETRAY_HOST_DEVICE constexpr bool operator==(const regular &rhs) const {
+        return (nbins() == rhs.nbins()) && (span() == rhs.span());
+    }
 };
 
 /// @brief An irregular binning scheme.
@@ -306,6 +319,36 @@ struct irregular {
 
         return {min, max};
     }
+
+    /// Equality operator
+    ///
+    /// @param rhs the axis to compare to
+    ///
+    /// @note as we cannot guarantee to have the same pointer for the bin edges,
+    /// we make a fast comparison of the pointer first, but also allow for a
+    /// value based comparison
+    ///
+    /// @returns whether the two axes are equal
+    DETRAY_HOST_DEVICE constexpr bool operator==(const irregular &rhs) const {
+        if (m_n_bins != rhs.m_n_bins) {
+            return false;
+        }
+        if (m_offset == rhs.m_offset && m_bin_edges == rhs.m_bin_edges) {
+            return true;
+        }
+        auto edge_range_lhs = detray::ranges::subrange(
+            *m_bin_edges, dindex_range{m_offset, m_offset + m_n_bins});
+        auto edge_range_rhs = detray::ranges::subrange(
+            *rhs.m_bin_edges,
+            dindex_range{rhs.m_offset, rhs.m_offset + rhs.m_n_bins});
+
+        for (dindex i = 0; i < m_n_bins; ++i) {
+            if (edge_range_lhs[i] != edge_range_rhs[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
 };
 
 }  // namespace detray::axis

core/include/detray/utils/grid/detail/axis_bounds.hpp

@@ -87,6 +87,13 @@ struct open {
                             const std::size_t nbins) const noexcept {
         return map(range[0], range[1], nbins);
     }
+
+    /// Equality operator
+    ///
+    /// @param rhs the open axis to compare with
+    ///
+    /// @returns whether the two axes are equal
+    constexpr bool operator==(const open &rhs) const = default;
 };
 
 /// @brief Describes the behaviour of a closed axis.
@@ -155,6 +162,13 @@ struct closed {
                             const std::size_t nbins) const {
         return map(range[0], range[1], nbins);
     }
+
+    /// Equality operator
+    ///
+    /// @param rhs the open axis to compare with
+    ///
+    /// @returns whether the two axes are equal
+    constexpr bool operator==(const closed &rhs) const = default;
 };
 
 /// @brief Describes the behaviour of a circular axis.
@@ -241,6 +255,13 @@ struct circular {
                              const std::size_t nbins) const noexcept {
         return wrap(range[0], range[1], nbins);
     }
+
+    /// Equality operator
+    ///
+    /// @param rhs the open axis to compare with
+    ///
+    /// @returns whether the two axes are equal
+    constexpr bool operator==(const circular &rhs) const = default;
 };
 
 }  // namespace detray::axis

core/include/detray/utils/grid/detail/bin_storage.hpp

@@ -112,6 +112,16 @@ class bin_storage : public detray::ranges::view_interface<
         return detray::get_data(m_bin_data);
     }
 
+    /// Equality operator
+    ///
+    /// @param rhs bin storage to compare with
+    ///
+    /// @returns true if the bin data is equal
+    DETRAY_HOST_DEVICE
+    constexpr bool operator==(const bin_storage& rhs) const {
+        return m_bin_data == rhs.m_bin_data;
+    }
+
     private:
     /// Container that holds all bin data when owning or a view into an
     /// externally owned container
@@ -453,6 +463,16 @@ class bin_storage<is_owning, detray::bins::dynamic_array<entry_t>, containers>
                                detray::get_data(m_entry_data)};
     }
 
+    /// Equality operator
+    ///
+    /// @param rhs bin storage to compare with
+    ///
+    /// @returns true if the bin data is equal
+    DETRAY_HOST_DEVICE
+    constexpr bool operator==(const bin_storage& rhs) const {
+        return m_bin_data == rhs.m_bin_data && m_entry_data == rhs.m_entry_data;
+    }
+
     private:
     /// Container that holds all bin data when owning or a view into an
     /// externally owned container

core/include/detray/utils/grid/detail/grid_bins.hpp

@@ -51,6 +51,16 @@ class single : public detray::ranges::single_view<entry_t> {
         (*this).ref() = entry;
         return *this;
     }
+
+    /// Equality operator
+    ///
+    /// @param rhs the single view to compare with
+    ///
+    /// @returns true if the single value is equal
+    DETRAY_HOST_DEVICE
+    constexpr bool operator==(const single& rhs) const {
+        return (*this).value() == rhs.value();
+    }
 };
 
 /// @brief Bin that holds a collection of entries.
@@ -153,6 +163,16 @@ class static_array
         return *this;
     }
 
+    /// Equality operator
+    ///
+    /// @param rhs the bin entry to compare with
+    ///
+    /// @returns true if the content is equal
+    DETRAY_HOST_DEVICE
+    constexpr bool operator==(const static_array& rhs) const {
+        return m_content == rhs.m_content;
+    }
+
     private:
     /// @returns the subrange on the valid bin content - const
     DETRAY_HOST_DEVICE constexpr auto view() const {
@@ -187,6 +207,8 @@ class dynamic_array
         dindex size{0u};
         dindex capacity{0u};
 
+        constexpr bool operator==(const data& rhs) const = default;
+
         DETRAY_HOST_DEVICE
         constexpr void update_offset(std::size_t shift) {
             offset += static_cast<dindex>(shift);
@@ -304,6 +326,33 @@ class dynamic_array
         return *this;
     }
 
+    /// Equality operator
+    ///
+    /// @param rhs the bin to be compared with
+    ///
+    /// @returns true if the view is identical
+    DETRAY_HOST_DEVICE
+    constexpr bool operator==(const dynamic_array& rhs) const {
+        // Check if the bin points to the same data
+        if (m_data == rhs.m_data || *m_data == *rhs.m_data) {
+            return true;
+        }
+        if (m_data->size != rhs.m_data->size) {
+            return false;
+        }
+        // It could still point to different data, but the
+        // content is the same
+        auto this_view = view();
+        auto rhs_view = rhs.view();
+        // Loop over the size of the bin and compare
+        for (dindex i{0u}; i < m_data->size; ++i) {
+            if (this_view[i] != rhs_view[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     private:
     /// @returns the subrange on the valid bin content - const
     DETRAY_HOST_DEVICE auto view() const {

core/include/detray/utils/grid/grid.hpp

@@ -361,6 +361,29 @@ class grid_impl {
                                detray::get_data(m_axes)};
     }
 
+    /// Equality comparison
+    ///
+    /// @param rhs the right-hand side of the comparison
+    ///
+    /// @note grids could have different bin storage ranges, but could still be
+    /// identical, hence compare the actual grid content
+    ///
+    /// @returns whether the two grids are equal
+    DETRAY_HOST_DEVICE constexpr auto operator==(const grid_impl &rhs) const
+        -> bool {
+        // Check axes: they need to be identical
+        if (m_axes != rhs.m_axes) {
+            return false;
+        }
+        // Loop over global bin index and compare the two
+        for (glob_bin_index i = 0; i < nbins(); ++i) {
+            if (bin(i) != rhs.bin(i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     private:
     /// Struct that contains the grid's data state
     bin_storage m_bins{};

core/include/detray/utils/ranges/subrange.hpp

@@ -87,6 +87,16 @@ class subrange : public detray::ranges::view_interface<subrange<range_t>> {
     DETRAY_HOST_DEVICE
     constexpr auto end() const -> const_iterator_t { return m_end; }
 
+    /// Equality operator
+    ///
+    /// @param rhs the subrange to compare with
+    ///
+    /// @returns whether the two subranges are equal
+    DETRAY_HOST_DEVICE
+    constexpr auto operator==(const subrange &rhs) const -> bool {
+        return m_begin == rhs.m_begin && m_end == rhs.m_end;
+    }
+
     private:
     /// Start and end position of the subrange
     iterator_t m_begin;

tests/unit_tests/cpu/material/material_maps.cpp

@@ -265,3 +265,49 @@ GTEST_TEST(detray_material, trapezoid_map) {
     EXPECT_FALSE(trapezoid_map.at(199, 0) ==
                  material_t(aluminium<scalar>{}, 201.f * unit<scalar>::mm));
 }
+
+/// Unittest: Test the material grid comparisons
+GTEST_TEST(detray_material, material_grid_comparison) {
+
+    /** Allows to create a regular grid to check the equality opeartor
+     * grids can differ in:
+     * - type (will never be compared)
+     * - bins/axes
+     * - entries (i.e. material data)
+     */
+    auto createGrid = [](const scalar hx, const scalar hy, unsigned int bx,
+                         unsigned int by, bool distort_entries) {
+        mask<rectangle2D> r2{0u, hx, hy};
+        auto material_grid = mat_map_factory.new_grid(r2, {bx, by});
+
+        // Fill the material grid with some data
+        scalar thickness = 2.f * unit<scalar>::mm;
+        for (dindex gbin = 0; gbin < material_grid.nbins(); ++gbin) {
+            material_grid.template populate<replace<>>(
+                gbin, material_t(oxygen_gas<scalar>{}, thickness));
+            thickness += 1.f * unit<scalar>::mm;
+            if (distort_entries) {
+                thickness += 1.f * unit<scalar>::mm;
+            }
+        }
+        // Return it
+        return material_grid;
+    };
+
+    // Two equal grids
+    auto grid_ref = createGrid(10.f, 20.f, 10u, 20u, false);
+    auto grid_eq = createGrid(10.f, 20.f, 10u, 20u, false);
+    EXPECT_EQ(grid_ref, grid_eq);
+
+    // One grid with different size
+    auto grid_neq_size = createGrid(11.f, 21.f, 10u, 20u, false);
+    EXPECT_NE(grid_ref, grid_neq_size);
+
+    // One grid with different binning
+    auto grid_neq_bins = createGrid(10.f, 20.f, 11u, 21u, false);
+    EXPECT_NE(grid_ref, grid_neq_bins);
+
+    // One grid with different entries
+    auto grid_neq_entries = createGrid(10.f, 20.f, 10u, 20u, true);
+    EXPECT_NE(grid_ref, grid_neq_entries);
+}