SplineBuilder doc

benchmarks/splines.cpp

@@ -132,11 +132,11 @@ static void characteristics_advection(benchmark::State& state)
             DDimY>
             spline_evaluator(periodic_extrapolation, periodic_extrapolation);
     ddc::Chunk coef_alloc(
-            spline_builder.spline_domain(),
+            spline_builder.batched_spline_domain(),
             ddc::KokkosAllocator<double, Kokkos::DefaultExecutionSpace::memory_space>());
     ddc::ChunkSpan coef = coef_alloc.span_view();
     ddc::Chunk feet_coords_alloc(
-            spline_builder.vals_domain(),
+            spline_builder.batched_interpolation_domain(),
             ddc::KokkosAllocator<
                     ddc::Coordinate<X, Y>,
                     Kokkos::DefaultExecutionSpace::memory_space>());

examples/characteristics_advection.cpp

@@ -239,13 +239,13 @@ int main(int argc, char** argv)
     //! [instantiate intermediate chunks]
     // Instantiate chunk of spline coefs to receive output of spline_builder
     ddc::Chunk coef_alloc(
-            spline_builder.spline_domain(),
+            spline_builder.batched_spline_domain(),
             ddc::DeviceAllocator<double>());
     ddc::ChunkSpan coef = coef_alloc.span_view();
 
     // Instantiate chunk to receive feet coords
     ddc::Chunk feet_coords_alloc(
-            spline_builder.vals_domain(),
+            spline_builder.batched_interpolation_domain(),
             ddc::DeviceAllocator<ddc::Coordinate<X>>());
     ddc::ChunkSpan feet_coords = feet_coords_alloc.span_view();
     //! [instantiate intermediate chunks]

include/ddc/kernels/splines/bsplines_uniform.hpp

@@ -24,6 +24,12 @@ struct UniformBSplinesBase
 {
 };
 
