From 0c10faad439c10be32fa9f2545d0496051f9c148 Mon Sep 17 00:00:00 2001
From: Emily Bourne <emily.bourne@epfl.ch>
Date: Mon, 21 Oct 2024 19:33:43 +0200
Subject: [PATCH] Add MultipatchField types

Add two new multipatch types:
- `MultipatchField` : To store all `Field` types (`Field`, `VectorField`, `DerivField`)
- `MultipatchFieldMem` : To store all `FieldMem` types (`FieldMem`, `VectorFieldMem`, `DerivFieldMem`)

The `MultipatchField` type is useful to provide all the aliases usually provided by `Field` types.
The `MultipatchFieldMem` type is necessary to allow these types to have `__host__` only versions of the functions in `MultipatchField`.

2 utility booleans are added:
- `has_data_access_methods_v` : To tell if a type is a `Field` type on which data access methods can be called:
     - `get_idx_range`
     - `get_field`
     - `get_const_field`
- `is_mem_type_v` : To tell if a type might allocate a chunk of memory (`FieldMem`, `VectorFieldMem`, `DerivFieldMem`)

These booleans are activated via `enable_X` booleans.

See merge request gysela-developpers/gyselalibxx!735

--------------------------------------------
---
 ci_tools/gyselalib_static_analysis.py         |   2 +-
 src/data_types/derivative_field.hpp           |  11 +-
 src/data_types/derivative_field_mem.hpp       |  13 +-
 src/data_types/vector_field.hpp               |  10 +
 src/data_types/vector_field_mem.hpp           |   9 +
 .../data_types/multipatch_field.hpp           | 189 ++++++++++++++++++
 .../data_types/multipatch_field_mem.hpp       | 175 ++++++++++++++++
 src/multipatch/data_types/multipatch_type.hpp |  50 ++---
 src/multipatch/data_types/types.hpp           |  10 +-
 .../spline/multipatch_spline_evaluator_2d.hpp |   4 +-
 src/utils/ddc_alias_inline_functions.hpp      |  67 ++++++-
 .../data_types/multipatch_field_2p.cpp        |  11 +-
 .../data_types/multipatch_field_9p.cpp        |   3 +-
 .../constant_extrapolation_rules_onion.cpp    |   7 +-
 .../spline/multipatch_spline_builder.cpp      |  16 +-
 .../spline/multipatch_spline_builder_2d.cpp   |  49 +++--
 .../spline/multipatch_spline_evaluator.cpp    |  29 +--
 .../spline/null_extrapolation_rules.cpp       |   7 +-
 .../spline/spline_testing_tools.hpp           |   5 +-
 19 files changed, 561 insertions(+), 106 deletions(-)
 create mode 100644 src/multipatch/data_types/multipatch_field.hpp
 create mode 100644 src/multipatch/data_types/multipatch_field_mem.hpp

diff --git a/ci_tools/gyselalib_static_analysis.py b/ci_tools/gyselalib_static_analysis.py
index 6fcd314f3..3b8e9faf6 100644
--- a/ci_tools/gyselalib_static_analysis.py
+++ b/ci_tools/gyselalib_static_analysis.py
@@ -48,7 +48,7 @@
 HOME_DIR = Path(__file__).parent.parent.absolute()
 global_folders = [HOME_DIR / f for f in ('src', 'simulations', 'tests')]
 
-auto_functions = set()
+auto_functions = set(['build_kokkos_layout'])
 field_mem_functions = set()
 
 def report_error(level, file, linenr, message):
diff --git a/src/data_types/derivative_field.hpp b/src/data_types/derivative_field.hpp
index 6b0e0aa02..0c1b056ef 100644
--- a/src/data_types/derivative_field.hpp
+++ b/src/data_types/derivative_field.hpp
@@ -27,6 +27,10 @@ template <class ElementType, class SupportType, class LayoutStridedPolicy, class
 inline constexpr bool enable_borrowed_deriv_field<
         DerivField<ElementType, SupportType, LayoutStridedPolicy, MemorySpace>> = true;
 
+template <class ElementType, class SupportType, class LayoutStridedPolicy, class MemorySpace>
+inline constexpr bool enable_data_access_methods<
+        DerivField<ElementType, SupportType, LayoutStridedPolicy, MemorySpace>> = true;
+
 namespace ddcHelper {
 
 /**
@@ -170,7 +174,7 @@ class DerivField<ElementType, IdxRange<DDims...>, LayoutStridedPolicy, MemorySpa
     using reference = typename chunk_type::reference;
 
     /// @brief The number of chunks which must be created to describe this object.
-    static constexpr int n_fields = base_type::n_fields;
+    using base_type::n_fields;
 
 private:
     /** @brief Get the subindex range to be extracted from a DerivFieldMem to build the internal_chunk at position ArrayIndex
@@ -251,7 +255,8 @@ class DerivField<ElementType, IdxRange<DDims...>, LayoutStridedPolicy, MemorySpa
             int NDerivs,
             class Allocator,
             class = std::enable_if_t<std::is_same_v<typename Allocator::memory_space, MemorySpace>>>
-    constexpr DerivField(DerivFieldMem<OElementType, index_range_type, NDerivs, Allocator>& field)
+    explicit constexpr DerivField(
+            DerivFieldMem<OElementType, index_range_type, NDerivs, Allocator>& field)
         : base_type(
                 field.m_physical_idx_range,
                 field.m_deriv_idx_range,
@@ -273,7 +278,7 @@ class DerivField<ElementType, IdxRange<DDims...>, LayoutStridedPolicy, MemorySpa
             int NDerivs,
             class Allocator,
             class = std::enable_if_t<std::is_same_v<typename Allocator::memory_space, MemorySpace>>>
-    constexpr DerivField(
+    explicit constexpr DerivField(
             DerivFieldMem<OElementType, index_range_type, NDerivs, Allocator> const& field)
         : base_type(
                 field.m_physical_idx_range,
diff --git a/src/data_types/derivative_field_mem.hpp b/src/data_types/derivative_field_mem.hpp
index afc30dada..4a97f1bcf 100644
--- a/src/data_types/derivative_field_mem.hpp
+++ b/src/data_types/derivative_field_mem.hpp
@@ -3,6 +3,7 @@
 #pragma once
 #include <ddc/ddc.hpp>
 
+#include "ddc_alias_inline_functions.hpp"
 #include "ddc_aliases.hpp"
 #include "derivative_field.hpp"
 #include "derivative_field_common.hpp"
@@ -17,6 +18,14 @@ template <class ElementType, class SupportType, int NDerivs, class MemSpace>
 inline constexpr bool
         enable_deriv_field<DerivFieldMem<ElementType, SupportType, NDerivs, MemSpace>> = true;
 
+template <class ElementType, class SupportType, int NDerivs, class Allocator>
+inline constexpr bool enable_data_access_methods<
+        DerivFieldMem<ElementType, SupportType, NDerivs, Allocator>> = true;
+
+template <class ElementType, class SupportType, int NDerivs, class Allocator>
+inline constexpr bool
+        enable_mem_type<DerivFieldMem<ElementType, SupportType, NDerivs, Allocator>> = true;
+
 
 /**
  * @brief A class which holds a chunk of memory describing a field and its derivatives.
@@ -132,7 +141,7 @@ class DerivFieldMem<ElementType, IdxRange<DDims...>, NDerivs, MemSpace>
     using internal_mdspan_type = typename base_type::internal_mdspan_type;
 
     /// @brief The number of chunks which must be created to describe this object.
-    static constexpr int n_fields = base_type::n_fields;
+    using base_type::n_fields;
 
 private:
     /// @brief A function to get the index range along direction Tag for the ArrayIndex-th element of internal_fields.
@@ -354,7 +363,7 @@ class DerivFieldMem<ElementType, IdxRange<DDims...>, NDerivs, MemSpace>
      */
     span_type span_view()
     {
-        return *this;
+        return span_type(*this);
     }
 };
 
diff --git a/src/data_types/vector_field.hpp b/src/data_types/vector_field.hpp
index e938bdfe3..21812a26c 100644
--- a/src/data_types/vector_field.hpp
+++ b/src/data_types/vector_field.hpp
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: MIT
 
 #pragma once
