diff --git a/post-process/PythonScripts/geometryXYVxVy/plot_electric_field.py b/post-process/PythonScripts/geometryXYVxVy/plot_electric_field.py
index 4c4bc205c..79a6a2df1 100644
--- a/post-process/PythonScripts/geometryXYVxVy/plot_electric_field.py
+++ b/post-process/PythonScripts/geometryXYVxVy/plot_electric_field.py
@@ -134,16 +134,17 @@ def plot_electric_energy():
 
         Emax = np.array(Emaxval)
         tm = np.array(tm)
-        res = stats.linregress(tm,np.log(np.sqrt(Emax)))
-        print(f'relative error on growth rate {(theo_rate-res[0]) /abs(res[0]):0.2f}')
-
+        if Emax.size>0:
+            res = stats.linregress(tm,np.log(np.sqrt(Emax)))
+            print(f'relative error on growth rate {(theo_rate-res[0]) /abs(res[0]):0.2f}')
         plt.clf()
         plt.plot(epot.coords['time'].values,np.log(np.sqrt(Energy)))
         plt.scatter(tm ,np.log(np.sqrt(Emax)),c='red')
-        plt.plot(tm ,tm*res[0]+res[1]  ,c='green')
+        if Emax.size>0:
+            plt.plot(tm ,tm*res[0]+res[1]  ,c='green')
+            plt.title(f'growthrate: {res[0]:0.3f} (theory: {theo_rate:0.3f})', fontsize=16)
         plt.ylabel('Electric energy', fontsize=12)
         plt.xlabel('time', fontsize=12)
-        plt.title(f'growthrate: {res[0]:0.3f} (theory: {theo_rate:0.3f})', fontsize=16)
         plt.savefig('Electric_energy.png')
 
     def plot_fdist(itime,Vx,Vy):
diff --git a/src/README.md b/src/README.md
index 2d0271fed..6f3982130 100644
--- a/src/README.md
+++ b/src/README.md
@@ -10,3 +10,4 @@ The `src/` folder contains all the code necessary to build a gyrokinetic semi-La
 <!-- - [paraconfpp](./paraconfpp/README.md) - Paraconf utility functions. -->
 - [quadrature](./quadrature/README.md) - Code describing different quadrature methods.
 <!-- - [speciesinfo](./speciesinfo/README.md) - Code used to describe the different species. -->
+- [utils](./utils/README.md) - Code describing utility functions.
diff --git a/src/utils/README.md b/src/utils/README.md
new file mode 100644
index 000000000..cebd30c56
--- /dev/null
+++ b/src/utils/README.md
@@ -0,0 +1,9 @@
+# Utility Functions
+
+This folder contains classes and functions which facilitate the writing of the rest of the code. For the most part these objects are required to fill gaps in DDC which will hopefully be filled in the future.
+
+The class ddcHelper exists to provide functionalities which are currently missing from DDC.
+
+The class NDTag exists to provide a way to group directional tags together. This is notably useful in order to create a vector field.
+
+Finally the classes VectorField and VectorFieldSpan provide a way to represent a vector field.
diff --git a/src/utils/ddc_helper.hpp b/src/utils/ddc_helper.hpp
index 8089f98b8..c4ef7097f 100644
--- a/src/utils/ddc_helper.hpp
+++ b/src/utils/ddc_helper.hpp
@@ -4,28 +4,38 @@
 
 #include <ddc/ddc.hpp>
 
