From 7b663b33ef45dc415956ce299b386bc5afa5a3d0 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Fri, 16 Oct 2020 14:03:30 +0000
Subject: [PATCH 01/24] naive_nabla is done

---
 .devcontainer/devcontainer.json               |  32 ++
 cpputil/unstructured/CMakeLists.txt           |  20 -
 cpputil/unstructured/atlas_field_converter.cc |  63 ---
 cpputil/unstructured/atlas_field_converter.cu |  61 ---
 cpputil/unstructured/atlas_mesh_adapter.cc    |  51 ---
 .../include/gridtools/next/atlas_adapter.hpp  | 102 +----
 .../next/atlas_array_view_adapter.hpp         |  22 +-
 .../gridtools/next/atlas_field_util.hpp       | 115 -----
 .../include/gridtools/next/domain.hpp         |  10 +
 .../include/gridtools/next/math.hpp           |   0
 .../include/gridtools/next/mesh.hpp           |  93 ----
 .../next/test_helper/field_builder.hpp        |  34 --
 .../next/test_helper/simple_mesh.hpp          | 165 -------
 .../include/gridtools/next/tmp_storage.hpp    |  21 +-
 .../include/gridtools/next/unstructured.hpp   |  23 +-
 cpputil/unstructured/prototype.cc             | 155 -------
 .../tests/regression/fvm_nabla/CMakeLists.txt |  19 +-
 .../tests/regression/fvm_nabla/driver.cc      | 421 +++++++-----------
 .../tests/regression/fvm_nabla/nabla_cuda.hpp |   6 +-
 .../regression/fvm_nabla/nabla_naive.hpp      | 343 +++++---------
 .../tests/unit_tests/next/CMakeLists.txt      |   4 -
 .../unit_tests/next/test_atlas_field_util.cc  |  62 ---
 .../next/test_helper/CMakeLists.txt           |   2 -
 .../next/test_helper/test_field_builder.cc    | 105 -----
 .../next/test_helper/test_simple_mesh.cc      |  54 ---
 .../tests/unit_tests/next/test_mesh.cc        |  30 --
 26 files changed, 370 insertions(+), 1643 deletions(-)
 create mode 100644 .devcontainer/devcontainer.json
 delete mode 100644 cpputil/unstructured/atlas_field_converter.cc
 delete mode 100644 cpputil/unstructured/atlas_field_converter.cu
 delete mode 100644 cpputil/unstructured/atlas_mesh_adapter.cc
 delete mode 100644 cpputil/unstructured/include/gridtools/next/atlas_field_util.hpp
 create mode 100644 cpputil/unstructured/include/gridtools/next/domain.hpp
 delete mode 100644 cpputil/unstructured/include/gridtools/next/math.hpp
 delete mode 100644 cpputil/unstructured/include/gridtools/next/mesh.hpp
 delete mode 100644 cpputil/unstructured/include/gridtools/next/test_helper/field_builder.hpp
 delete mode 100644 cpputil/unstructured/include/gridtools/next/test_helper/simple_mesh.hpp
 delete mode 100644 cpputil/unstructured/prototype.cc
 delete mode 100644 cpputil/unstructured/tests/unit_tests/next/test_atlas_field_util.cc
 delete mode 100644 cpputil/unstructured/tests/unit_tests/next/test_helper/CMakeLists.txt
 delete mode 100644 cpputil/unstructured/tests/unit_tests/next/test_helper/test_field_builder.cc
 delete mode 100644 cpputil/unstructured/tests/unit_tests/next/test_helper/test_simple_mesh.cc
 delete mode 100644 cpputil/unstructured/tests/unit_tests/next/test_mesh.cc

diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
new file mode 100644
index 0000000..5453115
--- /dev/null
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,32 @@
+{
+	"name": "Existing Dockerfile",
+
+	// Sets the run context to one level up instead of the .devcontainer folder.
+	"context": "..",
+
+	// Update the 'dockerFile' property if you aren't using the standard 'Dockerfile' filename.
+	"dockerFile": "../.gitpod.Dockerfile",
+
+	// Set *default* container specific settings.json values on container create.
+	"settings": { 
+		"terminal.integrated.shell.linux": null
+	},
+
+	// Add the IDs of extensions you want installed when the container is created.
+	"extensions": []
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Uncomment the next line to run commands after the container is created - for example installing curl.
+	// "postCreateCommand": "apt-get update && apt-get install -y curl",
+
+	// Uncomment when using a ptrace-based debugger like C++, Go, and Rust
+	// "runArgs": [ "--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined" ],
+
+	// Uncomment to use the Docker CLI from inside the container. See https://aka.ms/vscode-remote/samples/docker-from-docker.
+	// "mounts": [ "source=/var/run/docker.sock,target=/var/run/docker.sock,type=bind" ],
+
+	// Uncomment to connect as a non-root user if you've added one. See https://aka.ms/vscode-remote/containers/non-root.
+	// "remoteUser": "vscode"
+}
diff --git a/cpputil/unstructured/CMakeLists.txt b/cpputil/unstructured/CMakeLists.txt
index 2f6fafa..baea663 100644
--- a/cpputil/unstructured/CMakeLists.txt
+++ b/cpputil/unstructured/CMakeLists.txt
@@ -27,29 +27,9 @@ FetchContent_MakeAvailable(GridTools)
 add_library(gtnext INTERFACE)
 target_include_directories(gtnext INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
 
-add_executable(prototype prototype.cc)
-target_link_libraries(prototype GridTools::gridtools)
-target_include_directories(prototype PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
-
 find_package(eckit REQUIRED)
 find_package(Atlas REQUIRED)
 
-add_executable(atlas_mesh_adapter atlas_mesh_adapter.cc)
-target_link_libraries(atlas_mesh_adapter atlas GridTools::gridtools)
-target_include_directories(atlas_mesh_adapter PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
-
-add_executable(atlas_field_converter atlas_field_converter.cc)
-target_link_libraries(atlas_field_converter atlas GridTools::gridtools)
-target_include_directories(atlas_field_converter PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
-
-if(CMAKE_CUDA_COMPILER)
-  add_executable(atlas_field_converter_cuda atlas_field_converter.cu)
-  target_link_libraries(atlas_field_converter_cuda atlas GridTools::storage_gpu)
-  target_include_directories(atlas_field_converter_cuda PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
-  target_compile_options(atlas_field_converter_cuda PRIVATE "-std=c++17")
-  target_compile_options(atlas_field_converter_cuda PRIVATE "-arch=sm_50")
-endif()
-
 if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
     include(CTest)
     if(BUILD_TESTING)
diff --git a/cpputil/unstructured/atlas_field_converter.cc b/cpputil/unstructured/atlas_field_converter.cc
deleted file mode 100644
index 5438c81..0000000
--- a/cpputil/unstructured/atlas_field_converter.cc
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "atlas/grid.h"
-#include "atlas/mesh/actions/BuildCellCentres.h"
-#include "atlas/mesh/actions/BuildDualMesh.h"
-#include "atlas/mesh/actions/BuildEdges.h"
-#include "atlas/meshgenerator.h"
-#include "gridtools/common/integral_constant.hpp"
-#include <array_fwd.h>
-#include <atlas/array.h>
-#include <atlas/grid/StructuredGrid.h>
-#include <atlas/mesh.h>
-#include <atlas/option.h>
-#include <field/Field.h>
-#include <functionspace/EdgeColumns.h>
-#include <type_traits>
-
-#include "gridtools/next/atlas_array_view_adapter.hpp"
-#include <gridtools/next/atlas_adapter.hpp>
-#include <gridtools/next/atlas_field_util.hpp>
-#include <gridtools/next/mesh.hpp>
-#include <gridtools/sid/synthetic.hpp>
-
-#include "gridtools/sid/rename_dimensions.hpp"
-#include "tests/include/util/atlas_util.hpp"
-
-namespace dim {
-    struct k;
-} // namespace dim
-
-int main() {
-    auto mesh = atlas_util::make_mesh();
-    atlas::mesh::actions::build_edges(mesh);
-
-    int nb_levels = 5;
-    atlas::functionspace::EdgeColumns fs_edges(mesh, atlas::option::levels(nb_levels) | atlas::option::halo(1));
-
-    atlas::Field f;
-    auto my_field = fs_edges.createField<double>(atlas::option::name("my_field"));
-
-    auto view = atlas::array::make_view<double, 2>(my_field);
-    for (int i = 0; i < fs_edges.size(); ++i)
-        for (int k = 0; k < nb_levels; ++k)
-            view(i, k) = i * 10 + k;
-
-    auto my_field_sidified = gridtools::next::atlas_util::as<edge, dim::k>::with_type<double>{}(my_field);
-    static_assert(gridtools::is_sid<decltype(my_field_sidified)>{});
-
-    auto my_field_as_data_store =
-        gridtools::next::atlas_util::as_data_store<edge, dim::k>::with_type<double>{}(my_field);
-    static_assert(gridtools::is_sid<decltype(my_field_as_data_store)>{});
-
-    auto strides = gridtools::sid::get_strides(my_field_sidified);
-    auto strides_ds = gridtools::sid::get_strides(my_field_as_data_store);
-    for (int i = 0; i < fs_edges.size(); ++i)
-        for (int k = 0; k < nb_levels; ++k) {
-            auto ptr = gridtools::sid::get_origin(my_field_sidified)();
-            gridtools::sid::shift(ptr, gridtools::at_key<edge>(strides), i);
-            gridtools::sid::shift(ptr, gridtools::at_key<dim::k>(strides), k);
-            auto ptr2 = gridtools::sid::get_origin(my_field_as_data_store)();
-            gridtools::sid::shift(ptr2, gridtools::at_key<edge>(strides_ds), i);
-            gridtools::sid::shift(ptr2, gridtools::at_key<dim::k>(strides_ds), k);
-            std::cout << view(i, k) << "/" << *ptr << "/" << *ptr2 << std::endl;
-        }
-}
diff --git a/cpputil/unstructured/atlas_field_converter.cu b/cpputil/unstructured/atlas_field_converter.cu
deleted file mode 100644
index f5ef8f6..0000000
--- a/cpputil/unstructured/atlas_field_converter.cu
+++ /dev/null
@@ -1,61 +0,0 @@
-#include "atlas/grid.h"
-#include "atlas/mesh/actions/BuildCellCentres.h"
-#include "atlas/mesh/actions/BuildDualMesh.h"
-#include "atlas/mesh/actions/BuildEdges.h"
-#include "atlas/meshgenerator.h"
-#include "gridtools/common/integral_constant.hpp"
-#include <array_fwd.h>
-#include <atlas/array.h>
-#include <atlas/grid/StructuredGrid.h>
-#include <atlas/mesh.h>
-#include <atlas/option.h>
-#include <field/Field.h>
-#include <functionspace/EdgeColumns.h>
-#include <type_traits>
-
-#include "gridtools/next/atlas_array_view_adapter.hpp"
-#include <gridtools/next/atlas_adapter.hpp>
-#include <gridtools/next/atlas_field_util.hpp>
-#include <gridtools/next/mesh.hpp>
-#include <gridtools/sid/synthetic.hpp>
-
-#include "tests/include/util/atlas_util.hpp"
-
-namespace dim {
-    struct k;
-} // namespace dim
-
-template <class Ptr, class Strides, class UpperBounds>
-__global__ void kernel(Ptr ptr_holder, Strides strides, UpperBounds upper_bounds) {
-    auto ptr = ptr_holder();
-    gridtools::sid::shift(ptr, gridtools::device::at_key<edge>(strides), threadIdx.x);
-    for (int i = 0; i < gridtools::device::at_key<dim::k>(upper_bounds); ++i) {
-        printf("%f\n", *ptr);
-        gridtools::sid::shift(ptr, gridtools::device::at_key<dim::k>(strides), 1);
-    }
-}
-
-int main() {
-    auto mesh = atlas_util::make_mesh();
-    atlas::mesh::actions::build_edges(mesh);
-
-    int nb_levels = 5;
-    atlas::functionspace::EdgeColumns fs_edges(mesh, atlas::option::levels(nb_levels) | atlas::option::halo(1));
-
-    atlas::Field f;
-    auto my_field = fs_edges.createField<double>(atlas::option::name("my_field"));
-
-    auto view = atlas::array::make_view<double, 2>(my_field);
-    for (int i = 0; i < fs_edges.size(); ++i)
-        for (int k = 0; k < nb_levels; ++k)
-            view(i, k) = i * 10 + k;
-
-    auto my_field_as_data_store =
-        gridtools::next::atlas_util::as_data_store<edge, dim::k>::with_type<double>{}(my_field);
-    static_assert(gridtools::is_sid<decltype(my_field_as_data_store)>{});
-
-    kernel<<<1, fs_edges.size()>>>(gridtools::sid::get_origin(my_field_as_data_store),
-        gridtools::sid::get_strides(my_field_as_data_store),
-        gridtools::sid::get_upper_bounds(my_field_as_data_store));
-    cudaDeviceSynchronize();
-}
diff --git a/cpputil/unstructured/atlas_mesh_adapter.cc b/cpputil/unstructured/atlas_mesh_adapter.cc
deleted file mode 100644
index 9743e54..0000000
--- a/cpputil/unstructured/atlas_mesh_adapter.cc
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "atlas/grid.h"
-#include "atlas/mesh/actions/BuildCellCentres.h"
-#include "atlas/mesh/actions/BuildDualMesh.h"
-#include "atlas/mesh/actions/BuildEdges.h"
-#include "atlas/meshgenerator.h"
-#include <atlas/grid/StructuredGrid.h>
-#include <atlas/mesh.h>
-#include <type_traits>
-
-#include <gridtools/next/atlas_adapter.hpp>
-#include <gridtools/next/atlas_array_view_adapter.hpp>
-#include <gridtools/next/mesh.hpp>
-
-#include <gridtools/common/tuple_util.hpp>
-#include <gridtools/sid/composite.hpp>
-
-#include "tests/include/util/atlas_util.hpp"
-
-int main() {
-    auto mesh = atlas_util::make_mesh();
-    atlas::mesh::actions::build_edges(mesh);
-    atlas::mesh::actions::build_node_to_edge_connectivity(mesh);
-
-    auto const &v2e = gridtools::next::mesh::connectivity<std::tuple<vertex, edge>>(mesh);
-
-    auto n_vertices = gridtools::next::connectivity::size(v2e);
-    std::cout << n_vertices << std::endl;
-    std::cout << gridtools::next::connectivity::max_neighbors(v2e) << std::endl;
-    std::cout << gridtools::next::connectivity::skip_value(v2e) << std::endl;
-    auto v2e_tbl = gridtools::next::connectivity::neighbor_table(v2e);
-
-    static_assert(gridtools::is_sid<decltype(v2e_tbl)>{});
-    namespace tu = gridtools::tuple_util;
-    auto composite = tu::make<gridtools::sid::composite::keys<edge // TODO just a dummy
-        >::values>(v2e_tbl);
-    //   auto tmp = sid_get_lower_bounds(composite);
-    static_assert(gridtools::sid::concept_impl_::is_sid<decltype(composite)>{});
-
-    auto strides = gridtools::sid::get_strides(v2e_tbl);
-
-    std::cout << gridtools::at_key<neighbor>(strides) << std::endl;
-    std::cout << gridtools::at_key<vertex>(strides) << std::endl;
-
-    for (std::size_t v = 0; v < gridtools::next::connectivity::size(v2e); ++v) {
-        auto ptr = gridtools::sid::get_origin(v2e_tbl)();
-        gridtools::sid::shift(ptr, gridtools::at_key<vertex>(strides), v);
-        for (std::size_t i = 0; i < gridtools::next::connectivity::max_neighbors(v2e); ++i) {
-            gridtools::sid::shift(ptr, gridtools::at_key<neighbor>(strides), 1);
-        }
-    }
-}
diff --git a/cpputil/unstructured/include/gridtools/next/atlas_adapter.hpp b/cpputil/unstructured/include/gridtools/next/atlas_adapter.hpp
index aaa10c7..2b29cf7 100644
--- a/cpputil/unstructured/include/gridtools/next/atlas_adapter.hpp
+++ b/cpputil/unstructured/include/gridtools/next/atlas_adapter.hpp
@@ -1,98 +1,18 @@
 #pragma once
 
-#include <cstddef>
+#include <atlas/mesh/Connectivity.h>
 
-#include "gridtools/common/layout_map.hpp"
-#include <atlas/mesh.h>
-#include <gridtools/sid/concept.hpp>
-#include <gridtools/sid/rename_dimensions.hpp>
 #include <gridtools/storage/builder.hpp>
-#include <gridtools/storage/sid.hpp>
 
-#include <mesh/Connectivity.h>
-
-#include "mesh.hpp"
-#include "unstructured.hpp"
-#include <gridtools/next/atlas_field_util.hpp>
-
-#ifdef __CUDACC__ // TODO proper handling
-#include <gridtools/storage/gpu.hpp>
-using storage_trait = gridtools::storage::gpu;
-#else
-#include <gridtools/storage/cpu_ifirst.hpp>
-using storage_trait = gridtools::storage::cpu_ifirst;
-#endif
-
-namespace gridtools::next::atlas_wrappers {
-    // not really a connectivity
-    template <class LocationType>
-    struct primary_connectivity {
-        std::size_t size_;
-
-        GT_FUNCTION friend std::size_t connectivity_size(primary_connectivity const &conn) { return conn.size_; }
-    };
-
-    template <class LocationType, std::size_t MaxNeighbors>
-    struct regular_connectivity {
-        struct builder {
-            auto operator()(std::size_t size) {
-                return gridtools::storage::builder<storage_trait>.template type<int>().template layout<0, 1>().template dimensions(
-                    size, std::integral_constant<std::size_t, MaxNeighbors>{});
-            }
+namespace atlas::mesh {
+    template <class Connectivity, class MaxNeighbors>
+    auto make_storage_producer(MaxNeighbors max_neighbors, Connectivity const &src) {
+        return [&src, max_neighbors](auto traits) {
+            return gridtools::storage::builder<decltype(traits)>
+            .template type<int>()
+            .dimensions(src.rows(), max_neighbors)
+            .initializer([&src](auto row, auto col) { return col < src.cols(row) ? src(row, col) : -1; })
+            .build();
         };
-
-        decltype(builder{}(std::size_t{})()) tbl_;
-        const atlas::idx_t missing_value_; // TODO Not sure if we can leave the type open
-        const gridtools::uint_t size_;
-
-        regular_connectivity(atlas::mesh::IrregularConnectivity const &conn)
-            : tbl_{builder{}(conn.rows()).initializer([&conn](std::size_t row, std::size_t col) {
-                  return col < static_cast<size_t>(conn.cols(row)) ? conn.row(row)(col) : conn.missing_value();
-              })()},
-              missing_value_{conn.missing_value()}, size_{tbl_->lengths()[0]} {}
-
-        regular_connectivity(atlas::mesh::MultiBlockConnectivity const &conn)
-            : tbl_{builder{}(conn.rows()).initializer([&conn](std::size_t row, std::size_t col) {
-                  return col < static_cast<std::size_t>(conn.cols(row)) ? conn.row(row)(col) : conn.missing_value();
-              })()},
-              missing_value_{conn.missing_value()}, size_{tbl_->lengths()[0]} {}
-
-        GT_FUNCTION friend std::size_t connectivity_size(regular_connectivity const &conn) { return conn.size_; }
-
-        GT_FUNCTION friend std::integral_constant<std::size_t, MaxNeighbors> connectivity_max_neighbors(
-            regular_connectivity const &) {
-            return {};
-        }
-
-        GT_FUNCTION friend int connectivity_skip_value(regular_connectivity const &conn) { return conn.missing_value_; }
-
-        friend auto connectivity_neighbor_table(regular_connectivity const &conn) {
-            return gridtools::sid::rename_numbered_dimensions<LocationType, neighbor>(conn.tbl_);
-        }
-    };
-
-} // namespace gridtools::next::atlas_wrappers
-
-namespace atlas {
-    template <template <class...> class L>
-    decltype(auto) mesh_connectivity(L<vertex, edge>, const Mesh &mesh) {
-        return gridtools::next::atlas_wrappers::regular_connectivity<vertex, 7
-            // TODO this number must passed by the user (probably wrap atlas mesh)
-            >{mesh.nodes().edge_connectivity()};
-    }
-
-    template <template <class...> class L>
-    decltype(auto) mesh_connectivity(L<edge, vertex>, Mesh const &mesh) {
-        return gridtools::next::atlas_wrappers::regular_connectivity<edge, 2>{mesh.edges().node_connectivity()};
-    }
-
-    template <template <class...> class L>
-    decltype(auto) mesh_connectivity(L<edge>, Mesh const &mesh) {
-        return gridtools::next::atlas_wrappers::primary_connectivity<edge>{std::size_t(mesh.edges().size())};
-    }
-
-    template <template <class...> class L>
-    decltype(auto) mesh_connectivity(L<vertex>, Mesh const &mesh) {
-        return gridtools::next::atlas_wrappers::primary_connectivity<vertex>{std::size_t(mesh.nodes().size())};
     }
-} // namespace atlas
+} // namespace atlas::mesh
diff --git a/cpputil/unstructured/include/gridtools/next/atlas_array_view_adapter.hpp b/cpputil/unstructured/include/gridtools/next/atlas_array_view_adapter.hpp
index c6e5456..724a6b5 100644
--- a/cpputil/unstructured/include/gridtools/next/atlas_array_view_adapter.hpp
+++ b/cpputil/unstructured/include/gridtools/next/atlas_array_view_adapter.hpp
@@ -1,11 +1,14 @@
 #pragma once
 
-#include <atlas/array.h>
 #include <cstddef>
+#include <utility>
+
+#include <atlas/array.h>
+
 #include <gridtools/common/hymap.hpp>
 #include <gridtools/common/integral_constant.hpp>
 #include <gridtools/sid/simple_ptr_holder.hpp>
-#include <utility>
+#include <gridtools/storage/builder.hpp>
 
 /**
  * SID adapters for atlas::ArrayView.
@@ -80,4 +83,19 @@ namespace atlas::array {
         return sid_adapter_impl_::to_hymap<std::make_index_sequence<Rank>>{}(view.shape());
     }
 
+    namespace make_storage_impl {
+        template <class Traits, class T, int Rank, std::size_t... Is>
+        auto make_storage(ArrayView<T, Rank> const &view, std::index_sequence<Is...>) {
+            return ::gridtools::storage::builder<Traits> //
+                .template type<T>()                      //
+                .dimensions(view.shape(Is)...)           //
+                .initializer(view)                       //
+                .build();
+        }
+    } // namespace make_storage_impl
+
+    template <class Traits, class T, int Rank>
+    auto make_storage(Traits, ArrayView<T, Rank> const &view) {
+        return make_storage_impl::make_storage<Traits>(view, std::make_index_sequence<Rank>());
+    }
 } // namespace atlas::array
diff --git a/cpputil/unstructured/include/gridtools/next/atlas_field_util.hpp b/cpputil/unstructured/include/gridtools/next/atlas_field_util.hpp
deleted file mode 100644
index 9035caf..0000000
--- a/cpputil/unstructured/include/gridtools/next/atlas_field_util.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#include <array_fwd.h>
-#include <cassert>
-
-#include <atlas/field/Field.h>
-#include <atlas/functionspace.h>
-#include <gridtools/common/hymap.hpp>
-#include <gridtools/meta/first.hpp>
-#include <gridtools/next/atlas_array_view_adapter.hpp>
-#include <gridtools/sid/delegate.hpp>
-#include <gridtools/sid/rename_dimensions.hpp>
-
-#include <gridtools/storage/builder.hpp>
-#include <gridtools/storage/sid.hpp>
-#include <utility>
-#ifdef __CUDACC__ // TODO in a proper place
-#include <gridtools/storage/gpu.hpp>
-#else
-#include <gridtools/storage/cpu_ifirst.hpp>
-#endif
-#include "unstructured.hpp"
-
-#pragma once
-
-namespace gridtools::next::atlas_util {
-
-    // THE COMMENTED IS A DIRECT SID ADAPTION, THE OTHER IS USING THE
-    // ARRAY_VIEW_ADAPTER AND RENAMES:
-    // using strides_t =
-    //     typename gridtools::hymap::keys<DimensionTags...>::template
-    //     values<int, int>;
-    //
-    // return gridtools::sid::synthetic()
-    //     .set<gridtools::sid::property::origin>(
-    //         gridtools::sid::make_simple_ptr_holder(
-    //             atlas::array::make_view<DataType, 2>(field).data()))
-    //     .template set<gridtools::sid::property::strides>(strides_t(
-    //         field.strides()[0], field.strides()[1])) // TODO more
-    //         dimensions
-    //     .template set<gridtools::sid::property::strides_kind, strides_t>();
-
-    template <class... DimensionTags>
-    struct as {
-        using first_t = meta::first<as>;
-
-        // Atlas field dimensions order (TODO double check):
-        // 1. unstructured dimension
-        // 2. vertical
-        // 3. other dimensions
-        // from this we can derive some checks:
-        // - runtime: type of unstructured dimension (Done)
-        // - static: dim::k in first (no unstructured) or second dimension
-        // - static: no unstructured dimension tag after first dimension
-        template <class DataType>
-        struct with_type {
-            auto operator()(atlas::Field &field) {
-                assert(field.rank() == sizeof...(DimensionTags) && "Rank mismatch");
-
-                if constexpr (std::is_same<first_t, edge>{}) {
-                    if (field.functionspace().type().compare("EdgeColumns") != 0 &&
-                        field.functionspace().type().compare("Edges") != 0) // TODO EdgeColumns vs Edges
-                        atlas::throw_Exception(field.name() + " is not an edge field", Here());
-                } else if constexpr (std::is_same<first_t, cell>{}) {
-                    if (field.functionspace().type().compare("Cells") != 0)
-                        atlas::throw_Exception(field.name() + " is not a cell field", Here());
-                } else if constexpr (std::is_same<first_t, vertex>{}) {
-                    if (field.functionspace().type().compare("NodeColumns") != 0) // TODO NodeColumns vs Nodes
-                        atlas::throw_Exception(field.name() + " is not a vertex field", Here());
-                }
-
-                static_assert(
-                    gridtools::is_sid<decltype(atlas::array::make_view<DataType, sizeof...(DimensionTags)>(field))>{},
-                    "ArrayView is not SID. Did you include "
-                    "\"atlas_array_view_adapter.hpp\"?");
-                return gridtools::sid::rename_numbered_dimensions<DimensionTags...>(
-                    atlas::array::make_view<DataType, sizeof...(DimensionTags)>(field));
-            }
-        };
-    };
-
-    // TODO just a temporary solution, maybe a SID transformer would make sense
-    // (requirement would be upper and lower bounds are available for the input SID)
-    template <class... DimensionTags>
-    struct as_data_store {
-        template <class DataType>
-        struct with_type {
-            template <class>
-            struct custom_builder;
-            template <std::size_t... Is>
-            struct custom_builder<std::index_sequence<Is...>> {
-                template <class StorageTrait>
-                auto build(atlas::Field const &field) {
-                    auto const &shape = field.shape();
-                    auto view = atlas::array::make_view<DataType, sizeof...(DimensionTags)>(field);
-                    return gridtools::sid::rename_numbered_dimensions<DimensionTags...>(std::move(
-                    gridtools::storage::builder<StorageTrait>.template
-            dimensions(                shape[Is]...)
-            .template type<DataType>()
-                .initializer([&](auto... indices){
-                    return view(indices...);
-                })()
-            ));
-                }
-            };
-
-            auto operator()(atlas::Field &field) {
-                auto builder = custom_builder<std::make_index_sequence<sizeof...(DimensionTags)>>{};
-#ifdef __CUDACC__ // TODO in a proper place
-                return builder.template build<gridtools::storage::gpu>(field);
-#else
-                return builder.template build<gridtools::storage::cpu_ifirst>(field);
-#endif
-            }
-        };
-    };
-} // namespace gridtools::next::atlas_util
diff --git a/cpputil/unstructured/include/gridtools/next/domain.hpp b/cpputil/unstructured/include/gridtools/next/domain.hpp
new file mode 100644
index 0000000..ee4b893
--- /dev/null
+++ b/cpputil/unstructured/include/gridtools/next/domain.hpp
@@ -0,0 +1,10 @@
+#pragma once
+
+namespace gridtools::next {
+    struct domain {
+        int vertex;
+        int edge;
+        int cell;
+        int k;
+    };
+}
diff --git a/cpputil/unstructured/include/gridtools/next/math.hpp b/cpputil/unstructured/include/gridtools/next/math.hpp
deleted file mode 100644
index e69de29..0000000
diff --git a/cpputil/unstructured/include/gridtools/next/mesh.hpp b/cpputil/unstructured/include/gridtools/next/mesh.hpp
deleted file mode 100644
index 754f530..0000000
--- a/cpputil/unstructured/include/gridtools/next/mesh.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <utility>
-
-#include "unstructured.hpp"
-#include <gridtools/common/hymap.hpp>
-#include <gridtools/common/integral_constant.hpp>
-#include <gridtools/sid/concept.hpp>
-
-namespace gridtools {
-    namespace next {
-
-        namespace connectivity {
-            template <class Connectivity>
-            auto neighbor_table(Connectivity const &connectivity)
-            /* -> decltype(connectivity_neighbor_table(connectivity)) */ // TODO this results in a CUDA error
-            {
-                return connectivity_neighbor_table(connectivity);
-            };
-
-            // TODO remove GT_FUNCTION after Code generator is updated to use the info struct or similar
-            template <class Connectivity>
-            GT_FUNCTION auto max_neighbors(Connectivity const &connectivity)
-                -> decltype(connectivity_max_neighbors(connectivity)) {
-                // return max_neighbors_type<Connectivity>::value;
-                return connectivity_max_neighbors(connectivity);
-            }
-
-            // TODO remove GT_FUNCTION after Code generator is updated to use the info struct or similar
-            template <class Connectivity>
-            GT_FUNCTION std::size_t size(Connectivity const &connectivity) {
-                return connectivity_size(connectivity);
-            }
-
-            // TODO remove GT_FUNCTION after Code generator is updated to use the info struct or similar
-            template <class Connectivity>
-            GT_FUNCTION auto skip_value(Connectivity const &connectivity)
-                -> decltype(connectivity_skip_value(connectivity)) {
-                return connectivity_skip_value(connectivity);
-            }
-
-            template <class MaxNeighborsT, class SkipValueT>
-            struct info {
-                MaxNeighborsT max_neighbors;
-                SkipValueT skip_value;
-                std::size_t size;
-            };
-
-            template <class MaxNeighborsT, class SkipValueT>
-            info<MaxNeighborsT, SkipValueT> make_info(MaxNeighborsT max_neighbors,
-                SkipValueT skip_value,
-                std::size_t size /* size last as it will probably be replaced by iteration_space concept */) {
-                return {max_neighbors, skip_value, size};
-            }
-
-            template <class Connectivity>
-            auto extract_info(Connectivity const &connectivity) {
-                return make_info(max_neighbors(connectivity), skip_value(connectivity), size(connectivity));
-            }
-
-        } // namespace connectivity
-
-        namespace mesh {
-            struct not_provided;
-            not_provided mesh_connectivity(...);
-
-            // Models gridtools::hymaps as mesh
-            template <class Key,
-                class Mesh,
-                class K = meta::rename<meta::list, Key>,
-                class Res = decltype(mesh_connectivity(K(), std::declval<Mesh const &>())),
-                std::enable_if_t< //
-                    std::is_same_v<Res, not_provided>
-                    /* && is_connectivity_v<decltype(at_key<K>(std::declval<Mesh const&>()))> */,
-                    int> = 0>
-            auto connectivity(Mesh const &mesh) -> decltype(at_key<K>(mesh)) {
-                return at_key<K>(mesh);
-            }
-
-            template <class Key,
-                class Mesh,
-                // rename to meta::list avoids requiring keys to be defined if incoming list is, e.g., std::tuple
-                class K = meta::rename<meta::list, Key>,
-                class Res = decltype(mesh_connectivity(K(), std::declval<Mesh const &>())),
-                std::enable_if_t<!std::is_same<Res, not_provided>::value, int> = 0>
-            Res connectivity(Mesh const &mesh) {
-                return mesh_connectivity(K(), mesh);
-            }
-        } // namespace mesh
-
-    } // namespace next
-} // namespace gridtools
diff --git a/cpputil/unstructured/include/gridtools/next/test_helper/field_builder.hpp b/cpputil/unstructured/include/gridtools/next/test_helper/field_builder.hpp
deleted file mode 100644
index 673e628..0000000
--- a/cpputil/unstructured/include/gridtools/next/test_helper/field_builder.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "../unstructured.hpp"
-#include "gridtools/next/mesh.hpp"
-#include <gridtools/sid/rename_dimensions.hpp>
-#include <gridtools/storage/builder.hpp>
-#include <gridtools/storage/sid.hpp>
-#include <type_traits>
-
-#ifdef __CUDACC__ // TODO proper handling
-#include <gridtools/storage/gpu.hpp>
-using storage_trait = gridtools::storage::gpu;
-#else
-#include <gridtools/storage/cpu_ifirst.hpp>
-using storage_trait = gridtools::storage::cpu_ifirst;
-#endif
-
-namespace gridtools::next::test_helper {
-
-    namespace make_field_impl_ {
-
-        template <class T>
-        struct builder {
-            auto operator()(std::size_t size) const {
-                return gridtools::storage::builder<storage_trait>.template type<T>().template dimensions(size);
-            }
-        };
-    } // namespace make_field_impl_
-
-    template <class T, class Location, class Mesh>
-    auto make_field(Mesh const &mesh) {
-        // TODO seems it would be nice if we can adapt the data_store builder to create SIDs with named dimension
-        return sid::rename_numbered_dimensions<Location> // TODO
-            (make_field_impl_::builder<T>{}(connectivity::size(mesh::connectivity<meta::list<Location>>(mesh)))());
-    }
-} // namespace gridtools::next::test_helper
diff --git a/cpputil/unstructured/include/gridtools/next/test_helper/simple_mesh.hpp b/cpputil/unstructured/include/gridtools/next/test_helper/simple_mesh.hpp
deleted file mode 100644
index 8d0e3d3..0000000
--- a/cpputil/unstructured/include/gridtools/next/test_helper/simple_mesh.hpp
+++ /dev/null
@@ -1,165 +0,0 @@
-/**
- * Simple 3x3 Cartesian, periodic, hand-made mesh.
- *
- *      0e    1e    2e
- *   | ---- | ---- | ---- |
- * 9e|0v 10e|1v 11e|2v  9e|0v
- *   |  0c  |  1c  |  2c  |
- *   |  3e  |  4e  |  5e  |
- *   | ---- | ---- | ---- |
- *12e|3v 13e|4v 14e|5v 12e|3v
- *   |  3c  |  4c  |  5c  |
- *   |  6e  |  7e  |  8e  |
- *   | ---- | ---- | ---- |
- *15e|6v 16e|7v 17e|8v 15e| 6v
- *   |  6c  |  7c  |  8c  |
- *   |  0e  |  1e  |  2e  |
- *   | ---- | ---- | ---- |
- *    0v     1v     2v     0v
- *
- */
-
-#include "../mesh.hpp"
-#include "../unstructured.hpp"
-#include <cstddef>
-#include <gridtools/sid/rename_dimensions.hpp>
-#include <gridtools/storage/builder.hpp>
-#include <gridtools/storage/sid.hpp>
-#include <type_traits>
-
-#ifdef __CUDACC__ // TODO proper handling
-#include <gridtools/storage/gpu.hpp>
-using storage_trait = gridtools::storage::gpu;
-#else
-#include <gridtools/storage/cpu_ifirst.hpp>
-using storage_trait = gridtools::storage::cpu_ifirst;
-#endif
-
-namespace gridtools {
-    namespace next {
-        namespace test_helper {
-            struct simple_mesh {
-                template <class LocationType>
-                struct primary_connectivity {
-                    std::size_t size_;
-
-                    GT_FUNCTION friend std::size_t connectivity_size(primary_connectivity const &conn) {
-                        return conn.size_;
-                    }
-                };
-
-                template <class LocationType, std::size_t MaxNeighbors>
-                struct regular_connectivity {
-                    struct builder {
-                        auto operator()(std::size_t size) {
-                            return gridtools::storage::builder<storage_trait>.template type<int>().template layout<0, 1>().template dimensions(
-                    size, std::integral_constant<std::size_t, MaxNeighbors>{});
-                        }
-                    };
-
-                    decltype(builder{}(0)()) tbl_;
-                    std::size_t size_;
-                    static constexpr gridtools::int_t missing_value_ = -1;
-
-                    regular_connectivity(std::vector<std::array<int, MaxNeighbors>> tbl)
-                        : tbl_{builder{}(tbl.size()).initializer([&tbl](std::size_t primary, std::size_t neigh) {
-                              return tbl[primary][neigh];
-                          })()},
-                          size_{tbl.size()} {}
-
-                    GT_FUNCTION friend std::size_t connectivity_size(regular_connectivity const &conn) {
-                        return conn.size_;
-                    }
-
-                    GT_FUNCTION friend std::integral_constant<std::size_t, MaxNeighbors> connectivity_max_neighbors(
-                        regular_connectivity const &) {
-                        return {};
-                    }
-
-                    GT_FUNCTION friend int connectivity_skip_value(regular_connectivity const &conn) {
-                        return conn.missing_value_;
-                    }
-
-                    friend auto connectivity_neighbor_table(regular_connectivity const &conn) {
-                        return gridtools::sid::rename_numbered_dimensions<LocationType, neighbor>(conn.tbl_);
-                    }
-                };
-
-                template <template <class...> class L>
-                friend decltype(auto) mesh_connectivity(L<vertex>, simple_mesh const &) {
-                    return primary_connectivity<vertex>{9};
-                }
-                template <template <class...> class L>
-                friend decltype(auto) mesh_connectivity(L<edge>, simple_mesh const &) {
-                    return primary_connectivity<edge>{18};
-                }
-                template <template <class...> class L>
-                friend decltype(auto) mesh_connectivity(L<cell>, simple_mesh const &) {
-                    return primary_connectivity<cell>{9};
-                }
-                template <template <class...> class L>
-                friend decltype(auto) mesh_connectivity(L<cell, cell>, simple_mesh const &) {
-                    return regular_connectivity<cell, 4>{{
-                        {6, 1, 3, 2}, // 0
-                        {7, 2, 4, 0}, // 1
-                        {8, 0, 5, 1}, // 2
-                        {0, 4, 6, 5}, // 3
-                        {1, 5, 7, 3}, // 4
-                        {2, 3, 8, 4}, // 5
-                        {3, 7, 0, 8}, // 6
-                        {4, 8, 1, 6}, // 7
-                        {5, 6, 2, 7}  // 8
-                    }};
-                }
-                template <template <class...> class L>
-                friend decltype(auto) mesh_connectivity(L<edge, vertex>, simple_mesh const &) {
-                    return regular_connectivity<edge, 2>{{
-                        {0, 1}, // 0
-                        {1, 2},
-                        {2, 0},
-                        {3, 4},
-                        {4, 5},
-                        {5, 3},
-                        {6, 7},
-                        {7, 8},
-                        {8, 6},
-                        {0, 3}, // 9
-                        {1, 4},
-                        {2, 5},
-                        {3, 6},
-                        {4, 7},
-                        {5, 8},
-                        {6, 0},
-                        {7, 1},
-                        {8, 2},
-                    }};
-                }
-            };
-        } // namespace test_helper
-    }     // namespace next
-} // namespace gridtools
-
-/**
- * TODO maybe later: Simple 2x2 Cartesian hand-made mesh, non periodic, one halo line.
- *
- *     0e    1e    2e    3e
- *   | --- | --- | --- | --- |
- *   |0v   |1v   |2v   |3v   |4v
- *   |  0c |  1c |  2c |  3c |
- *   |     |     |     |     |
- *   | --- | --- | --- | --- |
- *   |     |     |     |     |
- *   |  4c |  5c |  6c |  7c |
- *   |     |     |     |     |
- *   | --- | --- | --- | --- |
- *   |     |     |     |     |
- *   |  8c |  9c | 10c | 11c |
- *   |     |     |     |     |
- *   | --- | --- | --- | --- |
- *   |     |     |     |     |
- *   | 12c | 13c | 14c | 15c |
- *   |     |     |     |     |
- *   | --- | --- | --- | --- |
- *
- *
- */
diff --git a/cpputil/unstructured/include/gridtools/next/tmp_storage.hpp b/cpputil/unstructured/include/gridtools/next/tmp_storage.hpp
index f8c7d38..5197706 100644
--- a/cpputil/unstructured/include/gridtools/next/tmp_storage.hpp
+++ b/cpputil/unstructured/include/gridtools/next/tmp_storage.hpp
@@ -1,22 +1,17 @@
-#include "unstructured.hpp"
+#pragma once
+
 #include <gridtools/common/hymap.hpp>
-#include <gridtools/common/integral_constant.hpp>
 #include <gridtools/common/tuple_util.hpp>
 #include <gridtools/sid/contiguous.hpp>
 
+#include "unstructured.hpp"
+
 namespace gridtools {
     namespace next {
-        namespace tmp_impl_ {
-            template <class LocationType>
-            auto sizes(int_t unstructured_size, int_t k_size) {
-                using value_t = typename hymap::keys<LocationType, dim::k>::template values<int_t, int_t>;
-                return value_t(unstructured_size, k_size);
-            }
-        } // namespace tmp_impl_
-
-        template <class LocationType, class Data, class Allocator>
-        auto make_simple_tmp_storage(int_t unstructured_size, int_t k_size, Allocator &alloc) {
-            return sid::make_contiguous<Data, int_t>(alloc, tmp_impl_::sizes<LocationType>(unstructured_size, k_size));
+        template <class T, class Alloc, class HSize, class KSize>
+        auto make_simple_tmp_storage(HSize h_size, KSize k_size, Alloc &alloc) {
+            return sid::make_contiguous<T>(
+                alloc, tuple_util::make<hymap::keys<dim::h, dim::k>::values>(h_size, k_size));
         }
     } // namespace next
 } // namespace gridtools
diff --git a/cpputil/unstructured/include/gridtools/next/unstructured.hpp b/cpputil/unstructured/include/gridtools/next/unstructured.hpp
index bb00542..2340696 100644
--- a/cpputil/unstructured/include/gridtools/next/unstructured.hpp
+++ b/cpputil/unstructured/include/gridtools/next/unstructured.hpp
@@ -1,13 +1,14 @@
 #pragma once
 
-// TODO namespace?
-
-struct vertex;
-struct edge;
-struct cell;
-
-struct neighbor;
-
-namespace dim {
-    struct k;
-}
+#include <gridtools/common/defs.hpp>
+#include <gridtools/common/integral_constant.hpp>
+
+namespace gridtools::next::dim {
+    using horizontal = integral_constant<int_t, 0>;
+    using vertical = integral_constant<int_t, 1>;
+    using neighbor = integral_constant<int_t, 2>;
+
+    using h = horizontal;
+    using k = vertical;
+    using n = neighbor;
+} // namespace gridtools::next::dim
diff --git a/cpputil/unstructured/prototype.cc b/cpputil/unstructured/prototype.cc
deleted file mode 100644
index 8fcf7ea..0000000
--- a/cpputil/unstructured/prototype.cc
+++ /dev/null
@@ -1,155 +0,0 @@
-#include <gridtools/common/hymap.hpp>
-#include <gridtools/common/tuple_util.hpp>
-#include <gridtools/next/mesh.hpp>
-#include <gridtools/next/unstructured.hpp>
-#include <gridtools/sid/composite.hpp>
-#include <gridtools/sid/concept.hpp>
-#include <gridtools/sid/synthetic.hpp>
-#include <tuple>
-#include <vector>
-
-#include <iostream>
-
-namespace tu = gridtools::tuple_util;
-
-using vertex2edge = gridtools::meta::list<vertex, edge>;
-using edge2vertex = gridtools::meta::list<edge, vertex>;
-using cell2vertex = gridtools::meta::list<cell, vertex>;
-
-namespace my_personal_connectivity {
-    template <std::size_t MaxNeighbors, class LocationType>
-    struct myCon {
-        using location = LocationType;
-        static constexpr std::size_t neighs = MaxNeighbors;
-        std::vector<std::array<int, MaxNeighbors>> neighborTable;
-    };
-
-    template <std::size_t MaxNeighbors, class LocationType>
-    auto connectivity_max_neighbors(myCon<MaxNeighbors, LocationType> const &) {
-        return std::integral_constant<std::size_t, MaxNeighbors>{};
-    }
-
-    template <std::size_t MaxNeighbors, class LocationType>
-    std::size_t connectivity_size(myCon<MaxNeighbors, LocationType> const &conn) {
-        return conn.neighborTable.size();
-    }
-
-    template <std::size_t MaxNeighbors, class LocationType>
-    auto connectivity_neighbor_table(myCon<MaxNeighbors, LocationType> const &conn) {
-
-        using strides_t = typename gridtools::hymap::keys<LocationType,
-            neighbor>::template values<std::integral_constant<size_t, MaxNeighbors>, std::integral_constant<size_t, 1>>;
-
-        return gridtools::sid::synthetic()
-            .set<gridtools::sid::property::origin>(
-                gridtools::sid::make_simple_ptr_holder(reinterpret_cast<const int *>(conn.neighborTable.data())))
-            .template set<gridtools::sid::property::strides>(
-                strides_t(std::integral_constant<size_t, MaxNeighbors>{}, std::integral_constant<size_t, 1>{}))
-            .template set<gridtools::sid::property::strides_kind, strides_t>();
-    }
-} // namespace my_personal_connectivity
-
-struct in_tag;
-struct out_tag;
-struct connectivity_tag;
-
-template <class SID, class NeighPtrT>
-auto indirect_access(SID &&field, NeighPtrT const &neighptr) {
-    auto ptr = gridtools::sid::get_origin(field)();
-    gridtools::sid::shift(ptr, gridtools::sid::get_stride<vertex>(gridtools::sid::get_strides(field)), *neighptr);
-    return ptr;
-}
-
-template <class Mesh, class In, class Out>
-void sum_vertex_to_cell(Mesh const &mesh, In &&in, Out &&out) {
-    auto n_cells = gridtools::next::connectivity::size(gridtools::at_key<cell2vertex>(mesh));
-
-    auto cell2vertex_conn = gridtools::next::mesh::connectivity<cell2vertex>(mesh);
-    auto cell_to_vertex = gridtools::next::connectivity::neighbor_table(cell2vertex_conn);
-
-    static_assert(gridtools::sid::concept_impl_::is_sid<decltype(cell_to_vertex)>{});
-
-    auto cells = tu::make<gridtools::sid::composite::keys<out_tag, connectivity_tag>::values>(out, cell_to_vertex);
-
-    static_assert(gridtools::sid::concept_impl_::is_sid<decltype(cells)>{});
-
-    auto ptr = gridtools::sid::get_origin(cells)();
-    for (std::size_t i = 0; i < n_cells; ++i) {
-        std::cout << "cell: " << *gridtools::at_key<out_tag>(ptr) << std::endl;
-        int sum = 0;
-        auto neigh_ptr = gridtools::at_key<connectivity_tag>(ptr);
-        for (std::size_t neigh_vertex = 0;
-             neigh_vertex < gridtools::next::connectivity::max_neighbors(gridtools::at_key<cell2vertex>(mesh));
-             ++neigh_vertex) {
-            auto absolute_neigh_index = *neigh_ptr;
-            std::cout << absolute_neigh_index << " ";
-
-            auto in_ptr = indirect_access(in, neigh_ptr);
-
-            std::cout << *in_ptr << std::endl;
-
-            sum += *in_ptr;
-
-            // last thing in the loop: shift
-            gridtools::sid::shift(
-                neigh_ptr, gridtools::sid::get_stride<neighbor>(gridtools::sid::get_strides(cell_to_vertex)), 1);
-        }
-        *gridtools::at_key<out_tag>(ptr) = sum;
-        gridtools::sid::shift(ptr,
-            gridtools::sid::get_stride<cell>(gridtools::sid::get_strides(cells)),
-            1); // TODO sid::loop
-    }
-}
-
-auto make_cell_to_vertex_connectivity() {
-    std::vector<std::array<int, 4>> res;
-    res.emplace_back(std::array{0, 1, 3, 4});
-    res.emplace_back(std::array{1, 2, 4, 5});
-    res.emplace_back(std::array{3, 4, 6, 7});
-    res.emplace_back(std::array{4, 5, 7, 8});
-    return res;
-}
-
-int main() {
-    auto mesh = gridtools::tuple_util::make<gridtools::hymap::keys<cell2vertex>::values>(
-        my_personal_connectivity::myCon<4, cell>{make_cell_to_vertex_connectivity()});
-
-    using namespace gridtools::literals;
-
-    constexpr int size = 3;
-    int in_array[size][size]; // on vertices
-    auto in =
-        gridtools::sid::synthetic()
-            .set<gridtools::sid::property::origin>(gridtools::sid::make_simple_ptr_holder(&in_array[0][0]))
-            .set<gridtools::sid::property::strides>(tu::make<gridtools::hymap::keys<vertex>::values>(1_c))
-            .set<gridtools::sid::property::upper_bounds>(tu::make<gridtools::hymap::keys<vertex>::values>(size * size));
-
-    static_assert(gridtools::is_sid<decltype(in)>{});
-
-    int out_array[size - 1][size - 1]; // on cells
-    auto out = gridtools::sid::synthetic()
-                   .set<gridtools::sid::property::origin>(gridtools::sid::make_simple_ptr_holder(&out_array[0][0]))
-                   .set<gridtools::sid::property::strides>(tu::make<gridtools::hymap::keys<cell>::values>(1_c))
-                   .set<gridtools::sid::property::upper_bounds>(
-                       tu::make<gridtools::hymap::keys<cell>::values>((size - 1) * (size - 1)));
-
-    for (int i = 0; auto &&row : in_array)
-        for (auto &&val : row) {
-            val = i++;
-        }
-    for (int i = 0; auto &&row : out_array)
-        for (auto &&val : row) {
-            val = i++;
-        }
-
-    //   tuple_util::make<sid::composite::keys< in_tag, out_tag,
-    //   connectivity_tag>::values>(
-
-    sum_vertex_to_cell(mesh, in, out);
-
-    std::cout << "=== result ===" << std::endl;
-    for (auto &&row : out_array)
-        for (auto &&val : row) {
-            std::cout << val << std::endl;
-        }
-}
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt b/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt
index 109fa89..ee02f1d 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt
@@ -1,19 +1,6 @@
-function(add_driver_executable target driver_source stencil_source)
-    # generate temporary directory to generate driver code to
-    set(gen_dir ${CMAKE_CURRENT_BINARY_DIR}/generated_${target})
-    file(MAKE_DIRECTORY ${gen_dir})
-
-    # get absolute path to the stencil used in the driver template
-    get_filename_component(STENCIL_IMPL_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/${stencil_source} ABSOLUTE)
-
-    # generate driver source
-    get_filename_component(driver_source_file_name "${driver_source}" NAME)
-    configure_file(${driver_source} ${gen_dir}/${driver_source_file_name})
-
-    # gridtools_setup_target expects a relative path so transform it
-    file(RELATIVE_PATH gen_dir_rel ${CMAKE_CURRENT_SOURCE_DIR} ${gen_dir})
-
-    add_executable(${target} ${gen_dir_rel}/${driver_source_file_name})
+function(add_driver_executable target driver_source stencil_header)
+    add_executable(${target} ${driver_source})
+    target_compile_definitions(${target} PRIVATE STENCIL_HEADER=\"${stencil_header}\")
 endfunction()
 
 add_driver_executable(fvm_nabla driver.cc nabla_naive.hpp)
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/driver.cc b/cpputil/unstructured/tests/regression/fvm_nabla/driver.cc
index 6f67d5a..721d25a 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/driver.cc
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/driver.cc
@@ -1,288 +1,187 @@
-#include <fstream>
+#include <algorithm>
+#include <cmath>
 #include <limits>
+#include <tuple>
+
+#include <gtest/gtest.h>
 
-#include "atlas/functionspace/EdgeColumns.h"
-#include "atlas/functionspace/NodeColumns.h"
-#include "atlas/grid.h"
-#include "atlas/mesh/actions/BuildCellCentres.h"
-#include "atlas/mesh/actions/BuildDualMesh.h"
-#include "atlas/mesh/actions/BuildEdges.h"
-#include "atlas/meshgenerator.h"
-#include "atlas/option/Options.h"
-#include "atlas/output/Gmsh.h"
-#include "gridtools/next/mesh.hpp"
 #include <atlas/array.h>
+#include <atlas/functionspace.h>
+#include <atlas/grid.h>
 #include <atlas/mesh.h>
-#include <atlas/mesh/Nodes.h>
+#include <atlas/mesh/actions/BuildDualMesh.h>
+#include <atlas/mesh/actions/BuildEdges.h>
+#include <atlas/meshgenerator.h>
 
-#include <gridtools/sid/composite.hpp>
+#include <gridtools/common/integral_constant.hpp>
+#include <gridtools/storage/builder.hpp>
+#include <gridtools/storage/sid.hpp>
 
 #include <gridtools/next/atlas_adapter.hpp>
-#include <gridtools/next/atlas_array_view_adapter.hpp>
-#include <gridtools/next/atlas_field_util.hpp>
-#include <tuple>
-
-#include <gtest/gtest.h>
-
-#include "${STENCIL_IMPL_SOURCE}"
 
+#ifdef __CUDACC__
+#include <gridtools/storage/gpu.hpp>
 namespace {
-    template <typename DS>
-    std::tuple<double, double, double> min_max(DS const &field) {
-        double min = std::numeric_limits<double>::max();
-        double max = std::numeric_limits<double>::min();
-        auto view = field.m_impl->host_view(); // we are mixing SID with data_store concepts...
+    using storage_traits_t = gridtools::storage::gpu;
+}
+#else
+#include <gridtools/storage/cpu_ifirst.hpp>
+namespace {
+    using storage_traits_t = gridtools::storage::cpu_ifirst;
+}
+#endif
 
-        auto first_length = field.m_impl->lengths()[0];
+#include STENCIL_HEADER
 
-        double avg = 0.;
-        for (std::size_t jnode = 0; jnode < first_length; ++jnode) {
-            min = std::min(min, view(jnode, 0));
-            max = std::max(max, view(jnode, 0));
-            avg += view(jnode, 0);
-        }
-        return {min, max, avg / (double)first_length};
+namespace {
+    using namespace gridtools::literals;
+
+    constexpr auto storage_builder = gridtools::storage::builder<storage_traits_t>;
+
+    auto make_mesh() {
+        using namespace atlas;
+        using param_t = StructuredMeshGenerator::Parameters;
+        auto res = StructuredMeshGenerator(param_t("triangulate", true) | param_t("angle", -1.)).generate(Grid("O32"));
+        functionspace::EdgeColumns(res, option::levels(1) | option::halo(1));
+        functionspace::NodeColumns(res, option::levels(1) | option::halo(1));
+        mesh::actions::build_edges(res);
+        mesh::actions::build_node_to_edge_connectivity(res);
+        mesh::actions::build_median_dual_mesh(res);
+        return res;
     }
-} // namespace
 
-namespace {
-    const double rpi = 2.0 * std::asin(1.0);
+    const double rpi = 2 * std::asin(1);
     const double radius = 6371.22e+03;
-    const double deg2rad = 2. * rpi / 360.;
-
-    const int MXX = 0;
-    const int MYY = 1;
-} // namespace
-
-class FVMDriver {
-  private:
-    atlas::Mesh mesh_;
-    atlas::functionspace::EdgeColumns fs_edges_;
-    atlas::functionspace::NodeColumns fs_nodes_;
-    int nb_levels_;
-
-    atlas::Field m_S_MXX;
-    atlas::Field m_S_MYY;
-
-    atlas::Field m_vol;
-    atlas::Field m_sign;
-
-  public:
-    constexpr static int edges_per_node = 7;
-
-    FVMDriver(std::string const &grid, int nb_levels)
-        : mesh_{[&grid]() {
-              atlas::StructuredGrid structuredGrid = atlas::Grid(grid);
-              atlas::MeshGenerator::Parameters generatorParams;
-              // generatorParams.set("three_dimensional", false);
-              generatorParams.set("triangulate", true);
-              // generatorParams.set("patch_pole", true);
-              // generatorParams.set("include_pole", false);
-              //   generatorParams.set("angle", 20);
-              generatorParams.set("angle", -1.0);
-              // generatorParams.set("ghost_at_end", true);
-
-              atlas::StructuredMeshGenerator generator(generatorParams);
-              return generator.generate(structuredGrid);
-          }()},
-          fs_edges_(mesh_, atlas::option::levels(nb_levels) | atlas::option::halo(1)),
-          fs_nodes_(mesh_,
-              atlas::option::levels(nb_levels) | atlas::option::halo(1)), //
-          nb_levels_(nb_levels), m_S_MXX(fs_edges_.createField<double>(atlas::option::name("S_MXX"))),
-          m_S_MYY(fs_edges_.createField<double>(atlas::option::name("S_MYY"))),
-          m_vol(fs_nodes_.createField<double>(atlas::option::name("vol"))),
-          m_sign(fs_nodes_.createField<double>(
-              atlas::option::name("m_sign") | atlas::option::variables(FVMDriver::edges_per_node))) {
-        atlas::mesh::actions::build_edges(mesh_);
-        atlas::mesh::actions::build_node_to_edge_connectivity(mesh_);
-        atlas::mesh::actions::build_median_dual_mesh(mesh_);
-
-        initialize_S();
-        // print_min_max(m_S_MXX);
-        // print_min_max(m_S_MYY);
-        initialize_sign();
-        initialize_vol();
-        // print_min_max(m_vol);
+    const double deg2rad = 2 * rpi / 360;
+    constexpr int MXX = 0;
+    constexpr int MYY = 1;
+    constexpr auto edges_per_node = 7_c;
+
+    auto make_vol(atlas::mesh::Nodes const &nodes) {
+        auto dual_volumes = atlas::array::make_view<double, 1>(nodes.field("dual_volumes"));
+        auto init = [&](int n) { return dual_volumes(n) * (std::pow(deg2rad, 2) * std::pow(radius, 2)); };
+        return storage_builder        //
+            .type<double>()           //
+            .dimensions(nodes.size()) //
+            .initializer(init)        //
+            .build();                 //
     }
 
-  private:
-    void initialize_vol() {
-        // print_min_max_1d(mesh_.nodes().field("dual_volumes"));
-        const auto vol_atlas = atlas::array::make_view<double, 1>(mesh_.nodes().field("dual_volumes"));
-        auto vol = atlas::array::make_view<double, 2>(m_vol);
-        for (int i = 0, size = vol_atlas.size(); i < size; ++i) {
-            vol(i, 0) = vol_atlas(i) * (std::pow(deg2rad, 2) * std::pow(radius, 2));
-        }
+    auto make_sign(atlas::Mesh const &mesh) {
+        auto &&edges = mesh.edges();
+        auto &&nodes = mesh.nodes();
+        auto &&n2e = nodes.edge_connectivity();
+        auto &&e2n = edges.node_connectivity();
+        auto flags = atlas::array::make_view<int, 1>(edges.flags());
+        auto is_pole_edge = [&](auto e) {
+            using topology_t = atlas::mesh::Nodes::Topology;
+            return topology_t::check(flags(e), topology_t::POLE);
+        };
+        auto init = [&](int n, int, int e) -> double {
+            if (e >= n2e.cols(n))
+                return 0;
+            auto ee = n2e(n, e);
+            return n == e2n(ee, 0) || is_pole_edge(ee) ? 1 : -1;
+        };
+        return storage_builder                           //
+            .type<double>()                              //
+            .selector<1, 0, 1>()                         //
+            .dimensions(nodes.size(), 1, edges_per_node) //
+            .initializer(init)                           //
+            .build();                                    //
     }
-    void initialize_S() {
-        // all fields supported by dawn are 2 (or 3 with sparse) dimensional:
-        // (unstructured, lev, sparse) S has dimensions (unstructured, [MMX/MMY])
-        const auto S = atlas::array::make_view<double, 2>(mesh_.edges().field("dual_normals"));
-
-        auto S_MXX = atlas::array::make_view<double, 2>(m_S_MXX);
-        auto S_MYY = atlas::array::make_view<double, 2>(m_S_MYY);
 
-        assert(nb_levels_ == 1);
-        int klevel = 0;
-        for (int i = 0, size = mesh_.edges().size(); i < size; ++i) {
-            S_MXX(i, klevel) = S(i, MXX) * radius * deg2rad;
-            S_MYY(i, klevel) = S(i, MYY) * radius * deg2rad;
-        }
+    auto make_S_MXX(atlas::mesh::Edges const &edges) {
+        auto dual_normals = atlas::array::make_view<double, 2>(edges.field("dual_normals"));
+        return storage_builder                                                           //
+            .type<double>()                                                              //
+            .dimensions(edges.size())                                                    //
+            .initializer([&](int i) { return dual_normals(i, MXX) * radius * deg2rad; }) //
+            .build();                                                                    //
     }
 
-    void initialize_sign() {
-        auto node2edge_sign = atlas::array::make_view<double, 3>(m_sign);
-
-        auto edge_flags = atlas::array::make_view<int, 1>(mesh_.edges().flags());
-        using Topology = atlas::mesh::Nodes::Topology;
-        auto is_pole_edge = [&](size_t e) { return Topology::check(edge_flags(e), Topology::POLE); };
-
-        for (atlas::idx_t jnode = 0; jnode < mesh_.nodes().size(); ++jnode) {
-            auto const &node_edge_connectivity = mesh_.nodes().edge_connectivity();
-            auto const &edge_node_connectivity = mesh_.edges().node_connectivity();
-            for (atlas::idx_t jedge = 0; jedge < node_edge_connectivity.cols(jnode); ++jedge) {
-                auto iedge = node_edge_connectivity(jnode, jedge);
-                auto ip1 = edge_node_connectivity(iedge, 0);
-                if (jnode == ip1) {
-                    node2edge_sign(jnode, 0, jedge) = 1.;
-                } else {
-                    node2edge_sign(jnode, 0, jedge) = -1.;
-                    if (is_pole_edge(iedge)) {
-                        node2edge_sign(jnode, 0, jedge) = 1.;
-                    }
-                }
-            }
-        }
+    auto make_S_MYY(atlas::mesh::Edges const &edges) {
+        auto dual_normals = atlas::array::make_view<double, 2>(edges.field("dual_normals"));
+        return storage_builder                                                           //
+            .type<double>()                                                              //
+            .dimensions(edges.size())                                                    //
+            .initializer([&](int i) { return dual_normals(i, MYY) * radius * deg2rad; }) //
+            .build();                                                                    //
     }
 
-  public:
-    atlas::Mesh const &mesh() const { return mesh_; }
-    atlas::Mesh &mesh() { return mesh_; }
-    atlas::functionspace::EdgeColumns const &fs_edges() const { return fs_edges_; }
-    atlas::functionspace::NodeColumns const &fs_nodes() const { return fs_nodes_; }
-    int nb_levels() const { return nb_levels_; }
-    atlas::Field &S_MXX() { return m_S_MXX; }
-    atlas::Field &S_MYY() { return m_S_MYY; }
-    atlas::Field &vol() { return m_vol; }
-    atlas::Field &sign() { return m_sign; }
-
     // TODO ask Christian for a proper name for this input data
-    void fillInputData(atlas::Field &field) const {
-        double zh0 = 2000.0;
-        double zrad = 3. * rpi / 4.0 * radius;
-        double zeta = rpi / 16.0 * radius;
-        double zlatc = 0.0;
-        double zlonc = 3.0 * rpi / 2.0;
-
-        atlas::Field m_rlonlatcr{
-            fs_nodes_.createField<double>(atlas::option::name("rlonlatcr") | atlas::option::variables(edges_per_node))};
-        auto rlonlatcr = atlas::array::make_view<double, 3>(m_rlonlatcr);
-
-        atlas::Field m_rcoords{
-            fs_nodes_.createField<double>(atlas::option::name("rcoords") | atlas::option::variables(edges_per_node))};
-        auto rcoords = atlas::array::make_view<double, 3>(m_rcoords);
-
-        atlas::Field m_rcosa{fs_nodes_.createField<double>(atlas::option::name("rcosa"))};
-        auto rcosa = atlas::array::make_view<double, 2>(m_rcosa);
-
-        atlas::Field m_rsina{fs_nodes_.createField<double>(atlas::option::name("rsina"))};
-        auto rsina = atlas::array::make_view<double, 2>(m_rsina);
-
-        auto rzs = atlas::array::make_view<double, 2>(field);
-
-        std::size_t k_level = 0;
-
-        const auto rcoords_deg = atlas::array::make_view<double, 2>(mesh_.nodes().field("lonlat"));
+    auto make_pp(atlas::mesh::Nodes const &nodes) {
+        static const double zh0 = 2000;
+        static const double zrad = 3 * rpi / 4 * radius;
+        static const double zeta = rpi / 16 * radius;
+        static const double zlatc = 0;
+        static const double zlonc = 3 * rpi / 2;
+
+        auto lonlat = atlas::array::make_view<double, 2>(nodes.field("lonlat"));
+        // lonlatcr is in physical space and may differ from coords later
+        auto rlonlatcr = [&](int n, int i) { return lonlat(n, i) * deg2rad; };
+        auto init = [&](int n) {
+            double zlon = rlonlatcr(n, MXX);
+            double rcosa = std::cos(rlonlatcr(n, MYY));
+            double rsina = std::sin(rlonlatcr(n, MYY));
+            double zdist = std::sin(zlatc) * rsina + std::cos(zlatc) * rcosa * std::cos(zlon - zlonc);
+            zdist = radius * std::acos(zdist);
+            return zdist < zrad
+                       ? .5 * zh0 * (1 + std::cos(rpi * zdist / zrad)) * std::pow(std::cos(rpi * zdist / zeta), 2)
+                       : 0;
+        };
+        return storage_builder        //
+            .type<double>()           //
+            .dimensions(nodes.size()) //
+            .initializer(init)        //
+            .build();                 //
+    }
 
-        for (atlas::idx_t jnode = 0; jnode < mesh_.nodes().size(); ++jnode) {
-            for (std::size_t i = 0; i < 2; ++i) {
-                rcoords(jnode, k_level, i) = rcoords_deg(jnode, i) * deg2rad;
-                rlonlatcr(jnode, k_level, i) = rcoords(jnode, k_level, i); // lonlatcr is in physical space and may
-                                                                           // differ from coords later
-            }
-            rcosa(jnode, k_level) = cos(rlonlatcr(jnode, k_level, MYY));
-            rsina(jnode, k_level) = sin(rlonlatcr(jnode, k_level, MYY));
-        }
-        for (atlas::idx_t jnode = 0; jnode < mesh_.nodes().size(); ++jnode) {
-            double zlon = rlonlatcr(jnode, k_level, MXX);
-            //   double zlat = rlonlatcr(jnode, k_level, MYY);
-            double zdist = sin(zlatc) * rsina(jnode, k_level) + cos(zlatc) * rcosa(jnode, k_level) * cos(zlon - zlonc);
-            zdist = radius * acos(zdist);
-            rzs(jnode, k_level) = 0.0;
-            if (zdist < zrad) {
-                rzs(jnode, k_level) = rzs(jnode, k_level) + 0.5 * zh0 * (1.0 + cos(rpi * zdist / zrad)) *
-                                                                std::pow(cos(rpi * zdist / zeta), 2);
+    template <class T>
+    auto min_max(T const &field) {
+        double min = std::numeric_limits<double>::max();
+        double max = std::numeric_limits<double>::min();
+        double avg = 0;
+        auto view = field->const_host_view();
+        auto lengths = field->lengths();
+        for (int i = 0; i < (int)lengths[0]; ++i)
+            for (int k = 0; k < (int)lengths[1]; ++k) {
+                double x = view(i, k);
+                min = std::min(min, x);
+                max = std::max(max, x);
+                avg += x;
             }
-        }
+        return std::make_tuple(min, max, avg / (lengths[0] * lengths[1]));
     }
-};
-
-TEST(FVM, nabla) {
-
-    FVMDriver driver{"O32", 1};
-    // std::cout << "n_edges = " << driver.fs_edges()->size() << std::endl;
-    // std::cout << "n_nodes = " << driver.fs_nodes()->size() << std::endl;
 
-    // input
-    atlas::Field m_pp = driver.fs_nodes().createField<double>(atlas::option::name("pp"));
-
-    // output
-    atlas::Field m_pnabla_MXX = driver.fs_nodes().createField<double>(atlas::option::name("pnabla_MXX"));
-    atlas::Field m_pnabla_MYY = driver.fs_nodes().createField<double>(atlas::option::name("pnabla_MYY"));
-
-    // temporary
-    //  note: temporary fields are allocated in the stencil, but are still here if needed for debugging purposes
-    //atlas::Field m_zavgS_MXX = driver.fs_edges().createField<double>(atlas::option::name("zavgS_MXX"));
-    //atlas::Field m_zavgS_MYY = driver.fs_edges().createField<double>(atlas::option::name("zavgS_MYY"));
-
-    driver.fillInputData(m_pp);
-    //   print_min_max(m_pp);
-
-    //   atlas::output::Gmsh gmesh("mymesh.msh");
-    //   gmesh.write(driver.mesh());
-    //   gmesh.write(m_pp);
-
-    auto edge_sid = [](auto &&field) {
-        return gridtools::next::atlas_util::as_data_store<edge, dim::k>::with_type<double>{}(field);
-    };
-    auto node_sid = [](auto &&field) {
-        return gridtools::next::atlas_util::as_data_store<vertex, dim::k>::with_type<double>{}(field);
-    };
-
-    auto S_MXX_ds = edge_sid(driver.S_MXX());
-    auto S_MYY_ds = edge_sid(driver.S_MYY());
-    //auto m_zavgS_MXX_ds = edge_sid(m_zavgS_MXX);
-    //auto m_zavgS_MYY_ds = edge_sid(m_zavgS_MYY);
-    auto m_pp_ds = node_sid(m_pp);
-    auto m_pnabla_MXX_ds = node_sid(m_pnabla_MXX);
-    auto m_pnabla_MYY_ds = node_sid(m_pnabla_MYY);
-    auto vol_ds = node_sid(driver.vol());
-    auto sign_ds =
-        gridtools::next::atlas_util::as_data_store<vertex, dim::k, neighbor>::with_type<double>{}(driver.sign());
-
-    nabla(driver.mesh(),
-        S_MXX_ds,
-        S_MYY_ds,
-        m_pp_ds,
-        m_pnabla_MXX_ds,
-        m_pnabla_MYY_ds,
-        vol_ds,
-        sign_ds);
-
-    //   gmesh.write(m_pnabla_MXX);
-
-    /*auto [zavgS_x_min, zavgS_x_max, zavgS_x_avg] = min_max(m_zavgS_MXX_ds);
-    auto [zavgS_y_min, zavgS_y_max, zavgS_y_avg] = min_max(m_zavgS_MYY_ds);
-    EXPECT_DOUBLE_EQ(-199755464.25741270, zavgS_x_min);
-    EXPECT_DOUBLE_EQ(388241977.58389181, zavgS_x_max);
-    EXPECT_DOUBLE_EQ(-1000788897.3202186, zavgS_y_min);
-    EXPECT_DOUBLE_EQ(1000788897.3202186, zavgS_y_max);*/
-
-    auto [x_min, x_max, x_avg] = min_max(m_pnabla_MXX_ds);
-    auto [y_min, y_max, y_avg] = min_max(m_pnabla_MYY_ds);
-
-    ASSERT_DOUBLE_EQ(-3.5455427772566003E-003, x_min);
-    ASSERT_DOUBLE_EQ(3.5455427772565435E-003, x_max);
-    ASSERT_DOUBLE_EQ(-3.3540113705465301E-003, y_min);
-    ASSERT_DOUBLE_EQ(3.3540113705465301E-003, y_max);
-}
+    TEST(FVM, nabla) {
+        constexpr auto k = 1_c;
+
+        auto mesh = make_mesh();
+        auto &&edges = mesh.edges();
+        auto &&nodes = mesh.nodes();
+
+        // output
+        auto make_output = storage_builder.type<double>().dimensions(nodes.size(), k);
+        auto pnabla_MXX = make_output();
+        auto pnabla_MYY = make_output();
+
+        nabla({.vertex = nodes.size(), .edge = edges.size(), .cell = mesh.cells().size(), .k = k},
+            make_storage_producer(edges_per_node, nodes.edge_connectivity()),
+            make_storage_producer(2_c, edges.node_connectivity()))(make_S_MXX(edges),
+            make_S_MYY(edges),
+            make_pp(nodes),
+            pnabla_MXX,
+            pnabla_MYY,
+            make_vol(nodes),
+            make_sign(mesh));
+
+        auto [x_min, x_max, x_avg] = min_max(pnabla_MXX);
+        auto [y_min, y_max, y_avg] = min_max(pnabla_MYY);
+
+        EXPECT_DOUBLE_EQ(-3.5455427772566003E-003, x_min);
+        EXPECT_DOUBLE_EQ(3.5455427772565435E-003, x_max);
+        EXPECT_DOUBLE_EQ(-3.3540113705465301E-003, y_min);
+        EXPECT_DOUBLE_EQ(3.3540113705465301E-003, y_max);
+    }
+} // namespace
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
index 1f8fc16..f449b9b 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
@@ -230,15 +230,15 @@ void nabla(Mesh &&mesh,
     int k_size = 1; // TODO
     auto cuda_alloc =
         gridtools::sid::device::make_cached_allocator(&gridtools::cuda_util::cuda_malloc<char[]>); // TODO
-    auto zavgS_MXX = gridtools::next::make_simple_tmp_storage<edge, double>(
+    auto zavgS_MXX = gridtools::next::make_simple_tmp_storage<double>(
         (int)gridtools::next::connectivity::size(gridtools::next::mesh::connectivity<edge>(mesh)), k_size, cuda_alloc);
-    auto zavgS_MYY = gridtools::next::make_simple_tmp_storage<edge, double>(
+    auto zavgS_MYY = gridtools::next::make_simple_tmp_storage<double>(
         (int)gridtools::next::connectivity::size(gridtools::next::mesh::connectivity<edge>(mesh)), k_size, cuda_alloc);
     {
         auto e2v = gridtools::next::mesh::connectivity<std::tuple<edge, vertex>>(mesh);
         static_assert(gridtools::is_sid<decltype(gridtools::next::connectivity::neighbor_table(e2v))>{});
 
-        auto zavg = gridtools::next::make_simple_tmp_storage<edge, double>(
+        auto zavg = gridtools::next::make_simple_tmp_storage<double>(
             (int)gridtools::next::connectivity::size(gridtools::next::mesh::connectivity<edge>(mesh)), k_size, cuda_alloc);
 
         auto edge_fields = tu::make<gridtools::sid::composite::
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
index 5eba3d1..d3a996c 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
@@ -1,244 +1,123 @@
 #pragma once
 
-#include <gridtools/next/tmp_storage.hpp>
+#include <gridtools/common/defs.hpp>
+#include <gridtools/common/integral_constant.hpp>
 #include <gridtools/sid/allocator.hpp>
+#include <gridtools/sid/composite.hpp>
+#include <gridtools/sid/concept.hpp>
+#include <gridtools/sid/loop.hpp>
+#include <gridtools/sid/rename_dimensions.hpp>
+#include <gridtools/storage/cpu_ifirst.hpp>
 
-struct connectivity_tag;
-struct S_MXX_tag;
-struct S_MYY_tag;
-struct zavgS_MXX_tag;
-struct zavgS_MYY_tag;
-
-struct pnabla_MXX_tag;
-struct pnabla_MYY_tag;
-struct vol_tag;
-struct sign_tag;
-
-template <class Mesh,
-    class S_MXX_t,
-    class S_MYY_t,
-    class pp_t,
-    class pnabla_MXX_t,
-    class pnabla_MYY_t,
-    class vol_t,
-    class sign_t>
-void nabla(Mesh &&mesh,
-    S_MXX_t &&S_MXX,
-    S_MYY_t &&S_MYY,
-    pp_t &&pp,
-    pnabla_MXX_t &&pnabla_MXX,
-    pnabla_MYY_t &&pnabla_MYY,
-    vol_t &&vol,
-    sign_t &&sign) {
-    namespace tu = gridtools::tuple_util;
-
-    static_assert(gridtools::is_sid<S_MXX_t>{});
-    static_assert(gridtools::is_sid<S_MYY_t>{});
-    static_assert(gridtools::is_sid<pp_t>{});
-    static_assert(gridtools::is_sid<pnabla_MXX_t>{});
-    static_assert(gridtools::is_sid<pnabla_MYY_t>{});
-    static_assert(gridtools::is_sid<vol_t>{});
-    static_assert(gridtools::is_sid<sign_t>{});
-
-    // allocate temporary field storage
-    int k_size = 1; // TODO
-    auto alloc = gridtools::sid::make_cached_allocator(&std::make_unique<char[]>);
-    auto zavgS_MXX = gridtools::next::make_simple_tmp_storage<edge, double>(
-        (int)gridtools::next::connectivity::size(gridtools::next::mesh::connectivity<std::tuple<edge>>(mesh)), k_size, alloc);
-    auto zavgS_MYY = gridtools::next::make_simple_tmp_storage<edge, double>(
-        (int)gridtools::next::connectivity::size(gridtools::next::mesh::connectivity<std::tuple<edge>>(mesh)), k_size, alloc);
-
-    { // first edge loop (this is the fused version without temporary)
-        // ===
-        //   for (auto const &t : getEdges(LibTag{}, mesh)) {
-        //     double zavg =
-        //         (double)0.5 *
-        //         (m_sparse_dimension_idx = 0,
-        //          reduceVertexToEdge(mesh, t, (double)0.0,
-        //                             [&](auto &lhs, auto const &redIdx) {
-        //                               lhs += pp(deref(LibTag{}, redIdx), k);
-        //                               m_sparse_dimension_idx++;
-        //                               return lhs;
-        //                             }));
-        //     zavgS_MXX(deref(LibTag{}, t), k) =
-        //         S_MXX(deref(LibTag{}, t), k) * zavg;
-        //     zavgS_MYY(deref(LibTag{}, t), k) =
-        //         S_MYY(deref(LibTag{}, t), k) * zavg;
-        //   }
-        // ===
-        auto e2v = gridtools::next::mesh::connectivity<std::tuple<edge, vertex>>(mesh);
-        static_assert(gridtools::is_sid<decltype(gridtools::next::connectivity::neighbor_table(e2v))>{});
-
-        auto edge_fields = tu::make<gridtools::sid::composite::
-                keys<connectivity_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>::values>(
-            gridtools::next::connectivity::neighbor_table(e2v), S_MXX, S_MYY, zavgS_MXX, zavgS_MYY);
-        static_assert(gridtools::sid::concept_impl_::is_sid<decltype(edge_fields)>{});
-
-        auto ptrs = gridtools::sid::get_origin(edge_fields)();
-        auto strides = gridtools::sid::get_strides(edge_fields);
-        for (std::size_t i = 0; i < gridtools::next::connectivity::size(e2v); ++i) {
-            double acc = 0.;
-            { // reduce
-                for (int neigh = 0; neigh < static_cast<int>(gridtools::next::connectivity::max_neighbors(e2v));
-                     ++neigh) {
-                    // body
-                    auto absolute_neigh_index = *gridtools::at_key<connectivity_tag>(ptrs);
+#include <gridtools/next/domain.hpp>
+#include <gridtools/next/tmp_storage.hpp>
+#include <gridtools/next/unstructured.hpp>
 
-                    auto pp_ptr = gridtools::sid::get_origin(pp)();
-                    gridtools::sid::shift(
-                        pp_ptr, gridtools::at_key<vertex>(gridtools::sid::get_strides(pp)), absolute_neigh_index);
-                    acc += *pp_ptr;
-                    // body end
+namespace nabla_impl_ {
 
-                    gridtools::sid::shift(ptrs, gridtools::at_key<neighbor>(strides), 1);
-                }
-                gridtools::sid::shift(ptrs,
-                    gridtools::at_key<neighbor>(strides),
-                    -gridtools::next::connectivity::max_neighbors(e2v)); // or reset ptr to origin and shift ?
-            }
-            double zavg = 0.5 * acc;
-            *gridtools::at_key<zavgS_MXX_tag>(ptrs) = *gridtools::at_key<S_MXX_tag>(ptrs) * zavg;
-            *gridtools::at_key<zavgS_MYY_tag>(ptrs) = *gridtools::at_key<S_MYY_tag>(ptrs) * zavg;
+    using namespace gridtools;
+    using namespace next;
 
-            gridtools::sid::shift(ptrs, gridtools::at_key<edge>(strides), 1);
-        }
+    template <class Dim, class Sid>
+    auto max_neighbors(Sid const &sid) {
+        static_assert(has_key<sid::upper_bounds_type<Sid>, Dim>());
+        return at_key<Dim>(sid::get_upper_bounds(sid));
     }
-    {
-        // vertex loop
-        // for (auto const &t : getVertices(LibTag{}, mesh)) {
-        //     pnabla_MXX(deref(LibTag{}, t), k) =
-        //         (m_sparse_dimension_idx = 0,
-        //          reduceEdgeToVertex(
-        //              mesh, t, (double)0.0, [&](auto &lhs, auto const &redIdx) {
-        //                lhs += zavgS_MXX(deref(LibTag{}, redIdx), k) *
-        //                       sign(deref(LibTag{}, t), m_sparse_dimension_idx,
-        //                       k);
-        //                m_sparse_dimension_idx++;
-        //                return lhs;
-        //              }));
-        //   }
-        //   for (auto const &t : getVertices(LibTag{}, mesh)) {
-        //     pnabla_MYY(deref(LibTag{}, t), k) =
-        //         (m_sparse_dimension_idx = 0,
-        //          reduceEdgeToVertex(
-        //              mesh, t, (double)0.0, [&](auto &lhs, auto const &redIdx) {
-        //                lhs += zavgS_MYY(deref(LibTag{}, redIdx), k) *
-        //                       sign(deref(LibTag{}, t), m_sparse_dimension_idx,
-        //                       k);
-        //                m_sparse_dimension_idx++;
-        //                return lhs;
-        //              }));
-        //   }
-        auto v2e = gridtools::next::mesh::connectivity<std::tuple<vertex, edge>>(mesh);
-        static_assert(gridtools::is_sid<decltype(gridtools::next::connectivity::neighbor_table(v2e))>{});
-
-        auto vertex_fields = tu::make<gridtools::sid::composite::
-                keys<connectivity_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag, vol_tag>::values>(
-            gridtools::next::connectivity::neighbor_table(v2e), pnabla_MXX, pnabla_MYY, sign, vol);
-        static_assert(gridtools::sid::concept_impl_::is_sid<decltype(vertex_fields)>{});
-
-        auto ptrs = gridtools::sid::get_origin(vertex_fields)();
-        auto strides = gridtools::sid::get_strides(vertex_fields);
-
-        for (std::size_t i = 0; i < gridtools::next::connectivity::size(v2e); ++i) {
-            *gridtools::at_key<pnabla_MXX_tag>(ptrs) = 0.;
-            { // reduce
-                for (int neigh = 0; neigh < static_cast<int>(gridtools::next::connectivity::max_neighbors(v2e));
-                     ++neigh) {
-                    // body
-                    auto absolute_neigh_index = *gridtools::at_key<connectivity_tag>(ptrs);
-                    if (absolute_neigh_index != gridtools::next::connectivity::skip_value(v2e)) {
 
-                        auto zavgS_MXX_ptr = gridtools::sid::get_origin(zavgS_MXX)();
-                        gridtools::sid::shift(zavgS_MXX_ptr,
-                            gridtools::at_key<edge>(gridtools::sid::get_strides(zavgS_MXX)),
-                            absolute_neigh_index);
-                        auto zavgS_MXX_value = *zavgS_MXX_ptr;
-
-                        auto sign_ptr = gridtools::at_key<sign_tag>(ptrs); // if the sparse dimension is tagged with
-                                                                           // neighbor, the ptr is already correct
-                        auto sign_value = *sign_ptr;
-
-                        *gridtools::at_key<pnabla_MXX_tag>(ptrs) += zavgS_MXX_value * sign_value;
-                        // body end
-                    }
-                    gridtools::sid::shift(ptrs, gridtools::at_key<neighbor>(strides), 1);
-                }
-                gridtools::sid::shift(ptrs,
-                    gridtools::at_key<neighbor>(strides),
-                    -gridtools::next::connectivity::max_neighbors(v2e)); // or reset ptr to origin and shift ?
+    struct v2e_dim;
+    struct e2v_dim;
+    struct v2e_tag;
+    struct e2v_tag;
+    struct S_MXX_tag;
+    struct S_MYY_tag;
+    struct zavgS_MXX_tag;
+    struct zavgS_MYY_tag;
+    struct pnabla_MXX_tag;
+    struct pnabla_MYY_tag;
+    struct vol_tag;
+    struct sign_tag;
+
+    template <class V2E, class E2V>
+    auto nabla(domain d, V2E &&v2e, E2V &&e2v) {
+        static_assert(is_sid<decltype(std::forward<V2E>(v2e)(storage::cpu_ifirst()))>());
+        static_assert(is_sid<decltype(std::forward<E2V>(e2v)(storage::cpu_ifirst()))>());
+        return [d = std::move(d),
+                   v2e = sid::rename_dimensions<integral_constant<int_t, 1>, v2e_dim>(
+                       std::forward<V2E>(v2e)(storage::cpu_ifirst())),
+                   e2v = sid::rename_dimensions<integral_constant<int_t, 1>, e2v_dim>(
+                       std::forward<E2V>(e2v)(storage::cpu_ifirst()))](auto &&S_MXX,
+                   auto &&S_MYY,
+                   auto &&pp,
+                   auto &&pnabla_MXX,
+                   auto &&pnabla_MYY,
+                   auto &&vol,
+                   auto &&sign) {
+            static_assert(is_sid<decltype(S_MXX)>());
+            static_assert(is_sid<decltype(S_MYY)>());
+            static_assert(is_sid<decltype(pp)>());
+            static_assert(is_sid<decltype(pnabla_MXX)>());
+            static_assert(is_sid<decltype(pnabla_MYY)>());
+            static_assert(is_sid<decltype(vol)>());
+            static_assert(is_sid<decltype(sign)>());
+
+            // allocate temporary field storage
+            auto alloc = sid::make_cached_allocator(&std::make_unique<char[]>);
+            auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
+            auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
+
+            {
+                auto fields = tuple_util::make<
+                    sid::composite::keys<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>::values>(
+                    e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY);
+                sid::make_loop<dim::h>(d.edge)(
+                    [&, pp = sid::get_origin(pp)(), pp_stride = at_key<dim::h>(sid::get_strides(pp))](
+                        auto &ptr, auto const &strides) {
+                        double acc = 0;
+                        sid::make_loop<e2v_dim>(max_neighbors<e2v_dim>(e2v))([&](auto const &ptr, auto &&) {
+                            acc += *sid::shifted(pp, pp_stride, *at_key<e2v_tag>(ptr));
+                        })(ptr, strides);
+                        acc *= 0.5;
+                        *at_key<zavgS_MXX_tag>(ptr) = *at_key<S_MXX_tag>(ptr) * acc;
+                        *at_key<zavgS_MYY_tag>(ptr) = *at_key<S_MYY_tag>(ptr) * acc;
+                    })(sid::get_origin(fields)(), sid::get_strides(fields));
             }
-            *gridtools::at_key<pnabla_MYY_tag>(ptrs) = 0.;
-            { // reduce
-                for (int neigh = 0; neigh < static_cast<int>(gridtools::next::connectivity::max_neighbors(v2e));
-                     ++neigh) {
-                    // body
-                    auto absolute_neigh_index = *gridtools::at_key<connectivity_tag>(ptrs);
-                    if (absolute_neigh_index != gridtools::next::connectivity::skip_value(v2e)) {
-
-                        auto zavgS_MYY_ptr = gridtools::sid::get_origin(zavgS_MYY)();
-                        gridtools::sid::shift(zavgS_MYY_ptr,
-                            gridtools::at_key<edge>(gridtools::sid::get_strides(zavgS_MYY)),
-                            absolute_neigh_index);
-                        auto zavgS_YY_value = *zavgS_MYY_ptr;
-
-                        // if the sparse dimension is tagged with `neighbor`, the ptr is
-                        // already correct
-                        auto sign_ptr = gridtools::at_key<sign_tag>(ptrs);
-                        auto sign_value = *sign_ptr;
-
-                        *gridtools::at_key<pnabla_MYY_tag>(ptrs) += zavgS_YY_value * sign_value;
-                        // body end
-                    }
-                    gridtools::sid::shift(ptrs, gridtools::at_key<neighbor>(strides), 1);
-                }
-                // the following or reset ptr to origin and shift ?
-                gridtools::sid::shift(
-                    ptrs, gridtools::at_key<neighbor>(strides), -gridtools::next::connectivity::max_neighbors(v2e));
+            {
+                auto fields =
+                    tuple_util::make<sid::composite::keys<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag>::values>(
+                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::n, v2e_dim>(sign));
+                sid::make_loop<dim::h>(d.vertex)([&,
+                                                     zavgS_MXX = sid::get_origin(zavgS_MXX)(),
+                                                     zavgS_MXX_stride = at_key<dim::h>(sid::get_strides(zavgS_MXX)),
+                                                     zavgS_MYY = sid::get_origin(zavgS_MYY)(),
+                                                     zavgS_MYY_stride = at_key<dim::h>(sid::get_strides(zavgS_MYY))](
+                                                     auto &ptr, auto const &strides) {
+                    double acc = 0;
+                    sid::make_loop<v2e_dim>(max_neighbors<v2e_dim>(v2e))([&](auto const &ptr, auto &&) {
+                        auto i = *at_key<v2e_tag>(ptr);
+                        if (i < 0)
+                            return;
+                        acc += *sid::shifted(zavgS_MXX, zavgS_MXX_stride, i) * *at_key<sign_tag>(ptr);
+                    })(ptr, strides);
+                    *at_key<pnabla_MXX_tag>(ptr) = acc;
+                    acc = 0;
+                    sid::make_loop<v2e_dim>(max_neighbors<v2e_dim>(v2e))([&](auto const &ptr, auto &&) {
+                        auto i = *at_key<v2e_tag>(ptr);
+                        if (i < 0)
+                            return;
+                        acc += *sid::shifted(zavgS_MYY, zavgS_MYY_stride, i) * *at_key<sign_tag>(ptr);
+                    })(ptr, strides);
+                    *at_key<pnabla_MYY_tag>(ptr) = acc;
+                })(sid::get_origin(fields)(), sid::get_strides(fields));
             }
-            gridtools::sid::shift(ptrs, gridtools::at_key<vertex>(strides), 1);
-        }
-    }
-
-    // ===
-    //   do jedge = 1,dstruct%nb_pole_edges
-    //     iedge = dstruct%pole_edges(jedge)
-    //     ip2   = dstruct%edges(2,iedge)
-    //     ! correct for wrong Y-derivatives in previous loop
-    //     pnabla(MYY,ip2) = pnabla(MYY,ip2)+2.0_wp*zavgS(MYY,iedge)
-    //   end do
-    // ===
-    //   {
-    //     auto pe2v = gridtools::next::mesh::connectivity<
-    //         std::tuple<atlas::pole_edge, vertex>>(mesh);
-    //     for (int i = 0; i < gridtools::next::connectivity::size(pe2v);
-    //          ++i) {
-    //     }
-    //   }
-
-    {
-        // vertex loop
-        // for (auto const &t : getVertices(LibTag{}, mesh)) {
-        //     pnabla_MXX(deref(LibTag{}, t), k) =
-        //         pnabla_MXX(deref(LibTag{}, t), k) / vol(deref(LibTag{}, t), k);
-        //     pnabla_MYY(deref(LibTag{}, t), k) =
-        //         pnabla_MYY(deref(LibTag{}, t), k) / vol(deref(LibTag{}, t), k);
-        //   }
-        auto v2e = gridtools::next::mesh::connectivity<std::tuple<vertex, edge>>(mesh);
-        static_assert(gridtools::is_sid<decltype(gridtools::next::connectivity::neighbor_table(v2e))>{});
-
-        auto vertex_fields = tu::make<gridtools::sid::composite::
-                keys<connectivity_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag, vol_tag>::values>(
-            gridtools::next::connectivity::neighbor_table(v2e), pnabla_MXX, pnabla_MYY, sign, vol);
-        static_assert(gridtools::sid::concept_impl_::is_sid<decltype(vertex_fields)>{});
-
-        auto ptrs = gridtools::sid::get_origin(vertex_fields)();
-        auto strides = gridtools::sid::get_strides(vertex_fields);
-
-        for (std::size_t i = 0; i < gridtools::next::connectivity::size(v2e); ++i) {
-            *gridtools::at_key<pnabla_MXX_tag>(ptrs) /= *gridtools::at_key<vol_tag>(ptrs);
-            *gridtools::at_key<pnabla_MYY_tag>(ptrs) /= *gridtools::at_key<vol_tag>(ptrs);
-            gridtools::sid::shift(ptrs, gridtools::at_key<vertex>(strides), 1);
-        }
+            {
+                auto fields = tuple_util::make<sid::composite::keys<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>::values>(
+                    pnabla_MXX, pnabla_MYY, vol);
+                sid::make_loop<dim::h>(d.vertex)([](auto &ptr, auto &&stride) {
+                    *at_key<pnabla_MXX_tag>(ptr) /= *at_key<vol_tag>(ptr);
+                    *at_key<pnabla_MYY_tag>(ptr) /= *at_key<vol_tag>(ptr);
+                })(sid::get_origin(fields)(), sid::get_strides(fields));
+            }
+        };
     }
-}
+} // namespace nabla_impl_
+using nabla_impl_::nabla;
diff --git a/cpputil/unstructured/tests/unit_tests/next/CMakeLists.txt b/cpputil/unstructured/tests/unit_tests/next/CMakeLists.txt
index 1e6722f..582058a 100644
--- a/cpputil/unstructured/tests/unit_tests/next/CMakeLists.txt
+++ b/cpputil/unstructured/tests/unit_tests/next/CMakeLists.txt
@@ -28,8 +28,4 @@ function(add_gtnext_atlas_test)
     add_gtnext_test(NAME ${ARG_NAME} SOURCES ${ARG_SOURCES} LIBRARIES atlas eckit)
 endfunction()
 
-add_subdirectory(test_helper)
-
 add_gtnext_atlas_test(NAME test_atlas_array_view_adapter)
-add_gtnext_atlas_test(NAME test_atlas_field_util SOURCES test_atlas_field_util.cc)
-add_gtnext_atlas_test(NAME test_mesh SOURCES test_mesh.cc)
diff --git a/cpputil/unstructured/tests/unit_tests/next/test_atlas_field_util.cc b/cpputil/unstructured/tests/unit_tests/next/test_atlas_field_util.cc
deleted file mode 100644
index 1bcd8fe..0000000
--- a/cpputil/unstructured/tests/unit_tests/next/test_atlas_field_util.cc
+++ /dev/null
@@ -1,62 +0,0 @@
-#include <gridtools/next/atlas_field_util.hpp>
-
-#include "util/atlas_util.hpp"
-#include <array_fwd.h>
-#include <gridtools/sid/concept.hpp>
-
-#include <gtest/gtest.h>
-
-namespace {
-    TEST(atlas_field_as_sid, edge_k_field) {
-        namespace tu = gridtools::tuple_util;
-
-        auto mesh = atlas_util::make_mesh();
-
-        auto k_size = 10;
-        auto edge_field = atlas_util::make_edge_field<double>(mesh, k_size);
-        //   auto view = atlas::array::make_view<double, 3>(edge_field);
-
-        auto testee = gridtools::next::atlas_util::as<edge, dim::k>::with_type<double>{}(edge_field);
-        using testee_t = decltype(testee);
-
-        static_assert(gridtools::sid::concept_impl_::is_sid<testee_t>{});
-
-        using strides_t = gridtools::sid::strides_type<testee_t>;
-        static_assert(tu::size<strides_t>() == 2, "");
-        static_assert(gridtools::has_key<strides_t, edge>{});
-        static_assert(gridtools::has_key<strides_t, dim::k>{});
-
-        [[maybe_unused]] auto strides = gridtools::sid::get_strides(testee);
-    }
-
-    TEST(atlas_field_as_sid, invalid_location_type) {
-        auto mesh = atlas_util::make_mesh();
-
-        auto k_size = 10;
-        auto edge_field = atlas_util::make_edge_field<double>(mesh, k_size);
-
-        ASSERT_ANY_THROW((gridtools::next::atlas_util::as<cell, dim::k>::with_type<double>{}(edge_field)));
-    }
-
-    TEST(atlas_field_as_data_store, edge_k_field) {
-        namespace tu = gridtools::tuple_util;
-
-        auto mesh = atlas_util::make_mesh();
-
-        auto k_size = 10;
-        auto edge_field = atlas_util::make_edge_field<double>(mesh, k_size);
-
-        auto testee = gridtools::next::atlas_util::as_data_store<edge, dim::k>::with_type<double>{}(edge_field);
-        using testee_t = decltype(testee);
-
-        static_assert(gridtools::sid::concept_impl_::is_sid<testee_t>{});
-
-        using strides_t = gridtools::sid::strides_type<testee_t>;
-        static_assert(tu::size<strides_t>() == 2, "");
-        static_assert(gridtools::has_key<strides_t, edge>{});
-        static_assert(gridtools::has_key<strides_t, dim::k>{});
-
-        [[maybe_unused]] auto strides = gridtools::sid::get_strides(testee);
-    }
-
-} // namespace
diff --git a/cpputil/unstructured/tests/unit_tests/next/test_helper/CMakeLists.txt b/cpputil/unstructured/tests/unit_tests/next/test_helper/CMakeLists.txt
deleted file mode 100644
index 9cf2a0e..0000000
--- a/cpputil/unstructured/tests/unit_tests/next/test_helper/CMakeLists.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-add_gtnext_test(NAME test_simple_mesh)
-add_gtnext_test(NAME test_field_builder)
diff --git a/cpputil/unstructured/tests/unit_tests/next/test_helper/test_field_builder.cc b/cpputil/unstructured/tests/unit_tests/next/test_helper/test_field_builder.cc
deleted file mode 100644
index ff8526d..0000000
--- a/cpputil/unstructured/tests/unit_tests/next/test_helper/test_field_builder.cc
+++ /dev/null
@@ -1,105 +0,0 @@
-#include <array>
-#include <gridtools/next/mesh.hpp>
-#include <gridtools/next/test_helper/field_builder.hpp>
-#include <gridtools/next/test_helper/simple_mesh.hpp>
-#include <gridtools/sid/composite.hpp>
-#include <gridtools/sid/concept.hpp>
-#include <gridtools/sid/loop.hpp>
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <utility>
-
-namespace {
-
-    TEST(field_builder, cell_field) {
-        gridtools::next::test_helper::simple_mesh mesh;
-
-        auto field = gridtools::next::test_helper::make_field<double, cell>(mesh);
-
-        static_assert(std::is_same<double *, gridtools::sid::ptr_type<decltype(field)>>{});
-        auto c2c = gridtools::next::mesh::connectivity<std::tuple<cell, cell>>(mesh);
-        ASSERT_EQ(
-            gridtools::next::connectivity::size(c2c), gridtools::at_key<cell>(gridtools::sid::get_upper_bounds(field)));
-    }
-
-    // TODO consider moving to a different file
-    // TODO we need to understand where we should use SID and where data_store concepts
-    using namespace gridtools::sid;
-    using namespace gridtools::next;
-    using gridtools::at_key;
-    namespace tu = gridtools::tuple_util;
-
-    struct in_tag;
-    struct out_tag;
-    struct connectivity_tag;
-
-    template <class DimTag, class Sid, class Fun>
-    void make_full_loop(Sid &&sid, Fun &&fun) {
-        auto ptr = get_origin(std::forward<Sid>(sid))();
-        auto strides = get_strides(std::forward<Sid>(sid));
-
-        make_loop<DimTag>(at_key<DimTag>(get_upper_bounds(std::forward<Sid>(sid))))(std::forward<Fun>(fun))(
-            ptr, strides);
-    }
-
-    TEST(simple_mesh_regression, cell2cell_reduction) {
-        test_helper::simple_mesh mesh;
-        auto c2c = mesh::connectivity<std::tuple<cell, cell>>(mesh);
-
-        auto in = test_helper::make_field<double, cell>(mesh);
-        auto out = gridtools::next::test_helper::make_field<double, cell>(mesh);
-
-        make_full_loop<cell>(in, [](auto ptr, auto const &) { *ptr = 1; });
-
-        auto primary_fields =
-            tu::make<composite::keys<out_tag, connectivity_tag>::values>(out, connectivity::neighbor_table(c2c));
-        {
-            auto ptrs = get_origin(primary_fields)();
-            auto strides = get_strides(primary_fields);
-
-            // variant 1:
-            // for (std::size_t c = 0; c < at_key<cell>(get_upper_bounds(out)); ++c) {
-            //     *at_key<out_tag>(ptrs) = 0;
-            //     for (std::size_t i = 0; i < connectivity::max_neighbors(c2c); ++i) {
-            //         auto in_ptr = get_origin(in)();
-            //         auto in_strides = get_strides(in);
-            //         shift(in_ptr, at_key<cell>(in_strides), *at_key<connectivity_tag>(ptrs));
-            //         *at_key<out_tag>(ptrs) += *in_ptr;
-            //         shift(ptrs, gridtools::at_key<neighbor>(strides), 1);
-            //     }
-            //     shift(ptrs, at_key<neighbor>(strides), -connectivity::max_neighbors(c2c));
-            //     shift(ptrs, at_key<cell>(strides), 1);
-            // }
-
-            // variant 2:
-            make_loop<cell>(gridtools::at_key<cell>(get_upper_bounds(out)))(
-                [&c2c, &in](auto ptrs, auto const &strides) {
-                    *at_key<out_tag>(ptrs) = 0;
-                    for (std::size_t i = 0; i < connectivity::max_neighbors(c2c); ++i) {
-                        auto in_ptr = get_origin(in)();
-                        auto in_strides = get_strides(in);
-                        shift(in_ptr, at_key<cell>(in_strides), *at_key<connectivity_tag>(ptrs));
-                        *at_key<out_tag>(ptrs) += *in_ptr;
-                        shift(ptrs, gridtools::at_key<neighbor>(strides), 1);
-                    }
-                })(ptrs, strides);
-        }
-
-        // variant 3:
-        // TODO requires changes in the make_full_loop
-        // auto loop_body = [&c2c, &in](auto ptrs, auto const &strides) {
-        //     *at_key<out_tag>(ptrs) = 0;
-        //     for (std::size_t i = 0; i < connectivity::max_neighbors(c2c); ++i) {
-        //         auto in_ptr = get_origin(in)();
-        //         auto in_strides = get_strides(in);
-        //         shift(in_ptr, at_key<cell>(in_strides), *at_key<connectivity_tag>(ptrs));
-        //         *at_key<out_tag>(ptrs) += *in_ptr;
-        //         shift(ptrs, gridtools::at_key<neighbor>(strides), 1);
-        //     }
-        // };
-        // make_full_loop<cell>(primary_fields, loop_body);
-
-        make_full_loop<cell>(out, [](auto ptr, auto const &) { ASSERT_EQ(4, *ptr); });
-    }
-} // namespace
diff --git a/cpputil/unstructured/tests/unit_tests/next/test_helper/test_simple_mesh.cc b/cpputil/unstructured/tests/unit_tests/next/test_helper/test_simple_mesh.cc
deleted file mode 100644
index 538d752..0000000
--- a/cpputil/unstructured/tests/unit_tests/next/test_helper/test_simple_mesh.cc
+++ /dev/null
@@ -1,54 +0,0 @@
-#include <array>
-#include <gridtools/meta/at.hpp>
-#include <gridtools/next/mesh.hpp>
-#include <gridtools/next/test_helper/simple_mesh.hpp>
-#include <gridtools/sid/concept.hpp>
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-template <typename NeighborChain, typename Mesh>
-auto get_neighbors(Mesh const &mesh, int i) {
-    namespace gs = gridtools::sid;
-    using namespace gridtools::next;
-
-    auto conn = mesh::connectivity<NeighborChain>(mesh);
-
-    auto tbl = gridtools::next::connectivity::neighbor_table(conn);
-    auto ptr = gs::get_origin(tbl)();
-    auto strides = gs::get_strides(tbl);
-    gs::shift(ptr, gridtools::at_key<gridtools::meta::at_c<NeighborChain, 0>>(strides), i);
-    std::array<int, decltype(gridtools::next::connectivity::max_neighbors(conn))::value> result;
-    for (std::size_t i = 0; i < result.size(); ++i) {
-        result[i] = *ptr;
-        gs::shift(ptr, gridtools::at_key<neighbor>(strides), 1);
-    }
-    return result;
-}
-
-TEST(simple_mesh, cell2cell) {
-    gridtools::next::test_helper::simple_mesh mesh;
-
-    auto c2c = gridtools::next::mesh::connectivity<std::tuple<cell, cell>>(mesh);
-
-    ASSERT_EQ(9, gridtools::next::connectivity::size(c2c));
-    ASSERT_EQ(4, gridtools::next::connectivity::max_neighbors(c2c));
-    ASSERT_EQ(-1, gridtools::next::connectivity::skip_value(c2c));
-
-    ASSERT_THAT((get_neighbors<std::tuple<cell, cell>>(mesh, 0)), testing::UnorderedElementsAre(1, 3, 2, 6));
-    ASSERT_THAT((get_neighbors<std::tuple<cell, cell>>(mesh, 1)), testing::UnorderedElementsAre(0, 7, 2, 4));
-    // etc
-}
-
-TEST(simple_mesh, edge2vertex) {
-    gridtools::next::test_helper::simple_mesh mesh;
-
-    auto e2v = gridtools::next::mesh::connectivity<std::tuple<edge, vertex>>(mesh);
-
-    ASSERT_EQ(18, gridtools::next::connectivity::size(e2v));
-    ASSERT_EQ(2, gridtools::next::connectivity::max_neighbors(e2v));
-    ASSERT_EQ(-1, gridtools::next::connectivity::skip_value(e2v));
-
-    ASSERT_THAT((get_neighbors<std::tuple<edge, vertex>>(mesh, 0)), testing::UnorderedElementsAre(0, 1));
-    // etc
-}
diff --git a/cpputil/unstructured/tests/unit_tests/next/test_mesh.cc b/cpputil/unstructured/tests/unit_tests/next/test_mesh.cc
deleted file mode 100644
index 1777f0d..0000000
--- a/cpputil/unstructured/tests/unit_tests/next/test_mesh.cc
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "gridtools/common/integral_constant.hpp"
-#include <gridtools/next/mesh.hpp>
-
-#include <gtest/gtest.h>
-#include <type_traits>
-
-// TODO test concept
-
-using namespace gridtools::next;
-
-namespace {
-    namespace fake {
-        struct fake_connectivity {
-            inline friend std::size_t connectivity_size(fake_connectivity const &) { return 1; }
-            inline friend gridtools::integral_constant<int, 2> connectivity_max_neighbors(fake_connectivity const &) {
-                return {};
-            }
-            inline friend gridtools::integral_constant<int, -1> connectivity_skip_value(fake_connectivity const &) {
-                return {};
-            }
-        };
-    } // namespace fake
-
-    TEST(connectivity, make_info) {
-        auto info = connectivity::extract_info(fake::fake_connectivity{});
-        ASSERT_EQ(1, info.size);
-        static_assert(std::is_same_v<gridtools::integral_constant<int, 2>, decltype(info.max_neighbors)>);
-        static_assert(std::is_same_v<gridtools::integral_constant<int, -1>, decltype(info.skip_value)>);
-    }
-} // namespace

From 14328d3e721c967d4c93ce0471d45e9acc506845 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Fri, 16 Oct 2020 18:06:13 +0000
Subject: [PATCH 02/24] nabla_cuda done

---
 cpputil/unstructured/CMakeLists.txt           |   2 +-
 .../include/gridtools/next/cuda_util.hpp      |   8 +-
 .../tests/regression/fvm_nabla/nabla_cuda.hpp | 441 +++++++-----------
 .../regression/fvm_nabla/nabla_naive.hpp      |   1 +
 4 files changed, 166 insertions(+), 286 deletions(-)

diff --git a/cpputil/unstructured/CMakeLists.txt b/cpputil/unstructured/CMakeLists.txt
index baea663..f95473b 100644
--- a/cpputil/unstructured/CMakeLists.txt
+++ b/cpputil/unstructured/CMakeLists.txt
@@ -3,7 +3,7 @@ project(unstructured_interface LANGUAGES CXX)
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake/private")
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 17)
 
 add_compile_options(-Wall)
 #add_compile_options(-Wall -Wextra -pedantic -Wno-sign-compare)
diff --git a/cpputil/unstructured/include/gridtools/next/cuda_util.hpp b/cpputil/unstructured/include/gridtools/next/cuda_util.hpp
index 3ce9679..ddafba4 100644
--- a/cpputil/unstructured/include/gridtools/next/cuda_util.hpp
+++ b/cpputil/unstructured/include/gridtools/next/cuda_util.hpp
@@ -2,10 +2,10 @@
 
 #include <tuple>
 
-namespace gridtools::next::cuda_util {
-    inline std::tuple<int, int> cuda_setup(int N) {
+namespace gridtools::next {
+    inline auto cuda_setup(int N) {
         int threads_per_block = 32;
         int blocks = (N + threads_per_block - 1) / threads_per_block;
-        return {blocks, threads_per_block};
+        return std::make_tuple(blocks, threads_per_block);
     }
-} // namespace gridtools::next::cuda_util
+} // namespace gridtools::next
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
index f449b9b..983bac4 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
@@ -4,297 +4,176 @@
 #error "Tried to compile CUDA code with a regular C++ compiler."
 #endif
 
-#include <gridtools/next/mesh.hpp>
-#include <gridtools/next/tmp_storage.hpp>
+#include <gridtools/common/cuda_util.hpp>
+#include <gridtools/common/defs.hpp>
+#include <gridtools/common/hymap.hpp>
+#include <gridtools/common/integral_constant.hpp>
 #include <gridtools/sid/allocator.hpp>
+#include <gridtools/sid/composite.hpp>
+#include <gridtools/sid/concept.hpp>
+#include <gridtools/sid/loop.hpp>
+#include <gridtools/sid/rename_dimensions.hpp>
+#include <gridtools/storage/gpu.hpp>
+
+#include <gridtools/next/cuda_util.hpp>
+#include <gridtools/next/domain.hpp>
+#include <gridtools/next/tmp_storage.hpp>
+#include <gridtools/next/unstructured.hpp>
 
-struct connectivity_tag;
-struct S_MXX_tag;
-struct S_MYY_tag;
-struct zavgS_MXX_tag;
-struct zavgS_MYY_tag;
-struct zavg_tag;
-
-struct pnabla_MXX_tag;
-struct pnabla_MYY_tag;
-struct vol_tag;
-struct sign_tag;
-struct pp_tag;
-
-template <class ConnInfoE2V, class EdgePtrs, class EdgeStrides, class VertexNeighborPtrs, class VertexNeighborStrides>
-__global__ void nabla_edge_1(ConnInfoE2V e2v,
-    EdgePtrs edge_ptr_holders,
-    EdgeStrides edge_strides,
-    VertexNeighborPtrs vertex_neighbor_ptr_holders,
-    VertexNeighborStrides vertex_neighbor_strides) {
-    { // first edge loop (this is the fused version without temporary)
-        // ===
-        //   for (auto const &t : getEdges(LibTag{}, mesh)) {
-        //     double zavg =
-        //         (double)0.5 *
-        //         (m_sparse_dimension_idx = 0,
-        //          reduceVertexToEdge(mesh, t, (double)0.0,
-        //                             [&](auto &lhs, auto const &redIdx) {
-        //                               lhs += pp(deref(LibTag{}, redIdx), k);
-        //                               m_sparse_dimension_idx++;
-        //                               return lhs;
-        //                             }));
-        //     zavgS_MXX(deref(LibTag{}, t), k) =
-        //         S_MXX(deref(LibTag{}, t), k) * zavg;
-        //     zavgS_MYY(deref(LibTag{}, t), k) =
-        //         S_MYY(deref(LibTag{}, t), k) * zavg;
-        //   }
-        // ===
-        auto idx = blockIdx.x * blockDim.x + threadIdx.x;
-        if (idx >= e2v.size)
-            return;
-
-        auto edge_ptrs = edge_ptr_holders();
-
-        gridtools::sid::shift(edge_ptrs, gridtools::device::at_key<edge>(edge_strides), idx);
-
-        double acc = 0.;
-        { // reduce
-            for (int neigh = 0; neigh < e2v.max_neighbors; ++neigh) {
-                // body
-                auto absolute_neigh_index = *gridtools::device::at_key<connectivity_tag>(edge_ptrs);
-                auto vertex_ptrs = vertex_neighbor_ptr_holders();
-                gridtools::sid::shift(
-                    vertex_ptrs, gridtools::device::at_key<vertex>(vertex_neighbor_strides), absolute_neigh_index);
-
-                acc += *gridtools::device::at_key<pp_tag>(vertex_ptrs);
-                // body end
+namespace nabla_impl_ {
+    using namespace gridtools;
+    using namespace next;
 
-                gridtools::sid::shift(edge_ptrs, gridtools::device::at_key<neighbor>(edge_strides), 1);
-            }
-            gridtools::sid::shift(edge_ptrs, gridtools::device::at_key<neighbor>(edge_strides), -e2v.max_neighbors);
-        }
-        *gridtools::device::at_key<zavg_tag>(edge_ptrs) =
-            0.5 * acc; // via temporary for non-optimized parallel model
-        *gridtools::device::at_key<zavgS_MXX_tag>(edge_ptrs) =
-            *gridtools::device::at_key<S_MXX_tag>(edge_ptrs) * *gridtools::device::at_key<zavg_tag>(edge_ptrs);
-        *gridtools::device::at_key<zavgS_MYY_tag>(edge_ptrs) =
-            *gridtools::device::at_key<S_MYY_tag>(edge_ptrs) * *gridtools::device::at_key<zavg_tag>(edge_ptrs);
+    template <class Dim, class Sid>
+    auto max_neighbors(Sid const &sid) {
+        static_assert(has_key<sid::upper_bounds_type<Sid>, Dim>());
+        return at_key<Dim>(sid::get_upper_bounds(sid));
     }
-}
 
-template <class ConnInfoV2E,
-    class VertexOrigins,
-    class VertexStrides,
-    class EdgeNeighborOrigins,
-    class EdgeNeighborStrides>
-__global__ void nabla_vertex_2(ConnInfoV2E v2e,
-    VertexOrigins vertex_origins,
-    VertexStrides vertex_strides,
-    EdgeNeighborOrigins edge_neighbor_origins,
-    EdgeNeighborStrides edge_neighbor_strides) {
-    // vertex loop
-    // for (auto const &t : getVertices(LibTag{}, mesh)) {
-    //     pnabla_MXX(deref(LibTag{}, t), k) =
-    //         (m_sparse_dimension_idx = 0,
-    //          reduceEdgeToVertex(
-    //              mesh, t, (double)0.0, [&](auto &lhs, auto const &redIdx) {
-    //                lhs += zavgS_MXX(deref(LibTag{}, redIdx), k) *
-    //                       sign(deref(LibTag{}, t), m_sparse_dimension_idx,
-    //                       k);
-    //                m_sparse_dimension_idx++;
-    //                return lhs;
-    //              }));
-    //   }
-    //   for (auto const &t : getVertices(LibTag{}, mesh)) {
-    //     pnabla_MYY(deref(LibTag{}, t), k) =
-    //         (m_sparse_dimension_idx = 0,
-    //          reduceEdgeToVertex(
-    //              mesh, t, (double)0.0, [&](auto &lhs, auto const &redIdx) {
-    //                lhs += zavgS_MYY(deref(LibTag{}, redIdx), k) *
-    //                       sign(deref(LibTag{}, t), m_sparse_dimension_idx,
-    //                       k);
-    //                m_sparse_dimension_idx++;
-    //                return lhs;
-    //              }));
-    //   }
-
-    auto idx = blockIdx.x * blockDim.x + threadIdx.x;
-    if (idx >= v2e.size)
-        return;
-
-    auto vertex_ptrs = vertex_origins();
-
-    gridtools::sid::shift(vertex_ptrs, gridtools::device::at_key<vertex>(vertex_strides), idx);
-
-    *gridtools::device::at_key<pnabla_MXX_tag>(vertex_ptrs) = 0.;
-    { // reduce
-        for (int neigh = 0; neigh < v2e.max_neighbors; ++neigh) {
-            // body
-            auto absolute_neigh_index = *gridtools::device::at_key<connectivity_tag>(vertex_ptrs);
-            if (absolute_neigh_index != v2e.skip_value) {
-                auto edge_ptrs = edge_neighbor_origins();
-                gridtools::sid::shift(
-                    edge_ptrs, gridtools::device::at_key<edge>(edge_neighbor_strides), absolute_neigh_index);
-
-                auto zavgS_MXX_value = *gridtools::device::at_key<zavgS_MXX_tag>(edge_ptrs);
-                auto sign_value = *gridtools::device::at_key<sign_tag>(vertex_ptrs);
-
-                *gridtools::device::at_key<pnabla_MXX_tag>(vertex_ptrs) += zavgS_MXX_value * sign_value;
-                // body end
-            }
-            gridtools::sid::shift(vertex_ptrs, gridtools::device::at_key<neighbor>(vertex_strides), 1);
+    struct v2e_dim;
+    struct e2v_dim;
+    struct v2e_tag;
+    struct e2v_tag;
+    struct S_MXX_tag;
+    struct S_MYY_tag;
+    struct zavgS_MXX_tag;
+    struct zavgS_MYY_tag;
+    struct pnabla_MXX_tag;
+    struct pnabla_MYY_tag;
+    struct vol_tag;
+    struct sign_tag;
+
+    template <class Ptr, class Loop, class Strides, class Pp, class PPStride>
+    __global__ void nabla_edge_1(int e_size, Loop loop, Ptr ptr_holder, Strides strides, Pp pp, PPStride pp_stride) {
+        {
+            auto idx = blockIdx.x * blockDim.x + threadIdx.x;
+            if (idx >= e_size)
+                return;
+            auto ptr = ptr_holder();
+            sid::shift(ptr, device::at_key<dim::h>(strides), idx);
+            double acc = 0;
+            loop([&acc, pp_stride, pp = pp()](auto const &ptr, auto &&) {
+                acc += *sid::shifted(pp, pp_stride, *device::at_key<e2v_tag>(ptr));
+            })(ptr, strides);
+            acc *= 0.5;
+            *device::at_key<zavgS_MXX_tag>(ptr) = *device::at_key<S_MXX_tag>(ptr) * acc;
+            *device::at_key<zavgS_MYY_tag>(ptr) = *device::at_key<S_MYY_tag>(ptr) * acc;
         }
-        gridtools::sid::shift(vertex_ptrs,
-            gridtools::device::at_key<neighbor>(vertex_strides),
-            -v2e.max_neighbors); // or reset ptr to origin and shift ?
     }
-    *gridtools::device::at_key<pnabla_MYY_tag>(vertex_ptrs) = 0.;
-    { // reduce
-        for (int neigh = 0; neigh < v2e.max_neighbors; ++neigh) {
-            // body
-            auto absolute_neigh_index = *gridtools::device::at_key<connectivity_tag>(vertex_ptrs);
-            if (absolute_neigh_index != v2e.skip_value) {
-                auto edge_ptrs = edge_neighbor_origins();
-                gridtools::sid::shift(
-                    edge_ptrs, gridtools::device::at_key<edge>(edge_neighbor_strides), absolute_neigh_index);
-
-                auto zavgS_MYY_value = *gridtools::device::at_key<zavgS_MYY_tag>(edge_ptrs);
-                auto sign_value = *gridtools::device::at_key<sign_tag>(vertex_ptrs);
-                ;
 
-                *gridtools::device::at_key<pnabla_MYY_tag>(vertex_ptrs) += zavgS_MYY_value * sign_value;
-                // body end
-            }
-            gridtools::sid::shift(vertex_ptrs, gridtools::device::at_key<neighbor>(vertex_strides), 1);
-        }
-        gridtools::sid::shift(vertex_ptrs, gridtools::device::at_key<neighbor>(vertex_strides), -v2e.max_neighbors);
+    template <class Ptr,
+        class Loop,
+        class Strides,
+        class ZavgS_MXX,
+        class ZavgS_MXXStride,
+        class ZavgS_MYY,
+        class ZavgS_MYYStride>
+    __global__ void nabla_vertex_2(int v_size,
+        Loop loop,
+        Ptr ptr_holder,
+        Strides strides,
+        ZavgS_MXX zavgS_MXX,
+        ZavgS_MXXStride zavgS_MXX_stride,
+        ZavgS_MYY zavgS_MYY,
+        ZavgS_MYYStride zavgS_MYY_stride) {
+        auto idx = blockIdx.x * blockDim.x + threadIdx.x;
+        if (idx >= v_size)
+            return;
+        auto ptr = ptr_holder();
+        sid::shift(ptr, gridtools::device::at_key<dim::h>(strides), idx);
+        double acc = 0;
+        loop([&acc, zavgS_MXX = zavgS_MXX(), zavgS_MXX_stride](auto const &ptr, auto &&) {
+            auto i = *device::at_key<v2e_tag>(ptr);
+            if (i < 0)
+                return;
+            acc += *sid::shifted(zavgS_MXX, zavgS_MXX_stride, i) * *device::at_key<sign_tag>(ptr);
+        })(ptr, strides);
+        *at_key<pnabla_MXX_tag>(ptr) = acc;
+        acc = 0;
+        loop([&acc, zavgS_MYY = zavgS_MYY(), zavgS_MYY_stride](auto const &ptr, auto &&) {
+            auto i = *device::at_key<v2e_tag>(ptr);
+            if (i < 0)
+                return;
+            acc += *sid::shifted(zavgS_MYY, zavgS_MYY_stride, i) * *device::at_key<sign_tag>(ptr);
+        })(ptr, strides);
+        *at_key<pnabla_MYY_tag>(ptr) = acc;
     }
-}
-// ===
-//   do jedge = 1,dstruct%nb_pole_edges
-//     iedge = dstruct%pole_edges(jedge)
-//     ip2   = dstruct%edges(2,iedge)
-//     ! correct for wrong Y-derivatives in previous loop
-//     pnabla(MYY,ip2) = pnabla(MYY,ip2)+2.0_wp*zavgS(MYY,iedge)
-//   end do
-// ===
-//   {
-//     auto pe2v = gridtools::next::mesh::connectivity<
-//         std::tuple<atlas::pole_edge, vertex>>(mesh);
-//     for (int i = 0; i < gridtools::next::connectivity::size(pe2v);
-//          ++i) {
-//     }
-//   }
-template <class VertexOrigins, class VertexStrides>
-__global__ void nabla_vertex_4(std::size_t size, VertexOrigins vertex_origins, VertexStrides vertex_strides) {
-    // vertex loop
-    // for (auto const &t : getVertices(LibTag{}, mesh)) {
-    //     pnabla_MXX(deref(LibTag{}, t), k) =
-    //         pnabla_MXX(deref(LibTag{}, t), k) / vol(deref(LibTag{}, t), k);
-    //     pnabla_MYY(deref(LibTag{}, t), k) =
-    //         pnabla_MYY(deref(LibTag{}, t), k) / vol(deref(LibTag{}, t), k);
-    //   }
 
-    auto idx = blockIdx.x * blockDim.x + threadIdx.x;
-    if (idx >= size)
-        return;
-
-    auto vertex_ptrs = vertex_origins();
-
-    gridtools::sid::shift(vertex_ptrs, gridtools::device::at_key<vertex>(vertex_strides), idx);
-
-    *gridtools::device::at_key<pnabla_MXX_tag>(vertex_ptrs) /= *gridtools::device::at_key<vol_tag>(vertex_ptrs);
-    *gridtools::device::at_key<pnabla_MYY_tag>(vertex_ptrs) /= *gridtools::device::at_key<vol_tag>(vertex_ptrs);
-}
-
-std::tuple<int, int> cuda_setup(int N) {
-    int threads_per_block = 32;
-    int blocks = (N + threads_per_block - 1) / threads_per_block;
-    return {blocks, threads_per_block};
-}
-
-template <class Mesh,
-    class S_MXX_t,
-    class S_MYY_t,
-    class pp_t,
-    class pnabla_MXX_t,
-    class pnabla_MYY_t,
-    class vol_t,
-    class sign_t>
-void nabla(Mesh &&mesh,
-    S_MXX_t &&S_MXX,
-    S_MYY_t &&S_MYY,
-    pp_t &&pp,
-    pnabla_MXX_t &&pnabla_MXX,
-    pnabla_MYY_t &&pnabla_MYY,
-    vol_t &&vol,
-    sign_t &&sign) {
-    namespace tu = gridtools::tuple_util;
-    // allocate temporary field storage
-    int k_size = 1; // TODO
-    auto cuda_alloc =
-        gridtools::sid::device::make_cached_allocator(&gridtools::cuda_util::cuda_malloc<char[]>); // TODO
-    auto zavgS_MXX = gridtools::next::make_simple_tmp_storage<double>(
-        (int)gridtools::next::connectivity::size(gridtools::next::mesh::connectivity<edge>(mesh)), k_size, cuda_alloc);
-    auto zavgS_MYY = gridtools::next::make_simple_tmp_storage<double>(
-        (int)gridtools::next::connectivity::size(gridtools::next::mesh::connectivity<edge>(mesh)), k_size, cuda_alloc);
-    {
-        auto e2v = gridtools::next::mesh::connectivity<std::tuple<edge, vertex>>(mesh);
-        static_assert(gridtools::is_sid<decltype(gridtools::next::connectivity::neighbor_table(e2v))>{});
-
-        auto zavg = gridtools::next::make_simple_tmp_storage<double>(
-            (int)gridtools::next::connectivity::size(gridtools::next::mesh::connectivity<edge>(mesh)), k_size, cuda_alloc);
-
-        auto edge_fields = tu::make<gridtools::sid::composite::
-                keys<connectivity_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag, zavg_tag>::values>(
-            gridtools::next::connectivity::neighbor_table(e2v), S_MXX, S_MYY, zavgS_MXX, zavgS_MYY, zavg);
-        static_assert(gridtools::sid::concept_impl_::is_sid<decltype(edge_fields)>{});
-
-        auto edge_ptrs = gridtools::sid::get_origin(edge_fields);
-        auto edge_strides = gridtools::sid::get_strides(edge_fields);
-
-        auto vertex_neighbor_fields = tu::make<gridtools::sid::composite::keys<pp_tag>::values>(pp);
-        auto vertex_neighbor_ptrs = gridtools::sid::get_origin(vertex_neighbor_fields);
-        auto vertex_neighbor_strides = gridtools::sid::get_strides(vertex_neighbor_fields);
-
-        auto [blocks, threads_per_block] = cuda_setup(gridtools::next::connectivity::size(e2v));
-
-        auto e2v_info = gridtools::next::connectivity::extract_info(e2v);
-
-        nabla_edge_1<<<blocks, threads_per_block>>>(
-            e2v_info, edge_ptrs, edge_strides, vertex_neighbor_ptrs, vertex_neighbor_strides);
-        GT_CUDA_CHECK(cudaDeviceSynchronize());
-    } // namespace gridtools::tuple_util;
-    {
-        auto v2e = gridtools::next::mesh::connectivity<std::tuple<vertex, edge>>(mesh);
-        static_assert(gridtools::is_sid<decltype(gridtools::next::connectivity::neighbor_table(v2e))>{});
-
-        auto vertex_fields = tu::make<gridtools::sid::composite::
-                keys<connectivity_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag, vol_tag>::values>(
-            gridtools::next::connectivity::neighbor_table(v2e), pnabla_MXX, pnabla_MYY, sign, vol);
-        static_assert(gridtools::sid::concept_impl_::is_sid<decltype(vertex_fields)>{});
-
-        auto edge_neighbor_fields =
-            tu::make<gridtools::sid::composite::keys<zavgS_MXX_tag, zavgS_MYY_tag>::values>(zavgS_MXX, zavgS_MYY);
-
-        auto v2e_info = gridtools::next::connectivity::extract_info(v2e);
-
-        auto [blocks, threads_per_block] = cuda_setup(gridtools::next::connectivity::size(v2e));
-        nabla_vertex_2<<<blocks, threads_per_block>>>(v2e_info,
-            gridtools::sid::get_origin(vertex_fields),
-            gridtools::sid::get_strides(vertex_fields),
-            gridtools::sid::get_origin(edge_neighbor_fields),
-            gridtools::sid::get_strides(edge_neighbor_fields));
-        GT_CUDA_CHECK(cudaDeviceSynchronize());
+    template <class Ptr, class Strides>
+    __global__ void nabla_vertex_4(int v_size, Ptr ptr_holder, Strides strides) {
+        auto idx = blockIdx.x * blockDim.x + threadIdx.x;
+        if (idx >= v_size)
+            return;
+        auto ptr = ptr_holder();
+        sid::shift(ptr, device::at_key<dim::h>(strides), idx);
+        *device::at_key<pnabla_MXX_tag>(ptr) /= *device::at_key<vol_tag>(ptr);
+        *device::at_key<pnabla_MYY_tag>(ptr) /= *device::at_key<vol_tag>(ptr);
     }
-    {
-        auto vertices = gridtools::next::mesh::connectivity<std::tuple<vertex>>(mesh);
 
-        auto vertex_fields = tu::make<gridtools::sid::composite::keys<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>::values>(
-            pnabla_MXX, pnabla_MYY, vol);
-        static_assert(gridtools::sid::concept_impl_::is_sid<decltype(vertex_fields)>{});
-
-        auto size = gridtools::next::connectivity::size(vertices);
-
-        auto [blocks, threads_per_block] = cuda_setup(gridtools::next::connectivity::size(vertices));
-        nabla_vertex_4<<<blocks, threads_per_block>>>(
-            size, gridtools::sid::get_origin(vertex_fields), gridtools::sid::get_strides(vertex_fields));
-        GT_CUDA_CHECK(cudaDeviceSynchronize());
+    template <class V2E, class E2V>
+    auto nabla(domain d, V2E &&v2e, E2V &&e2v) {
+        static_assert(is_sid<decltype(std::forward<V2E>(v2e)(storage::gpu()))>());
+        static_assert(is_sid<decltype(std::forward<E2V>(e2v)(storage::gpu()))>());
+        return [d = std::move(d),
+                   v2e = sid::rename_dimensions<integral_constant<int_t, 1>, v2e_dim>(
+                       std::forward<V2E>(v2e)(storage::gpu())),
+                   e2v = sid::rename_dimensions<integral_constant<int_t, 1>, e2v_dim>(
+                       std::forward<E2V>(e2v)(storage::gpu()))](auto &&S_MXX,
+                   auto &&S_MYY,
+                   auto &&pp,
+                   auto &&pnabla_MXX,
+                   auto &&pnabla_MYY,
+                   auto &&vol,
+                   auto &&sign) {
+            static_assert(is_sid<decltype(S_MXX)>());
+            static_assert(is_sid<decltype(S_MYY)>());
+            static_assert(is_sid<decltype(pp)>());
+            static_assert(is_sid<decltype(pnabla_MXX)>());
+            static_assert(is_sid<decltype(pnabla_MYY)>());
+            static_assert(is_sid<decltype(vol)>());
+            static_assert(is_sid<decltype(sign)>());
+
+            // allocate temporary field storage
+            auto alloc = sid::device::make_cached_allocator(&cuda_util::cuda_malloc<char[]>);
+            auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
+            auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
+            {
+                auto fields = tuple_util::make<
+                    sid::composite::keys<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>::values>(
+                    e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY);
+                auto [blocks, threads_per_block] = cuda_setup(d.edge);
+                nabla_edge_1<<<blocks, threads_per_block>>>(d.edge,
+                    sid::make_loop<e2v_dim>(max_neighbors<e2v_dim>(e2v)),
+                    sid::get_origin(fields),
+                    sid::get_strides(fields),
+                    sid::get_origin(pp),
+                    at_key<dim::h>(sid::get_strides(pp)));
+                GT_CUDA_CHECK(cudaGetLastError());
+            }
+            {
+                auto fields =
+                    tuple_util::make<sid::composite::keys<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag>::values>(
+                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::n, v2e_dim>(sign));
+                auto [blocks, threads_per_block] = cuda_setup(d.vertex);
+                nabla_vertex_2<<<blocks, threads_per_block>>>(d.vertex,
+                    sid::make_loop<v2e_dim>(max_neighbors<v2e_dim>(v2e)),
+                    sid::get_origin(fields),
+                    sid::get_strides(fields),
+                    sid::get_origin(zavgS_MXX),
+                    at_key<dim::h>(sid::get_strides(zavgS_MXX)),
+                    sid::get_origin(zavgS_MYY),
+                    at_key<dim::h>(sid::get_strides(zavgS_MYY)));
+                GT_CUDA_CHECK(cudaGetLastError());
+            }
+            {
+                auto fields = tuple_util::make<sid::composite::keys<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>::values>(
+                    pnabla_MXX, pnabla_MYY, vol);
+                auto [blocks, threads_per_block] = cuda_setup(d.vertex);
+                nabla_vertex_4<<<blocks, threads_per_block>>>(
+                    d.vertex, sid::get_origin(fields), sid::get_strides(fields));
+                GT_CUDA_CHECK(cudaGetLastError());
+            }
+        };
     }
-}
+} // namespace nabla_impl_
+using nabla_impl_::nabla;
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
index d3a996c..4221895 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <gridtools/common/defs.hpp>
+#include <gridtools/common/hymap.hpp>
 #include <gridtools/common/integral_constant.hpp>
 #include <gridtools/sid/allocator.hpp>
 #include <gridtools/sid/composite.hpp>

From 38c465289ab3153ba19ec43ddc0b9e0252c06631 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Fri, 23 Oct 2020 07:09:17 +0000
Subject: [PATCH 03/24] nabla_naive: adapt the structute to the code generation

---
 .../include/gridtools/next/tmp_storage.hpp    |  17 --
 .../include/gridtools/next/unstructured.hpp   |   4 +-
 .../include/gridtools/next/usid_helpers.hpp   |  58 ++++++
 .../gridtools/next/usid_naive_helpers.hpp     |  33 ++++
 .../tests/include/util/atlas_util.hpp         |  23 ---
 .../tests/regression/fvm_nabla/CMakeLists.txt |   2 +-
 .../tests/regression/fvm_nabla/driver.cc      | 187 +-----------------
 .../tests/regression/fvm_nabla/driver.hpp     | 176 +++++++++++++++++
 .../tests/regression/fvm_nabla/nabla_cuda.hpp |   9 +-
 .../regression/fvm_nabla/nabla_naive.hpp      | 171 ++++++----------
 10 files changed, 342 insertions(+), 338 deletions(-)
 delete mode 100644 cpputil/unstructured/include/gridtools/next/tmp_storage.hpp
 create mode 100644 cpputil/unstructured/include/gridtools/next/usid_helpers.hpp
 create mode 100644 cpputil/unstructured/include/gridtools/next/usid_naive_helpers.hpp
 delete mode 100644 cpputil/unstructured/tests/include/util/atlas_util.hpp
 create mode 100644 cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp

diff --git a/cpputil/unstructured/include/gridtools/next/tmp_storage.hpp b/cpputil/unstructured/include/gridtools/next/tmp_storage.hpp
deleted file mode 100644
index 5197706..0000000
--- a/cpputil/unstructured/include/gridtools/next/tmp_storage.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include <gridtools/common/hymap.hpp>
-#include <gridtools/common/tuple_util.hpp>
-#include <gridtools/sid/contiguous.hpp>
-
-#include "unstructured.hpp"
-
-namespace gridtools {
-    namespace next {
-        template <class T, class Alloc, class HSize, class KSize>
-        auto make_simple_tmp_storage(HSize h_size, KSize k_size, Alloc &alloc) {
-            return sid::make_contiguous<T>(
-                alloc, tuple_util::make<hymap::keys<dim::h, dim::k>::values>(h_size, k_size));
-        }
-    } // namespace next
-} // namespace gridtools
diff --git a/cpputil/unstructured/include/gridtools/next/unstructured.hpp b/cpputil/unstructured/include/gridtools/next/unstructured.hpp
index 2340696..2777937 100644
--- a/cpputil/unstructured/include/gridtools/next/unstructured.hpp
+++ b/cpputil/unstructured/include/gridtools/next/unstructured.hpp
@@ -6,9 +6,11 @@
 namespace gridtools::next::dim {
     using horizontal = integral_constant<int_t, 0>;
     using vertical = integral_constant<int_t, 1>;
-    using neighbor = integral_constant<int_t, 2>;
+    using neighbor = integral_constant<int_t, 1>;
+    using sparse = integral_constant<int_t, 2>;
 
     using h = horizontal;
     using k = vertical;
     using n = neighbor;
+    using s = sparse;
 } // namespace gridtools::next::dim
diff --git a/cpputil/unstructured/include/gridtools/next/usid_helpers.hpp b/cpputil/unstructured/include/gridtools/next/usid_helpers.hpp
new file mode 100644
index 0000000..51a5f41
--- /dev/null
+++ b/cpputil/unstructured/include/gridtools/next/usid_helpers.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include <type_traits>
+
+#include <gridtools/common/host_device.hpp>
+#include <gridtools/common/hymap.hpp>
+#include <gridtools/common/utility.hpp>
+#include <gridtools/meta/id.hpp>
+#include <gridtools/sid/composite.hpp>
+#include <gridtools/sid/concept.hpp>
+#include <gridtools/sid/contiguous.hpp>
+#include <gridtools/sid/loop.hpp>
+
+#include "unstructured.hpp"
+
+namespace gridtools::next {
+    template <class T, class Alloc, class HSize, class KSize>
+    auto make_simple_tmp_storage(HSize h_size, KSize k_size, Alloc &alloc) {
+        return sid::make_contiguous<T>(alloc, hymap::keys<dim::h, dim::k>::values<HSize, KSize>(h_size, k_size));
+    }
+
+    template <class Tag, class F, class Init, class N, class G, class HasSkipValues>
+    GT_FUNCTION auto fold_neighbors(F f, Init init, N n, G g, HasSkipValues) {
+        return [=, loop = sid::make_loop<Tag>(n)](
+                   auto &&ptr, auto const &strides, auto &&neighbor_ptr, auto &&neighbor_stride) {
+            using acc_t = std::decay_t<decltype(g(ptr, neighbor_ptr))>;
+            acc_t acc = init(meta::lazy::id<acc_t>());
+            loop([&](auto const &ptr, auto &&) {
+                auto i = *at_key<Tag>(ptr);
+                if constexpr (HasSkipValues::value)
+                    if (i < 0)
+                        return;
+                acc = f(acc, g(ptr, sid::shifted(neighbor_ptr, neighbor_stride, i)));
+            })(wstd::forward<decltype(ptr)>(ptr), strides);
+            return acc;
+        };
+    }
+
+    template <class Tag>
+    struct sum_neighbors_f {
+        template <class N, class F, class HasSkip = std::true_type>
+        GT_FUNCTION auto operator()(N n, F f, HasSkip has_skip = {}) const {
+            return fold_neighbors<Tag>([](auto x, auto y) { return x + y; },
+                [](auto z) -> typename decltype(z)::type { return {}; },
+                n,
+                f,
+                has_skip);
+        }
+    };
+
+    template <class Tag>
+    constexpr sum_neighbors_f<Tag> sum_neighbors = {};
+
+    template <class... Keys>
+    constexpr auto make_composite = [](auto &&...sids) {
+        return tuple_util::make<sid::composite::keys<Keys...>::template values>(std::forward<decltype(sids)>(sids)...);
+    };
+} // namespace gridtools::next
\ No newline at end of file
diff --git a/cpputil/unstructured/include/gridtools/next/usid_naive_helpers.hpp b/cpputil/unstructured/include/gridtools/next/usid_naive_helpers.hpp
new file mode 100644
index 0000000..d5abd98
--- /dev/null
+++ b/cpputil/unstructured/include/gridtools/next/usid_naive_helpers.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <memory>
+#include <tuple>
+
+#include <gridtools/common/hymap.hpp>
+#include <gridtools/sid/allocator.hpp>
+#include <gridtools/sid/concept.hpp>
+#include <gridtools/sid/loop.hpp>
+#include <gridtools/storage/cpu_ifirst.hpp>
+
+#include "unstructured.hpp"
+
+namespace gridtools::next::naive {
+    using traits_t = storage::cpu_ifirst;
+
+    inline auto make_allocator() { return sid::make_cached_allocator(&std::make_unique<char[]>); }
+
+    template <class Size, class Body, class Sid, class... Sids>
+    void call_kernel(Size size, Body &&body, Sid &&fields, Sids &&...neighbor_fields) {
+        sid::make_loop<dim::h>(size)(
+            [&body,
+                params = std::tuple_cat(std::make_tuple(sid::get_origin(neighbor_fields)(),
+                    sid::get_stride<dim::h>(sid::get_strides(neighbor_fields)))...)](auto &ptr, auto const &strides) {
+                std::apply(body, std::tuple_cat(std::forward_as_tuple(ptr, strides), params));
+            })(sid::get_origin(fields)(), sid::get_strides(fields));
+    }
+
+    template <class Tag, class Ptr>
+    decltype(auto) field(Ptr const &ptr) {
+        return *at_key<Tag>(ptr);
+    }
+} // namespace gridtools::next::naive
diff --git a/cpputil/unstructured/tests/include/util/atlas_util.hpp b/cpputil/unstructured/tests/include/util/atlas_util.hpp
deleted file mode 100644
index 5041e3f..0000000
--- a/cpputil/unstructured/tests/include/util/atlas_util.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#pragma once
-
-#include <atlas/functionspace/EdgeColumns.h>
-#include <atlas/grid/StructuredGrid.h>
-#include <atlas/mesh.h>
-#include <atlas/mesh/Mesh.h>
-#include <atlas/mesh/actions/BuildEdges.h>
-#include <atlas/meshgenerator/MeshGenerator.h>
-
-namespace atlas_util {
-
-    auto inline make_mesh(std::string const &grid_type = "O2") {
-        atlas::StructuredGrid structuredGrid = atlas::Grid(grid_type);
-        return atlas::StructuredMeshGenerator{}.generate(structuredGrid);
-    }
-
-    template <typename T = double>
-    auto inline make_edge_field(atlas::Mesh &mesh, int nb_levels) {
-        atlas::mesh::actions::build_edges(mesh);
-        atlas::functionspace::EdgeColumns fs_edges(mesh, atlas::option::levels(nb_levels) | atlas::option::halo(1));
-        return fs_edges.createField<T>();
-    }
-} // namespace atlas_util
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt b/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt
index ee02f1d..12beb00 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt
@@ -3,7 +3,7 @@ function(add_driver_executable target driver_source stencil_header)
     target_compile_definitions(${target} PRIVATE STENCIL_HEADER=\"${stencil_header}\")
 endfunction()
 
-add_driver_executable(fvm_nabla driver.cc nabla_naive.hpp)
+add_executable(fvm_nabla driver.cc)
 target_link_libraries(fvm_nabla PRIVATE atlas eckit GridTools::gridtools gtnext gtest gtest_main)
 add_test(NAME fvm_nabla COMMAND $<TARGET_FILE:fvm_nabla>)
 
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/driver.cc b/cpputil/unstructured/tests/regression/fvm_nabla/driver.cc
index 721d25a..9acb503 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/driver.cc
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/driver.cc
@@ -1,187 +1,6 @@
-#include <algorithm>
-#include <cmath>
-#include <limits>
-#include <tuple>
-
 #include <gtest/gtest.h>
 
-#include <atlas/array.h>
-#include <atlas/functionspace.h>
-#include <atlas/grid.h>
-#include <atlas/mesh.h>
-#include <atlas/mesh/actions/BuildDualMesh.h>
-#include <atlas/mesh/actions/BuildEdges.h>
-#include <atlas/meshgenerator.h>
-
-#include <gridtools/common/integral_constant.hpp>
-#include <gridtools/storage/builder.hpp>
-#include <gridtools/storage/sid.hpp>
-
-#include <gridtools/next/atlas_adapter.hpp>
-
-#ifdef __CUDACC__
-#include <gridtools/storage/gpu.hpp>
-namespace {
-    using storage_traits_t = gridtools::storage::gpu;
-}
-#else
-#include <gridtools/storage/cpu_ifirst.hpp>
-namespace {
-    using storage_traits_t = gridtools::storage::cpu_ifirst;
-}
-#endif
-
-#include STENCIL_HEADER
-
-namespace {
-    using namespace gridtools::literals;
-
-    constexpr auto storage_builder = gridtools::storage::builder<storage_traits_t>;
-
-    auto make_mesh() {
-        using namespace atlas;
-        using param_t = StructuredMeshGenerator::Parameters;
-        auto res = StructuredMeshGenerator(param_t("triangulate", true) | param_t("angle", -1.)).generate(Grid("O32"));
-        functionspace::EdgeColumns(res, option::levels(1) | option::halo(1));
-        functionspace::NodeColumns(res, option::levels(1) | option::halo(1));
-        mesh::actions::build_edges(res);
-        mesh::actions::build_node_to_edge_connectivity(res);
-        mesh::actions::build_median_dual_mesh(res);
-        return res;
-    }
-
-    const double rpi = 2 * std::asin(1);
-    const double radius = 6371.22e+03;
-    const double deg2rad = 2 * rpi / 360;
-    constexpr int MXX = 0;
-    constexpr int MYY = 1;
-    constexpr auto edges_per_node = 7_c;
-
-    auto make_vol(atlas::mesh::Nodes const &nodes) {
-        auto dual_volumes = atlas::array::make_view<double, 1>(nodes.field("dual_volumes"));
-        auto init = [&](int n) { return dual_volumes(n) * (std::pow(deg2rad, 2) * std::pow(radius, 2)); };
-        return storage_builder        //
-            .type<double>()           //
-            .dimensions(nodes.size()) //
-            .initializer(init)        //
-            .build();                 //
-    }
-
-    auto make_sign(atlas::Mesh const &mesh) {
-        auto &&edges = mesh.edges();
-        auto &&nodes = mesh.nodes();
-        auto &&n2e = nodes.edge_connectivity();
-        auto &&e2n = edges.node_connectivity();
-        auto flags = atlas::array::make_view<int, 1>(edges.flags());
-        auto is_pole_edge = [&](auto e) {
-            using topology_t = atlas::mesh::Nodes::Topology;
-            return topology_t::check(flags(e), topology_t::POLE);
-        };
-        auto init = [&](int n, int, int e) -> double {
-            if (e >= n2e.cols(n))
-                return 0;
-            auto ee = n2e(n, e);
-            return n == e2n(ee, 0) || is_pole_edge(ee) ? 1 : -1;
-        };
-        return storage_builder                           //
-            .type<double>()                              //
-            .selector<1, 0, 1>()                         //
-            .dimensions(nodes.size(), 1, edges_per_node) //
-            .initializer(init)                           //
-            .build();                                    //
-    }
-
-    auto make_S_MXX(atlas::mesh::Edges const &edges) {
-        auto dual_normals = atlas::array::make_view<double, 2>(edges.field("dual_normals"));
-        return storage_builder                                                           //
-            .type<double>()                                                              //
-            .dimensions(edges.size())                                                    //
-            .initializer([&](int i) { return dual_normals(i, MXX) * radius * deg2rad; }) //
-            .build();                                                                    //
-    }
-
-    auto make_S_MYY(atlas::mesh::Edges const &edges) {
-        auto dual_normals = atlas::array::make_view<double, 2>(edges.field("dual_normals"));
-        return storage_builder                                                           //
-            .type<double>()                                                              //
-            .dimensions(edges.size())                                                    //
-            .initializer([&](int i) { return dual_normals(i, MYY) * radius * deg2rad; }) //
-            .build();                                                                    //
-    }
-
-    // TODO ask Christian for a proper name for this input data
-    auto make_pp(atlas::mesh::Nodes const &nodes) {
-        static const double zh0 = 2000;
-        static const double zrad = 3 * rpi / 4 * radius;
-        static const double zeta = rpi / 16 * radius;
-        static const double zlatc = 0;
-        static const double zlonc = 3 * rpi / 2;
-
-        auto lonlat = atlas::array::make_view<double, 2>(nodes.field("lonlat"));
-        // lonlatcr is in physical space and may differ from coords later
-        auto rlonlatcr = [&](int n, int i) { return lonlat(n, i) * deg2rad; };
-        auto init = [&](int n) {
-            double zlon = rlonlatcr(n, MXX);
-            double rcosa = std::cos(rlonlatcr(n, MYY));
-            double rsina = std::sin(rlonlatcr(n, MYY));
-            double zdist = std::sin(zlatc) * rsina + std::cos(zlatc) * rcosa * std::cos(zlon - zlonc);
-            zdist = radius * std::acos(zdist);
-            return zdist < zrad
-                       ? .5 * zh0 * (1 + std::cos(rpi * zdist / zrad)) * std::pow(std::cos(rpi * zdist / zeta), 2)
-                       : 0;
-        };
-        return storage_builder        //
-            .type<double>()           //
-            .dimensions(nodes.size()) //
-            .initializer(init)        //
-            .build();                 //
-    }
-
-    template <class T>
-    auto min_max(T const &field) {
-        double min = std::numeric_limits<double>::max();
-        double max = std::numeric_limits<double>::min();
-        double avg = 0;
-        auto view = field->const_host_view();
-        auto lengths = field->lengths();
-        for (int i = 0; i < (int)lengths[0]; ++i)
-            for (int k = 0; k < (int)lengths[1]; ++k) {
-                double x = view(i, k);
-                min = std::min(min, x);
-                max = std::max(max, x);
-                avg += x;
-            }
-        return std::make_tuple(min, max, avg / (lengths[0] * lengths[1]));
-    }
-
-    TEST(FVM, nabla) {
-        constexpr auto k = 1_c;
-
-        auto mesh = make_mesh();
-        auto &&edges = mesh.edges();
-        auto &&nodes = mesh.nodes();
-
-        // output
-        auto make_output = storage_builder.type<double>().dimensions(nodes.size(), k);
-        auto pnabla_MXX = make_output();
-        auto pnabla_MYY = make_output();
-
-        nabla({.vertex = nodes.size(), .edge = edges.size(), .cell = mesh.cells().size(), .k = k},
-            make_storage_producer(edges_per_node, nodes.edge_connectivity()),
-            make_storage_producer(2_c, edges.node_connectivity()))(make_S_MXX(edges),
-            make_S_MYY(edges),
-            make_pp(nodes),
-            pnabla_MXX,
-            pnabla_MYY,
-            make_vol(nodes),
-            make_sign(mesh));
-
-        auto [x_min, x_max, x_avg] = min_max(pnabla_MXX);
-        auto [y_min, y_max, y_avg] = min_max(pnabla_MYY);
+#include "driver.hpp"
+#include "nabla_naive.hpp"
 
-        EXPECT_DOUBLE_EQ(-3.5455427772566003E-003, x_min);
-        EXPECT_DOUBLE_EQ(3.5455427772565435E-003, x_max);
-        EXPECT_DOUBLE_EQ(-3.3540113705465301E-003, y_min);
-        EXPECT_DOUBLE_EQ(3.3540113705465301E-003, y_max);
-    }
-} // namespace
+TEST(FVM, nabla) { driver(nabla); }
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp
new file mode 100644
index 0000000..ff0ae10
--- /dev/null
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp
@@ -0,0 +1,176 @@
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <tuple>
+
+#include <gtest/gtest.h>
+
+#include <atlas/array.h>
+#include <atlas/functionspace.h>
+#include <atlas/grid.h>
+#include <atlas/mesh.h>
+#include <atlas/mesh/actions/BuildDualMesh.h>
+#include <atlas/mesh/actions/BuildEdges.h>
+#include <atlas/meshgenerator.h>
+
+#include <gridtools/common/integral_constant.hpp>
+#include <gridtools/storage/builder.hpp>
+#include <gridtools/storage/sid.hpp>
+
+#include <gridtools/next/atlas_adapter.hpp>
+
+#ifdef __CUDACC__
+#include <gridtools/storage/gpu.hpp>
+namespace {
+    using storage_traits_t = gridtools::storage::gpu;
+}
+#else
+#include <gridtools/storage/cpu_ifirst.hpp>
+namespace {
+    using storage_traits_t = gridtools::storage::cpu_ifirst;
+}
+#endif
+
+namespace driver_impl_ {
+    using namespace gridtools::literals;
+
+    constexpr auto storage_builder = gridtools::storage::builder<storage_traits_t>;
+
+    auto make_mesh() {
+        using namespace atlas;
+        using param_t = StructuredMeshGenerator::Parameters;
+        auto res = StructuredMeshGenerator(param_t("triangulate", true) | param_t("angle", -1.)).generate(Grid("O32"));
+        functionspace::EdgeColumns(res, option::levels(1) | option::halo(1));
+        functionspace::NodeColumns(res, option::levels(1) | option::halo(1));
+        mesh::actions::build_edges(res);
+        mesh::actions::build_node_to_edge_connectivity(res);
+        mesh::actions::build_median_dual_mesh(res);
+        return res;
+    }
+
+    const double rpi = 2 * std::asin(1);
+    const double radius = 6371.22e+03;
+    const double deg2rad = 2 * rpi / 360;
+    constexpr int MXX = 0;
+    constexpr int MYY = 1;
+    constexpr auto edges_per_node = 7_c;
+
+    auto make_vol(atlas::mesh::Nodes const &nodes) {
+        auto dual_volumes = atlas::array::make_view<double, 1>(nodes.field("dual_volumes"));
+        auto init = [&](int n) { return dual_volumes(n) * (std::pow(deg2rad, 2) * std::pow(radius, 2)); };
+        return storage_builder.type<double>().dimensions(nodes.size()).initializer(init).build();
+    }
+
+    auto make_sign(atlas::Mesh const &mesh) {
+        auto &&edges = mesh.edges();
+        auto &&nodes = mesh.nodes();
+        auto &&n2e = nodes.edge_connectivity();
+        auto &&e2n = edges.node_connectivity();
+        auto flags = atlas::array::make_view<int, 1>(edges.flags());
+        auto is_pole_edge = [&](auto e) {
+            using topology_t = atlas::mesh::Nodes::Topology;
+            return topology_t::check(flags(e), topology_t::POLE);
+        };
+        auto init = [&](int n, int, int e) -> double {
+            if (e >= n2e.cols(n))
+                return 0;
+            auto ee = n2e(n, e);
+            return n == e2n(ee, 0) || is_pole_edge(ee) ? 1 : -1;
+        };
+        return storage_builder.type<double>()
+            .selector<1, 0, 1>()
+            .dimensions(nodes.size(), 1, edges_per_node)
+            .initializer(init)
+            .build();
+    }
+
+    auto make_S_MXX(atlas::mesh::Edges const &edges) {
+        auto dual_normals = atlas::array::make_view<double, 2>(edges.field("dual_normals"));
+        return storage_builder.type<double>()
+            .dimensions(edges.size())
+            .initializer([&](int i) { return dual_normals(i, MXX) * radius * deg2rad; })
+            .build();
+    }
+
+    auto make_S_MYY(atlas::mesh::Edges const &edges) {
+        auto dual_normals = atlas::array::make_view<double, 2>(edges.field("dual_normals"));
+        return storage_builder.type<double>()
+            .dimensions(edges.size())
+            .initializer([&](int i) { return dual_normals(i, MYY) * radius * deg2rad; })
+            .build();
+    }
+
+    // TODO ask Christian for a proper name for this input data
+    auto make_pp(atlas::mesh::Nodes const &nodes) {
+        static const double zh0 = 2000;
+        static const double zrad = 3 * rpi / 4 * radius;
+        static const double zeta = rpi / 16 * radius;
+        static const double zlatc = 0;
+        static const double zlonc = 3 * rpi / 2;
+
+        auto lonlat = atlas::array::make_view<double, 2>(nodes.field("lonlat"));
+        // lonlatcr is in physical space and may differ from coords later
+        auto rlonlatcr = [&](int n, int i) { return lonlat(n, i) * deg2rad; };
+        auto init = [&](int n) {
+            double zlon = rlonlatcr(n, MXX);
+            double rcosa = std::cos(rlonlatcr(n, MYY));
+            double rsina = std::sin(rlonlatcr(n, MYY));
+            double zdist = std::sin(zlatc) * rsina + std::cos(zlatc) * rcosa * std::cos(zlon - zlonc);
+            zdist = radius * std::acos(zdist);
+            return zdist < zrad
+                       ? .5 * zh0 * (1 + std::cos(rpi * zdist / zrad)) * std::pow(std::cos(rpi * zdist / zeta), 2)
+                       : 0;
+        };
+        return storage_builder.type<double>().dimensions(nodes.size()).initializer(init).build();
+    }
+
+    template <class T>
+    auto min_max(T const &field) {
+        double min = std::numeric_limits<double>::max();
+        double max = std::numeric_limits<double>::min();
+        auto view = field->const_host_view();
+        auto lengths = field->lengths();
+        for (int i = 0; i < (int)lengths[0]; ++i)
+            for (int k = 0; k < (int)lengths[1]; ++k) {
+                double x = view(i, k);
+                min = std::min(min, x);
+                max = std::max(max, x);
+            }
+        return std::make_tuple(min, max);
+    }
+
+    template <class Nabla>
+    void driver(Nabla nabla) {
+        constexpr auto k = 1_c;
+
+        auto mesh = make_mesh();
+        auto &&edges = mesh.edges();
+        auto &&nodes = mesh.nodes();
+
+        // output
+        auto make_output = storage_builder.type<double>().dimensions(nodes.size(), k);
+        auto pnabla_MXX = make_output();
+        auto pnabla_MYY = make_output();
+
+        nabla({.vertex = nodes.size(), .edge = edges.size(), .cell = mesh.cells().size(), .k = k},
+            make_storage_producer(edges_per_node, nodes.edge_connectivity()),
+            make_storage_producer(2_c, edges.node_connectivity()))(make_S_MXX(edges),
+            make_S_MYY(edges),
+            make_pp(nodes),
+            pnabla_MXX,
+            pnabla_MYY,
+            make_vol(nodes),
+            make_sign(mesh));
+
+        auto [x_min, x_max] = min_max(pnabla_MXX);
+        auto [y_min, y_max] = min_max(pnabla_MYY);
+
+        EXPECT_DOUBLE_EQ(-3.5455427772566003E-003, x_min);
+        EXPECT_DOUBLE_EQ(3.5455427772565435E-003, x_max);
+        EXPECT_DOUBLE_EQ(-3.3540113705465301E-003, y_min);
+        EXPECT_DOUBLE_EQ(3.3540113705465301E-003, y_max);
+    } //
+} // namespace driver_impl_
+using driver_impl_::driver;
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
index 983bac4..21aee03 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
@@ -4,7 +4,6 @@
 #error "Tried to compile CUDA code with a regular C++ compiler."
 #endif
 
-#include <gridtools/common/cuda_util.hpp>
 #include <gridtools/common/defs.hpp>
 #include <gridtools/common/hymap.hpp>
 #include <gridtools/common/integral_constant.hpp>
@@ -13,13 +12,15 @@
 #include <gridtools/sid/concept.hpp>
 #include <gridtools/sid/loop.hpp>
 #include <gridtools/sid/rename_dimensions.hpp>
-#include <gridtools/storage/gpu.hpp>
 
-#include <gridtools/next/cuda_util.hpp>
 #include <gridtools/next/domain.hpp>
 #include <gridtools/next/tmp_storage.hpp>
 #include <gridtools/next/unstructured.hpp>
 
+#include <gridtools/common/cuda_util.hpp>
+#include <gridtools/next/cuda_util.hpp>
+#include <gridtools/storage/gpu.hpp>
+
 namespace nabla_impl_ {
     using namespace gridtools;
     using namespace next;
@@ -153,7 +154,7 @@ namespace nabla_impl_ {
             {
                 auto fields =
                     tuple_util::make<sid::composite::keys<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag>::values>(
-                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::n, v2e_dim>(sign));
+                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_dim>(sign));
                 auto [blocks, threads_per_block] = cuda_setup(d.vertex);
                 nabla_vertex_2<<<blocks, threads_per_block>>>(d.vertex,
                     sid::make_loop<v2e_dim>(max_neighbors<v2e_dim>(v2e)),
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
index 4221895..2d08d07 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
@@ -1,32 +1,17 @@
 #pragma once
 
-#include <gridtools/common/defs.hpp>
-#include <gridtools/common/hymap.hpp>
-#include <gridtools/common/integral_constant.hpp>
-#include <gridtools/sid/allocator.hpp>
-#include <gridtools/sid/composite.hpp>
-#include <gridtools/sid/concept.hpp>
-#include <gridtools/sid/loop.hpp>
-#include <gridtools/sid/rename_dimensions.hpp>
-#include <gridtools/storage/cpu_ifirst.hpp>
+#include <utility>
 
+#include <gridtools/common/integral_constant.hpp>
 #include <gridtools/next/domain.hpp>
-#include <gridtools/next/tmp_storage.hpp>
 #include <gridtools/next/unstructured.hpp>
+#include <gridtools/next/usid_helpers.hpp>
+#include <gridtools/next/usid_naive_helpers.hpp>
+#include <gridtools/sid/concept.hpp>
+#include <gridtools/sid/rename_dimensions.hpp>
 
-namespace nabla_impl_ {
-
-    using namespace gridtools;
-    using namespace next;
-
-    template <class Dim, class Sid>
-    auto max_neighbors(Sid const &sid) {
-        static_assert(has_key<sid::upper_bounds_type<Sid>, Dim>());
-        return at_key<Dim>(sid::get_upper_bounds(sid));
-    }
-
-    struct v2e_dim;
-    struct e2v_dim;
+namespace gridtools::next::naive::nabla_impl_ {
+    using namespace literals;
     struct v2e_tag;
     struct e2v_tag;
     struct S_MXX_tag;
@@ -37,88 +22,58 @@ namespace nabla_impl_ {
     struct pnabla_MYY_tag;
     struct vol_tag;
     struct sign_tag;
-
-    template <class V2E, class E2V>
-    auto nabla(domain d, V2E &&v2e, E2V &&e2v) {
-        static_assert(is_sid<decltype(std::forward<V2E>(v2e)(storage::cpu_ifirst()))>());
-        static_assert(is_sid<decltype(std::forward<E2V>(e2v)(storage::cpu_ifirst()))>());
-        return [d = std::move(d),
-                   v2e = sid::rename_dimensions<integral_constant<int_t, 1>, v2e_dim>(
-                       std::forward<V2E>(v2e)(storage::cpu_ifirst())),
-                   e2v = sid::rename_dimensions<integral_constant<int_t, 1>, e2v_dim>(
-                       std::forward<E2V>(e2v)(storage::cpu_ifirst()))](auto &&S_MXX,
-                   auto &&S_MYY,
-                   auto &&pp,
-                   auto &&pnabla_MXX,
-                   auto &&pnabla_MYY,
-                   auto &&vol,
-                   auto &&sign) {
-            static_assert(is_sid<decltype(S_MXX)>());
-            static_assert(is_sid<decltype(S_MYY)>());
-            static_assert(is_sid<decltype(pp)>());
-            static_assert(is_sid<decltype(pnabla_MXX)>());
-            static_assert(is_sid<decltype(pnabla_MYY)>());
-            static_assert(is_sid<decltype(vol)>());
-            static_assert(is_sid<decltype(sign)>());
-
-            // allocate temporary field storage
-            auto alloc = sid::make_cached_allocator(&std::make_unique<char[]>);
-            auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
-            auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
-
-            {
-                auto fields = tuple_util::make<
-                    sid::composite::keys<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>::values>(
-                    e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY);
-                sid::make_loop<dim::h>(d.edge)(
-                    [&, pp = sid::get_origin(pp)(), pp_stride = at_key<dim::h>(sid::get_strides(pp))](
-                        auto &ptr, auto const &strides) {
-                        double acc = 0;
-                        sid::make_loop<e2v_dim>(max_neighbors<e2v_dim>(e2v))([&](auto const &ptr, auto &&) {
-                            acc += *sid::shifted(pp, pp_stride, *at_key<e2v_tag>(ptr));
-                        })(ptr, strides);
-                        acc *= 0.5;
-                        *at_key<zavgS_MXX_tag>(ptr) = *at_key<S_MXX_tag>(ptr) * acc;
-                        *at_key<zavgS_MYY_tag>(ptr) = *at_key<S_MYY_tag>(ptr) * acc;
-                    })(sid::get_origin(fields)(), sid::get_strides(fields));
-            }
-            {
-                auto fields =
-                    tuple_util::make<sid::composite::keys<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag>::values>(
-                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::n, v2e_dim>(sign));
-                sid::make_loop<dim::h>(d.vertex)([&,
-                                                     zavgS_MXX = sid::get_origin(zavgS_MXX)(),
-                                                     zavgS_MXX_stride = at_key<dim::h>(sid::get_strides(zavgS_MXX)),
-                                                     zavgS_MYY = sid::get_origin(zavgS_MYY)(),
-                                                     zavgS_MYY_stride = at_key<dim::h>(sid::get_strides(zavgS_MYY))](
-                                                     auto &ptr, auto const &strides) {
-                    double acc = 0;
-                    sid::make_loop<v2e_dim>(max_neighbors<v2e_dim>(v2e))([&](auto const &ptr, auto &&) {
-                        auto i = *at_key<v2e_tag>(ptr);
-                        if (i < 0)
-                            return;
-                        acc += *sid::shifted(zavgS_MXX, zavgS_MXX_stride, i) * *at_key<sign_tag>(ptr);
-                    })(ptr, strides);
-                    *at_key<pnabla_MXX_tag>(ptr) = acc;
-                    acc = 0;
-                    sid::make_loop<v2e_dim>(max_neighbors<v2e_dim>(v2e))([&](auto const &ptr, auto &&) {
-                        auto i = *at_key<v2e_tag>(ptr);
-                        if (i < 0)
-                            return;
-                        acc += *sid::shifted(zavgS_MYY, zavgS_MYY_stride, i) * *at_key<sign_tag>(ptr);
-                    })(ptr, strides);
-                    *at_key<pnabla_MYY_tag>(ptr) = acc;
-                })(sid::get_origin(fields)(), sid::get_strides(fields));
-            }
-            {
-                auto fields = tuple_util::make<sid::composite::keys<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>::values>(
-                    pnabla_MXX, pnabla_MYY, vol);
-                sid::make_loop<dim::h>(d.vertex)([](auto &ptr, auto &&stride) {
-                    *at_key<pnabla_MXX_tag>(ptr) /= *at_key<vol_tag>(ptr);
-                    *at_key<pnabla_MYY_tag>(ptr) /= *at_key<vol_tag>(ptr);
-                })(sid::get_origin(fields)(), sid::get_strides(fields));
-            }
-        };
-    }
-} // namespace nabla_impl_
-using nabla_impl_::nabla;
+    struct pp_tag;
+    constexpr auto nabla = [](domain d, auto &&v2e, auto &&e2v) {
+        static_assert(is_sid<decltype(v2e(traits_t()))>());
+        static_assert(is_sid<decltype(e2v(traits_t()))>());
+        return
+            [d = std::move(d),
+                v2e = sid::rename_dimensions<dim::n, v2e_tag>(std::forward<decltype(v2e)>(v2e)(traits_t())),
+                e2v = sid::rename_dimensions<dim::n, e2v_tag>(std::forward<decltype(e2v)>(e2v)(traits_t()))](
+                auto &&S_MXX, auto &&S_MYY, auto &&pp, auto &&pnabla_MXX, auto &&pnabla_MYY, auto &&vol, auto &&sign) {
+                static_assert(is_sid<decltype(S_MXX)>());
+                static_assert(is_sid<decltype(S_MYY)>());
+                static_assert(is_sid<decltype(pp)>());
+                static_assert(is_sid<decltype(pnabla_MXX)>());
+                static_assert(is_sid<decltype(pnabla_MYY)>());
+                static_assert(is_sid<decltype(vol)>());
+                static_assert(is_sid<decltype(sign)>());
+                auto alloc = make_allocator();
+                auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
+                auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
+                call_kernel(
+                    d.edge,
+                    [](auto &ptr, auto const &strides, auto const &neighbor_ptr, auto const &neighbor_stride) {
+                        auto zavg = 0.5 * sum_neighbors<e2v_tag>(2_c, [](auto &&, auto &&n) {
+                            return field<pp_tag>(n);
+                        })(ptr, strides, neighbor_ptr, neighbor_stride);
+                        field<zavgS_MXX_tag>(ptr) = field<S_MXX_tag>(ptr) * zavg;
+                        field<zavgS_MYY_tag>(ptr) = field<S_MYY_tag>(ptr) * zavg;
+                    },
+                    make_composite<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>(
+                        e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY),
+                    make_composite<pp_tag>(pp));
+                call_kernel(
+                    d.vertex,
+                    [](auto &ptr, auto const &strides, auto const &neighbor_ptr, auto const &neighbor_stride) {
+                        field<pnabla_MXX_tag>(ptr) = sum_neighbors<v2e_tag>(7_c, [](auto &&ptr, auto &&neighbor_ptr) {
+                            return field<zavgS_MXX_tag>(neighbor_ptr) * field<sign_tag>(ptr);
+                        })(ptr, strides, neighbor_ptr, neighbor_stride);
+                        field<pnabla_MYY_tag>(ptr) = sum_neighbors<v2e_tag>(7_c, [](auto &&ptr, auto &&neighbor_ptr) {
+                            return field<zavgS_MYY_tag>(neighbor_ptr) * field<sign_tag>(ptr);
+                        })(ptr, strides, neighbor_ptr, neighbor_stride);
+                    },
+                    make_composite<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag>(
+                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_tag>(sign)),
+                    make_composite<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX, zavgS_MYY));
+                call_kernel(
+                    d.vertex,
+                    [](auto &ptr, auto const &strides) {
+                        field<pnabla_MXX_tag>(ptr) = field<pnabla_MXX_tag>(ptr) / field<vol_tag>(ptr);
+                        field<pnabla_MYY_tag>(ptr) = field<pnabla_MYY_tag>(ptr) / field<vol_tag>(ptr);
+                    },
+                    make_composite<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>(pnabla_MXX, pnabla_MYY, vol));
+            };
+    };
+} // namespace gridtools::next::naive::nabla_impl_
+using gridtools::next::naive::nabla_impl_::nabla;

From b74b9e26e43496eef6a9f9ecff9e75a5a1b4fba6 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Fri, 23 Oct 2020 14:28:42 +0000
Subject: [PATCH 04/24] adapt nabla cuda to code generation

---
 .../include/gridtools/next/cuda_util.hpp      |  11 -
 .../gridtools/next/usid_cuda_helpers.hpp      |  49 ++++
 .../include/gridtools/next/usid_helpers.hpp   |  92 ++++---
 .../gridtools/next/usid_naive_helpers.hpp     |  13 +-
 .../tests/regression/fvm_nabla/CMakeLists.txt |   7 +-
 .../tests/regression/fvm_nabla/driver.cu      |   6 +
 .../tests/regression/fvm_nabla/driver.hpp     |   2 +-
 .../tests/regression/fvm_nabla/nabla_cuda.hpp | 236 +++++-------------
 .../regression/fvm_nabla/nabla_naive.hpp      |  77 +++---
 9 files changed, 234 insertions(+), 259 deletions(-)
 delete mode 100644 cpputil/unstructured/include/gridtools/next/cuda_util.hpp
 create mode 100644 cpputil/unstructured/include/gridtools/next/usid_cuda_helpers.hpp
 create mode 100644 cpputil/unstructured/tests/regression/fvm_nabla/driver.cu

diff --git a/cpputil/unstructured/include/gridtools/next/cuda_util.hpp b/cpputil/unstructured/include/gridtools/next/cuda_util.hpp
deleted file mode 100644
index ddafba4..0000000
--- a/cpputil/unstructured/include/gridtools/next/cuda_util.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma once
-
-#include <tuple>
-
-namespace gridtools::next {
-    inline auto cuda_setup(int N) {
-        int threads_per_block = 32;
-        int blocks = (N + threads_per_block - 1) / threads_per_block;
-        return std::make_tuple(blocks, threads_per_block);
-    }
-} // namespace gridtools::next
diff --git a/cpputil/unstructured/include/gridtools/next/usid_cuda_helpers.hpp b/cpputil/unstructured/include/gridtools/next/usid_cuda_helpers.hpp
new file mode 100644
index 0000000..841911c
--- /dev/null
+++ b/cpputil/unstructured/include/gridtools/next/usid_cuda_helpers.hpp
@@ -0,0 +1,49 @@
+#pragma once
+
+#ifndef __CUDACC__
+#error Tried to compile CUDA code with a regular C++ compiler.
+#endif
+
+#include <gridtools/common/cuda_util.hpp>
+#include <gridtools/common/hymap.hpp>
+#include <gridtools/common/pair.hpp>
+#include <gridtools/common/tuple_util.hpp>
+#include <gridtools/sid/allocator.hpp>
+#include <gridtools/sid/concept.hpp>
+#include <gridtools/storage/gpu.hpp>
+
+#include "unstructured.hpp"
+#include "usid_helpers.hpp"
+
+namespace gridtools::next::cuda {
+    using traits_t = storage::gpu;
+
+    inline auto make_allocator() { return sid::device::make_cached_allocator(&cuda_util::cuda_malloc<char[]>); }
+
+    template <class Kernel, class Ptr, class Strides, class... Neighbors>
+    __global__ void kernel(int h_size, Ptr ptr_holder, Strides strides, Neighbors... neighbors) {
+        auto h = blockIdx.x * blockDim.x + threadIdx.x;
+        if (h >= h_size)
+            return;
+        Kernel()()(sid::shifted(ptr_holder(), device::at_key<dim::h>(strides), h),
+            strides,
+            tuple_util::device::make<pair>(neighbors.first(), neighbors.second)...);
+    }
+
+    template <class Kernel, class Size, class Sid, class... Sids>
+    void call_kernel(Size size, Sid &&fields, Sids &&...neighbor_fields) {
+        int threads_per_block = 32;
+        int blocks = (size + threads_per_block - 1) / threads_per_block;
+        kernel<Kernel><<<blocks, threads_per_block>>>(size,
+            sid::get_origin(fields),
+            sid::get_strides(fields),
+            tuple_util::make<pair>(
+                sid::get_origin(neighbor_fields), at_key<dim::h>(sid::get_strides(neighbor_fields)))...);
+        GT_CUDA_CHECK(cudaGetLastError());
+    }
+
+    template <class Tag, class Ptr>
+    __device__ decltype(auto) field(Ptr const &ptr) {
+        return *device::at_key<Tag>(ptr);
+    }
+} // namespace gridtools::next::cuda
diff --git a/cpputil/unstructured/include/gridtools/next/usid_helpers.hpp b/cpputil/unstructured/include/gridtools/next/usid_helpers.hpp
index 51a5f41..a532236 100644
--- a/cpputil/unstructured/include/gridtools/next/usid_helpers.hpp
+++ b/cpputil/unstructured/include/gridtools/next/usid_helpers.hpp
@@ -1,16 +1,22 @@
 #pragma once
 
+#include <limits>
 #include <type_traits>
+#include <utility>
 
+#include <gridtools/common/defs.hpp>
 #include <gridtools/common/host_device.hpp>
 #include <gridtools/common/hymap.hpp>
+#include <gridtools/common/integral_constant.hpp>
 #include <gridtools/common/utility.hpp>
 #include <gridtools/meta/id.hpp>
 #include <gridtools/sid/composite.hpp>
 #include <gridtools/sid/concept.hpp>
 #include <gridtools/sid/contiguous.hpp>
 #include <gridtools/sid/loop.hpp>
+#include <gridtools/sid/rename_dimensions.hpp>
 
+#include "domain.hpp"
 #include "unstructured.hpp"
 
 namespace gridtools::next {
@@ -19,40 +25,68 @@ namespace gridtools::next {
         return sid::make_contiguous<T>(alloc, hymap::keys<dim::h, dim::k>::values<HSize, KSize>(h_size, k_size));
     }
 
-    template <class Tag, class F, class Init, class N, class G, class HasSkipValues>
-    GT_FUNCTION auto fold_neighbors(F f, Init init, N n, G g, HasSkipValues) {
-        return [=, loop = sid::make_loop<Tag>(n)](
-                   auto &&ptr, auto const &strides, auto &&neighbor_ptr, auto &&neighbor_stride) {
-            using acc_t = std::decay_t<decltype(g(ptr, neighbor_ptr))>;
-            acc_t acc = init(meta::lazy::id<acc_t>());
-            loop([&](auto const &ptr, auto &&) {
-                auto i = *at_key<Tag>(ptr);
-                if constexpr (HasSkipValues::value)
-                    if (i < 0)
-                        return;
-                acc = f(acc, g(ptr, sid::shifted(neighbor_ptr, neighbor_stride, i)));
-            })(wstd::forward<decltype(ptr)>(ptr), strides);
-            return acc;
-        };
+    template <class T,
+        class Tag,
+        int_t N,
+        bool HasSkipValues,
+        class F,
+        class Init,
+        class G,
+        class Ptr,
+        class Strides,
+        class Neighbors>
+    GT_FUNCTION T fold_neighbors(F f, Init init, G g, Ptr &&ptr, Strides &&strides, Neighbors &&neighbors) {
+        T acc = init(meta::lazy::id<T>());
+        sid::make_loop<Tag>(integral_constant<int_t, N>())([&](auto const &ptr, auto &&) {
+            auto i = *host_device::at_key<Tag>(ptr);
+            if constexpr (HasSkipValues)
+                if (i < 0)
+                    return;
+            acc = f(acc, g(ptr, sid::shifted(neighbors.first, neighbors.second, i)));
+        })(wstd::forward<decltype(ptr)>(ptr), strides);
+        return acc;
     }
 
-    template <class Tag>
-    struct sum_neighbors_f {
-        template <class N, class F, class HasSkip = std::true_type>
-        GT_FUNCTION auto operator()(N n, F f, HasSkip has_skip = {}) const {
-            return fold_neighbors<Tag>([](auto x, auto y) { return x + y; },
-                [](auto z) -> typename decltype(z)::type { return {}; },
-                n,
-                f,
-                has_skip);
-        }
-    };
+    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
+    GT_FUNCTION T sum_neighbors(F f, Args &&...args) {
+        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x + y; },
+            [](auto z) -> typename decltype(z)::type { return 0; },
+            f,
+            wstd::forward<Args>(args)...);
+    }
+
+    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
+    GT_FUNCTION T mul_neighbors(F f, Args &&...args) {
+        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x * y; },
+            [](auto z) -> typename decltype(z)::type { return 1; },
+            f,
+            wstd::forward<Args>(args)...);
+    }
 
-    template <class Tag>
-    constexpr sum_neighbors_f<Tag> sum_neighbors = {};
+    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
+    GT_FUNCTION T min_neighbors(F f, Args &&...args) {
+        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x < y ? x : y; },
+            [](auto z) -> typename decltype(z)::type {
+                constexpr auto res = std::numeric_limits<typename decltype(z)::type>::max();
+                return res;
+            },
+            f,
+            wstd::forward<Args>(args)...);
+    }
+
+    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
+    GT_FUNCTION T max_neighbors(F f, Args &&...args) {
+        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x > y ? x : y; },
+            [](auto z) -> typename decltype(z)::type {
+                constexpr auto res = std::numeric_limits<typename decltype(z)::type>::min();
+                return res;
+            },
+            f,
+            wstd::forward<Args>(args)...);
+    }
 
     template <class... Keys>
     constexpr auto make_composite = [](auto &&...sids) {
         return tuple_util::make<sid::composite::keys<Keys...>::template values>(std::forward<decltype(sids)>(sids)...);
     };
-} // namespace gridtools::next
\ No newline at end of file
+} // namespace gridtools::next
diff --git a/cpputil/unstructured/include/gridtools/next/usid_naive_helpers.hpp b/cpputil/unstructured/include/gridtools/next/usid_naive_helpers.hpp
index d5abd98..b949c1b 100644
--- a/cpputil/unstructured/include/gridtools/next/usid_naive_helpers.hpp
+++ b/cpputil/unstructured/include/gridtools/next/usid_naive_helpers.hpp
@@ -2,6 +2,7 @@
 
 #include <memory>
 #include <tuple>
+#include <utility>
 
 #include <gridtools/common/hymap.hpp>
 #include <gridtools/sid/allocator.hpp>
@@ -10,19 +11,19 @@
 #include <gridtools/storage/cpu_ifirst.hpp>
 
 #include "unstructured.hpp"
+#include "usid_helpers.hpp"
 
 namespace gridtools::next::naive {
     using traits_t = storage::cpu_ifirst;
 
     inline auto make_allocator() { return sid::make_cached_allocator(&std::make_unique<char[]>); }
 
-    template <class Size, class Body, class Sid, class... Sids>
-    void call_kernel(Size size, Body &&body, Sid &&fields, Sids &&...neighbor_fields) {
+    template <class Kernel, class Size, class Sid, class... Sids>
+    void call_kernel(Size size, Sid &&fields, Sids &&...neighbor_fields) {
         sid::make_loop<dim::h>(size)(
-            [&body,
-                params = std::tuple_cat(std::make_tuple(sid::get_origin(neighbor_fields)(),
-                    sid::get_stride<dim::h>(sid::get_strides(neighbor_fields)))...)](auto &ptr, auto const &strides) {
-                std::apply(body, std::tuple_cat(std::forward_as_tuple(ptr, strides), params));
+            [params = std::make_tuple(std::make_pair(sid::get_origin(neighbor_fields)(),
+                 sid::get_stride<dim::h>(sid::get_strides(neighbor_fields)))...)](auto &ptr, auto const &strides) {
+                std::apply(Kernel()(), std::tuple_cat(std::forward_as_tuple(ptr, strides), params));
             })(sid::get_origin(fields)(), sid::get_strides(fields));
     }
 
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt b/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt
index 12beb00..7b65cb8 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt
@@ -1,14 +1,9 @@
-function(add_driver_executable target driver_source stencil_header)
-    add_executable(${target} ${driver_source})
-    target_compile_definitions(${target} PRIVATE STENCIL_HEADER=\"${stencil_header}\")
-endfunction()
-
 add_executable(fvm_nabla driver.cc)
 target_link_libraries(fvm_nabla PRIVATE atlas eckit GridTools::gridtools gtnext gtest gtest_main)
 add_test(NAME fvm_nabla COMMAND $<TARGET_FILE:fvm_nabla>)
 
 if(CMAKE_CUDA_COMPILER)
-    add_driver_executable(fvm_nabla_cuda driver.cc nabla_cuda.hpp)
+    add_executable(fvm_nabla_cuda driver.cu)
     target_link_libraries(fvm_nabla_cuda PRIVATE atlas eckit GridTools::gridtools GridTools::stencil_gpu gtnext gtest gtest_main)
     gridtools_setup_target(fvm_nabla_cuda CUDA_ARCH sm_50)
     target_compile_options(fvm_nabla_cuda PRIVATE "-std=c++17")
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/driver.cu b/cpputil/unstructured/tests/regression/fvm_nabla/driver.cu
new file mode 100644
index 0000000..1b05bd2
--- /dev/null
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/driver.cu
@@ -0,0 +1,6 @@
+#include <gtest/gtest.h>
+
+#include "driver.hpp"
+#include "nabla_cuda.hpp"
+
+TEST(FVM, nabla) { driver(nabla); }
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp
index ff0ae10..4e1f8b0 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp
@@ -154,7 +154,7 @@ namespace driver_impl_ {
         auto pnabla_MXX = make_output();
         auto pnabla_MYY = make_output();
 
-        nabla({.vertex = nodes.size(), .edge = edges.size(), .cell = mesh.cells().size(), .k = k},
+        nabla({nodes.size(), edges.size(), mesh.cells().size(), k},
             make_storage_producer(edges_per_node, nodes.edge_connectivity()),
             make_storage_producer(2_c, edges.node_connectivity()))(make_S_MXX(edges),
             make_S_MYY(edges),
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
index 21aee03..77c635e 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
@@ -1,38 +1,6 @@
 #pragma once
-
-#ifndef __CUDACC__
-#error "Tried to compile CUDA code with a regular C++ compiler."
-#endif
-
-#include <gridtools/common/defs.hpp>
-#include <gridtools/common/hymap.hpp>
-#include <gridtools/common/integral_constant.hpp>
-#include <gridtools/sid/allocator.hpp>
-#include <gridtools/sid/composite.hpp>
-#include <gridtools/sid/concept.hpp>
-#include <gridtools/sid/loop.hpp>
-#include <gridtools/sid/rename_dimensions.hpp>
-
-#include <gridtools/next/domain.hpp>
-#include <gridtools/next/tmp_storage.hpp>
-#include <gridtools/next/unstructured.hpp>
-
-#include <gridtools/common/cuda_util.hpp>
-#include <gridtools/next/cuda_util.hpp>
-#include <gridtools/storage/gpu.hpp>
-
-namespace nabla_impl_ {
-    using namespace gridtools;
-    using namespace next;
-
-    template <class Dim, class Sid>
-    auto max_neighbors(Sid const &sid) {
-        static_assert(has_key<sid::upper_bounds_type<Sid>, Dim>());
-        return at_key<Dim>(sid::get_upper_bounds(sid));
-    }
-
-    struct v2e_dim;
-    struct e2v_dim;
+#include <gridtools/next/usid_cuda_helpers.hpp>
+namespace gridtools::next::cuda::nabla_impl_ {
     struct v2e_tag;
     struct e2v_tag;
     struct S_MXX_tag;
@@ -43,138 +11,70 @@ namespace nabla_impl_ {
     struct pnabla_MYY_tag;
     struct vol_tag;
     struct sign_tag;
-
-    template <class Ptr, class Loop, class Strides, class Pp, class PPStride>
-    __global__ void nabla_edge_1(int e_size, Loop loop, Ptr ptr_holder, Strides strides, Pp pp, PPStride pp_stride) {
-        {
-            auto idx = blockIdx.x * blockDim.x + threadIdx.x;
-            if (idx >= e_size)
-                return;
-            auto ptr = ptr_holder();
-            sid::shift(ptr, device::at_key<dim::h>(strides), idx);
-            double acc = 0;
-            loop([&acc, pp_stride, pp = pp()](auto const &ptr, auto &&) {
-                acc += *sid::shifted(pp, pp_stride, *device::at_key<e2v_tag>(ptr));
-            })(ptr, strides);
-            acc *= 0.5;
-            *device::at_key<zavgS_MXX_tag>(ptr) = *device::at_key<S_MXX_tag>(ptr) * acc;
-            *device::at_key<zavgS_MYY_tag>(ptr) = *device::at_key<S_MYY_tag>(ptr) * acc;
+    struct pp_tag;
+    struct kernel_0 {
+        GT_FUNCTION auto operator()() const {
+            return [](auto &&ptr, auto &&strides, auto &&neighbors) {
+                auto zavg = 0.5 * sum_neighbors<double, e2v_tag, 2, false>(
+                                      [](auto &&, auto &&n) { return field<pp_tag>(n); }, ptr, strides, neighbors);
+                field<zavgS_MXX_tag>(ptr) = field<S_MXX_tag>(ptr) * zavg;
+                field<zavgS_MYY_tag>(ptr) = field<S_MYY_tag>(ptr) * zavg;
+            };
         }
-    }
-
-    template <class Ptr,
-        class Loop,
-        class Strides,
-        class ZavgS_MXX,
-        class ZavgS_MXXStride,
-        class ZavgS_MYY,
-        class ZavgS_MYYStride>
-    __global__ void nabla_vertex_2(int v_size,
-        Loop loop,
-        Ptr ptr_holder,
-        Strides strides,
-        ZavgS_MXX zavgS_MXX,
-        ZavgS_MXXStride zavgS_MXX_stride,
-        ZavgS_MYY zavgS_MYY,
-        ZavgS_MYYStride zavgS_MYY_stride) {
-        auto idx = blockIdx.x * blockDim.x + threadIdx.x;
-        if (idx >= v_size)
-            return;
-        auto ptr = ptr_holder();
-        sid::shift(ptr, gridtools::device::at_key<dim::h>(strides), idx);
-        double acc = 0;
-        loop([&acc, zavgS_MXX = zavgS_MXX(), zavgS_MXX_stride](auto const &ptr, auto &&) {
-            auto i = *device::at_key<v2e_tag>(ptr);
-            if (i < 0)
-                return;
-            acc += *sid::shifted(zavgS_MXX, zavgS_MXX_stride, i) * *device::at_key<sign_tag>(ptr);
-        })(ptr, strides);
-        *at_key<pnabla_MXX_tag>(ptr) = acc;
-        acc = 0;
-        loop([&acc, zavgS_MYY = zavgS_MYY(), zavgS_MYY_stride](auto const &ptr, auto &&) {
-            auto i = *device::at_key<v2e_tag>(ptr);
-            if (i < 0)
-                return;
-            acc += *sid::shifted(zavgS_MYY, zavgS_MYY_stride, i) * *device::at_key<sign_tag>(ptr);
-        })(ptr, strides);
-        *at_key<pnabla_MYY_tag>(ptr) = acc;
-    }
-
-    template <class Ptr, class Strides>
-    __global__ void nabla_vertex_4(int v_size, Ptr ptr_holder, Strides strides) {
-        auto idx = blockIdx.x * blockDim.x + threadIdx.x;
-        if (idx >= v_size)
-            return;
-        auto ptr = ptr_holder();
-        sid::shift(ptr, device::at_key<dim::h>(strides), idx);
-        *device::at_key<pnabla_MXX_tag>(ptr) /= *device::at_key<vol_tag>(ptr);
-        *device::at_key<pnabla_MYY_tag>(ptr) /= *device::at_key<vol_tag>(ptr);
-    }
-
-    template <class V2E, class E2V>
-    auto nabla(domain d, V2E &&v2e, E2V &&e2v) {
-        static_assert(is_sid<decltype(std::forward<V2E>(v2e)(storage::gpu()))>());
-        static_assert(is_sid<decltype(std::forward<E2V>(e2v)(storage::gpu()))>());
-        return [d = std::move(d),
-                   v2e = sid::rename_dimensions<integral_constant<int_t, 1>, v2e_dim>(
-                       std::forward<V2E>(v2e)(storage::gpu())),
-                   e2v = sid::rename_dimensions<integral_constant<int_t, 1>, e2v_dim>(
-                       std::forward<E2V>(e2v)(storage::gpu()))](auto &&S_MXX,
-                   auto &&S_MYY,
-                   auto &&pp,
-                   auto &&pnabla_MXX,
-                   auto &&pnabla_MYY,
-                   auto &&vol,
-                   auto &&sign) {
-            static_assert(is_sid<decltype(S_MXX)>());
-            static_assert(is_sid<decltype(S_MYY)>());
-            static_assert(is_sid<decltype(pp)>());
-            static_assert(is_sid<decltype(pnabla_MXX)>());
-            static_assert(is_sid<decltype(pnabla_MYY)>());
-            static_assert(is_sid<decltype(vol)>());
-            static_assert(is_sid<decltype(sign)>());
-
-            // allocate temporary field storage
-            auto alloc = sid::device::make_cached_allocator(&cuda_util::cuda_malloc<char[]>);
-            auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
-            auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
-            {
-                auto fields = tuple_util::make<
-                    sid::composite::keys<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>::values>(
-                    e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY);
-                auto [blocks, threads_per_block] = cuda_setup(d.edge);
-                nabla_edge_1<<<blocks, threads_per_block>>>(d.edge,
-                    sid::make_loop<e2v_dim>(max_neighbors<e2v_dim>(e2v)),
-                    sid::get_origin(fields),
-                    sid::get_strides(fields),
-                    sid::get_origin(pp),
-                    at_key<dim::h>(sid::get_strides(pp)));
-                GT_CUDA_CHECK(cudaGetLastError());
-            }
-            {
-                auto fields =
-                    tuple_util::make<sid::composite::keys<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag>::values>(
-                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_dim>(sign));
-                auto [blocks, threads_per_block] = cuda_setup(d.vertex);
-                nabla_vertex_2<<<blocks, threads_per_block>>>(d.vertex,
-                    sid::make_loop<v2e_dim>(max_neighbors<v2e_dim>(v2e)),
-                    sid::get_origin(fields),
-                    sid::get_strides(fields),
-                    sid::get_origin(zavgS_MXX),
-                    at_key<dim::h>(sid::get_strides(zavgS_MXX)),
-                    sid::get_origin(zavgS_MYY),
-                    at_key<dim::h>(sid::get_strides(zavgS_MYY)));
-                GT_CUDA_CHECK(cudaGetLastError());
-            }
-            {
-                auto fields = tuple_util::make<sid::composite::keys<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>::values>(
-                    pnabla_MXX, pnabla_MYY, vol);
-                auto [blocks, threads_per_block] = cuda_setup(d.vertex);
-                nabla_vertex_4<<<blocks, threads_per_block>>>(
-                    d.vertex, sid::get_origin(fields), sid::get_strides(fields));
-                GT_CUDA_CHECK(cudaGetLastError());
-            }
-        };
-    }
-} // namespace nabla_impl_
-using nabla_impl_::nabla;
+    };
+    struct kernel_1 {
+        GT_FUNCTION auto operator()() const {
+            return [](auto &&ptr, auto &&strides, auto &&neighbors) {
+                field<pnabla_MXX_tag>(ptr) = sum_neighbors<double, v2e_tag, 7>(
+                    [](auto &&p, auto &&n) { return field<zavgS_MXX_tag>(n) * field<sign_tag>(p); },
+                    ptr,
+                    strides,
+                    neighbors);
+                field<pnabla_MYY_tag>(ptr) = sum_neighbors<double, v2e_tag, 7>(
+                    [](auto &&p, auto &&n) { return field<zavgS_MYY_tag>(n) * field<sign_tag>(p); },
+                    ptr,
+                    strides,
+                    neighbors);
+            };
+        }
+    };
+    struct kernel_2 {
+        GT_FUNCTION auto operator()() const {
+            return [](auto &&ptr, auto &&strides) {
+                field<pnabla_MXX_tag>(ptr) = field<pnabla_MXX_tag>(ptr) / field<vol_tag>(ptr);
+                field<pnabla_MYY_tag>(ptr) = field<pnabla_MYY_tag>(ptr) / field<vol_tag>(ptr);
+            };
+        }
+    };
+    inline constexpr auto nabla = [](domain d, auto &&v2e, auto &&e2v) {
+        static_assert(is_sid<decltype(v2e(traits_t()))>());
+        static_assert(is_sid<decltype(e2v(traits_t()))>());
+        return
+            [d = std::move(d),
+                v2e = sid::rename_dimensions<dim::n, v2e_tag>(std::forward<decltype(v2e)>(v2e)(traits_t())),
+                e2v = sid::rename_dimensions<dim::n, e2v_tag>(std::forward<decltype(e2v)>(e2v)(traits_t()))](
+                auto &&S_MXX, auto &&S_MYY, auto &&pp, auto &&pnabla_MXX, auto &&pnabla_MYY, auto &&vol, auto &&sign) {
+                static_assert(is_sid<decltype(S_MXX)>());
+                static_assert(is_sid<decltype(S_MYY)>());
+                static_assert(is_sid<decltype(pp)>());
+                static_assert(is_sid<decltype(pnabla_MXX)>());
+                static_assert(is_sid<decltype(pnabla_MYY)>());
+                static_assert(is_sid<decltype(vol)>());
+                static_assert(is_sid<decltype(sign)>());
+                auto alloc = make_allocator();
+                auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
+                auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
+                call_kernel<kernel_0>(d.edge,
+                    make_composite<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>(
+                        e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY),
+                    make_composite<pp_tag>(pp));
+                call_kernel<kernel_1>(d.vertex,
+                    make_composite<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag>(
+                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_tag>(sign)),
+                    make_composite<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX, zavgS_MYY));
+                call_kernel<kernel_2>(
+                    d.vertex, make_composite<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>(pnabla_MXX, pnabla_MYY, vol));
+            };
+    };
+} // namespace gridtools::next::cuda::nabla_impl_
+using gridtools::next::cuda::nabla_impl_::nabla;
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
index 2d08d07..9170e81 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
@@ -1,17 +1,6 @@
 #pragma once
-
-#include <utility>
-
-#include <gridtools/common/integral_constant.hpp>
-#include <gridtools/next/domain.hpp>
-#include <gridtools/next/unstructured.hpp>
-#include <gridtools/next/usid_helpers.hpp>
 #include <gridtools/next/usid_naive_helpers.hpp>
-#include <gridtools/sid/concept.hpp>
-#include <gridtools/sid/rename_dimensions.hpp>
-
 namespace gridtools::next::naive::nabla_impl_ {
-    using namespace literals;
     struct v2e_tag;
     struct e2v_tag;
     struct S_MXX_tag;
@@ -23,7 +12,41 @@ namespace gridtools::next::naive::nabla_impl_ {
     struct vol_tag;
     struct sign_tag;
     struct pp_tag;
-    constexpr auto nabla = [](domain d, auto &&v2e, auto &&e2v) {
+    struct kernel_0 {
+        GT_FUNCTION auto operator()() const {
+            return [](auto &&ptr, auto &&strides, auto &&neighbors) {
+                auto zavg = 0.5 * sum_neighbors<double, e2v_tag, 2, false>(
+                                      [](auto &&, auto &&n) { return field<pp_tag>(n); }, ptr, strides, neighbors);
+                field<zavgS_MXX_tag>(ptr) = field<S_MXX_tag>(ptr) * zavg;
+                field<zavgS_MYY_tag>(ptr) = field<S_MYY_tag>(ptr) * zavg;
+            };
+        }
+    };
+    struct kernel_1 {
+        GT_FUNCTION auto operator()() const {
+            return [](auto &&ptr, auto &&strides, auto &&neighbors) {
+                field<pnabla_MXX_tag>(ptr) = sum_neighbors<double, v2e_tag, 7>(
+                    [](auto &&p, auto &&n) { return field<zavgS_MXX_tag>(n) * field<sign_tag>(p); },
+                    ptr,
+                    strides,
+                    neighbors);
+                field<pnabla_MYY_tag>(ptr) = sum_neighbors<double, v2e_tag, 7>(
+                    [](auto &&p, auto &&n) { return field<zavgS_MYY_tag>(n) * field<sign_tag>(p); },
+                    ptr,
+                    strides,
+                    neighbors);
+            };
+        }
+    };
+    struct kernel_2 {
+        GT_FUNCTION auto operator()() const {
+            return [](auto &&ptr, auto &&strides) {
+                field<pnabla_MXX_tag>(ptr) = field<pnabla_MXX_tag>(ptr) / field<vol_tag>(ptr);
+                field<pnabla_MYY_tag>(ptr) = field<pnabla_MYY_tag>(ptr) / field<vol_tag>(ptr);
+            };
+        }
+    };
+    inline constexpr auto nabla = [](domain d, auto &&v2e, auto &&e2v) {
         static_assert(is_sid<decltype(v2e(traits_t()))>());
         static_assert(is_sid<decltype(e2v(traits_t()))>());
         return
@@ -41,38 +64,16 @@ namespace gridtools::next::naive::nabla_impl_ {
                 auto alloc = make_allocator();
                 auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
                 auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
-                call_kernel(
-                    d.edge,
-                    [](auto &ptr, auto const &strides, auto const &neighbor_ptr, auto const &neighbor_stride) {
-                        auto zavg = 0.5 * sum_neighbors<e2v_tag>(2_c, [](auto &&, auto &&n) {
-                            return field<pp_tag>(n);
-                        })(ptr, strides, neighbor_ptr, neighbor_stride);
-                        field<zavgS_MXX_tag>(ptr) = field<S_MXX_tag>(ptr) * zavg;
-                        field<zavgS_MYY_tag>(ptr) = field<S_MYY_tag>(ptr) * zavg;
-                    },
+                call_kernel<kernel_0>(d.edge,
                     make_composite<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>(
                         e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY),
                     make_composite<pp_tag>(pp));
-                call_kernel(
-                    d.vertex,
-                    [](auto &ptr, auto const &strides, auto const &neighbor_ptr, auto const &neighbor_stride) {
-                        field<pnabla_MXX_tag>(ptr) = sum_neighbors<v2e_tag>(7_c, [](auto &&ptr, auto &&neighbor_ptr) {
-                            return field<zavgS_MXX_tag>(neighbor_ptr) * field<sign_tag>(ptr);
-                        })(ptr, strides, neighbor_ptr, neighbor_stride);
-                        field<pnabla_MYY_tag>(ptr) = sum_neighbors<v2e_tag>(7_c, [](auto &&ptr, auto &&neighbor_ptr) {
-                            return field<zavgS_MYY_tag>(neighbor_ptr) * field<sign_tag>(ptr);
-                        })(ptr, strides, neighbor_ptr, neighbor_stride);
-                    },
+                call_kernel<kernel_1>(d.vertex,
                     make_composite<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag>(
                         v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_tag>(sign)),
                     make_composite<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX, zavgS_MYY));
-                call_kernel(
-                    d.vertex,
-                    [](auto &ptr, auto const &strides) {
-                        field<pnabla_MXX_tag>(ptr) = field<pnabla_MXX_tag>(ptr) / field<vol_tag>(ptr);
-                        field<pnabla_MYY_tag>(ptr) = field<pnabla_MYY_tag>(ptr) / field<vol_tag>(ptr);
-                    },
-                    make_composite<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>(pnabla_MXX, pnabla_MYY, vol));
+                call_kernel<kernel_2>(
+                    d.vertex, make_composite<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>(pnabla_MXX, pnabla_MYY, vol));
             };
     };
 } // namespace gridtools::next::naive::nabla_impl_

From 0f2cc53b032ce6f73fb273b768a76849ba88f461 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Fri, 23 Oct 2020 14:31:43 +0000
Subject: [PATCH 05/24] remove unused

---
 cpputil/unstructured/tests/include/util/CMakeLists.txt | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 cpputil/unstructured/tests/include/util/CMakeLists.txt

diff --git a/cpputil/unstructured/tests/include/util/CMakeLists.txt b/cpputil/unstructured/tests/include/util/CMakeLists.txt
deleted file mode 100644
index e69de29..0000000

From 434f545f008648665c3ab03f019151a36c9b8de6 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Fri, 23 Oct 2020 17:43:29 +0000
Subject: [PATCH 06/24] use sid::composite::make

---
 .../include/gridtools/next/usid_helpers.hpp          |  5 -----
 .../tests/regression/fvm_nabla/nabla_cuda.hpp        | 12 ++++++------
 .../tests/regression/fvm_nabla/nabla_naive.hpp       | 12 ++++++------
 3 files changed, 12 insertions(+), 17 deletions(-)

diff --git a/cpputil/unstructured/include/gridtools/next/usid_helpers.hpp b/cpputil/unstructured/include/gridtools/next/usid_helpers.hpp
index a532236..3220c32 100644
--- a/cpputil/unstructured/include/gridtools/next/usid_helpers.hpp
+++ b/cpputil/unstructured/include/gridtools/next/usid_helpers.hpp
@@ -84,9 +84,4 @@ namespace gridtools::next {
             f,
             wstd::forward<Args>(args)...);
     }
-
-    template <class... Keys>
-    constexpr auto make_composite = [](auto &&...sids) {
-        return tuple_util::make<sid::composite::keys<Keys...>::template values>(std::forward<decltype(sids)>(sids)...);
-    };
 } // namespace gridtools::next
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
index 77c635e..5a68ba2 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
@@ -65,15 +65,15 @@ namespace gridtools::next::cuda::nabla_impl_ {
                 auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
                 auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
                 call_kernel<kernel_0>(d.edge,
-                    make_composite<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>(
+                    sid::composite::make<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>(
                         e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY),
-                    make_composite<pp_tag>(pp));
+                    sid::composite::make<pp_tag>(pp));
                 call_kernel<kernel_1>(d.vertex,
-                    make_composite<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag>(
+                    sid::composite::make<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag>(
                         v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_tag>(sign)),
-                    make_composite<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX, zavgS_MYY));
-                call_kernel<kernel_2>(
-                    d.vertex, make_composite<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>(pnabla_MXX, pnabla_MYY, vol));
+                    sid::composite::make<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX, zavgS_MYY));
+                call_kernel<kernel_2>(d.vertex,
+                    sid::composite::make<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>(pnabla_MXX, pnabla_MYY, vol));
             };
     };
 } // namespace gridtools::next::cuda::nabla_impl_
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
index 9170e81..6fd1d6a 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
@@ -65,15 +65,15 @@ namespace gridtools::next::naive::nabla_impl_ {
                 auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
                 auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
                 call_kernel<kernel_0>(d.edge,
-                    make_composite<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>(
+                    sid::composite::make<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>(
                         e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY),
-                    make_composite<pp_tag>(pp));
+                    sid::composite::make<pp_tag>(pp));
                 call_kernel<kernel_1>(d.vertex,
-                    make_composite<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag>(
+                    sid::composite::make<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag>(
                         v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_tag>(sign)),
-                    make_composite<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX, zavgS_MYY));
-                call_kernel<kernel_2>(
-                    d.vertex, make_composite<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>(pnabla_MXX, pnabla_MYY, vol));
+                    sid::composite::make<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX, zavgS_MYY));
+                call_kernel<kernel_2>(d.vertex,
+                    sid::composite::make<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>(pnabla_MXX, pnabla_MYY, vol));
             };
     };
 } // namespace gridtools::next::naive::nabla_impl_

From 6b89c608026d57350adab8490ec62f77978afa6a Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 26 Oct 2020 12:13:04 +0000
Subject: [PATCH 07/24] add cpputil/usid

---
 .../tests/regression/fvm_nabla/driver.hpp     |  30 +--
 .../tests/regression/fvm_nabla/nabla_cuda.hpp |  12 +-
 .../regression/fvm_nabla/nabla_naive.hpp      |  40 ++--
 cpputil/usid/.clang-format                    |  60 ++++++
 cpputil/usid/CMakeLists.txt                   |  53 ++++++
 cpputil/usid/include/gridtools/usid/atlas.hpp |  19 ++
 .../include/gridtools/usid/cuda_helpers.hpp   |  52 ++++++
 cpputil/usid/include/gridtools/usid/dim.hpp   |  16 ++
 .../usid/include/gridtools/usid/domain.hpp    |  10 +
 .../usid/include/gridtools/usid/helpers.hpp   |  88 +++++++++
 .../include/gridtools/usid/naive_helpers.hpp  |  38 ++++
 .../usid/include/tests/fvm_nabla_driver.hpp   | 176 ++++++++++++++++++
 cpputil/usid/tests/CMakeLists.txt             |  11 ++
 cpputil/usid/tests/nabla_cuda.cu              |   5 +
 cpputil/usid/tests/nabla_cuda.hpp             |  82 ++++++++
 cpputil/usid/tests/nabla_naive.cpp            |   5 +
 cpputil/usid/tests/nabla_naive.hpp            |  66 +++++++
 17 files changed, 711 insertions(+), 52 deletions(-)
 create mode 100644 cpputil/usid/.clang-format
 create mode 100644 cpputil/usid/CMakeLists.txt
 create mode 100644 cpputil/usid/include/gridtools/usid/atlas.hpp
 create mode 100644 cpputil/usid/include/gridtools/usid/cuda_helpers.hpp
 create mode 100644 cpputil/usid/include/gridtools/usid/dim.hpp
 create mode 100644 cpputil/usid/include/gridtools/usid/domain.hpp
 create mode 100644 cpputil/usid/include/gridtools/usid/helpers.hpp
 create mode 100644 cpputil/usid/include/gridtools/usid/naive_helpers.hpp
 create mode 100644 cpputil/usid/include/tests/fvm_nabla_driver.hpp
 create mode 100644 cpputil/usid/tests/CMakeLists.txt
 create mode 100644 cpputil/usid/tests/nabla_cuda.cu
 create mode 100644 cpputil/usid/tests/nabla_cuda.hpp
 create mode 100644 cpputil/usid/tests/nabla_naive.cpp
 create mode 100644 cpputil/usid/tests/nabla_naive.hpp

diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp
index 4e1f8b0..f2f37a5 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp
@@ -23,12 +23,12 @@
 
 #ifdef __CUDACC__
 #include <gridtools/storage/gpu.hpp>
-namespace {
+namespace driver_impl_ {
     using storage_traits_t = gridtools::storage::gpu;
 }
 #else
 #include <gridtools/storage/cpu_ifirst.hpp>
-namespace {
+namespace driver_impl_ {
     using storage_traits_t = gridtools::storage::cpu_ifirst;
 }
 #endif
@@ -36,9 +36,9 @@ namespace {
 namespace driver_impl_ {
     using namespace gridtools::literals;
 
-    constexpr auto storage_builder = gridtools::storage::builder<storage_traits_t>;
+    inline constexpr auto storage_builder = gridtools::storage::builder<storage_traits_t>;
 
-    auto make_mesh() {
+    inline auto make_mesh() {
         using namespace atlas;
         using param_t = StructuredMeshGenerator::Parameters;
         auto res = StructuredMeshGenerator(param_t("triangulate", true) | param_t("angle", -1.)).generate(Grid("O32"));
@@ -50,20 +50,20 @@ namespace driver_impl_ {
         return res;
     }
 
-    const double rpi = 2 * std::asin(1);
-    const double radius = 6371.22e+03;
-    const double deg2rad = 2 * rpi / 360;
-    constexpr int MXX = 0;
-    constexpr int MYY = 1;
-    constexpr auto edges_per_node = 7_c;
+    inline const double rpi = 2 * std::asin(1);
+    inline const double radius = 6371.22e+03;
+    inline const double deg2rad = 2 * rpi / 360;
+    inline constexpr int MXX = 0;
+    inline constexpr int MYY = 1;
+    inline constexpr auto edges_per_node = 7_c;
 
-    auto make_vol(atlas::mesh::Nodes const &nodes) {
+    inline auto make_vol(atlas::mesh::Nodes const &nodes) {
         auto dual_volumes = atlas::array::make_view<double, 1>(nodes.field("dual_volumes"));
         auto init = [&](int n) { return dual_volumes(n) * (std::pow(deg2rad, 2) * std::pow(radius, 2)); };
         return storage_builder.type<double>().dimensions(nodes.size()).initializer(init).build();
     }
 
-    auto make_sign(atlas::Mesh const &mesh) {
+    inline auto make_sign(atlas::Mesh const &mesh) {
         auto &&edges = mesh.edges();
         auto &&nodes = mesh.nodes();
         auto &&n2e = nodes.edge_connectivity();
@@ -86,7 +86,7 @@ namespace driver_impl_ {
             .build();
     }
 
-    auto make_S_MXX(atlas::mesh::Edges const &edges) {
+    inline auto make_S_MXX(atlas::mesh::Edges const &edges) {
         auto dual_normals = atlas::array::make_view<double, 2>(edges.field("dual_normals"));
         return storage_builder.type<double>()
             .dimensions(edges.size())
@@ -94,7 +94,7 @@ namespace driver_impl_ {
             .build();
     }
 
-    auto make_S_MYY(atlas::mesh::Edges const &edges) {
+    inline auto make_S_MYY(atlas::mesh::Edges const &edges) {
         auto dual_normals = atlas::array::make_view<double, 2>(edges.field("dual_normals"));
         return storage_builder.type<double>()
             .dimensions(edges.size())
@@ -103,7 +103,7 @@ namespace driver_impl_ {
     }
 
     // TODO ask Christian for a proper name for this input data
-    auto make_pp(atlas::mesh::Nodes const &nodes) {
+    inline auto make_pp(atlas::mesh::Nodes const &nodes) {
         static const double zh0 = 2000;
         static const double zrad = 3 * rpi / 4 * radius;
         static const double zeta = rpi / 16 * radius;
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
index 5a68ba2..d7a00e6 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
@@ -35,12 +35,6 @@ namespace gridtools::next::cuda::nabla_impl_ {
                     ptr,
                     strides,
                     neighbors);
-            };
-        }
-    };
-    struct kernel_2 {
-        GT_FUNCTION auto operator()() const {
-            return [](auto &&ptr, auto &&strides) {
                 field<pnabla_MXX_tag>(ptr) = field<pnabla_MXX_tag>(ptr) / field<vol_tag>(ptr);
                 field<pnabla_MYY_tag>(ptr) = field<pnabla_MYY_tag>(ptr) / field<vol_tag>(ptr);
             };
@@ -69,11 +63,9 @@ namespace gridtools::next::cuda::nabla_impl_ {
                         e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY),
                     sid::composite::make<pp_tag>(pp));
                 call_kernel<kernel_1>(d.vertex,
-                    sid::composite::make<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag>(
-                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_tag>(sign)),
+                    sid::composite::make<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag, vol_tag>(
+                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_tag>(sign), vol),
                     sid::composite::make<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX, zavgS_MYY));
-                call_kernel<kernel_2>(d.vertex,
-                    sid::composite::make<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>(pnabla_MXX, pnabla_MYY, vol));
             };
     };
 } // namespace gridtools::next::cuda::nabla_impl_
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
index 6fd1d6a..c8742da 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
@@ -14,35 +14,23 @@ namespace gridtools::next::naive::nabla_impl_ {
     struct pp_tag;
     struct kernel_0 {
         GT_FUNCTION auto operator()() const {
-            return [](auto &&ptr, auto &&strides, auto &&neighbors) {
+            return [](auto &&e, auto &&strides, auto &&v) {
                 auto zavg = 0.5 * sum_neighbors<double, e2v_tag, 2, false>(
-                                      [](auto &&, auto &&n) { return field<pp_tag>(n); }, ptr, strides, neighbors);
-                field<zavgS_MXX_tag>(ptr) = field<S_MXX_tag>(ptr) * zavg;
-                field<zavgS_MYY_tag>(ptr) = field<S_MYY_tag>(ptr) * zavg;
+                                      [](auto &&e, auto &&v) { return field<pp_tag>(v); }, e, strides, v);
+                field<zavgS_MXX_tag>(e) = field<S_MXX_tag>(e) * zavg;
+                field<zavgS_MYY_tag>(e) = field<S_MYY_tag>(e) * zavg;
             };
         }
     };
     struct kernel_1 {
         GT_FUNCTION auto operator()() const {
-            return [](auto &&ptr, auto &&strides, auto &&neighbors) {
-                field<pnabla_MXX_tag>(ptr) = sum_neighbors<double, v2e_tag, 7>(
-                    [](auto &&p, auto &&n) { return field<zavgS_MXX_tag>(n) * field<sign_tag>(p); },
-                    ptr,
-                    strides,
-                    neighbors);
-                field<pnabla_MYY_tag>(ptr) = sum_neighbors<double, v2e_tag, 7>(
-                    [](auto &&p, auto &&n) { return field<zavgS_MYY_tag>(n) * field<sign_tag>(p); },
-                    ptr,
-                    strides,
-                    neighbors);
-            };
-        }
-    };
-    struct kernel_2 {
-        GT_FUNCTION auto operator()() const {
-            return [](auto &&ptr, auto &&strides) {
-                field<pnabla_MXX_tag>(ptr) = field<pnabla_MXX_tag>(ptr) / field<vol_tag>(ptr);
-                field<pnabla_MYY_tag>(ptr) = field<pnabla_MYY_tag>(ptr) / field<vol_tag>(ptr);
+            return [](auto &&v, auto &&strides, auto &&e) {
+                field<pnabla_MXX_tag>(v) = sum_neighbors<double, v2e_tag, 7>(
+                    [](auto &&v, auto &&e) { return field<zavgS_MXX_tag>(e) * field<sign_tag>(v); }, v, strides, e);
+                field<pnabla_MYY_tag>(v) = sum_neighbors<double, v2e_tag, 7>(
+                    [](auto &&v, auto &&e) { return field<zavgS_MYY_tag>(e) * field<sign_tag>(v); }, v, strides, e);
+                field<pnabla_MXX_tag>(v) = field<pnabla_MXX_tag>(v) / field<vol_tag>(v);
+                field<pnabla_MYY_tag>(v) = field<pnabla_MYY_tag>(v) / field<vol_tag>(v);
             };
         }
     };
@@ -69,11 +57,9 @@ namespace gridtools::next::naive::nabla_impl_ {
                         e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY),
                     sid::composite::make<pp_tag>(pp));
                 call_kernel<kernel_1>(d.vertex,
-                    sid::composite::make<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag>(
-                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_tag>(sign)),
+                    sid::composite::make<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag, vol_tag>(
+                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_tag>(sign), vol),
                     sid::composite::make<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX, zavgS_MYY));
-                call_kernel<kernel_2>(d.vertex,
-                    sid::composite::make<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>(pnabla_MXX, pnabla_MYY, vol));
             };
     };
 } // namespace gridtools::next::naive::nabla_impl_
diff --git a/cpputil/usid/.clang-format b/cpputil/usid/.clang-format
new file mode 100644
index 0000000..09cc831
--- /dev/null
+++ b/cpputil/usid/.clang-format
@@ -0,0 +1,60 @@
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -2
+ConstructorInitializerIndentWidth: 4
+#AlignEscapedNewlinesLeft: false
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AlwaysBreakTemplateDeclarations: true
+AlwaysBreakBeforeMultilineStrings: false
+BreakBeforeBinaryOperators: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BinPackParameters: false
+BinPackArguments: false
+ColumnLimit:     120
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+DerivePointerAlignment: false
+ExperimentalAutoDetectBinPacking: false
+IndentCaseLabels: false
+IndentWrappedFunctionNames: false
+IndentFunctionDeclarationAfterType: false
+MaxEmptyLinesToKeep: 1
+KeepEmptyLinesAtTheStartOfBlocks: true
+NamespaceIndentation: All
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakString: 1000
+PenaltyBreakFirstLessLess: 120
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Right
+SpacesBeforeTrailingComments: 1
+Cpp11BracedListStyle: true
+Standard:        Cpp11
+IndentWidth:     4
+TabWidth:        8
+UseTab:          Never
+BreakBeforeBraces: Attach
+SpacesInParentheses: false
+SpacesInAngles:  false
+SpaceInEmptyParentheses: false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: true
+SpaceBeforeAssignmentOperators: true
+ContinuationIndentWidth: 4
+CommentPragmas:  '*'
+ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
+SpaceBeforeParens: ControlStatements
+DisableFormat:   false
+AlignAfterOpenBracket: false
+AlignEscapedNewlinesLeft: true
+...
+
diff --git a/cpputil/usid/CMakeLists.txt b/cpputil/usid/CMakeLists.txt
new file mode 100644
index 0000000..0e001dc
--- /dev/null
+++ b/cpputil/usid/CMakeLists.txt
@@ -0,0 +1,53 @@
+cmake_minimum_required(VERSION 3.14.5)
+project(usid LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+
+add_compile_options(-Wall)
+
+include(FetchContent)
+FetchContent_Declare(GridTools
+    GIT_REPOSITORY https://github.com/GridTools/gridtools.git
+    GIT_TAG        master
+)
+FetchContent_MakeAvailable(GridTools)
+
+add_library(usid_naive_helper INTERFACE)
+target_include_directories(usid_naive_helper INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+target_link_libraries(usid_naive_helper INTERFACE GridTools::gridtools)
+
+include(CheckLanguage)
+check_language(CUDA)
+if(CMAKE_CUDA_COMPILER)
+    enable_language(CUDA)
+
+    add_library(usid_cuda_helper INTERFACE)
+    target_include_directories(usid_cuda_helper INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+    target_link_libraries(usid_cuda_helper INTERFACE GridTools::gridtools GridTools::stencil_gpu)
+endif()
+
+set(BUILD_SHARED_LIBS OFF)
+
+FetchContent_Declare(GoogleTest
+    GIT_REPOSITORY https://github.com/google/googletest.git
+    GIT_TAG        release-1.10.0
+)
+FetchContent_MakeAvailable(GoogleTest)
+
+find_package(eckit REQUIRED)
+find_package(Atlas REQUIRED)
+
+add_library(fvm_nabla_driver INTERFACE)
+target_include_directories(fvm_nabla_driver INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+target_link_libraries(fvm_nabla_driver INTERFACE atlas eckit GridTools::gridtools gtest)
+if(CMAKE_CUDA_COMPILER)
+    target_link_libraries(fvm_nabla_driver INTERFACE GridTools::stencil_gpu)
+endif()
+
+
+if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
+    include(CTest)
+    if(BUILD_TESTING)
+        add_subdirectory(tests)
+    endif()
+endif()
diff --git a/cpputil/usid/include/gridtools/usid/atlas.hpp b/cpputil/usid/include/gridtools/usid/atlas.hpp
new file mode 100644
index 0000000..ca5e7c8
--- /dev/null
+++ b/cpputil/usid/include/gridtools/usid/atlas.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <atlas/mesh/Connectivity.h>
+
+#include <gridtools/storage/builder.hpp>
+
+namespace atlas::mesh {
+template <class Connectivity, class MaxNeighbors>
+auto make_storage_producer(MaxNeighbors max_neighbors,
+                           Connectivity const &src) {
+  return [&src, max_neighbors](auto traits) {
+    return gridtools::storage::builder<decltype(traits)>
+            .template type<int>()
+            .dimensions(src.rows(), max_neighbors)
+            .initializer([&src](auto row, auto col) { return col < src.cols(row) ? src(row, col) : -1; })
+            .build();
+  };
+}
+} // namespace atlas::mesh
diff --git a/cpputil/usid/include/gridtools/usid/cuda_helpers.hpp b/cpputil/usid/include/gridtools/usid/cuda_helpers.hpp
new file mode 100644
index 0000000..7861453
--- /dev/null
+++ b/cpputil/usid/include/gridtools/usid/cuda_helpers.hpp
@@ -0,0 +1,52 @@
+#pragma once
+
+#ifndef __CUDACC__
+#error Tried to compile CUDA code with a regular C++ compiler.
+#endif
+
+#include <gridtools/common/cuda_util.hpp>
+#include <gridtools/common/hymap.hpp>
+#include <gridtools/common/pair.hpp>
+#include <gridtools/common/tuple_util.hpp>
+#include <gridtools/sid/allocator.hpp>
+#include <gridtools/sid/concept.hpp>
+#include <gridtools/storage/gpu.hpp>
+
+#include "dim.hpp"
+#include "helpers.hpp"
+
+namespace gridtools::usid::cuda {
+using traits_t = storage::gpu;
+
+inline auto make_allocator() {
+  return sid::device::make_cached_allocator(&cuda_util::cuda_malloc<char[]>);
+}
+
+template <class Kernel, class Ptr, class Strides, class... Neighbors>
+__global__ void kernel(int h_size, Ptr ptr_holder, Strides strides,
+                       Neighbors... neighbors) {
+  auto h = blockIdx.x * blockDim.x + threadIdx.x;
+  if (h >= h_size)
+    return;
+  Kernel()()(
+      sid::shifted(ptr_holder(), device::at_key<dim::h>(strides), h), strides,
+      tuple_util::device::make<pair>(neighbors.first(), neighbors.second)...);
+}
+
+template <class Kernel, class Size, class Sid, class... Sids>
+void call_kernel(Size size, Sid &&fields, Sids &&...neighbor_fields) {
+  int threads_per_block = 32;
+  int blocks = (size + threads_per_block - 1) / threads_per_block;
+  kernel<Kernel><<<blocks, threads_per_block>>>(
+      size, sid::get_origin(fields), sid::get_strides(fields),
+      tuple_util::make<pair>(
+          sid::get_origin(neighbor_fields),
+          at_key<dim::h>(sid::get_strides(neighbor_fields)))...);
+  GT_CUDA_CHECK(cudaGetLastError());
+}
+
+template <class Tag, class Ptr>
+__device__ decltype(auto) field(Ptr const &ptr) {
+  return *device::at_key<Tag>(ptr);
+}
+} // namespace gridtools::usid::cuda
diff --git a/cpputil/usid/include/gridtools/usid/dim.hpp b/cpputil/usid/include/gridtools/usid/dim.hpp
new file mode 100644
index 0000000..48214f8
--- /dev/null
+++ b/cpputil/usid/include/gridtools/usid/dim.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <gridtools/common/defs.hpp>
+#include <gridtools/common/integral_constant.hpp>
+
+namespace gridtools::usid::dim {
+using horizontal = integral_constant<int_t, 0>;
+using vertical = integral_constant<int_t, 1>;
+using neighbor = integral_constant<int_t, 1>;
+using sparse = integral_constant<int_t, 2>;
+
+using h = horizontal;
+using k = vertical;
+using n = neighbor;
+using s = sparse;
+} // namespace gridtools::usid::dim
diff --git a/cpputil/usid/include/gridtools/usid/domain.hpp b/cpputil/usid/include/gridtools/usid/domain.hpp
new file mode 100644
index 0000000..b709e93
--- /dev/null
+++ b/cpputil/usid/include/gridtools/usid/domain.hpp
@@ -0,0 +1,10 @@
+#pragma once
+
+namespace gridtools::usid {
+struct domain {
+  int vertex;
+  int edge;
+  int cell;
+  int k;
+};
+} // namespace gridtools::usid
diff --git a/cpputil/usid/include/gridtools/usid/helpers.hpp b/cpputil/usid/include/gridtools/usid/helpers.hpp
new file mode 100644
index 0000000..e2f3b01
--- /dev/null
+++ b/cpputil/usid/include/gridtools/usid/helpers.hpp
@@ -0,0 +1,88 @@
+#pragma once
+
+#include <limits>
+#include <type_traits>
+#include <utility>
+
+#include <gridtools/common/defs.hpp>
+#include <gridtools/common/host_device.hpp>
+#include <gridtools/common/hymap.hpp>
+#include <gridtools/common/integral_constant.hpp>
+#include <gridtools/common/utility.hpp>
+#include <gridtools/meta/id.hpp>
+#include <gridtools/sid/composite.hpp>
+#include <gridtools/sid/concept.hpp>
+#include <gridtools/sid/contiguous.hpp>
+#include <gridtools/sid/loop.hpp>
+#include <gridtools/sid/rename_dimensions.hpp>
+
+#include "dim.hpp"
+#include "domain.hpp"
+
+namespace gridtools::usid {
+template <class T, class Alloc, class HSize, class KSize>
+auto make_simple_tmp_storage(HSize h_size, KSize k_size, Alloc &alloc) {
+  return sid::make_contiguous<T>(
+      alloc, hymap::keys<dim::h, dim::k>::values<HSize, KSize>(h_size, k_size));
+}
+
+template <class T, class Tag, int_t N, bool HasSkipValues, class F, class Init,
+          class G, class Ptr, class Strides, class Neighbors>
+GT_FUNCTION T fold_neighbors(F f, Init init, G g, Ptr &&ptr, Strides &&strides,
+                             Neighbors &&neighbors) {
+  T acc = init(meta::lazy::id<T>());
+  sid::make_loop<Tag>(
+      integral_constant<int_t, N>())([&](auto const &ptr, auto &&) {
+    auto i = *host_device::at_key<Tag>(ptr);
+    if constexpr (HasSkipValues)
+      if (i < 0)
+        return;
+    acc = f(acc, g(ptr, sid::shifted(neighbors.first, neighbors.second, i)));
+  })(wstd::forward<decltype(ptr)>(ptr), strides);
+  return acc;
+}
+
+template <class T, class Tag, int_t N, bool HasSkip = true, class F,
+          class... Args>
+GT_FUNCTION T sum_neighbors(F f, Args &&...args) {
+  return fold_neighbors<T, Tag, N, HasSkip>(
+      [](auto x, auto y) { return x + y; },
+      [](auto z) -> typename decltype(z)::type { return 0; }, f,
+      wstd::forward<Args>(args)...);
+}
+
+template <class T, class Tag, int_t N, bool HasSkip = true, class F,
+          class... Args>
+GT_FUNCTION T mul_neighbors(F f, Args &&...args) {
+  return fold_neighbors<T, Tag, N, HasSkip>(
+      [](auto x, auto y) { return x * y; },
+      [](auto z) -> typename decltype(z)::type { return 1; }, f,
+      wstd::forward<Args>(args)...);
+}
+
+template <class T, class Tag, int_t N, bool HasSkip = true, class F,
+          class... Args>
+GT_FUNCTION T min_neighbors(F f, Args &&...args) {
+  return fold_neighbors<T, Tag, N, HasSkip>(
+      [](auto x, auto y) { return x < y ? x : y; },
+      [](auto z) -> typename decltype(z)::type {
+        constexpr auto res =
+            std::numeric_limits<typename decltype(z)::type>::max();
+        return res;
+      },
+      f, wstd::forward<Args>(args)...);
+}
+
+template <class T, class Tag, int_t N, bool HasSkip = true, class F,
+          class... Args>
+GT_FUNCTION T max_neighbors(F f, Args &&...args) {
+  return fold_neighbors<T, Tag, N, HasSkip>(
+      [](auto x, auto y) { return x > y ? x : y; },
+      [](auto z) -> typename decltype(z)::type {
+        constexpr auto res =
+            std::numeric_limits<typename decltype(z)::type>::min();
+        return res;
+      },
+      f, wstd::forward<Args>(args)...);
+}
+} // namespace gridtools::usid
diff --git a/cpputil/usid/include/gridtools/usid/naive_helpers.hpp b/cpputil/usid/include/gridtools/usid/naive_helpers.hpp
new file mode 100644
index 0000000..c094bb4
--- /dev/null
+++ b/cpputil/usid/include/gridtools/usid/naive_helpers.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <memory>
+#include <tuple>
+#include <utility>
+
+#include <gridtools/common/hymap.hpp>
+#include <gridtools/sid/allocator.hpp>
+#include <gridtools/sid/concept.hpp>
+#include <gridtools/sid/loop.hpp>
+#include <gridtools/storage/cpu_ifirst.hpp>
+
+#include "dim.hpp"
+#include "helpers.hpp"
+
+namespace gridtools::usid::naive {
+using traits_t = storage::cpu_ifirst;
+
+inline auto make_allocator() {
+  return sid::make_cached_allocator(&std::make_unique<char[]>);
+}
+
+template <class Kernel, class Size, class Sid, class... Sids>
+void call_kernel(Size size, Sid &&fields, Sids &&...neighbor_fields) {
+  sid::make_loop<dim::h>(size)(
+      [params = std::make_tuple(std::make_pair(
+           sid::get_origin(neighbor_fields)(),
+           sid::get_stride<dim::h>(sid::get_strides(neighbor_fields)))...)](
+          auto &ptr, auto const &strides) {
+        std::apply(Kernel()(),
+                   std::tuple_cat(std::forward_as_tuple(ptr, strides), params));
+      })(sid::get_origin(fields)(), sid::get_strides(fields));
+}
+
+template <class Tag, class Ptr> decltype(auto) field(Ptr const &ptr) {
+  return *at_key<Tag>(ptr);
+}
+} // namespace gridtools::usid::naive
diff --git a/cpputil/usid/include/tests/fvm_nabla_driver.hpp b/cpputil/usid/include/tests/fvm_nabla_driver.hpp
new file mode 100644
index 0000000..752b42b
--- /dev/null
+++ b/cpputil/usid/include/tests/fvm_nabla_driver.hpp
@@ -0,0 +1,176 @@
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <tuple>
+
+#include <gtest/gtest.h>
+
+#include <atlas/array.h>
+#include <atlas/functionspace.h>
+#include <atlas/grid.h>
+#include <atlas/mesh.h>
+#include <atlas/mesh/actions/BuildDualMesh.h>
+#include <atlas/mesh/actions/BuildEdges.h>
+#include <atlas/meshgenerator.h>
+
+#include <gridtools/common/integral_constant.hpp>
+#include <gridtools/storage/builder.hpp>
+#include <gridtools/storage/sid.hpp>
+
+#include <gridtools/usid/atlas.hpp>
+
+#ifdef __CUDACC__
+#include <gridtools/storage/gpu.hpp>
+namespace fvm_nabla_driver_impl_ {
+    using storage_traits_t = gridtools::storage::gpu;
+}
+#else
+#include <gridtools/storage/cpu_ifirst.hpp>
+namespace fvm_nabla_driver_impl_ {
+    using storage_traits_t = gridtools::storage::cpu_ifirst;
+}
+#endif
+
+namespace fvm_nabla_driver_impl_ {
+    using namespace gridtools::literals;
+
+    inline constexpr auto storage_builder = gridtools::storage::builder<storage_traits_t>;
+
+    inline auto make_mesh() {
+        using namespace atlas;
+        using param_t = StructuredMeshGenerator::Parameters;
+        auto res = StructuredMeshGenerator(param_t("triangulate", true) | param_t("angle", -1.)).generate(Grid("O32"));
+        functionspace::EdgeColumns(res, option::levels(1) | option::halo(1));
+        functionspace::NodeColumns(res, option::levels(1) | option::halo(1));
+        mesh::actions::build_edges(res);
+        mesh::actions::build_node_to_edge_connectivity(res);
+        mesh::actions::build_median_dual_mesh(res);
+        return res;
+    }
+
+    inline const double rpi = 2 * std::asin(1);
+    inline const double radius = 6371.22e+03;
+    inline const double deg2rad = 2 * rpi / 360;
+    inline constexpr int MXX = 0;
+    inline constexpr int MYY = 1;
+    inline constexpr auto edges_per_node = 7_c;
+
+    inline auto make_vol(atlas::mesh::Nodes const &nodes) {
+        auto dual_volumes = atlas::array::make_view<double, 1>(nodes.field("dual_volumes"));
+        auto init = [&](int n) { return dual_volumes(n) * (std::pow(deg2rad, 2) * std::pow(radius, 2)); };
+        return storage_builder.type<double>().dimensions(nodes.size()).initializer(init).build();
+    }
+
+    inline auto make_sign(atlas::Mesh const &mesh) {
+        auto &&edges = mesh.edges();
+        auto &&nodes = mesh.nodes();
+        auto &&n2e = nodes.edge_connectivity();
+        auto &&e2n = edges.node_connectivity();
+        auto flags = atlas::array::make_view<int, 1>(edges.flags());
+        auto is_pole_edge = [&](auto e) {
+            using topology_t = atlas::mesh::Nodes::Topology;
+            return topology_t::check(flags(e), topology_t::POLE);
+        };
+        auto init = [&](int n, int, int e) -> double {
+            if (e >= n2e.cols(n))
+                return 0;
+            auto ee = n2e(n, e);
+            return n == e2n(ee, 0) || is_pole_edge(ee) ? 1 : -1;
+        };
+        return storage_builder.type<double>()
+            .selector<1, 0, 1>()
+            .dimensions(nodes.size(), 1, edges_per_node)
+            .initializer(init)
+            .build();
+    }
+
+    inline auto make_S_MXX(atlas::mesh::Edges const &edges) {
+        auto dual_normals = atlas::array::make_view<double, 2>(edges.field("dual_normals"));
+        return storage_builder.type<double>()
+            .dimensions(edges.size())
+            .initializer([&](int i) { return dual_normals(i, MXX) * radius * deg2rad; })
+            .build();
+    }
+
+    inline auto make_S_MYY(atlas::mesh::Edges const &edges) {
+        auto dual_normals = atlas::array::make_view<double, 2>(edges.field("dual_normals"));
+        return storage_builder.type<double>()
+            .dimensions(edges.size())
+            .initializer([&](int i) { return dual_normals(i, MYY) * radius * deg2rad; })
+            .build();
+    }
+
+    // TODO ask Christian for a proper name for this input data
+    inline auto make_pp(atlas::mesh::Nodes const &nodes) {
+        static const double zh0 = 2000;
+        static const double zrad = 3 * rpi / 4 * radius;
+        static const double zeta = rpi / 16 * radius;
+        static const double zlatc = 0;
+        static const double zlonc = 3 * rpi / 2;
+
+        auto lonlat = atlas::array::make_view<double, 2>(nodes.field("lonlat"));
+        // lonlatcr is in physical space and may differ from coords later
+        auto rlonlatcr = [&](int n, int i) { return lonlat(n, i) * deg2rad; };
+        auto init = [&](int n) {
+            double zlon = rlonlatcr(n, MXX);
+            double rcosa = std::cos(rlonlatcr(n, MYY));
+            double rsina = std::sin(rlonlatcr(n, MYY));
+            double zdist = std::sin(zlatc) * rsina + std::cos(zlatc) * rcosa * std::cos(zlon - zlonc);
+            zdist = radius * std::acos(zdist);
+            return zdist < zrad
+                       ? .5 * zh0 * (1 + std::cos(rpi * zdist / zrad)) * std::pow(std::cos(rpi * zdist / zeta), 2)
+                       : 0;
+        };
+        return storage_builder.type<double>().dimensions(nodes.size()).initializer(init).build();
+    }
+
+    template <class T>
+    auto min_max(T const &field) {
+        double min = std::numeric_limits<double>::max();
+        double max = std::numeric_limits<double>::min();
+        auto view = field->const_host_view();
+        auto lengths = field->lengths();
+        for (int i = 0; i < (int)lengths[0]; ++i)
+            for (int k = 0; k < (int)lengths[1]; ++k) {
+                double x = view(i, k);
+                min = std::min(min, x);
+                max = std::max(max, x);
+            }
+        return std::make_tuple(min, max);
+    }
+
+    template <class Nabla>
+    void fvm_nabla_driver(Nabla nabla) {
+        constexpr auto k = 1_c;
+
+        auto mesh = make_mesh();
+        auto &&edges = mesh.edges();
+        auto &&nodes = mesh.nodes();
+
+        // output
+        auto make_output = storage_builder.type<double>().dimensions(nodes.size(), k);
+        auto pnabla_MXX = make_output();
+        auto pnabla_MYY = make_output();
+
+        nabla({nodes.size(), edges.size(), mesh.cells().size(), k},
+            make_storage_producer(edges_per_node, nodes.edge_connectivity()),
+            make_storage_producer(2_c, edges.node_connectivity()))(make_S_MXX(edges),
+            make_S_MYY(edges),
+            make_pp(nodes),
+            pnabla_MXX,
+            pnabla_MYY,
+            make_vol(nodes),
+            make_sign(mesh));
+
+        auto [x_min, x_max] = min_max(pnabla_MXX);
+        auto [y_min, y_max] = min_max(pnabla_MYY);
+
+        EXPECT_DOUBLE_EQ(-3.5455427772566003E-003, x_min);
+        EXPECT_DOUBLE_EQ(3.5455427772565435E-003, x_max);
+        EXPECT_DOUBLE_EQ(-3.3540113705465301E-003, y_min);
+        EXPECT_DOUBLE_EQ(3.3540113705465301E-003, y_max);
+    } //
+} // namespace fvm_nabla_driver_impl_
+using fvm_nabla_driver_impl_::fvm_nabla_driver;
diff --git a/cpputil/usid/tests/CMakeLists.txt b/cpputil/usid/tests/CMakeLists.txt
new file mode 100644
index 0000000..5f0c7df
--- /dev/null
+++ b/cpputil/usid/tests/CMakeLists.txt
@@ -0,0 +1,11 @@
+add_executable(nabla_naive nabla_naive.cpp)
+target_link_libraries(nabla_naive PRIVATE usid_naive_helper fvm_nabla_driver gtest_main)
+add_test(NAME nabla_naive COMMAND $<TARGET_FILE:nabla_naive>)
+
+if(CMAKE_CUDA_COMPILER)
+    add_executable(nabla_cuda nabla_cuda.cu)
+    target_link_libraries(nabla_cuda PRIVATE usid_cuda_helper fvm_nabla_driver gtest_main)
+    gridtools_setup_target(nabla_cuda CUDA_ARCH sm_50)
+    target_compile_options(nabla_cuda PRIVATE "-std=c++17")
+    add_test(NAME nabla_cuda COMMAND $<TARGET_FILE:nabla_cuda>)
+endif()
diff --git a/cpputil/usid/tests/nabla_cuda.cu b/cpputil/usid/tests/nabla_cuda.cu
new file mode 100644
index 0000000..a5784f9
--- /dev/null
+++ b/cpputil/usid/tests/nabla_cuda.cu
@@ -0,0 +1,5 @@
+#include "nabla_cuda.hpp"
+#include <gtest/gtest.h>
+#include <tests/fvm_nabla_driver.hpp>
+
+TEST(fvm, nabla_cuda) { fvm_nabla_driver(nabla); }
diff --git a/cpputil/usid/tests/nabla_cuda.hpp b/cpputil/usid/tests/nabla_cuda.hpp
new file mode 100644
index 0000000..d7ca9c6
--- /dev/null
+++ b/cpputil/usid/tests/nabla_cuda.hpp
@@ -0,0 +1,82 @@
+#pragma once
+#include <gridtools/next/usid_cuda_helpers.hpp>
+namespace gridtools::next::cuda::nabla_impl_ {
+struct v2e_tag;
+struct e2v_tag;
+struct S_MXX_tag;
+struct S_MYY_tag;
+struct zavgS_MXX_tag;
+struct zavgS_MYY_tag;
+struct pnabla_MXX_tag;
+struct pnabla_MYY_tag;
+struct vol_tag;
+struct sign_tag;
+struct pp_tag;
+struct kernel_0 {
+  GT_FUNCTION auto operator()() const {
+    return [](auto &&ptr, auto &&strides, auto &&neighbors) {
+      auto zavg = 0.5 * sum_neighbors<double, e2v_tag, 2, false>(
+                            [](auto &&, auto &&n) { return field<pp_tag>(n); },
+                            ptr, strides, neighbors);
+      field<zavgS_MXX_tag>(ptr) = field<S_MXX_tag>(ptr) * zavg;
+      field<zavgS_MYY_tag>(ptr) = field<S_MYY_tag>(ptr) * zavg;
+    };
+  }
+};
+struct kernel_1 {
+  GT_FUNCTION auto operator()() const {
+    return [](auto &&ptr, auto &&strides, auto &&neighbors) {
+      field<pnabla_MXX_tag>(ptr) = sum_neighbors<double, v2e_tag, 7>(
+          [](auto &&p, auto &&n) {
+            return field<zavgS_MXX_tag>(n) * field<sign_tag>(p);
+          },
+          ptr, strides, neighbors);
+      field<pnabla_MYY_tag>(ptr) = sum_neighbors<double, v2e_tag, 7>(
+          [](auto &&p, auto &&n) {
+            return field<zavgS_MYY_tag>(n) * field<sign_tag>(p);
+          },
+          ptr, strides, neighbors);
+      field<pnabla_MXX_tag>(ptr) =
+          field<pnabla_MXX_tag>(ptr) / field<vol_tag>(ptr);
+      field<pnabla_MYY_tag>(ptr) =
+          field<pnabla_MYY_tag>(ptr) / field<vol_tag>(ptr);
+    };
+  }
+};
+inline constexpr auto nabla = [](domain d, auto &&v2e, auto &&e2v) {
+  static_assert(is_sid<decltype(v2e(traits_t()))>());
+  static_assert(is_sid<decltype(e2v(traits_t()))>());
+  return [d = std::move(d),
+          v2e = sid::rename_dimensions<dim::n, v2e_tag>(
+              std::forward<decltype(v2e)>(v2e)(traits_t())),
+          e2v = sid::rename_dimensions<dim::n, e2v_tag>(
+              std::forward<decltype(e2v)>(e2v)(traits_t()))](
+             auto &&S_MXX, auto &&S_MYY, auto &&pp, auto &&pnabla_MXX,
+             auto &&pnabla_MYY, auto &&vol, auto &&sign) {
+    static_assert(is_sid<decltype(S_MXX)>());
+    static_assert(is_sid<decltype(S_MYY)>());
+    static_assert(is_sid<decltype(pp)>());
+    static_assert(is_sid<decltype(pnabla_MXX)>());
+    static_assert(is_sid<decltype(pnabla_MYY)>());
+    static_assert(is_sid<decltype(vol)>());
+    static_assert(is_sid<decltype(sign)>());
+    auto alloc = make_allocator();
+    auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
+    auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
+    call_kernel<kernel_0>(d.edge,
+                          sid::composite::make<e2v_tag, S_MXX_tag, S_MYY_tag,
+                                               zavgS_MXX_tag, zavgS_MYY_tag>(
+                              e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY),
+                          sid::composite::make<pp_tag>(pp));
+    call_kernel<kernel_1>(
+        d.vertex,
+        sid::composite::make<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag,
+                             vol_tag>(
+            v2e, pnabla_MXX, pnabla_MYY,
+            sid::rename_dimensions<dim::s, v2e_tag>(sign), vol),
+        sid::composite::make<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX,
+                                                           zavgS_MYY));
+  };
+};
+} // namespace gridtools::next::cuda::nabla_impl_
+using gridtools::next::cuda::nabla_impl_::nabla;
diff --git a/cpputil/usid/tests/nabla_naive.cpp b/cpputil/usid/tests/nabla_naive.cpp
new file mode 100644
index 0000000..a3cca65
--- /dev/null
+++ b/cpputil/usid/tests/nabla_naive.cpp
@@ -0,0 +1,5 @@
+#include "nabla_naive.hpp"
+#include <gtest/gtest.h>
+#include <tests/fvm_nabla_driver.hpp>
+
+TEST(fvm, nabla_naive) { fvm_nabla_driver(nabla); }
diff --git a/cpputil/usid/tests/nabla_naive.hpp b/cpputil/usid/tests/nabla_naive.hpp
new file mode 100644
index 0000000..8e4e115
--- /dev/null
+++ b/cpputil/usid/tests/nabla_naive.hpp
@@ -0,0 +1,66 @@
+#pragma once
+#include <gridtools/usid/naive_helpers.hpp>
+namespace gridtools::usid::naive::nabla_impl_ {
+    struct v2e_tag;
+    struct e2v_tag;
+    struct S_MXX_tag;
+    struct S_MYY_tag;
+    struct zavgS_MXX_tag;
+    struct zavgS_MYY_tag;
+    struct pnabla_MXX_tag;
+    struct pnabla_MYY_tag;
+    struct vol_tag;
+    struct sign_tag;
+    struct pp_tag;
+    struct kernel_0 {
+        GT_FUNCTION auto operator()() const {
+            return [](auto &&e, auto &&strides, auto &&v) {
+                auto zavg = 0.5 * sum_neighbors<double, e2v_tag, 2, false>(
+                                      [](auto &&e, auto &&v) { return field<pp_tag>(v); }, e, strides, v);
+                field<zavgS_MXX_tag>(e) = field<S_MXX_tag>(e) * zavg;
+                field<zavgS_MYY_tag>(e) = field<S_MYY_tag>(e) * zavg;
+            };
+        }
+    };
+    struct kernel_1 {
+        GT_FUNCTION auto operator()() const {
+            return [](auto &&v, auto &&strides, auto &&e) {
+                field<pnabla_MXX_tag>(v) = sum_neighbors<double, v2e_tag, 7>(
+                    [](auto &&v, auto &&e) { return field<zavgS_MXX_tag>(e) * field<sign_tag>(v); }, v, strides, e);
+                field<pnabla_MYY_tag>(v) = sum_neighbors<double, v2e_tag, 7>(
+                    [](auto &&v, auto &&e) { return field<zavgS_MYY_tag>(e) * field<sign_tag>(v); }, v, strides, e);
+                field<pnabla_MXX_tag>(v) = field<pnabla_MXX_tag>(v) / field<vol_tag>(v);
+                field<pnabla_MYY_tag>(v) = field<pnabla_MYY_tag>(v) / field<vol_tag>(v);
+            };
+        }
+    };
+    inline constexpr auto nabla = [](domain d, auto &&v2e, auto &&e2v) {
+        static_assert(is_sid<decltype(v2e(traits_t()))>());
+        static_assert(is_sid<decltype(e2v(traits_t()))>());
+        return
+            [d = std::move(d),
+                v2e = sid::rename_dimensions<dim::n, v2e_tag>(std::forward<decltype(v2e)>(v2e)(traits_t())),
+                e2v = sid::rename_dimensions<dim::n, e2v_tag>(std::forward<decltype(e2v)>(e2v)(traits_t()))](
+                auto &&S_MXX, auto &&S_MYY, auto &&pp, auto &&pnabla_MXX, auto &&pnabla_MYY, auto &&vol, auto &&sign) {
+                static_assert(is_sid<decltype(S_MXX)>());
+                static_assert(is_sid<decltype(S_MYY)>());
+                static_assert(is_sid<decltype(pp)>());
+                static_assert(is_sid<decltype(pnabla_MXX)>());
+                static_assert(is_sid<decltype(pnabla_MYY)>());
+                static_assert(is_sid<decltype(vol)>());
+                static_assert(is_sid<decltype(sign)>());
+                auto alloc = make_allocator();
+                auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
+                auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
+                call_kernel<kernel_0>(d.edge,
+                    sid::composite::make<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>(
+                        e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY),
+                    sid::composite::make<pp_tag>(pp));
+                call_kernel<kernel_1>(d.vertex,
+                    sid::composite::make<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag, vol_tag>(
+                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_tag>(sign), vol),
+                    sid::composite::make<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX, zavgS_MYY));
+            };
+    };
+} // namespace gridtools::usid::naive::nabla_impl_
+using gridtools::usid::naive::nabla_impl_::nabla;

From f05f7f944eeebfcd06f50cefab62613726db2f11 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 26 Oct 2020 13:24:15 +0100
Subject: [PATCH 08/24] restore cpputil/unstructured

---
 cpputil/unstructured/CMakeLists.txt           |  22 +-
 .../include/gridtools/next/atlas_adapter.hpp  | 102 ++++-
 .../next/atlas_array_view_adapter.hpp         |  22 +-
 .../gridtools/next/atlas_field_util.hpp       | 115 ++++++
 .../include/gridtools/next/cuda_util.hpp      |  11 +
 .../include/gridtools/next/math.hpp           |   0
 .../include/gridtools/next/mesh.hpp           |  93 +++++
 .../next/test_helper/field_builder.hpp        |  34 ++
 .../next/test_helper/simple_mesh.hpp          | 165 ++++++++
 .../include/gridtools/next/tmp_storage.hpp    |  22 ++
 .../include/gridtools/next/unstructured.hpp   |  21 +-
 .../tests/include/util/CMakeLists.txt         |   0
 .../tests/include/util/atlas_util.hpp         |  23 ++
 .../tests/regression/fvm_nabla/CMakeLists.txt |  22 +-
 .../tests/regression/fvm_nabla/driver.cc      | 288 +++++++++++++-
 .../tests/regression/fvm_nabla/nabla_cuda.hpp | 366 ++++++++++++++----
 .../regression/fvm_nabla/nabla_naive.hpp      | 304 ++++++++++++---
 .../tests/unit_tests/next/CMakeLists.txt      |   4 +
 .../unit_tests/next/test_atlas_field_util.cc  |  62 +++
 .../next/test_helper/CMakeLists.txt           |   2 +
 .../next/test_helper/test_field_builder.cc    | 105 +++++
 .../next/test_helper/test_simple_mesh.cc      |  54 +++
 .../tests/unit_tests/next/test_mesh.cc        |  30 ++
 23 files changed, 1686 insertions(+), 181 deletions(-)
 create mode 100644 cpputil/unstructured/include/gridtools/next/atlas_field_util.hpp
 create mode 100644 cpputil/unstructured/include/gridtools/next/cuda_util.hpp
 create mode 100644 cpputil/unstructured/include/gridtools/next/math.hpp
 create mode 100644 cpputil/unstructured/include/gridtools/next/mesh.hpp
 create mode 100644 cpputil/unstructured/include/gridtools/next/test_helper/field_builder.hpp
 create mode 100644 cpputil/unstructured/include/gridtools/next/test_helper/simple_mesh.hpp
 create mode 100644 cpputil/unstructured/include/gridtools/next/tmp_storage.hpp
 create mode 100644 cpputil/unstructured/tests/include/util/CMakeLists.txt
 create mode 100644 cpputil/unstructured/tests/include/util/atlas_util.hpp
 create mode 100644 cpputil/unstructured/tests/unit_tests/next/test_atlas_field_util.cc
 create mode 100644 cpputil/unstructured/tests/unit_tests/next/test_helper/CMakeLists.txt
 create mode 100644 cpputil/unstructured/tests/unit_tests/next/test_helper/test_field_builder.cc
 create mode 100644 cpputil/unstructured/tests/unit_tests/next/test_helper/test_simple_mesh.cc
 create mode 100644 cpputil/unstructured/tests/unit_tests/next/test_mesh.cc

diff --git a/cpputil/unstructured/CMakeLists.txt b/cpputil/unstructured/CMakeLists.txt
index f95473b..2f6fafa 100644
--- a/cpputil/unstructured/CMakeLists.txt
+++ b/cpputil/unstructured/CMakeLists.txt
@@ -3,7 +3,7 @@ project(unstructured_interface LANGUAGES CXX)
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake/private")
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 
 add_compile_options(-Wall)
 #add_compile_options(-Wall -Wextra -pedantic -Wno-sign-compare)
@@ -27,9 +27,29 @@ FetchContent_MakeAvailable(GridTools)
 add_library(gtnext INTERFACE)
 target_include_directories(gtnext INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
 
+add_executable(prototype prototype.cc)
+target_link_libraries(prototype GridTools::gridtools)
+target_include_directories(prototype PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
 find_package(eckit REQUIRED)
 find_package(Atlas REQUIRED)
 
+add_executable(atlas_mesh_adapter atlas_mesh_adapter.cc)
+target_link_libraries(atlas_mesh_adapter atlas GridTools::gridtools)
+target_include_directories(atlas_mesh_adapter PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+add_executable(atlas_field_converter atlas_field_converter.cc)
+target_link_libraries(atlas_field_converter atlas GridTools::gridtools)
+target_include_directories(atlas_field_converter PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+if(CMAKE_CUDA_COMPILER)
+  add_executable(atlas_field_converter_cuda atlas_field_converter.cu)
+  target_link_libraries(atlas_field_converter_cuda atlas GridTools::storage_gpu)
+  target_include_directories(atlas_field_converter_cuda PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+  target_compile_options(atlas_field_converter_cuda PRIVATE "-std=c++17")
+  target_compile_options(atlas_field_converter_cuda PRIVATE "-arch=sm_50")
+endif()
+
 if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
     include(CTest)
     if(BUILD_TESTING)
diff --git a/cpputil/unstructured/include/gridtools/next/atlas_adapter.hpp b/cpputil/unstructured/include/gridtools/next/atlas_adapter.hpp
index 2b29cf7..aaa10c7 100644
--- a/cpputil/unstructured/include/gridtools/next/atlas_adapter.hpp
+++ b/cpputil/unstructured/include/gridtools/next/atlas_adapter.hpp
@@ -1,18 +1,98 @@
 #pragma once
 
-#include <atlas/mesh/Connectivity.h>
+#include <cstddef>
 
+#include "gridtools/common/layout_map.hpp"
+#include <atlas/mesh.h>
+#include <gridtools/sid/concept.hpp>
+#include <gridtools/sid/rename_dimensions.hpp>
 #include <gridtools/storage/builder.hpp>
+#include <gridtools/storage/sid.hpp>
 
-namespace atlas::mesh {
-    template <class Connectivity, class MaxNeighbors>
-    auto make_storage_producer(MaxNeighbors max_neighbors, Connectivity const &src) {
-        return [&src, max_neighbors](auto traits) {
-            return gridtools::storage::builder<decltype(traits)>
-            .template type<int>()
-            .dimensions(src.rows(), max_neighbors)
-            .initializer([&src](auto row, auto col) { return col < src.cols(row) ? src(row, col) : -1; })
-            .build();
+#include <mesh/Connectivity.h>
+
+#include "mesh.hpp"
+#include "unstructured.hpp"
+#include <gridtools/next/atlas_field_util.hpp>
+
+#ifdef __CUDACC__ // TODO proper handling
+#include <gridtools/storage/gpu.hpp>
+using storage_trait = gridtools::storage::gpu;
+#else
+#include <gridtools/storage/cpu_ifirst.hpp>
+using storage_trait = gridtools::storage::cpu_ifirst;
+#endif
+
+namespace gridtools::next::atlas_wrappers {
+    // not really a connectivity
+    template <class LocationType>
+    struct primary_connectivity {
+        std::size_t size_;
+
+        GT_FUNCTION friend std::size_t connectivity_size(primary_connectivity const &conn) { return conn.size_; }
+    };
+
+    template <class LocationType, std::size_t MaxNeighbors>
+    struct regular_connectivity {
+        struct builder {
+            auto operator()(std::size_t size) {
+                return gridtools::storage::builder<storage_trait>.template type<int>().template layout<0, 1>().template dimensions(
+                    size, std::integral_constant<std::size_t, MaxNeighbors>{});
+            }
         };
+
+        decltype(builder{}(std::size_t{})()) tbl_;
+        const atlas::idx_t missing_value_; // TODO Not sure if we can leave the type open
+        const gridtools::uint_t size_;
+
+        regular_connectivity(atlas::mesh::IrregularConnectivity const &conn)
+            : tbl_{builder{}(conn.rows()).initializer([&conn](std::size_t row, std::size_t col) {
+                  return col < static_cast<size_t>(conn.cols(row)) ? conn.row(row)(col) : conn.missing_value();
+              })()},
+              missing_value_{conn.missing_value()}, size_{tbl_->lengths()[0]} {}
+
+        regular_connectivity(atlas::mesh::MultiBlockConnectivity const &conn)
+            : tbl_{builder{}(conn.rows()).initializer([&conn](std::size_t row, std::size_t col) {
+                  return col < static_cast<std::size_t>(conn.cols(row)) ? conn.row(row)(col) : conn.missing_value();
+              })()},
+              missing_value_{conn.missing_value()}, size_{tbl_->lengths()[0]} {}
+
+        GT_FUNCTION friend std::size_t connectivity_size(regular_connectivity const &conn) { return conn.size_; }
+
+        GT_FUNCTION friend std::integral_constant<std::size_t, MaxNeighbors> connectivity_max_neighbors(
+            regular_connectivity const &) {
+            return {};
+        }
+
+        GT_FUNCTION friend int connectivity_skip_value(regular_connectivity const &conn) { return conn.missing_value_; }
+
+        friend auto connectivity_neighbor_table(regular_connectivity const &conn) {
+            return gridtools::sid::rename_numbered_dimensions<LocationType, neighbor>(conn.tbl_);
+        }
+    };
+
+} // namespace gridtools::next::atlas_wrappers
+
+namespace atlas {
+    template <template <class...> class L>
+    decltype(auto) mesh_connectivity(L<vertex, edge>, const Mesh &mesh) {
+        return gridtools::next::atlas_wrappers::regular_connectivity<vertex, 7
+            // TODO this number must passed by the user (probably wrap atlas mesh)
+            >{mesh.nodes().edge_connectivity()};
+    }
+
+    template <template <class...> class L>
+    decltype(auto) mesh_connectivity(L<edge, vertex>, Mesh const &mesh) {
+        return gridtools::next::atlas_wrappers::regular_connectivity<edge, 2>{mesh.edges().node_connectivity()};
+    }
+
+    template <template <class...> class L>
+    decltype(auto) mesh_connectivity(L<edge>, Mesh const &mesh) {
+        return gridtools::next::atlas_wrappers::primary_connectivity<edge>{std::size_t(mesh.edges().size())};
+    }
+
+    template <template <class...> class L>
+    decltype(auto) mesh_connectivity(L<vertex>, Mesh const &mesh) {
+        return gridtools::next::atlas_wrappers::primary_connectivity<vertex>{std::size_t(mesh.nodes().size())};
     }
-} // namespace atlas::mesh
+} // namespace atlas
diff --git a/cpputil/unstructured/include/gridtools/next/atlas_array_view_adapter.hpp b/cpputil/unstructured/include/gridtools/next/atlas_array_view_adapter.hpp
index 724a6b5..c6e5456 100644
--- a/cpputil/unstructured/include/gridtools/next/atlas_array_view_adapter.hpp
+++ b/cpputil/unstructured/include/gridtools/next/atlas_array_view_adapter.hpp
@@ -1,14 +1,11 @@
 #pragma once
 
-#include <cstddef>
-#include <utility>
-
 #include <atlas/array.h>
-
+#include <cstddef>
 #include <gridtools/common/hymap.hpp>
 #include <gridtools/common/integral_constant.hpp>
 #include <gridtools/sid/simple_ptr_holder.hpp>
-#include <gridtools/storage/builder.hpp>
+#include <utility>
 
 /**
  * SID adapters for atlas::ArrayView.
@@ -83,19 +80,4 @@ namespace atlas::array {
         return sid_adapter_impl_::to_hymap<std::make_index_sequence<Rank>>{}(view.shape());
     }
 
-    namespace make_storage_impl {
-        template <class Traits, class T, int Rank, std::size_t... Is>
-        auto make_storage(ArrayView<T, Rank> const &view, std::index_sequence<Is...>) {
-            return ::gridtools::storage::builder<Traits> //
-                .template type<T>()                      //
-                .dimensions(view.shape(Is)...)           //
-                .initializer(view)                       //
-                .build();
-        }
-    } // namespace make_storage_impl
-
-    template <class Traits, class T, int Rank>
-    auto make_storage(Traits, ArrayView<T, Rank> const &view) {
-        return make_storage_impl::make_storage<Traits>(view, std::make_index_sequence<Rank>());
-    }
 } // namespace atlas::array
diff --git a/cpputil/unstructured/include/gridtools/next/atlas_field_util.hpp b/cpputil/unstructured/include/gridtools/next/atlas_field_util.hpp
new file mode 100644
index 0000000..9035caf
--- /dev/null
+++ b/cpputil/unstructured/include/gridtools/next/atlas_field_util.hpp
@@ -0,0 +1,115 @@
+#include <array_fwd.h>
+#include <cassert>
+
+#include <atlas/field/Field.h>
+#include <atlas/functionspace.h>
+#include <gridtools/common/hymap.hpp>
+#include <gridtools/meta/first.hpp>
+#include <gridtools/next/atlas_array_view_adapter.hpp>
+#include <gridtools/sid/delegate.hpp>
+#include <gridtools/sid/rename_dimensions.hpp>
+
+#include <gridtools/storage/builder.hpp>
+#include <gridtools/storage/sid.hpp>
+#include <utility>
+#ifdef __CUDACC__ // TODO in a proper place
+#include <gridtools/storage/gpu.hpp>
+#else
+#include <gridtools/storage/cpu_ifirst.hpp>
+#endif
+#include "unstructured.hpp"
+
+#pragma once
+
+namespace gridtools::next::atlas_util {
+
+    // THE COMMENTED IS A DIRECT SID ADAPTION, THE OTHER IS USING THE
+    // ARRAY_VIEW_ADAPTER AND RENAMES:
+    // using strides_t =
+    //     typename gridtools::hymap::keys<DimensionTags...>::template
+    //     values<int, int>;
+    //
+    // return gridtools::sid::synthetic()
+    //     .set<gridtools::sid::property::origin>(
+    //         gridtools::sid::make_simple_ptr_holder(
+    //             atlas::array::make_view<DataType, 2>(field).data()))
+    //     .template set<gridtools::sid::property::strides>(strides_t(
+    //         field.strides()[0], field.strides()[1])) // TODO more
+    //         dimensions
+    //     .template set<gridtools::sid::property::strides_kind, strides_t>();
+
+    template <class... DimensionTags>
+    struct as {
+        using first_t = meta::first<as>;
+
+        // Atlas field dimensions order (TODO double check):
+        // 1. unstructured dimension
+        // 2. vertical
+        // 3. other dimensions
+        // from this we can derive some checks:
+        // - runtime: type of unstructured dimension (Done)
+        // - static: dim::k in first (no unstructured) or second dimension
+        // - static: no unstructured dimension tag after first dimension
+        template <class DataType>
+        struct with_type {
+            auto operator()(atlas::Field &field) {
+                assert(field.rank() == sizeof...(DimensionTags) && "Rank mismatch");
+
+                if constexpr (std::is_same<first_t, edge>{}) {
+                    if (field.functionspace().type().compare("EdgeColumns") != 0 &&
+                        field.functionspace().type().compare("Edges") != 0) // TODO EdgeColumns vs Edges
+                        atlas::throw_Exception(field.name() + " is not an edge field", Here());
+                } else if constexpr (std::is_same<first_t, cell>{}) {
+                    if (field.functionspace().type().compare("Cells") != 0)
+                        atlas::throw_Exception(field.name() + " is not a cell field", Here());
+                } else if constexpr (std::is_same<first_t, vertex>{}) {
+                    if (field.functionspace().type().compare("NodeColumns") != 0) // TODO NodeColumns vs Nodes
+                        atlas::throw_Exception(field.name() + " is not a vertex field", Here());
+                }
+
+                static_assert(
+                    gridtools::is_sid<decltype(atlas::array::make_view<DataType, sizeof...(DimensionTags)>(field))>{},
+                    "ArrayView is not SID. Did you include "
+                    "\"atlas_array_view_adapter.hpp\"?");
+                return gridtools::sid::rename_numbered_dimensions<DimensionTags...>(
+                    atlas::array::make_view<DataType, sizeof...(DimensionTags)>(field));
+            }
+        };
+    };
+
+    // TODO just a temporary solution, maybe a SID transformer would make sense
+    // (requirement would be upper and lower bounds are available for the input SID)
+    template <class... DimensionTags>
+    struct as_data_store {
+        template <class DataType>
+        struct with_type {
+            template <class>
+            struct custom_builder;
+            template <std::size_t... Is>
+            struct custom_builder<std::index_sequence<Is...>> {
+                template <class StorageTrait>
+                auto build(atlas::Field const &field) {
+                    auto const &shape = field.shape();
+                    auto view = atlas::array::make_view<DataType, sizeof...(DimensionTags)>(field);
+                    return gridtools::sid::rename_numbered_dimensions<DimensionTags...>(std::move(
+                    gridtools::storage::builder<StorageTrait>.template
+            dimensions(                shape[Is]...)
+            .template type<DataType>()
+                .initializer([&](auto... indices){
+                    return view(indices...);
+                })()
+            ));
+                }
+            };
+
+            auto operator()(atlas::Field &field) {
+                auto builder = custom_builder<std::make_index_sequence<sizeof...(DimensionTags)>>{};
+#ifdef __CUDACC__ // TODO in a proper place
+                return builder.template build<gridtools::storage::gpu>(field);
+#else
+                return builder.template build<gridtools::storage::cpu_ifirst>(field);
+#endif
+            }
+        };
+    };
+} // namespace gridtools::next::atlas_util
diff --git a/cpputil/unstructured/include/gridtools/next/cuda_util.hpp b/cpputil/unstructured/include/gridtools/next/cuda_util.hpp
new file mode 100644
index 0000000..3ce9679
--- /dev/null
+++ b/cpputil/unstructured/include/gridtools/next/cuda_util.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <tuple>
+
+namespace gridtools::next::cuda_util {
+    inline std::tuple<int, int> cuda_setup(int N) {
+        int threads_per_block = 32;
+        int blocks = (N + threads_per_block - 1) / threads_per_block;
+        return {blocks, threads_per_block};
+    }
+} // namespace gridtools::next::cuda_util
diff --git a/cpputil/unstructured/include/gridtools/next/math.hpp b/cpputil/unstructured/include/gridtools/next/math.hpp
new file mode 100644
index 0000000..e69de29
diff --git a/cpputil/unstructured/include/gridtools/next/mesh.hpp b/cpputil/unstructured/include/gridtools/next/mesh.hpp
new file mode 100644
index 0000000..754f530
--- /dev/null
+++ b/cpputil/unstructured/include/gridtools/next/mesh.hpp
@@ -0,0 +1,93 @@
+#pragma once
+
+#include <cstddef>
+#include <utility>
+
+#include "unstructured.hpp"
+#include <gridtools/common/hymap.hpp>
+#include <gridtools/common/integral_constant.hpp>
+#include <gridtools/sid/concept.hpp>
+
+namespace gridtools {
+    namespace next {
+
+        namespace connectivity {
+            template <class Connectivity>
+            auto neighbor_table(Connectivity const &connectivity)
+            /* -> decltype(connectivity_neighbor_table(connectivity)) */ // TODO this results in a CUDA error
+            {
+                return connectivity_neighbor_table(connectivity);
+            };
+
+            // TODO remove GT_FUNCTION after Code generator is updated to use the info struct or similar
+            template <class Connectivity>
+            GT_FUNCTION auto max_neighbors(Connectivity const &connectivity)
+                -> decltype(connectivity_max_neighbors(connectivity)) {
+                // return max_neighbors_type<Connectivity>::value;
+                return connectivity_max_neighbors(connectivity);
+            }
+
+            // TODO remove GT_FUNCTION after Code generator is updated to use the info struct or similar
+            template <class Connectivity>
+            GT_FUNCTION std::size_t size(Connectivity const &connectivity) {
+                return connectivity_size(connectivity);
+            }
+
+            // TODO remove GT_FUNCTION after Code generator is updated to use the info struct or similar
+            template <class Connectivity>
+            GT_FUNCTION auto skip_value(Connectivity const &connectivity)
+                -> decltype(connectivity_skip_value(connectivity)) {
+                return connectivity_skip_value(connectivity);
+            }
+
+            template <class MaxNeighborsT, class SkipValueT>
+            struct info {
+                MaxNeighborsT max_neighbors;
+                SkipValueT skip_value;
+                std::size_t size;
+            };
+
+            template <class MaxNeighborsT, class SkipValueT>
+            info<MaxNeighborsT, SkipValueT> make_info(MaxNeighborsT max_neighbors,
+                SkipValueT skip_value,
+                std::size_t size /* size last as it will probably be replaced by iteration_space concept */) {
+                return {max_neighbors, skip_value, size};
+            }
+
+            template <class Connectivity>
+            auto extract_info(Connectivity const &connectivity) {
+                return make_info(max_neighbors(connectivity), skip_value(connectivity), size(connectivity));
+            }
+
+        } // namespace connectivity
+
+        namespace mesh {
+            struct not_provided;
+            not_provided mesh_connectivity(...);
+
+            // Models gridtools::hymaps as mesh
+            template <class Key,
+                class Mesh,
+                class K = meta::rename<meta::list, Key>,
+                class Res = decltype(mesh_connectivity(K(), std::declval<Mesh const &>())),
+                std::enable_if_t< //
+                    std::is_same_v<Res, not_provided>
+                    /* && is_connectivity_v<decltype(at_key<K>(std::declval<Mesh const&>()))> */,
+                    int> = 0>
+            auto connectivity(Mesh const &mesh) -> decltype(at_key<K>(mesh)) {
+                return at_key<K>(mesh);
+            }
+
+            template <class Key,
+                class Mesh,
+                // rename to meta::list avoids requiring keys to be defined if incoming list is, e.g., std::tuple
+                class K = meta::rename<meta::list, Key>,
+                class Res = decltype(mesh_connectivity(K(), std::declval<Mesh const &>())),
+                std::enable_if_t<!std::is_same<Res, not_provided>::value, int> = 0>
+            Res connectivity(Mesh const &mesh) {
+                return mesh_connectivity(K(), mesh);
+            }
+        } // namespace mesh
+
+    } // namespace next
+} // namespace gridtools
diff --git a/cpputil/unstructured/include/gridtools/next/test_helper/field_builder.hpp b/cpputil/unstructured/include/gridtools/next/test_helper/field_builder.hpp
new file mode 100644
index 0000000..673e628
--- /dev/null
+++ b/cpputil/unstructured/include/gridtools/next/test_helper/field_builder.hpp
@@ -0,0 +1,34 @@
+#include "../unstructured.hpp"
+#include "gridtools/next/mesh.hpp"
+#include <gridtools/sid/rename_dimensions.hpp>
+#include <gridtools/storage/builder.hpp>
+#include <gridtools/storage/sid.hpp>
+#include <type_traits>
+
+#ifdef __CUDACC__ // TODO proper handling
+#include <gridtools/storage/gpu.hpp>
+using storage_trait = gridtools::storage::gpu;
+#else
+#include <gridtools/storage/cpu_ifirst.hpp>
+using storage_trait = gridtools::storage::cpu_ifirst;
+#endif
+
+namespace gridtools::next::test_helper {
+
+    namespace make_field_impl_ {
+
+        template <class T>
+        struct builder {
+            auto operator()(std::size_t size) const {
+                return gridtools::storage::builder<storage_trait>.template type<T>().template dimensions(size);
+            }
+        };
+    } // namespace make_field_impl_
+
+    template <class T, class Location, class Mesh>
+    auto make_field(Mesh const &mesh) {
+        // TODO seems it would be nice if we can adapt the data_store builder to create SIDs with named dimension
+        return sid::rename_numbered_dimensions<Location> // TODO
+            (make_field_impl_::builder<T>{}(connectivity::size(mesh::connectivity<meta::list<Location>>(mesh)))());
+    }
+} // namespace gridtools::next::test_helper
diff --git a/cpputil/unstructured/include/gridtools/next/test_helper/simple_mesh.hpp b/cpputil/unstructured/include/gridtools/next/test_helper/simple_mesh.hpp
new file mode 100644
index 0000000..8d0e3d3
--- /dev/null
+++ b/cpputil/unstructured/include/gridtools/next/test_helper/simple_mesh.hpp
@@ -0,0 +1,165 @@
+/**
+ * Simple 3x3 Cartesian, periodic, hand-made mesh.
+ *
+ *      0e    1e    2e
+ *   | ---- | ---- | ---- |
+ * 9e|0v 10e|1v 11e|2v  9e|0v
+ *   |  0c  |  1c  |  2c  |
+ *   |  3e  |  4e  |  5e  |
+ *   | ---- | ---- | ---- |
+ *12e|3v 13e|4v 14e|5v 12e|3v
+ *   |  3c  |  4c  |  5c  |
+ *   |  6e  |  7e  |  8e  |
+ *   | ---- | ---- | ---- |
+ *15e|6v 16e|7v 17e|8v 15e| 6v
+ *   |  6c  |  7c  |  8c  |
+ *   |  0e  |  1e  |  2e  |
+ *   | ---- | ---- | ---- |
+ *    0v     1v     2v     0v
+ *
+ */
+
+#include "../mesh.hpp"
+#include "../unstructured.hpp"
+#include <cstddef>
+#include <gridtools/sid/rename_dimensions.hpp>
+#include <gridtools/storage/builder.hpp>
+#include <gridtools/storage/sid.hpp>
+#include <type_traits>
+
+#ifdef __CUDACC__ // TODO proper handling
+#include <gridtools/storage/gpu.hpp>
+using storage_trait = gridtools::storage::gpu;
+#else
+#include <gridtools/storage/cpu_ifirst.hpp>
+using storage_trait = gridtools::storage::cpu_ifirst;
+#endif
+
+namespace gridtools {
+    namespace next {
+        namespace test_helper {
+            struct simple_mesh {
+                template <class LocationType>
+                struct primary_connectivity {
+                    std::size_t size_;
+
+                    GT_FUNCTION friend std::size_t connectivity_size(primary_connectivity const &conn) {
+                        return conn.size_;
+                    }
+                };
+
+                template <class LocationType, std::size_t MaxNeighbors>
+                struct regular_connectivity {
+                    struct builder {
+                        auto operator()(std::size_t size) {
+                            return gridtools::storage::builder<storage_trait>.template type<int>().template layout<0, 1>().template dimensions(
+                    size, std::integral_constant<std::size_t, MaxNeighbors>{});
+                        }
+                    };
+
+                    decltype(builder{}(0)()) tbl_;
+                    std::size_t size_;
+                    static constexpr gridtools::int_t missing_value_ = -1;
+
+                    regular_connectivity(std::vector<std::array<int, MaxNeighbors>> tbl)
+                        : tbl_{builder{}(tbl.size()).initializer([&tbl](std::size_t primary, std::size_t neigh) {
+                              return tbl[primary][neigh];
+                          })()},
+                          size_{tbl.size()} {}
+
+                    GT_FUNCTION friend std::size_t connectivity_size(regular_connectivity const &conn) {
+                        return conn.size_;
+                    }
+
+                    GT_FUNCTION friend std::integral_constant<std::size_t, MaxNeighbors> connectivity_max_neighbors(
+                        regular_connectivity const &) {
+                        return {};
+                    }
+
+                    GT_FUNCTION friend int connectivity_skip_value(regular_connectivity const &conn) {
+                        return conn.missing_value_;
+                    }
+
+                    friend auto connectivity_neighbor_table(regular_connectivity const &conn) {
+                        return gridtools::sid::rename_numbered_dimensions<LocationType, neighbor>(conn.tbl_);
+                    }
+                };
+
+                template <template <class...> class L>
+                friend decltype(auto) mesh_connectivity(L<vertex>, simple_mesh const &) {
+                    return primary_connectivity<vertex>{9};
+                }
+                template <template <class...> class L>
+                friend decltype(auto) mesh_connectivity(L<edge>, simple_mesh const &) {
+                    return primary_connectivity<edge>{18};
+                }
+                template <template <class...> class L>
+                friend decltype(auto) mesh_connectivity(L<cell>, simple_mesh const &) {
+                    return primary_connectivity<cell>{9};
+                }
+                template <template <class...> class L>
+                friend decltype(auto) mesh_connectivity(L<cell, cell>, simple_mesh const &) {
+                    return regular_connectivity<cell, 4>{{
+                        {6, 1, 3, 2}, // 0
+                        {7, 2, 4, 0}, // 1
+                        {8, 0, 5, 1}, // 2
+                        {0, 4, 6, 5}, // 3
+                        {1, 5, 7, 3}, // 4
+                        {2, 3, 8, 4}, // 5
+                        {3, 7, 0, 8}, // 6
+                        {4, 8, 1, 6}, // 7
+                        {5, 6, 2, 7}  // 8
+                    }};
+                }
+                template <template <class...> class L>
+                friend decltype(auto) mesh_connectivity(L<edge, vertex>, simple_mesh const &) {
+                    return regular_connectivity<edge, 2>{{
+                        {0, 1}, // 0
+                        {1, 2},
+                        {2, 0},
+                        {3, 4},
+                        {4, 5},
+                        {5, 3},
+                        {6, 7},
+                        {7, 8},
+                        {8, 6},
+                        {0, 3}, // 9
+                        {1, 4},
+                        {2, 5},
+                        {3, 6},
+                        {4, 7},
+                        {5, 8},
+                        {6, 0},
+                        {7, 1},
+                        {8, 2},
+                    }};
+                }
+            };
+        } // namespace test_helper
+    }     // namespace next
+} // namespace gridtools
+
+/**
+ * TODO maybe later: Simple 2x2 Cartesian hand-made mesh, non periodic, one halo line.
+ *
+ *     0e    1e    2e    3e
+ *   | --- | --- | --- | --- |
+ *   |0v   |1v   |2v   |3v   |4v
+ *   |  0c |  1c |  2c |  3c |
+ *   |     |     |     |     |
+ *   | --- | --- | --- | --- |
+ *   |     |     |     |     |
+ *   |  4c |  5c |  6c |  7c |
+ *   |     |     |     |     |
+ *   | --- | --- | --- | --- |
+ *   |     |     |     |     |
+ *   |  8c |  9c | 10c | 11c |
+ *   |     |     |     |     |
+ *   | --- | --- | --- | --- |
+ *   |     |     |     |     |
+ *   | 12c | 13c | 14c | 15c |
+ *   |     |     |     |     |
+ *   | --- | --- | --- | --- |
+ *
+ *
+ */
diff --git a/cpputil/unstructured/include/gridtools/next/tmp_storage.hpp b/cpputil/unstructured/include/gridtools/next/tmp_storage.hpp
new file mode 100644
index 0000000..f8c7d38
--- /dev/null
+++ b/cpputil/unstructured/include/gridtools/next/tmp_storage.hpp
@@ -0,0 +1,22 @@
+#include "unstructured.hpp"
+#include <gridtools/common/hymap.hpp>
+#include <gridtools/common/integral_constant.hpp>
+#include <gridtools/common/tuple_util.hpp>
+#include <gridtools/sid/contiguous.hpp>
+
+namespace gridtools {
+    namespace next {
+        namespace tmp_impl_ {
+            template <class LocationType>
+            auto sizes(int_t unstructured_size, int_t k_size) {
+                using value_t = typename hymap::keys<LocationType, dim::k>::template values<int_t, int_t>;
+                return value_t(unstructured_size, k_size);
+            }
+        } // namespace tmp_impl_
+
+        template <class LocationType, class Data, class Allocator>
+        auto make_simple_tmp_storage(int_t unstructured_size, int_t k_size, Allocator &alloc) {
+            return sid::make_contiguous<Data, int_t>(alloc, tmp_impl_::sizes<LocationType>(unstructured_size, k_size));
+        }
+    } // namespace next
+} // namespace gridtools
diff --git a/cpputil/unstructured/include/gridtools/next/unstructured.hpp b/cpputil/unstructured/include/gridtools/next/unstructured.hpp
index 2777937..bb00542 100644
--- a/cpputil/unstructured/include/gridtools/next/unstructured.hpp
+++ b/cpputil/unstructured/include/gridtools/next/unstructured.hpp
@@ -1,16 +1,13 @@
 #pragma once
 
-#include <gridtools/common/defs.hpp>
-#include <gridtools/common/integral_constant.hpp>
+// TODO namespace?
 
-namespace gridtools::next::dim {
-    using horizontal = integral_constant<int_t, 0>;
-    using vertical = integral_constant<int_t, 1>;
-    using neighbor = integral_constant<int_t, 1>;
-    using sparse = integral_constant<int_t, 2>;
+struct vertex;
+struct edge;
+struct cell;
 
-    using h = horizontal;
-    using k = vertical;
-    using n = neighbor;
-    using s = sparse;
-} // namespace gridtools::next::dim
+struct neighbor;
+
+namespace dim {
+    struct k;
+}
diff --git a/cpputil/unstructured/tests/include/util/CMakeLists.txt b/cpputil/unstructured/tests/include/util/CMakeLists.txt
new file mode 100644
index 0000000..e69de29
diff --git a/cpputil/unstructured/tests/include/util/atlas_util.hpp b/cpputil/unstructured/tests/include/util/atlas_util.hpp
new file mode 100644
index 0000000..5041e3f
--- /dev/null
+++ b/cpputil/unstructured/tests/include/util/atlas_util.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <atlas/functionspace/EdgeColumns.h>
+#include <atlas/grid/StructuredGrid.h>
+#include <atlas/mesh.h>
+#include <atlas/mesh/Mesh.h>
+#include <atlas/mesh/actions/BuildEdges.h>
+#include <atlas/meshgenerator/MeshGenerator.h>
+
+namespace atlas_util {
+
+    auto inline make_mesh(std::string const &grid_type = "O2") {
+        atlas::StructuredGrid structuredGrid = atlas::Grid(grid_type);
+        return atlas::StructuredMeshGenerator{}.generate(structuredGrid);
+    }
+
+    template <typename T = double>
+    auto inline make_edge_field(atlas::Mesh &mesh, int nb_levels) {
+        atlas::mesh::actions::build_edges(mesh);
+        atlas::functionspace::EdgeColumns fs_edges(mesh, atlas::option::levels(nb_levels) | atlas::option::halo(1));
+        return fs_edges.createField<T>();
+    }
+} // namespace atlas_util
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt b/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt
index 7b65cb8..109fa89 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/CMakeLists.txt
@@ -1,9 +1,27 @@
-add_executable(fvm_nabla driver.cc)
+function(add_driver_executable target driver_source stencil_source)
+    # generate temporary directory to generate driver code to
+    set(gen_dir ${CMAKE_CURRENT_BINARY_DIR}/generated_${target})
+    file(MAKE_DIRECTORY ${gen_dir})
+
+    # get absolute path to the stencil used in the driver template
+    get_filename_component(STENCIL_IMPL_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/${stencil_source} ABSOLUTE)
+
+    # generate driver source
+    get_filename_component(driver_source_file_name "${driver_source}" NAME)
+    configure_file(${driver_source} ${gen_dir}/${driver_source_file_name})
+
+    # gridtools_setup_target expects a relative path so transform it
+    file(RELATIVE_PATH gen_dir_rel ${CMAKE_CURRENT_SOURCE_DIR} ${gen_dir})
+
+    add_executable(${target} ${gen_dir_rel}/${driver_source_file_name})
+endfunction()
+
+add_driver_executable(fvm_nabla driver.cc nabla_naive.hpp)
 target_link_libraries(fvm_nabla PRIVATE atlas eckit GridTools::gridtools gtnext gtest gtest_main)
 add_test(NAME fvm_nabla COMMAND $<TARGET_FILE:fvm_nabla>)
 
 if(CMAKE_CUDA_COMPILER)
-    add_executable(fvm_nabla_cuda driver.cu)
+    add_driver_executable(fvm_nabla_cuda driver.cc nabla_cuda.hpp)
     target_link_libraries(fvm_nabla_cuda PRIVATE atlas eckit GridTools::gridtools GridTools::stencil_gpu gtnext gtest gtest_main)
     gridtools_setup_target(fvm_nabla_cuda CUDA_ARCH sm_50)
     target_compile_options(fvm_nabla_cuda PRIVATE "-std=c++17")
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/driver.cc b/cpputil/unstructured/tests/regression/fvm_nabla/driver.cc
index 9acb503..6f67d5a 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/driver.cc
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/driver.cc
@@ -1,6 +1,288 @@
+#include <fstream>
+#include <limits>
+
+#include "atlas/functionspace/EdgeColumns.h"
+#include "atlas/functionspace/NodeColumns.h"
+#include "atlas/grid.h"
+#include "atlas/mesh/actions/BuildCellCentres.h"
+#include "atlas/mesh/actions/BuildDualMesh.h"
+#include "atlas/mesh/actions/BuildEdges.h"
+#include "atlas/meshgenerator.h"
+#include "atlas/option/Options.h"
+#include "atlas/output/Gmsh.h"
+#include "gridtools/next/mesh.hpp"
+#include <atlas/array.h>
+#include <atlas/mesh.h>
+#include <atlas/mesh/Nodes.h>
+
+#include <gridtools/sid/composite.hpp>
+
+#include <gridtools/next/atlas_adapter.hpp>
+#include <gridtools/next/atlas_array_view_adapter.hpp>
+#include <gridtools/next/atlas_field_util.hpp>
+#include <tuple>
+
 #include <gtest/gtest.h>
 
-#include "driver.hpp"
-#include "nabla_naive.hpp"
+#include "${STENCIL_IMPL_SOURCE}"
+
+namespace {
+    template <typename DS>
+    std::tuple<double, double, double> min_max(DS const &field) {
+        double min = std::numeric_limits<double>::max();
+        double max = std::numeric_limits<double>::min();
+        auto view = field.m_impl->host_view(); // we are mixing SID with data_store concepts...
+
+        auto first_length = field.m_impl->lengths()[0];
+
+        double avg = 0.;
+        for (std::size_t jnode = 0; jnode < first_length; ++jnode) {
+            min = std::min(min, view(jnode, 0));
+            max = std::max(max, view(jnode, 0));
+            avg += view(jnode, 0);
+        }
+        return {min, max, avg / (double)first_length};
+    }
+} // namespace
+
+namespace {
+    const double rpi = 2.0 * std::asin(1.0);
+    const double radius = 6371.22e+03;
+    const double deg2rad = 2. * rpi / 360.;
+
+    const int MXX = 0;
+    const int MYY = 1;
+} // namespace
+
+class FVMDriver {
+  private:
+    atlas::Mesh mesh_;
+    atlas::functionspace::EdgeColumns fs_edges_;
+    atlas::functionspace::NodeColumns fs_nodes_;
+    int nb_levels_;
+
+    atlas::Field m_S_MXX;
+    atlas::Field m_S_MYY;
+
+    atlas::Field m_vol;
+    atlas::Field m_sign;
+
+  public:
+    constexpr static int edges_per_node = 7;
+
+    FVMDriver(std::string const &grid, int nb_levels)
+        : mesh_{[&grid]() {
+              atlas::StructuredGrid structuredGrid = atlas::Grid(grid);
+              atlas::MeshGenerator::Parameters generatorParams;
+              // generatorParams.set("three_dimensional", false);
+              generatorParams.set("triangulate", true);
+              // generatorParams.set("patch_pole", true);
+              // generatorParams.set("include_pole", false);
+              //   generatorParams.set("angle", 20);
+              generatorParams.set("angle", -1.0);
+              // generatorParams.set("ghost_at_end", true);
+
+              atlas::StructuredMeshGenerator generator(generatorParams);
+              return generator.generate(structuredGrid);
+          }()},
+          fs_edges_(mesh_, atlas::option::levels(nb_levels) | atlas::option::halo(1)),
+          fs_nodes_(mesh_,
+              atlas::option::levels(nb_levels) | atlas::option::halo(1)), //
+          nb_levels_(nb_levels), m_S_MXX(fs_edges_.createField<double>(atlas::option::name("S_MXX"))),
+          m_S_MYY(fs_edges_.createField<double>(atlas::option::name("S_MYY"))),
+          m_vol(fs_nodes_.createField<double>(atlas::option::name("vol"))),
+          m_sign(fs_nodes_.createField<double>(
+              atlas::option::name("m_sign") | atlas::option::variables(FVMDriver::edges_per_node))) {
+        atlas::mesh::actions::build_edges(mesh_);
+        atlas::mesh::actions::build_node_to_edge_connectivity(mesh_);
+        atlas::mesh::actions::build_median_dual_mesh(mesh_);
+
+        initialize_S();
+        // print_min_max(m_S_MXX);
+        // print_min_max(m_S_MYY);
+        initialize_sign();
+        initialize_vol();
+        // print_min_max(m_vol);
+    }
+
+  private:
+    void initialize_vol() {
+        // print_min_max_1d(mesh_.nodes().field("dual_volumes"));
+        const auto vol_atlas = atlas::array::make_view<double, 1>(mesh_.nodes().field("dual_volumes"));
+        auto vol = atlas::array::make_view<double, 2>(m_vol);
+        for (int i = 0, size = vol_atlas.size(); i < size; ++i) {
+            vol(i, 0) = vol_atlas(i) * (std::pow(deg2rad, 2) * std::pow(radius, 2));
+        }
+    }
+    void initialize_S() {
+        // all fields supported by dawn are 2 (or 3 with sparse) dimensional:
+        // (unstructured, lev, sparse) S has dimensions (unstructured, [MMX/MMY])
+        const auto S = atlas::array::make_view<double, 2>(mesh_.edges().field("dual_normals"));
+
+        auto S_MXX = atlas::array::make_view<double, 2>(m_S_MXX);
+        auto S_MYY = atlas::array::make_view<double, 2>(m_S_MYY);
+
+        assert(nb_levels_ == 1);
+        int klevel = 0;
+        for (int i = 0, size = mesh_.edges().size(); i < size; ++i) {
+            S_MXX(i, klevel) = S(i, MXX) * radius * deg2rad;
+            S_MYY(i, klevel) = S(i, MYY) * radius * deg2rad;
+        }
+    }
+
+    void initialize_sign() {
+        auto node2edge_sign = atlas::array::make_view<double, 3>(m_sign);
+
+        auto edge_flags = atlas::array::make_view<int, 1>(mesh_.edges().flags());
+        using Topology = atlas::mesh::Nodes::Topology;
+        auto is_pole_edge = [&](size_t e) { return Topology::check(edge_flags(e), Topology::POLE); };
+
+        for (atlas::idx_t jnode = 0; jnode < mesh_.nodes().size(); ++jnode) {
+            auto const &node_edge_connectivity = mesh_.nodes().edge_connectivity();
+            auto const &edge_node_connectivity = mesh_.edges().node_connectivity();
+            for (atlas::idx_t jedge = 0; jedge < node_edge_connectivity.cols(jnode); ++jedge) {
+                auto iedge = node_edge_connectivity(jnode, jedge);
+                auto ip1 = edge_node_connectivity(iedge, 0);
+                if (jnode == ip1) {
+                    node2edge_sign(jnode, 0, jedge) = 1.;
+                } else {
+                    node2edge_sign(jnode, 0, jedge) = -1.;
+                    if (is_pole_edge(iedge)) {
+                        node2edge_sign(jnode, 0, jedge) = 1.;
+                    }
+                }
+            }
+        }
+    }
+
+  public:
+    atlas::Mesh const &mesh() const { return mesh_; }
+    atlas::Mesh &mesh() { return mesh_; }
+    atlas::functionspace::EdgeColumns const &fs_edges() const { return fs_edges_; }
+    atlas::functionspace::NodeColumns const &fs_nodes() const { return fs_nodes_; }
+    int nb_levels() const { return nb_levels_; }
+    atlas::Field &S_MXX() { return m_S_MXX; }
+    atlas::Field &S_MYY() { return m_S_MYY; }
+    atlas::Field &vol() { return m_vol; }
+    atlas::Field &sign() { return m_sign; }
+
+    // TODO ask Christian for a proper name for this input data
+    void fillInputData(atlas::Field &field) const {
+        double zh0 = 2000.0;
+        double zrad = 3. * rpi / 4.0 * radius;
+        double zeta = rpi / 16.0 * radius;
+        double zlatc = 0.0;
+        double zlonc = 3.0 * rpi / 2.0;
+
+        atlas::Field m_rlonlatcr{
+            fs_nodes_.createField<double>(atlas::option::name("rlonlatcr") | atlas::option::variables(edges_per_node))};
+        auto rlonlatcr = atlas::array::make_view<double, 3>(m_rlonlatcr);
+
+        atlas::Field m_rcoords{
+            fs_nodes_.createField<double>(atlas::option::name("rcoords") | atlas::option::variables(edges_per_node))};
+        auto rcoords = atlas::array::make_view<double, 3>(m_rcoords);
+
+        atlas::Field m_rcosa{fs_nodes_.createField<double>(atlas::option::name("rcosa"))};
+        auto rcosa = atlas::array::make_view<double, 2>(m_rcosa);
+
+        atlas::Field m_rsina{fs_nodes_.createField<double>(atlas::option::name("rsina"))};
+        auto rsina = atlas::array::make_view<double, 2>(m_rsina);
+
+        auto rzs = atlas::array::make_view<double, 2>(field);
+
+        std::size_t k_level = 0;
+
+        const auto rcoords_deg = atlas::array::make_view<double, 2>(mesh_.nodes().field("lonlat"));
+
+        for (atlas::idx_t jnode = 0; jnode < mesh_.nodes().size(); ++jnode) {
+            for (std::size_t i = 0; i < 2; ++i) {
+                rcoords(jnode, k_level, i) = rcoords_deg(jnode, i) * deg2rad;
+                rlonlatcr(jnode, k_level, i) = rcoords(jnode, k_level, i); // lonlatcr is in physical space and may
+                                                                           // differ from coords later
+            }
+            rcosa(jnode, k_level) = cos(rlonlatcr(jnode, k_level, MYY));
+            rsina(jnode, k_level) = sin(rlonlatcr(jnode, k_level, MYY));
+        }
+        for (atlas::idx_t jnode = 0; jnode < mesh_.nodes().size(); ++jnode) {
+            double zlon = rlonlatcr(jnode, k_level, MXX);
+            //   double zlat = rlonlatcr(jnode, k_level, MYY);
+            double zdist = sin(zlatc) * rsina(jnode, k_level) + cos(zlatc) * rcosa(jnode, k_level) * cos(zlon - zlonc);
+            zdist = radius * acos(zdist);
+            rzs(jnode, k_level) = 0.0;
+            if (zdist < zrad) {
+                rzs(jnode, k_level) = rzs(jnode, k_level) + 0.5 * zh0 * (1.0 + cos(rpi * zdist / zrad)) *
+                                                                std::pow(cos(rpi * zdist / zeta), 2);
+            }
+        }
+    }
+};
+
+TEST(FVM, nabla) {
+
+    FVMDriver driver{"O32", 1};
+    // std::cout << "n_edges = " << driver.fs_edges()->size() << std::endl;
+    // std::cout << "n_nodes = " << driver.fs_nodes()->size() << std::endl;
+
+    // input
+    atlas::Field m_pp = driver.fs_nodes().createField<double>(atlas::option::name("pp"));
+
+    // output
+    atlas::Field m_pnabla_MXX = driver.fs_nodes().createField<double>(atlas::option::name("pnabla_MXX"));
+    atlas::Field m_pnabla_MYY = driver.fs_nodes().createField<double>(atlas::option::name("pnabla_MYY"));
+
+    // temporary
+    //  note: temporary fields are allocated in the stencil, but are still here if needed for debugging purposes
+    //atlas::Field m_zavgS_MXX = driver.fs_edges().createField<double>(atlas::option::name("zavgS_MXX"));
+    //atlas::Field m_zavgS_MYY = driver.fs_edges().createField<double>(atlas::option::name("zavgS_MYY"));
+
+    driver.fillInputData(m_pp);
+    //   print_min_max(m_pp);
+
+    //   atlas::output::Gmsh gmesh("mymesh.msh");
+    //   gmesh.write(driver.mesh());
+    //   gmesh.write(m_pp);
+
+    auto edge_sid = [](auto &&field) {
+        return gridtools::next::atlas_util::as_data_store<edge, dim::k>::with_type<double>{}(field);
+    };
+    auto node_sid = [](auto &&field) {
+        return gridtools::next::atlas_util::as_data_store<vertex, dim::k>::with_type<double>{}(field);
+    };
+
+    auto S_MXX_ds = edge_sid(driver.S_MXX());
+    auto S_MYY_ds = edge_sid(driver.S_MYY());
+    //auto m_zavgS_MXX_ds = edge_sid(m_zavgS_MXX);
+    //auto m_zavgS_MYY_ds = edge_sid(m_zavgS_MYY);
+    auto m_pp_ds = node_sid(m_pp);
+    auto m_pnabla_MXX_ds = node_sid(m_pnabla_MXX);
+    auto m_pnabla_MYY_ds = node_sid(m_pnabla_MYY);
+    auto vol_ds = node_sid(driver.vol());
+    auto sign_ds =
+        gridtools::next::atlas_util::as_data_store<vertex, dim::k, neighbor>::with_type<double>{}(driver.sign());
+
+    nabla(driver.mesh(),
+        S_MXX_ds,
+        S_MYY_ds,
+        m_pp_ds,
+        m_pnabla_MXX_ds,
+        m_pnabla_MYY_ds,
+        vol_ds,
+        sign_ds);
+
+    //   gmesh.write(m_pnabla_MXX);
+
+    /*auto [zavgS_x_min, zavgS_x_max, zavgS_x_avg] = min_max(m_zavgS_MXX_ds);
+    auto [zavgS_y_min, zavgS_y_max, zavgS_y_avg] = min_max(m_zavgS_MYY_ds);
+    EXPECT_DOUBLE_EQ(-199755464.25741270, zavgS_x_min);
+    EXPECT_DOUBLE_EQ(388241977.58389181, zavgS_x_max);
+    EXPECT_DOUBLE_EQ(-1000788897.3202186, zavgS_y_min);
+    EXPECT_DOUBLE_EQ(1000788897.3202186, zavgS_y_max);*/
+
+    auto [x_min, x_max, x_avg] = min_max(m_pnabla_MXX_ds);
+    auto [y_min, y_max, y_avg] = min_max(m_pnabla_MYY_ds);
 
-TEST(FVM, nabla) { driver(nabla); }
+    ASSERT_DOUBLE_EQ(-3.5455427772566003E-003, x_min);
+    ASSERT_DOUBLE_EQ(3.5455427772565435E-003, x_max);
+    ASSERT_DOUBLE_EQ(-3.3540113705465301E-003, y_min);
+    ASSERT_DOUBLE_EQ(3.3540113705465301E-003, y_max);
+}
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
index d7a00e6..1f8fc16 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_cuda.hpp
@@ -1,72 +1,300 @@
 #pragma once
-#include <gridtools/next/usid_cuda_helpers.hpp>
-namespace gridtools::next::cuda::nabla_impl_ {
-    struct v2e_tag;
-    struct e2v_tag;
-    struct S_MXX_tag;
-    struct S_MYY_tag;
-    struct zavgS_MXX_tag;
-    struct zavgS_MYY_tag;
-    struct pnabla_MXX_tag;
-    struct pnabla_MYY_tag;
-    struct vol_tag;
-    struct sign_tag;
-    struct pp_tag;
-    struct kernel_0 {
-        GT_FUNCTION auto operator()() const {
-            return [](auto &&ptr, auto &&strides, auto &&neighbors) {
-                auto zavg = 0.5 * sum_neighbors<double, e2v_tag, 2, false>(
-                                      [](auto &&, auto &&n) { return field<pp_tag>(n); }, ptr, strides, neighbors);
-                field<zavgS_MXX_tag>(ptr) = field<S_MXX_tag>(ptr) * zavg;
-                field<zavgS_MYY_tag>(ptr) = field<S_MYY_tag>(ptr) * zavg;
-            };
+
+#ifndef __CUDACC__
+#error "Tried to compile CUDA code with a regular C++ compiler."
+#endif
+
+#include <gridtools/next/mesh.hpp>
+#include <gridtools/next/tmp_storage.hpp>
+#include <gridtools/sid/allocator.hpp>
+
+struct connectivity_tag;
+struct S_MXX_tag;
+struct S_MYY_tag;
+struct zavgS_MXX_tag;
+struct zavgS_MYY_tag;
+struct zavg_tag;
+
+struct pnabla_MXX_tag;
+struct pnabla_MYY_tag;
+struct vol_tag;
+struct sign_tag;
+struct pp_tag;
+
+template <class ConnInfoE2V, class EdgePtrs, class EdgeStrides, class VertexNeighborPtrs, class VertexNeighborStrides>
+__global__ void nabla_edge_1(ConnInfoE2V e2v,
+    EdgePtrs edge_ptr_holders,
+    EdgeStrides edge_strides,
+    VertexNeighborPtrs vertex_neighbor_ptr_holders,
+    VertexNeighborStrides vertex_neighbor_strides) {
+    { // first edge loop (this is the fused version without temporary)
+        // ===
+        //   for (auto const &t : getEdges(LibTag{}, mesh)) {
+        //     double zavg =
+        //         (double)0.5 *
+        //         (m_sparse_dimension_idx = 0,
+        //          reduceVertexToEdge(mesh, t, (double)0.0,
+        //                             [&](auto &lhs, auto const &redIdx) {
+        //                               lhs += pp(deref(LibTag{}, redIdx), k);
+        //                               m_sparse_dimension_idx++;
+        //                               return lhs;
+        //                             }));
+        //     zavgS_MXX(deref(LibTag{}, t), k) =
+        //         S_MXX(deref(LibTag{}, t), k) * zavg;
+        //     zavgS_MYY(deref(LibTag{}, t), k) =
+        //         S_MYY(deref(LibTag{}, t), k) * zavg;
+        //   }
+        // ===
+        auto idx = blockIdx.x * blockDim.x + threadIdx.x;
+        if (idx >= e2v.size)
+            return;
+
+        auto edge_ptrs = edge_ptr_holders();
+
+        gridtools::sid::shift(edge_ptrs, gridtools::device::at_key<edge>(edge_strides), idx);
+
+        double acc = 0.;
+        { // reduce
+            for (int neigh = 0; neigh < e2v.max_neighbors; ++neigh) {
+                // body
+                auto absolute_neigh_index = *gridtools::device::at_key<connectivity_tag>(edge_ptrs);
+                auto vertex_ptrs = vertex_neighbor_ptr_holders();
+                gridtools::sid::shift(
+                    vertex_ptrs, gridtools::device::at_key<vertex>(vertex_neighbor_strides), absolute_neigh_index);
+
+                acc += *gridtools::device::at_key<pp_tag>(vertex_ptrs);
+                // body end
+
+                gridtools::sid::shift(edge_ptrs, gridtools::device::at_key<neighbor>(edge_strides), 1);
+            }
+            gridtools::sid::shift(edge_ptrs, gridtools::device::at_key<neighbor>(edge_strides), -e2v.max_neighbors);
         }
-    };
-    struct kernel_1 {
-        GT_FUNCTION auto operator()() const {
-            return [](auto &&ptr, auto &&strides, auto &&neighbors) {
-                field<pnabla_MXX_tag>(ptr) = sum_neighbors<double, v2e_tag, 7>(
-                    [](auto &&p, auto &&n) { return field<zavgS_MXX_tag>(n) * field<sign_tag>(p); },
-                    ptr,
-                    strides,
-                    neighbors);
-                field<pnabla_MYY_tag>(ptr) = sum_neighbors<double, v2e_tag, 7>(
-                    [](auto &&p, auto &&n) { return field<zavgS_MYY_tag>(n) * field<sign_tag>(p); },
-                    ptr,
-                    strides,
-                    neighbors);
-                field<pnabla_MXX_tag>(ptr) = field<pnabla_MXX_tag>(ptr) / field<vol_tag>(ptr);
-                field<pnabla_MYY_tag>(ptr) = field<pnabla_MYY_tag>(ptr) / field<vol_tag>(ptr);
-            };
+        *gridtools::device::at_key<zavg_tag>(edge_ptrs) =
+            0.5 * acc; // via temporary for non-optimized parallel model
+        *gridtools::device::at_key<zavgS_MXX_tag>(edge_ptrs) =
+            *gridtools::device::at_key<S_MXX_tag>(edge_ptrs) * *gridtools::device::at_key<zavg_tag>(edge_ptrs);
+        *gridtools::device::at_key<zavgS_MYY_tag>(edge_ptrs) =
+            *gridtools::device::at_key<S_MYY_tag>(edge_ptrs) * *gridtools::device::at_key<zavg_tag>(edge_ptrs);
+    }
+}
+
+template <class ConnInfoV2E,
+    class VertexOrigins,
+    class VertexStrides,
+    class EdgeNeighborOrigins,
+    class EdgeNeighborStrides>
+__global__ void nabla_vertex_2(ConnInfoV2E v2e,
+    VertexOrigins vertex_origins,
+    VertexStrides vertex_strides,
+    EdgeNeighborOrigins edge_neighbor_origins,
+    EdgeNeighborStrides edge_neighbor_strides) {
+    // vertex loop
+    // for (auto const &t : getVertices(LibTag{}, mesh)) {
+    //     pnabla_MXX(deref(LibTag{}, t), k) =
+    //         (m_sparse_dimension_idx = 0,
+    //          reduceEdgeToVertex(
+    //              mesh, t, (double)0.0, [&](auto &lhs, auto const &redIdx) {
+    //                lhs += zavgS_MXX(deref(LibTag{}, redIdx), k) *
+    //                       sign(deref(LibTag{}, t), m_sparse_dimension_idx,
+    //                       k);
+    //                m_sparse_dimension_idx++;
+    //                return lhs;
+    //              }));
+    //   }
+    //   for (auto const &t : getVertices(LibTag{}, mesh)) {
+    //     pnabla_MYY(deref(LibTag{}, t), k) =
+    //         (m_sparse_dimension_idx = 0,
+    //          reduceEdgeToVertex(
+    //              mesh, t, (double)0.0, [&](auto &lhs, auto const &redIdx) {
+    //                lhs += zavgS_MYY(deref(LibTag{}, redIdx), k) *
+    //                       sign(deref(LibTag{}, t), m_sparse_dimension_idx,
+    //                       k);
+    //                m_sparse_dimension_idx++;
+    //                return lhs;
+    //              }));
+    //   }
+
+    auto idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx >= v2e.size)
+        return;
+
+    auto vertex_ptrs = vertex_origins();
+
+    gridtools::sid::shift(vertex_ptrs, gridtools::device::at_key<vertex>(vertex_strides), idx);
+
+    *gridtools::device::at_key<pnabla_MXX_tag>(vertex_ptrs) = 0.;
+    { // reduce
+        for (int neigh = 0; neigh < v2e.max_neighbors; ++neigh) {
+            // body
+            auto absolute_neigh_index = *gridtools::device::at_key<connectivity_tag>(vertex_ptrs);
+            if (absolute_neigh_index != v2e.skip_value) {
+                auto edge_ptrs = edge_neighbor_origins();
+                gridtools::sid::shift(
+                    edge_ptrs, gridtools::device::at_key<edge>(edge_neighbor_strides), absolute_neigh_index);
+
+                auto zavgS_MXX_value = *gridtools::device::at_key<zavgS_MXX_tag>(edge_ptrs);
+                auto sign_value = *gridtools::device::at_key<sign_tag>(vertex_ptrs);
+
+                *gridtools::device::at_key<pnabla_MXX_tag>(vertex_ptrs) += zavgS_MXX_value * sign_value;
+                // body end
+            }
+            gridtools::sid::shift(vertex_ptrs, gridtools::device::at_key<neighbor>(vertex_strides), 1);
         }
-    };
-    inline constexpr auto nabla = [](domain d, auto &&v2e, auto &&e2v) {
-        static_assert(is_sid<decltype(v2e(traits_t()))>());
-        static_assert(is_sid<decltype(e2v(traits_t()))>());
-        return
-            [d = std::move(d),
-                v2e = sid::rename_dimensions<dim::n, v2e_tag>(std::forward<decltype(v2e)>(v2e)(traits_t())),
-                e2v = sid::rename_dimensions<dim::n, e2v_tag>(std::forward<decltype(e2v)>(e2v)(traits_t()))](
-                auto &&S_MXX, auto &&S_MYY, auto &&pp, auto &&pnabla_MXX, auto &&pnabla_MYY, auto &&vol, auto &&sign) {
-                static_assert(is_sid<decltype(S_MXX)>());
-                static_assert(is_sid<decltype(S_MYY)>());
-                static_assert(is_sid<decltype(pp)>());
-                static_assert(is_sid<decltype(pnabla_MXX)>());
-                static_assert(is_sid<decltype(pnabla_MYY)>());
-                static_assert(is_sid<decltype(vol)>());
-                static_assert(is_sid<decltype(sign)>());
-                auto alloc = make_allocator();
-                auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
-                auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
-                call_kernel<kernel_0>(d.edge,
-                    sid::composite::make<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>(
-                        e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY),
-                    sid::composite::make<pp_tag>(pp));
-                call_kernel<kernel_1>(d.vertex,
-                    sid::composite::make<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag, vol_tag>(
-                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_tag>(sign), vol),
-                    sid::composite::make<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX, zavgS_MYY));
-            };
-    };
-} // namespace gridtools::next::cuda::nabla_impl_
-using gridtools::next::cuda::nabla_impl_::nabla;
+        gridtools::sid::shift(vertex_ptrs,
+            gridtools::device::at_key<neighbor>(vertex_strides),
+            -v2e.max_neighbors); // or reset ptr to origin and shift ?
+    }
+    *gridtools::device::at_key<pnabla_MYY_tag>(vertex_ptrs) = 0.;
+    { // reduce
+        for (int neigh = 0; neigh < v2e.max_neighbors; ++neigh) {
+            // body
+            auto absolute_neigh_index = *gridtools::device::at_key<connectivity_tag>(vertex_ptrs);
+            if (absolute_neigh_index != v2e.skip_value) {
+                auto edge_ptrs = edge_neighbor_origins();
+                gridtools::sid::shift(
+                    edge_ptrs, gridtools::device::at_key<edge>(edge_neighbor_strides), absolute_neigh_index);
+
+                auto zavgS_MYY_value = *gridtools::device::at_key<zavgS_MYY_tag>(edge_ptrs);
+                auto sign_value = *gridtools::device::at_key<sign_tag>(vertex_ptrs);
+                ;
+
+                *gridtools::device::at_key<pnabla_MYY_tag>(vertex_ptrs) += zavgS_MYY_value * sign_value;
+                // body end
+            }
+            gridtools::sid::shift(vertex_ptrs, gridtools::device::at_key<neighbor>(vertex_strides), 1);
+        }
+        gridtools::sid::shift(vertex_ptrs, gridtools::device::at_key<neighbor>(vertex_strides), -v2e.max_neighbors);
+    }
+}
+// ===
+//   do jedge = 1,dstruct%nb_pole_edges
+//     iedge = dstruct%pole_edges(jedge)
+//     ip2   = dstruct%edges(2,iedge)
+//     ! correct for wrong Y-derivatives in previous loop
+//     pnabla(MYY,ip2) = pnabla(MYY,ip2)+2.0_wp*zavgS(MYY,iedge)
+//   end do
+// ===
+//   {
+//     auto pe2v = gridtools::next::mesh::connectivity<
+//         std::tuple<atlas::pole_edge, vertex>>(mesh);
+//     for (int i = 0; i < gridtools::next::connectivity::size(pe2v);
+//          ++i) {
+//     }
+//   }
+template <class VertexOrigins, class VertexStrides>
+__global__ void nabla_vertex_4(std::size_t size, VertexOrigins vertex_origins, VertexStrides vertex_strides) {
+    // vertex loop
+    // for (auto const &t : getVertices(LibTag{}, mesh)) {
+    //     pnabla_MXX(deref(LibTag{}, t), k) =
+    //         pnabla_MXX(deref(LibTag{}, t), k) / vol(deref(LibTag{}, t), k);
+    //     pnabla_MYY(deref(LibTag{}, t), k) =
+    //         pnabla_MYY(deref(LibTag{}, t), k) / vol(deref(LibTag{}, t), k);
+    //   }
+
+    auto idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx >= size)
+        return;
+
+    auto vertex_ptrs = vertex_origins();
+
+    gridtools::sid::shift(vertex_ptrs, gridtools::device::at_key<vertex>(vertex_strides), idx);
+
+    *gridtools::device::at_key<pnabla_MXX_tag>(vertex_ptrs) /= *gridtools::device::at_key<vol_tag>(vertex_ptrs);
+    *gridtools::device::at_key<pnabla_MYY_tag>(vertex_ptrs) /= *gridtools::device::at_key<vol_tag>(vertex_ptrs);
+}
+
+std::tuple<int, int> cuda_setup(int N) {
+    int threads_per_block = 32;
+    int blocks = (N + threads_per_block - 1) / threads_per_block;
+    return {blocks, threads_per_block};
+}
+
+template <class Mesh,
+    class S_MXX_t,
+    class S_MYY_t,
+    class pp_t,
+    class pnabla_MXX_t,
+    class pnabla_MYY_t,
+    class vol_t,
+    class sign_t>
+void nabla(Mesh &&mesh,
+    S_MXX_t &&S_MXX,
+    S_MYY_t &&S_MYY,
+    pp_t &&pp,
+    pnabla_MXX_t &&pnabla_MXX,
+    pnabla_MYY_t &&pnabla_MYY,
+    vol_t &&vol,
+    sign_t &&sign) {
+    namespace tu = gridtools::tuple_util;
+    // allocate temporary field storage
+    int k_size = 1; // TODO
+    auto cuda_alloc =
+        gridtools::sid::device::make_cached_allocator(&gridtools::cuda_util::cuda_malloc<char[]>); // TODO
+    auto zavgS_MXX = gridtools::next::make_simple_tmp_storage<edge, double>(
+        (int)gridtools::next::connectivity::size(gridtools::next::mesh::connectivity<edge>(mesh)), k_size, cuda_alloc);
+    auto zavgS_MYY = gridtools::next::make_simple_tmp_storage<edge, double>(
+        (int)gridtools::next::connectivity::size(gridtools::next::mesh::connectivity<edge>(mesh)), k_size, cuda_alloc);
+    {
+        auto e2v = gridtools::next::mesh::connectivity<std::tuple<edge, vertex>>(mesh);
+        static_assert(gridtools::is_sid<decltype(gridtools::next::connectivity::neighbor_table(e2v))>{});
+
+        auto zavg = gridtools::next::make_simple_tmp_storage<edge, double>(
+            (int)gridtools::next::connectivity::size(gridtools::next::mesh::connectivity<edge>(mesh)), k_size, cuda_alloc);
+
+        auto edge_fields = tu::make<gridtools::sid::composite::
+                keys<connectivity_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag, zavg_tag>::values>(
+            gridtools::next::connectivity::neighbor_table(e2v), S_MXX, S_MYY, zavgS_MXX, zavgS_MYY, zavg);
+        static_assert(gridtools::sid::concept_impl_::is_sid<decltype(edge_fields)>{});
+
+        auto edge_ptrs = gridtools::sid::get_origin(edge_fields);
+        auto edge_strides = gridtools::sid::get_strides(edge_fields);
+
+        auto vertex_neighbor_fields = tu::make<gridtools::sid::composite::keys<pp_tag>::values>(pp);
+        auto vertex_neighbor_ptrs = gridtools::sid::get_origin(vertex_neighbor_fields);
+        auto vertex_neighbor_strides = gridtools::sid::get_strides(vertex_neighbor_fields);
+
+        auto [blocks, threads_per_block] = cuda_setup(gridtools::next::connectivity::size(e2v));
+
+        auto e2v_info = gridtools::next::connectivity::extract_info(e2v);
+
+        nabla_edge_1<<<blocks, threads_per_block>>>(
+            e2v_info, edge_ptrs, edge_strides, vertex_neighbor_ptrs, vertex_neighbor_strides);
+        GT_CUDA_CHECK(cudaDeviceSynchronize());
+    } // namespace gridtools::tuple_util;
+    {
+        auto v2e = gridtools::next::mesh::connectivity<std::tuple<vertex, edge>>(mesh);
+        static_assert(gridtools::is_sid<decltype(gridtools::next::connectivity::neighbor_table(v2e))>{});
+
+        auto vertex_fields = tu::make<gridtools::sid::composite::
+                keys<connectivity_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag, vol_tag>::values>(
+            gridtools::next::connectivity::neighbor_table(v2e), pnabla_MXX, pnabla_MYY, sign, vol);
+        static_assert(gridtools::sid::concept_impl_::is_sid<decltype(vertex_fields)>{});
+
+        auto edge_neighbor_fields =
+            tu::make<gridtools::sid::composite::keys<zavgS_MXX_tag, zavgS_MYY_tag>::values>(zavgS_MXX, zavgS_MYY);
+
+        auto v2e_info = gridtools::next::connectivity::extract_info(v2e);
+
+        auto [blocks, threads_per_block] = cuda_setup(gridtools::next::connectivity::size(v2e));
+        nabla_vertex_2<<<blocks, threads_per_block>>>(v2e_info,
+            gridtools::sid::get_origin(vertex_fields),
+            gridtools::sid::get_strides(vertex_fields),
+            gridtools::sid::get_origin(edge_neighbor_fields),
+            gridtools::sid::get_strides(edge_neighbor_fields));
+        GT_CUDA_CHECK(cudaDeviceSynchronize());
+    }
+    {
+        auto vertices = gridtools::next::mesh::connectivity<std::tuple<vertex>>(mesh);
+
+        auto vertex_fields = tu::make<gridtools::sid::composite::keys<pnabla_MXX_tag, pnabla_MYY_tag, vol_tag>::values>(
+            pnabla_MXX, pnabla_MYY, vol);
+        static_assert(gridtools::sid::concept_impl_::is_sid<decltype(vertex_fields)>{});
+
+        auto size = gridtools::next::connectivity::size(vertices);
+
+        auto [blocks, threads_per_block] = cuda_setup(gridtools::next::connectivity::size(vertices));
+        nabla_vertex_4<<<blocks, threads_per_block>>>(
+            size, gridtools::sid::get_origin(vertex_fields), gridtools::sid::get_strides(vertex_fields));
+        GT_CUDA_CHECK(cudaDeviceSynchronize());
+    }
+}
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
index c8742da..5eba3d1 100644
--- a/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
+++ b/cpputil/unstructured/tests/regression/fvm_nabla/nabla_naive.hpp
@@ -1,66 +1,244 @@
 #pragma once
-#include <gridtools/next/usid_naive_helpers.hpp>
-namespace gridtools::next::naive::nabla_impl_ {
-    struct v2e_tag;
-    struct e2v_tag;
-    struct S_MXX_tag;
-    struct S_MYY_tag;
-    struct zavgS_MXX_tag;
-    struct zavgS_MYY_tag;
-    struct pnabla_MXX_tag;
-    struct pnabla_MYY_tag;
-    struct vol_tag;
-    struct sign_tag;
-    struct pp_tag;
-    struct kernel_0 {
-        GT_FUNCTION auto operator()() const {
-            return [](auto &&e, auto &&strides, auto &&v) {
-                auto zavg = 0.5 * sum_neighbors<double, e2v_tag, 2, false>(
-                                      [](auto &&e, auto &&v) { return field<pp_tag>(v); }, e, strides, v);
-                field<zavgS_MXX_tag>(e) = field<S_MXX_tag>(e) * zavg;
-                field<zavgS_MYY_tag>(e) = field<S_MYY_tag>(e) * zavg;
-            };
+
+#include <gridtools/next/tmp_storage.hpp>
+#include <gridtools/sid/allocator.hpp>
+
+struct connectivity_tag;
+struct S_MXX_tag;
+struct S_MYY_tag;
+struct zavgS_MXX_tag;
+struct zavgS_MYY_tag;
+
+struct pnabla_MXX_tag;
+struct pnabla_MYY_tag;
+struct vol_tag;
+struct sign_tag;
+
+template <class Mesh,
+    class S_MXX_t,
+    class S_MYY_t,
+    class pp_t,
+    class pnabla_MXX_t,
+    class pnabla_MYY_t,
+    class vol_t,
+    class sign_t>
+void nabla(Mesh &&mesh,
+    S_MXX_t &&S_MXX,
+    S_MYY_t &&S_MYY,
+    pp_t &&pp,
+    pnabla_MXX_t &&pnabla_MXX,
+    pnabla_MYY_t &&pnabla_MYY,
+    vol_t &&vol,
+    sign_t &&sign) {
+    namespace tu = gridtools::tuple_util;
+
+    static_assert(gridtools::is_sid<S_MXX_t>{});
+    static_assert(gridtools::is_sid<S_MYY_t>{});
+    static_assert(gridtools::is_sid<pp_t>{});
+    static_assert(gridtools::is_sid<pnabla_MXX_t>{});
+    static_assert(gridtools::is_sid<pnabla_MYY_t>{});
+    static_assert(gridtools::is_sid<vol_t>{});
+    static_assert(gridtools::is_sid<sign_t>{});
+
+    // allocate temporary field storage
+    int k_size = 1; // TODO
+    auto alloc = gridtools::sid::make_cached_allocator(&std::make_unique<char[]>);
+    auto zavgS_MXX = gridtools::next::make_simple_tmp_storage<edge, double>(
+        (int)gridtools::next::connectivity::size(gridtools::next::mesh::connectivity<std::tuple<edge>>(mesh)), k_size, alloc);
+    auto zavgS_MYY = gridtools::next::make_simple_tmp_storage<edge, double>(
+        (int)gridtools::next::connectivity::size(gridtools::next::mesh::connectivity<std::tuple<edge>>(mesh)), k_size, alloc);
+
+    { // first edge loop (this is the fused version without temporary)
+        // ===
+        //   for (auto const &t : getEdges(LibTag{}, mesh)) {
+        //     double zavg =
+        //         (double)0.5 *
+        //         (m_sparse_dimension_idx = 0,
+        //          reduceVertexToEdge(mesh, t, (double)0.0,
+        //                             [&](auto &lhs, auto const &redIdx) {
+        //                               lhs += pp(deref(LibTag{}, redIdx), k);
+        //                               m_sparse_dimension_idx++;
+        //                               return lhs;
+        //                             }));
+        //     zavgS_MXX(deref(LibTag{}, t), k) =
+        //         S_MXX(deref(LibTag{}, t), k) * zavg;
+        //     zavgS_MYY(deref(LibTag{}, t), k) =
+        //         S_MYY(deref(LibTag{}, t), k) * zavg;
+        //   }
+        // ===
+        auto e2v = gridtools::next::mesh::connectivity<std::tuple<edge, vertex>>(mesh);
+        static_assert(gridtools::is_sid<decltype(gridtools::next::connectivity::neighbor_table(e2v))>{});
+
+        auto edge_fields = tu::make<gridtools::sid::composite::
+                keys<connectivity_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>::values>(
+            gridtools::next::connectivity::neighbor_table(e2v), S_MXX, S_MYY, zavgS_MXX, zavgS_MYY);
+        static_assert(gridtools::sid::concept_impl_::is_sid<decltype(edge_fields)>{});
+
+        auto ptrs = gridtools::sid::get_origin(edge_fields)();
+        auto strides = gridtools::sid::get_strides(edge_fields);
+        for (std::size_t i = 0; i < gridtools::next::connectivity::size(e2v); ++i) {
+            double acc = 0.;
+            { // reduce
+                for (int neigh = 0; neigh < static_cast<int>(gridtools::next::connectivity::max_neighbors(e2v));
+                     ++neigh) {
+                    // body
+                    auto absolute_neigh_index = *gridtools::at_key<connectivity_tag>(ptrs);
+
+                    auto pp_ptr = gridtools::sid::get_origin(pp)();
+                    gridtools::sid::shift(
+                        pp_ptr, gridtools::at_key<vertex>(gridtools::sid::get_strides(pp)), absolute_neigh_index);
+                    acc += *pp_ptr;
+                    // body end
+
+                    gridtools::sid::shift(ptrs, gridtools::at_key<neighbor>(strides), 1);
+                }
+                gridtools::sid::shift(ptrs,
+                    gridtools::at_key<neighbor>(strides),
+                    -gridtools::next::connectivity::max_neighbors(e2v)); // or reset ptr to origin and shift ?
+            }
+            double zavg = 0.5 * acc;
+            *gridtools::at_key<zavgS_MXX_tag>(ptrs) = *gridtools::at_key<S_MXX_tag>(ptrs) * zavg;
+            *gridtools::at_key<zavgS_MYY_tag>(ptrs) = *gridtools::at_key<S_MYY_tag>(ptrs) * zavg;
+
+            gridtools::sid::shift(ptrs, gridtools::at_key<edge>(strides), 1);
         }
-    };
-    struct kernel_1 {
-        GT_FUNCTION auto operator()() const {
-            return [](auto &&v, auto &&strides, auto &&e) {
-                field<pnabla_MXX_tag>(v) = sum_neighbors<double, v2e_tag, 7>(
-                    [](auto &&v, auto &&e) { return field<zavgS_MXX_tag>(e) * field<sign_tag>(v); }, v, strides, e);
-                field<pnabla_MYY_tag>(v) = sum_neighbors<double, v2e_tag, 7>(
-                    [](auto &&v, auto &&e) { return field<zavgS_MYY_tag>(e) * field<sign_tag>(v); }, v, strides, e);
-                field<pnabla_MXX_tag>(v) = field<pnabla_MXX_tag>(v) / field<vol_tag>(v);
-                field<pnabla_MYY_tag>(v) = field<pnabla_MYY_tag>(v) / field<vol_tag>(v);
-            };
+    }
+    {
+        // vertex loop
+        // for (auto const &t : getVertices(LibTag{}, mesh)) {
+        //     pnabla_MXX(deref(LibTag{}, t), k) =
+        //         (m_sparse_dimension_idx = 0,
+        //          reduceEdgeToVertex(
+        //              mesh, t, (double)0.0, [&](auto &lhs, auto const &redIdx) {
+        //                lhs += zavgS_MXX(deref(LibTag{}, redIdx), k) *
+        //                       sign(deref(LibTag{}, t), m_sparse_dimension_idx,
+        //                       k);
+        //                m_sparse_dimension_idx++;
+        //                return lhs;
+        //              }));
+        //   }
+        //   for (auto const &t : getVertices(LibTag{}, mesh)) {
+        //     pnabla_MYY(deref(LibTag{}, t), k) =
+        //         (m_sparse_dimension_idx = 0,
+        //          reduceEdgeToVertex(
+        //              mesh, t, (double)0.0, [&](auto &lhs, auto const &redIdx) {
+        //                lhs += zavgS_MYY(deref(LibTag{}, redIdx), k) *
+        //                       sign(deref(LibTag{}, t), m_sparse_dimension_idx,
+        //                       k);
+        //                m_sparse_dimension_idx++;
+        //                return lhs;
+        //              }));
+        //   }
+        auto v2e = gridtools::next::mesh::connectivity<std::tuple<vertex, edge>>(mesh);
+        static_assert(gridtools::is_sid<decltype(gridtools::next::connectivity::neighbor_table(v2e))>{});
+
+        auto vertex_fields = tu::make<gridtools::sid::composite::
+                keys<connectivity_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag, vol_tag>::values>(
+            gridtools::next::connectivity::neighbor_table(v2e), pnabla_MXX, pnabla_MYY, sign, vol);
+        static_assert(gridtools::sid::concept_impl_::is_sid<decltype(vertex_fields)>{});
+
+        auto ptrs = gridtools::sid::get_origin(vertex_fields)();
+        auto strides = gridtools::sid::get_strides(vertex_fields);
+
+        for (std::size_t i = 0; i < gridtools::next::connectivity::size(v2e); ++i) {
+            *gridtools::at_key<pnabla_MXX_tag>(ptrs) = 0.;
+            { // reduce
+                for (int neigh = 0; neigh < static_cast<int>(gridtools::next::connectivity::max_neighbors(v2e));
+                     ++neigh) {
+                    // body
+                    auto absolute_neigh_index = *gridtools::at_key<connectivity_tag>(ptrs);
+                    if (absolute_neigh_index != gridtools::next::connectivity::skip_value(v2e)) {
+
+                        auto zavgS_MXX_ptr = gridtools::sid::get_origin(zavgS_MXX)();
+                        gridtools::sid::shift(zavgS_MXX_ptr,
+                            gridtools::at_key<edge>(gridtools::sid::get_strides(zavgS_MXX)),
+                            absolute_neigh_index);
+                        auto zavgS_MXX_value = *zavgS_MXX_ptr;
+
+                        auto sign_ptr = gridtools::at_key<sign_tag>(ptrs); // if the sparse dimension is tagged with
+                                                                           // neighbor, the ptr is already correct
+                        auto sign_value = *sign_ptr;
+
+                        *gridtools::at_key<pnabla_MXX_tag>(ptrs) += zavgS_MXX_value * sign_value;
+                        // body end
+                    }
+                    gridtools::sid::shift(ptrs, gridtools::at_key<neighbor>(strides), 1);
+                }
+                gridtools::sid::shift(ptrs,
+                    gridtools::at_key<neighbor>(strides),
+                    -gridtools::next::connectivity::max_neighbors(v2e)); // or reset ptr to origin and shift ?
+            }
+            *gridtools::at_key<pnabla_MYY_tag>(ptrs) = 0.;
+            { // reduce
+                for (int neigh = 0; neigh < static_cast<int>(gridtools::next::connectivity::max_neighbors(v2e));
+                     ++neigh) {
+                    // body
+                    auto absolute_neigh_index = *gridtools::at_key<connectivity_tag>(ptrs);
+                    if (absolute_neigh_index != gridtools::next::connectivity::skip_value(v2e)) {
+
+                        auto zavgS_MYY_ptr = gridtools::sid::get_origin(zavgS_MYY)();
+                        gridtools::sid::shift(zavgS_MYY_ptr,
+                            gridtools::at_key<edge>(gridtools::sid::get_strides(zavgS_MYY)),
+                            absolute_neigh_index);
+                        auto zavgS_YY_value = *zavgS_MYY_ptr;
+
+                        // if the sparse dimension is tagged with `neighbor`, the ptr is
+                        // already correct
+                        auto sign_ptr = gridtools::at_key<sign_tag>(ptrs);
+                        auto sign_value = *sign_ptr;
+
+                        *gridtools::at_key<pnabla_MYY_tag>(ptrs) += zavgS_YY_value * sign_value;
+                        // body end
+                    }
+                    gridtools::sid::shift(ptrs, gridtools::at_key<neighbor>(strides), 1);
+                }
+                // the following or reset ptr to origin and shift ?
+                gridtools::sid::shift(
+                    ptrs, gridtools::at_key<neighbor>(strides), -gridtools::next::connectivity::max_neighbors(v2e));
+            }
+            gridtools::sid::shift(ptrs, gridtools::at_key<vertex>(strides), 1);
         }
-    };
-    inline constexpr auto nabla = [](domain d, auto &&v2e, auto &&e2v) {
-        static_assert(is_sid<decltype(v2e(traits_t()))>());
-        static_assert(is_sid<decltype(e2v(traits_t()))>());
-        return
-            [d = std::move(d),
-                v2e = sid::rename_dimensions<dim::n, v2e_tag>(std::forward<decltype(v2e)>(v2e)(traits_t())),
-                e2v = sid::rename_dimensions<dim::n, e2v_tag>(std::forward<decltype(e2v)>(e2v)(traits_t()))](
-                auto &&S_MXX, auto &&S_MYY, auto &&pp, auto &&pnabla_MXX, auto &&pnabla_MYY, auto &&vol, auto &&sign) {
-                static_assert(is_sid<decltype(S_MXX)>());
-                static_assert(is_sid<decltype(S_MYY)>());
-                static_assert(is_sid<decltype(pp)>());
-                static_assert(is_sid<decltype(pnabla_MXX)>());
-                static_assert(is_sid<decltype(pnabla_MYY)>());
-                static_assert(is_sid<decltype(vol)>());
-                static_assert(is_sid<decltype(sign)>());
-                auto alloc = make_allocator();
-                auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
-                auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
-                call_kernel<kernel_0>(d.edge,
-                    sid::composite::make<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>(
-                        e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY),
-                    sid::composite::make<pp_tag>(pp));
-                call_kernel<kernel_1>(d.vertex,
-                    sid::composite::make<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag, vol_tag>(
-                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_tag>(sign), vol),
-                    sid::composite::make<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX, zavgS_MYY));
-            };
-    };
-} // namespace gridtools::next::naive::nabla_impl_
-using gridtools::next::naive::nabla_impl_::nabla;
+    }
+
+    // ===
+    //   do jedge = 1,dstruct%nb_pole_edges
+    //     iedge = dstruct%pole_edges(jedge)
+    //     ip2   = dstruct%edges(2,iedge)
+    //     ! correct for wrong Y-derivatives in previous loop
+    //     pnabla(MYY,ip2) = pnabla(MYY,ip2)+2.0_wp*zavgS(MYY,iedge)
+    //   end do
+    // ===
+    //   {
+    //     auto pe2v = gridtools::next::mesh::connectivity<
+    //         std::tuple<atlas::pole_edge, vertex>>(mesh);
+    //     for (int i = 0; i < gridtools::next::connectivity::size(pe2v);
+    //          ++i) {
+    //     }
+    //   }
+
+    {
+        // vertex loop
+        // for (auto const &t : getVertices(LibTag{}, mesh)) {
+        //     pnabla_MXX(deref(LibTag{}, t), k) =
+        //         pnabla_MXX(deref(LibTag{}, t), k) / vol(deref(LibTag{}, t), k);
+        //     pnabla_MYY(deref(LibTag{}, t), k) =
+        //         pnabla_MYY(deref(LibTag{}, t), k) / vol(deref(LibTag{}, t), k);
+        //   }
+        auto v2e = gridtools::next::mesh::connectivity<std::tuple<vertex, edge>>(mesh);
+        static_assert(gridtools::is_sid<decltype(gridtools::next::connectivity::neighbor_table(v2e))>{});
+
+        auto vertex_fields = tu::make<gridtools::sid::composite::
+                keys<connectivity_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag, vol_tag>::values>(
+            gridtools::next::connectivity::neighbor_table(v2e), pnabla_MXX, pnabla_MYY, sign, vol);
+        static_assert(gridtools::sid::concept_impl_::is_sid<decltype(vertex_fields)>{});
+
+        auto ptrs = gridtools::sid::get_origin(vertex_fields)();
+        auto strides = gridtools::sid::get_strides(vertex_fields);
+
+        for (std::size_t i = 0; i < gridtools::next::connectivity::size(v2e); ++i) {
+            *gridtools::at_key<pnabla_MXX_tag>(ptrs) /= *gridtools::at_key<vol_tag>(ptrs);
+            *gridtools::at_key<pnabla_MYY_tag>(ptrs) /= *gridtools::at_key<vol_tag>(ptrs);
+            gridtools::sid::shift(ptrs, gridtools::at_key<vertex>(strides), 1);
+        }
+    }
+}
diff --git a/cpputil/unstructured/tests/unit_tests/next/CMakeLists.txt b/cpputil/unstructured/tests/unit_tests/next/CMakeLists.txt
index 582058a..1e6722f 100644
--- a/cpputil/unstructured/tests/unit_tests/next/CMakeLists.txt
+++ b/cpputil/unstructured/tests/unit_tests/next/CMakeLists.txt
@@ -28,4 +28,8 @@ function(add_gtnext_atlas_test)
     add_gtnext_test(NAME ${ARG_NAME} SOURCES ${ARG_SOURCES} LIBRARIES atlas eckit)
 endfunction()
 
+add_subdirectory(test_helper)
+
 add_gtnext_atlas_test(NAME test_atlas_array_view_adapter)
+add_gtnext_atlas_test(NAME test_atlas_field_util SOURCES test_atlas_field_util.cc)
+add_gtnext_atlas_test(NAME test_mesh SOURCES test_mesh.cc)
diff --git a/cpputil/unstructured/tests/unit_tests/next/test_atlas_field_util.cc b/cpputil/unstructured/tests/unit_tests/next/test_atlas_field_util.cc
new file mode 100644
index 0000000..1bcd8fe
--- /dev/null
+++ b/cpputil/unstructured/tests/unit_tests/next/test_atlas_field_util.cc
@@ -0,0 +1,62 @@
+#include <gridtools/next/atlas_field_util.hpp>
+
+#include "util/atlas_util.hpp"
+#include <array_fwd.h>
+#include <gridtools/sid/concept.hpp>
+
+#include <gtest/gtest.h>
+
+namespace {
+    TEST(atlas_field_as_sid, edge_k_field) {
+        namespace tu = gridtools::tuple_util;
+
+        auto mesh = atlas_util::make_mesh();
+
+        auto k_size = 10;
+        auto edge_field = atlas_util::make_edge_field<double>(mesh, k_size);
+        //   auto view = atlas::array::make_view<double, 3>(edge_field);
+
+        auto testee = gridtools::next::atlas_util::as<edge, dim::k>::with_type<double>{}(edge_field);
+        using testee_t = decltype(testee);
+
+        static_assert(gridtools::sid::concept_impl_::is_sid<testee_t>{});
+
+        using strides_t = gridtools::sid::strides_type<testee_t>;
+        static_assert(tu::size<strides_t>() == 2, "");
+        static_assert(gridtools::has_key<strides_t, edge>{});
+        static_assert(gridtools::has_key<strides_t, dim::k>{});
+
+        [[maybe_unused]] auto strides = gridtools::sid::get_strides(testee);
+    }
+
+    TEST(atlas_field_as_sid, invalid_location_type) {
+        auto mesh = atlas_util::make_mesh();
+
+        auto k_size = 10;
+        auto edge_field = atlas_util::make_edge_field<double>(mesh, k_size);
+
+        ASSERT_ANY_THROW((gridtools::next::atlas_util::as<cell, dim::k>::with_type<double>{}(edge_field)));
+    }
+
+    TEST(atlas_field_as_data_store, edge_k_field) {
+        namespace tu = gridtools::tuple_util;
+
+        auto mesh = atlas_util::make_mesh();
+
+        auto k_size = 10;
+        auto edge_field = atlas_util::make_edge_field<double>(mesh, k_size);
+
+        auto testee = gridtools::next::atlas_util::as_data_store<edge, dim::k>::with_type<double>{}(edge_field);
+        using testee_t = decltype(testee);
+
+        static_assert(gridtools::sid::concept_impl_::is_sid<testee_t>{});
+
+        using strides_t = gridtools::sid::strides_type<testee_t>;
+        static_assert(tu::size<strides_t>() == 2, "");
+        static_assert(gridtools::has_key<strides_t, edge>{});
+        static_assert(gridtools::has_key<strides_t, dim::k>{});
+
+        [[maybe_unused]] auto strides = gridtools::sid::get_strides(testee);
+    }
+
+} // namespace
diff --git a/cpputil/unstructured/tests/unit_tests/next/test_helper/CMakeLists.txt b/cpputil/unstructured/tests/unit_tests/next/test_helper/CMakeLists.txt
new file mode 100644
index 0000000..9cf2a0e
--- /dev/null
+++ b/cpputil/unstructured/tests/unit_tests/next/test_helper/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_gtnext_test(NAME test_simple_mesh)
+add_gtnext_test(NAME test_field_builder)
diff --git a/cpputil/unstructured/tests/unit_tests/next/test_helper/test_field_builder.cc b/cpputil/unstructured/tests/unit_tests/next/test_helper/test_field_builder.cc
new file mode 100644
index 0000000..ff8526d
--- /dev/null
+++ b/cpputil/unstructured/tests/unit_tests/next/test_helper/test_field_builder.cc
@@ -0,0 +1,105 @@
+#include <array>
+#include <gridtools/next/mesh.hpp>
+#include <gridtools/next/test_helper/field_builder.hpp>
+#include <gridtools/next/test_helper/simple_mesh.hpp>
+#include <gridtools/sid/composite.hpp>
+#include <gridtools/sid/concept.hpp>
+#include <gridtools/sid/loop.hpp>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <utility>
+
+namespace {
+
+    TEST(field_builder, cell_field) {
+        gridtools::next::test_helper::simple_mesh mesh;
+
+        auto field = gridtools::next::test_helper::make_field<double, cell>(mesh);
+
+        static_assert(std::is_same<double *, gridtools::sid::ptr_type<decltype(field)>>{});
+        auto c2c = gridtools::next::mesh::connectivity<std::tuple<cell, cell>>(mesh);
+        ASSERT_EQ(
+            gridtools::next::connectivity::size(c2c), gridtools::at_key<cell>(gridtools::sid::get_upper_bounds(field)));
+    }
+
+    // TODO consider moving to a different file
+    // TODO we need to understand where we should use SID and where data_store concepts
+    using namespace gridtools::sid;
+    using namespace gridtools::next;
+    using gridtools::at_key;
+    namespace tu = gridtools::tuple_util;
+
+    struct in_tag;
+    struct out_tag;
+    struct connectivity_tag;
+
+    template <class DimTag, class Sid, class Fun>
+    void make_full_loop(Sid &&sid, Fun &&fun) {
+        auto ptr = get_origin(std::forward<Sid>(sid))();
+        auto strides = get_strides(std::forward<Sid>(sid));
+
+        make_loop<DimTag>(at_key<DimTag>(get_upper_bounds(std::forward<Sid>(sid))))(std::forward<Fun>(fun))(
+            ptr, strides);
+    }
+
+    TEST(simple_mesh_regression, cell2cell_reduction) {
+        test_helper::simple_mesh mesh;
+        auto c2c = mesh::connectivity<std::tuple<cell, cell>>(mesh);
+
+        auto in = test_helper::make_field<double, cell>(mesh);
+        auto out = gridtools::next::test_helper::make_field<double, cell>(mesh);
+
+        make_full_loop<cell>(in, [](auto ptr, auto const &) { *ptr = 1; });
+
+        auto primary_fields =
+            tu::make<composite::keys<out_tag, connectivity_tag>::values>(out, connectivity::neighbor_table(c2c));
+        {
+            auto ptrs = get_origin(primary_fields)();
+            auto strides = get_strides(primary_fields);
+
+            // variant 1:
+            // for (std::size_t c = 0; c < at_key<cell>(get_upper_bounds(out)); ++c) {
+            //     *at_key<out_tag>(ptrs) = 0;
+            //     for (std::size_t i = 0; i < connectivity::max_neighbors(c2c); ++i) {
+            //         auto in_ptr = get_origin(in)();
+            //         auto in_strides = get_strides(in);
+            //         shift(in_ptr, at_key<cell>(in_strides), *at_key<connectivity_tag>(ptrs));
+            //         *at_key<out_tag>(ptrs) += *in_ptr;
+            //         shift(ptrs, gridtools::at_key<neighbor>(strides), 1);
+            //     }
+            //     shift(ptrs, at_key<neighbor>(strides), -connectivity::max_neighbors(c2c));
+            //     shift(ptrs, at_key<cell>(strides), 1);
+            // }
+
+            // variant 2:
+            make_loop<cell>(gridtools::at_key<cell>(get_upper_bounds(out)))(
+                [&c2c, &in](auto ptrs, auto const &strides) {
+                    *at_key<out_tag>(ptrs) = 0;
+                    for (std::size_t i = 0; i < connectivity::max_neighbors(c2c); ++i) {
+                        auto in_ptr = get_origin(in)();
+                        auto in_strides = get_strides(in);
+                        shift(in_ptr, at_key<cell>(in_strides), *at_key<connectivity_tag>(ptrs));
+                        *at_key<out_tag>(ptrs) += *in_ptr;
+                        shift(ptrs, gridtools::at_key<neighbor>(strides), 1);
+                    }
+                })(ptrs, strides);
+        }
+
+        // variant 3:
+        // TODO requires changes in the make_full_loop
+        // auto loop_body = [&c2c, &in](auto ptrs, auto const &strides) {
+        //     *at_key<out_tag>(ptrs) = 0;
+        //     for (std::size_t i = 0; i < connectivity::max_neighbors(c2c); ++i) {
+        //         auto in_ptr = get_origin(in)();
+        //         auto in_strides = get_strides(in);
+        //         shift(in_ptr, at_key<cell>(in_strides), *at_key<connectivity_tag>(ptrs));
+        //         *at_key<out_tag>(ptrs) += *in_ptr;
+        //         shift(ptrs, gridtools::at_key<neighbor>(strides), 1);
+        //     }
+        // };
+        // make_full_loop<cell>(primary_fields, loop_body);
+
+        make_full_loop<cell>(out, [](auto ptr, auto const &) { ASSERT_EQ(4, *ptr); });
+    }
+} // namespace
diff --git a/cpputil/unstructured/tests/unit_tests/next/test_helper/test_simple_mesh.cc b/cpputil/unstructured/tests/unit_tests/next/test_helper/test_simple_mesh.cc
new file mode 100644
index 0000000..538d752
--- /dev/null
+++ b/cpputil/unstructured/tests/unit_tests/next/test_helper/test_simple_mesh.cc
@@ -0,0 +1,54 @@
+#include <array>
+#include <gridtools/meta/at.hpp>
+#include <gridtools/next/mesh.hpp>
+#include <gridtools/next/test_helper/simple_mesh.hpp>
+#include <gridtools/sid/concept.hpp>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+template <typename NeighborChain, typename Mesh>
+auto get_neighbors(Mesh const &mesh, int i) {
+    namespace gs = gridtools::sid;
+    using namespace gridtools::next;
+
+    auto conn = mesh::connectivity<NeighborChain>(mesh);
+
+    auto tbl = gridtools::next::connectivity::neighbor_table(conn);
+    auto ptr = gs::get_origin(tbl)();
+    auto strides = gs::get_strides(tbl);
+    gs::shift(ptr, gridtools::at_key<gridtools::meta::at_c<NeighborChain, 0>>(strides), i);
+    std::array<int, decltype(gridtools::next::connectivity::max_neighbors(conn))::value> result;
+    for (std::size_t i = 0; i < result.size(); ++i) {
+        result[i] = *ptr;
+        gs::shift(ptr, gridtools::at_key<neighbor>(strides), 1);
+    }
+    return result;
+}
+
+TEST(simple_mesh, cell2cell) {
+    gridtools::next::test_helper::simple_mesh mesh;
+
+    auto c2c = gridtools::next::mesh::connectivity<std::tuple<cell, cell>>(mesh);
+
+    ASSERT_EQ(9, gridtools::next::connectivity::size(c2c));
+    ASSERT_EQ(4, gridtools::next::connectivity::max_neighbors(c2c));
+    ASSERT_EQ(-1, gridtools::next::connectivity::skip_value(c2c));
+
+    ASSERT_THAT((get_neighbors<std::tuple<cell, cell>>(mesh, 0)), testing::UnorderedElementsAre(1, 3, 2, 6));
+    ASSERT_THAT((get_neighbors<std::tuple<cell, cell>>(mesh, 1)), testing::UnorderedElementsAre(0, 7, 2, 4));
+    // etc
+}
+
+TEST(simple_mesh, edge2vertex) {
+    gridtools::next::test_helper::simple_mesh mesh;
+
+    auto e2v = gridtools::next::mesh::connectivity<std::tuple<edge, vertex>>(mesh);
+
+    ASSERT_EQ(18, gridtools::next::connectivity::size(e2v));
+    ASSERT_EQ(2, gridtools::next::connectivity::max_neighbors(e2v));
+    ASSERT_EQ(-1, gridtools::next::connectivity::skip_value(e2v));
+
+    ASSERT_THAT((get_neighbors<std::tuple<edge, vertex>>(mesh, 0)), testing::UnorderedElementsAre(0, 1));
+    // etc
+}
diff --git a/cpputil/unstructured/tests/unit_tests/next/test_mesh.cc b/cpputil/unstructured/tests/unit_tests/next/test_mesh.cc
new file mode 100644
index 0000000..1777f0d
--- /dev/null
+++ b/cpputil/unstructured/tests/unit_tests/next/test_mesh.cc
@@ -0,0 +1,30 @@
+#include "gridtools/common/integral_constant.hpp"
+#include <gridtools/next/mesh.hpp>
+
+#include <gtest/gtest.h>
+#include <type_traits>
+
+// TODO test concept
+
+using namespace gridtools::next;
+
+namespace {
+    namespace fake {
+        struct fake_connectivity {
+            inline friend std::size_t connectivity_size(fake_connectivity const &) { return 1; }
+            inline friend gridtools::integral_constant<int, 2> connectivity_max_neighbors(fake_connectivity const &) {
+                return {};
+            }
+            inline friend gridtools::integral_constant<int, -1> connectivity_skip_value(fake_connectivity const &) {
+                return {};
+            }
+        };
+    } // namespace fake
+
+    TEST(connectivity, make_info) {
+        auto info = connectivity::extract_info(fake::fake_connectivity{});
+        ASSERT_EQ(1, info.size);
+        static_assert(std::is_same_v<gridtools::integral_constant<int, 2>, decltype(info.max_neighbors)>);
+        static_assert(std::is_same_v<gridtools::integral_constant<int, -1>, decltype(info.skip_value)>);
+    }
+} // namespace

From f31c5942598d31b56e71394c5cc855fdfe25a3cd Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 26 Oct 2020 13:32:07 +0100
Subject: [PATCH 09/24] rertore 2

---
 cpputil/unstructured/atlas_field_converter.cc |  63 +++++++
 cpputil/unstructured/atlas_field_converter.cu |  61 ++++++
 cpputil/unstructured/atlas_mesh_adapter.cc    |  51 +++++
 .../include/gridtools/next/domain.hpp         |  10 -
 .../gridtools/next/usid_cuda_helpers.hpp      |  49 -----
 .../include/gridtools/next/usid_helpers.hpp   |  87 ---------
 .../gridtools/next/usid_naive_helpers.hpp     |  34 ----
 cpputil/unstructured/prototype.cc             | 155 +++++++++++++++
 .../tests/regression/fvm_nabla/driver.cu      |   6 -
 .../tests/regression/fvm_nabla/driver.hpp     | 176 ------------------
 10 files changed, 330 insertions(+), 362 deletions(-)
 create mode 100644 cpputil/unstructured/atlas_field_converter.cc
 create mode 100644 cpputil/unstructured/atlas_field_converter.cu
 create mode 100644 cpputil/unstructured/atlas_mesh_adapter.cc
 delete mode 100644 cpputil/unstructured/include/gridtools/next/domain.hpp
 delete mode 100644 cpputil/unstructured/include/gridtools/next/usid_cuda_helpers.hpp
 delete mode 100644 cpputil/unstructured/include/gridtools/next/usid_helpers.hpp
 delete mode 100644 cpputil/unstructured/include/gridtools/next/usid_naive_helpers.hpp
 create mode 100644 cpputil/unstructured/prototype.cc
 delete mode 100644 cpputil/unstructured/tests/regression/fvm_nabla/driver.cu
 delete mode 100644 cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp

diff --git a/cpputil/unstructured/atlas_field_converter.cc b/cpputil/unstructured/atlas_field_converter.cc
new file mode 100644
index 0000000..5438c81
--- /dev/null
+++ b/cpputil/unstructured/atlas_field_converter.cc
@@ -0,0 +1,63 @@
+#include "atlas/grid.h"
+#include "atlas/mesh/actions/BuildCellCentres.h"
+#include "atlas/mesh/actions/BuildDualMesh.h"
+#include "atlas/mesh/actions/BuildEdges.h"
+#include "atlas/meshgenerator.h"
+#include "gridtools/common/integral_constant.hpp"
+#include <array_fwd.h>
+#include <atlas/array.h>
+#include <atlas/grid/StructuredGrid.h>
+#include <atlas/mesh.h>
+#include <atlas/option.h>
+#include <field/Field.h>
+#include <functionspace/EdgeColumns.h>
+#include <type_traits>
+
+#include "gridtools/next/atlas_array_view_adapter.hpp"
+#include <gridtools/next/atlas_adapter.hpp>
+#include <gridtools/next/atlas_field_util.hpp>
+#include <gridtools/next/mesh.hpp>
+#include <gridtools/sid/synthetic.hpp>
+
+#include "gridtools/sid/rename_dimensions.hpp"
+#include "tests/include/util/atlas_util.hpp"
+
+namespace dim {
+    struct k;
+} // namespace dim
+
+int main() {
+    auto mesh = atlas_util::make_mesh();
+    atlas::mesh::actions::build_edges(mesh);
+
+    int nb_levels = 5;
+    atlas::functionspace::EdgeColumns fs_edges(mesh, atlas::option::levels(nb_levels) | atlas::option::halo(1));
+
+    atlas::Field f;
+    auto my_field = fs_edges.createField<double>(atlas::option::name("my_field"));
+
+    auto view = atlas::array::make_view<double, 2>(my_field);
+    for (int i = 0; i < fs_edges.size(); ++i)
+        for (int k = 0; k < nb_levels; ++k)
+            view(i, k) = i * 10 + k;
+
+    auto my_field_sidified = gridtools::next::atlas_util::as<edge, dim::k>::with_type<double>{}(my_field);
+    static_assert(gridtools::is_sid<decltype(my_field_sidified)>{});
+
+    auto my_field_as_data_store =
+        gridtools::next::atlas_util::as_data_store<edge, dim::k>::with_type<double>{}(my_field);
+    static_assert(gridtools::is_sid<decltype(my_field_as_data_store)>{});
+
+    auto strides = gridtools::sid::get_strides(my_field_sidified);
+    auto strides_ds = gridtools::sid::get_strides(my_field_as_data_store);
+    for (int i = 0; i < fs_edges.size(); ++i)
+        for (int k = 0; k < nb_levels; ++k) {
+            auto ptr = gridtools::sid::get_origin(my_field_sidified)();
+            gridtools::sid::shift(ptr, gridtools::at_key<edge>(strides), i);
+            gridtools::sid::shift(ptr, gridtools::at_key<dim::k>(strides), k);
+            auto ptr2 = gridtools::sid::get_origin(my_field_as_data_store)();
+            gridtools::sid::shift(ptr2, gridtools::at_key<edge>(strides_ds), i);
+            gridtools::sid::shift(ptr2, gridtools::at_key<dim::k>(strides_ds), k);
+            std::cout << view(i, k) << "/" << *ptr << "/" << *ptr2 << std::endl;
+        }
+}
diff --git a/cpputil/unstructured/atlas_field_converter.cu b/cpputil/unstructured/atlas_field_converter.cu
new file mode 100644
index 0000000..f5ef8f6
--- /dev/null
+++ b/cpputil/unstructured/atlas_field_converter.cu
@@ -0,0 +1,61 @@
+#include "atlas/grid.h"
+#include "atlas/mesh/actions/BuildCellCentres.h"
+#include "atlas/mesh/actions/BuildDualMesh.h"
+#include "atlas/mesh/actions/BuildEdges.h"
+#include "atlas/meshgenerator.h"
+#include "gridtools/common/integral_constant.hpp"
+#include <array_fwd.h>
+#include <atlas/array.h>
+#include <atlas/grid/StructuredGrid.h>
+#include <atlas/mesh.h>
+#include <atlas/option.h>
+#include <field/Field.h>
+#include <functionspace/EdgeColumns.h>
+#include <type_traits>
+
+#include "gridtools/next/atlas_array_view_adapter.hpp"
+#include <gridtools/next/atlas_adapter.hpp>
+#include <gridtools/next/atlas_field_util.hpp>
+#include <gridtools/next/mesh.hpp>
+#include <gridtools/sid/synthetic.hpp>
+
+#include "tests/include/util/atlas_util.hpp"
+
+namespace dim {
+    struct k;
+} // namespace dim
+
+template <class Ptr, class Strides, class UpperBounds>
+__global__ void kernel(Ptr ptr_holder, Strides strides, UpperBounds upper_bounds) {
+    auto ptr = ptr_holder();
+    gridtools::sid::shift(ptr, gridtools::device::at_key<edge>(strides), threadIdx.x);
+    for (int i = 0; i < gridtools::device::at_key<dim::k>(upper_bounds); ++i) {
+        printf("%f\n", *ptr);
+        gridtools::sid::shift(ptr, gridtools::device::at_key<dim::k>(strides), 1);
+    }
+}
+
+int main() {
+    auto mesh = atlas_util::make_mesh();
+    atlas::mesh::actions::build_edges(mesh);
+
+    int nb_levels = 5;
+    atlas::functionspace::EdgeColumns fs_edges(mesh, atlas::option::levels(nb_levels) | atlas::option::halo(1));
+
+    atlas::Field f;
+    auto my_field = fs_edges.createField<double>(atlas::option::name("my_field"));
+
+    auto view = atlas::array::make_view<double, 2>(my_field);
+    for (int i = 0; i < fs_edges.size(); ++i)
+        for (int k = 0; k < nb_levels; ++k)
+            view(i, k) = i * 10 + k;
+
+    auto my_field_as_data_store =
+        gridtools::next::atlas_util::as_data_store<edge, dim::k>::with_type<double>{}(my_field);
+    static_assert(gridtools::is_sid<decltype(my_field_as_data_store)>{});
+
+    kernel<<<1, fs_edges.size()>>>(gridtools::sid::get_origin(my_field_as_data_store),
+        gridtools::sid::get_strides(my_field_as_data_store),
+        gridtools::sid::get_upper_bounds(my_field_as_data_store));
+    cudaDeviceSynchronize();
+}
diff --git a/cpputil/unstructured/atlas_mesh_adapter.cc b/cpputil/unstructured/atlas_mesh_adapter.cc
new file mode 100644
index 0000000..9743e54
--- /dev/null
+++ b/cpputil/unstructured/atlas_mesh_adapter.cc
@@ -0,0 +1,51 @@
+#include "atlas/grid.h"
+#include "atlas/mesh/actions/BuildCellCentres.h"
+#include "atlas/mesh/actions/BuildDualMesh.h"
+#include "atlas/mesh/actions/BuildEdges.h"
+#include "atlas/meshgenerator.h"
+#include <atlas/grid/StructuredGrid.h>
+#include <atlas/mesh.h>
+#include <type_traits>
+
+#include <gridtools/next/atlas_adapter.hpp>
+#include <gridtools/next/atlas_array_view_adapter.hpp>
+#include <gridtools/next/mesh.hpp>
+
+#include <gridtools/common/tuple_util.hpp>
+#include <gridtools/sid/composite.hpp>
+
+#include "tests/include/util/atlas_util.hpp"
+
+int main() {
+    auto mesh = atlas_util::make_mesh();
+    atlas::mesh::actions::build_edges(mesh);
+    atlas::mesh::actions::build_node_to_edge_connectivity(mesh);
+
+    auto const &v2e = gridtools::next::mesh::connectivity<std::tuple<vertex, edge>>(mesh);
+
+    auto n_vertices = gridtools::next::connectivity::size(v2e);
+    std::cout << n_vertices << std::endl;
+    std::cout << gridtools::next::connectivity::max_neighbors(v2e) << std::endl;
+    std::cout << gridtools::next::connectivity::skip_value(v2e) << std::endl;
+    auto v2e_tbl = gridtools::next::connectivity::neighbor_table(v2e);
+
+    static_assert(gridtools::is_sid<decltype(v2e_tbl)>{});
+    namespace tu = gridtools::tuple_util;
+    auto composite = tu::make<gridtools::sid::composite::keys<edge // TODO just a dummy
+        >::values>(v2e_tbl);
+    //   auto tmp = sid_get_lower_bounds(composite);
+    static_assert(gridtools::sid::concept_impl_::is_sid<decltype(composite)>{});
+
+    auto strides = gridtools::sid::get_strides(v2e_tbl);
+
+    std::cout << gridtools::at_key<neighbor>(strides) << std::endl;
+    std::cout << gridtools::at_key<vertex>(strides) << std::endl;
+
+    for (std::size_t v = 0; v < gridtools::next::connectivity::size(v2e); ++v) {
+        auto ptr = gridtools::sid::get_origin(v2e_tbl)();
+        gridtools::sid::shift(ptr, gridtools::at_key<vertex>(strides), v);
+        for (std::size_t i = 0; i < gridtools::next::connectivity::max_neighbors(v2e); ++i) {
+            gridtools::sid::shift(ptr, gridtools::at_key<neighbor>(strides), 1);
+        }
+    }
+}
diff --git a/cpputil/unstructured/include/gridtools/next/domain.hpp b/cpputil/unstructured/include/gridtools/next/domain.hpp
deleted file mode 100644
index ee4b893..0000000
--- a/cpputil/unstructured/include/gridtools/next/domain.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-namespace gridtools::next {
-    struct domain {
-        int vertex;
-        int edge;
-        int cell;
-        int k;
-    };
-}
diff --git a/cpputil/unstructured/include/gridtools/next/usid_cuda_helpers.hpp b/cpputil/unstructured/include/gridtools/next/usid_cuda_helpers.hpp
deleted file mode 100644
index 841911c..0000000
--- a/cpputil/unstructured/include/gridtools/next/usid_cuda_helpers.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#pragma once
-
-#ifndef __CUDACC__
-#error Tried to compile CUDA code with a regular C++ compiler.
-#endif
-
-#include <gridtools/common/cuda_util.hpp>
-#include <gridtools/common/hymap.hpp>
-#include <gridtools/common/pair.hpp>
-#include <gridtools/common/tuple_util.hpp>
-#include <gridtools/sid/allocator.hpp>
-#include <gridtools/sid/concept.hpp>
-#include <gridtools/storage/gpu.hpp>
-
-#include "unstructured.hpp"
-#include "usid_helpers.hpp"
-
-namespace gridtools::next::cuda {
-    using traits_t = storage::gpu;
-
-    inline auto make_allocator() { return sid::device::make_cached_allocator(&cuda_util::cuda_malloc<char[]>); }
-
-    template <class Kernel, class Ptr, class Strides, class... Neighbors>
-    __global__ void kernel(int h_size, Ptr ptr_holder, Strides strides, Neighbors... neighbors) {
-        auto h = blockIdx.x * blockDim.x + threadIdx.x;
-        if (h >= h_size)
-            return;
-        Kernel()()(sid::shifted(ptr_holder(), device::at_key<dim::h>(strides), h),
-            strides,
-            tuple_util::device::make<pair>(neighbors.first(), neighbors.second)...);
-    }
-
-    template <class Kernel, class Size, class Sid, class... Sids>
-    void call_kernel(Size size, Sid &&fields, Sids &&...neighbor_fields) {
-        int threads_per_block = 32;
-        int blocks = (size + threads_per_block - 1) / threads_per_block;
-        kernel<Kernel><<<blocks, threads_per_block>>>(size,
-            sid::get_origin(fields),
-            sid::get_strides(fields),
-            tuple_util::make<pair>(
-                sid::get_origin(neighbor_fields), at_key<dim::h>(sid::get_strides(neighbor_fields)))...);
-        GT_CUDA_CHECK(cudaGetLastError());
-    }
-
-    template <class Tag, class Ptr>
-    __device__ decltype(auto) field(Ptr const &ptr) {
-        return *device::at_key<Tag>(ptr);
-    }
-} // namespace gridtools::next::cuda
diff --git a/cpputil/unstructured/include/gridtools/next/usid_helpers.hpp b/cpputil/unstructured/include/gridtools/next/usid_helpers.hpp
deleted file mode 100644
index 3220c32..0000000
--- a/cpputil/unstructured/include/gridtools/next/usid_helpers.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#pragma once
-
-#include <limits>
-#include <type_traits>
-#include <utility>
-
-#include <gridtools/common/defs.hpp>
-#include <gridtools/common/host_device.hpp>
-#include <gridtools/common/hymap.hpp>
-#include <gridtools/common/integral_constant.hpp>
-#include <gridtools/common/utility.hpp>
-#include <gridtools/meta/id.hpp>
-#include <gridtools/sid/composite.hpp>
-#include <gridtools/sid/concept.hpp>
-#include <gridtools/sid/contiguous.hpp>
-#include <gridtools/sid/loop.hpp>
-#include <gridtools/sid/rename_dimensions.hpp>
-
-#include "domain.hpp"
-#include "unstructured.hpp"
-
-namespace gridtools::next {
-    template <class T, class Alloc, class HSize, class KSize>
-    auto make_simple_tmp_storage(HSize h_size, KSize k_size, Alloc &alloc) {
-        return sid::make_contiguous<T>(alloc, hymap::keys<dim::h, dim::k>::values<HSize, KSize>(h_size, k_size));
-    }
-
-    template <class T,
-        class Tag,
-        int_t N,
-        bool HasSkipValues,
-        class F,
-        class Init,
-        class G,
-        class Ptr,
-        class Strides,
-        class Neighbors>
-    GT_FUNCTION T fold_neighbors(F f, Init init, G g, Ptr &&ptr, Strides &&strides, Neighbors &&neighbors) {
-        T acc = init(meta::lazy::id<T>());
-        sid::make_loop<Tag>(integral_constant<int_t, N>())([&](auto const &ptr, auto &&) {
-            auto i = *host_device::at_key<Tag>(ptr);
-            if constexpr (HasSkipValues)
-                if (i < 0)
-                    return;
-            acc = f(acc, g(ptr, sid::shifted(neighbors.first, neighbors.second, i)));
-        })(wstd::forward<decltype(ptr)>(ptr), strides);
-        return acc;
-    }
-
-    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
-    GT_FUNCTION T sum_neighbors(F f, Args &&...args) {
-        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x + y; },
-            [](auto z) -> typename decltype(z)::type { return 0; },
-            f,
-            wstd::forward<Args>(args)...);
-    }
-
-    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
-    GT_FUNCTION T mul_neighbors(F f, Args &&...args) {
-        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x * y; },
-            [](auto z) -> typename decltype(z)::type { return 1; },
-            f,
-            wstd::forward<Args>(args)...);
-    }
-
-    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
-    GT_FUNCTION T min_neighbors(F f, Args &&...args) {
-        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x < y ? x : y; },
-            [](auto z) -> typename decltype(z)::type {
-                constexpr auto res = std::numeric_limits<typename decltype(z)::type>::max();
-                return res;
-            },
-            f,
-            wstd::forward<Args>(args)...);
-    }
-
-    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
-    GT_FUNCTION T max_neighbors(F f, Args &&...args) {
-        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x > y ? x : y; },
-            [](auto z) -> typename decltype(z)::type {
-                constexpr auto res = std::numeric_limits<typename decltype(z)::type>::min();
-                return res;
-            },
-            f,
-            wstd::forward<Args>(args)...);
-    }
-} // namespace gridtools::next
diff --git a/cpputil/unstructured/include/gridtools/next/usid_naive_helpers.hpp b/cpputil/unstructured/include/gridtools/next/usid_naive_helpers.hpp
deleted file mode 100644
index b949c1b..0000000
--- a/cpputil/unstructured/include/gridtools/next/usid_naive_helpers.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <tuple>
-#include <utility>
-
-#include <gridtools/common/hymap.hpp>
-#include <gridtools/sid/allocator.hpp>
-#include <gridtools/sid/concept.hpp>
-#include <gridtools/sid/loop.hpp>
-#include <gridtools/storage/cpu_ifirst.hpp>
-
-#include "unstructured.hpp"
-#include "usid_helpers.hpp"
-
-namespace gridtools::next::naive {
-    using traits_t = storage::cpu_ifirst;
-
-    inline auto make_allocator() { return sid::make_cached_allocator(&std::make_unique<char[]>); }
-
-    template <class Kernel, class Size, class Sid, class... Sids>
-    void call_kernel(Size size, Sid &&fields, Sids &&...neighbor_fields) {
-        sid::make_loop<dim::h>(size)(
-            [params = std::make_tuple(std::make_pair(sid::get_origin(neighbor_fields)(),
-                 sid::get_stride<dim::h>(sid::get_strides(neighbor_fields)))...)](auto &ptr, auto const &strides) {
-                std::apply(Kernel()(), std::tuple_cat(std::forward_as_tuple(ptr, strides), params));
-            })(sid::get_origin(fields)(), sid::get_strides(fields));
-    }
-
-    template <class Tag, class Ptr>
-    decltype(auto) field(Ptr const &ptr) {
-        return *at_key<Tag>(ptr);
-    }
-} // namespace gridtools::next::naive
diff --git a/cpputil/unstructured/prototype.cc b/cpputil/unstructured/prototype.cc
new file mode 100644
index 0000000..8fcf7ea
--- /dev/null
+++ b/cpputil/unstructured/prototype.cc
@@ -0,0 +1,155 @@
+#include <gridtools/common/hymap.hpp>
+#include <gridtools/common/tuple_util.hpp>
+#include <gridtools/next/mesh.hpp>
+#include <gridtools/next/unstructured.hpp>
+#include <gridtools/sid/composite.hpp>
+#include <gridtools/sid/concept.hpp>
+#include <gridtools/sid/synthetic.hpp>
+#include <tuple>
+#include <vector>
+
+#include <iostream>
+
+namespace tu = gridtools::tuple_util;
+
+using vertex2edge = gridtools::meta::list<vertex, edge>;
+using edge2vertex = gridtools::meta::list<edge, vertex>;
+using cell2vertex = gridtools::meta::list<cell, vertex>;
+
+namespace my_personal_connectivity {
+    template <std::size_t MaxNeighbors, class LocationType>
+    struct myCon {
+        using location = LocationType;
+        static constexpr std::size_t neighs = MaxNeighbors;
+        std::vector<std::array<int, MaxNeighbors>> neighborTable;
+    };
+
+    template <std::size_t MaxNeighbors, class LocationType>
+    auto connectivity_max_neighbors(myCon<MaxNeighbors, LocationType> const &) {
+        return std::integral_constant<std::size_t, MaxNeighbors>{};
+    }
+
+    template <std::size_t MaxNeighbors, class LocationType>
+    std::size_t connectivity_size(myCon<MaxNeighbors, LocationType> const &conn) {
+        return conn.neighborTable.size();
+    }
+
+    template <std::size_t MaxNeighbors, class LocationType>
+    auto connectivity_neighbor_table(myCon<MaxNeighbors, LocationType> const &conn) {
+
+        using strides_t = typename gridtools::hymap::keys<LocationType,
+            neighbor>::template values<std::integral_constant<size_t, MaxNeighbors>, std::integral_constant<size_t, 1>>;
+
+        return gridtools::sid::synthetic()
+            .set<gridtools::sid::property::origin>(
+                gridtools::sid::make_simple_ptr_holder(reinterpret_cast<const int *>(conn.neighborTable.data())))
+            .template set<gridtools::sid::property::strides>(
+                strides_t(std::integral_constant<size_t, MaxNeighbors>{}, std::integral_constant<size_t, 1>{}))
+            .template set<gridtools::sid::property::strides_kind, strides_t>();
+    }
+} // namespace my_personal_connectivity
+
+struct in_tag;
+struct out_tag;
+struct connectivity_tag;
+
+template <class SID, class NeighPtrT>
+auto indirect_access(SID &&field, NeighPtrT const &neighptr) {
+    auto ptr = gridtools::sid::get_origin(field)();
+    gridtools::sid::shift(ptr, gridtools::sid::get_stride<vertex>(gridtools::sid::get_strides(field)), *neighptr);
+    return ptr;
+}
+
+template <class Mesh, class In, class Out>
+void sum_vertex_to_cell(Mesh const &mesh, In &&in, Out &&out) {
+    auto n_cells = gridtools::next::connectivity::size(gridtools::at_key<cell2vertex>(mesh));
+
+    auto cell2vertex_conn = gridtools::next::mesh::connectivity<cell2vertex>(mesh);
+    auto cell_to_vertex = gridtools::next::connectivity::neighbor_table(cell2vertex_conn);
+
+    static_assert(gridtools::sid::concept_impl_::is_sid<decltype(cell_to_vertex)>{});
+
+    auto cells = tu::make<gridtools::sid::composite::keys<out_tag, connectivity_tag>::values>(out, cell_to_vertex);
+
+    static_assert(gridtools::sid::concept_impl_::is_sid<decltype(cells)>{});
+
+    auto ptr = gridtools::sid::get_origin(cells)();
+    for (std::size_t i = 0; i < n_cells; ++i) {
+        std::cout << "cell: " << *gridtools::at_key<out_tag>(ptr) << std::endl;
+        int sum = 0;
+        auto neigh_ptr = gridtools::at_key<connectivity_tag>(ptr);
+        for (std::size_t neigh_vertex = 0;
+             neigh_vertex < gridtools::next::connectivity::max_neighbors(gridtools::at_key<cell2vertex>(mesh));
+             ++neigh_vertex) {
+            auto absolute_neigh_index = *neigh_ptr;
+            std::cout << absolute_neigh_index << " ";
+
+            auto in_ptr = indirect_access(in, neigh_ptr);
+
+            std::cout << *in_ptr << std::endl;
+
+            sum += *in_ptr;
+
+            // last thing in the loop: shift
+            gridtools::sid::shift(
+                neigh_ptr, gridtools::sid::get_stride<neighbor>(gridtools::sid::get_strides(cell_to_vertex)), 1);
+        }
+        *gridtools::at_key<out_tag>(ptr) = sum;
+        gridtools::sid::shift(ptr,
+            gridtools::sid::get_stride<cell>(gridtools::sid::get_strides(cells)),
+            1); // TODO sid::loop
+    }
+}
+
+auto make_cell_to_vertex_connectivity() {
+    std::vector<std::array<int, 4>> res;
+    res.emplace_back(std::array{0, 1, 3, 4});
+    res.emplace_back(std::array{1, 2, 4, 5});
+    res.emplace_back(std::array{3, 4, 6, 7});
+    res.emplace_back(std::array{4, 5, 7, 8});
+    return res;
+}
+
+int main() {
+    auto mesh = gridtools::tuple_util::make<gridtools::hymap::keys<cell2vertex>::values>(
+        my_personal_connectivity::myCon<4, cell>{make_cell_to_vertex_connectivity()});
+
+    using namespace gridtools::literals;
+
+    constexpr int size = 3;
+    int in_array[size][size]; // on vertices
+    auto in =
+        gridtools::sid::synthetic()
+            .set<gridtools::sid::property::origin>(gridtools::sid::make_simple_ptr_holder(&in_array[0][0]))
+            .set<gridtools::sid::property::strides>(tu::make<gridtools::hymap::keys<vertex>::values>(1_c))
+            .set<gridtools::sid::property::upper_bounds>(tu::make<gridtools::hymap::keys<vertex>::values>(size * size));
+
+    static_assert(gridtools::is_sid<decltype(in)>{});
+
+    int out_array[size - 1][size - 1]; // on cells
+    auto out = gridtools::sid::synthetic()
+                   .set<gridtools::sid::property::origin>(gridtools::sid::make_simple_ptr_holder(&out_array[0][0]))
+                   .set<gridtools::sid::property::strides>(tu::make<gridtools::hymap::keys<cell>::values>(1_c))
+                   .set<gridtools::sid::property::upper_bounds>(
+                       tu::make<gridtools::hymap::keys<cell>::values>((size - 1) * (size - 1)));
+
+    for (int i = 0; auto &&row : in_array)
+        for (auto &&val : row) {
+            val = i++;
+        }
+    for (int i = 0; auto &&row : out_array)
+        for (auto &&val : row) {
+            val = i++;
+        }
+
+    //   tuple_util::make<sid::composite::keys< in_tag, out_tag,
+    //   connectivity_tag>::values>(
+
+    sum_vertex_to_cell(mesh, in, out);
+
+    std::cout << "=== result ===" << std::endl;
+    for (auto &&row : out_array)
+        for (auto &&val : row) {
+            std::cout << val << std::endl;
+        }
+}
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/driver.cu b/cpputil/unstructured/tests/regression/fvm_nabla/driver.cu
deleted file mode 100644
index 1b05bd2..0000000
--- a/cpputil/unstructured/tests/regression/fvm_nabla/driver.cu
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <gtest/gtest.h>
-
-#include "driver.hpp"
-#include "nabla_cuda.hpp"
-
-TEST(FVM, nabla) { driver(nabla); }
diff --git a/cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp b/cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp
deleted file mode 100644
index f2f37a5..0000000
--- a/cpputil/unstructured/tests/regression/fvm_nabla/driver.hpp
+++ /dev/null
@@ -1,176 +0,0 @@
-#pragma once
-
-#include <algorithm>
-#include <cmath>
-#include <limits>
-#include <tuple>
-
-#include <gtest/gtest.h>
-
-#include <atlas/array.h>
-#include <atlas/functionspace.h>
-#include <atlas/grid.h>
-#include <atlas/mesh.h>
-#include <atlas/mesh/actions/BuildDualMesh.h>
-#include <atlas/mesh/actions/BuildEdges.h>
-#include <atlas/meshgenerator.h>
-
-#include <gridtools/common/integral_constant.hpp>
-#include <gridtools/storage/builder.hpp>
-#include <gridtools/storage/sid.hpp>
-
-#include <gridtools/next/atlas_adapter.hpp>
-
-#ifdef __CUDACC__
-#include <gridtools/storage/gpu.hpp>
-namespace driver_impl_ {
-    using storage_traits_t = gridtools::storage::gpu;
-}
-#else
-#include <gridtools/storage/cpu_ifirst.hpp>
-namespace driver_impl_ {
-    using storage_traits_t = gridtools::storage::cpu_ifirst;
-}
-#endif
-
-namespace driver_impl_ {
-    using namespace gridtools::literals;
-
-    inline constexpr auto storage_builder = gridtools::storage::builder<storage_traits_t>;
-
-    inline auto make_mesh() {
-        using namespace atlas;
-        using param_t = StructuredMeshGenerator::Parameters;
-        auto res = StructuredMeshGenerator(param_t("triangulate", true) | param_t("angle", -1.)).generate(Grid("O32"));
-        functionspace::EdgeColumns(res, option::levels(1) | option::halo(1));
-        functionspace::NodeColumns(res, option::levels(1) | option::halo(1));
-        mesh::actions::build_edges(res);
-        mesh::actions::build_node_to_edge_connectivity(res);
-        mesh::actions::build_median_dual_mesh(res);
-        return res;
-    }
-
-    inline const double rpi = 2 * std::asin(1);
-    inline const double radius = 6371.22e+03;
-    inline const double deg2rad = 2 * rpi / 360;
-    inline constexpr int MXX = 0;
-    inline constexpr int MYY = 1;
-    inline constexpr auto edges_per_node = 7_c;
-
-    inline auto make_vol(atlas::mesh::Nodes const &nodes) {
-        auto dual_volumes = atlas::array::make_view<double, 1>(nodes.field("dual_volumes"));
-        auto init = [&](int n) { return dual_volumes(n) * (std::pow(deg2rad, 2) * std::pow(radius, 2)); };
-        return storage_builder.type<double>().dimensions(nodes.size()).initializer(init).build();
-    }
-
-    inline auto make_sign(atlas::Mesh const &mesh) {
-        auto &&edges = mesh.edges();
-        auto &&nodes = mesh.nodes();
-        auto &&n2e = nodes.edge_connectivity();
-        auto &&e2n = edges.node_connectivity();
-        auto flags = atlas::array::make_view<int, 1>(edges.flags());
-        auto is_pole_edge = [&](auto e) {
-            using topology_t = atlas::mesh::Nodes::Topology;
-            return topology_t::check(flags(e), topology_t::POLE);
-        };
-        auto init = [&](int n, int, int e) -> double {
-            if (e >= n2e.cols(n))
-                return 0;
-            auto ee = n2e(n, e);
-            return n == e2n(ee, 0) || is_pole_edge(ee) ? 1 : -1;
-        };
-        return storage_builder.type<double>()
-            .selector<1, 0, 1>()
-            .dimensions(nodes.size(), 1, edges_per_node)
-            .initializer(init)
-            .build();
-    }
-
-    inline auto make_S_MXX(atlas::mesh::Edges const &edges) {
-        auto dual_normals = atlas::array::make_view<double, 2>(edges.field("dual_normals"));
-        return storage_builder.type<double>()
-            .dimensions(edges.size())
-            .initializer([&](int i) { return dual_normals(i, MXX) * radius * deg2rad; })
-            .build();
-    }
-
-    inline auto make_S_MYY(atlas::mesh::Edges const &edges) {
-        auto dual_normals = atlas::array::make_view<double, 2>(edges.field("dual_normals"));
-        return storage_builder.type<double>()
-            .dimensions(edges.size())
-            .initializer([&](int i) { return dual_normals(i, MYY) * radius * deg2rad; })
-            .build();
-    }
-
-    // TODO ask Christian for a proper name for this input data
-    inline auto make_pp(atlas::mesh::Nodes const &nodes) {
-        static const double zh0 = 2000;
-        static const double zrad = 3 * rpi / 4 * radius;
-        static const double zeta = rpi / 16 * radius;
-        static const double zlatc = 0;
-        static const double zlonc = 3 * rpi / 2;
-
-        auto lonlat = atlas::array::make_view<double, 2>(nodes.field("lonlat"));
-        // lonlatcr is in physical space and may differ from coords later
-        auto rlonlatcr = [&](int n, int i) { return lonlat(n, i) * deg2rad; };
-        auto init = [&](int n) {
-            double zlon = rlonlatcr(n, MXX);
-            double rcosa = std::cos(rlonlatcr(n, MYY));
-            double rsina = std::sin(rlonlatcr(n, MYY));
-            double zdist = std::sin(zlatc) * rsina + std::cos(zlatc) * rcosa * std::cos(zlon - zlonc);
-            zdist = radius * std::acos(zdist);
-            return zdist < zrad
-                       ? .5 * zh0 * (1 + std::cos(rpi * zdist / zrad)) * std::pow(std::cos(rpi * zdist / zeta), 2)
-                       : 0;
-        };
-        return storage_builder.type<double>().dimensions(nodes.size()).initializer(init).build();
-    }
-
-    template <class T>
-    auto min_max(T const &field) {
-        double min = std::numeric_limits<double>::max();
-        double max = std::numeric_limits<double>::min();
-        auto view = field->const_host_view();
-        auto lengths = field->lengths();
-        for (int i = 0; i < (int)lengths[0]; ++i)
-            for (int k = 0; k < (int)lengths[1]; ++k) {
-                double x = view(i, k);
-                min = std::min(min, x);
-                max = std::max(max, x);
-            }
-        return std::make_tuple(min, max);
-    }
-
-    template <class Nabla>
-    void driver(Nabla nabla) {
-        constexpr auto k = 1_c;
-
-        auto mesh = make_mesh();
-        auto &&edges = mesh.edges();
-        auto &&nodes = mesh.nodes();
-
-        // output
-        auto make_output = storage_builder.type<double>().dimensions(nodes.size(), k);
-        auto pnabla_MXX = make_output();
-        auto pnabla_MYY = make_output();
-
-        nabla({nodes.size(), edges.size(), mesh.cells().size(), k},
-            make_storage_producer(edges_per_node, nodes.edge_connectivity()),
-            make_storage_producer(2_c, edges.node_connectivity()))(make_S_MXX(edges),
-            make_S_MYY(edges),
-            make_pp(nodes),
-            pnabla_MXX,
-            pnabla_MYY,
-            make_vol(nodes),
-            make_sign(mesh));
-
-        auto [x_min, x_max] = min_max(pnabla_MXX);
-        auto [y_min, y_max] = min_max(pnabla_MYY);
-
-        EXPECT_DOUBLE_EQ(-3.5455427772566003E-003, x_min);
-        EXPECT_DOUBLE_EQ(3.5455427772565435E-003, x_max);
-        EXPECT_DOUBLE_EQ(-3.3540113705465301E-003, y_min);
-        EXPECT_DOUBLE_EQ(3.3540113705465301E-003, y_max);
-    } //
-} // namespace driver_impl_
-using driver_impl_::driver;

From d79231020a5f1006a8ca674fa5bf46e39b66b1f0 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 26 Oct 2020 12:36:32 +0000
Subject: [PATCH 10/24] fix nabla cuda

---
 cpputil/usid/tests/nabla_cuda.hpp | 148 ++++++++++++++----------------
 1 file changed, 69 insertions(+), 79 deletions(-)

diff --git a/cpputil/usid/tests/nabla_cuda.hpp b/cpputil/usid/tests/nabla_cuda.hpp
index d7ca9c6..3a57185 100644
--- a/cpputil/usid/tests/nabla_cuda.hpp
+++ b/cpputil/usid/tests/nabla_cuda.hpp
@@ -1,82 +1,72 @@
 #pragma once
-#include <gridtools/next/usid_cuda_helpers.hpp>
-namespace gridtools::next::cuda::nabla_impl_ {
-struct v2e_tag;
-struct e2v_tag;
-struct S_MXX_tag;
-struct S_MYY_tag;
-struct zavgS_MXX_tag;
-struct zavgS_MYY_tag;
-struct pnabla_MXX_tag;
-struct pnabla_MYY_tag;
-struct vol_tag;
-struct sign_tag;
-struct pp_tag;
-struct kernel_0 {
-  GT_FUNCTION auto operator()() const {
-    return [](auto &&ptr, auto &&strides, auto &&neighbors) {
-      auto zavg = 0.5 * sum_neighbors<double, e2v_tag, 2, false>(
-                            [](auto &&, auto &&n) { return field<pp_tag>(n); },
-                            ptr, strides, neighbors);
-      field<zavgS_MXX_tag>(ptr) = field<S_MXX_tag>(ptr) * zavg;
-      field<zavgS_MYY_tag>(ptr) = field<S_MYY_tag>(ptr) * zavg;
+#include <gridtools/usid/usid_cuda_helpers.hpp>
+namespace gridtools::usid::cuda::nabla_impl_ {
+    struct v2e_tag;
+    struct e2v_tag;
+    struct S_MXX_tag;
+    struct S_MYY_tag;
+    struct zavgS_MXX_tag;
+    struct zavgS_MYY_tag;
+    struct pnabla_MXX_tag;
+    struct pnabla_MYY_tag;
+    struct vol_tag;
+    struct sign_tag;
+    struct pp_tag;
+    struct kernel_0 {
+        GT_FUNCTION auto operator()() const {
+            return [](auto &&ptr, auto &&strides, auto &&neighbors) {
+                auto zavg = 0.5 * sum_neighbors<double, e2v_tag, 2, false>(
+                                      [](auto &&, auto &&n) { return field<pp_tag>(n); }, ptr, strides, neighbors);
+                field<zavgS_MXX_tag>(ptr) = field<S_MXX_tag>(ptr) * zavg;
+                field<zavgS_MYY_tag>(ptr) = field<S_MYY_tag>(ptr) * zavg;
+            };
+        }
     };
-  }
-};
-struct kernel_1 {
-  GT_FUNCTION auto operator()() const {
-    return [](auto &&ptr, auto &&strides, auto &&neighbors) {
-      field<pnabla_MXX_tag>(ptr) = sum_neighbors<double, v2e_tag, 7>(
-          [](auto &&p, auto &&n) {
-            return field<zavgS_MXX_tag>(n) * field<sign_tag>(p);
-          },
-          ptr, strides, neighbors);
-      field<pnabla_MYY_tag>(ptr) = sum_neighbors<double, v2e_tag, 7>(
-          [](auto &&p, auto &&n) {
-            return field<zavgS_MYY_tag>(n) * field<sign_tag>(p);
-          },
-          ptr, strides, neighbors);
-      field<pnabla_MXX_tag>(ptr) =
-          field<pnabla_MXX_tag>(ptr) / field<vol_tag>(ptr);
-      field<pnabla_MYY_tag>(ptr) =
-          field<pnabla_MYY_tag>(ptr) / field<vol_tag>(ptr);
+    struct kernel_1 {
+        GT_FUNCTION auto operator()() const {
+            return [](auto &&ptr, auto &&strides, auto &&neighbors) {
+                field<pnabla_MXX_tag>(ptr) = sum_neighbors<double, v2e_tag, 7>(
+                    [](auto &&p, auto &&n) { return field<zavgS_MXX_tag>(n) * field<sign_tag>(p); },
+                    ptr,
+                    strides,
+                    neighbors);
+                field<pnabla_MYY_tag>(ptr) = sum_neighbors<double, v2e_tag, 7>(
+                    [](auto &&p, auto &&n) { return field<zavgS_MYY_tag>(n) * field<sign_tag>(p); },
+                    ptr,
+                    strides,
+                    neighbors);
+                field<pnabla_MXX_tag>(ptr) = field<pnabla_MXX_tag>(ptr) / field<vol_tag>(ptr);
+                field<pnabla_MYY_tag>(ptr) = field<pnabla_MYY_tag>(ptr) / field<vol_tag>(ptr);
+            };
+        }
     };
-  }
-};
-inline constexpr auto nabla = [](domain d, auto &&v2e, auto &&e2v) {
-  static_assert(is_sid<decltype(v2e(traits_t()))>());
-  static_assert(is_sid<decltype(e2v(traits_t()))>());
-  return [d = std::move(d),
-          v2e = sid::rename_dimensions<dim::n, v2e_tag>(
-              std::forward<decltype(v2e)>(v2e)(traits_t())),
-          e2v = sid::rename_dimensions<dim::n, e2v_tag>(
-              std::forward<decltype(e2v)>(e2v)(traits_t()))](
-             auto &&S_MXX, auto &&S_MYY, auto &&pp, auto &&pnabla_MXX,
-             auto &&pnabla_MYY, auto &&vol, auto &&sign) {
-    static_assert(is_sid<decltype(S_MXX)>());
-    static_assert(is_sid<decltype(S_MYY)>());
-    static_assert(is_sid<decltype(pp)>());
-    static_assert(is_sid<decltype(pnabla_MXX)>());
-    static_assert(is_sid<decltype(pnabla_MYY)>());
-    static_assert(is_sid<decltype(vol)>());
-    static_assert(is_sid<decltype(sign)>());
-    auto alloc = make_allocator();
-    auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
-    auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
-    call_kernel<kernel_0>(d.edge,
-                          sid::composite::make<e2v_tag, S_MXX_tag, S_MYY_tag,
-                                               zavgS_MXX_tag, zavgS_MYY_tag>(
-                              e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY),
-                          sid::composite::make<pp_tag>(pp));
-    call_kernel<kernel_1>(
-        d.vertex,
-        sid::composite::make<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag,
-                             vol_tag>(
-            v2e, pnabla_MXX, pnabla_MYY,
-            sid::rename_dimensions<dim::s, v2e_tag>(sign), vol),
-        sid::composite::make<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX,
-                                                           zavgS_MYY));
-  };
-};
-} // namespace gridtools::next::cuda::nabla_impl_
-using gridtools::next::cuda::nabla_impl_::nabla;
+    inline constexpr auto nabla = [](domain d, auto &&v2e, auto &&e2v) {
+        static_assert(is_sid<decltype(v2e(traits_t()))>());
+        static_assert(is_sid<decltype(e2v(traits_t()))>());
+        return
+            [d = std::move(d),
+                v2e = sid::rename_dimensions<dim::n, v2e_tag>(std::forward<decltype(v2e)>(v2e)(traits_t())),
+                e2v = sid::rename_dimensions<dim::n, e2v_tag>(std::forward<decltype(e2v)>(e2v)(traits_t()))](
+                auto &&S_MXX, auto &&S_MYY, auto &&pp, auto &&pnabla_MXX, auto &&pnabla_MYY, auto &&vol, auto &&sign) {
+                static_assert(is_sid<decltype(S_MXX)>());
+                static_assert(is_sid<decltype(S_MYY)>());
+                static_assert(is_sid<decltype(pp)>());
+                static_assert(is_sid<decltype(pnabla_MXX)>());
+                static_assert(is_sid<decltype(pnabla_MYY)>());
+                static_assert(is_sid<decltype(vol)>());
+                static_assert(is_sid<decltype(sign)>());
+                auto alloc = make_allocator();
+                auto zavgS_MXX = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
+                auto zavgS_MYY = make_simple_tmp_storage<double>(d.edge, d.k, alloc);
+                call_kernel<kernel_0>(d.edge,
+                    sid::composite::make<e2v_tag, S_MXX_tag, S_MYY_tag, zavgS_MXX_tag, zavgS_MYY_tag>(
+                        e2v, S_MXX, S_MYY, zavgS_MXX, zavgS_MYY),
+                    sid::composite::make<pp_tag>(pp));
+                call_kernel<kernel_1>(d.vertex,
+                    sid::composite::make<v2e_tag, pnabla_MXX_tag, pnabla_MYY_tag, sign_tag, vol_tag>(
+                        v2e, pnabla_MXX, pnabla_MYY, sid::rename_dimensions<dim::s, v2e_tag>(sign), vol),
+                    sid::composite::make<zavgS_MXX_tag, zavgS_MYY_tag>(zavgS_MXX, zavgS_MYY));
+            };
+    };
+} // namespace gridtools::usid::cuda::nabla_impl_
+using gridtools::usid::cuda::nabla_impl_::nabla;

From 3ed992e08f42e0f7ba69a2dd01d14cde85ce4126 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 26 Oct 2020 13:55:38 +0100
Subject: [PATCH 11/24] nuke devcont

---
 .devcontainer/devcontainer.json | 32 --------------------------------
 1 file changed, 32 deletions(-)
 delete mode 100644 .devcontainer/devcontainer.json

diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
deleted file mode 100644
index 5453115..0000000
--- a/.devcontainer/devcontainer.json
+++ /dev/null
@@ -1,32 +0,0 @@
-{
-	"name": "Existing Dockerfile",
-
-	// Sets the run context to one level up instead of the .devcontainer folder.
-	"context": "..",
-
-	// Update the 'dockerFile' property if you aren't using the standard 'Dockerfile' filename.
-	"dockerFile": "../.gitpod.Dockerfile",
-
-	// Set *default* container specific settings.json values on container create.
-	"settings": { 
-		"terminal.integrated.shell.linux": null
-	},
-
-	// Add the IDs of extensions you want installed when the container is created.
-	"extensions": []
-
-	// Use 'forwardPorts' to make a list of ports inside the container available locally.
-	// "forwardPorts": [],
-
-	// Uncomment the next line to run commands after the container is created - for example installing curl.
-	// "postCreateCommand": "apt-get update && apt-get install -y curl",
-
-	// Uncomment when using a ptrace-based debugger like C++, Go, and Rust
-	// "runArgs": [ "--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined" ],
-
-	// Uncomment to use the Docker CLI from inside the container. See https://aka.ms/vscode-remote/samples/docker-from-docker.
-	// "mounts": [ "source=/var/run/docker.sock,target=/var/run/docker.sock,type=bind" ],
-
-	// Uncomment to connect as a non-root user if you've added one. See https://aka.ms/vscode-remote/containers/non-root.
-	// "remoteUser": "vscode"
-}

From e80e4225f921ee7766853b9e19bf44fc6467c55c Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Thu, 29 Oct 2020 14:10:08 +0000
Subject: [PATCH 12/24] fix test

---
 src/gtc/unstructured/usid_codegen.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/gtc/unstructured/usid_codegen.py b/src/gtc/unstructured/usid_codegen.py
index d61b181..9942a4c 100644
--- a/src/gtc/unstructured/usid_codegen.py
+++ b/src/gtc/unstructured/usid_codegen.py
@@ -171,7 +171,7 @@ def visit_Kernel(self, node: Kernel, **kwargs):
         """<%
             sid_deref = symbol_tbl_sids[_this_node.sid]
             sid_entry_deref = sid_deref.symbol_tbl[_this_node.name]
-        %>*gridtools::device::at_key<${ sid_entry_deref.tag_name }>(${ sid_deref.ptr_name })"""
+        %>*gridtools::host_device::at_key<${ sid_entry_deref.tag_name }>(${ sid_deref.ptr_name })"""
     )
 
     AssignStmt = as_fmt("{left} = {right};")
@@ -186,21 +186,21 @@ def visit_Kernel(self, node: Kernel, **kwargs):
             body_location = _this_generator.LOCATION_TYPE_TO_STR[sid_deref.location.elements[-1]] if sid_deref else None
         %>
         for (int neigh = 0; neigh < gridtools::next::connectivity::max_neighbors(${ conn_deref.name }); ++neigh) {
-            auto absolute_neigh_index = *gridtools::device::at_key<${ conn_deref.neighbor_tbl_tag }>(${ outer_sid_deref.ptr_name});
+            auto absolute_neigh_index = *gridtools::host_device::at_key<${ conn_deref.neighbor_tbl_tag }>(${ outer_sid_deref.ptr_name});
             if (absolute_neigh_index != gridtools::next::connectivity::skip_value(${ conn_deref.name })) {
                 % if sid_deref:
                     auto ${ sid_deref.ptr_name } = ${ sid_deref.origin_name }();
                     gridtools::sid::shift(
-                        ${ sid_deref.ptr_name }, gridtools::device::at_key<${ body_location }>(${ sid_deref.strides_name }), absolute_neigh_index);
+                        ${ sid_deref.ptr_name }, gridtools::host_device::at_key<${ body_location }>(${ sid_deref.strides_name }), absolute_neigh_index);
                 % endif
 
                 // bodyparameters
                 ${ ''.join(body) }
                 // end body
             }
-            gridtools::sid::shift(${ outer_sid_deref.ptr_name }, gridtools::device::at_key<neighbor>(${ outer_sid_deref.strides_name }), 1);
+            gridtools::sid::shift(${ outer_sid_deref.ptr_name }, gridtools::host_device::at_key<neighbor>(${ outer_sid_deref.strides_name }), 1);
         }
-        gridtools::sid::shift(${ outer_sid_deref.ptr_name }, gridtools::device::at_key<neighbor>(${ outer_sid_deref.strides_name }),
+        gridtools::sid::shift(${ outer_sid_deref.ptr_name }, gridtools::host_device::at_key<neighbor>(${ outer_sid_deref.strides_name }),
             -gridtools::next::connectivity::max_neighbors(${ conn_deref.name }));
 
         """
@@ -330,7 +330,7 @@ class UsidGpuCodeGenerator(UsidCodeGenerator):
 
 class UsidNaiveCodeGenerator(UsidCodeGenerator):
 
-    cache_allocator_ = "gridtools::sid::device::make_cached_allocator(&std::make_unique<char[]>);"
+    cache_allocator_ = "gridtools::sid::make_cached_allocator(&std::make_unique<char[]>);"
 
     KernelCall = as_mako(
         """
@@ -354,7 +354,7 @@ class UsidNaiveCodeGenerator(UsidCodeGenerator):
             for(std::size_t idx = 0; idx < gridtools::next::connectivity::size(${ prim_conn.name }); idx++) {
                 % if len(prim_sid.entries) > 0:
                 auto ${ prim_sid.ptr_name } = ${ prim_sid.origin_name }();
-                gridtools::sid::shift(${ prim_sid.ptr_name }, gridtools::device::at_key<
+                gridtools::sid::shift(${ prim_sid.ptr_name }, gridtools::at_key<
                     ${ _this_generator.LOCATION_TYPE_TO_STR[prim_sid.location.elements[-1]] }
                     >(${ prim_sid.strides_name }), idx);
                 % endif

From 7125e015761eb959f5599890fbbbf427f8667b68 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Fri, 30 Oct 2020 13:41:51 +0000
Subject: [PATCH 13/24] new usid + usid_codegen

---
 cpputil/usid/CMakeLists.txt                   |   3 +
 src/gtc/unstructured/usid2.py                 | 111 +++++++++++++++
 src/gtc/unstructured/usid2_codegen.py         |  81 +++++++++++
 .../tests_gtc/regression/cpp2/CMakeLists.txt  |  25 ++++
 tests/tests_gtc/regression/cpp2/fvm_nabla.py  | 128 ++++++++++++++++++
 .../regression/cpp2/fvm_nabla_naive.cpp       |   5 +
 6 files changed, 353 insertions(+)
 create mode 100644 src/gtc/unstructured/usid2.py
 create mode 100644 src/gtc/unstructured/usid2_codegen.py
 create mode 100644 tests/tests_gtc/regression/cpp2/CMakeLists.txt
 create mode 100644 tests/tests_gtc/regression/cpp2/fvm_nabla.py
 create mode 100644 tests/tests_gtc/regression/cpp2/fvm_nabla_naive.cpp

diff --git a/cpputil/usid/CMakeLists.txt b/cpputil/usid/CMakeLists.txt
index 0e001dc..fcb1d98 100644
--- a/cpputil/usid/CMakeLists.txt
+++ b/cpputil/usid/CMakeLists.txt
@@ -13,6 +13,7 @@ FetchContent_Declare(GridTools
 FetchContent_MakeAvailable(GridTools)
 
 add_library(usid_naive_helper INTERFACE)
+add_library(usid::usid_naive_helper ALIAS usid_naive_helper)
 target_include_directories(usid_naive_helper INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
 target_link_libraries(usid_naive_helper INTERFACE GridTools::gridtools)
 
@@ -22,6 +23,7 @@ if(CMAKE_CUDA_COMPILER)
     enable_language(CUDA)
 
     add_library(usid_cuda_helper INTERFACE)
+    add_library(usid::usid_cuda_helper ALIAS usid_cuda_helper)
     target_include_directories(usid_cuda_helper INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
     target_link_libraries(usid_cuda_helper INTERFACE GridTools::gridtools GridTools::stencil_gpu)
 endif()
@@ -38,6 +40,7 @@ find_package(eckit REQUIRED)
 find_package(Atlas REQUIRED)
 
 add_library(fvm_nabla_driver INTERFACE)
+add_library(usid::fvm_nabla_driver ALIAS fvm_nabla_driver)
 target_include_directories(fvm_nabla_driver INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
 target_link_libraries(fvm_nabla_driver INTERFACE atlas eckit GridTools::gridtools gtest)
 if(CMAKE_CUDA_COMPILER)
diff --git a/src/gtc/unstructured/usid2.py b/src/gtc/unstructured/usid2.py
new file mode 100644
index 0000000..484732f
--- /dev/null
+++ b/src/gtc/unstructured/usid2.py
@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+#
+# Eve Toolchain - GT4Py Project - GridTools Framework
+#
+# Copyright (c) 2020, CSCS - Swiss National Supercomputing Center, ETH Zurich
+# All rights reserved.
+#
+# This file is part of the GT4Py project and the GridTools framework.
+# GT4Py is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later
+# version. See the LICENSE.txt file at the top-level directory of this
+# distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import enum
+from typing import List
+from eve import Node, Str, Int, Bool, StrEnum
+from gtc import common
+
+
+class Sid(Node):
+    name: Str
+
+
+class SparseField(Sid):
+    connectivity: Str
+
+
+class Temporary(Node):
+    name: Str
+    location_type: Str
+    dtype: Str
+
+
+class Composite(Node):
+    name: Str
+    items: List[Sid]
+
+
+class Expr(Node):
+    pass
+
+
+class Literal(Expr):
+    value: Str
+    dtype: Str
+
+
+class FieldAccess(Expr):
+    name: Str
+    location: Str
+
+
+class VarAccess(Expr):
+    name: Str
+
+
+class BinaryOp(Expr):
+    op: common.BinaryOperator
+    left: Expr
+    right: Expr
+
+
+@enum.unique
+class ReduceOperator(StrEnum):
+    ADD = "sum"
+    MUL = "mul"
+    MAX = "max"
+    MIN = "min"
+
+
+class NeighborReduction(Expr):
+    op: ReduceOperator
+    dtype: Str
+    connectivity: Str
+    max_neighbors: Int
+    has_skip_values: Bool
+    primary: Str
+    secondary: Str
+    body: Expr
+
+
+class Stmt(Node):
+    pass
+
+
+class VarDecl(Stmt):
+    name: Str
+    init: Expr
+
+
+class Assign(Stmt):
+    left: FieldAccess
+    right: Expr
+
+
+class Kernel(Node):
+    location_type: Str
+    primary: Composite
+    secondaries: List[Composite]
+    body: List[Stmt]
+
+
+class Computation(Node):
+    name: Str
+    connectivities: List[Str]
+    params: List[Str]
+    temporaries: List[Temporary]
+    kernels: List[Kernel]
diff --git a/src/gtc/unstructured/usid2_codegen.py b/src/gtc/unstructured/usid2_codegen.py
new file mode 100644
index 0000000..2d0c28e
--- /dev/null
+++ b/src/gtc/unstructured/usid2_codegen.py
@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+#
+# Eve Toolchain - GT4Py Project - GridTools Framework
+#
+# Copyright (c) 2020, CSCS - Swiss National Supercomputing Center, ETH Zurich
+# All rights reserved.
+#
+# This file is part of the GT4Py project and the GridTools framework.
+# GT4Py is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later
+# version. See the LICENSE.txt file at the top-level directory of this
+# distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from eve import codegen
+from eve.codegen import FormatTemplate as as_fmt
+from eve.codegen import MakoTemplate as as_mako
+from gtc.unstructured import usid2
+
+
+class _KernelCallGenerator(codegen.TemplatedGenerator):
+    Sid = as_fmt('{name}')
+    SparseField = as_fmt('sid::rename_dimensions<dim::s, {connectivity}_tag>({name})')
+    Composite = as_mako(
+        "sid::composite::make<${', '.join(f'{i.name}_tag' for i in _this_node.items)}>(${', '.join(items)})")
+    Kernel = as_mako(
+        "call_kernel<${id_}>(d.${location_type}${''.join(f', {c}' for c in [primary] + secondaries)});")
+
+
+class _Generator(codegen.TemplatedGenerator):
+    def visit_Computation(self, node: usid2.Computation, **kwargs):
+        return self.generic_visit(node, kernel_calls=[_KernelCallGenerator.apply(k) for k in node.kernels], **kwargs)
+
+    Literal = as_mako('${dtype}{${value}}')
+    BinaryOp = as_fmt('({left} {op} {right})')
+    FieldAccess = as_fmt('field<{name}_tag>({location})')
+    VarAccess = as_fmt('{name}')
+    NeighborReduction = as_mako(
+        '${op}_neighbors<${dtype}, ${connectivity}_tag, ${max_neighbors}, ${has_skip_values.lower()}>' +
+        '([](auto &&${primary}, auto &&${secondary}) { return ${body}; }, ${primary}, strides, ${secondary})')
+    VarDecl = as_fmt('auto&& {name} = {init};')
+    Assign = as_fmt('{left} = {right};')
+    Kernel = as_mako('''struct ${id_} {
+    GT_FUNCTION auto operator()() const {
+        return [](auto && ${_this_node.primary.name}, auto &&strides${''.join(f', auto&& {s.name}' for s in _this_node.secondaries)}) {
+            ${'\\n            '.join(body)}
+        };
+    }
+};''')
+    Temporary = as_fmt(
+        'auto {name} = make_simple_tmp_storage<{dtype}>(d.{location_type}, d.k, alloc);')
+    Computation = as_mako("""#pragma once
+#include <gridtools/usid/${ backend }_helpers.hpp>
+namespace gridtools::usid::${ backend }::${ name }_impl_ {
+${'\\n'.join(f'struct {f}_tag;' for f in connectivities + params + [t.name for t in _this_node.temporaries])}
+${'\\n'.join(kernels)}
+inline constexpr auto ${ name } = [](domain d${ ''.join(f', auto&& {c}' for c in connectivities) }) {
+    ${'\\n    '.join(f'static_assert(is_sid<decltype({c}(traits_t()))>());' for c in connectivities)}
+    return[d = std::move(d)${ ''.join(f', {c} = sid::rename_dimensions<dim::n, {c}_tag>(std::forward<decltype({c})>({c})(traits_t()))' for c in connectivities) }]
+    (${ ', '.join(f'auto&& {p}' for p in params)}) {
+        ${'\\n        '.join(f'static_assert(is_sid<decltype({p})>());' for p in params)}
+% if len(temporaries) > 0:
+        auto alloc = make_allocator();
+        ${'\\n        '.join(temporaries)}
+% endif
+        ${'\\n        '.join(kernel_calls)}
+    };
+};
+}
+using gridtools::usid::${ backend }::${ name }_impl_::${ name };
+""")
+
+
+def _impl(backend):
+    return lambda src: codegen.format_source('cpp', _Generator.apply(src, backend=backend), style='LLVM')
+
+
+naive = _impl('naive')
+gpu = _impl('gpu')
diff --git a/tests/tests_gtc/regression/cpp2/CMakeLists.txt b/tests/tests_gtc/regression/cpp2/CMakeLists.txt
new file mode 100644
index 0000000..875d02c
--- /dev/null
+++ b/tests/tests_gtc/regression/cpp2/CMakeLists.txt
@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.14.5)
+project(gtc_regression2 LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+
+include(FetchContent)
+FetchContent_Declare(usid
+    SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../cpputil/usid)
+FetchContent_MakeAvailable(usid)
+
+include(CTest)
+find_package(Python3 COMPONENTS Interpreter REQUIRED)
+
+# TODO(anstaf): factor out the stuff into cmake function 
+add_custom_command(
+    OUTPUT fvm_nabla_naive.hpp
+    COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/fvm_nabla.py naive > fvm_nabla_naive.hpp)
+add_custom_target(fvm_nabla_naive_header DEPENDS fvm_nabla_naive.hpp)
+add_executable(fvm_nabla_naive fvm_nabla_naive.cpp)
+target_include_directories(fvm_nabla_naive PRIVATE ${CMAKE_BINARY_DIR})
+add_dependencies(fvm_nabla_naive fvm_nabla_naive_header)
+target_link_libraries(fvm_nabla_naive PRIVATE usid::usid_naive_helper usid::fvm_nabla_driver gtest_main)
+add_test(NAME fvm_nabla_naive COMMAND $<TARGET_FILE:fvm_nabla_naive>)
+
+# TODO(anstaf): add gpu executable
diff --git a/tests/tests_gtc/regression/cpp2/fvm_nabla.py b/tests/tests_gtc/regression/cpp2/fvm_nabla.py
new file mode 100644
index 0000000..fa8240a
--- /dev/null
+++ b/tests/tests_gtc/regression/cpp2/fvm_nabla.py
@@ -0,0 +1,128 @@
+import sys
+from gtc.unstructured.usid2 import *
+from gtc.unstructured import usid2_codegen
+
+input = Computation(
+    name='nabla',
+    connectivities=['v2e', 'e2v'],
+    params=['S_MXX', 'S_MYY', 'pp', 'pnabla_MXX', 'pnabla_MYY', 'vol', 'sign'],
+    temporaries=[
+        Temporary(name='zavgS_MXX', dtype='double', location_type='edge'),
+        Temporary(name='zavgS_MYY', dtype='double', location_type='edge'),
+    ],
+    kernels=[
+        Kernel(
+            location_type='edge',
+            primary=Composite(
+                name='e',
+                items=[
+                    Sid(name='e2v'),
+                    Sid(name='S_MXX'),
+                    Sid(name='S_MYY'),
+                    Sid(name='zavgS_MXX'),
+                    Sid(name='zavgS_MYY')]),
+            secondaries=[Composite(name='v', items=[Sid(name='pp')])],
+            body=[
+                VarDecl(
+                    name='zavg',
+                    init=BinaryOp(
+                        op=common.BinaryOperator.MUL,
+                        left=Literal(dtype='double', value='.5'),
+                        right=NeighborReduction(
+                            op=ReduceOperator.ADD,
+                            dtype='double',
+                            connectivity='e2v',
+                            max_neighbors=2,
+                            has_skip_values=False,
+                            primary='e',
+                            secondary='v',
+                            body=FieldAccess(name='pp', location='v'),
+                        ),
+                    ),
+                ),
+                Assign(
+                    left=FieldAccess(name='zavgS_MXX', location='e'),
+                    right=BinaryOp(
+                        op=common.BinaryOperator.MUL,
+                        left=FieldAccess(name='S_MXX', location='e'),
+                        right=VarAccess(name='zavg')),
+                ),
+                Assign(
+                    left=FieldAccess(name='zavgS_MYY', location='e'),
+                    right=BinaryOp(
+                        op=common.BinaryOperator.MUL,
+                        left=FieldAccess(name='S_MYY', location='e'),
+                        right=VarAccess(name='zavg')),
+                ),
+            ],
+        ),
+        Kernel(
+            location_type='vertex',
+            primary=Composite(
+                name='v',
+                items=[
+                    Sid(name='v2e'),
+                    Sid(name='pnabla_MXX'),
+                    Sid(name='pnabla_MYY'),
+                    SparseField(name='sign', connectivity='v2e'),
+                    Sid(name='vol')
+                ]),
+            secondaries=[Composite(name='e', items=[Sid(name='zavgS_MXX'), Sid(name='zavgS_MYY')])],
+            body=[
+                Assign(
+                    left=FieldAccess(name='pnabla_MXX', location='v'),
+                    right=NeighborReduction(
+                        op=ReduceOperator.ADD,
+                        dtype='double',
+                        connectivity='v2e',
+                        max_neighbors=7,
+                        has_skip_values=True,
+                        primary='v',
+                        secondary='e',
+                        body=BinaryOp(
+                            op=common.BinaryOperator.MUL,
+                            left=FieldAccess(name='zavgS_MXX', location='e'),
+                            right=FieldAccess(name='sign', location='v'),
+                        ),
+                    ),
+                ),
+                Assign(
+                    left=FieldAccess(name='pnabla_MYY', location='v'),
+                    right=NeighborReduction(
+                        op=ReduceOperator.ADD,
+                        dtype='double',
+                        connectivity='v2e',
+                        max_neighbors=7,
+                        has_skip_values=True,
+                        primary='v',
+                        secondary='e',
+                        body=BinaryOp(
+                            op=common.BinaryOperator.MUL,
+                            left=FieldAccess(name='zavgS_MYY', location='e'),
+                            right=FieldAccess(name='sign', location='v'),
+                        ),
+                    ),
+                ),
+                Assign(
+                    left=FieldAccess(name='pnabla_MXX', location='v'),
+                    right=BinaryOp(
+                        op=common.BinaryOperator.DIV,
+                        left=FieldAccess(name='pnabla_MXX', location='v'),
+                        right=FieldAccess(name='vol', location='v'),
+                    ),
+                ),
+                Assign(
+                    left=FieldAccess(name='pnabla_MYY', location='v'),
+                    right=BinaryOp(
+                        op=common.BinaryOperator.DIV,
+                        left=FieldAccess(name='pnabla_MYY', location='v'),
+                        right=FieldAccess(name='vol', location='v'),
+                    ),
+                ),
+            ],
+        )
+    ])
+
+if __name__ == "__main__":
+    gen = usid2_codegen.gpu if len(sys.argv) > 1 and sys.argv[1] == 'gpu' else usid2_codegen.naive
+    print(gen(input))
diff --git a/tests/tests_gtc/regression/cpp2/fvm_nabla_naive.cpp b/tests/tests_gtc/regression/cpp2/fvm_nabla_naive.cpp
new file mode 100644
index 0000000..764316d
--- /dev/null
+++ b/tests/tests_gtc/regression/cpp2/fvm_nabla_naive.cpp
@@ -0,0 +1,5 @@
+#include "fvm_nabla_naive.hpp"
+#include <gtest/gtest.h>
+#include <tests/fvm_nabla_driver.hpp>
+
+TEST(fvm, nabla_naive) { fvm_nabla_driver(nabla); }

From 64bc3e98d86c83d812076e687ecedfe7b8e7d69c Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Fri, 30 Oct 2020 14:02:11 +0000
Subject: [PATCH 14/24] make linter happy

---
 tests/tests_gtc/regression/cpp2/fvm_nabla.py | 125 ++++++++++---------
 1 file changed, 63 insertions(+), 62 deletions(-)

diff --git a/tests/tests_gtc/regression/cpp2/fvm_nabla.py b/tests/tests_gtc/regression/cpp2/fvm_nabla.py
index fa8240a..e4cf3c6 100644
--- a/tests/tests_gtc/regression/cpp2/fvm_nabla.py
+++ b/tests/tests_gtc/regression/cpp2/fvm_nabla.py
@@ -1,122 +1,123 @@
 import sys
-from gtc.unstructured.usid2 import *
-from gtc.unstructured import usid2_codegen
+from gtc.unstructured import usid2_codegen, usid2
+from gtc import common
 
-input = Computation(
+_usid2_src = usid2.Computation(
     name='nabla',
     connectivities=['v2e', 'e2v'],
     params=['S_MXX', 'S_MYY', 'pp', 'pnabla_MXX', 'pnabla_MYY', 'vol', 'sign'],
     temporaries=[
-        Temporary(name='zavgS_MXX', dtype='double', location_type='edge'),
-        Temporary(name='zavgS_MYY', dtype='double', location_type='edge'),
+        usid2.Temporary(name='zavgS_MXX', dtype='double', location_type='edge'),
+        usid2.Temporary(name='zavgS_MYY', dtype='double', location_type='edge'),
     ],
     kernels=[
-        Kernel(
+        usid2.Kernel(
             location_type='edge',
-            primary=Composite(
+            primary=usid2.Composite(
                 name='e',
                 items=[
-                    Sid(name='e2v'),
-                    Sid(name='S_MXX'),
-                    Sid(name='S_MYY'),
-                    Sid(name='zavgS_MXX'),
-                    Sid(name='zavgS_MYY')]),
-            secondaries=[Composite(name='v', items=[Sid(name='pp')])],
+                    usid2.Sid(name='e2v'),
+                    usid2.Sid(name='S_MXX'),
+                    usid2.Sid(name='S_MYY'),
+                    usid2.Sid(name='zavgS_MXX'),
+                    usid2.Sid(name='zavgS_MYY')]),
+            secondaries=[usid2.Composite(name='v', items=[usid2.Sid(name='pp')])],
             body=[
-                VarDecl(
+                usid2.VarDecl(
                     name='zavg',
-                    init=BinaryOp(
+                    init=usid2.BinaryOp(
                         op=common.BinaryOperator.MUL,
-                        left=Literal(dtype='double', value='.5'),
-                        right=NeighborReduction(
-                            op=ReduceOperator.ADD,
+                        left=usid2.Literal(dtype='double', value='.5'),
+                        right=usid2.NeighborReduction(
+                            op=usid2.ReduceOperator.ADD,
                             dtype='double',
                             connectivity='e2v',
                             max_neighbors=2,
                             has_skip_values=False,
                             primary='e',
                             secondary='v',
-                            body=FieldAccess(name='pp', location='v'),
+                            body=usid2.FieldAccess(name='pp', location='v'),
                         ),
                     ),
                 ),
-                Assign(
-                    left=FieldAccess(name='zavgS_MXX', location='e'),
-                    right=BinaryOp(
+                usid2.Assign(
+                    left=usid2.FieldAccess(name='zavgS_MXX', location='e'),
+                    right=usid2.BinaryOp(
                         op=common.BinaryOperator.MUL,
-                        left=FieldAccess(name='S_MXX', location='e'),
-                        right=VarAccess(name='zavg')),
+                        left=usid2.FieldAccess(name='S_MXX', location='e'),
+                        right=usid2.VarAccess(name='zavg')),
                 ),
-                Assign(
-                    left=FieldAccess(name='zavgS_MYY', location='e'),
-                    right=BinaryOp(
+                usid2.Assign(
+                    left=usid2.FieldAccess(name='zavgS_MYY', location='e'),
+                    right=usid2.BinaryOp(
                         op=common.BinaryOperator.MUL,
-                        left=FieldAccess(name='S_MYY', location='e'),
-                        right=VarAccess(name='zavg')),
+                        left=usid2.FieldAccess(name='S_MYY', location='e'),
+                        right=usid2.VarAccess(name='zavg')),
                 ),
             ],
         ),
-        Kernel(
+        usid2.Kernel(
             location_type='vertex',
-            primary=Composite(
+            primary=usid2.Composite(
                 name='v',
                 items=[
-                    Sid(name='v2e'),
-                    Sid(name='pnabla_MXX'),
-                    Sid(name='pnabla_MYY'),
-                    SparseField(name='sign', connectivity='v2e'),
-                    Sid(name='vol')
+                    usid2.Sid(name='v2e'),
+                    usid2.Sid(name='pnabla_MXX'),
+                    usid2.Sid(name='pnabla_MYY'),
+                    usid2.SparseField(name='sign', connectivity='v2e'),
+                    usid2.Sid(name='vol')
                 ]),
-            secondaries=[Composite(name='e', items=[Sid(name='zavgS_MXX'), Sid(name='zavgS_MYY')])],
+            secondaries=[usid2.Composite(
+                name='e', items=[usid2.Sid(name='zavgS_MXX'), usid2.Sid(name='zavgS_MYY')])],
             body=[
-                Assign(
-                    left=FieldAccess(name='pnabla_MXX', location='v'),
-                    right=NeighborReduction(
-                        op=ReduceOperator.ADD,
+                usid2.Assign(
+                    left=usid2.FieldAccess(name='pnabla_MXX', location='v'),
+                    right=usid2.NeighborReduction(
+                        op=usid2.ReduceOperator.ADD,
                         dtype='double',
                         connectivity='v2e',
                         max_neighbors=7,
                         has_skip_values=True,
                         primary='v',
                         secondary='e',
-                        body=BinaryOp(
+                        body=usid2.BinaryOp(
                             op=common.BinaryOperator.MUL,
-                            left=FieldAccess(name='zavgS_MXX', location='e'),
-                            right=FieldAccess(name='sign', location='v'),
+                            left=usid2.FieldAccess(name='zavgS_MXX', location='e'),
+                            right=usid2.FieldAccess(name='sign', location='v'),
                         ),
                     ),
                 ),
-                Assign(
-                    left=FieldAccess(name='pnabla_MYY', location='v'),
-                    right=NeighborReduction(
-                        op=ReduceOperator.ADD,
+                usid2.Assign(
+                    left=usid2.FieldAccess(name='pnabla_MYY', location='v'),
+                    right=usid2.NeighborReduction(
+                        op=usid2.ReduceOperator.ADD,
                         dtype='double',
                         connectivity='v2e',
                         max_neighbors=7,
                         has_skip_values=True,
                         primary='v',
                         secondary='e',
-                        body=BinaryOp(
+                        body=usid2.BinaryOp(
                             op=common.BinaryOperator.MUL,
-                            left=FieldAccess(name='zavgS_MYY', location='e'),
-                            right=FieldAccess(name='sign', location='v'),
+                            left=usid2.FieldAccess(name='zavgS_MYY', location='e'),
+                            right=usid2.FieldAccess(name='sign', location='v'),
                         ),
                     ),
                 ),
-                Assign(
-                    left=FieldAccess(name='pnabla_MXX', location='v'),
-                    right=BinaryOp(
+                usid2.Assign(
+                    left=usid2.FieldAccess(name='pnabla_MXX', location='v'),
+                    right=usid2.BinaryOp(
                         op=common.BinaryOperator.DIV,
-                        left=FieldAccess(name='pnabla_MXX', location='v'),
-                        right=FieldAccess(name='vol', location='v'),
+                        left=usid2.FieldAccess(name='pnabla_MXX', location='v'),
+                        right=usid2.FieldAccess(name='vol', location='v'),
                     ),
                 ),
-                Assign(
-                    left=FieldAccess(name='pnabla_MYY', location='v'),
-                    right=BinaryOp(
+                usid2.Assign(
+                    left=usid2.FieldAccess(name='pnabla_MYY', location='v'),
+                    right=usid2.BinaryOp(
                         op=common.BinaryOperator.DIV,
-                        left=FieldAccess(name='pnabla_MYY', location='v'),
-                        right=FieldAccess(name='vol', location='v'),
+                        left=usid2.FieldAccess(name='pnabla_MYY', location='v'),
+                        right=usid2.FieldAccess(name='vol', location='v'),
                     ),
                 ),
             ],
@@ -125,4 +126,4 @@
 
 if __name__ == "__main__":
     gen = usid2_codegen.gpu if len(sys.argv) > 1 and sys.argv[1] == 'gpu' else usid2_codegen.naive
-    print(gen(input))
+    print(gen(_usid2_src))

From 40842b738b11666e5bae63941f77debf8ced0cc6 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Fri, 30 Oct 2020 14:27:46 +0000
Subject: [PATCH 15/24] formatting

---
 src/gtc/unstructured/usid2.py         |  3 +-
 src/gtc/unstructured/usid2_codegen.py | 54 ++++++++++++++++-----------
 2 files changed, 35 insertions(+), 22 deletions(-)

diff --git a/src/gtc/unstructured/usid2.py b/src/gtc/unstructured/usid2.py
index 484732f..b8b634b 100644
--- a/src/gtc/unstructured/usid2.py
+++ b/src/gtc/unstructured/usid2.py
@@ -16,7 +16,8 @@
 
 import enum
 from typing import List
-from eve import Node, Str, Int, Bool, StrEnum
+
+from eve import Bool, Int, Node, Str, StrEnum
 from gtc import common
 
 
diff --git a/src/gtc/unstructured/usid2_codegen.py b/src/gtc/unstructured/usid2_codegen.py
index 2d0c28e..c36ebc3 100644
--- a/src/gtc/unstructured/usid2_codegen.py
+++ b/src/gtc/unstructured/usid2_codegen.py
@@ -21,37 +21,46 @@
 
 
 class _KernelCallGenerator(codegen.TemplatedGenerator):
-    Sid = as_fmt('{name}')
-    SparseField = as_fmt('sid::rename_dimensions<dim::s, {connectivity}_tag>({name})')
+    Sid = as_fmt("{name}")
+    SparseField = as_fmt("sid::rename_dimensions<dim::s, {connectivity}_tag>({name})")
     Composite = as_mako(
-        "sid::composite::make<${', '.join(f'{i.name}_tag' for i in _this_node.items)}>(${', '.join(items)})")
+        "sid::composite::make<${', '.join(f'{i.name}_tag' for i in _this_node.items)}>(${', '.join(items)})"
+    )
     Kernel = as_mako(
-        "call_kernel<${id_}>(d.${location_type}${''.join(f', {c}' for c in [primary] + secondaries)});")
+        "call_kernel<${id_}>(d.${location_type}${''.join(f', {c}' for c in [primary] + secondaries)});"
+    )
 
 
 class _Generator(codegen.TemplatedGenerator):
     def visit_Computation(self, node: usid2.Computation, **kwargs):
-        return self.generic_visit(node, kernel_calls=[_KernelCallGenerator.apply(k) for k in node.kernels], **kwargs)
+        return self.generic_visit(
+            node, kernel_calls=[_KernelCallGenerator.apply(k) for k in node.kernels], **kwargs
+        )
 
-    Literal = as_mako('${dtype}{${value}}')
-    BinaryOp = as_fmt('({left} {op} {right})')
-    FieldAccess = as_fmt('field<{name}_tag>({location})')
-    VarAccess = as_fmt('{name}')
+    Literal = as_mako("${dtype}{${value}}")
+    BinaryOp = as_fmt("({left} {op} {right})")
+    FieldAccess = as_fmt("field<{name}_tag>({location})")
+    VarAccess = as_fmt("{name}")
     NeighborReduction = as_mako(
-        '${op}_neighbors<${dtype}, ${connectivity}_tag, ${max_neighbors}, ${has_skip_values.lower()}>' +
-        '([](auto &&${primary}, auto &&${secondary}) { return ${body}; }, ${primary}, strides, ${secondary})')
-    VarDecl = as_fmt('auto&& {name} = {init};')
-    Assign = as_fmt('{left} = {right};')
-    Kernel = as_mako('''struct ${id_} {
+        "${op}_neighbors<${dtype}, ${connectivity}_tag, ${max_neighbors}, ${has_skip_values.lower()}>"
+        + "([](auto &&${primary}, auto &&${secondary}) { return ${body}; }, ${primary}, strides, ${secondary})"
+    )
+    VarDecl = as_fmt("auto&& {name} = {init};")
+    Assign = as_fmt("{left} = {right};")
+    Kernel = as_mako(
+        """struct ${id_} {
     GT_FUNCTION auto operator()() const {
         return [](auto && ${_this_node.primary.name}, auto &&strides${''.join(f', auto&& {s.name}' for s in _this_node.secondaries)}) {
             ${'\\n            '.join(body)}
         };
     }
-};''')
+};"""
+    )
     Temporary = as_fmt(
-        'auto {name} = make_simple_tmp_storage<{dtype}>(d.{location_type}, d.k, alloc);')
-    Computation = as_mako("""#pragma once
+        "auto {name} = make_simple_tmp_storage<{dtype}>(d.{location_type}, d.k, alloc);"
+    )
+    Computation = as_mako(
+        """#pragma once
 #include <gridtools/usid/${ backend }_helpers.hpp>
 namespace gridtools::usid::${ backend }::${ name }_impl_ {
 ${'\\n'.join(f'struct {f}_tag;' for f in connectivities + params + [t.name for t in _this_node.temporaries])}
@@ -70,12 +79,15 @@ def visit_Computation(self, node: usid2.Computation, **kwargs):
 };
 }
 using gridtools::usid::${ backend }::${ name }_impl_::${ name };
-""")
+"""
+    )
 
 
 def _impl(backend):
-    return lambda src: codegen.format_source('cpp', _Generator.apply(src, backend=backend), style='LLVM')
+    return lambda src: codegen.format_source(
+        "cpp", _Generator.apply(src, backend=backend), style="LLVM"
+    )
 
 
-naive = _impl('naive')
-gpu = _impl('gpu')
+naive = _impl("naive")
+gpu = _impl("gpu")

From d4acc98270a4723af559ec7c0a11b9b689e9208c Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Fri, 30 Oct 2020 14:28:13 +0000
Subject: [PATCH 16/24] formatting

---
 tests/tests_gtc/regression/cpp2/fvm_nabla.py | 132 ++++++++++---------
 1 file changed, 72 insertions(+), 60 deletions(-)

diff --git a/tests/tests_gtc/regression/cpp2/fvm_nabla.py b/tests/tests_gtc/regression/cpp2/fvm_nabla.py
index e4cf3c6..c3a1ecb 100644
--- a/tests/tests_gtc/regression/cpp2/fvm_nabla.py
+++ b/tests/tests_gtc/regression/cpp2/fvm_nabla.py
@@ -1,129 +1,141 @@
+# -*- coding: utf-8 -*-
 import sys
-from gtc.unstructured import usid2_codegen, usid2
+
 from gtc import common
+from gtc.unstructured import usid2, usid2_codegen
+
 
 _usid2_src = usid2.Computation(
-    name='nabla',
-    connectivities=['v2e', 'e2v'],
-    params=['S_MXX', 'S_MYY', 'pp', 'pnabla_MXX', 'pnabla_MYY', 'vol', 'sign'],
+    name="nabla",
+    connectivities=["v2e", "e2v"],
+    params=["S_MXX", "S_MYY", "pp", "pnabla_MXX", "pnabla_MYY", "vol", "sign"],
     temporaries=[
-        usid2.Temporary(name='zavgS_MXX', dtype='double', location_type='edge'),
-        usid2.Temporary(name='zavgS_MYY', dtype='double', location_type='edge'),
+        usid2.Temporary(name="zavgS_MXX", dtype="double", location_type="edge"),
+        usid2.Temporary(name="zavgS_MYY", dtype="double", location_type="edge"),
     ],
     kernels=[
         usid2.Kernel(
-            location_type='edge',
+            location_type="edge",
             primary=usid2.Composite(
-                name='e',
+                name="e",
                 items=[
-                    usid2.Sid(name='e2v'),
-                    usid2.Sid(name='S_MXX'),
-                    usid2.Sid(name='S_MYY'),
-                    usid2.Sid(name='zavgS_MXX'),
-                    usid2.Sid(name='zavgS_MYY')]),
-            secondaries=[usid2.Composite(name='v', items=[usid2.Sid(name='pp')])],
+                    usid2.Sid(name="e2v"),
+                    usid2.Sid(name="S_MXX"),
+                    usid2.Sid(name="S_MYY"),
+                    usid2.Sid(name="zavgS_MXX"),
+                    usid2.Sid(name="zavgS_MYY"),
+                ],
+            ),
+            secondaries=[usid2.Composite(name="v", items=[usid2.Sid(name="pp")])],
             body=[
                 usid2.VarDecl(
-                    name='zavg',
+                    name="zavg",
                     init=usid2.BinaryOp(
                         op=common.BinaryOperator.MUL,
-                        left=usid2.Literal(dtype='double', value='.5'),
+                        left=usid2.Literal(dtype="double", value=".5"),
                         right=usid2.NeighborReduction(
                             op=usid2.ReduceOperator.ADD,
-                            dtype='double',
-                            connectivity='e2v',
+                            dtype="double",
+                            connectivity="e2v",
                             max_neighbors=2,
                             has_skip_values=False,
-                            primary='e',
-                            secondary='v',
-                            body=usid2.FieldAccess(name='pp', location='v'),
+                            primary="e",
+                            secondary="v",
+                            body=usid2.FieldAccess(name="pp", location="v"),
                         ),
                     ),
                 ),
                 usid2.Assign(
-                    left=usid2.FieldAccess(name='zavgS_MXX', location='e'),
+                    left=usid2.FieldAccess(name="zavgS_MXX", location="e"),
                     right=usid2.BinaryOp(
                         op=common.BinaryOperator.MUL,
-                        left=usid2.FieldAccess(name='S_MXX', location='e'),
-                        right=usid2.VarAccess(name='zavg')),
+                        left=usid2.FieldAccess(name="S_MXX", location="e"),
+                        right=usid2.VarAccess(name="zavg"),
+                    ),
                 ),
                 usid2.Assign(
-                    left=usid2.FieldAccess(name='zavgS_MYY', location='e'),
+                    left=usid2.FieldAccess(name="zavgS_MYY", location="e"),
                     right=usid2.BinaryOp(
                         op=common.BinaryOperator.MUL,
-                        left=usid2.FieldAccess(name='S_MYY', location='e'),
-                        right=usid2.VarAccess(name='zavg')),
+                        left=usid2.FieldAccess(name="S_MYY", location="e"),
+                        right=usid2.VarAccess(name="zavg"),
+                    ),
                 ),
             ],
         ),
         usid2.Kernel(
-            location_type='vertex',
+            location_type="vertex",
             primary=usid2.Composite(
-                name='v',
+                name="v",
                 items=[
-                    usid2.Sid(name='v2e'),
-                    usid2.Sid(name='pnabla_MXX'),
-                    usid2.Sid(name='pnabla_MYY'),
-                    usid2.SparseField(name='sign', connectivity='v2e'),
-                    usid2.Sid(name='vol')
-                ]),
-            secondaries=[usid2.Composite(
-                name='e', items=[usid2.Sid(name='zavgS_MXX'), usid2.Sid(name='zavgS_MYY')])],
+                    usid2.Sid(name="v2e"),
+                    usid2.Sid(name="pnabla_MXX"),
+                    usid2.Sid(name="pnabla_MYY"),
+                    usid2.SparseField(name="sign", connectivity="v2e"),
+                    usid2.Sid(name="vol"),
+                ],
+            ),
+            secondaries=[
+                usid2.Composite(
+                    name="e", items=[usid2.Sid(name="zavgS_MXX"), usid2.Sid(name="zavgS_MYY")]
+                )
+            ],
             body=[
                 usid2.Assign(
-                    left=usid2.FieldAccess(name='pnabla_MXX', location='v'),
+                    left=usid2.FieldAccess(name="pnabla_MXX", location="v"),
                     right=usid2.NeighborReduction(
                         op=usid2.ReduceOperator.ADD,
-                        dtype='double',
-                        connectivity='v2e',
+                        dtype="double",
+                        connectivity="v2e",
                         max_neighbors=7,
                         has_skip_values=True,
-                        primary='v',
-                        secondary='e',
+                        primary="v",
+                        secondary="e",
                         body=usid2.BinaryOp(
                             op=common.BinaryOperator.MUL,
-                            left=usid2.FieldAccess(name='zavgS_MXX', location='e'),
-                            right=usid2.FieldAccess(name='sign', location='v'),
+                            left=usid2.FieldAccess(name="zavgS_MXX", location="e"),
+                            right=usid2.FieldAccess(name="sign", location="v"),
                         ),
                     ),
                 ),
                 usid2.Assign(
-                    left=usid2.FieldAccess(name='pnabla_MYY', location='v'),
+                    left=usid2.FieldAccess(name="pnabla_MYY", location="v"),
                     right=usid2.NeighborReduction(
                         op=usid2.ReduceOperator.ADD,
-                        dtype='double',
-                        connectivity='v2e',
+                        dtype="double",
+                        connectivity="v2e",
                         max_neighbors=7,
                         has_skip_values=True,
-                        primary='v',
-                        secondary='e',
+                        primary="v",
+                        secondary="e",
                         body=usid2.BinaryOp(
                             op=common.BinaryOperator.MUL,
-                            left=usid2.FieldAccess(name='zavgS_MYY', location='e'),
-                            right=usid2.FieldAccess(name='sign', location='v'),
+                            left=usid2.FieldAccess(name="zavgS_MYY", location="e"),
+                            right=usid2.FieldAccess(name="sign", location="v"),
                         ),
                     ),
                 ),
                 usid2.Assign(
-                    left=usid2.FieldAccess(name='pnabla_MXX', location='v'),
+                    left=usid2.FieldAccess(name="pnabla_MXX", location="v"),
                     right=usid2.BinaryOp(
                         op=common.BinaryOperator.DIV,
-                        left=usid2.FieldAccess(name='pnabla_MXX', location='v'),
-                        right=usid2.FieldAccess(name='vol', location='v'),
+                        left=usid2.FieldAccess(name="pnabla_MXX", location="v"),
+                        right=usid2.FieldAccess(name="vol", location="v"),
                     ),
                 ),
                 usid2.Assign(
-                    left=usid2.FieldAccess(name='pnabla_MYY', location='v'),
+                    left=usid2.FieldAccess(name="pnabla_MYY", location="v"),
                     right=usid2.BinaryOp(
                         op=common.BinaryOperator.DIV,
-                        left=usid2.FieldAccess(name='pnabla_MYY', location='v'),
-                        right=usid2.FieldAccess(name='vol', location='v'),
+                        left=usid2.FieldAccess(name="pnabla_MYY", location="v"),
+                        right=usid2.FieldAccess(name="vol", location="v"),
                     ),
                 ),
             ],
-        )
-    ])
+        ),
+    ],
+)
 
 if __name__ == "__main__":
-    gen = usid2_codegen.gpu if len(sys.argv) > 1 and sys.argv[1] == 'gpu' else usid2_codegen.naive
+    gen = usid2_codegen.gpu if len(sys.argv) > 1 and sys.argv[1] == "gpu" else usid2_codegen.naive
     print(gen(_usid2_src))

From c965f7db7a84f9f1656f1be1bd0070dcbd84a380 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Thu, 5 Nov 2020 17:20:00 +0000
Subject: [PATCH 17/24] gtir2 and friends

---
 cpputil/usid/CMakeLists.txt                   |   6 +-
 .../usid/include/gridtools/usid/helpers.hpp   | 119 ++++---
 setup.cfg                                     |   3 +-
 src/gt_frontend/built_in_types.py             |   8 +
 src/gt_frontend/gtscript.py                   |   4 +-
 src/gtc/unstructured/frontend.py              |  28 ++
 src/gtc/unstructured/gtir2.py                 | 114 +++++++
 src/gtc/unstructured/gtir_to_usid2.py         | 182 +++++++++++
 src/gtc/unstructured/gtscript_ast2.py         |  81 +++++
 src/gtc/unstructured/py_to_gtir2.py           | 291 ++++++++++++++++++
 src/gtc/unstructured/py_to_gtscript2.py       | 130 ++++++++
 src/gtc/unstructured/usid2.py                 |  31 +-
 src/gtc/unstructured/usid2_codegen.py         |   6 +-
 tests/tests_gtc/regression/cpp2/fvm_nabla.py  | 176 +++--------
 14 files changed, 950 insertions(+), 229 deletions(-)
 create mode 100644 src/gtc/unstructured/frontend.py
 create mode 100644 src/gtc/unstructured/gtir2.py
 create mode 100644 src/gtc/unstructured/gtir_to_usid2.py
 create mode 100644 src/gtc/unstructured/gtscript_ast2.py
 create mode 100644 src/gtc/unstructured/py_to_gtir2.py
 create mode 100644 src/gtc/unstructured/py_to_gtscript2.py

diff --git a/cpputil/usid/CMakeLists.txt b/cpputil/usid/CMakeLists.txt
index fcb1d98..ecf288e 100644
--- a/cpputil/usid/CMakeLists.txt
+++ b/cpputil/usid/CMakeLists.txt
@@ -14,7 +14,7 @@ FetchContent_MakeAvailable(GridTools)
 
 add_library(usid_naive_helper INTERFACE)
 add_library(usid::usid_naive_helper ALIAS usid_naive_helper)
-target_include_directories(usid_naive_helper INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+target_include_directories(usid_naive_helper INTERFACE ${PROJECT_SOURCE_DIR}/include)
 target_link_libraries(usid_naive_helper INTERFACE GridTools::gridtools)
 
 include(CheckLanguage)
@@ -24,7 +24,7 @@ if(CMAKE_CUDA_COMPILER)
 
     add_library(usid_cuda_helper INTERFACE)
     add_library(usid::usid_cuda_helper ALIAS usid_cuda_helper)
-    target_include_directories(usid_cuda_helper INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+    target_include_directories(usid_cuda_helper INTERFACE ${PROJECT_SOURCE_DIR}/include)
     target_link_libraries(usid_cuda_helper INTERFACE GridTools::gridtools GridTools::stencil_gpu)
 endif()
 
@@ -41,7 +41,7 @@ find_package(Atlas REQUIRED)
 
 add_library(fvm_nabla_driver INTERFACE)
 add_library(usid::fvm_nabla_driver ALIAS fvm_nabla_driver)
-target_include_directories(fvm_nabla_driver INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+target_include_directories(fvm_nabla_driver INTERFACE ${PROJECT_SOURCE_DIR}/include)
 target_link_libraries(fvm_nabla_driver INTERFACE atlas eckit GridTools::gridtools gtest)
 if(CMAKE_CUDA_COMPILER)
     target_link_libraries(fvm_nabla_driver INTERFACE GridTools::stencil_gpu)
diff --git a/cpputil/usid/include/gridtools/usid/helpers.hpp b/cpputil/usid/include/gridtools/usid/helpers.hpp
index e2f3b01..d07fdf3 100644
--- a/cpputil/usid/include/gridtools/usid/helpers.hpp
+++ b/cpputil/usid/include/gridtools/usid/helpers.hpp
@@ -20,69 +20,68 @@
 #include "domain.hpp"
 
 namespace gridtools::usid {
-template <class T, class Alloc, class HSize, class KSize>
-auto make_simple_tmp_storage(HSize h_size, KSize k_size, Alloc &alloc) {
-  return sid::make_contiguous<T>(
-      alloc, hymap::keys<dim::h, dim::k>::values<HSize, KSize>(h_size, k_size));
-}
+    template <class T, class Alloc, class HSize, class KSize>
+    auto make_simple_tmp_storage(HSize h_size, KSize k_size, Alloc &alloc) {
+        return sid::make_contiguous<T>(alloc, hymap::keys<dim::h, dim::k>::values<HSize, KSize>(h_size, k_size));
+    }
 
-template <class T, class Tag, int_t N, bool HasSkipValues, class F, class Init,
-          class G, class Ptr, class Strides, class Neighbors>
-GT_FUNCTION T fold_neighbors(F f, Init init, G g, Ptr &&ptr, Strides &&strides,
-                             Neighbors &&neighbors) {
-  T acc = init(meta::lazy::id<T>());
-  sid::make_loop<Tag>(
-      integral_constant<int_t, N>())([&](auto const &ptr, auto &&) {
-    auto i = *host_device::at_key<Tag>(ptr);
-    if constexpr (HasSkipValues)
-      if (i < 0)
-        return;
-    acc = f(acc, g(ptr, sid::shifted(neighbors.first, neighbors.second, i)));
-  })(wstd::forward<decltype(ptr)>(ptr), strides);
-  return acc;
-}
+    template <class T,
+        class Tag,
+        int_t N,
+        bool HasSkipValues,
+        class F,
+        class Init,
+        class G,
+        class Ptr,
+        class Strides,
+        class Neighbors>
+    GT_FUNCTION T fold_neighbors(F f, Init init, G g, Ptr &&ptr, Strides &&strides, Neighbors &&neighbors) {
+        T acc = init(meta::lazy::id<T>());
+        sid::make_loop<Tag>(integral_constant<int_t, N>())([&](auto const &ptr, auto &&) {
+            auto i = *host_device::at_key<Tag>(ptr);
+            if constexpr (HasSkipValues)
+                if (i < 0)
+                    return;
+            acc = f(acc, g(ptr, sid::shifted(neighbors.first, neighbors.second, i)));
+        })(wstd::forward<decltype(ptr)>(ptr), strides);
+        return acc;
+    }
 
-template <class T, class Tag, int_t N, bool HasSkip = true, class F,
-          class... Args>
-GT_FUNCTION T sum_neighbors(F f, Args &&...args) {
-  return fold_neighbors<T, Tag, N, HasSkip>(
-      [](auto x, auto y) { return x + y; },
-      [](auto z) -> typename decltype(z)::type { return 0; }, f,
-      wstd::forward<Args>(args)...);
-}
+    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
+    GT_FUNCTION T sum_neighbors(F f, Args &&...args) {
+        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x + y; },
+            [](auto z) -> typename decltype(z)::type { return 0; },
+            f,
+            wstd::forward<Args>(args)...);
+    }
 
-template <class T, class Tag, int_t N, bool HasSkip = true, class F,
-          class... Args>
-GT_FUNCTION T mul_neighbors(F f, Args &&...args) {
-  return fold_neighbors<T, Tag, N, HasSkip>(
-      [](auto x, auto y) { return x * y; },
-      [](auto z) -> typename decltype(z)::type { return 1; }, f,
-      wstd::forward<Args>(args)...);
-}
+    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
+    GT_FUNCTION T product_neighbors(F f, Args &&...args) {
+        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x * y; },
+            [](auto z) -> typename decltype(z)::type { return 1; },
+            f,
+            wstd::forward<Args>(args)...);
+    }
 
-template <class T, class Tag, int_t N, bool HasSkip = true, class F,
-          class... Args>
-GT_FUNCTION T min_neighbors(F f, Args &&...args) {
-  return fold_neighbors<T, Tag, N, HasSkip>(
-      [](auto x, auto y) { return x < y ? x : y; },
-      [](auto z) -> typename decltype(z)::type {
-        constexpr auto res =
-            std::numeric_limits<typename decltype(z)::type>::max();
-        return res;
-      },
-      f, wstd::forward<Args>(args)...);
-}
+    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
+    GT_FUNCTION T min_neighbors(F f, Args &&...args) {
+        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x < y ? x : y; },
+            [](auto z) -> typename decltype(z)::type {
+                constexpr auto res = std::numeric_limits<typename decltype(z)::type>::max();
+                return res;
+            },
+            f,
+            wstd::forward<Args>(args)...);
+    }
 
-template <class T, class Tag, int_t N, bool HasSkip = true, class F,
-          class... Args>
-GT_FUNCTION T max_neighbors(F f, Args &&...args) {
-  return fold_neighbors<T, Tag, N, HasSkip>(
-      [](auto x, auto y) { return x > y ? x : y; },
-      [](auto z) -> typename decltype(z)::type {
-        constexpr auto res =
-            std::numeric_limits<typename decltype(z)::type>::min();
-        return res;
-      },
-      f, wstd::forward<Args>(args)...);
-}
+    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
+    GT_FUNCTION T max_neighbors(F f, Args &&...args) {
+        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x > y ? x : y; },
+            [](auto z) -> typename decltype(z)::type {
+                constexpr auto res = std::numeric_limits<typename decltype(z)::type>::min();
+                return res;
+            },
+            f,
+            wstd::forward<Args>(args)...);
+    }
 } // namespace gridtools::usid
diff --git a/setup.cfg b/setup.cfg
index 8d13861..583e755 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -40,6 +40,7 @@ install_requires =
   black>=19.10b0
   boltons>=20.0
   devtools>=0.5
+  compose>=1.1.1
   jinja2>=2.10
   lark-parser>=0.8
   mako>=1.1
@@ -120,7 +121,7 @@ lines_after_imports = 2
 default_section = THIRDPARTY
 sections = FUTURE,STDLIB,THIRDPARTY,FIRSTPARTY,LOCALFOLDER
 known_first_party = eve,gtc
-known_third_party = atlas4py,black,boltons,cppimport,devtools,fvm_nabla_wrapper,jinja2,mako,networkx,numpy,packaging,pydantic,pytest,setuptools,sphinx_material,typing_inspect,xxhash
+known_third_party = atlas4py,black,boltons,compose,cppimport,devtools,fvm_nabla_wrapper,jinja2,mako,networkx,numpy,packaging,pydantic,pytest,setuptools,sphinx_material,typing_inspect,xxhash
 
 
 #-- mypy --
diff --git a/src/gt_frontend/built_in_types.py b/src/gt_frontend/built_in_types.py
index 784855b..8fe5419 100644
--- a/src/gt_frontend/built_in_types.py
+++ b/src/gt_frontend/built_in_types.py
@@ -76,6 +76,10 @@ class Field(BuiltInType):
     pass
 
 
+class SparseField(BuiltInType):
+    pass
+
+
 class TemporaryField(BuiltInType):  # TODO(tehrengruber): make this a subtype of Field
     pass
 
@@ -90,3 +94,7 @@ class Local(BuiltInType):
     """
 
     pass
+
+
+class Connectivity(BuiltInType):
+    pass
diff --git a/src/gt_frontend/gtscript.py b/src/gt_frontend/gtscript.py
index 1f84cce..1e9bd1a 100644
--- a/src/gt_frontend/gtscript.py
+++ b/src/gt_frontend/gtscript.py
@@ -18,7 +18,7 @@
 
 import gtc.common as common
 
-from .built_in_types import Field, Local, Location, Mesh, TemporaryField
+from .built_in_types import Connectivity, Field, Local, Location, Mesh, SparseField, TemporaryField
 
 
 # built-in symbols
@@ -47,6 +47,8 @@
     "Vertex",
     "Edge",
     "Cell",
+    "Connectivity",
+    "SparseField",
 ]
 
 
diff --git a/src/gtc/unstructured/frontend.py b/src/gtc/unstructured/frontend.py
new file mode 100644
index 0000000..b1fce0b
--- /dev/null
+++ b/src/gtc/unstructured/frontend.py
@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+#
+# Eve Toolchain - GT4Py Project - GridTools Framework
+#
+# Copyright (c) 2020, CSCS - Swiss National Supercomputing Center, ETH Zurich
+# All rights reserved.
+#
+# This file is part of the GT4Py project and the GridTools framework.
+# GT4Py is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later
+# version. See the LICENSE.txt file at the top-level directory of this
+# distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+
+from compose import compose
+
+from gtc.unstructured import gtir_to_usid2, py_to_gtir2, usid2_codegen
+
+
+def _impl(codegen):
+    return compose(codegen, gtir_to_usid2.transform, py_to_gtir2.transform)
+
+
+naive = _impl(usid2_codegen.naive)
+gpu = _impl(usid2_codegen.gpu)
diff --git a/src/gtc/unstructured/gtir2.py b/src/gtc/unstructured/gtir2.py
new file mode 100644
index 0000000..eb7c00a
--- /dev/null
+++ b/src/gtc/unstructured/gtir2.py
@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+#
+# Eve Toolchain - GT4Py Project - GridTools Framework
+#
+# Copyright (c) 2020, CSCS - Swiss National Supercomputing Center, ETH Zurich
+# All rights reserved.
+#
+# This file is part of the GT4Py project and the GridTools framework.
+# GT4Py is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later
+# version. See the LICENSE.txt file at the top-level directory of this
+# distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import enum
+from typing import List, Union
+
+from eve import Bool, Int, Node, Str, StrEnum
+from gtc import common
+
+
+class Connectivity(Node):
+    name: Str
+    primary: common.LocationType
+    secondary: common.LocationType
+    max_neighbors: Int
+    has_skip_values: Bool
+
+
+class Field(Node):
+    name: Str
+    location_type: common.LocationType
+    dtype: common.DataType
+
+
+class SparseField(Node):
+    name: Str
+    connectivity: Str
+    dtype: common.DataType
+
+
+class Expr(Node):
+    pass
+
+
+class FieldAccess(Expr):
+    name: Str
+    location: Str
+
+
+class SparseFieldAccess(Expr):
+    name: Str
+    primary: Str
+    secondary: Str
+
+
+class BinaryOp(Expr):
+    op: common.BinaryOperator
+    left: Expr
+    right: Expr
+
+
+class Literal(Expr):
+    value: Str
+    dtype: common.DataType
+
+
+@enum.unique
+class ReduceOperator(StrEnum):
+    """Reduction operator identifier."""
+
+    SUM = "sum"
+    PRODUCT = "product"
+    MIN = "min"
+    MAX = "max"
+
+
+class SecondaryLocation(Node):
+    name: Str
+    connectivity: Str
+    primary: Str
+
+
+class NeighborReduce(Expr):
+    op: ReduceOperator
+    dtype: common.DataType
+    location: SecondaryLocation
+    body: Expr
+
+
+class Assign(Node):
+    left: FieldAccess
+    right: Expr
+
+
+class PrimaryLocation(Node):
+    name: Str
+    location_type: common.LocationType
+
+
+class Stencil(Node):
+    loop_order: common.LoopOrder
+    location: PrimaryLocation
+    body: List[Assign]
+
+
+class Computation(Node):
+    name: Str
+    connectivities: List[Connectivity]
+    args: List[Union[Field, SparseField]]
+    temporaries: List[Field]
+    stencils: List[Stencil]
diff --git a/src/gtc/unstructured/gtir_to_usid2.py b/src/gtc/unstructured/gtir_to_usid2.py
new file mode 100644
index 0000000..e9801f4
--- /dev/null
+++ b/src/gtc/unstructured/gtir_to_usid2.py
@@ -0,0 +1,182 @@
+# -*- coding: utf-8 -*-
+#
+# Eve Toolchain - GT4Py Project - GridTools Framework
+#
+# Copyright (c) 2020, CSCS - Swiss National Supercomputing Center, ETH Zurich
+# All rights reserved.
+#
+# This file is part of the GT4Py project and the GridTools framework.
+# GT4Py is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later
+# version. See the LICENSE.txt file at the top-level directory of this
+# distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import itertools
+
+import eve
+from gtc import common
+from gtc.unstructured import gtir2, usid2
+
+
+_C_TYPES = {
+    common.DataType.FLOAT64: "double",
+    common.DataType.FLOAT32: "float",
+    common.DataType.INT32: "::std::int32_t",
+    common.DataType.UINT32: "::std::uint32_t",
+    common.DataType.BOOLEAN: "bool",
+}
+
+
+def _loc2str(x: common.LocationType):
+    return x.name.lower()
+
+
+class _PrimaryCompositeExtractor(eve.NodeVisitor):
+    def visit_Literal(self, src: gtir2.Literal, **kwargs):
+        return {}
+
+    def visit_FieldAccess(self, src: gtir2.FieldAccess, primary, **kwargs):
+        return {src.name: usid2.Sid(name=src.name)} if src.location == primary else {}
+
+    def visit_SparseFieldAccess(self, src: gtir2.SparseFieldAccess, primary, connectivity):
+        assert src.primary == primary
+        return {src.name: usid2.SparseField(name=src.name, connectivity=connectivity)}
+
+    def visit_BinaryOp(self, src: gtir2.BinaryOp, **kwargs):
+        return {**self.visit(src.left, **kwargs), **self.visit(src.right, **kwargs)}
+
+    def visit_NeighborReduce(self, src: gtir2.NeighborReduce, primary, **kwargs):
+        assert src.location.primary == primary
+        return {
+            src.location.connectivity: usid2.Sid(name=src.location.connectivity),
+            **self.visit(src.body, primary=primary, connectivity=src.location.connectivity),
+        }
+
+    def visit_Assign(self, src: gtir2.Assign, **kwargs):
+        return {**self.visit(src.left, **kwargs), **self.visit(src.right, **kwargs)}
+
+    def visit_Stencil(self, src: gtir2.Stencil):
+        items = {}
+        for s in src.body:
+            items.update(self.visit(s, primary=src.location.name))
+        return usid2.Composite(name=src.location.name, items=list(items.values()))
+
+
+_extract_primary_composite = _PrimaryCompositeExtractor().visit
+
+
+class _SecondaryCompositeExtractor(eve.NodeVisitor):
+    def visit_SparseFieldAccess(self, src: gtir2.SparseFieldAccess, **kwargs):
+        return {}
+
+    def visit_Literal(self, src: gtir2.Literal, **kwargs):
+        return {}
+
+    def visit_FieldAccess(self, src: gtir2.FieldAccess, secondary, **kwargs):
+        return {src.name: usid2.Sid(name=src.name)} if src.location == secondary else {}
+
+    def visit_BinaryOp(self, src: gtir2.BinaryOp, **kwargs):
+        return {**self.visit(src.left, **kwargs), **self.visit(src.right, **kwargs)}
+
+    def visit_NeighborReduce(self, src: gtir2.NeighborReduce):
+        return {src.location.connectivity: self.visit(src.body, secondary=src.location.name)}
+
+
+_extract_secondary_composite = _SecondaryCompositeExtractor().visit
+
+
+def _merge_dicts_of_dicts(*srcs):
+    res = {}
+    for k in set(itertools.chain(*srcs)):
+        res[k] = {}
+        for src in srcs:
+            if k in src:
+                res[k].update(src[k])
+    return res
+
+
+class _SecondaryCompositesExtractor(eve.NodeVisitor):
+    def visit_FieldAccess(self, src: gtir2.FieldAccess):
+        return {}
+
+    def visit_Literal(self, src: gtir2.Literal):
+        return {}
+
+    def visit_Assign(self, src: gtir2.Assign):
+        return self.visit(src.right)
+
+    def visit_NeighborReduce(self, src: gtir2.NeighborReduce):
+        return _extract_secondary_composite(src)
+
+    def visit_BinaryOp(self, src: gtir2.BinaryOp):
+        return _merge_dicts_of_dicts(self.visit(src.left), self.visit(src.right))
+
+    def visit_Stencil(self, src: gtir2.Stencil):
+        return [
+            usid2.Composite(name=name, items=list(sids.values()))
+            for name, sids in _merge_dicts_of_dicts(*(self.visit(e) for e in src.body)).items()
+        ]
+
+
+_extract_secondary_composites = _SecondaryCompositesExtractor().visit
+
+
+class _Visitor(eve.NodeVisitor):
+    def visit_FieldAccess(self, src: gtir2.FieldAccess, **kwargs):
+        return usid2.FieldAccess(name=src.name, location=src.location)
+
+    def visit_SparseFieldAccess(self, src: gtir2.SparseFieldAccess, **kwargs):
+        return usid2.FieldAccess(name=src.name, location=src.primary)
+
+    def visit_Literal(self, src: gtir2.Literal, **kwargs):
+        return usid2.Literal(value=src.value, dtype=_C_TYPES[src.dtype])
+
+    def visit_BinaryOp(self, src: gtir2.BinaryOp, **kwargs):
+        return usid2.BinaryOp(
+            op=src.op, left=self.visit(src.left, **kwargs), right=self.visit(src.right, **kwargs)
+        )
+
+    def visit_NeighborReduce(self, src: gtir2.NeighborReduce, tbl):
+        connectivity = tbl[src.location.connectivity]
+        return usid2.NeighborReduce(
+            op=src.op,
+            dtype=_C_TYPES[src.dtype],
+            connectivity=connectivity.name,
+            max_neighbors=connectivity.max_neighbors,
+            has_skip_values=connectivity.has_skip_values,
+            primary=src.location.primary,
+            secondary=src.location.name,
+            body=self.visit(src.body),
+        )
+
+    def visit_Assign(self, src: gtir2.Assign, tbl):
+        return usid2.Assign(left=self.visit(src.left), right=self.visit(src.right, tbl=tbl))
+
+    def visit_Stencil(self, src: gtir2.Stencil, tbl):
+        return usid2.Kernel(
+            location_type=_loc2str(src.location.location_type),
+            primary=_extract_primary_composite(src),
+            secondaries=_extract_secondary_composites(src),
+            body=[self.visit(e, tbl=tbl) for e in src.body],
+        )
+
+    def visit_Computation(self, src: gtir2.Computation):
+        tbl = {e.name: e for e in src.connectivities + src.args + src.temporaries}
+        return usid2.Computation(
+            name=src.name,
+            connectivities=[e.name for e in src.connectivities],
+            params=[e.name for e in src.args],
+            temporaries=[
+                usid2.Temporary(
+                    name=e.name, location_type=_loc2str(e.location_type), dtype=_C_TYPES[e.dtype]
+                )
+                for e in src.temporaries
+            ],
+            kernels=[self.visit(e, tbl=tbl) for e in src.stencils],
+        )
+
+
+transform = _Visitor().visit
diff --git a/src/gtc/unstructured/gtscript_ast2.py b/src/gtc/unstructured/gtscript_ast2.py
new file mode 100644
index 0000000..2a197d6
--- /dev/null
+++ b/src/gtc/unstructured/gtscript_ast2.py
@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+#
+# Eve Toolchain - GT4Py Project - GridTools Framework
+#
+# Copyright (c) 2020, CSCS - Swiss National Supercomputing Center, ETH Zurich
+# All rights reserved.
+#
+# This file is part of the GT4Py project and the GridTools framework.
+# GT4Py is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later
+# version. See the LICENSE.txt file at the top-level directory of this
+# distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import Any, List, Optional, Union
+
+from eve import Node, Str
+
+
+class Stmt(Node):
+    pass
+
+
+class Expr(Node):
+    pass
+
+
+class Name(Expr):
+    name: Str
+
+
+class Subscript(Expr):
+    value: Name
+    index: Union[Name, List[Name]]
+
+
+class Call(Expr):
+    func: Name
+    args: List[Expr]
+
+
+class Comprehension(Node):
+    target: Union[Name, List[Name]]
+    iterable: Expr
+
+
+class GeneratorExp(Expr):
+    elt: Expr
+    generators: List[Comprehension]
+
+
+class BinOp(Expr):
+    left: Expr
+    op: Str
+    right: Expr
+
+
+class Constant(Expr):
+    value: Any
+
+
+class Assign(Stmt):
+    targets: List[Expr]
+    value: Expr
+
+
+class WithItem(Node):
+    expr: Expr
+    var: Optional[Name]
+
+
+class With(Stmt):
+    items: List[WithItem]
+    body: List[Stmt]
+
+
+class Function(Node):
+    name: Str
+    body: List[Stmt]
diff --git a/src/gtc/unstructured/py_to_gtir2.py b/src/gtc/unstructured/py_to_gtir2.py
new file mode 100644
index 0000000..db4a51a
--- /dev/null
+++ b/src/gtc/unstructured/py_to_gtir2.py
@@ -0,0 +1,291 @@
+# -*- coding: utf-8 -*-
+#
+# Eve Toolchain - GT4Py Project - GridTools Framework
+#
+# Copyright (c) 2020, CSCS - Swiss National Supercomputing Center, ETH Zurich
+# All rights reserved.
+#
+# This file is part of the GT4Py project and the GridTools framework.
+# GT4Py is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later
+# version. See the LICENSE.txt file at the top-level directory of this
+# distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import functools
+import inspect
+import sys
+
+from gt_frontend import built_in_types
+
+import eve
+from gtc import common
+from gtc.unstructured import gtir2, gtscript_ast2, py_to_gtscript2
+
+
+def _is_conncetivity_annotation(src):
+    return hasattr(src, "__supertype__") and issubclass(
+        src.__supertype__, built_in_types.Connectivity
+    )
+
+
+def _is_field_annotation(src):
+    return issubclass(src, built_in_types.Field)
+
+
+def _is_sparse_field_annotation(src):
+    return issubclass(src, built_in_types.SparseField)
+
+
+def _is_legit_annotation(src):
+    return (
+        _is_conncetivity_annotation(src)
+        or _is_field_annotation(src)
+        or _is_sparse_field_annotation(src)
+    )
+
+
+def _extract_params(fun):
+    res = [p for _, p in inspect.signature(fun).parameters.items()]
+    for p in res:
+        if not _is_legit_annotation(p.annotation):
+            raise RuntimeError(f"unexpected type annotation: {p}")
+    return res
+
+
+def _extract_connectivity(param):
+    args = param.annotation.__supertype__.args
+    assert len(args) > 3
+    return gtir2.Connectivity(
+        name=param.name,
+        primary=args[0],
+        secondary=args[1],
+        max_neighbors=args[2],
+        has_skip_values=args[3] if len(args) > 3 else True,
+    )
+
+
+def _extract_arg(param, connectivity_type_to_name):
+    args = param.annotation.args
+    if _is_field_annotation(param.annotation):
+        assert len(args) == 2
+        return gtir2.Field(name=param.name, location_type=args[0], dtype=args[1])
+    else:
+        assert len(args) == 2
+        return gtir2.SparseField(
+            name=param.name, connectivity=connectivity_type_to_name[args[0]], dtype=args[1]
+        )
+
+
+_SORTED_TYPES = (
+    common.DataType.INVALID,
+    common.DataType.AUTO,
+    common.DataType.FLOAT64,
+    common.DataType.FLOAT32,
+    common.DataType.INT32,
+    common.DataType.UINT32,
+    common.DataType.BOOLEAN,
+)
+
+
+def _common_type(lhs: common.DataType, rhs: common.DataType) -> common.DataType:
+    for t in _SORTED_TYPES:
+        if lhs == t or rhs == t:
+            return t
+    raise RuntimeError(f"unsupported types {lhs}, {rhs}")
+
+
+class _DeduceExprTypeVisotor(eve.NodeVisitor):
+    def visit_Literal(self, src: gtir2.Literal, tbl):
+        return src.dtype
+
+    def visit_NeighborReduce(self, src: gtir2.NeighborReduce, tbl):
+        return src.dtype
+
+    def visit_FieldAccess(self, src: gtir2.FieldAccess, tbl):
+        return tbl[src.name].dtype
+
+    def visit_SparseFieldAccess(self, src: gtir2.SparseFieldAccess, tbl):
+        return tbl[src.name].dtype
+
+    def visit_BinaryOp(self, src: gtir2.BinaryOp, tbl):
+        return _common_type(self.visit(src.left, tbl=tbl), self.visit(src.right, tbl=tbl))
+
+
+def _deduce_expr_type(src: gtir2.Expr, tbl):
+    return _DeduceExprTypeVisotor().visit(src, tbl=tbl)
+
+
+_PY_TYPE_TO_DATA_TYPE = {
+    int: common.DataType.INT32,
+    float: common.DataType.FLOAT64 if sys.float_info.mant_dig >= 53 else common.DataType.FLOAT32,
+}
+
+
+class _Visitor(eve.NodeVisitor):
+    def visit_Constant(self, src: gtscript_ast2.Constant, **kwargs):
+        return gtir2.Literal(value=str(src.value), dtype=_PY_TYPE_TO_DATA_TYPE[type(src.value)])
+
+    def visit_Call(self, src: gtscript_ast2.Call, tbl, location):
+        assert isinstance(location, gtir2.PrimaryLocation)
+        assert len(src.args) == 1
+        generator_exp = src.args[0]
+        assert isinstance(generator_exp, gtscript_ast2.GeneratorExp)
+        assert len(generator_exp.generators) == 1
+        generator = generator_exp.generators[0]
+        target = generator.target
+        assert isinstance(target, gtscript_ast2.Name)
+        secondary = gtir2.SecondaryLocation(
+            name=target.name,
+            connectivity=self.visit(generator.iterable, tbl=tbl, location=location),
+            primary=location.name,
+        )
+        body = self.visit(generator_exp.elt, tbl=tbl, location=secondary)
+        return gtir2.NeighborReduce(
+            op=gtir2.ReduceOperator(src.func.name),
+            location=secondary,
+            dtype=_deduce_expr_type(body, tbl),
+            body=body,
+        )
+
+    def visit_Name(self, src: gtscript_ast2.Name, tbl, location, is_target=False):
+        if src.name in tbl:
+            field = tbl[src.name]
+            if isinstance(field, gtir2.Field):
+                if isinstance(location, gtir2.PrimaryLocation):
+                    assert field.location_type == location.location_type
+                    loc = location.name
+                else:
+                    assert isinstance(location, gtir2.SecondaryLocation)
+                    if field.location_type == tbl[location.connectivity].primary:
+                        loc = location.primary
+                    elif field.location_type == tbl[location.connectivity].secondary:
+                        loc = location.name
+                    else:
+                        raise RuntimeError(f"invalid field access {src}")
+                return gtir2.FieldAccess(name=field.name, location=loc)
+            elif isinstance(field, gtir2.SparseField):
+                assert isinstance(location, gtir2.SecondaryLocation)
+                assert field.connectivity == location.connectivity
+                return gtir2.SparseFieldAccess(
+                    name=field.name, primary=location.primary, secondary=location.name
+                )
+            elif isinstance(field, gtir2.Connectivity):
+                assert isinstance(location, gtir2.PrimaryLocation)
+                assert field.primary == location.location_type
+                return field.name
+            else:
+                raise RuntimeError(f"invalid access {src} to {field}")
+        elif is_target:
+            assert isinstance(location, gtir2.PrimaryLocation)
+            return gtir2.FieldAccess(name=src.name, location=location.name)
+        else:
+            raise RuntimeError(f"unbound name {src}")
+
+    def visit_Subscript(self, src: gtscript_ast2.Subscript, location, **kwargs):
+        res = self.visit(src.value, location=location, **kwargs)
+        if isinstance(res, gtir2.FieldAccess):
+            assert isinstance(src.index, gtscript_ast2.Name)
+            assert src.index.name == res.location
+        elif isinstance(res, gtir2.SparseFieldAccess):
+            assert isinstance(src.index, list)
+            assert len(src.index) == 2
+            assert src.index[0].name == res.primary
+            assert src.index[1].name == res.secondary
+        elif isinstance(res, str):
+            assert src.index.name == location.name
+        return res
+
+    def visit_BinOp(self, src: gtscript_ast2.BinOp, **kwargs):
+        return gtir2.BinaryOp(
+            op=common.BinaryOperator(src.op),
+            left=self.visit(src.left, **kwargs),
+            right=self.visit(src.right, **kwargs),
+        )
+
+    def visit_Assign(self, src: gtscript_ast2.Assign, tbl, primary):
+        assert len(src.targets) == 1
+        target = src.targets[0]
+        left = self.visit(target, tbl=tbl, location=primary, is_target=True)
+        right = self.visit(src.value, tbl=tbl, location=primary)
+        return (
+            gtir2.Assign(left=left, right=right),
+            []
+            if left.name in tbl
+            else [
+                gtir2.Field(
+                    name=left.name,
+                    location_type=primary.location_type,
+                    dtype=_deduce_expr_type(right, tbl),
+                )
+            ],
+        )
+
+    def visit_With(self, src: gtscript_ast2.With, tbl):
+        loop_order = None
+        location = None
+        for item in src.items:
+            assert isinstance(item.expr, gtscript_ast2.Call)
+            f = item.expr
+            if f.func.name == "computation":
+                assert len(f.args) == 1
+                assert isinstance(f.args[0], gtscript_ast2.Name)
+                assert loop_order is None
+                loop_order = common.LoopOrder[f.args[0].name]
+            elif f.func.name == "location":
+                assert len(f.args) == 1
+                assert isinstance(f.args[0], gtscript_ast2.Name)
+                assert location is None
+                assert item.var is not None
+                location = gtir2.PrimaryLocation(
+                    name=item.var.name, location_type=common.LocationType[f.args[0].name]
+                )
+            elif f.func.name == "interval":
+                pass
+            else:
+                raise RuntimeError(f"unexpected withitem: {item}")
+        assert all(isinstance(s, gtscript_ast2.Assign) for s in src.body)
+
+        def folder(acc, stmt):
+            assign, temporaries = self.visit(
+                stmt, tbl={**tbl, **{t.name: t for t in acc[1]}}, primary=location
+            )
+            return acc[0] + [assign], acc[1] + temporaries
+
+        body, temporaries = functools.reduce(folder, src.body, ([], []))
+        return gtir2.Stencil(loop_order=loop_order, location=location, body=body), temporaries
+
+    def visit_Function(self, src: gtscript_ast2.Function, fun_params):
+        connectivity_params = [p for p in fun_params if _is_conncetivity_annotation(p.annotation)]
+        connectivity_type_to_name = dict((p.annotation, p.name) for p in connectivity_params)
+        if len(connectivity_params) > len(connectivity_type_to_name):
+            raise RuntimeError(
+                "the types of the conncetivities within computation should be all different"
+            )
+        connectivities = [_extract_connectivity(p) for p in connectivity_params]
+        args = [
+            _extract_arg(p, connectivity_type_to_name)
+            for p in fun_params
+            if not _is_conncetivity_annotation(p.annotation)
+        ]
+        assert all(isinstance(s, gtscript_ast2.With) for s in src.body)
+        tbl = {e.name: e for e in connectivities + args}
+
+        def folder(acc, stmt):
+            stencil, temporaries = self.visit(stmt, tbl={**tbl, **{t.name: t for t in acc[1]}})
+            return acc[0] + [stencil], acc[1] + temporaries
+
+        stencils, temporaries = functools.reduce(folder, src.body, ([], []))
+        return gtir2.Computation(
+            name=src.name,
+            connectivities=connectivities,
+            args=args,
+            temporaries=temporaries,
+            stencils=stencils,
+        )
+
+
+def transform(src):
+    return _Visitor().visit(py_to_gtscript2.transform(src), fun_params=_extract_params(src))
diff --git a/src/gtc/unstructured/py_to_gtscript2.py b/src/gtc/unstructured/py_to_gtscript2.py
new file mode 100644
index 0000000..9cf41a2
--- /dev/null
+++ b/src/gtc/unstructured/py_to_gtscript2.py
@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+#
+# Eve Toolchain - GT4Py Project - GridTools Framework
+#
+# Copyright (c) 2020, CSCS - Swiss National Supercomputing Center, ETH Zurich
+# All rights reserved.
+#
+# This file is part of the GT4Py project and the GridTools framework.
+# GT4Py is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later
+# version. See the LICENSE.txt file at the top-level directory of this
+# distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import ast
+import inspect
+import textwrap
+from typing import List
+
+from compose import compose
+
+import eve
+from gtc.unstructured import gtscript_ast2
+
+
+class _Visitor(ast.NodeVisitor):
+    def _visit_list(self, src):
+        return [self.visit(e) for e in src]
+
+    def visit_Tuple(self, src: ast.Tuple):
+        return self._visit_list(src.elts)
+
+    def visit_Name(self, src: ast.Name):
+        return gtscript_ast2.Name(name=src.id)
+
+    def visit_Subscript(self, src: ast.Subscript):
+        return gtscript_ast2.Subscript(
+            value=self.visit(src.value), index=self.visit(src.slice.value)
+        )
+
+    def visit_withitem(self, src: ast.withitem):
+        return gtscript_ast2.WithItem(
+            expr=self.visit(src.context_expr),
+            var=self.visit(src.optional_vars) if src.optional_vars else None,
+        )
+
+    def visit_With(self, src: ast.With):
+        return gtscript_ast2.With(
+            items=self._visit_list(src.items), body=self._visit_list(src.body)
+        )
+
+    def visit_Call(self, src: ast.Call):
+        return gtscript_ast2.Call(func=self.visit(src.func), args=self._visit_list(src.args))
+
+    def visit_BinOp(self, src: ast.BinOp):
+        return gtscript_ast2.BinOp(
+            left=self.visit(src.left), op=self.visit(src.op), right=self.visit(src.right)
+        )
+
+    def visit_Div(self, src: ast.Div):
+        return "/"
+
+    def visit_Mult(self, src: ast.Mult):
+        return "*"
+
+    def visit_Add(self, src: ast.Div):
+        return "+"
+
+    def visit_Sub(self, src: ast.Mult):
+        return "-"
+
+    def visit_Constant(self, src: ast.Constant):
+        return gtscript_ast2.Constant(value=src.value)
+
+    def visit_GeneratorExp(self, src: ast.GeneratorExp):
+        return gtscript_ast2.GeneratorExp(
+            elt=self.visit(src.elt), generators=self._visit_list(src.generators)
+        )
+
+    def visit_comprehension(self, src: ast.comprehension):
+        return gtscript_ast2.Comprehension(
+            target=self.visit(src.target), iterable=self.visit(src.iter)
+        )
+
+    def visit_Assign(self, src: ast.Assign):
+        return gtscript_ast2.Assign(
+            targets=self._visit_list(src.targets), value=self.visit(src.value)
+        )
+
+    def visit_FunctionDef(self, src: ast.FunctionDef):
+        return gtscript_ast2.Function(name=src.name, body=self._visit_list(src.body))
+
+
+def _flatten(ll):
+    return [e for l in ll for e in l]
+
+
+class _FlattenWiths(eve.NodeTranslator):
+    def _process_statements(self, src: List[gtscript_ast2.Stmt]):
+        return (
+            _flatten(
+                self.visit(s, items=[]) if isinstance(s, gtscript_ast2.With) else [self.visit(s)]
+                for s in src
+            )
+            if any(isinstance(s, gtscript_ast2.With) for s in src)
+            else [self.visit(s) for s in src]
+        )
+
+    def visit_Function(self, src: gtscript_ast2.Function):
+        return gtscript_ast2.Function(name=src.name, body=self._process_statements(src.body))
+
+    def visit_With(self, src: gtscript_ast2.With, items: List[gtscript_ast2.WithItem]):
+        items = items + src.items
+        return (
+            _flatten(self.visit(s, items=items) for s in src.body)
+            if all(isinstance(s, gtscript_ast2.With) for s in src.body)
+            else [gtscript_ast2.With(items=items, body=self._process_statements(src.body))]
+        )
+
+
+transform = compose(
+    _FlattenWiths().visit,
+    _Visitor().visit,
+    lambda x: x.body[0],
+    ast.parse,
+    textwrap.dedent,
+    inspect.getsource,
+)
diff --git a/src/gtc/unstructured/usid2.py b/src/gtc/unstructured/usid2.py
index b8b634b..5801791 100644
--- a/src/gtc/unstructured/usid2.py
+++ b/src/gtc/unstructured/usid2.py
@@ -14,11 +14,11 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-import enum
 from typing import List
 
-from eve import Bool, Int, Node, Str, StrEnum
+from eve import Bool, Int, Node, Str
 from gtc import common
+from gtc.unstructured.gtir2 import ReduceOperator
 
 
 class Sid(Node):
@@ -54,25 +54,13 @@ class FieldAccess(Expr):
     location: Str
 
 
-class VarAccess(Expr):
-    name: Str
-
-
 class BinaryOp(Expr):
     op: common.BinaryOperator
     left: Expr
     right: Expr
 
 
-@enum.unique
-class ReduceOperator(StrEnum):
-    ADD = "sum"
-    MUL = "mul"
-    MAX = "max"
-    MIN = "min"
-
-
-class NeighborReduction(Expr):
+class NeighborReduce(Expr):
     op: ReduceOperator
     dtype: Str
     connectivity: Str
@@ -83,16 +71,7 @@ class NeighborReduction(Expr):
     body: Expr
 
 
-class Stmt(Node):
-    pass
-
-
-class VarDecl(Stmt):
-    name: Str
-    init: Expr
-
-
-class Assign(Stmt):
+class Assign(Node):
     left: FieldAccess
     right: Expr
 
@@ -101,7 +80,7 @@ class Kernel(Node):
     location_type: Str
     primary: Composite
     secondaries: List[Composite]
-    body: List[Stmt]
+    body: List[Assign]
 
 
 class Computation(Node):
diff --git a/src/gtc/unstructured/usid2_codegen.py b/src/gtc/unstructured/usid2_codegen.py
index c36ebc3..c923a46 100644
--- a/src/gtc/unstructured/usid2_codegen.py
+++ b/src/gtc/unstructured/usid2_codegen.py
@@ -40,12 +40,10 @@ def visit_Computation(self, node: usid2.Computation, **kwargs):
     Literal = as_mako("${dtype}{${value}}")
     BinaryOp = as_fmt("({left} {op} {right})")
     FieldAccess = as_fmt("field<{name}_tag>({location})")
-    VarAccess = as_fmt("{name}")
-    NeighborReduction = as_mako(
+    NeighborReduce = as_mako(
         "${op}_neighbors<${dtype}, ${connectivity}_tag, ${max_neighbors}, ${has_skip_values.lower()}>"
-        + "([](auto &&${primary}, auto &&${secondary}) { return ${body}; }, ${primary}, strides, ${secondary})"
+        + "([](auto &&${primary}, auto &&${secondary}) { return ${body}; }, ${primary}, strides, ${connectivity})"
     )
-    VarDecl = as_fmt("auto&& {name} = {init};")
     Assign = as_fmt("{left} = {right};")
     Kernel = as_mako(
         """struct ${id_} {
diff --git a/tests/tests_gtc/regression/cpp2/fvm_nabla.py b/tests/tests_gtc/regression/cpp2/fvm_nabla.py
index c3a1ecb..4b7f3c7 100644
--- a/tests/tests_gtc/regression/cpp2/fvm_nabla.py
+++ b/tests/tests_gtc/regression/cpp2/fvm_nabla.py
@@ -1,141 +1,49 @@
 # -*- coding: utf-8 -*-
 import sys
+import typing
 
-from gtc import common
-from gtc.unstructured import usid2, usid2_codegen
+from gt_frontend.gtscript import (
+    FORWARD,
+    Connectivity,
+    Edge,
+    Field,
+    SparseField,
+    Vertex,
+    computation,
+    location,
+)
 
+from gtc.common import DataType
+from gtc.unstructured import frontend
+
+
+dtype = DataType.FLOAT64
+E2V = typing.NewType("E2V", Connectivity[Edge, Vertex, 2, False])
+V2E = typing.NewType("V2E", Connectivity[Vertex, Edge, 7, True])
+
+
+def nabla(
+    e2v: E2V,
+    v2e: V2E,
+    S_MXX: Field[Edge, dtype],
+    S_MYY: Field[Edge, dtype],
+    pp: Field[Vertex, dtype],
+    pnabla_MXX: Field[Vertex, dtype],
+    pnabla_MYY: Field[Vertex, dtype],
+    vol: Field[Vertex, dtype],
+    sign: SparseField[V2E, dtype],
+):
+    with computation(FORWARD):
+        with location(Edge) as e:
+            zavg = 0.5 * sum(pp[v] for v in e2v[e])
+            zavgS_MXX = S_MXX * zavg
+            zavgS_MYY = S_MYY * zavg
+        with location(Vertex) as v:
+            pnabla_MXX = sum(zavgS_MXX[e] * sign[v, e] for e in v2e[v])
+            pnabla_MYY = sum(zavgS_MYY[e] * sign[v, e] for e in v2e[v])
+            pnabla_MXX = pnabla_MXX / vol
+            pnabla_MYY = pnabla_MYY / vol
 
-_usid2_src = usid2.Computation(
-    name="nabla",
-    connectivities=["v2e", "e2v"],
-    params=["S_MXX", "S_MYY", "pp", "pnabla_MXX", "pnabla_MYY", "vol", "sign"],
-    temporaries=[
-        usid2.Temporary(name="zavgS_MXX", dtype="double", location_type="edge"),
-        usid2.Temporary(name="zavgS_MYY", dtype="double", location_type="edge"),
-    ],
-    kernels=[
-        usid2.Kernel(
-            location_type="edge",
-            primary=usid2.Composite(
-                name="e",
-                items=[
-                    usid2.Sid(name="e2v"),
-                    usid2.Sid(name="S_MXX"),
-                    usid2.Sid(name="S_MYY"),
-                    usid2.Sid(name="zavgS_MXX"),
-                    usid2.Sid(name="zavgS_MYY"),
-                ],
-            ),
-            secondaries=[usid2.Composite(name="v", items=[usid2.Sid(name="pp")])],
-            body=[
-                usid2.VarDecl(
-                    name="zavg",
-                    init=usid2.BinaryOp(
-                        op=common.BinaryOperator.MUL,
-                        left=usid2.Literal(dtype="double", value=".5"),
-                        right=usid2.NeighborReduction(
-                            op=usid2.ReduceOperator.ADD,
-                            dtype="double",
-                            connectivity="e2v",
-                            max_neighbors=2,
-                            has_skip_values=False,
-                            primary="e",
-                            secondary="v",
-                            body=usid2.FieldAccess(name="pp", location="v"),
-                        ),
-                    ),
-                ),
-                usid2.Assign(
-                    left=usid2.FieldAccess(name="zavgS_MXX", location="e"),
-                    right=usid2.BinaryOp(
-                        op=common.BinaryOperator.MUL,
-                        left=usid2.FieldAccess(name="S_MXX", location="e"),
-                        right=usid2.VarAccess(name="zavg"),
-                    ),
-                ),
-                usid2.Assign(
-                    left=usid2.FieldAccess(name="zavgS_MYY", location="e"),
-                    right=usid2.BinaryOp(
-                        op=common.BinaryOperator.MUL,
-                        left=usid2.FieldAccess(name="S_MYY", location="e"),
-                        right=usid2.VarAccess(name="zavg"),
-                    ),
-                ),
-            ],
-        ),
-        usid2.Kernel(
-            location_type="vertex",
-            primary=usid2.Composite(
-                name="v",
-                items=[
-                    usid2.Sid(name="v2e"),
-                    usid2.Sid(name="pnabla_MXX"),
-                    usid2.Sid(name="pnabla_MYY"),
-                    usid2.SparseField(name="sign", connectivity="v2e"),
-                    usid2.Sid(name="vol"),
-                ],
-            ),
-            secondaries=[
-                usid2.Composite(
-                    name="e", items=[usid2.Sid(name="zavgS_MXX"), usid2.Sid(name="zavgS_MYY")]
-                )
-            ],
-            body=[
-                usid2.Assign(
-                    left=usid2.FieldAccess(name="pnabla_MXX", location="v"),
-                    right=usid2.NeighborReduction(
-                        op=usid2.ReduceOperator.ADD,
-                        dtype="double",
-                        connectivity="v2e",
-                        max_neighbors=7,
-                        has_skip_values=True,
-                        primary="v",
-                        secondary="e",
-                        body=usid2.BinaryOp(
-                            op=common.BinaryOperator.MUL,
-                            left=usid2.FieldAccess(name="zavgS_MXX", location="e"),
-                            right=usid2.FieldAccess(name="sign", location="v"),
-                        ),
-                    ),
-                ),
-                usid2.Assign(
-                    left=usid2.FieldAccess(name="pnabla_MYY", location="v"),
-                    right=usid2.NeighborReduction(
-                        op=usid2.ReduceOperator.ADD,
-                        dtype="double",
-                        connectivity="v2e",
-                        max_neighbors=7,
-                        has_skip_values=True,
-                        primary="v",
-                        secondary="e",
-                        body=usid2.BinaryOp(
-                            op=common.BinaryOperator.MUL,
-                            left=usid2.FieldAccess(name="zavgS_MYY", location="e"),
-                            right=usid2.FieldAccess(name="sign", location="v"),
-                        ),
-                    ),
-                ),
-                usid2.Assign(
-                    left=usid2.FieldAccess(name="pnabla_MXX", location="v"),
-                    right=usid2.BinaryOp(
-                        op=common.BinaryOperator.DIV,
-                        left=usid2.FieldAccess(name="pnabla_MXX", location="v"),
-                        right=usid2.FieldAccess(name="vol", location="v"),
-                    ),
-                ),
-                usid2.Assign(
-                    left=usid2.FieldAccess(name="pnabla_MYY", location="v"),
-                    right=usid2.BinaryOp(
-                        op=common.BinaryOperator.DIV,
-                        left=usid2.FieldAccess(name="pnabla_MYY", location="v"),
-                        right=usid2.FieldAccess(name="vol", location="v"),
-                    ),
-                ),
-            ],
-        ),
-    ],
-)
 
 if __name__ == "__main__":
-    gen = usid2_codegen.gpu if len(sys.argv) > 1 and sys.argv[1] == "gpu" else usid2_codegen.naive
-    print(gen(_usid2_src))
+    print((frontend.gpu if len(sys.argv) > 1 and sys.argv[1] == "gpu" else frontend.naive)(nabla))

From 6da763ec1ef620ba77708f3e40905a3310639720 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Thu, 5 Nov 2020 17:30:55 +0000
Subject: [PATCH 18/24] add toolz

---
 setup.cfg                               | 4 ++--
 src/gtc/unstructured/frontend.py        | 2 +-
 src/gtc/unstructured/py_to_gtscript2.py | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/setup.cfg b/setup.cfg
index 583e755..de4c799 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -40,7 +40,7 @@ install_requires =
   black>=19.10b0
   boltons>=20.0
   devtools>=0.5
-  compose>=1.1.1
+  toolz>=0.11.1
   jinja2>=2.10
   lark-parser>=0.8
   mako>=1.1
@@ -121,7 +121,7 @@ lines_after_imports = 2
 default_section = THIRDPARTY
 sections = FUTURE,STDLIB,THIRDPARTY,FIRSTPARTY,LOCALFOLDER
 known_first_party = eve,gtc
-known_third_party = atlas4py,black,boltons,compose,cppimport,devtools,fvm_nabla_wrapper,jinja2,mako,networkx,numpy,packaging,pydantic,pytest,setuptools,sphinx_material,typing_inspect,xxhash
+known_third_party = atlas4py,black,boltons,cppimport,devtools,fvm_nabla_wrapper,jinja2,mako,networkx,numpy,packaging,pydantic,pytest,setuptools,sphinx_material,toolz,typing_inspect,xxhash
 
 
 #-- mypy --
diff --git a/src/gtc/unstructured/frontend.py b/src/gtc/unstructured/frontend.py
index b1fce0b..58745cb 100644
--- a/src/gtc/unstructured/frontend.py
+++ b/src/gtc/unstructured/frontend.py
@@ -15,7 +15,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 
-from compose import compose
+from toolz.functoolz import compose
 
 from gtc.unstructured import gtir_to_usid2, py_to_gtir2, usid2_codegen
 
diff --git a/src/gtc/unstructured/py_to_gtscript2.py b/src/gtc/unstructured/py_to_gtscript2.py
index 9cf41a2..3486b08 100644
--- a/src/gtc/unstructured/py_to_gtscript2.py
+++ b/src/gtc/unstructured/py_to_gtscript2.py
@@ -19,7 +19,7 @@
 import textwrap
 from typing import List
 
-from compose import compose
+from toolz.functoolz import compose
 
 import eve
 from gtc.unstructured import gtscript_ast2

From cebfbb60033a1bcc05bac5f00623b54ce8adc1de Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Thu, 5 Nov 2020 18:09:50 +0000
Subject: [PATCH 19/24] address review comment

---
 src/gtc/unstructured/usid2_codegen.py | 57 +++++++++++++++------------
 1 file changed, 31 insertions(+), 26 deletions(-)

diff --git a/src/gtc/unstructured/usid2_codegen.py b/src/gtc/unstructured/usid2_codegen.py
index c923a46..2118432 100644
--- a/src/gtc/unstructured/usid2_codegen.py
+++ b/src/gtc/unstructured/usid2_codegen.py
@@ -46,38 +46,43 @@ def visit_Computation(self, node: usid2.Computation, **kwargs):
     )
     Assign = as_fmt("{left} = {right};")
     Kernel = as_mako(
-        """struct ${id_} {
-    GT_FUNCTION auto operator()() const {
-        return [](auto && ${_this_node.primary.name}, auto &&strides${''.join(f', auto&& {s.name}' for s in _this_node.secondaries)}) {
-            ${'\\n            '.join(body)}
+        """
+        struct ${id_} {
+            GT_FUNCTION auto operator()() const {
+                return [](auto && ${_this_node.primary.name},
+                    auto &&strides${''.join(f', auto&& {s.name}' for s in _this_node.secondaries)}) {
+                    ${''.join(body)}
+                };
+            }
         };
-    }
-};"""
+        """
     )
     Temporary = as_fmt(
         "auto {name} = make_simple_tmp_storage<{dtype}>(d.{location_type}, d.k, alloc);"
     )
     Computation = as_mako(
-        """#pragma once
-#include <gridtools/usid/${ backend }_helpers.hpp>
-namespace gridtools::usid::${ backend }::${ name }_impl_ {
-${'\\n'.join(f'struct {f}_tag;' for f in connectivities + params + [t.name for t in _this_node.temporaries])}
-${'\\n'.join(kernels)}
-inline constexpr auto ${ name } = [](domain d${ ''.join(f', auto&& {c}' for c in connectivities) }) {
-    ${'\\n    '.join(f'static_assert(is_sid<decltype({c}(traits_t()))>());' for c in connectivities)}
-    return[d = std::move(d)${ ''.join(f', {c} = sid::rename_dimensions<dim::n, {c}_tag>(std::forward<decltype({c})>({c})(traits_t()))' for c in connectivities) }]
-    (${ ', '.join(f'auto&& {p}' for p in params)}) {
-        ${'\\n        '.join(f'static_assert(is_sid<decltype({p})>());' for p in params)}
-% if len(temporaries) > 0:
-        auto alloc = make_allocator();
-        ${'\\n        '.join(temporaries)}
-% endif
-        ${'\\n        '.join(kernel_calls)}
-    };
-};
-}
-using gridtools::usid::${ backend }::${ name }_impl_::${ name };
-"""
+        """
+        #pragma once
+        #include <gridtools/usid/${ backend }_helpers.hpp>
+        namespace gridtools::usid::${ backend }::${ name }_impl_ {
+        ${''.join(f'struct {f}_tag;' for f in connectivities + params + [t.name for t in _this_node.temporaries])}
+        ${''.join(kernels)}
+        inline constexpr auto ${name} = [](domain d${''.join(f', auto&& {c}' for c in connectivities)}) {
+            ${''.join(f'static_assert(is_sid<decltype({c}(traits_t()))>());' for c in connectivities)}
+            return[d = std::move(d)
+                ${ ''.join(f', {c} = sid::rename_dimensions<dim::n, {c}_tag>(std::forward<decltype({c})>({c})(traits_t()))' for c in connectivities) }]
+                (${ ','.join(f'auto&& {p}' for p in params)}) {
+                ${''.join(f'static_assert(is_sid<decltype({p})>());' for p in params)}
+        % if len(temporaries) > 0:
+                auto alloc = make_allocator();
+                ${''.join(temporaries)}
+        % endif
+                ${''.join(kernel_calls)}
+            };
+        };
+        }
+        using gridtools::usid::${ backend }::${ name }_impl_::${ name };
+        """
     )
 
 

From d62f2c0c7636f0c55504819b383a910646f4a5c3 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Fri, 6 Nov 2020 10:55:49 +0000
Subject: [PATCH 20/24] use FrozenList

---
 src/gtc/unstructured/gtir2.py           | 13 ++++++-----
 src/gtc/unstructured/gtir_to_usid2.py   | 18 +++++++-------
 src/gtc/unstructured/gtscript_ast2.py   | 19 ++++++++-------
 src/gtc/unstructured/py_to_gtir2.py     | 31 ++++++++++++++-----------
 src/gtc/unstructured/py_to_gtscript2.py | 30 ++++++++++++------------
 src/gtc/unstructured/usid2.py           | 17 +++++++-------
 src/gtc/unstructured/usid2_codegen.py   |  9 ++++---
 7 files changed, 72 insertions(+), 65 deletions(-)

diff --git a/src/gtc/unstructured/gtir2.py b/src/gtc/unstructured/gtir2.py
index eb7c00a..f973798 100644
--- a/src/gtc/unstructured/gtir2.py
+++ b/src/gtc/unstructured/gtir2.py
@@ -15,9 +15,10 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 import enum
-from typing import List, Union
+from typing import Union
 
 from eve import Bool, Int, Node, Str, StrEnum
+from eve.typingx import FrozenList
 from gtc import common
 
 
@@ -103,12 +104,12 @@ class PrimaryLocation(Node):
 class Stencil(Node):
     loop_order: common.LoopOrder
     location: PrimaryLocation
-    body: List[Assign]
+    body: FrozenList[Assign]
 
 
 class Computation(Node):
     name: Str
-    connectivities: List[Connectivity]
-    args: List[Union[Field, SparseField]]
-    temporaries: List[Field]
-    stencils: List[Stencil]
+    connectivities: FrozenList[Connectivity]
+    args: FrozenList[Union[Field, SparseField]]
+    temporaries: FrozenList[Field]
+    stencils: FrozenList[Stencil]
diff --git a/src/gtc/unstructured/gtir_to_usid2.py b/src/gtc/unstructured/gtir_to_usid2.py
index e9801f4..ff1d5d2 100644
--- a/src/gtc/unstructured/gtir_to_usid2.py
+++ b/src/gtc/unstructured/gtir_to_usid2.py
@@ -62,7 +62,7 @@ def visit_Stencil(self, src: gtir2.Stencil):
         items = {}
         for s in src.body:
             items.update(self.visit(s, primary=src.location.name))
-        return usid2.Composite(name=src.location.name, items=list(items.values()))
+        return usid2.Composite(name=src.location.name, items=tuple(items.values()))
 
 
 _extract_primary_composite = _PrimaryCompositeExtractor().visit
@@ -115,10 +115,10 @@ def visit_BinaryOp(self, src: gtir2.BinaryOp):
         return _merge_dicts_of_dicts(self.visit(src.left), self.visit(src.right))
 
     def visit_Stencil(self, src: gtir2.Stencil):
-        return [
+        return tuple(
             usid2.Composite(name=name, items=list(sids.values()))
             for name, sids in _merge_dicts_of_dicts(*(self.visit(e) for e in src.body)).items()
-        ]
+        )
 
 
 _extract_secondary_composites = _SecondaryCompositesExtractor().visit
@@ -160,22 +160,22 @@ def visit_Stencil(self, src: gtir2.Stencil, tbl):
             location_type=_loc2str(src.location.location_type),
             primary=_extract_primary_composite(src),
             secondaries=_extract_secondary_composites(src),
-            body=[self.visit(e, tbl=tbl) for e in src.body],
+            body=tuple(self.visit(e, tbl=tbl) for e in src.body),
         )
 
     def visit_Computation(self, src: gtir2.Computation):
         tbl = {e.name: e for e in src.connectivities + src.args + src.temporaries}
         return usid2.Computation(
             name=src.name,
-            connectivities=[e.name for e in src.connectivities],
-            params=[e.name for e in src.args],
-            temporaries=[
+            connectivities=tuple(e.name for e in src.connectivities),
+            params=tuple(e.name for e in src.args),
+            temporaries=tuple(
                 usid2.Temporary(
                     name=e.name, location_type=_loc2str(e.location_type), dtype=_C_TYPES[e.dtype]
                 )
                 for e in src.temporaries
-            ],
-            kernels=[self.visit(e, tbl=tbl) for e in src.stencils],
+            ),
+            kernels=tuple(self.visit(e, tbl=tbl) for e in src.stencils),
         )
 
 
diff --git a/src/gtc/unstructured/gtscript_ast2.py b/src/gtc/unstructured/gtscript_ast2.py
index 2a197d6..e19571a 100644
--- a/src/gtc/unstructured/gtscript_ast2.py
+++ b/src/gtc/unstructured/gtscript_ast2.py
@@ -14,9 +14,10 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-from typing import Any, List, Optional, Union
+from typing import Any, Optional, Union
 
 from eve import Node, Str
+from eve.typingx import FrozenList
 
 
 class Stmt(Node):
@@ -33,22 +34,22 @@ class Name(Expr):
 
 class Subscript(Expr):
     value: Name
-    index: Union[Name, List[Name]]
+    index: Union[Name, FrozenList[Name]]
 
 
 class Call(Expr):
     func: Name
-    args: List[Expr]
+    args: FrozenList[Expr]
 
 
 class Comprehension(Node):
-    target: Union[Name, List[Name]]
+    target: Union[Name, FrozenList[Name]]
     iterable: Expr
 
 
 class GeneratorExp(Expr):
     elt: Expr
-    generators: List[Comprehension]
+    generators: FrozenList[Comprehension]
 
 
 class BinOp(Expr):
@@ -62,7 +63,7 @@ class Constant(Expr):
 
 
 class Assign(Stmt):
-    targets: List[Expr]
+    targets: FrozenList[Expr]
     value: Expr
 
 
@@ -72,10 +73,10 @@ class WithItem(Node):
 
 
 class With(Stmt):
-    items: List[WithItem]
-    body: List[Stmt]
+    items: FrozenList[WithItem]
+    body: FrozenList[Stmt]
 
 
 class Function(Node):
     name: Str
-    body: List[Stmt]
+    body: FrozenList[Stmt]
diff --git a/src/gtc/unstructured/py_to_gtir2.py b/src/gtc/unstructured/py_to_gtir2.py
index db4a51a..7ca764e 100644
--- a/src/gtc/unstructured/py_to_gtir2.py
+++ b/src/gtc/unstructured/py_to_gtir2.py
@@ -14,6 +14,7 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
+import collections
 import functools
 import inspect
 import sys
@@ -48,7 +49,7 @@ def _is_legit_annotation(src):
 
 
 def _extract_params(fun):
-    res = [p for _, p in inspect.signature(fun).parameters.items()]
+    res = tuple(p for _, p in inspect.signature(fun).parameters.items())
     for p in res:
         if not _is_legit_annotation(p.annotation):
             raise RuntimeError(f"unexpected type annotation: {p}")
@@ -190,7 +191,7 @@ def visit_Subscript(self, src: gtscript_ast2.Subscript, location, **kwargs):
             assert isinstance(src.index, gtscript_ast2.Name)
             assert src.index.name == res.location
         elif isinstance(res, gtir2.SparseFieldAccess):
-            assert isinstance(src.index, list)
+            assert isinstance(src.index, collections.Sequence)
             assert len(src.index) == 2
             assert src.index[0].name == res.primary
             assert src.index[1].name == res.secondary
@@ -212,15 +213,15 @@ def visit_Assign(self, src: gtscript_ast2.Assign, tbl, primary):
         right = self.visit(src.value, tbl=tbl, location=primary)
         return (
             gtir2.Assign(left=left, right=right),
-            []
+            ()
             if left.name in tbl
-            else [
+            else (
                 gtir2.Field(
                     name=left.name,
                     location_type=primary.location_type,
                     dtype=_deduce_expr_type(right, tbl),
-                )
-            ],
+                ),
+            ),
         )
 
     def visit_With(self, src: gtscript_ast2.With, tbl):
@@ -252,32 +253,34 @@ def folder(acc, stmt):
             assign, temporaries = self.visit(
                 stmt, tbl={**tbl, **{t.name: t for t in acc[1]}}, primary=location
             )
-            return acc[0] + [assign], acc[1] + temporaries
+            return acc[0] + (assign,), acc[1] + temporaries
 
-        body, temporaries = functools.reduce(folder, src.body, ([], []))
+        body, temporaries = functools.reduce(folder, src.body, ((), ()))
         return gtir2.Stencil(loop_order=loop_order, location=location, body=body), temporaries
 
     def visit_Function(self, src: gtscript_ast2.Function, fun_params):
-        connectivity_params = [p for p in fun_params if _is_conncetivity_annotation(p.annotation)]
+        connectivity_params = tuple(
+            p for p in fun_params if _is_conncetivity_annotation(p.annotation)
+        )
         connectivity_type_to_name = dict((p.annotation, p.name) for p in connectivity_params)
         if len(connectivity_params) > len(connectivity_type_to_name):
             raise RuntimeError(
                 "the types of the conncetivities within computation should be all different"
             )
-        connectivities = [_extract_connectivity(p) for p in connectivity_params]
-        args = [
+        connectivities = tuple(_extract_connectivity(p) for p in connectivity_params)
+        args = tuple(
             _extract_arg(p, connectivity_type_to_name)
             for p in fun_params
             if not _is_conncetivity_annotation(p.annotation)
-        ]
+        )
         assert all(isinstance(s, gtscript_ast2.With) for s in src.body)
         tbl = {e.name: e for e in connectivities + args}
 
         def folder(acc, stmt):
             stencil, temporaries = self.visit(stmt, tbl={**tbl, **{t.name: t for t in acc[1]}})
-            return acc[0] + [stencil], acc[1] + temporaries
+            return acc[0] + (stencil,), acc[1] + temporaries
 
-        stencils, temporaries = functools.reduce(folder, src.body, ([], []))
+        stencils, temporaries = functools.reduce(folder, src.body, ((), ()))
         return gtir2.Computation(
             name=src.name,
             connectivities=connectivities,
diff --git a/src/gtc/unstructured/py_to_gtscript2.py b/src/gtc/unstructured/py_to_gtscript2.py
index 3486b08..ce46a89 100644
--- a/src/gtc/unstructured/py_to_gtscript2.py
+++ b/src/gtc/unstructured/py_to_gtscript2.py
@@ -17,7 +17,7 @@
 import ast
 import inspect
 import textwrap
-from typing import List
+from typing import Sequence
 
 from toolz.functoolz import compose
 
@@ -26,11 +26,11 @@
 
 
 class _Visitor(ast.NodeVisitor):
-    def _visit_list(self, src):
-        return [self.visit(e) for e in src]
+    def _visit_iterable(self, src):
+        return tuple(self.visit(e) for e in src)
 
     def visit_Tuple(self, src: ast.Tuple):
-        return self._visit_list(src.elts)
+        return tuple(self.visit(e) for e in src.elts)
 
     def visit_Name(self, src: ast.Name):
         return gtscript_ast2.Name(name=src.id)
@@ -48,11 +48,11 @@ def visit_withitem(self, src: ast.withitem):
 
     def visit_With(self, src: ast.With):
         return gtscript_ast2.With(
-            items=self._visit_list(src.items), body=self._visit_list(src.body)
+            items=self._visit_iterable(src.items), body=self._visit_iterable(src.body)
         )
 
     def visit_Call(self, src: ast.Call):
-        return gtscript_ast2.Call(func=self.visit(src.func), args=self._visit_list(src.args))
+        return gtscript_ast2.Call(func=self.visit(src.func), args=self._visit_iterable(src.args))
 
     def visit_BinOp(self, src: ast.BinOp):
         return gtscript_ast2.BinOp(
@@ -76,7 +76,7 @@ def visit_Constant(self, src: ast.Constant):
 
     def visit_GeneratorExp(self, src: ast.GeneratorExp):
         return gtscript_ast2.GeneratorExp(
-            elt=self.visit(src.elt), generators=self._visit_list(src.generators)
+            elt=self.visit(src.elt), generators=self._visit_iterable(src.generators)
         )
 
     def visit_comprehension(self, src: ast.comprehension):
@@ -86,37 +86,37 @@ def visit_comprehension(self, src: ast.comprehension):
 
     def visit_Assign(self, src: ast.Assign):
         return gtscript_ast2.Assign(
-            targets=self._visit_list(src.targets), value=self.visit(src.value)
+            targets=self._visit_iterable(src.targets), value=self.visit(src.value)
         )
 
     def visit_FunctionDef(self, src: ast.FunctionDef):
-        return gtscript_ast2.Function(name=src.name, body=self._visit_list(src.body))
+        return gtscript_ast2.Function(name=src.name, body=self._visit_iterable(src.body))
 
 
 def _flatten(ll):
-    return [e for l in ll for e in l]
+    return tuple(e for l in ll for e in l)
 
 
 class _FlattenWiths(eve.NodeTranslator):
-    def _process_statements(self, src: List[gtscript_ast2.Stmt]):
+    def _process_statements(self, src: Sequence[gtscript_ast2.Stmt]):
         return (
             _flatten(
-                self.visit(s, items=[]) if isinstance(s, gtscript_ast2.With) else [self.visit(s)]
+                self.visit(s, items=()) if isinstance(s, gtscript_ast2.With) else (self.visit(s),)
                 for s in src
             )
             if any(isinstance(s, gtscript_ast2.With) for s in src)
-            else [self.visit(s) for s in src]
+            else tuple(self.visit(s) for s in src)
         )
 
     def visit_Function(self, src: gtscript_ast2.Function):
         return gtscript_ast2.Function(name=src.name, body=self._process_statements(src.body))
 
-    def visit_With(self, src: gtscript_ast2.With, items: List[gtscript_ast2.WithItem]):
+    def visit_With(self, src: gtscript_ast2.With, items: Sequence[gtscript_ast2.WithItem]):
         items = items + src.items
         return (
             _flatten(self.visit(s, items=items) for s in src.body)
             if all(isinstance(s, gtscript_ast2.With) for s in src.body)
-            else [gtscript_ast2.With(items=items, body=self._process_statements(src.body))]
+            else (gtscript_ast2.With(items=items, body=self._process_statements(src.body)),)
         )
 
 
diff --git a/src/gtc/unstructured/usid2.py b/src/gtc/unstructured/usid2.py
index 5801791..cc68b39 100644
--- a/src/gtc/unstructured/usid2.py
+++ b/src/gtc/unstructured/usid2.py
@@ -14,9 +14,8 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-from typing import List
-
 from eve import Bool, Int, Node, Str
+from eve.typingx import FrozenList
 from gtc import common
 from gtc.unstructured.gtir2 import ReduceOperator
 
@@ -37,7 +36,7 @@ class Temporary(Node):
 
 class Composite(Node):
     name: Str
-    items: List[Sid]
+    items: FrozenList[Sid]
 
 
 class Expr(Node):
@@ -79,13 +78,13 @@ class Assign(Node):
 class Kernel(Node):
     location_type: Str
     primary: Composite
-    secondaries: List[Composite]
-    body: List[Assign]
+    secondaries: FrozenList[Composite]
+    body: FrozenList[Assign]
 
 
 class Computation(Node):
     name: Str
-    connectivities: List[Str]
-    params: List[Str]
-    temporaries: List[Temporary]
-    kernels: List[Kernel]
+    connectivities: FrozenList[Str]
+    params: FrozenList[Str]
+    temporaries: FrozenList[Temporary]
+    kernels: FrozenList[Kernel]
diff --git a/src/gtc/unstructured/usid2_codegen.py b/src/gtc/unstructured/usid2_codegen.py
index 2118432..cd2e2ba 100644
--- a/src/gtc/unstructured/usid2_codegen.py
+++ b/src/gtc/unstructured/usid2_codegen.py
@@ -14,6 +14,8 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
+from toolz.functoolz import compose
+
 from eve import codegen
 from eve.codegen import FormatTemplate as as_fmt
 from eve.codegen import MakoTemplate as as_mako
@@ -34,7 +36,7 @@ class _KernelCallGenerator(codegen.TemplatedGenerator):
 class _Generator(codegen.TemplatedGenerator):
     def visit_Computation(self, node: usid2.Computation, **kwargs):
         return self.generic_visit(
-            node, kernel_calls=[_KernelCallGenerator.apply(k) for k in node.kernels], **kwargs
+            node, kernel_calls=tuple(_KernelCallGenerator.apply(k) for k in node.kernels), **kwargs
         )
 
     Literal = as_mako("${dtype}{${value}}")
@@ -87,8 +89,9 @@ def visit_Computation(self, node: usid2.Computation, **kwargs):
 
 
 def _impl(backend):
-    return lambda src: codegen.format_source(
-        "cpp", _Generator.apply(src, backend=backend), style="LLVM"
+    return compose(
+        lambda x: codegen.format_source("cpp", x, style="LLVM"),
+        lambda x: _Generator.apply(x, backend=backend),
     )
 
 

From a43a722d36f182aecd4704c0f99cd96af9ffa669 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Fri, 6 Nov 2020 11:21:34 +0000
Subject: [PATCH 21/24] fix the test

---
 tests/tests_gtc/regression/cpp2/fvm_nabla.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/tests_gtc/regression/cpp2/fvm_nabla.py b/tests/tests_gtc/regression/cpp2/fvm_nabla.py
index 4b7f3c7..12e29ed 100644
--- a/tests/tests_gtc/regression/cpp2/fvm_nabla.py
+++ b/tests/tests_gtc/regression/cpp2/fvm_nabla.py
@@ -23,8 +23,8 @@
 
 
 def nabla(
-    e2v: E2V,
     v2e: V2E,
+    e2v: E2V,
     S_MXX: Field[Edge, dtype],
     S_MYY: Field[Edge, dtype],
     pp: Field[Vertex, dtype],

From 5b1d1df3bd01f2c191e05f27b6c26f53138aa044 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Fri, 6 Nov 2020 16:46:54 +0000
Subject: [PATCH 22/24] simplify usid

---
 .../usid/include/gridtools/usid/helpers.hpp   |  70 +++++++----
 src/gtc/unstructured/gtir2.py                 |   4 +-
 src/gtc/unstructured/gtir_to_usid2.py         | 109 ++++++++++--------
 src/gtc/unstructured/py_to_gtir2.py           |   2 +-
 src/gtc/unstructured/usid2.py                 |  19 +--
 src/gtc/unstructured/usid2_codegen.py         |  42 ++++---
 6 files changed, 151 insertions(+), 95 deletions(-)

diff --git a/cpputil/usid/include/gridtools/usid/helpers.hpp b/cpputil/usid/include/gridtools/usid/helpers.hpp
index d07fdf3..2fcd5eb 100644
--- a/cpputil/usid/include/gridtools/usid/helpers.hpp
+++ b/cpputil/usid/include/gridtools/usid/helpers.hpp
@@ -25,21 +25,30 @@ namespace gridtools::usid {
         return sid::make_contiguous<T>(alloc, hymap::keys<dim::h, dim::k>::values<HSize, KSize>(h_size, k_size));
     }
 
-    template <class T,
-        class Tag,
-        int_t N,
-        bool HasSkipValues,
-        class F,
-        class Init,
-        class G,
-        class Ptr,
-        class Strides,
-        class Neighbors>
+    template <int_t N, bool HasSkipValues>
+    struct connectivity {
+        using max_neighbors_t = integral_constant<int_t, N>;
+        using has_skip_values_t = std::bool_constant<HasSkipValues>;
+    };
+
+    template <class Connectivity>
+    struct sparse_field {
+        using connectivity_t = Connectivity;
+    };
+
+    template <class, class = void>
+    struct is_sparse_field : std::false_type {};
+
+    template <class T>
+    struct is_sparse_field<T, std::enable_if_t<std::is_base_of_v<sparse_field<typename T::connectivity_t>, T>>>
+        : std::true_type {};
+
+    template <class T, class Conncectivity, class F, class Init, class G, class Ptr, class Strides, class Neighbors>
     GT_FUNCTION T fold_neighbors(F f, Init init, G g, Ptr &&ptr, Strides &&strides, Neighbors &&neighbors) {
         T acc = init(meta::lazy::id<T>());
-        sid::make_loop<Tag>(integral_constant<int_t, N>())([&](auto const &ptr, auto &&) {
-            auto i = *host_device::at_key<Tag>(ptr);
-            if constexpr (HasSkipValues)
+        sid::make_loop<Conncectivity>(typename Conncectivity::max_neighbors_t())([&](auto const &ptr, auto &&) {
+            auto i = *host_device::at_key<Conncectivity>(ptr);
+            if constexpr (Conncectivity::has_skip_values_t::value)
                 if (i < 0)
                     return;
             acc = f(acc, g(ptr, sid::shifted(neighbors.first, neighbors.second, i)));
@@ -47,25 +56,25 @@ namespace gridtools::usid {
         return acc;
     }
 
-    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
+    template <class T, class Conncectivity, class F, class... Args>
     GT_FUNCTION T sum_neighbors(F f, Args &&...args) {
-        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x + y; },
+        return fold_neighbors<T, Conncectivity>([](auto x, auto y) { return x + y; },
             [](auto z) -> typename decltype(z)::type { return 0; },
             f,
             wstd::forward<Args>(args)...);
     }
 
-    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
+    template <class T, class Conncectivity, class F, class... Args>
     GT_FUNCTION T product_neighbors(F f, Args &&...args) {
-        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x * y; },
+        return fold_neighbors<T, Conncectivity>([](auto x, auto y) { return x * y; },
             [](auto z) -> typename decltype(z)::type { return 1; },
             f,
             wstd::forward<Args>(args)...);
     }
 
-    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
+    template <class T, class Conncectivity, class F, class... Args>
     GT_FUNCTION T min_neighbors(F f, Args &&...args) {
-        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x < y ? x : y; },
+        return fold_neighbors<T, Conncectivity>([](auto x, auto y) { return x < y ? x : y; },
             [](auto z) -> typename decltype(z)::type {
                 constexpr auto res = std::numeric_limits<typename decltype(z)::type>::max();
                 return res;
@@ -74,9 +83,9 @@ namespace gridtools::usid {
             wstd::forward<Args>(args)...);
     }
 
-    template <class T, class Tag, int_t N, bool HasSkip = true, class F, class... Args>
+    template <class T, class Conncectivity, class F, class... Args>
     GT_FUNCTION T max_neighbors(F f, Args &&...args) {
-        return fold_neighbors<T, Tag, N, HasSkip>([](auto x, auto y) { return x > y ? x : y; },
+        return fold_neighbors<T, Conncectivity>([](auto x, auto y) { return x > y ? x : y; },
             [](auto z) -> typename decltype(z)::type {
                 constexpr auto res = std::numeric_limits<typename decltype(z)::type>::min();
                 return res;
@@ -84,4 +93,23 @@ namespace gridtools::usid {
             f,
             wstd::forward<Args>(args)...);
     }
+
+    template <class Tag, class Val>
+    decltype(auto) composite_item(Tag, Val &&val) {
+        if constexpr (is_sparse_field<Tag>::value)
+            return sid::rename_dimensions<dim::s, typename Tag::connectivity_t>(std::forward<Val>(val));
+        else
+            return std::forward<Val>(val);
+    }
+
+    template <class... Tags>
+    struct make_composite_f {
+        template <class... Vals>
+        auto operator()(Vals &&...vals) const {
+            return sid::composite::make<Tags...>(composite_item(Tags(), std::forward<Vals>(vals))...);
+        }
+    };
+
+    template <class... Tags>
+    constexpr make_composite_f<Tags...> make_composite = {};
 } // namespace gridtools::usid
diff --git a/src/gtc/unstructured/gtir2.py b/src/gtc/unstructured/gtir2.py
index f973798..9917760 100644
--- a/src/gtc/unstructured/gtir2.py
+++ b/src/gtc/unstructured/gtir2.py
@@ -15,7 +15,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 import enum
-from typing import Union
+from typing import Any, Union
 
 from eve import Bool, Int, Node, Str, StrEnum
 from eve.typingx import FrozenList
@@ -64,7 +64,7 @@ class BinaryOp(Expr):
 
 
 class Literal(Expr):
-    value: Str
+    value: Any
     dtype: common.DataType
 
 
diff --git a/src/gtc/unstructured/gtir_to_usid2.py b/src/gtc/unstructured/gtir_to_usid2.py
index ff1d5d2..9c044bf 100644
--- a/src/gtc/unstructured/gtir_to_usid2.py
+++ b/src/gtc/unstructured/gtir_to_usid2.py
@@ -14,8 +14,11 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
+import functools
 import itertools
 
+from toolz.functoolz import compose
+
 import eve
 from gtc import common
 from gtc.unstructured import gtir2, usid2
@@ -29,6 +32,14 @@
     common.DataType.BOOLEAN: "bool",
 }
 
+_LITERAL_CONVERTERS = {
+    common.DataType.FLOAT64: compose(str, float),
+    common.DataType.FLOAT32: lambda x: str(float(x)) + "f",
+    common.DataType.INT32: compose(str, int),
+    common.DataType.UINT32: lambda x: str(int(x)) + "u",
+    common.DataType.BOOLEAN: lambda x: str(bool(x)).lower(),
+}
+
 
 def _loc2str(x: common.LocationType):
     return x.name.lower()
@@ -36,33 +47,32 @@ def _loc2str(x: common.LocationType):
 
 class _PrimaryCompositeExtractor(eve.NodeVisitor):
     def visit_Literal(self, src: gtir2.Literal, **kwargs):
-        return {}
+        return set()
 
-    def visit_FieldAccess(self, src: gtir2.FieldAccess, primary, **kwargs):
-        return {src.name: usid2.Sid(name=src.name)} if src.location == primary else {}
+    def visit_FieldAccess(self, src: gtir2.FieldAccess, primary):
+        return {src.name} if src.location == primary else set()
 
-    def visit_SparseFieldAccess(self, src: gtir2.SparseFieldAccess, primary, connectivity):
+    def visit_SparseFieldAccess(self, src: gtir2.SparseFieldAccess, primary):
         assert src.primary == primary
-        return {src.name: usid2.SparseField(name=src.name, connectivity=connectivity)}
+        return {src.name}
 
     def visit_BinaryOp(self, src: gtir2.BinaryOp, **kwargs):
-        return {**self.visit(src.left, **kwargs), **self.visit(src.right, **kwargs)}
+        return self.visit(src.left, **kwargs) | self.visit(src.right, **kwargs)
 
-    def visit_NeighborReduce(self, src: gtir2.NeighborReduce, primary, **kwargs):
+    def visit_NeighborReduce(self, src: gtir2.NeighborReduce, primary):
         assert src.location.primary == primary
-        return {
-            src.location.connectivity: usid2.Sid(name=src.location.connectivity),
-            **self.visit(src.body, primary=primary, connectivity=src.location.connectivity),
-        }
+        return {src.location.connectivity} | self.visit(src.body, primary=primary)
 
     def visit_Assign(self, src: gtir2.Assign, **kwargs):
-        return {**self.visit(src.left, **kwargs), **self.visit(src.right, **kwargs)}
+        return self.visit(src.left, **kwargs) | self.visit(src.right, **kwargs)
 
     def visit_Stencil(self, src: gtir2.Stencil):
-        items = {}
-        for s in src.body:
-            items.update(self.visit(s, primary=src.location.name))
-        return usid2.Composite(name=src.location.name, items=tuple(items.values()))
+        return usid2.Composite(
+            name=src.location.name,
+            items=functools.reduce(
+                lambda acc, e: acc | self.visit(e, primary=src.location.name), src.body, set()
+            ),
+        )
 
 
 _extract_primary_composite = _PrimaryCompositeExtractor().visit
@@ -70,16 +80,16 @@ def visit_Stencil(self, src: gtir2.Stencil):
 
 class _SecondaryCompositeExtractor(eve.NodeVisitor):
     def visit_SparseFieldAccess(self, src: gtir2.SparseFieldAccess, **kwargs):
-        return {}
+        return set()
 
     def visit_Literal(self, src: gtir2.Literal, **kwargs):
-        return {}
+        return set()
 
     def visit_FieldAccess(self, src: gtir2.FieldAccess, secondary, **kwargs):
-        return {src.name: usid2.Sid(name=src.name)} if src.location == secondary else {}
+        return {src.name} if src.location == secondary else {}
 
     def visit_BinaryOp(self, src: gtir2.BinaryOp, **kwargs):
-        return {**self.visit(src.left, **kwargs), **self.visit(src.right, **kwargs)}
+        return self.visit(src.left, **kwargs) | self.visit(src.right, **kwargs)
 
     def visit_NeighborReduce(self, src: gtir2.NeighborReduce):
         return {src.location.connectivity: self.visit(src.body, secondary=src.location.name)}
@@ -88,13 +98,13 @@ def visit_NeighborReduce(self, src: gtir2.NeighborReduce):
 _extract_secondary_composite = _SecondaryCompositeExtractor().visit
 
 
-def _merge_dicts_of_dicts(*srcs):
+def _merge_dicts_of_sets(*srcs):
     res = {}
     for k in set(itertools.chain(*srcs)):
-        res[k] = {}
+        res[k] = set()
         for src in srcs:
             if k in src:
-                res[k].update(src[k])
+                res[k] = res[k] | src[k]
     return res
 
 
@@ -112,12 +122,12 @@ def visit_NeighborReduce(self, src: gtir2.NeighborReduce):
         return _extract_secondary_composite(src)
 
     def visit_BinaryOp(self, src: gtir2.BinaryOp):
-        return _merge_dicts_of_dicts(self.visit(src.left), self.visit(src.right))
+        return _merge_dicts_of_sets(self.visit(src.left), self.visit(src.right))
 
     def visit_Stencil(self, src: gtir2.Stencil):
         return tuple(
-            usid2.Composite(name=name, items=list(sids.values()))
-            for name, sids in _merge_dicts_of_dicts(*(self.visit(e) for e in src.body)).items()
+            usid2.Composite(name=name, items=items)
+            for name, items in _merge_dicts_of_sets(*(self.visit(e) for e in src.body)).items()
         )
 
 
@@ -125,57 +135,62 @@ def visit_Stencil(self, src: gtir2.Stencil):
 
 
 class _Visitor(eve.NodeVisitor):
-    def visit_FieldAccess(self, src: gtir2.FieldAccess, **kwargs):
+    def visit_FieldAccess(self, src: gtir2.FieldAccess):
         return usid2.FieldAccess(name=src.name, location=src.location)
 
-    def visit_SparseFieldAccess(self, src: gtir2.SparseFieldAccess, **kwargs):
+    def visit_SparseFieldAccess(self, src: gtir2.SparseFieldAccess):
         return usid2.FieldAccess(name=src.name, location=src.primary)
 
-    def visit_Literal(self, src: gtir2.Literal, **kwargs):
-        return usid2.Literal(value=src.value, dtype=_C_TYPES[src.dtype])
+    def visit_Literal(self, src: gtir2.Literal):
+        return usid2.Literal(value=_LITERAL_CONVERTERS[src.dtype](src.value))
 
-    def visit_BinaryOp(self, src: gtir2.BinaryOp, **kwargs):
-        return usid2.BinaryOp(
-            op=src.op, left=self.visit(src.left, **kwargs), right=self.visit(src.right, **kwargs)
-        )
+    def visit_BinaryOp(self, src: gtir2.BinaryOp):
+        return usid2.BinaryOp(op=src.op, left=self.visit(src.left), right=self.visit(src.right))
 
-    def visit_NeighborReduce(self, src: gtir2.NeighborReduce, tbl):
-        connectivity = tbl[src.location.connectivity]
+    def visit_NeighborReduce(self, src: gtir2.NeighborReduce):
         return usid2.NeighborReduce(
             op=src.op,
             dtype=_C_TYPES[src.dtype],
-            connectivity=connectivity.name,
-            max_neighbors=connectivity.max_neighbors,
-            has_skip_values=connectivity.has_skip_values,
+            connectivity=src.location.connectivity,
             primary=src.location.primary,
             secondary=src.location.name,
             body=self.visit(src.body),
         )
 
-    def visit_Assign(self, src: gtir2.Assign, tbl):
-        return usid2.Assign(left=self.visit(src.left), right=self.visit(src.right, tbl=tbl))
+    def visit_Assign(self, src: gtir2.Assign):
+        return usid2.Assign(left=self.visit(src.left), right=self.visit(src.right))
 
-    def visit_Stencil(self, src: gtir2.Stencil, tbl):
+    def visit_Stencil(self, src: gtir2.Stencil):
         return usid2.Kernel(
             location_type=_loc2str(src.location.location_type),
             primary=_extract_primary_composite(src),
             secondaries=_extract_secondary_composites(src),
-            body=tuple(self.visit(e, tbl=tbl) for e in src.body),
+            body=tuple(self.visit(e) for e in src.body),
+        )
+
+    def visit_Connectivity(self, src: gtir2.Connectivity):
+        return usid2.Connectivity(
+            name=src.name, max_neighbors=src.max_neighbors, has_skip_values=src.has_skip_values
         )
 
+    def visit_Field(self, src: gtir2.Field):
+        return usid2.Field(name=src.name)
+
+    def visit_SparseField(self, src: gtir2.SparseField):
+        return usid2.SparseField(name=src.name, connectivity=src.connectivity)
+
     def visit_Computation(self, src: gtir2.Computation):
-        tbl = {e.name: e for e in src.connectivities + src.args + src.temporaries}
         return usid2.Computation(
             name=src.name,
-            connectivities=tuple(e.name for e in src.connectivities),
-            params=tuple(e.name for e in src.args),
+            connectivities=tuple(self.visit(e) for e in src.connectivities),
+            args=tuple(self.visit(e) for e in src.args),
             temporaries=tuple(
                 usid2.Temporary(
                     name=e.name, location_type=_loc2str(e.location_type), dtype=_C_TYPES[e.dtype]
                 )
                 for e in src.temporaries
             ),
-            kernels=tuple(self.visit(e, tbl=tbl) for e in src.stencils),
+            kernels=tuple(self.visit(e) for e in src.stencils),
         )
 
 
diff --git a/src/gtc/unstructured/py_to_gtir2.py b/src/gtc/unstructured/py_to_gtir2.py
index 7ca764e..9630c24 100644
--- a/src/gtc/unstructured/py_to_gtir2.py
+++ b/src/gtc/unstructured/py_to_gtir2.py
@@ -127,7 +127,7 @@ def _deduce_expr_type(src: gtir2.Expr, tbl):
 
 class _Visitor(eve.NodeVisitor):
     def visit_Constant(self, src: gtscript_ast2.Constant, **kwargs):
-        return gtir2.Literal(value=str(src.value), dtype=_PY_TYPE_TO_DATA_TYPE[type(src.value)])
+        return gtir2.Literal(value=src.value, dtype=_PY_TYPE_TO_DATA_TYPE[type(src.value)])
 
     def visit_Call(self, src: gtscript_ast2.Call, tbl, location):
         assert isinstance(location, gtir2.PrimaryLocation)
diff --git a/src/gtc/unstructured/usid2.py b/src/gtc/unstructured/usid2.py
index cc68b39..aa8a6aa 100644
--- a/src/gtc/unstructured/usid2.py
+++ b/src/gtc/unstructured/usid2.py
@@ -20,11 +20,17 @@
 from gtc.unstructured.gtir2 import ReduceOperator
 
 
-class Sid(Node):
+class Connectivity(Node):
+    name: Str
+    max_neighbors: Int
+    has_skip_values: Bool
+
+
+class Field(Node):
     name: Str
 
 
-class SparseField(Sid):
+class SparseField(Field):
     connectivity: Str
 
 
@@ -36,7 +42,7 @@ class Temporary(Node):
 
 class Composite(Node):
     name: Str
-    items: FrozenList[Sid]
+    items: FrozenList[Str]
 
 
 class Expr(Node):
@@ -45,7 +51,6 @@ class Expr(Node):
 
 class Literal(Expr):
     value: Str
-    dtype: Str
 
 
 class FieldAccess(Expr):
@@ -63,8 +68,6 @@ class NeighborReduce(Expr):
     op: ReduceOperator
     dtype: Str
     connectivity: Str
-    max_neighbors: Int
-    has_skip_values: Bool
     primary: Str
     secondary: Str
     body: Expr
@@ -84,7 +87,7 @@ class Kernel(Node):
 
 class Computation(Node):
     name: Str
-    connectivities: FrozenList[Str]
-    params: FrozenList[Str]
+    connectivities: FrozenList[Connectivity]
+    args: FrozenList[Field]
     temporaries: FrozenList[Temporary]
     kernels: FrozenList[Kernel]
diff --git a/src/gtc/unstructured/usid2_codegen.py b/src/gtc/unstructured/usid2_codegen.py
index cd2e2ba..93dd635 100644
--- a/src/gtc/unstructured/usid2_codegen.py
+++ b/src/gtc/unstructured/usid2_codegen.py
@@ -23,10 +23,8 @@
 
 
 class _KernelCallGenerator(codegen.TemplatedGenerator):
-    Sid = as_fmt("{name}")
-    SparseField = as_fmt("sid::rename_dimensions<dim::s, {connectivity}_tag>({name})")
     Composite = as_mako(
-        "sid::composite::make<${', '.join(f'{i.name}_tag' for i in _this_node.items)}>(${', '.join(items)})"
+        "make_composite<${','.join(f'{i}_tag' for i in items)}>(${','.join(items)})"
     )
     Kernel = as_mako(
         "call_kernel<${id_}>(d.${location_type}${''.join(f', {c}' for c in [primary] + secondaries)});"
@@ -39,11 +37,11 @@ def visit_Computation(self, node: usid2.Computation, **kwargs):
             node, kernel_calls=tuple(_KernelCallGenerator.apply(k) for k in node.kernels), **kwargs
         )
 
-    Literal = as_mako("${dtype}{${value}}")
+    Literal = as_mako("${value}")
     BinaryOp = as_fmt("({left} {op} {right})")
     FieldAccess = as_fmt("field<{name}_tag>({location})")
     NeighborReduce = as_mako(
-        "${op}_neighbors<${dtype}, ${connectivity}_tag, ${max_neighbors}, ${has_skip_values.lower()}>"
+        "${op}_neighbors<${dtype}, ${connectivity}_tag>"
         + "([](auto &&${primary}, auto &&${secondary}) { return ${body}; }, ${primary}, strides, ${connectivity})"
     )
     Assign = as_fmt("{left} = {right};")
@@ -62,19 +60,31 @@ def visit_Computation(self, node: usid2.Computation, **kwargs):
     Temporary = as_fmt(
         "auto {name} = make_simple_tmp_storage<{dtype}>(d.{location_type}, d.k, alloc);"
     )
+    Connectivity = as_mako(
+        "struct ${name}_tag: connectivity<${max_neighbors}, ${has_skip_values.lower()}> {};"
+    )
+    Field = as_mako("struct ${name}_tag {};")
+    SparseField = as_mako("struct ${name}_tag: sparse_field<${connectivity}_tag> {};")
     Computation = as_mako(
-        """
-        #pragma once
-        #include <gridtools/usid/${ backend }_helpers.hpp>
-        namespace gridtools::usid::${ backend }::${ name }_impl_ {
-        ${''.join(f'struct {f}_tag;' for f in connectivities + params + [t.name for t in _this_node.temporaries])}
+        """<%
+
+            ts = tuple(e.name for e in _this_node.temporaries)
+            cs = tuple(e.name for e in _this_node.connectivities)
+            ps = tuple(e.name for e in _this_node.args)
+
+        %>#pragma once
+        #include <gridtools/usid/${backend}_helpers.hpp>
+        namespace gridtools::usid::${backend}::${name}_impl_ {
+        ${''.join(connectivities)}
+        ${''.join(args)}
+        ${''.join(f'struct {t}_tag {{}};' for t in ts)}
         ${''.join(kernels)}
-        inline constexpr auto ${name} = [](domain d${''.join(f', auto&& {c}' for c in connectivities)}) {
-            ${''.join(f'static_assert(is_sid<decltype({c}(traits_t()))>());' for c in connectivities)}
+        inline constexpr auto ${name} = [](domain d${''.join(f', auto&& {c}' for c in cs)}) {
+            ${''.join(f'static_assert(is_sid<decltype({c}(traits_t()))>());' for c in cs)}
             return[d = std::move(d)
-                ${ ''.join(f', {c} = sid::rename_dimensions<dim::n, {c}_tag>(std::forward<decltype({c})>({c})(traits_t()))' for c in connectivities) }]
-                (${ ','.join(f'auto&& {p}' for p in params)}) {
-                ${''.join(f'static_assert(is_sid<decltype({p})>());' for p in params)}
+                ${ ''.join(f', {c} = sid::rename_dimensions<dim::n, {c}_tag>(std::forward<decltype({c})>({c})(traits_t()))' for c in cs) }]
+                (${ ','.join(f'auto&& {p}' for p in ps)}) {
+                ${''.join(f'static_assert(is_sid<decltype({p})>());' for p in ps)}
         % if len(temporaries) > 0:
                 auto alloc = make_allocator();
                 ${''.join(temporaries)}
@@ -83,7 +93,7 @@ def visit_Computation(self, node: usid2.Computation, **kwargs):
             };
         };
         }
-        using gridtools::usid::${ backend }::${ name }_impl_::${ name };
+        using gridtools::usid::${backend}::${name}_impl_::${name};
         """
     )
 

From 4c90b2c48d8c293f35087d7afbf774c359ded708 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 9 Nov 2020 16:02:23 +0000
Subject: [PATCH 23/24] add stencils merge

---
 src/gtc/unstructured/frontend.py              |  5 +-
 .../gtir_passes2/merge_stencils.py            | 56 ++++++++++++++++++
 .../gtir_passes2/rename_location.py           | 59 +++++++++++++++++++
 src/gtc/unstructured/gtscript_ast2.py         |  1 +
 src/gtc/unstructured/usid2.py                 |  2 +
 src/gtc/unstructured/usid2_codegen.py         |  1 +
 6 files changed, 123 insertions(+), 1 deletion(-)
 create mode 100644 src/gtc/unstructured/gtir_passes2/merge_stencils.py
 create mode 100644 src/gtc/unstructured/gtir_passes2/rename_location.py

diff --git a/src/gtc/unstructured/frontend.py b/src/gtc/unstructured/frontend.py
index 58745cb..9ad188b 100644
--- a/src/gtc/unstructured/frontend.py
+++ b/src/gtc/unstructured/frontend.py
@@ -18,10 +18,13 @@
 from toolz.functoolz import compose
 
 from gtc.unstructured import gtir_to_usid2, py_to_gtir2, usid2_codegen
+from gtc.unstructured.gtir_passes2 import merge_stencils
 
 
 def _impl(codegen):
-    return compose(codegen, gtir_to_usid2.transform, py_to_gtir2.transform)
+    return compose(
+        codegen, gtir_to_usid2.transform, merge_stencils.transform, py_to_gtir2.transform
+    )
 
 
 naive = _impl(usid2_codegen.naive)
diff --git a/src/gtc/unstructured/gtir_passes2/merge_stencils.py b/src/gtc/unstructured/gtir_passes2/merge_stencils.py
new file mode 100644
index 0000000..6b0e4d5
--- /dev/null
+++ b/src/gtc/unstructured/gtir_passes2/merge_stencils.py
@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+#
+# Eve Toolchain - GT4Py Project - GridTools Framework
+#
+# Copyright (c) 2020, CSCS - Swiss National Supercomputing Center, ETH Zurich
+# All rights reserved.
+#
+# This file is part of the GT4Py project and the GridTools framework.
+# GT4Py is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later
+# version. See the LICENSE.txt file at the top-level directory of this
+# distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import functools
+
+import eve
+from gtc.unstructured import gtir2
+from gtc.unstructured.gtir_passes2 import rename_location
+
+
+def _merge(lhs, rhs):
+    t = rename_location.transform(rhs.location.name, lhs.location.name)
+    return gtir2.Stencil(
+        loop_order=lhs.loop_order,
+        location=lhs.location,
+        body=lhs.body + tuple(t(e) for e in rhs.body),
+    )
+
+
+def _folder(body, cur):
+    if len(body) == 0:
+        return (cur,)
+    last = body[-1]
+    return (
+        body[0:-1] + (_merge(last, cur),)
+        if last.loop_order == cur.loop_order
+        and last.location.location_type == cur.location.location_type
+        else body + (cur,)
+    )
+
+
+class _Visitor(eve.NodeVisitor):
+    def visit_Computation(self, src: gtir2.Computation):
+        return gtir2.Computation(
+            name=src.name,
+            connectivities=src.connectivities,
+            args=src.args,
+            temporaries=src.temporaries,
+            stencils=functools.reduce(_folder, src.stencils, ()),
+        )
+
+
+transform = _Visitor().visit
diff --git a/src/gtc/unstructured/gtir_passes2/rename_location.py b/src/gtc/unstructured/gtir_passes2/rename_location.py
new file mode 100644
index 0000000..10e1ac8
--- /dev/null
+++ b/src/gtc/unstructured/gtir_passes2/rename_location.py
@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+#
+# Eve Toolchain - GT4Py Project - GridTools Framework
+#
+# Copyright (c) 2020, CSCS - Swiss National Supercomputing Center, ETH Zurich
+# All rights reserved.
+#
+# This file is part of the GT4Py project and the GridTools framework.
+# GT4Py is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later
+# version. See the LICENSE.txt file at the top-level directory of this
+# distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import eve
+from gtc.unstructured import gtir2
+
+
+class _Translator(eve.NodeTranslator):
+    def visit_FieldAccess(self, src: gtir2.FieldAccess, renamer):
+        return gtir2.FieldAccess(name=src.name, location=renamer(src.location))
+
+    def visit_SparseFieldAccess(self, src: gtir2.SparseFieldAccess, renamer):
+        return gtir2.SparseFieldAccess(
+            name=src.name, primary=renamer(src.primary), secondary=renamer(src.secondary)
+        )
+
+    def visit_SecondaryLocation(self, src: gtir2.SecondaryLocation, renamer):
+        return gtir2.SecondaryLocation(
+            name=src.name, connectivity=src.connectivity, primary=renamer(src.primary),
+        )
+
+    def visit_NeighborReduce(self, src: gtir2.NeighborReduce, **kwarg):
+        return gtir2.NeighborReduce(
+            op=src.op,
+            dtype=src.dtype,
+            location=self.visit(src.location, **kwarg),
+            body=self.visit(src.body, **kwarg),
+        )
+
+    def visit_BinaryOp(self, src: gtir2.BinaryOp, **kwarg):
+        return gtir2.BinaryOp(
+            op=src.op, left=self.visit(src.left, **kwarg), right=self.visit(src.right, **kwarg)
+        )
+
+    def visit_Assign(self, src: gtir2.Assign, **kwarg):
+        return gtir2.Assign(
+            left=self.visit(src.left, **kwarg), right=self.visit(src.right, **kwarg)
+        )
+
+
+def transform(old, new):
+    return (
+        lambda x: x
+        if old == new
+        else lambda src: _Translator().visit(src, lambda x: new if x == old else x)
+    )
diff --git a/src/gtc/unstructured/gtscript_ast2.py b/src/gtc/unstructured/gtscript_ast2.py
index e19571a..5a3ccaf 100644
--- a/src/gtc/unstructured/gtscript_ast2.py
+++ b/src/gtc/unstructured/gtscript_ast2.py
@@ -44,6 +44,7 @@ class Call(Expr):
 
 class Comprehension(Node):
     target: Union[Name, FrozenList[Name]]
+    # TODO(anstaf): rename to iter_
     iterable: Expr
 
 
diff --git a/src/gtc/unstructured/usid2.py b/src/gtc/unstructured/usid2.py
index aa8a6aa..393a24b 100644
--- a/src/gtc/unstructured/usid2.py
+++ b/src/gtc/unstructured/usid2.py
@@ -26,6 +26,7 @@ class Connectivity(Node):
     has_skip_values: Bool
 
 
+# TODO(anstaf): explain why we do not need dtype here
 class Field(Node):
     name: Str
 
@@ -64,6 +65,7 @@ class BinaryOp(Expr):
     right: Expr
 
 
+# TODO(till): discuss it with Hannes (primary, secondary)
 class NeighborReduce(Expr):
     op: ReduceOperator
     dtype: Str
diff --git a/src/gtc/unstructured/usid2_codegen.py b/src/gtc/unstructured/usid2_codegen.py
index 93dd635..0d9f196 100644
--- a/src/gtc/unstructured/usid2_codegen.py
+++ b/src/gtc/unstructured/usid2_codegen.py
@@ -99,6 +99,7 @@ def visit_Computation(self, node: usid2.Computation, **kwargs):
 
 
 def _impl(backend):
+    # TOOO(anstaf): agree on python style here
     return compose(
         lambda x: codegen.format_source("cpp", x, style="LLVM"),
         lambda x: _Generator.apply(x, backend=backend),

From 0f4728151b962e72440d8b391ffb03a9ed3e0ca6 Mon Sep 17 00:00:00 2001
From: Anton Afanasyev <anstaf@gmail.com>
Date: Mon, 9 Nov 2020 16:49:02 +0000
Subject: [PATCH 24/24] address Till comments

---
 src/gtc/unstructured/gtir_to_usid2.py   | 19 ++++----
 src/gtc/unstructured/gtscript_ast2.py   |  3 +-
 src/gtc/unstructured/py_to_gtir2.py     | 59 ++++++++++++-------------
 src/gtc/unstructured/py_to_gtscript2.py |  2 +-
 src/gtc/unstructured/usid2.py           |  2 +-
 5 files changed, 40 insertions(+), 45 deletions(-)

diff --git a/src/gtc/unstructured/gtir_to_usid2.py b/src/gtc/unstructured/gtir_to_usid2.py
index 9c044bf..42ebece 100644
--- a/src/gtc/unstructured/gtir_to_usid2.py
+++ b/src/gtc/unstructured/gtir_to_usid2.py
@@ -67,11 +67,8 @@ def visit_Assign(self, src: gtir2.Assign, **kwargs):
         return self.visit(src.left, **kwargs) | self.visit(src.right, **kwargs)
 
     def visit_Stencil(self, src: gtir2.Stencil):
-        return usid2.Composite(
-            name=src.location.name,
-            items=functools.reduce(
-                lambda acc, e: acc | self.visit(e, primary=src.location.name), src.body, set()
-            ),
+        return functools.reduce(
+            lambda acc, e: acc | self.visit(e, primary=src.location.name), src.body, set()
         )
 
 
@@ -125,10 +122,7 @@ def visit_BinaryOp(self, src: gtir2.BinaryOp):
         return _merge_dicts_of_sets(self.visit(src.left), self.visit(src.right))
 
     def visit_Stencil(self, src: gtir2.Stencil):
-        return tuple(
-            usid2.Composite(name=name, items=items)
-            for name, items in _merge_dicts_of_sets(*(self.visit(e) for e in src.body)).items()
-        )
+        return _merge_dicts_of_sets(*(self.visit(e) for e in src.body)).items()
 
 
 _extract_secondary_composites = _SecondaryCompositesExtractor().visit
@@ -163,8 +157,11 @@ def visit_Assign(self, src: gtir2.Assign):
     def visit_Stencil(self, src: gtir2.Stencil):
         return usid2.Kernel(
             location_type=_loc2str(src.location.location_type),
-            primary=_extract_primary_composite(src),
-            secondaries=_extract_secondary_composites(src),
+            primary=usid2.Composite(name=src.location.name, items=_extract_primary_composite(src)),
+            secondaries=tuple(
+                usid2.Composite(name=name, items=items)
+                for name, items in _extract_secondary_composites(src)
+            ),
             body=tuple(self.visit(e) for e in src.body),
         )
 
diff --git a/src/gtc/unstructured/gtscript_ast2.py b/src/gtc/unstructured/gtscript_ast2.py
index 5a3ccaf..e88bf67 100644
--- a/src/gtc/unstructured/gtscript_ast2.py
+++ b/src/gtc/unstructured/gtscript_ast2.py
@@ -44,8 +44,7 @@ class Call(Expr):
 
 class Comprehension(Node):
     target: Union[Name, FrozenList[Name]]
-    # TODO(anstaf): rename to iter_
-    iterable: Expr
+    iter_: Expr
 
 
 class GeneratorExp(Expr):
diff --git a/src/gtc/unstructured/py_to_gtir2.py b/src/gtc/unstructured/py_to_gtir2.py
index 9630c24..33c7152 100644
--- a/src/gtc/unstructured/py_to_gtir2.py
+++ b/src/gtc/unstructured/py_to_gtir2.py
@@ -140,7 +140,7 @@ def visit_Call(self, src: gtscript_ast2.Call, tbl, location):
         assert isinstance(target, gtscript_ast2.Name)
         secondary = gtir2.SecondaryLocation(
             name=target.name,
-            connectivity=self.visit(generator.iterable, tbl=tbl, location=location),
+            connectivity=self.visit(generator.iter_, tbl=tbl, location=location),
             primary=location.name,
         )
         body = self.visit(generator_exp.elt, tbl=tbl, location=secondary)
@@ -258,37 +258,36 @@ def folder(acc, stmt):
         body, temporaries = functools.reduce(folder, src.body, ((), ()))
         return gtir2.Stencil(loop_order=loop_order, location=location, body=body), temporaries
 
-    def visit_Function(self, src: gtscript_ast2.Function, fun_params):
-        connectivity_params = tuple(
-            p for p in fun_params if _is_conncetivity_annotation(p.annotation)
-        )
-        connectivity_type_to_name = dict((p.annotation, p.name) for p in connectivity_params)
-        if len(connectivity_params) > len(connectivity_type_to_name):
-            raise RuntimeError(
-                "the types of the conncetivities within computation should be all different"
-            )
-        connectivities = tuple(_extract_connectivity(p) for p in connectivity_params)
-        args = tuple(
-            _extract_arg(p, connectivity_type_to_name)
-            for p in fun_params
-            if not _is_conncetivity_annotation(p.annotation)
-        )
-        assert all(isinstance(s, gtscript_ast2.With) for s in src.body)
-        tbl = {e.name: e for e in connectivities + args}
 
-        def folder(acc, stmt):
-            stencil, temporaries = self.visit(stmt, tbl={**tbl, **{t.name: t for t in acc[1]}})
-            return acc[0] + (stencil,), acc[1] + temporaries
-
-        stencils, temporaries = functools.reduce(folder, src.body, ((), ()))
-        return gtir2.Computation(
-            name=src.name,
-            connectivities=connectivities,
-            args=args,
-            temporaries=temporaries,
-            stencils=stencils,
+def _transform(src: gtscript_ast2.Function, fun_params):
+    connectivity_params = tuple(p for p in fun_params if _is_conncetivity_annotation(p.annotation))
+    connectivity_type_to_name = dict((p.annotation, p.name) for p in connectivity_params)
+    if len(connectivity_params) > len(connectivity_type_to_name):
+        raise RuntimeError(
+            "the types of the conncetivities within computation should be all different"
         )
+    connectivities = tuple(_extract_connectivity(p) for p in connectivity_params)
+    args = tuple(
+        _extract_arg(p, connectivity_type_to_name)
+        for p in fun_params
+        if not _is_conncetivity_annotation(p.annotation)
+    )
+    assert all(isinstance(s, gtscript_ast2.With) for s in src.body)
+    tbl = {e.name: e for e in connectivities + args}
+
+    def folder(acc, stmt):
+        stencil, temporaries = _Visitor().visit(stmt, tbl={**tbl, **{t.name: t for t in acc[1]}})
+        return acc[0] + (stencil,), acc[1] + temporaries
+
+    stencils, temporaries = functools.reduce(folder, src.body, ((), ()))
+    return gtir2.Computation(
+        name=src.name,
+        connectivities=connectivities,
+        args=args,
+        temporaries=temporaries,
+        stencils=stencils,
+    )
 
 
 def transform(src):
-    return _Visitor().visit(py_to_gtscript2.transform(src), fun_params=_extract_params(src))
+    return _transform(py_to_gtscript2.transform(src), _extract_params(src))
diff --git a/src/gtc/unstructured/py_to_gtscript2.py b/src/gtc/unstructured/py_to_gtscript2.py
index ce46a89..a687cd3 100644
--- a/src/gtc/unstructured/py_to_gtscript2.py
+++ b/src/gtc/unstructured/py_to_gtscript2.py
@@ -81,7 +81,7 @@ def visit_GeneratorExp(self, src: ast.GeneratorExp):
 
     def visit_comprehension(self, src: ast.comprehension):
         return gtscript_ast2.Comprehension(
-            target=self.visit(src.target), iterable=self.visit(src.iter)
+            target=self.visit(src.target), iter_=self.visit(src.iter)
         )
 
     def visit_Assign(self, src: ast.Assign):
diff --git a/src/gtc/unstructured/usid2.py b/src/gtc/unstructured/usid2.py
index 393a24b..4755fe6 100644
--- a/src/gtc/unstructured/usid2.py
+++ b/src/gtc/unstructured/usid2.py
@@ -26,9 +26,9 @@ class Connectivity(Node):
     has_skip_values: Bool
 
 
-# TODO(anstaf): explain why we do not need dtype here
 class Field(Node):
     name: Str
+    # dtype is missing because it is not used in the code generation
 
 
 class SparseField(Field):