+#include "ddc_alias_inline_functions.hpp"
 #include "ddc_aliases.hpp"
 #include "vector_field_mem.hpp"
 
@@ -22,6 +23,15 @@ template <
 inline constexpr bool enable_field<
         VectorField<ElementType, IdxRangeType, NDTag, LayoutStridedPolicy, MemorySpace>> = true;
 
+template <
+        class ElementType,
+        class IdxRangeType,
+        class NDTag,
+        class LayoutStridedPolicy,
+        class MemorySpace>
+inline constexpr bool enable_data_access_methods<
+        VectorField<ElementType, IdxRangeType, NDTag, LayoutStridedPolicy, MemorySpace>> = true;
+
 template <
         class ElementType,
         class IdxRangeType,
diff --git a/src/data_types/vector_field_mem.hpp b/src/data_types/vector_field_mem.hpp
index 734b2aeab..1ea90a5de 100644
--- a/src/data_types/vector_field_mem.hpp
+++ b/src/data_types/vector_field_mem.hpp
@@ -3,6 +3,7 @@
 #pragma once
 #include <ddc/ddc.hpp>
 
+#include "ddc_alias_inline_functions.hpp"
 #include "ddc_aliases.hpp"
 #include "vector_field_common.hpp"
 
@@ -21,6 +22,14 @@ template <class ElementType, class IdxRangeType, class DimSeq, class MemSpace>
 inline constexpr bool
         enable_field<VectorFieldMem<ElementType, IdxRangeType, DimSeq, MemSpace>> = true;
 
+template <class ElementType, class IdxRangeType, class DimSeq, class Allocator>
+inline constexpr bool enable_data_access_methods<
+        VectorFieldMem<ElementType, IdxRangeType, DimSeq, Allocator>> = true;
+
+template <class ElementType, class IdxRangeType, class DimSeq, class Allocator>
+inline constexpr bool
+        enable_mem_type<VectorFieldMem<ElementType, IdxRangeType, DimSeq, Allocator>> = true;
+
 /**
  * @brief Pre-declaration of VectorField.
  */