+namespace ddcHelper {
+//TODO: this should be directly handled by ddc::Discretization really,
+//      in the meantime, we do it ourselves
 /**
  * Computes fluid moments of the distribution function 
  * Density, mean velocity and temperature.
+ *
+ * @param dom The domain on which the length should be calculated.
+ *
+ * @return The length of the domain.
  */
-class ddcHelper
+template <class IDim>
+constexpr std::enable_if_t<!IDim::continuous_dimension_type::PERIODIC, double>
+total_interval_length(ddc::DiscreteDomain<IDim> const& dom)
 {
-public:
-    //TODO: this should be directly handled by ddc::Discretization really,
-    //      in the meantime, we do it ourselves
-    template <class IDim>
-    static constexpr std::enable_if_t<!IDim::continuous_dimension_type::PERIODIC, double>
-    total_interval_length(ddc::DiscreteDomain<IDim> const& dom)
-    {
-        return std::fabs(ddc::rlength(dom));
-    }
+    return std::fabs(ddc::rlength(dom));
+}
 
-    //TODO: this should be directly handled by ddc::Discretization really,
-    //      in the meantime, we do it ourselves
-    template <class RDim>
-    static constexpr std::enable_if_t<RDim::PERIODIC, double> total_interval_length(
-            ddc::DiscreteDomain<ddc::UniformPointSampling<RDim>> const& dom)
-    {
-        return std::fabs(ddc::rlength(dom) + ddc::step<ddc::UniformPointSampling<RDim>>());
-    }
-};
+//TODO: this should be directly handled by ddc::Discretization really,
+//      in the meantime, we do it ourselves
+/**
+ * Computes fluid moments of the distribution function 
+ * Density, mean velocity and temperature.
+ *
+ * @param dom The domain on which the length should be calculated.
+ *
+ * @return The length of the domain.
+ */
+template <class RDim>
+constexpr std::enable_if_t<RDim::PERIODIC, double> total_interval_length(
+        ddc::DiscreteDomain<ddc::UniformPointSampling<RDim>> const& dom)
+{
+    return std::fabs(ddc::rlength(dom) + ddc::step<ddc::UniformPointSampling<RDim>>());
+}
+}; // namespace ddcHelper
diff --git a/src/utils/directional_tag.hpp b/src/utils/directional_tag.hpp
new file mode 100644
index 000000000..c2ee1124c
--- /dev/null
+++ b/src/utils/directional_tag.hpp
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <ddc/ddc.hpp>
+
+template <class... DDims>
+using NDTag = ddc::detail::TypeSeq<DDims...>;
diff --git a/src/utils/vector_field.hpp b/src/utils/vector_field.hpp
new file mode 100644
index 000000000..a5cf9ece1
--- /dev/null
+++ b/src/utils/vector_field.hpp
@@ -0,0 +1,244 @@
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <ddc/ddc.hpp>
+
+#include "vector_field_common.hpp"
+
+/**
+ * @brief Pre-declaration of VectorField.
+ */
+template <class ElementType, class Domain, class, class Allocator = ddc::HostAllocator<ElementType>>
+class VectorField;
+
+
+template <class ElementType, class Domain, class DimSeq, class Allocator>
+inline constexpr bool enable_field<VectorField<ElementType, Domain, DimSeq, Allocator>> = true;
+
+/**
+ * @brief Pre-declaration of VectorFieldSpan.
+ */
+template <class, class, class, class, class>
+class VectorFieldSpan;
+
+/**
+ * @brief A class which describes a vector field.
+ *
+ * A class which describes a vector field. In other words a class which maps a position on a domain
+ * to a vector (x,y,z,...). This is done by storing the values at the positions in individual
+ * Chunks.
+ */
+template <class ElementType, class Domain, class NDTag, class Allocator>
+class VectorField : public VectorFieldCommon<ddc::Chunk<ElementType, Domain, Allocator>, NDTag>
+{
+public:
+    /**
+     * @brief Type describing the object which can be extracted from this VectorField using the get<> function.
+     */
+    using chunk_type = ddc::Chunk<ElementType, Domain, Allocator>;
+
+private:
+    using base_type = VectorFieldCommon<chunk_type, NDTag>;
+
+    using mdomain_type = typename base_type::mdomain_type;
+
+public:
+    /**
+     * @brief A type which can hold a reference to this VectorField.
+     */
+    using span_type = VectorFieldSpan<
+            ElementType,
+            Domain,
+            NDTag,
+            std::experimental::layout_right,
+            typename Allocator::memory_space>;
+
+    /**
+     * @brief A type which can hold a constant reference to this VectorField.
+     */
+    using view_type = VectorFieldSpan<
+            const ElementType,
+            Domain,
+            NDTag,
+            std::experimental::layout_right,
+            typename Allocator::memory_space>;
+
+private:
+    /// Construct a VectorField on a domain with uninitialized values
+    template <std::size_t... Is>
+    explicit VectorField(
+            mdomain_type const& domain,
+            Allocator allocator,
+            std::index_sequence<Is...> const&)
+        : base_type(((void)Is, chunk_type(domain, allocator))...)
+    {
+    }
+
+    template <std::size_t... Is>
+    VectorField(VectorField&& other, std::index_sequence<Is...> const&)
+        : base_type(chunk_type(
+                std::move(ddcHelpers::get<ddc::type_seq_element_t<Is, NDTag>>(other)))...)
+    {
+    }
+
+    /**
+     * Construct a VectorField from a deepcopy of a VectorFieldSpan
+     *
+     * @param[inout] field_span
+     */
+    template <class OElementType, class LayoutDomain, class MemorySpace, std::size_t... Is>
+    explicit VectorField(
+            VectorFieldSpan<OElementType, Domain, NDTag, LayoutDomain, MemorySpace> field_span,
+            std::index_sequence<Is...> const&)
+        : base_type(chunk_type(ddcHelpers::get<ddc::type_seq_element_t<Is, NDTag>>(field_span))...)
+    {
+    }
+
+public:
+    /// Empty VectorField
+    VectorField() = default;
+
+    /**
+     * Construct a VectorField on a domain with uninitialized values
+     *
+     * @param[in] domain The domain on which the chunk will be defined.
+     * @param[in] allocator An optional allocator used to create the chunks.
+     */
+    explicit VectorField(mdomain_type const& domain, Allocator allocator = Allocator())
+        : VectorField(domain, allocator, std::make_index_sequence<base_type::NDims> {})
+    {
+    }
+
+    /**
+     * Construct a VectorField from a deepcopy of a VectorFieldSpan
+     *
+     * @param[inout] field_span A reference to another vector field.
+     */
+    template <class OElementType, class LayoutDomain, class MemorySpace>
+    explicit VectorField(
+            VectorFieldSpan<OElementType, Domain, NDTag, LayoutDomain, MemorySpace> field_span)
+        : VectorField(field_span, std::make_index_sequence<base_type::NDims> {})
+    {
+    }
+
+    /// Deleted: use deepcopy instead
+    VectorField(VectorField const& other) = delete;
+
+    /**
+     * Constructs a new VectorField by move
+     * @param other the VectorField to move
+     */
+    VectorField(VectorField&& other)
+        : VectorField(std::move(other), std::make_index_sequence<base_type::NDims> {})
+    {
+    }
+
+    /**
+     * Copy-assigns a new value to this VectorFieldSpan, yields a new view to the same data
+     * @param other the VectorFieldSpan to copy
+     * @return *this
+     */
+    VectorField& operator=(VectorField const& other) = default;
+
+    /**
+     * Move-assigns a new value to this VectorFieldSpan
+     * @param other the VectorFieldSpan to move
+     * @return *this
+     */
+    VectorField& operator=(VectorField&& other) = default;
+
+    ~VectorField() = default;
+
+    /**
+     * Get a constant reference to this vector field.
+     *
+     * @return A constant reference to this vector field.
+     */
+    view_type span_cview() const
+    {
+        return view_type(*this);
+    }
+
+    /**
+     * Get a constant reference to this vector field.
+     *
+     * @return A constant reference to this vector field.
+     */
+    view_type span_view() const
+    {
+        return view_type(*this);
+    }
+
+    /**
+     * Get a modifiable reference to this vector field.
+     *
+     * @return A modifiable reference to this vector field.
+     */
+    span_type span_view()
+    {
+        return span_type(*this);
+    }
+
+    /**
+     * @brief Slice out some dimensions.
+     *
+     * Get the VectorField on the reduced domain which is obtained by indexing
+     * the dimensions QueryDDims at the position slice_spec.
+     *
+     * @param[in] slice_spec The slice describing the domain of interest.
+     *
+     * @return A constant reference to the vector field on the sliced domain.
+     */
+    template <class... QueryDDims>
+    auto operator[](ddc::DiscreteElement<QueryDDims...> const& slice_spec) const
+    {
+        return span_cview()[slice_spec];
+    }
+
+    /**
+     * @brief Slice out some dimensions.
+     *
+     * Get the VectorField on the reduced domain which is obtained by indexing
+     * the dimensions QueryDDims at the position slice_spec.
+     *
+     * @param[in] slice_spec The slice describing the domain of interest.
+     *
+     * @return A modifiable reference to the vector field on the sliced domain.
+     */
+    template <class... QueryDDims>
+    auto operator[](ddc::DiscreteElement<QueryDDims...> const& slice_spec)
+    {
+        return span_view()[slice_spec];
+    }
+
+    /**
+     * @brief Slice out some dimensions.
+     *
+     * Get the VectorField on the reduced domain passed as an argument.
+     *
+     * @param[in] odomain The domain of interest.
+     *
+     * @return A modifiable reference to the vector field on the sliced domain.
+     */
+    template <class... QueryDDims>
+    auto operator[](ddc::DiscreteDomain<QueryDDims...> const& odomain) const
+    {
+        return span_cview()[odomain];
+    }
+
+    /**
+     * @brief Slice out some dimensions.
+     *
+     * Get the VectorField on the reduced domain passed as an argument.
+     *
+     * @param[in] odomain The domain of interest.
+     *
+     * @return A modifiable reference to the vector field on the sliced domain.
+     */
+    template <class... QueryDDims>
+    auto operator[](ddc::DiscreteDomain<QueryDDims...> const& odomain)
+    {
+        return span_view()[odomain];
+    }
+};
diff --git a/src/utils/vector_field_common.hpp b/src/utils/vector_field_common.hpp
new file mode 100644
index 000000000..2509bd7a1
--- /dev/null
+++ b/src/utils/vector_field_common.hpp
@@ -0,0 +1,161 @@
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <ddc/ddc.hpp>
+
+template <class, class>
+class VectorFieldCommon;
+
+template <class T>
+inline constexpr bool enable_field = false;
+
+template <class T>
+inline constexpr bool enable_borrowed_field = false;
+
+template <class T>
+inline constexpr bool is_field_v = enable_field<std::remove_const_t<std::remove_reference_t<T>>>;
+
+template <class T>
+inline constexpr bool is_borrowed_field_v
+        = is_field_v<
+                  T> && (std::is_lvalue_reference_v<T> || enable_borrowed_field<std::remove_cv_t<std::remove_reference_t<T>>>);
+
+namespace ddcHelpers {
+
+template <class... QueryDDims, class FieldType>
+auto get_domain(FieldType const& field) noexcept
+{
+    static_assert(is_field_v<FieldType>, "Not a field span type");
+    return field.template domain<QueryDDims...>();
+}
+
+template <class FieldDst, class FieldSrc>
+auto deepcopy(FieldDst&& dst, FieldSrc&& src)
+{
+    static_assert(is_borrowed_field_v<FieldDst>);
+    static_assert(is_borrowed_field_v<FieldSrc>);
+    static_assert(std::is_same_v<
+                  typename std::remove_reference_t<FieldDst>::NDTypeTag,
+                  typename std::remove_reference_t<FieldSrc>::NDTypeTag>);
+
+    assert(dst.domain().extents() == src.domain().extents());
+
+    dst.deepcopy(src);
+    return dst.span_view();
+}
+
+template <class QueryTag, class ChunkType, class NDTypeTag>
+inline constexpr typename ChunkType::span_type get(
+        VectorFieldCommon<ChunkType, NDTypeTag>& field) noexcept
+{
+    return field.template get<QueryTag>();
+}
+
+template <class QueryTag, class ChunkType, class NDTypeTag>
+inline constexpr typename ChunkType::view_type get(
+        VectorFieldCommon<ChunkType, NDTypeTag> const& field) noexcept
+{
+    return field.template get<QueryTag>();
+}
+
+
+}; // namespace ddcHelpers
+
+template <class ChunkType, class... DDims>
+class VectorFieldCommon<ChunkType, ddc::detail::TypeSeq<DDims...>>
+{
+    static_assert(ddc::is_chunk_v<ChunkType>);
+    using data_type = typename ChunkType::element_type;
+
+public:
+    using mdomain_type = typename ChunkType::mdomain_type;
+    using element_type = typename ddc::detail::TaggedVector<data_type, DDims...>;
+    using element_ref_type = typename ddc::detail::TaggedVector<data_type&, DDims...>;
+    using NDTypeTag = ddc::detail::TypeSeq<DDims...>;
+
+    using chunk_span_type = typename ChunkType::span_type;
+    using chunk_view_type = typename ChunkType::view_type;
+
+protected:
+    static constexpr std::size_t NDims = sizeof...(DDims);
+
+private:
+    std::array<ChunkType, NDims> m_values;
+
+protected:
+    /// Empty Chunk
+    VectorFieldCommon() = default;
+
+    /// Construct a Chunk on a domain with uninitialized values
+    template <
+            class... Chunks,
+            class = std::enable_if_t<std::conjunction_v<std::is_same<Chunks, ChunkType>...>>>
+    explicit VectorFieldCommon(Chunks&&... chunks) : m_values {std::move(chunks)...}
+    {
+    }
+
+public:
+    /** Element access using a list of DiscreteElement
+     * @param delems 1D discrete coordinates
+     * @return copy of this element
+     */
+    template <class... ODDims>
+    element_type operator()(ddc::DiscreteElement<ODDims> const&... delems) const noexcept
+    {
+        return element_type((this->get<DDims>()(delems...))...);
+    }
+
+    /** Element access using a multi-dimensional DiscreteElement
+     * @param delems discrete coordinates
+     * @return copy of this element
+     */
+    template <class... ODDims, class = std::enable_if_t<sizeof...(ODDims) != 1>>
+    element_type operator()(ddc::DiscreteElement<ODDims...> const& delems) const noexcept
+    {
+        return element_type((this->get<DDims>()(delems))...);
+    }
+
+    constexpr mdomain_type domain() const noexcept
+    {
+        return m_values[0].domain();
+    }
+
+    /** Provide access to the domain on which this chunk is defined
+     * @return the domain on which this chunk is defined
+     */
+    template <class... QueryDDims>
+    constexpr ddc::DiscreteDomain<QueryDDims...> domain() const noexcept
+    {
+        return ddc::select<QueryDDims...>(domain());
+    }
+
+    static constexpr int rank() noexcept
+    {
+        return ChunkType::rank();
+    }
+
+    template <class FieldSrc>
+    void deepcopy(FieldSrc const& src)
+    {
+        ((ddc::deepcopy(this->get<DDims>(), src.template get<DDims>())), ...);
+    }
+
+    template <class QueryTag>
+    inline constexpr chunk_span_type get() noexcept
+    {
+        static_assert(
+                ddc::in_tags_v<QueryTag, NDTypeTag>,
+                "requested Tag absent from TaggedVector");
+        return m_values[ddc::type_seq_rank_v<QueryTag, NDTypeTag>].span_view();
+    }
+
+    template <class QueryTag>
+    inline constexpr chunk_view_type get() const noexcept
+    {
+        static_assert(
+                ddc::in_tags_v<QueryTag, NDTypeTag>,
+                "requested Tag absent from TaggedVector");
+        return m_values[ddc::type_seq_rank_v<QueryTag, NDTypeTag>].span_cview();
+    }
+};
diff --git a/src/utils/vector_field_span.hpp b/src/utils/vector_field_span.hpp
new file mode 100644
index 000000000..32bcab344
--- /dev/null
+++ b/src/utils/vector_field_span.hpp
@@ -0,0 +1,275 @@
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "vector_field.hpp"
+
+
+template <
+        class ElementType,
+        class Domain,
+        class NDTag,
+        class LayoutStridedPolicy = std::experimental::layout_right,
+        class MemorySpace = Kokkos::DefaultHostExecutionSpace::memory_space>
+class VectorFieldSpan;
+
+template <
+        class ElementType,
+        class Domain,
+        class NDTag,
+        class LayoutStridedPolicy,
+        class MemorySpace>
+inline constexpr bool enable_field<
+        VectorFieldSpan<ElementType, Domain, NDTag, LayoutStridedPolicy, MemorySpace>> = true;
+
+template <
+        class ElementType,
+        class Domain,
+        class NDTag,
+        class LayoutStridedPolicy,
+        class MemorySpace>
+inline constexpr bool enable_borrowed_field<
+        VectorFieldSpan<ElementType, Domain, NDTag, LayoutStridedPolicy, MemorySpace>> = true;
+
+
+template <
+        class ElementType,
+        class Domain,
+        class NDTag,
+        class LayoutStridedPolicy,
+        class MemorySpace>
+class VectorFieldSpan
+    : public VectorFieldCommon<
+              ddc::ChunkSpan<ElementType, Domain, LayoutStridedPolicy, MemorySpace>,
+              NDTag>
+{
+public:
+    /**
+     * @brief Type describing the object which can be extracted from this VectorFieldSpan using the get<> function.
+     */
+    using chunk_type = ddc::ChunkSpan<ElementType, Domain, LayoutStridedPolicy, MemorySpace>;
+
+private:
+    using base_type = VectorFieldCommon<chunk_type, NDTag>;
+
+    using mdomain_type = typename base_type::mdomain_type;
+
+public:
+    /**
+     * @brief A type which can hold a modifiable reference to a VectorField.
+     *
+     * A type which can hold a reference to a VectorField. If this object is modifiable then
+     * so is the span type.
+     */
+    using span_type = VectorFieldSpan<ElementType, Domain, NDTag, LayoutStridedPolicy, MemorySpace>;
+    /**
+     * @brief A type which can hold a constant reference to a VectorField.
+     */
+    using view_type
+            = VectorFieldSpan<const ElementType, Domain, NDTag, LayoutStridedPolicy, MemorySpace>;
+
+    /**
+     * @brief Type describing the way in which the data is laid out in the Chunk span memory.
+     *
+     * Type describing the way in which the data is laid out in the Chunk span memory.
+     * I.e. it describes whether it is contiguous or not.
+     */
+    using layout_type = LayoutStridedPolicy;
+
+private:
+    template <class, class, class, class, class>
+    friend class VectorFieldSpan;
+
+    template <class OElementType, class Allocator, std::size_t... Is>
+    constexpr VectorFieldSpan(
+            VectorField<OElementType, Domain, NDTag, Allocator>& other,
+            std::index_sequence<Is...> const&) noexcept
+        : base_type((chunk_type(ddcHelpers::get<ddc::type_seq_element_t<Is, NDTag>>(other)))...)
+    {
+    }
+
+    /** Constructs a new VectorFieldSpan from a VectorField, yields a new view to the same data
+     * @param other the VectorField to view
+     */
+    // Disabled by SFINAE in the case of `ElementType` is not `const` to avoid write access
+    template <
+            class OElementType,
+            std::size_t... Is,
+            class SFINAEElementType = ElementType,
+            class = std::enable_if_t<std::is_const_v<SFINAEElementType>>,
+            class Allocator>
+    constexpr VectorFieldSpan(
+            VectorField<OElementType, Domain, NDTag, Allocator> const& other,
+            std::index_sequence<Is...> const&) noexcept
+        : base_type((chunk_type(ddcHelpers::get<ddc::type_seq_element_t<Is, NDTag>>(other)))...)
+    {
+    }
+
+    template <
+            class... Chunks,
+            class = std::enable_if_t<std::conjunction_v<std::is_same<Chunks, chunk_type>...>>>
+    constexpr VectorFieldSpan(Chunks&&... chunks) : base_type(std::move(chunks)...)
+    {
+    }
+
+    /** Constructs a new VectorFieldSpan by copy of a chunk, yields a new view to the same data
+     * @param other the VectorFieldSpan to move
+     */
+    template <class OElementType, std::size_t... Is>
+    constexpr VectorFieldSpan(
+            VectorFieldSpan<OElementType, mdomain_type, LayoutStridedPolicy, MemorySpace> const&
+                    other,
+            std::index_sequence<Is...> const&) noexcept
+        : base_type((ddcHelpers::get<ddc::type_seq_element_t<Is, NDTag>>(other))...)
+    {
+    }
+
+    template <class SliceType, std::size_t... Is>
+    constexpr auto get_slice(SliceType const& slice_spec, std::index_sequence<Is...> const&)
+    {
+        auto chunk_slices = std::make_tuple(
+                this->template get<ddc::type_seq_element_t<Is, NDTag>>()[slice_spec]...);
+        using ChunkType = std::tuple_element_t<0, decltype(chunk_slices)>;
+        return VectorFieldSpan<
+                ElementType,
+                typename ChunkType::mdomain_type,
+                NDTag,
+                typename ChunkType::layout_type,
+                typename ChunkType::memory_space>(std::move(std::get<Is>(chunk_slices))...);
+    }
+
+public:
+    /// Empty VectorFieldSpan
+    constexpr VectorFieldSpan() = default;
+
+    /** Constructs a new VectorFieldSpan by copy, yields a new view to the same data
+     * @param other the VectorFieldSpan to copy
+     */
+    constexpr VectorFieldSpan(VectorFieldSpan const& other) = default;
+
+    /** Constructs a new VectorFieldSpan by move
+     * @param other the VectorFieldSpan to move
+     */
+    constexpr VectorFieldSpan(VectorFieldSpan&& other) = default;
+
+    /** Constructs a new VectorFieldSpan from a VectorField, yields a new view to the same data
+     * @param other the VectorField to view
+     */
+    template <class OElementType, class Allocator>
+    constexpr VectorFieldSpan(VectorField<OElementType, Domain, NDTag, Allocator>& other) noexcept
+        : VectorFieldSpan(other, std::make_index_sequence<base_type::NDims> {})
+    {
+    }
+
+    /** Constructs a new VectorFieldSpan from a VectorField, yields a new view to the same data
+     * @param other the VectorField to view
+     */
+    // Disabled by SFINAE in the case of `ElementType` is not `const` to avoid write access
+    template <
+            class OElementType,
+            class SFINAEElementType = ElementType,
+            class = std::enable_if_t<std::is_const_v<SFINAEElementType>>,
+            class Allocator>
+    constexpr VectorFieldSpan(
+            VectorField<OElementType, Domain, NDTag, Allocator> const& other) noexcept
+        : VectorFieldSpan(other, std::make_index_sequence<base_type::NDims> {})
+    {
+    }
+
+    /** Constructs a new VectorFieldSpan by copy of a chunk, yields a new view to the same data
+     * @param other the VectorFieldSpan to move
+     */
+    template <class OElementType>
+    constexpr VectorFieldSpan(
+            VectorFieldSpan<OElementType, mdomain_type, LayoutStridedPolicy, MemorySpace> const&
+                    other) noexcept
+        : VectorFieldSpan(other, std::make_index_sequence<base_type::NDims> {})
+    {
+    }
+
+    /** Constructs a new VectorFieldSpan from scratch
+     * @param ptr the allocation pointer to the data
+     * @param domain the domain that sustains the view
+     */
+    template <
+            class... OElementType,
+            class = std::enable_if_t<
+                    std::conjunction_v<std::is_same<OElementType, ElementType>...>>,
+            class = std::enable_if_t<sizeof...(OElementType) == base_type::NDims>>
+    KOKKOS_FUNCTION VectorFieldSpan(mdomain_type const& domain, OElementType*... ptr)
+        : base_type((chunk_type(ptr, domain))...)
+    {
+    }
+
+    /** Copy-assigns a new value to this VectorFieldSpan, yields a new view to the same data
+     * @param other the VectorFieldSpan to copy
+     * @return *this
+     */
+    constexpr VectorFieldSpan& operator=(VectorFieldSpan const& other) = default;
+
+    /** Move-assigns a new value to this VectorFieldSpan
+     * @param other the VectorFieldSpan to move
+     * @return *this
+     */
+    constexpr VectorFieldSpan& operator=(VectorFieldSpan&& other) = default;
+
+    /**
+     * Get a constant reference to the vector field referred to by this vector field span.
+     *
+     * @return A constant reference to the vector field.
+     */
+    constexpr view_type span_cview() const
+    {
+        return view_type(*this);
+    }
+
+    /**
+     * Get a modifiable reference to the vector field referred to by this vector field span.
+     *
+     * @return A constant reference to the vector field.
+     */
+    constexpr span_type span_view() const
+    {
+        return *this;
+    }
+
+    /**
+     * @brief Slice out some dimensions.
+     *
+     * Get the VectorField on the reduced domain which is obtained by indexing
+     * the dimensions QueryDDims at the position slice_spec.
+     *
+     * @param[in] slice_spec The slice describing the domain of interest.
+     *
+     * @return A reference to the vector field on the sliced domain.
+     */
+    template <class... QueryDDims>
+    constexpr auto operator[](ddc::DiscreteElement<QueryDDims...> const& slice_spec)
+    {
+        return get_slice(slice_spec, std::make_index_sequence<base_type::NDims> {});
+    }
+
+    /**
+     * @brief Slice out some dimensions.
+     *
+     * Get the VectorField on the reduced domain passed as an argument.
+     *
+     * @param[in] odomain The domain of interest.
+     *
+     * @return A reference to the vector field on the sliced domain.
+     */
+    template <class... QueryDDims>
+    constexpr auto operator[](ddc::DiscreteDomain<QueryDDims...> const& odomain)
+    {
+        return get_slice(odomain, std::make_index_sequence<base_type::NDims> {});
+    }
+};
+
+template <
+        class ElementType,
+        class Domain,
+        class NDTag,
+        class LayoutStridedPolicy = std::experimental::layout_right,
+        class MemorySpace = Kokkos::DefaultHostExecutionSpace::memory_space>
+using VectorFieldView
+        = VectorFieldSpan<const ElementType, Domain, NDTag, LayoutStridedPolicy, MemorySpace>;
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index d935ecf2d..10d355b42 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -18,3 +18,4 @@ gtest_discover_tests(unit_tests_common)
 add_subdirectory(geometryXVx)
 add_subdirectory(geometryXYVxVy)
 add_subdirectory(geometryRTheta)