+/**
+ * The type of a uniform BSplines 1D basis.
+ *
+ * @tparam Tag The tag identifying the continuous dimension which supports the building of the BSplines.
+ * @tparam D The degree of the BSplines.
+ */
 template <class Tag, std::size_t D>
 class UniformBSplines : UniformBSplinesBase
 {

include/ddc/kernels/splines/greville_interpolation_points.hpp

@@ -15,7 +15,7 @@
 namespace ddc {
 
 /**
- * A class which provides helper functions to initialise the Greville points from a B-Spline definition.
+ * A class which provides helper functions to initialize the Greville points from a B-Spline definition.
  *
  * @tparam BSplines The bspline class relative to which the Greville points will be calculated.
  * @tparam BcXmin The (left) boundary condition that will be used to build the splines.

include/ddc/kernels/splines/null_extrapolation_rule.hpp

@@ -6,6 +6,9 @@
 
 namespace ddc {
 
+/**
+ * @brief A functor for describing a spline boundary value by a null extrapolation for 1D evaluator.
+ */
 struct NullExtrapolationRule
 {
     template <class CoordType, class ChunkSpan>

include/ddc/kernels/splines/spline_builder.hpp

@@ -10,10 +10,26 @@
 #include "deriv.hpp"
 
 namespace ddc {
+
+/**
+ * @brief An enum determining the backend solver of a SplineBuilder or SplineBuilder2d.
+ *
+ * An enum determining the backend solver of a SplineBuilder or SplineBuilder2d. Only GINKGO available at the moment,
+ * other solvers will be implemented in the futur.
+ */
 enum class SplineSolver {
     GINKGO
-}; // Only GINKGO available atm, other solvers will be implemented in the futur
+};
 
+/**
+ * @brief An helper giving the uniform/non_uniform status of a spline interpolation mesh according to its attributes.
+ *
+ * An helper giving the uniform/non_uniform status of a spline interpolation mesh according to its attributes.
+ * @param is_uniform A boolean giving the presumed status before considering boundary conditions.
+ * @param BcXmin The Xmin boundary condition.
+ * @param BcXmax The Xmax boundary condition.
+ * @param int The degree of the spline.
+ */
 constexpr bool is_spline_interpolation_mesh_uniform(
         bool const is_uniform,
         ddc::BoundCond const BcXmin,
@@ -34,6 +50,14 @@ constexpr bool is_spline_interpolation_mesh_uniform(
  * of BSplines. The spline is constructed such that it respects the boundary conditions
  * BcXmin and BcXmax, and it interpolates the function at the points on the interpolation_mesh
  * associated with interpolation_mesh_type.
+ * @tparam ExecSpace The Kokkos execution space on which the spline transform is performed.
+ * @tparam MemorySpace The Kokkos memory space on which the data (interpolation function and splines coefficients) are stored.
+ * @tparam BSplines The BSplines dimension.
+ * @tparam InterpolationMesh The discrete dimension supporting the interpolation points.
+ * @tparam BcXmin The Xmin boundary condition.
+ * @tparam BcXmax The Xmax boundary condition.
+ * @tparam Solver The SplineSolver giving the backend used to perform the spline transform.
+ * @tparam IDimX A variadic template of all the discrete dimensions forming the full space (InterpolationMesh + batched dimensions).
  */
 template <
         class ExecSpace,
@@ -57,52 +81,70 @@ class SplineBuilder
     using tag_type = typename InterpolationMesh::continuous_dimension_type;
 
 public:
+    /**
+     * @brief The type of the Kokkos execution space used by this class.
+     */
     using exec_space = ExecSpace;
 
+    /**
+     * @brief The type of the Kokkos memory space used by this class.
+     */
     using memory_space = MemorySpace;
 
     /**
-     * @brief The type of the interpolation mesh used by this class.
+     * @brief The type of the interpolation mesh (discrete dimension of interest) used by this class.
      */
     using interpolation_mesh_type = InterpolationMesh;
 
     /**
-     * @brief The type of the BSplines which are compatible with this class.
+     * @brief The BSplines dimension.
      */
     using bsplines_type = BSplines;
 
+	/**
+     * @brief The deriv dimension at the boundaries.
+     */
     using deriv_type = ddc::Deriv<tag_type>;
 
     /**
      * @brief The type of the domain for the interpolation mesh used by this class.
      */
     using interpolation_domain_type = ddc::DiscreteDomain<interpolation_mesh_type>;
 
-    using vals_domain_type = ddc::DiscreteDomain<IDimX...>;
+    /**
+     * @brief The type of the whole domain representing interpolation points.
+     */
+    using batched_interpolation_domain_type = ddc::DiscreteDomain<IDimX...>;
 
+    /**
+     * @brief The type of the batch domain (obtained by removing dimension of interest from whole space).
+     */
     using batch_domain_type =
             typename ddc::detail::convert_type_seq_to_discrete_domain<ddc::type_seq_remove_t<
                     ddc::detail::TypeSeq<IDimX...>,
                     ddc::detail::TypeSeq<interpolation_mesh_type>>>;
 
+	/**
+     * @brief The dimension WIP.
+     */
     template <typename Tag>
     using spline_dim_type
             = std::conditional_t<std::is_same_v<Tag, interpolation_mesh_type>, bsplines_type, Tag>;
 
-    using spline_domain_type =
+    using batched_spline_domain_type =
             typename ddc::detail::convert_type_seq_to_discrete_domain<ddc::type_seq_replace_t<
                     ddc::detail::TypeSeq<IDimX...>,
                     ddc::detail::TypeSeq<interpolation_mesh_type>,
                     ddc::detail::TypeSeq<bsplines_type>>>;
 
-    using spline_tr_domain_type =
+    using batched_spline_tr_domain_type =
             typename ddc::detail::convert_type_seq_to_discrete_domain<ddc::type_seq_merge_t<
                     ddc::detail::TypeSeq<bsplines_type>,
                     ddc::type_seq_remove_t<
                             ddc::detail::TypeSeq<IDimX...>,
                             ddc::detail::TypeSeq<interpolation_mesh_type>>>>;
 
-    using derivs_domain_type =
+    using batched_derivs_domain_type =
             typename ddc::detail::convert_type_seq_to_discrete_domain<ddc::type_seq_replace_t<
                     ddc::detail::TypeSeq<IDimX...>,
                     ddc::detail::TypeSeq<interpolation_mesh_type>,
@@ -152,7 +194,7 @@ class SplineBuilder
     static constexpr ddc::BoundCond s_bc_xmax = BcXmax;
 
 private:
-    vals_domain_type m_vals_domain;
+    batched_interpolation_domain_type m_batched_interpolation_domain;
 
     int m_offset;
 
@@ -165,10 +207,10 @@ class SplineBuilder
     int compute_offset(interpolation_domain_type const& interpolation_domain);
 
     explicit SplineBuilder(
-            vals_domain_type const& vals_domain,
+            batched_interpolation_domain_type const& batched_interpolation_domain,
             std::optional<int> cols_per_chunk = std::nullopt,
             std::optional<unsigned int> preconditionner_max_block_size = std::nullopt)
-        : m_vals_domain(vals_domain)
+        : m_batched_interpolation_domain(batched_interpolation_domain)
         , m_offset(compute_offset(interpolation_domain()))
         , m_dx((ddc::discrete_space<BSplines>().rmax() - ddc::discrete_space<BSplines>().rmin())
                / ddc::discrete_space<BSplines>().ncells())
@@ -212,9 +254,9 @@ class SplineBuilder
      */
     SplineBuilder& operator=(SplineBuilder&& x) = default;
 
-    vals_domain_type vals_domain() const noexcept
+    batched_interpolation_domain_type batched_interpolation_domain() const noexcept
     {
-        return m_vals_domain;
+        return m_batched_interpolation_domain;
     }
 
     /**
@@ -227,15 +269,15 @@ class SplineBuilder
      */
     interpolation_domain_type interpolation_domain() const noexcept
     {
-        return interpolation_domain_type(vals_domain());
+        return interpolation_domain_type(batched_interpolation_domain());
     }
 
     batch_domain_type batch_domain() const noexcept
     {
-        return ddc::remove_dims_of(vals_domain(), interpolation_domain());
+        return ddc::remove_dims_of(batched_interpolation_domain(), interpolation_domain());
     }
 
-    ddc::DiscreteDomain<bsplines_type> bsplines_domain() const noexcept // TODO : clarify name
+    ddc::DiscreteDomain<bsplines_type> spline_domain() const noexcept
     {
         return ddc::discrete_space<bsplines_type>().full_domain();
     }
@@ -248,31 +290,31 @@ class SplineBuilder
      *
      * @return The domain for the splines.
      */
-    spline_domain_type spline_domain() const noexcept
+    batched_spline_domain_type batched_spline_domain() const noexcept
     {
         return ddc::replace_dim_of<
                 interpolation_mesh_type,
-                bsplines_type>(vals_domain(), bsplines_domain());
+                bsplines_type>(batched_interpolation_domain(), spline_domain());
     }
 
-    spline_tr_domain_type spline_tr_domain() const noexcept
+    batched_spline_tr_domain_type spline_tr_domain() const noexcept
     {
-        return spline_tr_domain_type(bsplines_domain(), batch_domain());
+        return batched_spline_tr_domain_type(spline_domain(), batch_domain());
     }
 
-    derivs_domain_type derivs_xmin_domain() const noexcept
+    batched_derivs_domain_type derivs_xmin_domain() const noexcept
     {
         return ddc::replace_dim_of<interpolation_mesh_type, deriv_type>(
-                vals_domain(),
+                batched_interpolation_domain(),
                 ddc::DiscreteDomain<deriv_type>(
                         ddc::DiscreteElement<deriv_type>(1),
                         ddc::DiscreteVector<deriv_type>(s_nbc_xmin)));
     }
 
-    derivs_domain_type derivs_xmax_domain() const noexcept
+    batched_derivs_domain_type derivs_xmax_domain() const noexcept
     {
         return ddc::replace_dim_of<interpolation_mesh_type, deriv_type>(
-                vals_domain(),
+                batched_interpolation_domain(),
                 ddc::DiscreteDomain<deriv_type>(
                         ddc::DiscreteElement<deriv_type>(1),
                         ddc::DiscreteVector<deriv_type>(s_nbc_xmax)));
@@ -309,15 +351,20 @@ class SplineBuilder
      */
     template <class Layout>
     void operator()(
-            ddc::ChunkSpan<double, spline_domain_type, Layout, memory_space> spline,
-            ddc::ChunkSpan<double const, vals_domain_type, Layout, memory_space> vals,
-            std::optional<
-                    ddc::ChunkSpan<double const, derivs_domain_type, Layout, memory_space>> const
-                    derivs_xmin
+            ddc::ChunkSpan<double, batched_spline_domain_type, Layout, memory_space> spline,
+            ddc::ChunkSpan<double const, batched_interpolation_domain_type, Layout, memory_space>
+                    vals,
+            std::optional<ddc::ChunkSpan<
+                    double const,
+                    batched_derivs_domain_type,
+                    Layout,
+                    memory_space>> const derivs_xmin
             = std::nullopt,
-            std::optional<
-                    ddc::ChunkSpan<double const, derivs_domain_type, Layout, memory_space>> const
-                    derivs_xmax
+            std::optional<ddc::ChunkSpan<
+                    double const,
+                    batched_derivs_domain_type,
+                    Layout,
+                    memory_space>> const derivs_xmax
             = std::nullopt) const;
 
 private:
@@ -629,12 +676,18 @@ void SplineBuilder<
         Solver,
         IDimX...>::
 operator()(
-        ddc::ChunkSpan<double, spline_domain_type, Layout, memory_space> spline,
-        ddc::ChunkSpan<double const, vals_domain_type, Layout, memory_space> vals,
-        std::optional<ddc::ChunkSpan<double const, derivs_domain_type, Layout, memory_space>> const
-                derivs_xmin,
-        std::optional<ddc::ChunkSpan<double const, derivs_domain_type, Layout, memory_space>> const
-                derivs_xmax) const
+        ddc::ChunkSpan<double, batched_spline_domain_type, Layout, memory_space> spline,
+        ddc::ChunkSpan<double const, batched_interpolation_domain_type, Layout, memory_space> vals,
+        std::optional<ddc::ChunkSpan<
+                double const,
+                batched_derivs_domain_type,
+                Layout,
+                memory_space>> const derivs_xmin,
+        std::optional<ddc::ChunkSpan<
+                double const,
+                batched_derivs_domain_type,
+                Layout,
+                memory_space>> const derivs_xmax) const
 {
     assert(vals.template extent<interpolation_mesh_type>()
            == ddc::discrete_space<bsplines_type>().nbasis() - s_nbe_xmin - s_nbe_xmax);