diff --git a/src/multipatch/data_types/multipatch_field.hpp b/src/multipatch/data_types/multipatch_field.hpp
new file mode 100644
index 000000000..abf19f697
--- /dev/null
+++ b/src/multipatch/data_types/multipatch_field.hpp
@@ -0,0 +1,189 @@
+// SPDX-License-Identifier: MIT
+
+#pragma once
+#include "multipatch_type.hpp"
+
+
+/**
+ * @brief A class to store field objects on patches.
+ *
+ * On a multipatch domain when we have objects and types defined on different patches, e.g. fields.
+ * They can be stored in this class and then be accessed by the patch they are defined
+ * on.
+ *
+ * @tparam T The type of the fields/derivative fields/vector fields that are stored on the given patches.
+ * @tparam Patches The patches of the objects in the same order of the patches
+ *                 that the given objects are defined on.
+ *
+ * @warning The objects have to be defined on different patches. Otherwise retrieving
+ *          them by their patch is ill-defined.
+ */
+template <template <typename P> typename T, class... Patches>
+class MultipatchField : public MultipatchType<T, Patches...>
+{
+    static_assert(
+            (has_data_access_methods_v<T<Patches>> && ...),
+            "The MultipatchField type should only contain instances of objects that can be "
+            "manipulated like fields.");
+
+public:
+    /// @brief The MultipatchType from which this class inherits
+    using base_type = MultipatchType<T, Patches...>;
+
+    /// @brief A tag storing the order of Patches in this MultipatchField
+    using typename base_type::PatchOrdering;
+
+private:
+    /// An internal type alias that is only instantiated if the idx_range method is called.
+    template <class Patch>
+    using InternalIdxRangeOnPatch = typename T<Patch>::discrete_domain_type;
+
+    /// An internal type alias that is only instantiated if the get_const_field method is called.
+    template <class Patch>
+    using InternalFieldOnPatch = typename T<Patch>::span_type;
+
+    /// An internal type alias that is only instantiated if the get_const_field method is called.
+    template <class Patch>
+    using InternalConstFieldOnPatch = typename T<Patch>::view_type;
+
+    template <template <typename P> typename OT, class... OPatches>
+    friend class MultipatchField;
+
+    using example_element = T<ddc::type_seq_element_t<0, PatchOrdering>>;
+
+    static_assert(
+            !is_mem_type_v<example_element>,
+            "For correct GPU handling a FieldMem object must be saved in a MultipatchFieldMem "
+            "type.");
+
+public:
+    /// The type of a modifiable reference to this multipatch field
+    using span_type = MultipatchField<InternalFieldOnPatch, Patches...>;
+    /// The type of a constant reference to this multipatch field
+    using view_type = MultipatchField<InternalConstFieldOnPatch, Patches...>;
+    /// The type of the index ranges that can be used to access this field.
+    using discrete_domain_type = MultipatchType<InternalIdxRangeOnPatch, Patches...>;
+    /// The memory space (CPU/GPU) where the data is saved.
+    using memory_space = typename example_element::memory_space;
+    /// The type of the elements inside the field.
+    using element_type = typename example_element::element_type;
+
+public:
+    /**
+     * Instantiate the MultipatchField class from an arbitrary number of objects.
+     *
+     * @param args The objects to be stored in the class.
+     */
+    explicit KOKKOS_FUNCTION MultipatchField(T<Patches>... args) : base_type(args...) {}
+
+    /**
+     * Create a MultipatchField class by copying an instance of another compatible MultipatchField.
+     *
+     * A compatible MultipatchField is one which uses all the patches used by this class. The object
+     * being copied may include more patches than this MultipatchField. Further the original
+     * MultipatchField must store objects of the correct type (the type template may be different
+     * but return the same type depending on how it is designed).
+     *
+     * @param other The equivalent MultipatchField being copied.
+     */
+    template <class MultipatchObj, std::enable_if_t<!is_mem_type_v<MultipatchObj>, bool> = true>
+    KOKKOS_FUNCTION MultipatchField(MultipatchObj& other)
+        : base_type(std::move(T<Patches>(other.template get<Patches>()))...)
+    {
+    }
+
+    /**
+     * Create a MultipatchField class from a compatible MultipatchFieldMem.
+     *
+     * A compatible MultipatchField is one which uses all the patches used by this class. The object
+     * being copied may include more patches than this MultipatchField. Further the original
+     * MultipatchField must store objects of the correct type.
+     *
+     * @param other The MultipatchFieldMem being accessed.
+     */
+    template <class MultipatchObj, std::enable_if_t<is_mem_type_v<MultipatchObj>, bool> = true>
+    MultipatchField(MultipatchObj& other)
+        : base_type(std::move(T<Patches>(other.template get<Patches>()))...)
+    {
+    }
+
+    /**
+     * Create a MultipatchField class from an r-value (temporary) instance of another MultipatchField which
+     * uses the same type for the internal tuple.
+     *
+     * @param other The equivalent MultipatchField being copied.
+     */
+    template <template <typename P> typename OT, class... OPatches>
+    MultipatchField(MultipatchField<OT, OPatches...>&& other) : base_type(other)
+    {
+        static_assert(
+                std::is_same_v<ddc::detail::TypeSeq<Patches...>, ddc::detail::TypeSeq<OPatches...>>,
+                "Cannot create a MultipatchField from a temporary MultipatchField with a different "
+                "ordering");
+        static_assert(
+                std::is_same_v<std::tuple<T<Patches>...>, std::tuple<OT<OPatches>...>>,
+                "MultipatchFields are not equivalent");
+    }
+
+    KOKKOS_FUNCTION ~MultipatchField() {}
+
+    /**
+     * Retrieve an object from the patch that it is defined on.
+     *
+     * @tparam Patch The patch of the object to be returned.
+     * @return The object on the given patch.
+     */
+    template <class Patch>
+    KOKKOS_FUNCTION auto get() const
+    {
+        return ::get_const_field(std::get<T<Patch>>(base_type::m_tuple));
+    }
+
+    /**
+     * Retrieve an object from the patch that it is defined on.
+     *
+     * @tparam Patch The patch of the object to be returned.
+     * @return The object on the given patch.
+     */
+    template <class Patch>
+    KOKKOS_FUNCTION auto get()
+    {
+        return ::get_field(std::get<T<Patch>>(base_type::m_tuple));
+    }
+
+    /**
+     * @brief Get a MultipatchType containing the index ranges on which the fields are defined.
+     *
+     * @returns The set of index ranges on which the set of fields stored in this class are defined.
+     */
+    auto idx_range() const
+    {
+        return MultipatchType<InternalIdxRangeOnPatch, Patches...>(
+                get_idx_range(std::get<T<Patches>>(base_type::m_tuple))...);
+    }
+
+    /**
+     * @brief Get a MultipatchField containing modifiable fields.
+     *
+     * @returns A set of modifiable fields providing access to the fields stored in this class.
+     */
+    KOKKOS_FUNCTION auto get_field()
+    {
+        return MultipatchField<InternalFieldOnPatch, Patches...>(
+                ::get_field(std::get<T<Patches>>(base_type::m_tuple))...);
+    }
+
+    /**
+     * @brief Get a MultipatchField containing constant fields so the values cannot be modified.
+     *
+     * @returns A set of constant fields providing access to the fields stored in this class.
+     */
+    KOKKOS_FUNCTION auto get_const_field() const
+    {
+        return MultipatchField<InternalConstFieldOnPatch, Patches...>(
+                ::get_const_field(std::get<T<Patches>>(base_type::m_tuple))...);
+    }
+};
+
+template <template <typename P> typename T, class... Patches>
+inline constexpr bool enable_multipatch_type<MultipatchField<T, Patches...>> = true;
diff --git a/src/multipatch/data_types/multipatch_field_mem.hpp b/src/multipatch/data_types/multipatch_field_mem.hpp
new file mode 100644
index 000000000..052aa19ca
--- /dev/null
+++ b/src/multipatch/data_types/multipatch_field_mem.hpp
@@ -0,0 +1,175 @@
+// SPDX-License-Identifier: MIT
+#pragma once
+
+#include "multipatch_field.hpp"
+#include "multipatch_type.hpp"
+
+
+/**
+ * @brief A class to store field memory block objects on patches.
+ *
+ * On a multipatch domain when we have objects and types defined on different patches, e.g. FieldMems.
+ * They can be stored in this class and then be accessed by the patch they are defined
+ * on.
+ *
+ * @tparam T The type of the FieldMem/DerivMem/VectorFieldMem that are stored on the given patches.
+ * @tparam Patches The patches of the objects in the same order of the patches
+ *                 that the given objects are defined on.
+ *
+ * @warning The objects have to be defined on different patches. Otherwise retrieving
+ *          them by their patch is ill-defined.
+ */
+template <template <typename P> typename T, class... Patches>
+class MultipatchFieldMem : public MultipatchType<T, Patches...>
+{
+    static_assert(
+            (has_data_access_methods_v<T<Patches>> && ...),
+            "The MultipatchFieldMem type should only contain instances of objects that can be "
+            "manipulated like fields.");
+
+public:
+    /// @brief The MultipatchType from which this class inherits
+    using base_type = MultipatchType<T, Patches...>;
+
+    /// @brief A tag storing the order of Patches in this MultipatchFieldMem
+    using typename base_type::PatchOrdering;
+
+private:
+    /// An internal type alias that is only instantiated if the idx_range method is called.
+    template <class Patch>
+    using InternalIdxRangeOnPatch = typename T<Patch>::discrete_domain_type;
+
+    /// An internal type alias that is only instantiated if the get_const_field method is called.
+    template <class Patch>
+    using InternalFieldOnPatch = typename T<Patch>::span_type;
+
+    /// An internal type alias that is only instantiated if the get_const_field method is called.
+    template <class Patch>
+    using InternalConstFieldOnPatch = typename T<Patch>::view_type;
+
+    template <template <typename P> typename OT, class... OPatches>
+    friend class MultipatchFieldMem;
+
+    using example_element = T<ddc::type_seq_element_t<0, PatchOrdering>>;
+
+public:
+    /// The type of a modifiable reference to this multipatch field
+    using span_type = MultipatchField<InternalFieldOnPatch, Patches...>;
+    /// The type of a constant reference to this multipatch field
+    using view_type = MultipatchField<InternalConstFieldOnPatch, Patches...>;
+    /// The type of the index ranges that can be used to access this field.
+    using discrete_domain_type = MultipatchType<InternalIdxRangeOnPatch, Patches...>;
+    /// The memory space (CPU/GPU) where the data is saved.
+    using memory_space = typename example_element::memory_space;
+    /// The type of the elements inside the field.
+    using element_type = typename example_element::element_type;
+
+public:
+    /**
+     * Instantiate the MultipatchFieldMem class from an arbitrary number of objects.
+     *
+     * @param args The objects to be stored in the class.
+     */
+    explicit MultipatchFieldMem(T<Patches>... args) : base_type(args...) {}
+
+    /**
+     * Create a MultipatchFieldMem class by copying an instance of another compatible MultipatchFieldMem.
+     *
+     * A compatible MultipatchFieldMem is one which uses all the patches used by this class. The object
+     * being copied may include more patches than this MultipatchFieldMem. Further the original
+     * MultipatchFieldMem must store objects of the correct type (the type template may be different
+     * but return the same type depending on how it is designed.
+     *
+     * @param other The equivalent MultipatchFieldMem being copied.
+     */
+    template <class MultipatchObj>
+    MultipatchFieldMem(MultipatchObj& other)
+        : base_type(std::move(T<Patches>(other.template get<Patches>()))...)
+    {
+        static_assert(is_multipatch_type_v<MultipatchObj>);
+    }
+
+    /**
+     * Create a MultipatchFieldMem class from an r-value (temporary) instance of another MultipatchFieldMem which
+     * uses the same type for the internal tuple.
+     *
+     * @param other The equivalent MultipatchFieldMem being copied.
+     */
+    template <template <typename P> typename OT, class... OPatches>
+    MultipatchFieldMem(MultipatchFieldMem<OT, OPatches...>&& other) : base_type(other)
+    {
+        static_assert(
+                std::is_same_v<ddc::detail::TypeSeq<Patches...>, ddc::detail::TypeSeq<OPatches...>>,
+                "Cannot create a MultipatchFieldMem from a temporary MultipatchFieldMem with a "
+                "different "
+                "ordering");
+        static_assert(
+                std::is_same_v<std::tuple<T<Patches>...>, std::tuple<OT<OPatches>...>>,
+                "MultipatchFieldMems are not equivalent");
+    }
+
+    ~MultipatchFieldMem() {}
+
+    /**
+     * Retrieve an object from the patch that it is defined on.
+     *
+     * @tparam Patch The patch of the object to be returned.
+     * @return The object on the given patch.
+     */
+    template <class Patch>
+    auto get() const
+    {
+        return ::get_const_field(std::get<T<Patch>>(base_type::m_tuple));
+    }
+
+    /**
+     * Retrieve an object from the patch that it is defined on.
+     *
+     * @tparam Patch The patch of the object to be returned.
+     * @return The object on the given patch.
+     */
+    template <class Patch>
+    auto get()
+    {
+        return ::get_field(std::get<T<Patch>>(base_type::m_tuple));
+    }
+
+    /**
+     * @brief Get a MultipatchType containing the index ranges on which the fields are defined.
+     *
+     * @returns The set of index ranges on which the set of fields stored in this class are defined.
+     */
+    auto idx_range() const
+    {
+        return MultipatchType<InternalIdxRangeOnPatch, Patches...>(
+                get_idx_range(std::get<T<Patches>>(base_type::m_tuple))...);
+    }
+
+    /**
+     * @brief Get a MultipatchField containing modifiable fields.
+     *
+     * @returns A set of modifiable fields providing access to the fields stored in this class.
+     */
+    auto get_field()
+    {
+        return MultipatchFieldMem<InternalFieldOnPatch, Patches...>(
+                ::get_field(std::get<T<Patches>>(base_type::m_tuple))...);
+    }
+
+    /**
+     * @brief Get a MultipatchConstField containing constant fields so the values cannot be modified.
+     *
+     * @returns A set of constant fields providing access to the fields stored in this class.
+     */
+    auto get_const_field() const
+    {
+        return MultipatchFieldMem<InternalConstFieldOnPatch, Patches...>(
+                ::get_const_field(std::get<T<Patches>>(base_type::m_tuple))...);
+    }
+};
+
+template <template <typename P> typename T, class... Patches>
+inline constexpr bool enable_multipatch_type<MultipatchFieldMem<T, Patches...>> = true;
+
+template <template <typename P> typename T, class... Patches>
+inline constexpr bool enable_mem_type<MultipatchFieldMem<T, Patches...>> = true;
diff --git a/src/multipatch/data_types/multipatch_type.hpp b/src/multipatch/data_types/multipatch_type.hpp
index 28e61d195..bf0b52156 100644
--- a/src/multipatch/data_types/multipatch_type.hpp
+++ b/src/multipatch/data_types/multipatch_type.hpp
@@ -5,6 +5,13 @@
 #include "ddc_aliases.hpp"
 #include "types.hpp"
 