+add_subdirectory(utils)
diff --git a/tests/utils/CMakeLists.txt b/tests/utils/CMakeLists.txt
new file mode 100644
index 000000000..79ce4f9f8
--- /dev/null
+++ b/tests/utils/CMakeLists.txt
@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: MIT
+
+cmake_minimum_required(VERSION 3.15)
+
+include(GoogleTest)
+
+add_executable(unit_tests_utils
+    field.cpp
+    ../main.cpp
+)
+target_compile_features(unit_tests_utils PUBLIC cxx_std_17)
+target_link_libraries(unit_tests_utils
+    PUBLIC
+        DDC::PDI_Wrapper
+        GTest::gtest
+        GTest::gmock
+        paraconf::paraconf
+        vcx::utils
+)
+
+gtest_discover_tests(unit_tests_utils)
diff --git a/tests/utils/field.cpp b/tests/utils/field.cpp
new file mode 100644
index 000000000..e1d3f6396
--- /dev/null
+++ b/tests/utils/field.cpp
@@ -0,0 +1,640 @@
+// SPDX-License-Identifier: MIT
+#include <ddc/ddc.hpp>
+
+#include <gtest/gtest.h>
+
+#include <directional_tag.hpp>
+#include <vector_field.hpp>
+#include <vector_field_span.hpp>
+
+namespace {
+
+class Tag1
+{
+};
+class Tag2
+{
+};
+
+using Direction = NDTag<Tag1, Tag2>;
+
+using Coord = ddc::Coordinate<Tag1, Tag2>;
+
+using DElem0D = ddc::DiscreteElement<>;
+using DVect0D = ddc::DiscreteVector<>;
+using DDom0D = ddc::DiscreteDomain<>;
+
+template <class Datatype>
+using VectorField0D = VectorField<Datatype, DDom0D, Direction>;
+template <class Datatype>
+using VectorFieldSpan0D = VectorFieldSpan<Datatype, DDom0D, Direction>;
+
+struct DDimX;
+using DElemX = ddc::DiscreteElement<DDimX>;
+using DVectX = ddc::DiscreteVector<DDimX>;
+using DDomX = ddc::DiscreteDomain<DDimX>;
+
+template <class Datatype>
+using VectorFieldX = VectorField<Datatype, DDomX, Direction>;
+template <class Datatype>
+using VectorFieldSpanX = VectorFieldSpan<Datatype, DDomX, Direction>;
+
+
+struct DDimY;
+using DElemY = ddc::DiscreteElement<DDimY>;
+using DVectY = ddc::DiscreteVector<DDimY>;
+using DDomY = ddc::DiscreteDomain<DDimY>;
+
+template <class Datatype>
+using VectorFieldY = VectorField<Datatype, DDomY, Direction>;
+template <class Datatype>
+using VectorFieldSpanY = VectorFieldSpan<Datatype, DDomY, Direction>;
+
+
+struct DDimZ;
+using DElemZ = ddc::DiscreteElement<DDimZ>;
+using DVectZ = ddc::DiscreteVector<DDimZ>;
+using DDomZ = ddc::DiscreteDomain<DDimZ>;
+
+
+using DElemXY = ddc::DiscreteElement<DDimX, DDimY>;
+using DVectXY = ddc::DiscreteVector<DDimX, DDimY>;
+using DDomXY = ddc::DiscreteDomain<DDimX, DDimY>;
+
+template <class Datatype>
+using VectorFieldXY = VectorField<Datatype, DDomXY, Direction>;
+
+
+using DElemYX = ddc::DiscreteElement<DDimY, DDimX>;
+using DVectYX = ddc::DiscreteVector<DDimY, DDimX>;
+using DDomYX = ddc::DiscreteDomain<DDimY, DDimX>;
+
+template <class Datatype>
+using VectorFieldYX = VectorField<Datatype, DDomYX, Direction>;
+template <class Datatype>
+using VectorFieldSpanYX = VectorFieldSpan<Datatype, DDomYX, Direction>;
+
+
+static DElem0D constexpr lbound_0d {};
+static DVect0D constexpr nelems_0d {};
+static DDom0D constexpr dom_0d(lbound_0d, nelems_0d);
+
+static DElemX constexpr lbound_x(50);
+static DVectX constexpr nelems_x(3);
+static DDomX constexpr dom_x(lbound_x, nelems_x);
+
+static DElemY constexpr lbound_y(4);
+static DVectY constexpr nelems_y(12);
+
+static DElemXY constexpr lbound_x_y {lbound_x, lbound_y};
+static DVectXY constexpr nelems_x_y(nelems_x, nelems_y);
+static DDomXY constexpr dom_x_y(lbound_x_y, nelems_x_y);
+
+} // namespace
+
+// Member types of VectorField 1D \{
+
+TEST(VectorField0DTest, LayoutType)
+{
+    EXPECT_TRUE((std::is_same_v<
+                 VectorField0D<double>::chunk_type::layout_type,
+                 std::experimental::layout_right>));
+}
+
+TEST(VectorField1DTest, LayoutType)
+{
+    VectorFieldX<double> chunk(dom_x);
+
+    EXPECT_TRUE((std::is_same_v<
+                 std::decay_t<decltype(chunk)::chunk_type>::layout_type,
+                 std::experimental::layout_right>));
+}
+
+// TODO: many missing types
+
+// \}
+// Functions implemented in VectorField 1D (and free functions specific to it) \{
+
+TEST(VectorField0DTest, VectorFieldSpanConversionConstructor)
+{
+    Coord constexpr factor(1.391, 2.444);
+    VectorField0D<double> chunk(dom_0d);
+    ddcHelpers::get<Tag1>(chunk)() = ddc::get<Tag1>(factor);
+    ddcHelpers::get<Tag2>(chunk)() = ddc::get<Tag2>(factor);
+
+    VectorField0D<double> chunk2(chunk.span_view());
+    EXPECT_EQ(chunk2.domain(), dom_0d);
+    EXPECT_DOUBLE_EQ(factor.get<Tag1>(), chunk2().get<Tag1>());
+    EXPECT_DOUBLE_EQ(factor.get<Tag2>(), chunk2().get<Tag2>());
+}
+
+TEST(VectorField1DTest, VectorFieldSpanConversionConstructor)
+{
+    Coord constexpr factor(1.391, 2.444);
+    VectorFieldX<double> chunk(dom_x);
+    for (auto&& ix : chunk.domain()) {
+        Coord val = double(ix.uid()) * factor;
+        ddcHelpers::get<Tag1>(chunk)(ix) = ddc::get<Tag1>(val);
+        ddcHelpers::get<Tag2>(chunk)(ix) = ddc::get<Tag2>(val);
+    }
+
+    VectorFieldX<double> chunk2(chunk.span_view());
+    EXPECT_EQ(chunk2.domain(), dom_x);
+    for (auto&& ix : chunk2.domain()) {
+        EXPECT_DOUBLE_EQ(ddc::get<Tag1>(factor) * ix.uid(), ddc::get<Tag1>(chunk2(ix)));
+        EXPECT_DOUBLE_EQ(ddc::get<Tag2>(factor) * ix.uid(), ddc::get<Tag2>(chunk2(ix)));
+    }
+}
+
+TEST(VectorField0DTest, MoveConstructor)
+{
+    Coord constexpr factor(1.391, 2.444);
+    VectorField0D<double> chunk(dom_0d);
+    ddcHelpers::get<Tag1>(chunk)() = ddc::get<Tag1>(factor);
+    ddcHelpers::get<Tag2>(chunk)() = ddc::get<Tag2>(factor);
+
+    VectorField0D<double> chunk2(std::move(chunk));
+    EXPECT_EQ(chunk2.domain(), dom_0d);
+    EXPECT_DOUBLE_EQ(ddc::get<Tag1>(factor), ddc::get<Tag1>(chunk2()));
+    EXPECT_DOUBLE_EQ(ddc::get<Tag2>(factor), ddc::get<Tag2>(chunk2()));
+}
+
+TEST(VectorField1DTest, MoveConstructor)
+{
+    Coord constexpr factor(1.391, 2.444);
+    VectorFieldX<double> chunk(dom_x);
+    for (auto&& ix : chunk.domain()) {
+        Coord val = double(ix.uid()) * factor;
+        ddcHelpers::get<Tag1>(chunk)(ix) = ddc::get<Tag1>(val);
+        ddcHelpers::get<Tag2>(chunk)(ix) = ddc::get<Tag2>(val);
+    }
+
+    VectorFieldX<double> chunk2(std::move(chunk));
+    EXPECT_EQ(chunk2.domain(), dom_x);
+    for (auto&& ix : chunk2.domain()) {
+        // we expect exact equality, not EXPECT_DOUBLE_EQ: this is the same ref twice
+        Coord val = double(ix.uid()) * factor;
+        EXPECT_EQ(ddc::get<Tag1>(val), ddc::get<Tag1>(chunk2(ix)));
+        EXPECT_EQ(ddc::get<Tag2>(val), ddc::get<Tag2>(chunk2(ix)));
+    }
+}
+
+TEST(VectorField0DTest, MoveAssignment)
+{
+    Coord constexpr factor(1.391, 2.444);
+    VectorField0D<double> chunk(dom_0d);
+    ddcHelpers::get<Tag1>(chunk)() = ddc::get<Tag1>(factor);
+    ddcHelpers::get<Tag2>(chunk)() = ddc::get<Tag2>(factor);
+
+    VectorField0D<double> chunk2(DDom0D(lbound_0d, DVect0D()));
+    chunk2 = std::move(chunk);
+    EXPECT_EQ(chunk2.domain(), dom_0d);
+    EXPECT_DOUBLE_EQ(ddc::get<Tag1>(factor), ddc::get<Tag1>(chunk2()));
+    EXPECT_DOUBLE_EQ(ddc::get<Tag2>(factor), ddc::get<Tag2>(chunk2()));
+}
+
+TEST(VectorField1DTest, MoveAssignment)
+{
+    Coord constexpr factor(1.391, 2.444);
+    VectorFieldX<double> chunk(dom_x);
+    for (auto&& ix : chunk.domain()) {
+        Coord val = double(ix.uid()) * factor;
+        ddcHelpers::get<Tag1>(chunk)(ix) = ddc::get<Tag1>(val);
+        ddcHelpers::get<Tag2>(chunk)(ix) = ddc::get<Tag2>(val);
+    }
+
+    VectorFieldX<double> chunk2(DDomX(lbound_x, DVectX(0)));
+    chunk2 = std::move(chunk);
+    EXPECT_EQ(chunk2.domain(), dom_x);
+    for (auto&& ix : chunk2.domain()) {
+        // we expect exact equality, not EXPECT_DOUBLE_EQ: this is the same ref twice
+        Coord val = double(ix.uid()) * factor;
+        EXPECT_EQ(ddc::get<Tag1>(val), ddc::get<Tag1>(chunk2(ix)));
+        EXPECT_EQ(ddc::get<Tag2>(val), ddc::get<Tag2>(chunk2(ix)));
+    }
+}
+
+TEST(VectorField0DTest, Swap)
+{
+    Coord constexpr factor(1.391, 2.444);
+    VectorField0D<double> chunk(dom_0d);
+    ddcHelpers::get<Tag1>(chunk)() = ddc::get<Tag1>(factor);
+    ddcHelpers::get<Tag2>(chunk)() = ddc::get<Tag2>(factor);
+
+    DDom0D empty_domain(lbound_0d, DVect0D());
+    VectorField0D<double> chunk2(empty_domain);
+
+    std::swap(chunk2, chunk);
+    EXPECT_EQ(chunk.domain(), empty_domain);
+    EXPECT_EQ(chunk2.domain(), dom_0d);
+    EXPECT_DOUBLE_EQ(ddc::get<Tag1>(factor), ddc::get<Tag1>(chunk2()));
+    EXPECT_DOUBLE_EQ(ddc::get<Tag2>(factor), ddc::get<Tag2>(chunk2()));
+}
+
+TEST(VectorField1DTest, Swap)
+{
+    Coord constexpr factor(1.391, 2.444);
+    VectorFieldX<double> chunk(dom_x);
+    for (auto&& ix : chunk.domain()) {
+        Coord val = double(ix.uid()) * factor;
+        ddcHelpers::get<Tag1>(chunk)(ix) = ddc::get<Tag1>(val);
+        ddcHelpers::get<Tag2>(chunk)(ix) = ddc::get<Tag2>(val);
+    }
+
+    DDomX empty_domain(lbound_x, DVectX(0));
+    VectorFieldX<double> chunk2(empty_domain);
+
+    std::swap(chunk2, chunk);
+    EXPECT_EQ(chunk.domain(), empty_domain);
+    EXPECT_EQ(chunk2.domain(), dom_x);
+    for (auto&& ix : chunk2.domain()) {
+        // we expect exact equality, not EXPECT_DOUBLE_EQ: this is the same ref twice
+        Coord val = double(ix.uid()) * factor;
+        EXPECT_EQ(ddc::get<Tag1>(val), ddc::get<Tag1>(chunk2(ix)));
+        EXPECT_EQ(ddc::get<Tag2>(val), ddc::get<Tag2>(chunk2(ix)));
+    }
+}
+
+// no dim subset access in 1D
+
+TEST(VectorField1DTest, AccessConst)
+{
+    Coord constexpr factor(1.391, 2.444);
+    VectorFieldX<double> chunk(dom_x);
+    VectorFieldX<double> const& chunk_cref = chunk;
+    for (auto&& ix : chunk.domain()) {
+        Coord val = double(ix.uid()) * factor;
+        ddcHelpers::get<Tag1>(chunk)(ix) = ddc::get<Tag1>(val);
+        ddcHelpers::get<Tag2>(chunk)(ix) = ddc::get<Tag2>(val);
+        // we expect exact equality, not EXPECT_DOUBLE_EQ: this is the same ref twice
+        EXPECT_EQ(ddc::get<Tag1>(val), ddc::get<Tag1>(chunk_cref(ix)));
+        EXPECT_EQ(ddc::get<Tag2>(val), ddc::get<Tag2>(chunk_cref(ix)));
+    }
+}
+
+TEST(VectorField1DTest, Access)
+{
+    Coord constexpr factor(1.391, 2.444);
+    VectorFieldX<double> chunk(dom_x);
+    for (auto&& ix : chunk.domain()) {
+        Coord val = double(ix.uid()) * factor;
+        ddcHelpers::get<Tag1>(chunk)(ix) = ddc::get<Tag1>(val);
+        ddcHelpers::get<Tag2>(chunk)(ix) = ddc::get<Tag2>(val);
+        // we expect exact equality, not EXPECT_DOUBLE_EQ: this is the same ref twice
+        EXPECT_EQ(ddc::get<Tag1>(val), ddc::get<Tag1>(chunk(ix)));
+        EXPECT_EQ(ddc::get<Tag2>(val), ddc::get<Tag2>(chunk(ix)));
+    }
+}
+
+TEST(VectorField1DTest, SpanCview)
+{
+    Coord constexpr factor(1.391, 2.444);
+    VectorFieldX<double> chunk(dom_x);
+    for (auto&& ix : chunk.domain()) {
+        Coord val = double(ix.uid()) * factor;
+        ddcHelpers::get<Tag1>(chunk)(ix) = ddc::get<Tag1>(val);
+        ddcHelpers::get<Tag2>(chunk)(ix) = ddc::get<Tag2>(val);
+        // we expect exact equality, not EXPECT_DOUBLE_EQ: this is the same ref twice
+        EXPECT_EQ(ddc::get<Tag1>(val), ddc::get<Tag1>(chunk.span_cview()(ix)));
+        EXPECT_EQ(ddc::get<Tag2>(val), ddc::get<Tag2>(chunk.span_cview()(ix)));
+    }
+}
+
+TEST(VectorField1DTest, ViewConst)
+{
+    Coord constexpr factor(1.391, 2.444);
+    VectorFieldX<double> chunk(dom_x);
+    VectorFieldX<double> const& chunk_cref = chunk;
+    for (auto&& ix : chunk.domain()) {
+        Coord val = double(ix.uid()) * factor;
+        ddcHelpers::get<Tag1>(chunk)(ix) = ddc::get<Tag1>(val);
+        ddcHelpers::get<Tag2>(chunk)(ix) = ddc::get<Tag2>(val);
+        // we expect exact equality, not EXPECT_DOUBLE_EQ: this is the same ref twice
+        EXPECT_EQ(ddc::get<Tag1>(val), ddc::get<Tag1>(chunk_cref.span_view()(ix)));
+        EXPECT_EQ(ddc::get<Tag2>(val), ddc::get<Tag2>(chunk_cref.span_view()(ix)));
+    }
+}
+
+TEST(VectorField1DTest, View)
+{
+    Coord constexpr factor(1.391, 2.444);
+    VectorFieldX<double> chunk(dom_x);
+    VectorFieldSpanX<double> chunk_span = chunk.span_view();
+    for (auto&& ix : chunk.domain()) {
+        Coord val = double(ix.uid()) * factor;
+        ddcHelpers::get<Tag1>(chunk_span)(ix) = ddc::get<Tag1>(val);
+        ddcHelpers::get<Tag2>(chunk_span)(ix) = ddc::get<Tag2>(val);
+        // we expect exact equality, not EXPECT_DOUBLE_EQ: this is the same ref twice
+        EXPECT_EQ(ddc::get<Tag1>(val), ddc::get<Tag1>(chunk(ix)));
+        EXPECT_EQ(ddc::get<Tag2>(val), ddc::get<Tag2>(chunk(ix)));
+    }
+}
+
+// \}
+// Functions inherited from VectorFieldCommon (and free functions implemented for it) \{
+
+// constructors are hidden
+
+// assignment operators are hidden
+
+// no slicing (operator[]) in 1D
+
+// access (operator()) operators are hidden
+
+// TODO: accessor
+
+TEST(VectorField1DTest, Rank)
+{
+    VectorFieldX<double> chunk(dom_x);
+    EXPECT_EQ(VectorFieldX<double>::rank(), 1);
+}
+
+// TODO: stride
+
+// swap is hidden
+
+TEST(VectorField1DTest, Domain)
+{
+    VectorFieldX<double> chunk(dom_x);
+    EXPECT_EQ(dom_x, chunk.domain());
+}
+
+TEST(VectorField1DTest, DomainX)
+{
+    VectorFieldX<double> chunk(dom_x);
+    EXPECT_EQ(dom_x, chunk.domain<DDimX>());
+}
+
+// TODO: data_handle()
+
+// TODO: internal_mdspan
+
+// TODO: allocation_mdspan
+
+TEST(VectorField1DTest, GetDomainX)
+{
+    VectorFieldX<double> chunk(dom_x);
+    EXPECT_EQ(dom_x, ddcHelpers::get_domain<DDimX>(chunk));
+}
+
+
+TEST(VectorField1DTest, Deepcopy)
+{
+    VectorFieldX<double> chunk(dom_x);
+    for (auto&& ix : chunk.domain()) {
+        ddcHelpers::get<Tag1>(chunk)(ix) = 1.001 * ix.uid();
+        ddcHelpers::get<Tag2>(chunk)(ix) = 0.0;
+    }
+    VectorFieldX<double> chunk2(chunk.domain());
+    ddcHelpers::deepcopy(chunk2, chunk);
+    for (auto&& ix : chunk.domain()) {
+        // we expect exact equality, not EXPECT_DOUBLE_EQ: these are copy
+        EXPECT_EQ(ddc::get<Tag1>(chunk2(ix)), ddc::get<Tag1>(chunk(ix)));
+        EXPECT_EQ(ddc::get<Tag2>(chunk2(ix)), ddc::get<Tag2>(chunk(ix)));
+    }
+}
+
+// \}
+// Functions implemented in VectorField 2D (and free functions specific to it) \{
+
+// TODO: lots to do still!
+
+TEST(VectorField2DTest, Access)
+{
+    VectorFieldXY<double> chunk(dom_x_y);
+    for (auto&& ix : chunk.domain<DDimX>()) {
+        for (auto&& iy : chunk.domain<DDimY>()) {
+            ddcHelpers::get<Tag1>(chunk)(ix, iy) = 1.357 * ix.uid();
+            ddcHelpers::get<Tag2>(chunk)(ix, iy) = 1.159 * iy.uid();
+            // we expect exact equality, not EXPECT_DOUBLE_EQ: this is the same ref twice
+            EXPECT_EQ(ddc::get<Tag1>(chunk(ix, iy)), ddc::get<Tag1>(chunk(ix, iy)));
+            EXPECT_EQ(ddc::get<Tag2>(chunk(ix, iy)), ddc::get<Tag2>(chunk(ix, iy)));
+        }
+    }
+}
+
+TEST(VectorField2DTest, AccessReordered)
+{
+    VectorFieldXY<double> chunk(dom_x_y);
+    for (auto&& ix : chunk.domain<DDimX>()) {
+        for (auto&& iy : chunk.domain<DDimY>()) {
+            ddcHelpers::get<Tag1>(chunk)(ix, iy) = 1.455 * ix.uid();
+            ddcHelpers::get<Tag2>(chunk)(ix, iy) = 1.522 * iy.uid();
+            // we expect exact equality, not EXPECT_DOUBLE_EQ: this is the same ref twice
+            EXPECT_EQ(ddc::get<Tag1>(chunk(iy, ix)), ddc::get<Tag1>(chunk(ix, iy)));
+            EXPECT_EQ(ddc::get<Tag2>(chunk(iy, ix)), ddc::get<Tag2>(chunk(ix, iy)));
+        }
+    }
+}
+
+TEST(VectorField2DTest, Cview)
+{
+    VectorFieldXY<double> chunk(dom_x_y);
+    for (auto&& ix : chunk.domain<DDimX>()) {
+        for (auto&& iy : chunk.domain<DDimY>()) {
+            ddcHelpers::get<Tag1>(chunk)(ix, iy) = 1. * ix.uid();
+            ddcHelpers::get<Tag2>(chunk)(ix, iy) = .001 * iy.uid();
+        }
+    }
+    auto cview = chunk.span_cview();
+    for (auto&& ix : chunk.domain<DDimX>()) {
+        for (auto&& iy : chunk.domain<DDimY>()) {
+            // we expect complete equality, not EXPECT_DOUBLE_EQ: these are copy
+            EXPECT_EQ(ddc::get<Tag1>(cview(ix, iy)), ddc::get<Tag1>(chunk(ix, iy)));
+            EXPECT_EQ(ddc::get<Tag2>(cview(ix, iy)), ddc::get<Tag2>(chunk(ix, iy)));
+        }
+    }
+}
+
+TEST(VectorField2DTest, SliceCoordX)
+{
+    DElemX constexpr slice_x_val = DElemX(lbound_x + 1);
+
+    VectorFieldXY<double> chunk(dom_x_y);
+    VectorFieldXY<double> const& chunk_cref = chunk;
+    for (auto&& ix : chunk.domain<DDimX>()) {
+        for (auto&& iy : chunk.domain<DDimY>()) {
+            ddcHelpers::get<Tag1>(chunk)(ix, iy) = 1. * ix.uid();
+            ddcHelpers::get<Tag2>(chunk)(ix, iy) = .001 * iy.uid();
+        }
+    }
+
+    auto&& chunk_y = chunk_cref[slice_x_val];
+    EXPECT_TRUE((std::is_same_v<
+                 std::decay_t<decltype(chunk_y)>::layout_type,
+                 std::experimental::layout_right>));
+    EXPECT_EQ(
+            ddcHelpers::get<Tag1>(chunk_y).extent<DDimY>(),
+            ddcHelpers::get<Tag1>(chunk).extent<DDimY>());
+    EXPECT_EQ(
+            ddcHelpers::get<Tag2>(chunk_y).extent<DDimY>(),
+            ddcHelpers::get<Tag2>(chunk).extent<DDimY>());
+    for (auto&& ix : chunk_cref.domain<DDimY>()) {
+        // we expect complete equality, not EXPECT_DOUBLE_EQ: these are copy
+        EXPECT_EQ(ddc::get<Tag1>(chunk_y(ix)), ddc::get<Tag1>(chunk_cref(slice_x_val, ix)));
+        EXPECT_EQ(ddc::get<Tag2>(chunk_y(ix)), ddc::get<Tag2>(chunk_cref(slice_x_val, ix)));
+    }
+}
+
+TEST(VectorField2DTest, SliceCoordY)
+{
+    DElemY constexpr slice_y_val = DElemY(lbound_y + 1);
+
+    VectorFieldXY<double> chunk(dom_x_y);
+    VectorFieldXY<double> const& chunk_cref = chunk;
+    for (auto&& ix : chunk.domain<DDimX>()) {
+        for (auto&& iy : chunk.domain<DDimY>()) {
+            ddcHelpers::get<Tag1>(chunk)(ix, iy) = 1. * ix.uid();
+            ddcHelpers::get<Tag2>(chunk)(ix, iy) = .001 * iy.uid();
+        }
+    }
+
+    auto&& chunk_x = chunk_cref[slice_y_val];
+    EXPECT_TRUE((std::is_same_v<
+                 std::decay_t<decltype(chunk_x)>::layout_type,
+                 std::experimental::layout_stride>));
+    EXPECT_EQ(
+            ddcHelpers::get<Tag1>(chunk_x).extent<DDimX>(),
+            ddcHelpers::get<Tag1>(chunk).extent<DDimX>());
+    EXPECT_EQ(
+            ddcHelpers::get<Tag2>(chunk_x).extent<DDimX>(),
+            ddcHelpers::get<Tag2>(chunk).extent<DDimX>());
+    for (auto&& ix : chunk_cref.domain<DDimX>()) {
+        // we expect complete equality, not EXPECT_DOUBLE_EQ: these are copy
+        EXPECT_EQ(ddc::get<Tag1>(chunk_x(ix)), ddc::get<Tag1>(chunk_cref(ix, slice_y_val)));
+        EXPECT_EQ(ddc::get<Tag2>(chunk_x(ix)), ddc::get<Tag2>(chunk_cref(ix, slice_y_val)));
+    }
+}
+
+TEST(VectorField2DTest, SliceDomainX)
+{
+    DDomX constexpr subdomain_x = DDomX(DElemX(lbound_x + 1), DVectX(nelems_x - 2));
+
+    VectorFieldXY<double> chunk(dom_x_y);
+    VectorFieldXY<double> const& chunk_cref = chunk;
+    for (auto&& ix : chunk.domain<DDimX>()) {
+        for (auto&& iy : chunk.domain<DDimY>()) {
+            ddcHelpers::get<Tag1>(chunk)(ix, iy) = 1. * ix.uid();
+            ddcHelpers::get<Tag2>(chunk)(ix, iy) = .001 * iy.uid();
+        }
+    }
+
+    auto&& subchunk_x = chunk_cref[subdomain_x];
+    EXPECT_TRUE((std::is_same_v<
+                 std::decay_t<decltype(subchunk_x)>::layout_type,
+                 std::experimental::layout_right>));
+
+    EXPECT_EQ(ddcHelpers::get<Tag1>(subchunk_x).extent<DDimX>(), subdomain_x.size());
+    EXPECT_EQ(ddcHelpers::get<Tag2>(subchunk_x).extent<DDimY>(), chunk.domain<DDimY>().size());
+    EXPECT_EQ(ddcHelpers::get<Tag1>(subchunk_x).extent<DDimX>(), subdomain_x.size());
+    EXPECT_EQ(ddcHelpers::get<Tag2>(subchunk_x).extent<DDimY>(), chunk.domain<DDimY>().size());
+    for (auto&& ix : subchunk_x.domain<DDimX>()) {
+        for (auto&& iy : subchunk_x.domain<DDimY>()) {
+            // we expect complete equality, not EXPECT_DOUBLE_EQ: these are copy
+            EXPECT_EQ(ddc::get<Tag1>(subchunk_x(ix, iy)), ddc::get<Tag1>(chunk_cref(ix, iy)));
+            EXPECT_EQ(ddc::get<Tag2>(subchunk_x(ix, iy)), ddc::get<Tag2>(chunk_cref(ix, iy)));
+        }
+    }
+}
+
+TEST(VectorField2DTest, SliceDomainXTooearly)
+{
+    [[maybe_unused]] DDomX constexpr subdomain_x = DDomX(DElemX(lbound_x - 1), nelems_x);
+
+    VectorFieldXY<double> chunk(dom_x_y);
+#ifndef NDEBUG // The assertion is only checked if NDEBUG isn't defined
+    // the error message is checked with clang & gcc only
+    EXPECT_DEATH(
+            chunk[subdomain_x],
+            R"rgx([Aa]ssert.*uid<ODDims>\(m_element_begin\).*uid<ODDims>\(odomain\.m_element_begin\))rgx");
+#endif
+}
+
+TEST(VectorField2DTest, SliceDomainXToolate)
+{
+    [[maybe_unused]] DDomX constexpr subdomain_x = DDomX(lbound_x, DVectX(nelems_x + 1));
+
+    VectorFieldXY<double> chunk(dom_x_y);
+#ifndef NDEBUG // The assertion is only checked if NDEBUG isn't defined
+    // the error message is checked with clang & gcc only
+    EXPECT_DEATH(
+            chunk[subdomain_x],
+            R"rgx([Aa]ssert.*uid<ODDims>\(m_element_end\).*uid<ODDims>\(odomain\.m_element_end\).*)rgx");
+#endif
+}
+
+TEST(VectorField2DTest, SliceDomainY)
+{
+    DDomY constexpr subdomain_y = DDomY(DElemY(lbound_y + 1), DVectY(nelems_y - 2));
+
+    VectorFieldXY<double> chunk(dom_x_y);
+    VectorFieldXY<double> const& chunk_cref = chunk;
+    for (auto&& ix : chunk.domain<DDimX>()) {
+        for (auto&& iy : chunk.domain<DDimY>()) {
+            ddcHelpers::get<Tag1>(chunk)(ix, iy) = 1. * ix.uid();
+            ddcHelpers::get<Tag2>(chunk)(ix, iy) = .001 * iy.uid();
+        }
+    }
+    auto&& subchunk_y = chunk_cref[subdomain_y];
+    EXPECT_TRUE((std::is_same_v<
+                 std::decay_t<decltype(subchunk_y)>::layout_type,
+                 std::experimental::layout_stride>));
+
+    EXPECT_EQ(ddcHelpers::get<Tag1>(subchunk_y).extent<DDimX>(), chunk.domain<DDimX>().size());
+    EXPECT_EQ(ddcHelpers::get<Tag1>(subchunk_y).extent<DDimY>(), subdomain_y.size());
+    EXPECT_EQ(ddcHelpers::get<Tag2>(subchunk_y).extent<DDimX>(), chunk.domain<DDimX>().size());
+    EXPECT_EQ(ddcHelpers::get<Tag2>(subchunk_y).extent<DDimY>(), subdomain_y.size());
+    for (auto&& ix : subchunk_y.domain<DDimX>()) {
+        for (auto&& iy : subchunk_y.domain<DDimY>()) {
+            // we expect complete equality, not EXPECT_DOUBLE_EQ: these are copy
+            EXPECT_EQ(ddc::get<Tag1>(subchunk_y(ix, iy)), ddc::get<Tag1>(chunk_cref(ix, iy)));
+            EXPECT_EQ(ddc::get<Tag2>(subchunk_y(ix, iy)), ddc::get<Tag2>(chunk_cref(ix, iy)));
+        }
+    }
+}
+
+TEST(VectorField2DTest, Deepcopy)
+{
+    VectorFieldXY<double> chunk(dom_x_y);
+    for (auto&& ix : chunk.domain<DDimX>()) {
+        for (auto&& iy : chunk.domain<DDimY>()) {
+            ddcHelpers::get<Tag1>(chunk)(ix, iy) = 1.739 * ix.uid();
+            ddcHelpers::get<Tag2>(chunk)(ix, iy) = 1.412 * iy.uid();
+        }
+    }
+    VectorFieldXY<double> chunk2(chunk.domain());
+    ddcHelpers::deepcopy(chunk2, chunk);
+    for (auto&& ix : chunk.domain<DDimX>()) {
+        for (auto&& iy : chunk.domain<DDimY>()) {
+            // we expect complete equality, not EXPECT_DOUBLE_EQ: these are copy
+            EXPECT_EQ(ddc::get<Tag1>(chunk2(ix, iy)), ddc::get<Tag1>(chunk(ix, iy)));
+            EXPECT_EQ(ddc::get<Tag2>(chunk2(ix, iy)), ddc::get<Tag2>(chunk(ix, iy)));
+        }
+    }
+}
+
+TEST(VectorField2DTest, DeepcopyReordered)
+{
+    VectorFieldXY<double> chunk(dom_x_y);
+    for (auto&& ix : chunk.domain<DDimX>()) {
+        for (auto&& iy : chunk.domain<DDimY>()) {
+            ddcHelpers::get<Tag1>(chunk)(ix, iy) = 1.739 * ix.uid();
+            ddcHelpers::get<Tag2>(chunk)(ix, iy) = 1.412 * iy.uid();
+        }
+    }
+    VectorFieldYX<double> chunk2(ddc::select<DDimY, DDimX>(chunk.domain()));
+    VectorFieldSpan<double, DDomXY, Direction, std::experimental::layout_left> chunk2_view(
+            chunk.domain(),
+            chunk2.get<Tag1>().data_handle(),
+            chunk2.get<Tag2>().data_handle());
+    ddcHelpers::deepcopy(chunk2_view, chunk);
+    for (auto&& ix : chunk.domain<DDimX>()) {
+        for (auto&& iy : chunk.domain<DDimY>()) {
+            // we expect complete equality, not EXPECT_DOUBLE_EQ: these are copy
+            EXPECT_EQ(ddc::get<Tag1>(chunk2(ix, iy)), ddc::get<Tag1>(chunk(ix, iy)));
+            EXPECT_EQ(ddc::get<Tag2>(chunk2(ix, iy)), ddc::get<Tag2>(chunk(ix, iy)));
+            EXPECT_EQ(ddc::get<Tag1>(chunk2(ix, iy)), ddc::get<Tag1>(chunk(iy, ix)));
+            EXPECT_EQ(ddc::get<Tag2>(chunk2(ix, iy)), ddc::get<Tag2>(chunk(iy, ix)));
+        }
+    }
+}