+template <class T>
+inline constexpr bool enable_multipatch_type = false;
+
+template <class T>
+inline constexpr bool is_multipatch_type_v
+        = enable_multipatch_type<std::remove_const_t<std::remove_reference_t<T>>>;
+
 
 /**
  * @brief A class to store several objects that are of a type which is templated by the patch.
@@ -27,17 +34,10 @@ class MultipatchType
     /// @brief A tag storing the order of Patches in this MultipatchType
     using PatchOrdering = ddc::detail::TypeSeq<Patches...>;
 
-private:
+protected:
+    /// The internal tuple containing the data
     std::tuple<T<Patches>...> m_tuple;
 
-    /// An internal type alias that is only instantiated if the idx_range method is called.
-    template <class Patch>
-    using InternalIdxRangeOnPatch = typename T<Patch>::discrete_domain_type;
-
-    /// An internal type alias that is only instantiated if the get_const_field method is called.
-    template <class Patch>
-    using InternalConstFieldOnPatch = typename T<Patch>::view_type;
-
     template <template <typename P> typename OT, class... OPatches>
     friend class MultipatchType;
 
@@ -47,7 +47,10 @@ class MultipatchType
      * 
      * @param args The objects to be stored in the class.
      */
-    explicit MultipatchType(T<Patches>... args) : m_tuple(std::make_tuple(args...)) {}
+    explicit KOKKOS_FUNCTION MultipatchType(T<Patches>... args)
+        : m_tuple(std::make_tuple(std::move(args)...))
+    {
+    }
 
     /**
      * Create a MultipatchType class by copying an instance of another compatible MultipatchType.
@@ -112,30 +115,6 @@ class MultipatchType
         return sizeof...(Patches);
     }
 
-    /**
-     * @brief Get a MultipatchType containing the index ranges on which the fields are defined.
-     * This function can only be called if the current MultipatchType stores fields.
-     *
-     * @returns The set of index ranges on which the set of fields stored in this class are defined.
-     */
-    auto idx_range() const
-    {
-        return MultipatchType<InternalIdxRangeOnPatch, Patches...>(
-                get_idx_range(std::get<T<Patches>>(m_tuple))...);
-    }
-
-    /**
-     * @brief Get a MultipatchType containing constant fields so the values cannot be modified.
-     * This function can only be called if the current MultipatchType stores fields.
-     *
-     * @returns A set of constant fields providing access to the fields stored in this class.
-     */
-    auto get_const_field() const
-    {
-        return MultipatchType<InternalConstFieldOnPatch, Patches...>(
-                ::get_const_field(std::get<T<Patches>>(m_tuple))...);
-    }
-
     /**
      * @brief Get a constant reference to the tuple of objects stored inside this MultipatchType.
      *
@@ -146,3 +125,6 @@ class MultipatchType
         return m_tuple;
     }
 };
+
+template <template <typename P> typename T, class... Patches>
+inline constexpr bool enable_multipatch_type<MultipatchType<T, Patches...>> = true;
diff --git a/src/multipatch/data_types/types.hpp b/src/multipatch/data_types/types.hpp
index 43a2c2aef..fd57b7557 100644
--- a/src/multipatch/data_types/types.hpp
+++ b/src/multipatch/data_types/types.hpp
@@ -19,10 +19,18 @@ using Grid2OnPatch = typename Patch::Grid2;
 
 // FIELDS ----------------------------------------------------------------------------------------
 
-/// @brief A FieldMem defined on the Patch's 2D logical domain. This type should not be used in a MultipatchType.
+/// @brief A FieldMem defined on the Patch's 2D logical domain.
 template <class Patch>
 using DFieldMemOnPatch = DFieldMem<typename Patch::IdxRange12>;
 
+/// @brief A FieldMem defined on the Patch's first logical domain.
+template <class Patch>
+using DFieldMem1OnPatch = DFieldMem<typename Patch::IdxRange1>;
+
+/// @brief A FieldMem defined on the Patch's first logical domain.
+template <class Patch>
+using DFieldMem2OnPatch = DFieldMem<typename Patch::IdxRange2>;
+
 /// @brief Type for MultipatchType: A Field defined on the Patch's 2D logical domain.
 template <class Patch>
 using DFieldOnPatch = DField<typename Patch::IdxRange12>;
diff --git a/src/multipatch/spline/multipatch_spline_evaluator_2d.hpp b/src/multipatch/spline/multipatch_spline_evaluator_2d.hpp
index c99e4eef2..8ec330273 100644
--- a/src/multipatch/spline/multipatch_spline_evaluator_2d.hpp
+++ b/src/multipatch/spline/multipatch_spline_evaluator_2d.hpp
@@ -183,8 +183,8 @@ class MultipatchSplineEvaluator2D
 private:
     // MultipatchTypes
     using MultipatchValues = MultipatchType<ValuesOnPatch, Patches...>;
-    using MultipatchCoordField = MultipatchType<CoordConstFieldOnPatch, Patches...>;
-    using MultipatchSplineCoeff = MultipatchType<SplineCoeffOnPatch, Patches...>;
+    using MultipatchCoordField = MultipatchField<CoordConstFieldOnPatch, Patches...>;
+    using MultipatchSplineCoeff = MultipatchField<SplineCoeffOnPatch, Patches...>;
 
     // Patches
     using PatchOrdering = ddc::detail::TypeSeq<Patches...>;
diff --git a/src/utils/ddc_alias_inline_functions.hpp b/src/utils/ddc_alias_inline_functions.hpp
index 0ee192df8..40b1d9838 100644
--- a/src/utils/ddc_alias_inline_functions.hpp
+++ b/src/utils/ddc_alias_inline_functions.hpp
@@ -64,6 +64,35 @@ class IsGslxField
 };
 
 } // namespace detail
+//
+template <class T>
+inline constexpr bool enable_data_access_methods = false;
+
+template <class T>
+inline constexpr bool enable_mem_type = false;
+
+template <class ElementType, class IdxRangeType, class LayoutType, class MemoryType>
+inline constexpr bool
+        enable_data_access_methods<Field<ElementType, IdxRangeType, LayoutType, MemoryType>> = true;
+
+template <class ElementType, class IdxRangeType, class MemoryType>
+inline constexpr bool
+        enable_data_access_methods<FieldMem<ElementType, IdxRangeType, MemoryType>> = true;
+
+template <class ElementType, class IdxRangeType, class MemoryType>
+inline constexpr bool enable_mem_type<FieldMem<ElementType, IdxRangeType, MemoryType>> = true;
+
+template <class PolarBSplines>
+inline constexpr bool enable_data_access_methods<PolarSpline<PolarBSplines>> = true;
+
+template <class PolarBSplines>
+inline constexpr bool enable_data_access_methods<PolarSplineView<PolarBSplines>> = true;
+
+template <class PolarBSplines>
+inline constexpr bool enable_data_access_methods<PolarSplineSpan<PolarBSplines>> = true;
+
+template <class PolarBSplines>
+inline constexpr bool enable_mem_type<PolarSpline<PolarBSplines>> = true;
 
 template <typename Type>
 static constexpr bool has_idx_range_v = detail::HasIdxRange<Type>::value;
@@ -71,6 +100,14 @@ static constexpr bool has_idx_range_v = detail::HasIdxRange<Type>::value;
 template <typename Type>
 static constexpr bool is_gslx_field_v = detail::IsGslxField<Type>::value;
 
+template <typename Type>
+inline constexpr bool has_data_access_methods_v
+        = enable_data_access_methods<std::remove_const_t<std::remove_reference_t<Type>>>;
+
+template <class Type>
+inline constexpr bool is_mem_type_v
+        = enable_mem_type<std::remove_const_t<std::remove_reference_t<Type>>>;
+
 /**
  * A function to get the range of valid indices that can be used to index this field.
  *
@@ -118,13 +155,20 @@ inline auto get_spline_idx_range(SplineBuilder const& builder) noexcept
  * @param[in] field The field memory object.
  * @returns The modifiable field.
  */
-template <class FieldType>
+template <class FieldType, std::enable_if_t<!is_mem_type_v<FieldType>, bool> = true>
+KOKKOS_INLINE_FUNCTION auto get_field(FieldType&& field)
+{
+    static_assert(
+            has_data_access_methods_v<FieldType>,
+            "Not a Field or FieldMem (ddc::Chunk or ddc::ChunkSpan) type");
+    return field.span_view();
+}
+
+template <class FieldType, std::enable_if_t<is_mem_type_v<FieldType>, bool> = true>
 inline auto get_field(FieldType&& field)
 {
-    using Type = std::remove_cv_t<std::remove_reference_t<FieldType>>;
     static_assert(
-            (ddc::is_chunk_v<Type>) || (is_field_v<Type>) || (is_deriv_field_v<Type>)
-                    || (is_polar_spline_v<Type>),
+            has_data_access_methods_v<FieldType>,
             "Not a Field or FieldMem (ddc::Chunk or ddc::ChunkSpan) type");
     return field.span_view();
 }
@@ -135,13 +179,20 @@ inline auto get_field(FieldType&& field)
  * @param[in] field The field memory object.
  * @returns The constant field.
  */
-template <class FieldType>
+template <class FieldType, std::enable_if_t<!is_mem_type_v<FieldType>, bool> = true>
+KOKKOS_INLINE_FUNCTION auto get_const_field(FieldType&& field)
+{
+    static_assert(
+            has_data_access_methods_v<FieldType>,
+            "Not a Field or FieldMem (ddc::Chunk or ddc::ChunkSpan) type");
+    return field.span_cview();
+}
+
+template <class FieldType, std::enable_if_t<is_mem_type_v<FieldType>, bool> = true>
 inline auto get_const_field(FieldType&& field)
 {
-    using Type = std::remove_cv_t<std::remove_reference_t<FieldType>>;
     static_assert(
-            (ddc::is_chunk_v<Type>) || (is_field_v<Type>) || (is_deriv_field_v<Type>)
-                    || (is_polar_spline_v<Type>) || (is_gslx_field_v<Type>),
+            has_data_access_methods_v<FieldType>,
             "Not a Field or FieldMem (ddc::Chunk or ddc::ChunkSpan) type");
     return field.span_cview();
 }
diff --git a/tests/multipatch/data_types/multipatch_field_2p.cpp b/tests/multipatch/data_types/multipatch_field_2p.cpp
index 64c42537a..84a0b5c81 100644
--- a/tests/multipatch/data_types/multipatch_field_2p.cpp
+++ b/tests/multipatch/data_types/multipatch_field_2p.cpp
@@ -13,6 +13,7 @@
 #include "2patches_2d_non_periodic_uniform.hpp"
 #include "ddc_alias_inline_functions.hpp"
 #include "ddc_aliases.hpp"
+#include "multipatch_field.hpp"
 #include "multipatch_type.hpp"
 #include "patch.hpp"
 #include "types.hpp"
@@ -124,7 +125,7 @@ TEST_F(MultiPatchField2Patches, ZeroOnFirstPatchOneOnSecond)
     ddc::parallel_fill(Kokkos::DefaultExecutionSpace(), field1, 0.0);
     ddc::parallel_fill(Kokkos::DefaultExecutionSpace(), field2, 1.0);
 
-    MultipatchType<DFieldOnPatch, Patch1, Patch2> global_field(field1, field2);
+    MultipatchField<DFieldOnPatch, Patch1, Patch2> global_field(field1, field2);
 
     // Act
     Field1 field1_from_multipatch = global_field.get<Patch1>();
@@ -150,7 +151,7 @@ TEST_F(MultiPatchField2Patches, Polynomials)
 
     initialize_non_const_fields(field1, field2);
 
-    MultipatchType<DFieldOnPatch, Patch1, Patch2> global_field(field1, field2);
+    MultipatchField<DFieldOnPatch, Patch1, Patch2> global_field(field1, field2);
 
     // Act
     Field1 field1_from_multipatch = global_field.get<Patch1>();
@@ -190,7 +191,7 @@ TEST_F(MultiPatchField2Patches, GetIdxRange)
 
     initialize_non_const_fields(field1, field2);
 
-    MultipatchType<DFieldOnPatch, Patch1, Patch2> global_field(field1, field2);
+    MultipatchField<DFieldOnPatch, Patch1, Patch2> global_field(field1, field2);
 
     MultipatchType<IdxRangeOnPatch, Patch1, Patch2> all_idx_ranges(get_idx_range(global_field));
 
@@ -206,9 +207,9 @@ TEST_F(MultiPatchField2Patches, ConstField)
 
     initialize_non_const_fields(field1, field2);
 
-    MultipatchType<DFieldOnPatch, Patch1, Patch2> global_field(field1, field2);
+    MultipatchField<DFieldOnPatch, Patch1, Patch2> global_field(field1, field2);
 
-    MultipatchType<DConstFieldOnPatch, Patch1, Patch2> global_const_field(
+    MultipatchField<DConstFieldOnPatch, Patch1, Patch2> global_const_field(
             global_field.get_const_field());
 
     // Act
diff --git a/tests/multipatch/data_types/multipatch_field_9p.cpp b/tests/multipatch/data_types/multipatch_field_9p.cpp
index 1962edb9e..e5f831f1e 100644
--- a/tests/multipatch/data_types/multipatch_field_9p.cpp
+++ b/tests/multipatch/data_types/multipatch_field_9p.cpp
@@ -13,6 +13,7 @@
 #include "9patches_2d_periodic_strips_uniform.hpp"
 #include "ddc_alias_inline_functions.hpp"
 #include "ddc_aliases.hpp"
+#include "multipatch_field.hpp"
 #include "multipatch_type.hpp"
 #include "types.hpp"
 
@@ -89,7 +90,7 @@ TEST(MultipatchFieldMorePatches, ConstantOnEveryOne)
     ddc::parallel_fill(Kokkos::DefaultExecutionSpace(), field5, 5.0);
     ddc::parallel_fill(Kokkos::DefaultExecutionSpace(), field7, 7.0);
 
-    MultipatchType<DFieldOnPatch, Patch3, Patch5, Patch7> global_field(field3, field5, field7);
+    MultipatchField<DFieldOnPatch, Patch3, Patch5, Patch7> global_field(field3, field5, field7);
 
     // Act
     Field3 field3_from_multipatch = global_field.get<Patch3>();
diff --git a/tests/multipatch/spline/constant_extrapolation_rules_onion.cpp b/tests/multipatch/spline/constant_extrapolation_rules_onion.cpp
index 33b6627d7..366d6c698 100644
--- a/tests/multipatch/spline/constant_extrapolation_rules_onion.cpp
+++ b/tests/multipatch/spline/constant_extrapolation_rules_onion.cpp
@@ -9,6 +9,7 @@
 #include "2patches_2d_onion_shape_non_uniform.hpp"
 #include "constant_extrapolation_rules_onion.hpp"
 #include "ddc_helper.hpp"
+#include "multipatch_field.hpp"
 #include "multipatch_type.hpp"
 #include "onion_patch_locator.hpp"
 #include "physical_geometry.hpp"
@@ -21,7 +22,7 @@ template <class PatchLocator>
 void test_on_device(
         typename Patch1::Coord1 const& r1_min,
         typename Patch2::Coord1 const& r2_max,
-        MultipatchType<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const& splines)
+        MultipatchField<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const& splines)
 {
     ConstantExtrapolationRuleOnion<PatchLocator> const_extrapol_rule(r1_min, r2_max);
 
@@ -83,7 +84,7 @@ TEST_F(MultipatchSplineOnionShapeTest, ConstantExtrapolationRuleOnionShapeHostTe
 {
     auto function_1_coef_host = ddc::create_mirror_and_copy(splines.template get<Patch1>());
     auto function_2_coef_host = ddc::create_mirror_and_copy(splines.template get<Patch2>());
-    MultipatchType<ConstSplineCoeffOnPatch_2D_host, Patch1, Patch2> const
+    MultipatchField<ConstSplineCoeffOnPatch_2D_host, Patch1, Patch2> const
             splines_host(get_field(function_1_coef_host), get_field(function_2_coef_host));
 
     ConstantExtrapolationRuleOnion<PatchLocator<HostExecSpace>> const_extrapol_rule(r1_min, r2_max);
@@ -128,4 +129,4 @@ TEST_F(MultipatchSplineOnionShapeTest, ConstantExtrapolationRuleOnionShapeHostTe
 TEST_F(MultipatchSplineOnionShapeTest, ConstantExtrapolationRuleOnionShapeDeviceTest)
 {
     test_on_device<PatchLocator<DeviceExecSpace>>(r1_min, r2_max, splines);
-}
\ No newline at end of file
+}
diff --git a/tests/multipatch/spline/multipatch_spline_builder.cpp b/tests/multipatch/spline/multipatch_spline_builder.cpp
index ce325a3b9..0ef2607aa 100644
--- a/tests/multipatch/spline/multipatch_spline_builder.cpp
+++ b/tests/multipatch/spline/multipatch_spline_builder.cpp
@@ -9,6 +9,7 @@
 #include "ddc_helper.hpp"
 #include "directional_tag.hpp"
 #include "mesh_builder.hpp"
+#include "multipatch_field.hpp"
 #include "multipatch_spline_builder.hpp"
 #include "vector_field.hpp"
 #include "vector_field_mem.hpp"
@@ -213,6 +214,9 @@ class MultipatchSplineBuilderTest : public ::testing::Test
             SplineField1 const& function_1_coef_expected,
             SplineField2 const& function_2_coef_expected)
     {
+        using Idx1 = typename SplineField1::discrete_domain_type::discrete_element_type;
+        using Idx2 = typename SplineField2::discrete_domain_type::discrete_element_type;
+
         // --- get the spline representation on CPU
         auto function_coef_1_host
                 = ddc::create_mirror_and_copy(function_coef.template get<Patch1>());
@@ -225,11 +229,11 @@ class MultipatchSplineBuilderTest : public ::testing::Test
 
         // --- check error
         double max_abs_error = 0;
-        ddc::for_each(get_idx_range(function_coef_1_expected_host), [&](auto const idx) {
+        ddc::for_each(get_idx_range(function_coef_1_expected_host), [&](Idx1 const idx) {
             double err = abs(function_coef_1_expected_host(idx) - function_coef_1_host(idx));
             max_abs_error = std::max(max_abs_error, err);
         });
-        ddc::for_each(get_idx_range(function_coef_2_expected_host), [&](auto const idx) {
+        ddc::for_each(get_idx_range(function_coef_2_expected_host), [&](Idx2 const idx) {
             double err = abs(function_coef_2_expected_host(idx) - function_coef_2_host(idx));
             max_abs_error = std::max(max_abs_error, err);
         });
@@ -267,7 +271,7 @@ TEST_F(MultipatchSplineBuilderTest, TwoPatches1D)
     initialize_1D_functions(function_1, function_2);
 
     // --- collection of values of the function on each patch
-    MultipatchType<DConstField1OnPatch, Patch1, Patch2> function_values(function_1, function_2);
+    MultipatchField<DConstField1OnPatch, Patch1, Patch2> function_values(function_1, function_2);
 
 
 
@@ -291,7 +295,7 @@ TEST_F(MultipatchSplineBuilderTest, TwoPatches1D)
             = get_field(function_2_coef_expected_alloc);
 
     // --- collection
-    MultipatchType<SplineCoeff1OnPatch_1D, Patch1, Patch2>
+    MultipatchField<SplineCoeff1OnPatch_1D, Patch1, Patch2>
             function_coef(function_1_coef, function_2_coef);
 
 
@@ -338,7 +342,7 @@ TEST_F(MultipatchSplineBuilderTest, TwoPatches2D)
     initialize_2D_functions(function_1, function_2);
 
     // --- collection of values of the function on each patch
-    MultipatchType<DConstFieldOnPatch, Patch1, Patch2> function_values(function_1, function_2);
+    MultipatchField<DConstFieldOnPatch, Patch1, Patch2> function_values(function_1, function_2);
 
 
 
@@ -364,7 +368,7 @@ TEST_F(MultipatchSplineBuilderTest, TwoPatches2D)
             = get_field(function_2_coef_expected_alloc);
 
     // --- collection
-    MultipatchType<SplineCoeff1OnPatch_2D, Patch1, Patch2>
+    MultipatchField<SplineCoeff1OnPatch_2D, Patch1, Patch2>
             function_coef(function_1_coef, function_2_coef);
 
 
diff --git a/tests/multipatch/spline/multipatch_spline_builder_2d.cpp b/tests/multipatch/spline/multipatch_spline_builder_2d.cpp
index a8a2e2f24..41a728365 100644
--- a/tests/multipatch/spline/multipatch_spline_builder_2d.cpp
+++ b/tests/multipatch/spline/multipatch_spline_builder_2d.cpp
@@ -9,6 +9,7 @@
 #include "ddc_helper.hpp"
 #include "directional_tag.hpp"
 #include "mesh_builder.hpp"
+#include "multipatch_field.hpp"
 #include "multipatch_spline_builder_2d.hpp"
 #include "vector_field.hpp"
 #include "vector_field_mem.hpp"
@@ -143,7 +144,7 @@ class MultipatchSplineBuilder2DTest : public ::testing::Test
 
     // Test method -------------------------------------------------------------------------------
     void check_if_equal_to_expected(
-            MultipatchType<SplineCoeffOnPatch_2D, Patch1, Patch2> const& function_coef,
+            MultipatchField<SplineCoeffOnPatch_2D, Patch1, Patch2> const& function_coef,
             SplineCoeffOnPatch_2D<Patch1> function_1_coef_expected,
             SplineCoeffOnPatch_2D<Patch2> function_2_coef_expected)
     {
@@ -159,14 +160,20 @@ class MultipatchSplineBuilder2DTest : public ::testing::Test
 
         // --- check error
         double max_abs_error = 0;
-        ddc::for_each(get_idx_range(function_coef_1_expected_host), [&](auto const idx) {
-            double err = abs(function_coef_1_expected_host(idx) - function_coef_1_host(idx));
-            max_abs_error = std::max(max_abs_error, err);
-        });
-        ddc::for_each(get_idx_range(function_coef_2_expected_host), [&](auto const idx) {
-            double err = abs(function_coef_2_expected_host(idx) - function_coef_2_host(idx));
-            max_abs_error = std::max(max_abs_error, err);
-        });
+        ddc::for_each(
+                get_idx_range(function_coef_1_expected_host),
+                [&](Idx<Patch1::BSplines1, Patch1::BSplines2> const idx) {
+                    double err
+                            = abs(function_coef_1_expected_host(idx) - function_coef_1_host(idx));
+                    max_abs_error = std::max(max_abs_error, err);
+                });
+        ddc::for_each(
+                get_idx_range(function_coef_2_expected_host),
+                [&](Idx<Patch2::BSplines1, Patch2::BSplines2> const idx) {
+                    double err
+                            = abs(function_coef_2_expected_host(idx) - function_coef_2_host(idx));
+                    max_abs_error = std::max(max_abs_error, err);
+                });
         std::cout << "Max absolute error: " << max_abs_error << std::endl;
         EXPECT_LE(max_abs_error, 1e-15);
     }
@@ -223,7 +230,7 @@ TEST_F(MultipatchSplineBuilder2DTest, TwoPatches2D)
     initialize_2D_functions(function_1, function_2);
 
     // --- collection of values of the function on each patch
-    MultipatchType<DConstFieldOnPatch, Patch1, Patch2> function_values(function_1, function_2);
+    MultipatchField<DConstFieldOnPatch, Patch1, Patch2> function_values(function_1, function_2);
 
 
 
@@ -249,7 +256,7 @@ TEST_F(MultipatchSplineBuilder2DTest, TwoPatches2D)
             = get_field(function_2_coef_expected_alloc);
 
     // --- collection
-    MultipatchType<SplineCoeffOnPatch_2D, Patch1, Patch2>
+    MultipatchField<SplineCoeffOnPatch_2D, Patch1, Patch2>
             function_coef(function_1_coef, function_2_coef);
 
 
@@ -310,7 +317,7 @@ TEST_F(MultipatchSplineBuilder2DTest, TwoPatches2DHermite)
     initialize_2D_functions(function_1, function_2);
 
     // --- collection of values of the function on each patch
-    MultipatchType<DConstFieldOnPatch, Patch1, Patch2> function_values(function_1, function_2);
+    MultipatchField<DConstFieldOnPatch, Patch1, Patch2> function_values(function_1, function_2);
 
     // Derivatives Patch1
     Idx<ddc::Deriv<X<1>>> first_deriv_x1(1);
@@ -368,10 +375,10 @@ TEST_F(MultipatchSplineBuilder2DTest, TwoPatches2DHermite)
 
 
     // --- collection of values of the function on each patch
-    MultipatchType<ConstDeriv1_OnPatch_2D, Patch1, Patch2> derivs_xmin(derivs_xmin1, derivs_xmin2);
-    MultipatchType<ConstDeriv1_OnPatch_2D, Patch1, Patch2> derivs_xmax(derivs_xmax1, derivs_xmax2);
-    MultipatchType<ConstDeriv2_OnPatch_2D, Patch1, Patch2> derivs_ymin(derivs_ymin1, derivs_ymin2);
-    MultipatchType<ConstDeriv2_OnPatch_2D, Patch1, Patch2> derivs_ymax(derivs_ymax1, derivs_ymax2);
+    MultipatchField<ConstDeriv1_OnPatch_2D, Patch1, Patch2> derivs_xmin(derivs_xmin1, derivs_xmin2);
+    MultipatchField<ConstDeriv1_OnPatch_2D, Patch1, Patch2> derivs_xmax(derivs_xmax1, derivs_xmax2);
+    MultipatchField<ConstDeriv2_OnPatch_2D, Patch1, Patch2> derivs_ymin(derivs_ymin1, derivs_ymin2);
+    MultipatchField<ConstDeriv2_OnPatch_2D, Patch1, Patch2> derivs_ymax(derivs_ymax1, derivs_ymax2);
 
     IdxRange<ddc::Deriv<X<1>>, ddc::Deriv<Y<1>>>
             cross_derivs_idx_range1(deriv_x_idx_range1, deriv_y_idx_range1);
@@ -426,16 +433,16 @@ TEST_F(MultipatchSplineBuilder2DTest, TwoPatches2DHermite)
                     * (Kokkos::cos(2. * xmax2 * ymax2)
                        - 2. * xmax2 * ymax2 * Kokkos::sin(2. * xmax2 * ymax2)));
 
-    MultipatchType<ConstDeriv12_OnPatch_2D, Patch1, Patch2> mixed_derivs_min1_min2(
+    MultipatchField<ConstDeriv12_OnPatch_2D, Patch1, Patch2> mixed_derivs_min1_min2(
             get_const_field(mixed_derivs_min1_min2_alloc1),
             get_const_field(mixed_derivs_min1_min2_alloc2));
-    MultipatchType<ConstDeriv12_OnPatch_2D, Patch1, Patch2> mixed_derivs_max1_min2(
+    MultipatchField<ConstDeriv12_OnPatch_2D, Patch1, Patch2> mixed_derivs_max1_min2(
             get_const_field(mixed_derivs_max1_min2_alloc1),
             get_const_field(mixed_derivs_max1_min2_alloc2));
-    MultipatchType<ConstDeriv12_OnPatch_2D, Patch1, Patch2> mixed_derivs_min1_max2(
+    MultipatchField<ConstDeriv12_OnPatch_2D, Patch1, Patch2> mixed_derivs_min1_max2(
             get_const_field(mixed_derivs_min1_max2_alloc1),
             get_const_field(mixed_derivs_min1_max2_alloc2));
-    MultipatchType<ConstDeriv12_OnPatch_2D, Patch1, Patch2> mixed_derivs_max1_max2(
+    MultipatchField<ConstDeriv12_OnPatch_2D, Patch1, Patch2> mixed_derivs_max1_max2(
             get_const_field(mixed_derivs_max1_max2_alloc1),
             get_const_field(mixed_derivs_max1_max2_alloc2));
 
@@ -461,7 +468,7 @@ TEST_F(MultipatchSplineBuilder2DTest, TwoPatches2DHermite)
             = get_field(function_2_coef_expected_alloc);
 
     // --- collection
-    MultipatchType<SplineCoeffOnPatch_2D, Patch1, Patch2>
+    MultipatchField<SplineCoeffOnPatch_2D, Patch1, Patch2>
             function_coef(function_1_coef, function_2_coef);
 
 
diff --git a/tests/multipatch/spline/multipatch_spline_evaluator.cpp b/tests/multipatch/spline/multipatch_spline_evaluator.cpp
index a3d136b3b..14123243e 100644
--- a/tests/multipatch/spline/multipatch_spline_evaluator.cpp
+++ b/tests/multipatch/spline/multipatch_spline_evaluator.cpp
@@ -9,6 +9,7 @@
 #include "2patches_2d_onion_shape_non_uniform.hpp"
 #include "constant_extrapolation_rules_onion.hpp"
 #include "mesh_builder.hpp"
+#include "multipatch_field.hpp"
 #include "multipatch_spline_evaluator_2d.hpp"
 #include "multipatch_type.hpp"
 #include "onion_patch_locator.hpp"
@@ -133,7 +134,7 @@ void test_operator_assignement(
         SplineRThetaEvaluator<2, DeviceExecSpace> const& single_evaluator_2,
         Kokkos::View<Coord<R, Theta>*, Kokkos::DefaultExecutionSpace::memory_space> const&
                 eval_coords,
-        MultipatchType<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const& splines,
+        MultipatchField<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const& splines,
         ConstSplineCoeffOnPatch_2D<Patch1> const& spline_patch_1,
         ConstSplineCoeffOnPatch_2D<Patch2> const& spline_patch_2)
 {
@@ -162,7 +163,7 @@ void test_deriv_dim_1(
         SplineRThetaEvaluator<1, DeviceExecSpace> const& single_evaluator_1,
         SplineRThetaEvaluator<2, DeviceExecSpace> const& single_evaluator_2,
         Kokkos::View<Coord<R, Theta>*> const& eval_coords,
-        MultipatchType<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const& splines,
+        MultipatchField<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const& splines,
         ConstSplineCoeffOnPatch_2D<Patch1> const& spline_patch_1,
         ConstSplineCoeffOnPatch_2D<Patch2> const& spline_patch_2)
 {
@@ -191,7 +192,7 @@ void test_deriv_dim_2(
         SplineRThetaEvaluator<1, DeviceExecSpace> const& single_evaluator_1,
         SplineRThetaEvaluator<2, DeviceExecSpace> const& single_evaluator_2,
         Kokkos::View<Coord<R, Theta>*> const& eval_coords,
-        MultipatchType<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const& splines,
+        MultipatchField<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const& splines,
         ConstSplineCoeffOnPatch_2D<Patch1> const& spline_patch_1,
         ConstSplineCoeffOnPatch_2D<Patch2> const& spline_patch_2)
 {
@@ -220,7 +221,7 @@ void test_deriv_1_and_2(
         SplineRThetaEvaluator<1, DeviceExecSpace> const& single_evaluator_1,
         SplineRThetaEvaluator<2, DeviceExecSpace> const& single_evaluator_2,
         Kokkos::View<Coord<R, Theta>*> const& eval_coords,
-        MultipatchType<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const& splines,
+        MultipatchField<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const& splines,
         ConstSplineCoeffOnPatch_2D<Patch1> const& spline_patch_1,
         ConstSplineCoeffOnPatch_2D<Patch2> const& spline_patch_2)
 {
@@ -250,7 +251,7 @@ void test_deriv(
         SplineRThetaEvaluator<1, DeviceExecSpace> const& single_evaluator_1,
         SplineRThetaEvaluator<2, DeviceExecSpace> const& single_evaluator_2,
         Kokkos::View<Coord<R, Theta>*> const& eval_coords,
-        MultipatchType<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const& splines,
+        MultipatchField<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const& splines,
         ConstSplineCoeffOnPatch_2D<Patch1> const& spline_patch_1,
         ConstSplineCoeffOnPatch_2D<Patch2> const& spline_patch_2)
 {
@@ -299,7 +300,7 @@ TEST_F(MultipatchSplineEvaluatorTest, HostEvaluateOnSingleCoord)
 
     auto const function_1_coef_host = ddc::create_mirror_and_copy(function_1_coef);
     auto const function_2_coef_host = ddc::create_mirror_and_copy(function_2_coef);
-    MultipatchType<ConstSplineCoeffOnPatch_2D_host, Patch1, Patch2> const
+    MultipatchField<ConstSplineCoeffOnPatch_2D_host, Patch1, Patch2> const
             splines_host(get_field(function_1_coef_host), get_field(function_2_coef_host));
 
     host_t<DConstField<IdxRange<BSplinesR<1>, BSplinesTheta<1>>>> const const_function_1_coef_host(
@@ -413,7 +414,7 @@ TEST_F(MultipatchSplineEvaluatorTest, EvaluateOnCoordField)
     set_eval_points_2D<Patch2::Grid1, Patch2::Grid2>(eval_points_2);
 
     // --- collection
-    MultipatchType<CoordConstFieldOnPatch, Patch1, Patch2> const
+    MultipatchField<CoordConstFieldOnPatch, Patch1, Patch2> const
             eval_points(get_const_field(eval_points_1), get_const_field(eval_points_2));
 
 
@@ -427,7 +428,7 @@ TEST_F(MultipatchSplineEvaluatorTest, EvaluateOnCoordField)
     DField<Patch2::IdxRange12> eval_function_2 = get_field(eval_function_2_alloc);
 
     // --- collection
-    MultipatchType<DFieldOnPatch, Patch1, Patch2> const
+    MultipatchField<DFieldOnPatch, Patch1, Patch2> const
             eval_functions(eval_function_1, eval_function_2);
 
 
@@ -500,7 +501,7 @@ TEST_F(MultipatchSplineEvaluatorTest, HostDerivativesOnSingleCoord)
 
     auto const function_1_coef_host = ddc::create_mirror_and_copy(function_1_coef);
     auto const function_2_coef_host = ddc::create_mirror_and_copy(function_2_coef);
-    MultipatchType<ConstSplineCoeffOnPatch_2D_host, Patch1, Patch2> const
+    MultipatchField<ConstSplineCoeffOnPatch_2D_host, Patch1, Patch2> const
             splines_host(get_field(function_1_coef_host), get_field(function_2_coef_host));
 
     host_t<DConstField<IdxRange<BSplinesR<1>, BSplinesTheta<1>>>> const cst_function_1_coef_h(
@@ -761,7 +762,7 @@ TEST_F(MultipatchSplineEvaluatorTest, DerivativativesOnCoordField)
             = get_const_field(eval_points_2);
 
     // --- collection
-    MultipatchType<CoordConstFieldOnPatch, Patch1, Patch2> const
+    MultipatchField<CoordConstFieldOnPatch, Patch1, Patch2> const
             eval_points(const_eval_points_1, const_eval_points_2);
 
 
@@ -788,11 +789,11 @@ TEST_F(MultipatchSplineEvaluatorTest, DerivativativesOnCoordField)
     DField<Patch2::IdxRange12> eval_derivs_12_patch_2 = get_field(eval_derivs_12_patch_2_alloc);
 
     // ----- collections
-    MultipatchType<DFieldOnPatch, Patch1, Patch2> const
+    MultipatchField<DFieldOnPatch, Patch1, Patch2> const
             eval_derivs_1(eval_derivs_1_patch_1, eval_derivs_1_patch_2);
-    MultipatchType<DFieldOnPatch, Patch1, Patch2> const
+    MultipatchField<DFieldOnPatch, Patch1, Patch2> const
             eval_derivs_2(eval_derivs_2_patch_1, eval_derivs_2_patch_2);
-    MultipatchType<DFieldOnPatch, Patch1, Patch2> const
+    MultipatchField<DFieldOnPatch, Patch1, Patch2> const
             eval_derivs_12(eval_derivs_12_patch_1, eval_derivs_12_patch_2);
 
 
@@ -899,7 +900,7 @@ TEST_F(MultipatchSplineEvaluatorTest, HostIntegrateOnCoordField)
 {
     auto function_1_coef_host = ddc::create_mirror_and_copy(function_1_coef);
     auto function_2_coef_host = ddc::create_mirror_and_copy(function_2_coef);
-    MultipatchType<ConstSplineCoeffOnPatch_2D_host, Patch1, Patch2> const
+    MultipatchField<ConstSplineCoeffOnPatch_2D_host, Patch1, Patch2> const
             splines_host(get_field(function_1_coef_host), get_field(function_2_coef_host));
 
     // Definition of MultipatchSplineEvaluator2D
diff --git a/tests/multipatch/spline/null_extrapolation_rules.cpp b/tests/multipatch/spline/null_extrapolation_rules.cpp
index ee1a1cc01..584c8f355 100644
--- a/tests/multipatch/spline/null_extrapolation_rules.cpp
+++ b/tests/multipatch/spline/null_extrapolation_rules.cpp
@@ -6,6 +6,7 @@
 #include <gtest/gtest.h>
 
 #include "2patches_2d_onion_shape_non_uniform.hpp"
+#include "multipatch_field.hpp"
 #include "multipatch_type.hpp"
 #include "null_extrapolation_rules.hpp"
 #include "spline_testing_tools.hpp"
@@ -14,7 +15,7 @@
 
 
 namespace {
-void test_on_device(MultipatchType<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const& splines)
+void test_on_device(MultipatchField<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const& splines)
 {
     NullExtrapolationRule null_extrapol_rule;
 
@@ -45,7 +46,7 @@ TEST_F(MultipatchSplineOnionShapeTest, NullExtrapolationRuleHostTest)
 {
     auto function_1_coef_host = ddc::create_mirror_and_copy(splines.template get<Patch1>());
     auto function_2_coef_host = ddc::create_mirror_and_copy(splines.template get<Patch2>());
-    MultipatchType<ConstSplineCoeffOnPatch_2D_host, Patch1, Patch2> const
+    MultipatchField<ConstSplineCoeffOnPatch_2D_host, Patch1, Patch2> const
             splines_host(get_field(function_1_coef_host), get_field(function_2_coef_host));
 
     NullExtrapolationRule null_extrapol_rule;
@@ -64,4 +65,4 @@ TEST_F(MultipatchSplineOnionShapeTest, NullExtrapolationRuleHostTest)
 TEST_F(MultipatchSplineOnionShapeTest, NullExtrapolationRuleDeviceTest)
 {
     test_on_device(splines);
-}
\ No newline at end of file
+}
diff --git a/tests/multipatch/spline/spline_testing_tools.hpp b/tests/multipatch/spline/spline_testing_tools.hpp
index 53281000e..66ac4afcd 100644
--- a/tests/multipatch/spline/spline_testing_tools.hpp
+++ b/tests/multipatch/spline/spline_testing_tools.hpp
@@ -11,6 +11,7 @@
 #include "2patches_2d_onion_shape_non_uniform.hpp"
 #include "ddc_helper.hpp"
 #include "mesh_builder.hpp"
+#include "multipatch_field.hpp"
 #include "multipatch_type.hpp"
 #include "onion_patch_locator.hpp"
 #include "physical_geometry.hpp"
@@ -132,7 +133,7 @@ class MultipatchSplineOnionShapeTest : public ::testing::Test
 
     /// @brief MultipatchType of const fields of the spline coefficients of the function
     // on the patches.
-    MultipatchType<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const splines;
+    MultipatchField<ConstSplineCoeffOnPatch_2D, Patch1, Patch2> const splines;
 
     /// @brief MultipatchType of index ranges on the patches.
     MultipatchIdxRange const all_idx_ranges;
@@ -201,4 +202,4 @@ class MultipatchSplineOnionShapeTest : public ::testing::Test
      * @return A field of function value initiliased on Patch2.
      */
     DField<Patch2::IdxRangeBS12> set_spline_2(DField<Patch2::IdxRangeBS12> const& function_2_coef);
-};
\ No newline at end of file
+};