diff --git a/pyphare/pyphare/core/gridlayout.py b/pyphare/pyphare/core/gridlayout.py
index c3c69018e..ec35311ca 100644
--- a/pyphare/pyphare/core/gridlayout.py
+++ b/pyphare/pyphare/core/gridlayout.py
@@ -271,24 +271,6 @@ def physicalEndIndex(self, interpOrder, centering, nbrCells):
         )
         return index
 
-    def physicalStartIndices(self, qty):
-        assert qty in self.hybridQuantities
-        indices = np.zeros(self.box.ndim)
-        for i, direction in enumerate(directions[: self.box.ndim]):
-            centering = yee_centering[direction][qty]
-            indices[i] = self.physicalStartIndex(self.interp_order, centering)
-        return indices
-
-    def physicalEndIndices(self, qty):
-        assert qty in self.hybridQuantities
-        indices = np.zeros(self.box.ndim)
-        for i, direction in enumerate(directions[: self.box.ndim]):
-            centering = yee_centering[direction][qty]
-            indices[i] = self.physicalEndIndex(
-                self.interp_order, centering, self.box.shape[i]
-            )
-        return indices
-
     def nbrGhostFor(self, qty):
         assert qty in self.hybridQuantities
         nGhosts = np.zeros(self.box.ndim, dtype=np.int32)
@@ -329,6 +311,11 @@ def allocSizeDerived(self, interpOrder, centering, nbrCells):
         )
         return size
 
+    def localPointToAMR(self, point):
+        return (
+            point + self.box.lower - self.physicalStartIndex(self.interp_order, "dual")
+        )
+
     def AMRPointToLocal(self, point):
         return (
             point - self.box.lower + self.physicalStartIndex(self.interp_order, "dual")
diff --git a/pyphare/pyphare/pharein/__init__.py b/pyphare/pyphare/pharein/__init__.py
index 6b7356b28..e40af8ab3 100644
--- a/pyphare/pyphare/pharein/__init__.py
+++ b/pyphare/pyphare/pharein/__init__.py
@@ -166,19 +166,16 @@ def add_vector_int(path, val):
     add_string("simulation/grid/layout_type", simulation.layout)
     add_int("simulation/grid/nbr_cells/x", simulation.cells[0])
     add_double("simulation/grid/meshsize/x", simulation.dl[0])
-    add_double("simulation/grid/origin/x", simulation.origin[0])
     add_string("simulation/grid/boundary_type/x", simulation.boundary_types[0])
 
     if simulation.ndim > 1:
         add_int("simulation/grid/nbr_cells/y", simulation.cells[1])
         add_double("simulation/grid/meshsize/y", simulation.dl[1])
-        add_double("simulation/grid/origin/y", simulation.origin[1])
         add_string("simulation/grid/boundary_type/y", simulation.boundary_types[1])
 
         if simulation.ndim > 2:
             add_int("simulation/grid/nbr_cells/z", simulation.cells[2])
             add_double("simulation/grid/meshsize/z", simulation.dl[2])
-            add_double("simulation/grid/origin/z", simulation.origin[2])
             add_string("simulation/grid/boundary_type/z", simulation.boundary_types[2])
 
     add_int("simulation/interp_order", simulation.interp_order)
diff --git a/pyphare/pyphare/pharein/maxwellian_fluid_model.py b/pyphare/pyphare/pharein/maxwellian_fluid_model.py
index 0b7473b2d..fe8725c53 100644
--- a/pyphare/pyphare/pharein/maxwellian_fluid_model.py
+++ b/pyphare/pyphare/pharein/maxwellian_fluid_model.py
@@ -196,7 +196,7 @@ def validate(self, sim, atol=1e-15):
 
     def validate1d(self, sim, atol):
         domain_box = Box([0] * sim.ndim, sim.cells)
-        layout = GridLayout(domain_box, sim.origin, sim.dl, sim.interp_order)
+        layout = GridLayout(domain_box, domain_box.lower, sim.dl, sim.interp_order)
         nbrDualGhosts = layout.nbrGhostsPrimal(sim.interp_order)
         nbrPrimalGhosts = layout.nbrGhostsPrimal(sim.interp_order)
         directions = ["X"]
@@ -236,7 +236,7 @@ def validate1d(self, sim, atol):
 
     def validate2d(self, sim, atol):
         domain_box = Box([0] * sim.ndim, sim.cells)
-        layout = GridLayout(domain_box, sim.origin, sim.dl, sim.interp_order)
+        layout = GridLayout(domain_box, domain_box.lower, sim.dl, sim.interp_order)
         nbrDualGhosts = layout.nbrGhostsPrimal(sim.interp_order)
         nbrPrimalGhosts = layout.nbrGhostsPrimal(sim.interp_order)
         directions = ["X", "Y"]
diff --git a/pyphare/pyphare/pharein/simulation.py b/pyphare/pyphare/pharein/simulation.py
index 54b41b7ef..2c272aa48 100644
--- a/pyphare/pyphare/pharein/simulation.py
+++ b/pyphare/pyphare/pharein/simulation.py
@@ -295,14 +295,6 @@ def check_refined_particle_nbr(ndim, **kwargs):
 # ------------------------------------------------------------------------------
 
 
-def check_origin(ndim, **kwargs):
-    origin = kwargs.get("origin", [0.0] * ndim)
-    return origin
-
-
-# ------------------------------------------------------------------------------
-
-
 def as_list_per_level(refinement_boxes):
     """
     accepts various formats of boxes.
@@ -636,7 +628,6 @@ def wrapper(simulation_object, **kwargs):
             "time_step_nbr",
             "layout",
             "interp_order",
-            "origin",
             "boundary_types",
             "refined_particle_nbr",
             "path",
@@ -695,7 +686,6 @@ def wrapper(simulation_object, **kwargs):
         kwargs["restart_options"] = check_restart_options(**kwargs)
 
         kwargs["boundary_types"] = check_boundaries(ndim, **kwargs)
-        kwargs["origin"] = check_origin(ndim, **kwargs)
 
         kwargs["refined_particle_nbr"] = check_refined_particle_nbr(ndim, **kwargs)
         kwargs["diag_export_format"] = kwargs.get("diag_export_format", "hdf5")
@@ -850,7 +840,6 @@ class Simulation(object):
         These parameters are more advanced, modify them at your own risk
 
             * **layout** (``str``), layout of the physical quantities on the mesh (default = "yee")
-            * **origin** (``int`` or ``tuple``), origin of the physical domain, (default (0,0,0) in 3D)
 
 
     For instance:
@@ -976,7 +965,7 @@ def __init__(self, **kwargs):
         validate_restart_options(self)
 
     def simulation_domain(self):
-        return [dl * n + ori for dl, n, ori in zip(self.dl, self.cells, self.origin)]
+        return [dl * n for dl, n in zip(self.dl, self.cells)]
 
     def within_simulation_duration(self, time_period):
         return time_period[0] >= 0 and time_period[1] < self.time_step_nbr
diff --git a/src/amr/resources_manager/amr_utils.hpp b/src/amr/resources_manager/amr_utils.hpp
index 3b23afb2c..48eb36cce 100644
--- a/src/amr/resources_manager/amr_utils.hpp
+++ b/src/amr/resources_manager/amr_utils.hpp
@@ -1,12 +1,10 @@
 #ifndef PHARE_AMR_UTILS_HPP
 #define PHARE_AMR_UTILS_HPP
 
-#include "core/def/phare_mpi.hpp" // IWYU pragma: keep
-
 
 #include "core/def.hpp"
+#include "core/def/phare_mpi.hpp" // IWYU pragma: keep
 #include "core/utilities/constants.hpp"
-#include "core/utilities/point/point.hpp"
 
 #include "amr/types/amr_types.hpp"
 #include "amr/utilities/box/amr_box.hpp"
@@ -158,28 +156,13 @@ namespace amr
     {
         auto constexpr dimension = GridLayoutT::dimension;
 
-        SAMRAI::tbox::Dimension const dim{dimension};
-
         //  We get geometry information from the patch, such as meshSize, and physical origin
         auto patchGeom = std::dynamic_pointer_cast<SAMRAI::geom::CartesianPatchGeometry>(
             patch.getPatchGeometry());
-        core::Point<double, dimension> origin;
 
-        std::array<double, dimension> dl;
-
-        if (patchGeom != nullptr)
-        {
-            auto pOrigin = patchGeom->getXLower();
-            auto pDl     = patchGeom->getDx();
-
-            for (std::size_t iDim = 0; iDim < dimension; ++iDim)
-            {
-                origin[iDim] = pOrigin[iDim];
-                dl[iDim]     = pDl[iDim];
-            }
-        }
-        else
         /*
+          if(patchGeom == nullptr)
+
           We assume that this is a temporary patch used by SAMRAI for data transfers
           Temporary patches are not given a Geometry at this moment so we can't use it.
           This happens in:
@@ -187,25 +170,29 @@ namespace amr
 
           SEE: https://github.com/LLNL/SAMRAI/issues/147
         */
-        {
-            for (std::size_t iDim = 0; iDim < dimension; ++iDim)
-            {
-                origin[iDim] = 0;
-                dl[iDim]     = 1;
-            }
-        }
-
-        SAMRAI::hier::Box domain = patch.getBox();
-
-        std::array<std::uint32_t, dimension> nbrCell;
-
-        for (std::size_t iDim = 0; iDim < dimension; ++iDim)
-        {
-            nbrCell[iDim] = static_cast<std::uint32_t>(domain.numberCells(iDim));
-        }
 
-        auto lvlNbr = patch.getPatchLevelNumber();
-        return GridLayoutT{dl, nbrCell, origin, amr::Box<int, dimension>{domain}, lvlNbr};
+        auto const dl = core::for_N_make_array<dimension>([&](auto i) {
+            if (patchGeom != nullptr)
+                return patchGeom->getDx()[i];
+            return 1.0;
+        });
+
+        auto const origin = core::for_N_make_array<dimension>([&](auto i) {
+            if (patchGeom != nullptr)
+                return patchGeom->getXLower()[i];
+            return 0.0;
+        });
+
+        auto const nbrCell = core::for_N_make_array<dimension>(
+            [&](auto i) { return static_cast<std::uint32_t>(patch.getBox().numberCells(i)); });
+
+        return {
+            dl,
+            nbrCell,
+            origin, //
+            amr::Box<int, dimension>{patch.getBox()},
+            patch.getPatchLevelNumber(), //
+        };
     }
 
 
diff --git a/src/amr/wrappers/hierarchy.hpp b/src/amr/wrappers/hierarchy.hpp
index 07b2fc07f..aec20254b 100644
--- a/src/amr/wrappers/hierarchy.hpp
+++ b/src/amr/wrappers/hierarchy.hpp
@@ -94,7 +94,7 @@ class Hierarchy : public HierarchyRestarter, public SAMRAI::hier::PatchHierarchy
     NO_DISCARD auto const& boundaryConditions() const { return boundaryConditions_; }
     NO_DISCARD auto const& cellWidth() const { return cellWidth_; }
     NO_DISCARD auto const& domainBox() const { return domainBox_; }
-    NO_DISCARD auto const& origin() const { return origin_; }
+
 
 
     auto writeRestartFile(std::string directory) const;
@@ -113,14 +113,12 @@ class Hierarchy : public HierarchyRestarter, public SAMRAI::hier::PatchHierarchy
               std::shared_ptr<SAMRAI::geom::CartesianGridGeometry>&& geo,
               std::shared_ptr<SAMRAI::tbox::MemoryDatabase>&& db,
               std::array<int, dimension> const domainBox,
-              std::array<double, dimension> const origin,
               std::array<double, dimension> const cellWidth,
               std::array<std::string, dimension> const boundaryConditions);
 
 private:
     std::vector<double> const cellWidth_;
     std::vector<int> const domainBox_;
-    std::vector<double> const origin_;
     std::vector<std::string> boundaryConditions_;
 };
 
@@ -204,7 +202,6 @@ Hierarchy::Hierarchy(initializer::PHAREDict const& dict,
                      std::shared_ptr<SAMRAI::geom::CartesianGridGeometry>&& geo,
                      std::shared_ptr<SAMRAI::tbox::MemoryDatabase>&& db,
                      std::array<int, dimension> const domainBox,
-                     std::array<double, dimension> const origin,
                      std::array<double, dimension> const cellWidth,
                      std::array<std::string, dimension> const boundaryConditions)
     // needs to open restart database before SAMRAI::PatchHierarcy constructor
@@ -212,7 +209,6 @@ Hierarchy::Hierarchy(initializer::PHAREDict const& dict,
     , SAMRAI::hier::PatchHierarchy{"PHARE_hierarchy", geo, db}
     , cellWidth_(cellWidth.data(), cellWidth.data() + dimension)
     , domainBox_(domainBox.data(), domainBox.data() + dimension)
-    , origin_(origin.data(), origin.data() + dimension)
     , boundaryConditions_(boundaryConditions.data(), boundaryConditions.data() + dimension)
 {
 }
@@ -264,11 +260,10 @@ void getDomainCoords(PHARE::initializer::PHAREDict const& grid, double lower[dim
 
     auto nbr_cells = parseDimXYZType<int, dimension>(grid, "nbr_cells");
     auto mesh_size = parseDimXYZType<double, dimension>(grid, "meshsize");
-    auto origin    = parseDimXYZType<double, dimension>(grid, "origin");
 
     for (std::size_t i = 0; i < dimension; i++)
     {
-        lower[i] = origin[i];
+        lower[i] = 0;
         upper[i] = lower[i] + nbr_cells[i] * mesh_size[i];
     }
 }
@@ -400,7 +395,6 @@ DimHierarchy<_dimension>::DimHierarchy(PHARE::initializer::PHAREDict const& dict
               griddingAlgorithmDatabase<dimension>(dict["simulation"]["grid"])),
           patchHierarchyDatabase<dimension>(dict["simulation"]["AMR"]),
           shapeToBox(parseDimXYZType<int, dimension>(dict["simulation"]["grid"], "nbr_cells")),
-          parseDimXYZType<double, dimension>(dict["simulation"]["grid"], "origin"),
           parseDimXYZType<double, dimension>(dict["simulation"]["grid"], "meshsize"),
           parseDimXYZType<std::string, dimension>(dict["simulation"]["grid"], "boundary_type")}
 {
diff --git a/src/core/data/field/initializers/field_user_initializer.hpp b/src/core/data/field/initializers/field_user_initializer.hpp
index d9c74275a..c8fca0bb7 100644
--- a/src/core/data/field/initializers/field_user_initializer.hpp
+++ b/src/core/data/field/initializers/field_user_initializer.hpp
@@ -3,9 +3,11 @@
 
 #include "core/utilities/span.hpp"
 #include "initializer/data_provider.hpp"
+#include "core/utilities/point/point.hpp"
 
 #include <tuple>
 #include <memory>
+#include <cassert>
 
 namespace PHARE::core
 {
@@ -16,10 +18,10 @@ class FieldUserFunctionInitializer
     void static initialize(Field& field, GridLayout const& layout,
                            initializer::InitFunction<GridLayout::dimension> const& init)
     {
-        auto const indices = layout.ghostStartToEndIndices(field, /*includeEnd=*/true);
+        auto const indices = layout.indices(layout.AMRGhostBoxFor(field));
         auto const coords  = layout.template indexesToCoordVectors</*WithField=*/true>(
             indices, field, [](auto& gridLayout, auto& field_, auto const&... args) {
-                return gridLayout.fieldNodeCoordinates(field_, gridLayout.origin(), args...);
+                return gridLayout.fieldNodeCoordinates(field_, args...);
             });
 
         std::shared_ptr<Span<double>> gridPtr // keep grid data alive
@@ -27,7 +29,9 @@ class FieldUserFunctionInitializer
         Span<double>& grid = *gridPtr;
 
         for (std::size_t cell_idx = 0; cell_idx < indices.size(); cell_idx++)
-            std::apply([&](auto&... args) { field(args...) = grid[cell_idx]; }, indices[cell_idx]);
+            std::apply(
+                [&](auto&... args) { field(layout.AMRToLocal(Point{args...})) = grid[cell_idx]; },
+                indices[cell_idx]);
     }
 };
 
diff --git a/src/core/data/grid/gridlayout.hpp b/src/core/data/grid/gridlayout.hpp
index 0440ebe6c..0aee24142 100644
--- a/src/core/data/grid/gridlayout.hpp
+++ b/src/core/data/grid/gridlayout.hpp
@@ -227,30 +227,19 @@ namespace core
 
 
 
-        template<typename Centering>
-        NO_DISCARD auto physicalStartToEndIndices(Centering const& centering,
-                                                  bool const includeEnd = false) const
-        {
-            return StartToEndIndices_(
-                centering,
-                [&](auto const& centering_, auto const direction) {
-                    return this->physicalStartToEnd(centering_, direction);
-                },
-                includeEnd);
-        }
 
-        template<typename Centering>
-        NO_DISCARD auto ghostStartToEndIndices(Centering const& centering,
-                                               bool const includeEnd = false) const
+        template<typename T>
+        NO_DISCARD auto indices(Box<T, dimension> const& box) const
         {
-            return StartToEndIndices_(
-                centering,
-                [&](auto const& centering_, auto const direction) {
-                    return this->ghostStartToEnd(centering_, direction);
+            return generate(
+                [](auto const& amr_idx) -> tuple_fixed_type<T, dimension> {
+                    return for_N<dimension>([&](auto i) { return amr_idx[i]; });
                 },
-                includeEnd);
+                box);
         }
 
+
+
         template<bool WithField, typename Centering, typename CoordsFn, typename... Indexes>
         NO_DISCARD auto inline indexesToCoords([[maybe_unused]] Centering const& centering,
                                                CoordsFn const& coordsFn,
@@ -304,8 +293,8 @@ namespace core
         NO_DISCARD std::uint32_t physicalStartIndex(QtyCentering centering,
                                                     Direction direction) const
         {
-            std::uint32_t icentering = static_cast<std::uint32_t>(centering);
-            std::uint32_t iDir       = static_cast<std::uint32_t>(direction);
+            auto const icentering = static_cast<std::uint32_t>(centering);
+            auto const iDir       = static_cast<std::uint32_t>(direction);
             return physicalStartIndexTable_[icentering][iDir];
         }
 
@@ -314,11 +303,10 @@ namespace core
         NO_DISCARD std::uint32_t physicalStartIndex(HybridQuantity::Scalar const& hybridQuantity,
                                                     Direction direction) const
         {
-            std::uint32_t iQty                 = static_cast<std::uint32_t>(hybridQuantity);
-            std::uint32_t iDir                 = static_cast<std::uint32_t>(direction);
-            constexpr auto& hybridQtyCentering = GridLayoutImpl::hybridQtyCentering_;
-            std::uint32_t iCentering = static_cast<std::uint32_t>(hybridQtyCentering[iQty][iDir]);
-
+            constexpr auto hybridQtyCentering = GridLayoutImpl::hybridQtyCentering_;
+            auto const iQty                   = static_cast<std::uint32_t>(hybridQuantity);
+            auto const iDir                   = static_cast<std::uint32_t>(direction);
+            auto const iCentering = static_cast<std::uint32_t>(hybridQtyCentering[iQty][iDir]);
             return physicalStartIndexTable_[iCentering][iDir];
         }
 
@@ -463,32 +451,23 @@ namespace core
          * @brief fieldNodeCoordinates returns the coordinate of a multidimensional index
          * associated with a given Field, in physical coordinates.
          */
-        template<typename Field_t, typename... Indexes>
+        template<typename Field_t>
         NO_DISCARD Point<double, dimension>
-        fieldNodeCoordinates(Field_t const& field, Point<double, dimension> const& origin,
-                             Indexes... index) const
+        fieldNodeCoordinates(Field_t const& field, Point<int, dimension> amr_idx) const
         {
-            static_assert(sizeof...(Indexes) == dimension,
-                          "Error dimension does not match number of arguments");
-
-
-            std::uint32_t iQuantity       = static_cast<std::uint32_t>(field.physicalQuantity());
             constexpr std::uint32_t iDual = static_cast<std::uint32_t>(QtyCentering::dual);
 
-
+            auto const iQuantity = static_cast<std::uint32_t>(field.physicalQuantity());
             constexpr auto& hybridQtyCentering = GridLayoutImpl::hybridQtyCentering_;
 
-            Point<std::int32_t, dimension> coord{static_cast<std::int32_t>(index)...};
-
             Point<double, dimension> position;
 
             for (std::size_t iDir = 0; iDir < dimension; ++iDir)
             {
-                double halfCell = 0.0;
-
                 auto const centering
                     = static_cast<std::uint32_t>(hybridQtyCentering[iQuantity][iDir]);
-                std::int32_t const iStart = physicalStartIndexTable_[centering][iDir];
+
+                double const halfCell = centering == iDual ? 0.5 : 0.0;
 
                 // A shift of +dx/2, +dy/2, +dz/2 is necessary to get the physical
                 // coordinate on the dual mesh
@@ -499,53 +478,56 @@ namespace core
                 // if ix is dual   then ixStart is dual
                 // if iy is primal then iyStart is primal ...
 
-                if (centering == iDual)
-                {
-                    halfCell = 0.5;
-                }
-
-                position[iDir]
-                    = (static_cast<double>(coord[iDir] - iStart) + halfCell) * meshSize_[iDir]
-                      + origin[iDir];
+                position[iDir] = (static_cast<double>(amr_idx[iDir]) + halfCell) * meshSize_[iDir];
             }
 
             return position;
         }
 
+        template<typename Field_t, typename... Indexes>
+        NO_DISCARD Point<double, dimension> fieldNodeCoordinates(Field_t const& field,
+                                                                 Indexes... index) const
+        {
+            static_assert(sizeof...(Indexes) == dimension,
+                          "Error dimension does not match number of arguments");
+
+            return fieldNodeCoordinates(field, Point<int, dimension>{index...});
+        }
+
 
         /**
          * @brief cellCenteredCoordinates returns the coordinates in physical units
          * of a multidimensional index that is cell-centered.
          */
-        template<typename... Indexes>
-        NO_DISCARD Point<double, dimension> cellCenteredCoordinates(Indexes... index) const
+        NO_DISCARD Point<double, dimension>
+        cellCenteredCoordinates(Point<int, dimension> coord) const
         {
-            static_assert(sizeof...(Indexes) == dimension,
-                          "Error dimension does not match number of arguments");
-
-            std::uint32_t constexpr iPrimal = static_cast<std::uint32_t>(QtyCentering::primal);
-
             constexpr double halfCell = 0.5;
+
             // A shift of +dx/2, +dy/2, +dz/2 is necessary to get the
             // cell center physical coordinates,
             // because this point is located on the dual mesh
 
-            Point<std::uint32_t, dimension> coord(index...);
 
             Point<double, dimension> physicalPosition;
 
             for (std::size_t iDir = 0; iDir < dimension; ++iDir)
-            {
-                auto iStart = physicalStartIndexTable_[iPrimal][iDir];
-
                 physicalPosition[iDir]
-                    = (static_cast<double>(coord[iDir] - iStart) + halfCell) * meshSize_[iDir]
-                      + origin_[iDir];
-            }
+                    = (static_cast<double>(coord[iDir]) + halfCell) * meshSize_[iDir];
+
 
             return physicalPosition;
         }
 
+        template<typename... Indexes>
+        NO_DISCARD Point<double, dimension> cellCenteredCoordinates(Indexes... index) const
+        {
+            static_assert(sizeof...(Indexes) == dimension,
+                          "Error dimension does not match number of arguments");
+
+            return cellCenteredCoordinates(Point<int, dimension>{index...});
+        }
+
 
 
         /**
@@ -807,7 +789,7 @@ namespace core
             Point<std::uint32_t, dimension> localPoint;
 
             // any direction, it's the same because we want cells
-            auto localStart = physicalStartIndex(QtyCentering::dual, Direction::X);
+            auto const localStart = physicalStartIndex(QtyCentering::dual, Direction::X);
 
             //
             for (auto i = 0u; i < dimension; ++i)
@@ -897,6 +879,7 @@ namespace core
             return GridLayoutImpl::centering(hybridQuantity);
         }
 
+
         NO_DISCARD constexpr static std::array<std::array<QtyCentering, dimension>, 6>
         centering(HybridQuantity::Tensor hybridQuantity)
         {
@@ -904,6 +887,15 @@ namespace core
                 [](auto) { return ConstArray<QtyCentering, dimension>(QtyCentering::primal); });
         }
 
+        template<typename HasQuantity>
+        NO_DISCARD constexpr static auto centering(HasQuantity const& hasQuantity)
+            requires(has_physicalQuantity_v<HasQuantity>)
+        {
+            return centering(hasQuantity.physicalQuantity());
+        }
+
+
+
         /**
          * @brief GridLayout<GridLayoutImpl::dim>::allocSize
          * @return An std::array<std::uint32_t, dim> object, containing the size to which allocate
@@ -1165,8 +1157,8 @@ namespace core
 
 
 
-        template<typename Field>
-        auto AMRGhostBoxFor(Field const& field) const
+
+        auto AMRGhostBoxFor(auto const& field) const
         {
             auto const centerings = centering(field);
             auto const growBy     = [&]() {
@@ -1181,7 +1173,13 @@ namespace core
             return ghostBox;
         }
 
-
+        auto AMRBoxFor(auto const& field) const
+        {
+            auto const centerings = centering(field);
+            return grow(AMRGhostBoxFor(field), for_N_make_array<dimension>([&](auto i) {
+                            return -1 * nbrGhosts(centerings[i]);
+                        }));
+        }
 
         template<typename Field, typename Fn>
         void evalOnBox(Field& field, Fn&& fn) const
@@ -1263,46 +1261,6 @@ namespace core
         }
 
 
-        template<typename Centering, typename StartToEnd>
-        auto StartToEndIndices_(Centering const& centering, StartToEnd const&& startToEnd,
-                                bool const includeEnd = false) const
-        {
-            std::vector<tuple_fixed_type<std::uint32_t, dimension>> indices;
-
-            std::size_t plus = (includeEnd) ? 1 : 0;
-
-            auto const [ix0, ix1] = startToEnd(centering, Direction::X);
-
-            for (auto ix = ix0; ix < ix1 + plus; ++ix)
-            {
-                if constexpr (dimension > 1)
-                {
-                    auto const [iy0, iy1] = startToEnd(centering, Direction::Y);
-
-                    for (auto iy = iy0; iy < iy1 + plus; ++iy)
-                    {
-                        if constexpr (dimension > 2)
-                        {
-                            auto const [iz0, iz1] = startToEnd(centering, Direction::Z);
-
-                            for (auto iz = iz0; iz < iz1 + plus; ++iz)
-                                indices.emplace_back(std::make_tuple(ix, iy, iz));
-                        }
-                        else // 2D
-                        {
-                            indices.emplace_back(std::make_tuple(ix, iy));
-                        }
-                    }
-                }
-                else // 1D
-                {
-                    indices.emplace_back(std::make_tuple(ix));
-                }
-            }
-            return indices;
-        }
-
-
 
 
         /**
@@ -1558,6 +1516,51 @@ namespace core
 
 
 
+        struct AMRLocalIndexer //
+        {
+            GridLayout const* layout;
+            Box<int, dimension> amr_box;
+            Box<std::uint32_t, dimension> lcl_box = layout->AMRToLocal(amr_box);
+
+            struct iterator
+            {
+                void operator++()
+                {
+                    ++amr_it;
+                    ++lcl_it;
+                }
+                auto operator*() { return std::forward_as_tuple(*amr_it, *lcl_it); }
+                auto operator==(auto const& that) const
+                {
+                    return amr_it == that.amr_it and lcl_it == that.lcl_it;
+                }
+                auto operator!=(auto const& that) const
+                {
+                    return amr_it != that.amr_it or lcl_it != that.lcl_it;
+                }
+
+                AMRLocalIndexer const* amr_lcl_indexer;
+                box_iterator<int, dimension> amr_it;
+                box_iterator<std::uint32_t, dimension> lcl_it;
+            };
+
+            auto begin() const { return iterator{this, amr_box.begin(), lcl_box.begin()}; }
+            auto end() const { return iterator{this, amr_box.end(), lcl_box.end()}; }
+        };
+
+    public:
+        auto amr_lcl_idx(auto const& box) const { return AMRLocalIndexer{this, box}; }
+        auto amr_lcl_idx() const { return amr_lcl_idx(AMRBox()); }
+        auto domain_amr_lcl_idx(auto const& field) const
+        {
+            return AMRLocalIndexer{this, AMRBoxFor(field)};
+        }
+        auto ghost_amr_lcl_idx(auto const& field) const
+        {
+            return AMRLocalIndexer{this, AMRGhostBoxFor(field)};
+        }
+
+    private:
         std::array<double, dimension> meshSize_;
         Point<double, dimension> origin_;
         std::array<std::uint32_t, dimension> nbrPhysicalCells_;
diff --git a/src/core/data/ions/particle_initializers/maxwellian_particle_initializer.hpp b/src/core/data/ions/particle_initializers/maxwellian_particle_initializer.hpp
index 49098af06..ed94e1531 100644
--- a/src/core/data/ions/particle_initializers/maxwellian_particle_initializer.hpp
+++ b/src/core/data/ions/particle_initializers/maxwellian_particle_initializer.hpp
@@ -138,31 +138,19 @@ template<typename ParticleArray, typename GridLayout>
 void MaxwellianParticleInitializer<ParticleArray, GridLayout>::loadParticles(
     ParticleArray& particles, GridLayout const& layout) const
 {
-    auto point = [](std::size_t i, auto const& indices) -> core::Point<std::uint32_t, dimension> {
-        if constexpr (dimension == 1)
-            return {std::get<0>(indices[i])};
-        if constexpr (dimension == 2)
-            return {std::get<0>(indices[i]), std::get<1>(indices[i])};
-        if constexpr (dimension == 3)
-            return {std::get<0>(indices[i]), std::get<1>(indices[i]), std::get<2>(indices[i])};
+    auto const icell = [](auto const idx, auto const& indices) {
+        return for_N_make_array<dimension>([&](auto i) { return std::get<i>(indices[idx]); });
     };
 
-
-    auto deltas = [](auto& pos, auto& gen) -> std::array<double, dimension> {
-        if constexpr (dimension == 1)
-            return {pos(gen)};
-        if constexpr (dimension == 2)
-            return {pos(gen), pos(gen)};
-        if constexpr (dimension == 3)
-            return {pos(gen), pos(gen), pos(gen)};
+    auto const deltas = [](auto& pos, auto& gen) {
+        return for_N_make_array<dimension>([&](auto) { return pos(gen); });
     };
 
-
     // in the following two calls,
     // primal indexes are given here because that's what cellCenteredCoordinates takes
 
-    // indices = std::vector<std::tuple<std::uint32_t, per dim>>
-    auto ndCellIndices = layout.physicalStartToEndIndices(QtyCentering::primal);
+    // indices = std::vector<std::tuple<int, per dim>>
+    auto const ndCellIndices = layout.indices(layout.AMRBox());
 
     // coords = std::tuple<std::vector<double>,  per dim>
     auto cellCoords = layout.indexesToCoordVectors(
@@ -183,9 +171,8 @@ void MaxwellianParticleInitializer<ParticleArray, GridLayout>::loadParticles(
         if (n[flatCellIdx] < densityCutOff_)
             continue;
 
-        auto const cellWeight   = n[flatCellIdx] / nbrParticlePerCell_;
-        auto const AMRCellIndex = layout.localToAMR(point(flatCellIdx, ndCellIndices));
-        auto const iCell        = AMRCellIndex.template toArray<int>();
+        auto const cellWeight = n[flatCellIdx] / nbrParticlePerCell_;
+        auto const iCell      = icell(flatCellIdx, ndCellIndices);
         std::array<double, 3> particleVelocity;
         std::array<std::array<double, 3>, 3> basis;
 
diff --git a/src/core/data/particles/particle_utilities.hpp b/src/core/data/particles/particle_utilities.hpp
index cdbc4e097..3a67b70a0 100644
--- a/src/core/data/particles/particle_utilities.hpp
+++ b/src/core/data/particles/particle_utilities.hpp
@@ -20,17 +20,11 @@ NO_DISCARD auto positionAsPoint(Particle<GridLayout::dimension> const& particle,
                                 GridLayout const& layout)
 {
     Point<double, GridLayout::dimension> position;
-    auto origin       = layout.origin();
-    auto startIndexes = layout.physicalStartIndex(QtyCentering::primal);
-    auto meshSize     = layout.meshSize();
-    auto iCell        = layout.AMRToLocal(Point{particle.iCell});
 
+    auto const meshSize = layout.meshSize();
     for (auto iDim = 0u; iDim < GridLayout::dimension; ++iDim)
-    {
-        position[iDim] = origin[iDim];
-        position[iDim]
-            += (iCell[iDim] - startIndexes[iDim] + particle.delta[iDim]) * meshSize[iDim];
-    }
+        position[iDim] = (particle.iCell[iDim] + particle.delta[iDim]) * meshSize[iDim];
+
     return position;
 }
 
diff --git a/src/core/utilities/box/box.hpp b/src/core/utilities/box/box.hpp
index 2d6c49f50..6e55d5196 100644
--- a/src/core/utilities/box/box.hpp
+++ b/src/core/utilities/box/box.hpp
@@ -25,6 +25,7 @@ class box_iterator;
 template<typename Type, std::size_t dim>
 struct Box
 {
+    using value_type                = Type;
     static constexpr auto dimension = dim;
 
 
@@ -137,7 +138,6 @@ struct Box
             return iterator{this, {upper[0] + 1, upper[1] + 1, upper[2] + 1}};
         }
     }
-    using value_type = Type;
 
 
     NO_DISCARD constexpr static std::size_t nbrRemainBoxes()
diff --git a/src/core/utilities/point/point.hpp b/src/core/utilities/point/point.hpp
index f812bc1f7..2fdb79d05 100644
--- a/src/core/utilities/point/point.hpp
+++ b/src/core/utilities/point/point.hpp
@@ -216,14 +216,28 @@ namespace core
 
         NO_DISCARD auto& operator*() const { return r; }
 
+
+
+        template<typename To>
+        auto as() const
+        {
+            return Point<To, dim>{this->template toArray<To>()};
+        }
+
         auto as_unsigned() const
         {
             for (auto iDim = 0u; iDim < dim; ++iDim)
                 if (r[iDim] < 0)
                     throw std::runtime_error("Cannot make unsigned from negative values");
+            if constexpr (sizeof(Type) == 4)
+                return as<std::uint32_t>();
+            // else no return cause not yet handled
+        }
 
+        auto as_signed() const
+        {
             if constexpr (sizeof(Type) == 4)
-                return Point<std::uint32_t, dim>{this->template toArray<std::uint32_t>()};
+                return as<std::int32_t>();
             // else no return cause not yet handled
         }
 
diff --git a/src/core/utilities/types.hpp b/src/core/utilities/types.hpp
index f4313a595..806a8e940 100644
--- a/src/core/utilities/types.hpp
+++ b/src/core/utilities/types.hpp
@@ -481,6 +481,7 @@ constexpr auto for_N(Fn&& fn)
     return for_N<N, M>(fn);
 }
 
+
 template<std::uint16_t N, typename Fn>
 constexpr auto for_N_make_array(Fn&& fn)
 {
diff --git a/src/diagnostic/diagnostic_model_view.hpp b/src/diagnostic/diagnostic_model_view.hpp
index fca5e359b..e6edd8d1c 100644
--- a/src/diagnostic/diagnostic_model_view.hpp
+++ b/src/diagnostic/diagnostic_model_view.hpp
@@ -100,7 +100,7 @@ class BaseModelView : public IModelView
 
     NO_DISCARD auto boundaryConditions() const { return hierarchy_.boundaryConditions(); }
     NO_DISCARD auto domainBox() const { return hierarchy_.domainBox(); }
-    NO_DISCARD auto origin() const { return hierarchy_.origin(); }
+    NO_DISCARD auto origin() const { return std::vector<double>(dimension, 0); }
     NO_DISCARD auto cellWidth() const { return hierarchy_.cellWidth(); }
 
     NO_DISCARD std::string getLayoutTypeString() const
diff --git a/tests/amr/data/field/copy_pack/field_data_test_param.hpp b/tests/amr/data/field/copy_pack/field_data_test_param.hpp
index ab5b64d92..30b30342d 100644
--- a/tests/amr/data/field/copy_pack/field_data_test_param.hpp
+++ b/tests/amr/data/field/copy_pack/field_data_test_param.hpp
@@ -91,8 +91,7 @@ struct FieldDataTestParam
         auto& sourceLayout = sourceFieldData->gridLayout;
         auto& sourceField  = sourceFieldData->field;
 
-        auto origin   = sourceLayout.origin();
-        auto position = sourceLayout.fieldNodeCoordinates(sourceField, origin, iCell);
+        auto const position = sourceLayout.fieldNodeCoordinates(sourceField, iCell);
 
         return std::cos(position[0]);
     }
@@ -107,8 +106,7 @@ struct FieldDataTestParam
         auto& destinationLayout = destinationFieldData->gridLayout;
         auto& destinationField  = destinationFieldData->field;
 
-        auto origin   = destinationLayout.origin();
-        auto position = destinationLayout.fieldNodeCoordinates(destinationField, origin, iCell);
+        auto const position = destinationLayout.fieldNodeCoordinates(destinationField, iCell);
 
         return std::sin(position[0]);
     }
diff --git a/tests/amr/data/field/refine/test_tag_strategy.hpp b/tests/amr/data/field/refine/test_tag_strategy.hpp
index b37976b93..596cb5e33 100644
--- a/tests/amr/data/field/refine/test_tag_strategy.hpp
+++ b/tests/amr/data/field/refine/test_tag_strategy.hpp
@@ -177,55 +177,11 @@ class TagStrategy : public SAMRAI::mesh::StandardTagAndInitStrategy
                     auto& layout = fieldData->gridLayout;
                     auto& field  = fieldData->field;
 
-                    if constexpr (dim == 1)
+                    for (auto const amr_idx : layout.AMRGhostBoxFor(field))
                     {
-                        std::uint32_t gsi_X = layout.ghostStartIndex(field, Direction::X);
-                        std::uint32_t gei_X = layout.ghostEndIndex(field, Direction::X);
-
-                        for (std::uint32_t ix = gsi_X; ix <= gei_X; ++ix)
-                        {
-                            auto position = layout.fieldNodeCoordinates(field, layout.origin(), ix);
-                            field(ix)     = affineFill(position, dataId);
-                        }
-                    }
-                    if constexpr (dim == 2)
-                    {
-                        std::uint32_t gsi_X = layout.ghostStartIndex(field, Direction::X);
-                        std::uint32_t gei_X = layout.ghostEndIndex(field, Direction::X);
-                        std::uint32_t gsi_Y = layout.ghostStartIndex(field, Direction::Y);
-                        std::uint32_t gei_Y = layout.ghostEndIndex(field, Direction::Y);
-
-                        for (std::uint32_t ix = gsi_X; ix <= gei_X; ++ix)
-                        {
-                            for (std::uint32_t iy = gsi_Y; iy <= gei_Y; ++iy)
-                            {
-                                auto position
-                                    = layout.fieldNodeCoordinates(field, layout.origin(), ix, iy);
-                                field(ix, iy) = affineFill(position, dataId);
-                            }
-                        }
-                    }
-                    if constexpr (dim == 3)
-                    {
-                        std::uint32_t gsi_X = layout.ghostStartIndex(field, Direction::X);
-                        std::uint32_t gei_X = layout.ghostEndIndex(field, Direction::X);
-                        std::uint32_t gsi_Y = layout.ghostStartIndex(field, Direction::Y);
-                        std::uint32_t gei_Y = layout.ghostEndIndex(field, Direction::Y);
-                        std::uint32_t gsi_Z = layout.ghostStartIndex(field, Direction::Z);
-                        std::uint32_t gei_Z = layout.ghostEndIndex(field, Direction::Z);
-
-                        for (std::uint32_t ix = gsi_X; ix <= gei_X; ++ix)
-                        {
-                            for (std::uint32_t iy = gsi_Y; iy <= gei_Y; ++iy)
-                            {
-                                for (std::uint32_t iz = gsi_Z; iz <= gei_Z; ++iz)
-                                {
-                                    auto position = layout.fieldNodeCoordinates(
-                                        field, layout.origin(), ix, iy, iz);
-                                    field(ix, iy, iz) = affineFill(position, dataId);
-                                }
-                            }
-                        }
+                        auto position      = layout.fieldNodeCoordinates(field, amr_idx);
+                        auto const lcl_idx = layout.AMRToLocal(amr_idx);
+                        field(lcl_idx)     = affineFill(position, dataId);
                     }
                 }
             }
diff --git a/tests/amr/data/field/time_interpolate/test_field_data_time_interpolate.cpp b/tests/amr/data/field/time_interpolate/test_field_data_time_interpolate.cpp
index 79e6824ea..d5200ab6d 100644
--- a/tests/amr/data/field/time_interpolate/test_field_data_time_interpolate.cpp
+++ b/tests/amr/data/field/time_interpolate/test_field_data_time_interpolate.cpp
@@ -81,8 +81,8 @@ struct aFieldLinearTimeInterpolate : public ::testing::Test
         , srcNew{std::make_shared<FieldDataT>(domain, ghost, fieldName, dl, nbrCells, origin, qty)}
         , destNew{std::make_shared<FieldDataT>(domain, ghost, fieldName, dl, nbrCells, origin, qty)}
     {
-        double oldTime = 0.;
-        double newTime = 0.5;
+        double const oldTime = 0.;
+        double const newTime = 0.5;
 
         srcOld->setTime(oldTime);
         srcNew->setTime(newTime);
@@ -91,67 +91,32 @@ struct aFieldLinearTimeInterpolate : public ::testing::Test
         auto& srcFieldOld = srcOld->field;
         auto& srcFieldNew = srcNew->field;
 
-
-        if constexpr (dim == 1)
+        for (auto const amr_idx : layout.AMRGhostBoxFor(qty))
         {
-            auto iStartX = layout.ghostStartIndex(qty, Direction::X);
-            auto iEndX   = layout.ghostEndIndex(qty, Direction::X);
+            auto const position = layout.fieldNodeCoordinates(srcFieldOld, amr_idx);
+            auto const lcl_idx  = layout.AMRToLocal(amr_idx);
 
-            for (auto ix = iStartX; ix <= iEndX; ++ix)
+            if constexpr (dim == 1)
             {
-                auto position = layout.fieldNodeCoordinates(srcFieldOld, origin, ix);
-
-                srcFieldOld(ix) = srcFunc(oldTime, position[dirX]);
-                srcFieldNew(ix) = srcFunc(newTime, position[dirX]);
+                srcFieldOld(lcl_idx) = srcFunc(oldTime, position[dirX]);
+                srcFieldNew(lcl_idx) = srcFunc(newTime, position[dirX]);
             }
-        }
-        if constexpr (dim == 2)
-        {
-            auto iStartX = layout.ghostStartIndex(qty, Direction::X);
-            auto iEndX   = layout.ghostEndIndex(qty, Direction::X);
-            auto iStartY = layout.ghostStartIndex(qty, Direction::Y);
-            auto iEndY   = layout.ghostEndIndex(qty, Direction::Y);
-
-            for (auto ix = iStartX; ix <= iEndX; ++ix)
+            if constexpr (dim == 2)
             {
-                for (auto iy = iStartY; iy <= iEndY; ++iy)
-                {
-                    auto position = layout.fieldNodeCoordinates(srcFieldOld, origin, ix, iy);
-
-                    srcFieldOld(ix, iy) = srcFunc(oldTime, position[dirX], position[dirY]);
-                    srcFieldNew(ix, iy) = srcFunc(newTime, position[dirX], position[dirY]);
-                }
+                srcFieldOld(lcl_idx) = srcFunc(oldTime, position[dirX], position[dirY]);
+                srcFieldNew(lcl_idx) = srcFunc(newTime, position[dirX], position[dirY]);
             }
-        }
-        if constexpr (dim == 3)
-        {
-            auto iStartX = layout.ghostStartIndex(qty, Direction::X);
-            auto iEndX   = layout.ghostEndIndex(qty, Direction::X);
-            auto iStartY = layout.ghostStartIndex(qty, Direction::Y);
-            auto iEndY   = layout.ghostEndIndex(qty, Direction::Y);
-            auto iStartZ = layout.ghostStartIndex(qty, Direction::Z);
-            auto iEndZ   = layout.ghostEndIndex(qty, Direction::Z);
-
-            for (auto ix = iStartX; ix <= iEndX; ++ix)
+            if constexpr (dim == 3)
             {
-                for (auto iy = iStartY; iy <= iEndY; ++iy)
-                {
-                    for (auto iz = iStartZ; iz <= iEndZ; ++iz)
-                    {
-                        auto position
-                            = layout.fieldNodeCoordinates(srcFieldOld, origin, ix, iy, iz);
-
-                        srcFieldOld(ix, iy, iz)
-                            = srcFunc(oldTime, position[dirX], position[dirY], position[dirZ]);
-                        srcFieldNew(ix, iy, iz)
-                            = srcFunc(newTime, position[dirX], position[dirY], position[dirZ]);
-                    }
-                }
+                srcFieldOld(lcl_idx)
+                    = srcFunc(oldTime, position[dirX], position[dirY], position[dirZ]);
+                srcFieldNew(lcl_idx)
+                    = srcFunc(newTime, position[dirX], position[dirY], position[dirZ]);
             }
         }
     }
 
-    auto zeroTransformation()
+    auto zeroTransformation() const
     {
         return SAMRAI::hier::Transformation(SAMRAI::hier::Transformation::NO_ROTATE,
                                             SAMRAI::hier::IntVector::getZero(dimension),
@@ -177,7 +142,7 @@ int aFieldLinearTimeInterpolate<TypeInfo>::countLocal = 0;
 
 TYPED_TEST(aFieldLinearTimeInterpolate, giveOldSrcForAlphaZero)
 {
-    double interpolateTime = 0.;
+    double const interpolateTime = 0.;
     this->destNew->setTime(interpolateTime);
 
     auto& layout      = this->srcOld->gridLayout;
@@ -342,90 +307,38 @@ TYPED_TEST(aFieldLinearTimeInterpolate, giveNewSrcForAlphaOne)
 
 TYPED_TEST(aFieldLinearTimeInterpolate, giveEvaluationOnTheInterpolateTimeForLinear)
 {
-    double interpolateTime = 0.2;
+    static constexpr auto dim = typename TypeParam::first_type{}();
+
+    double const interpolateTime = 0.2;
     this->destNew->setTime(interpolateTime);
 
     auto& layout    = this->srcOld->gridLayout;
     auto& destField = this->destNew->field;
 
-    auto zero_transformation{this->zeroTransformation()};
     SAMRAI::hier::BoxContainer ghost_cntnr;
-    FieldOverlap overlap{ghost_cntnr, zero_transformation};
+    FieldOverlap overlap{ghost_cntnr, this->zeroTransformation()};
 
     this->timeOp.timeInterpolate(*(this->destNew), this->domain, overlap, *(this->srcOld),
                                  *(this->srcNew));
 
-
-    static constexpr auto dim    = typename TypeParam::first_type{}();
-    static constexpr auto interp = typename TypeParam::second_type{}();
-
-    using GridYee = GridLayout<GridLayoutImplYee<dim, interp>>;
-
-    auto box = FieldGeometry<GridYee, HybridQuantity::Scalar>::toFieldBox(this->domain, this->qty,
-                                                                          layout);
-
-    auto ghostBox_{this->domain};
-    ghostBox_.grow(SAMRAI::hier::IntVector{SAMRAI::tbox::Dimension{dim},
-                                           static_cast<int>(GridYee::nbrGhosts())});
-    auto ghostBox
-        = FieldGeometry<GridYee, HybridQuantity::Scalar>::toFieldBox(ghostBox_, this->qty, layout);
-
-    auto localBox = AMRToLocal(static_cast<std::add_const_t<decltype(box)>>(box), ghostBox);
-
-
-    if constexpr (dim == 1)
+    for (auto const [amr_idx, lcl_idx] : layout.domain_amr_lcl_idx(destField))
     {
-        auto iStartX = localBox.lower(dirX);
-        auto iEndX   = localBox.upper(dirX);
+        auto const position = layout.fieldNodeCoordinates(destField, amr_idx);
 
-        for (auto ix = iStartX; ix <= iEndX; ++ix)
+        if constexpr (dim == 1)
         {
-            auto position = layout.fieldNodeCoordinates(destField, this->origin, ix);
-
-            EXPECT_DOUBLE_EQ(srcFunc(interpolateTime, position[dirX]), destField(ix));
+            EXPECT_DOUBLE_EQ(srcFunc(interpolateTime, position[dirX]), destField(lcl_idx));
         }
-    }
-    if constexpr (dim == 2)
-    {
-        auto iStartX = localBox.lower(dirX);
-        auto iEndX   = localBox.upper(dirX);
-        auto iStartY = localBox.lower(dirY);
-        auto iEndY   = localBox.upper(dirY);
-
-        for (auto ix = iStartX; ix <= iEndX; ++ix)
+        if constexpr (dim == 2)
         {
-            for (auto iy = iStartY; iy <= iEndY; ++iy)
-            {
-                auto position = layout.fieldNodeCoordinates(destField, this->origin, ix, iy);
-
-                EXPECT_DOUBLE_EQ(srcFunc(interpolateTime, position[dirX], position[dirY]),
-                                 destField(ix, iy));
-            }
+            EXPECT_DOUBLE_EQ(srcFunc(interpolateTime, position[dirX], position[dirY]),
+                             destField(lcl_idx));
         }
-    }
-    if constexpr (dim == 3)
-    {
-        auto iStartX = localBox.lower(dirX);
-        auto iEndX   = localBox.upper(dirX);
-        auto iStartY = localBox.lower(dirY);
-        auto iEndY   = localBox.upper(dirY);
-        auto iStartZ = localBox.lower(dirZ);
-        auto iEndZ   = localBox.upper(dirZ);
-
-        for (auto ix = iStartX; ix <= iEndX; ++ix)
+        if constexpr (dim == 3)
         {
-            for (auto iy = iStartY; iy <= iEndY; ++iy)
-            {
-                for (auto iz = iStartZ; iz <= iEndZ; ++iz)
-                {
-                    auto position
-                        = layout.fieldNodeCoordinates(destField, this->origin, ix, iy, iz);
-
-                    EXPECT_DOUBLE_EQ(
-                        srcFunc(interpolateTime, position[dirX], position[dirY], position[dirZ]),
-                        destField(ix, iy, iz));
-                }
-            }
+            EXPECT_DOUBLE_EQ(
+                srcFunc(interpolateTime, position[dirX], position[dirY], position[dirZ]),
+                destField(lcl_idx));
         }
     }
 }
diff --git a/tests/amr/messengers/test_messenger_tag_strategy.hpp b/tests/amr/messengers/test_messenger_tag_strategy.hpp
index afe314c29..e9605e48f 100644
--- a/tests/amr/messengers/test_messenger_tag_strategy.hpp
+++ b/tests/amr/messengers/test_messenger_tag_strategy.hpp
@@ -29,9 +29,8 @@ void fillField(Field& field, GridLayout& layout, Func f)
 
     for (auto ix = iStart; ix <= iEnd; ++ix)
     {
-        auto origin = layout.origin();
-        auto x      = layout.fieldNodeCoordinates(field, origin, ix);
-        field(ix)   = f(x[0]);
+        auto x    = layout.fieldNodeCoordinates(field, ix);
+        field(ix) = f(x[0]);
     }
 }
 
diff --git a/tests/core/data/electrons/test_electrons.cpp b/tests/core/data/electrons/test_electrons.cpp
index 5f5ffc700..ffd440728 100644
--- a/tests/core/data/electrons/test_electrons.cpp
+++ b/tests/core/data/electrons/test_electrons.cpp
@@ -23,7 +23,7 @@
 
 using namespace PHARE::core;
 
-const double Te = 0.12;
+double const Te = 0.12;
 
 
 
@@ -226,13 +226,10 @@ struct ElectronsTest : public ::testing::Test
         if constexpr (dim == 1)
         {
             auto fill = [this](auto& field, auto const& filler) {
-                auto gsi_X = this->layout.ghostStartIndex(field, Direction::X);
-                auto gei_X = this->layout.ghostEndIndex(field, Direction::X);
-
-                for (auto ix = gsi_X; ix <= gei_X; ++ix)
+                for (auto const [amr_idx, lcl_idx] : layout.ghost_amr_lcl_idx(field))
                 {
-                    auto point = this->layout.fieldNodeCoordinates(field, Point<double, 1>{0.}, ix);
-                    field(ix)  = filler(point[0]);
+                    auto const point = this->layout.fieldNodeCoordinates(field, amr_idx);
+                    field(lcl_idx)   = filler(point[0]);
                 }
             };
 
@@ -249,19 +246,10 @@ struct ElectronsTest : public ::testing::Test
         else if constexpr (dim == 2)
         {
             auto fill = [this](auto& field, auto const& filler) {
-                auto gsi_X = this->layout.ghostStartIndex(field, Direction::X);
-                auto gei_X = this->layout.ghostEndIndex(field, Direction::X);
-                auto gsi_Y = this->layout.ghostStartIndex(field, Direction::Y);
-                auto gei_Y = this->layout.ghostEndIndex(field, Direction::Y);
-
-                for (auto ix = gsi_X; ix <= gei_X; ++ix)
+                for (auto const amr_idx : layout.AMRGhostBoxFor(field))
                 {
-                    for (auto iy = gsi_Y; iy <= gei_Y; ++iy)
-                    {
-                        auto point = this->layout.fieldNodeCoordinates(
-                            field, Point<double, 2>{0., 0.}, ix, iy);
-                        field(ix, iy) = filler(point[0], point[1]);
-                    }
+                    auto point = this->layout.fieldNodeCoordinates(field, amr_idx);
+                    field(layout.AMRToLocal(amr_idx)) = filler(point[0], point[1]);
                 }
             };
 
@@ -279,24 +267,10 @@ struct ElectronsTest : public ::testing::Test
         else if constexpr (dim == 3)
         {
             auto fill = [this](auto& field, auto const& filler) {
-                auto gsi_X = this->layout.ghostStartIndex(field, Direction::X);
-                auto gei_X = this->layout.ghostEndIndex(field, Direction::X);
-                auto gsi_Y = this->layout.ghostStartIndex(field, Direction::Y);
-                auto gei_Y = this->layout.ghostEndIndex(field, Direction::Y);
-                auto gsi_Z = this->layout.ghostStartIndex(field, Direction::Z);
-                auto gei_Z = this->layout.ghostEndIndex(field, Direction::Z);
-
-                for (auto ix = gsi_X; ix <= gei_X; ++ix)
+                for (auto const amr_idx : layout.AMRGhostBoxFor(field))
                 {
-                    for (auto iy = gsi_Y; iy <= gei_Y; ++iy)
-                    {
-                        for (auto iz = gsi_Z; iz <= gei_Z; ++iz)
-                        {
-                            auto point = this->layout.fieldNodeCoordinates(
-                                field, Point<double, 3>{0., 0., 0.}, ix, iy, iz);
-                            field(ix, iy, iz) = filler(point[0], point[1], point[2]);
-                        }
-                    }
+                    auto point = this->layout.fieldNodeCoordinates(field, amr_idx);
+                    field(layout.AMRToLocal(amr_idx)) = filler(point[0], point[1], point[2]);
                 }
             };
 
diff --git a/tests/core/data/gridlayout/cellCenteredCoordinates.py b/tests/core/data/gridlayout/cellCenteredCoordinates.py
index e719f67ac..695c56a16 100644
--- a/tests/core/data/gridlayout/cellCenteredCoordinates.py
+++ b/tests/core/data/gridlayout/cellCenteredCoordinates.py
@@ -23,37 +23,49 @@
 class CenteredCoordParams(gridparams.GridParams):
     def __init__(self, dim, interpOrder):
         gridparams.GridParams.__init__(self, dim, interpOrder)
-
         self.origin = ()
-
         self.iStart = ()
         self.iEnd = ()
 
     def setCoord(self, gl, originPosition, centering):
         if self.dim == 1:
             self.origin = originPosition[0]
-            self.iStart = gl.physicalStartIndex(self.interpOrder, centering)
-            self.iEnd = gl.physicalEndIndex(
-                self.interpOrder, centering, self.nbrCell
-            ) - gl.isDual(centering)
+            self.iStart = gl.localPointToAMR(
+                gl.physicalStartIndex(self.interpOrder, centering)
+            )[0]
+            assert self.iStart >= 0
+            self.iEnd = gl.localPointToAMR(
+                gl.physicalEndIndex(self.interpOrder, centering, self.nbrCell)
+                - gl.isDual(centering)
+            )[0]
+            assert self.iEnd >= self.iStart
 
         if self.dim > 1:
-            iStartX = gl.physicalStartIndex(self.interpOrder, centering[0])
-            iEndX = gl.physicalEndIndex(
-                self.interpOrder, centering[0], self.nbrCell[0]
-            ) - gl.isDual(centering[0])
-
-            iStartY = gl.physicalStartIndex(self.interpOrder, centering[1])
-            iEndY = gl.physicalEndIndex(
-                self.interpOrder, centering[1], self.nbrCell[1]
-            ) - gl.isDual(centering[1])
+            iStartX = gl.localPointToAMR(
+                gl.physicalStartIndex(self.interpOrder, centering[0])
+            )[0]
+            iEndX = gl.localPointToAMR(
+                gl.physicalEndIndex(self.interpOrder, centering[0], self.nbrCell[0])
+                - gl.isDual(centering[0])
+            )[0]
+
+            iStartY = gl.localPointToAMR(
+                gl.physicalStartIndex(self.interpOrder, centering[1])
+            )[0]
+            iEndY = gl.localPointToAMR(
+                gl.physicalEndIndex(self.interpOrder, centering[1], self.nbrCell[1])
+                - gl.isDual(centering[1])
+            )[0]
 
         if self.dim > 2:
-            iStartZ = gl.physicalStartIndex(self.interpOrder, centering[2])
+            iStartZ = gl.localPointToAMR(
+                gl.physicalStartIndex(self.interpOrder, centering[2])
+            )[0]
 
-            iEndZ = gl.physicalEndIndex(
-                self.interpOrder, centering[2], self.nbrCell[2]
-            ) - gl.isDual(centering[2])
+            iEndZ = gl.localPointToAMR(
+                gl.physicalEndIndex(self.interpOrder, centering[2], self.nbrCell[2])
+                - gl.isDual(centering[2])
+            )[0]
 
         if self.dim == 2:
             self.origin = (originPosition[0], originPosition[1])
@@ -80,13 +92,10 @@ def getCellCentered(dimension):
 #
 # This method returns a point
 #
-def centeredCoords(primalIndex, startIndex, dl, origin):
+def centeredCoords(primalIndex, dl):
     # a cell-centered coordinate is always dual
     halfCell = 0.5
-
-    x = ((primalIndex - startIndex) + halfCell) * dl + origin
-
-    return x
+    return (primalIndex + halfCell) * dl
 
 
 # ---------------------- MAIN CODE -----------------------------------------
@@ -110,8 +119,6 @@ def main(path="./"):
 
     originPosition = [0.0, 0.0, 0.0]
 
-    gl = gridlayout.GridLayout()
-
     # ------- Debug commands -------
     # for icase in icase_l:
     #     idim = dim_l[icase]
@@ -146,6 +153,8 @@ def main(path="./"):
     for interpOrder, outFilesSumDim, outFilesValDim in zip(
         interpOrders, outSummaries, outValues
     ):
+        gl = gridlayout.GridLayout(interp_order=interpOrder)
+
         for (
             dimension,
             outFileS,
@@ -186,14 +195,11 @@ def main(path="./"):
             outSummaryString = utilities.removeTupleFormat(outSummaryString)
 
             outFileS.write(outSummaryString)
-
             if dimension == 1:
                 for position in np.arange(params.iStart, params.iEnd + 1):
                     outValuesString = "{} {}\n".format(
                         position,
-                        centeredCoords(
-                            position, params.iStart, params.dl, params.origin
-                        ),
+                        centeredCoords(position, params.dl),
                     )
 
                     outFileV.write(utilities.removeTupleFormat(outValuesString))
@@ -203,18 +209,8 @@ def main(path="./"):
                     for positionY in np.arange(params.iStart[1], params.iEnd[1] + 1):
                         position = (positionX, positionY)
                         centered = (
-                            centeredCoords(
-                                positionX,
-                                params.iStart[0],
-                                params.dl[0],
-                                params.origin[0],
-                            ),
-                            centeredCoords(
-                                positionY,
-                                params.iStart[1],
-                                params.dl[1],
-                                params.origin[1],
-                            ),
+                            centeredCoords(positionX, params.dl[0]),
+                            centeredCoords(positionY, params.dl[1]),
                         )
 
                         outValuesString = "{} {}\n".format(position, centered)
@@ -229,24 +225,9 @@ def main(path="./"):
                         ):
                             position = (positionX, positionY, positionZ)
                             centered = (
-                                centeredCoords(
-                                    positionX,
-                                    params.iStart[0],
-                                    params.dl[0],
-                                    params.origin[0],
-                                ),
-                                centeredCoords(
-                                    positionY,
-                                    params.iStart[1],
-                                    params.dl[1],
-                                    params.origin[1],
-                                ),
-                                centeredCoords(
-                                    positionZ,
-                                    params.iStart[2],
-                                    params.dl[2],
-                                    params.origin[2],
-                                ),
+                                centeredCoords(positionX, params.dl[0]),
+                                centeredCoords(positionY, params.dl[1]),
+                                centeredCoords(positionZ, params.dl[2]),
                             )
 
                             outValuesString = "{} {}\n".format(position, centered)
diff --git a/tests/core/data/gridlayout/deriv.py b/tests/core/data/gridlayout/deriv.py
index 9abb324b2..be55bacc3 100644
--- a/tests/core/data/gridlayout/deriv.py
+++ b/tests/core/data/gridlayout/deriv.py
@@ -94,8 +94,6 @@ def main(path="./"):
 
     originPosition = [0.0, 0.0, 0.0]
 
-    gl = gridlayout.GridLayout()
-
     # TODO : end Todo
 
     # TODO: FieldCoords and CenteredCoords share a common base, refactor this
@@ -115,6 +113,8 @@ def main(path="./"):
     outDerivedValues1D = open(os.path.join(path, "deriv_derived_values_1d.txt"), "w")
 
     for interpOrder in interpOrders:
+        gl = gridlayout.GridLayout(interp_order=interpOrder)
+
         for (
             dimension,
             outSummary,
@@ -180,12 +180,7 @@ def main(path="./"):
                 if dimension == 1:
                     for position in np.arange(params.iGhostStart, params.iGhostEnd):
                         coord = fieldNodeCoordinates.fieldCoords(
-                            position,
-                            params.iStart,
-                            quantity,
-                            "X",
-                            params.dl,
-                            params.origin,
+                            position, quantity, "X", params.dl, gl
                         )
                         functionValue = primitive(coord)
 
@@ -200,12 +195,7 @@ def main(path="./"):
 
                     for position in np.arange(params.iStart, params.iEnd + 1):
                         coord = fieldNodeCoordinates.fieldCoords(
-                            position,
-                            params.iStart,
-                            derivQuantity,
-                            "X",
-                            params.dl,
-                            params.origin,
+                            position, derivQuantity, "X", params.dl, gl
                         )
 
                         derivedValue = scipy.misc.derivative(
diff --git a/tests/core/data/gridlayout/fieldNodeCoordinates.py b/tests/core/data/gridlayout/fieldNodeCoordinates.py
index 4146fac0c..686fb97d8 100644
--- a/tests/core/data/gridlayout/fieldNodeCoordinates.py
+++ b/tests/core/data/gridlayout/fieldNodeCoordinates.py
@@ -21,16 +21,13 @@
 #
 # This method returns a point
 #
-def fieldCoords(primalIndex, startIndex, quantity, direction, dl, origin):
+def fieldCoords(primalIndex, quantity, direction, dl, gl):
     halfCell = 0.0
-    gl = gridlayout.GridLayout()
 
     if gl.qtyCentering(quantity, direction) == "dual":
         halfCell = 0.5
 
-    x = ((primalIndex - startIndex) + halfCell) * dl + origin
-
-    return x
+    return (primalIndex + halfCell) * dl
 
 
 class FieldNodeCoordParams(cellCenteredCoordinates.CenteredCoordParams):
@@ -74,8 +71,6 @@ def main(path="./"):
 
     originPosition = [0.0, 0.0, 0.0]
 
-    gl = gridlayout.GridLayout()
-
     # TODO : end Todo
 
     # TODO: FieldCoords and CenteredCoords share a common base, refactor this
@@ -103,6 +98,8 @@ def main(path="./"):
     for interpOrder, outFilesSumDim, outFilesValDim in zip(
         interpOrders, outSummaries, outValues
     ):
+        gl = gridlayout.GridLayout(interp_order=interpOrder)
+
         for (
             dimension,
             outFileS,
@@ -152,14 +149,7 @@ def main(path="./"):
                         outValuesString = "{} {} {}\n".format(
                             quantity,
                             position,
-                            fieldCoords(
-                                position,
-                                params.iStart,
-                                quantity,
-                                "X",
-                                params.dl,
-                                params.origin,
-                            ),
+                            fieldCoords(position, quantity, "X", params.dl, gl),
                         )
 
                         outFileV.write(utilities.removeTupleFormat(outValuesString))
@@ -171,22 +161,8 @@ def main(path="./"):
                         ):
                             position = (positionX, positionY)
                             centered = (
-                                fieldCoords(
-                                    positionX,
-                                    params.iStart[0],
-                                    quantity,
-                                    "X",
-                                    params.dl[0],
-                                    params.origin[0],
-                                ),
-                                fieldCoords(
-                                    positionY,
-                                    params.iStart[1],
-                                    quantity,
-                                    "Y",
-                                    params.dl[1],
-                                    params.origin[1],
-                                ),
+                                fieldCoords(positionX, quantity, "X", params.dl[0], gl),
+                                fieldCoords(positionY, quantity, "Y", params.dl[1], gl),
                             )
 
                             outValuesString = "{} {} {}\n".format(
@@ -206,28 +182,13 @@ def main(path="./"):
                                 position = (positionX, positionY, positionZ)
                                 centered = (
                                     fieldCoords(
-                                        positionX,
-                                        params.iStart[0],
-                                        quantity,
-                                        "X",
-                                        params.dl[0],
-                                        params.origin[0],
+                                        positionX, quantity, "X", params.dl[0], gl
                                     ),
                                     fieldCoords(
-                                        positionY,
-                                        params.iStart[1],
-                                        quantity,
-                                        "Y",
-                                        params.dl[1],
-                                        params.origin[1],
+                                        positionY, quantity, "Y", params.dl[1], gl
                                     ),
                                     fieldCoords(
-                                        positionZ,
-                                        params.iStart[2],
-                                        quantity,
-                                        "Z",
-                                        params.dl[2],
-                                        params.origin[2],
+                                        positionZ, quantity, "Z", params.dl[2], gl
                                     ),
                                 )
 
diff --git a/tests/core/data/gridlayout/gridlayout_cell_centered_coord.hpp b/tests/core/data/gridlayout/gridlayout_cell_centered_coord.hpp
index 652f39c19..3b8142805 100644
--- a/tests/core/data/gridlayout/gridlayout_cell_centered_coord.hpp
+++ b/tests/core/data/gridlayout/gridlayout_cell_centered_coord.hpp
@@ -18,22 +18,11 @@ struct GridLayoutCellCenteringParam
 {
     GridLayoutTestParam<GridLayoutImpl> base;
 
-    std::vector<std::array<std::uint32_t, GridLayoutImpl::dimension>> iCellForCentering;
+    std::vector<Point<int, GridLayoutImpl::dimension>> iCellForCentering;
     std::vector<std::array<double, GridLayoutImpl::dimension>> expectedPosition;
 
     std::vector<std::array<double, GridLayoutImpl::dimension>> actualPosition;
 
-    template<typename Array, std::size_t... I>
-    auto cellCenteredCoord_impl(Array const& array, std::index_sequence<I...>)
-    {
-        return base.layout->cellCenteredCoordinates(array[I]...);
-    }
-
-    template<typename T, std::size_t N, typename Indices = std::make_index_sequence<N>>
-    auto cellCenteredCoord(const std::array<T, N>& array)
-    {
-        return cellCenteredCoord_impl(array, Indices{});
-    }
 
     void init()
     {
@@ -45,18 +34,8 @@ struct GridLayoutCellCenteringParam
 
         for (auto&& iCell : iCellForCentering)
         {
-            Point<double, GridLayoutImpl::dimension> pos;
-            pos = cellCenteredCoord(iCell);
-
-            std::array<double, GridLayoutImpl::dimension> actualPos;
-
-            for (std::size_t iDim = 0; iDim < GridLayoutImpl::dimension; ++iDim)
-            {
-                actualPos[iDim] = pos[iDim];
-            }
-
-
-            actualPosition.push_back(actualPos);
+            auto const pos = base.layout->cellCenteredCoordinates(iCell);
+            actualPosition.push_back(*pos);
         }
     }
 };
@@ -80,23 +59,10 @@ auto createCellCenteringParam()
     std::ifstream summary{summaryPath};
     std::ifstream value{valuePath};
 
-    std::string layoutName{"yee"};
-
-    const std::map<std::string, HybridQuantity::Scalar> namesToQuantity{
-        {"Bx", HybridQuantity::Scalar::Bx}, {"By", HybridQuantity::Scalar::By},
-        {"Bz", HybridQuantity::Scalar::Bz}, {"Ex", HybridQuantity::Scalar::Ex},
-        {"Ey", HybridQuantity::Scalar::Ey}, {"Ez", HybridQuantity::Scalar::Ez},
-        {"Jx", HybridQuantity::Scalar::Jx}, {"Jy", HybridQuantity::Scalar::Jy},
-        {"Jz", HybridQuantity::Scalar::Jz}, {"rho", HybridQuantity::Scalar::rho},
-        {"Vx", HybridQuantity::Scalar::Vx}, {"Vy", HybridQuantity::Scalar::Vy},
-        {"Vz", HybridQuantity::Scalar::Vz}, {"P", HybridQuantity::Scalar::P}};
-
     std::array<std::uint32_t, GridLayoutImpl::dimension> nbCell;
     std::array<double, GridLayoutImpl::dimension> dl;
-
     std::array<std::uint32_t, GridLayoutImpl::dimension> iStart;
     std::array<std::uint32_t, GridLayoutImpl::dimension> iEnd;
-
     std::array<double, GridLayoutImpl::dimension> origin;
 
     writeToArray(summary, nbCell);
@@ -105,14 +71,9 @@ auto createCellCenteringParam()
     writeToArray(summary, iEnd);
     writeToArray(summary, origin);
 
-
-
     params.emplace_back();
 
-    // NOTE: c++17 : Point{origin}, C++14 : Point<double, dim>{origin}
-    params.back().base
-        = createParam<GridLayoutImpl>(dl, nbCell, Point<double, GridLayoutImpl::dimension>{origin});
-
+    params.back().base = createParam<GridLayoutImpl>(dl, nbCell, Point{origin});
 
     std::array<std::uint32_t, GridLayoutImpl::dimension> icell;
     std::array<double, GridLayoutImpl::dimension> realPosition;
diff --git a/tests/core/data/gridlayout/gridlayout_deriv.cpp b/tests/core/data/gridlayout/gridlayout_deriv.cpp
index 4a598e5ef..ebefc4489 100644
--- a/tests/core/data/gridlayout/gridlayout_deriv.cpp
+++ b/tests/core/data/gridlayout/gridlayout_deriv.cpp
@@ -1,12 +1,14 @@
 
-#include <math.h>
+
+#include "core/data/grid/gridlayoutdefs.hpp"
 
 #include "gridlayout_deriv.hpp"
-#include "gridlayout_params.hpp"
-#include "gridlayout_test.hpp"
+
+#include <math.h>
+#include <string>
 
 
-std::vector<double> read(std::string filename)
+std::vector<double> read(std::string const filename)
 {
     std::ifstream readFile(filename);
     assert(readFile.is_open());
@@ -17,6 +19,7 @@ std::vector<double> read(std::string filename)
     return x;
 }
 
+
 // -----------------------------------------------------------------------------
 //              1D case
 // -----------------------------------------------------------------------------
@@ -30,26 +33,21 @@ TYPED_TEST_SUITE(a1DDerivative, layoutImpls1D);
 
 TYPED_TEST(a1DDerivative, DXBY1D)
 {
-    std::string filename = std::string("dxBy_interpOrder_")
-                           + std::to_string(TestFixture::interp_order) + std::string("_1d.txt");
-    auto expDerValue            = read(filename);
-    [[maybe_unused]] auto gei_d = this->layout.ghostEndIndex(QtyCentering::dual, Direction::X);
-
-    auto gei_d_X = this->layout.ghostEndIndex(QtyCentering::dual, Direction::X);
+    auto const filename = std::string("dxBy_interpOrder_")
+                          + std::to_string(TestFixture::interp_order) + std::string("_1d.txt");
+    auto const expDerValue = read(filename);
 
-    auto psi_p_X = this->layout.physicalStartIndex(QtyCentering::primal, Direction::X);
-    auto pei_p_X = this->layout.physicalEndIndex(QtyCentering::primal, Direction::X);
 
-    for (auto ix = 0u; ix <= gei_d_X; ++ix)
+    for (auto const [amr_idx, lcl_idx] : this->layout.ghost_amr_lcl_idx(this->By))
     {
-        Point<double, 1> point = this->layout.fieldNodeCoordinates(this->By, {0.}, ix);
-        this->By(ix)           = std::cos(2 * M_PI / 5. * point[0]);
+        auto const point  = this->layout.fieldNodeCoordinates(this->By, amr_idx);
+        this->By(lcl_idx) = std::cos(2 * M_PI / 5. * point[0]);
     }
 
-    for (auto ix = psi_p_X; ix <= pei_p_X; ++ix)
+    for (auto const lcl_idx : this->layout.AMRToLocal(this->layout.AMRBox()))
     {
-        auto localDerivative = this->layout.template deriv<Direction::X>(this->By, {ix});
-        EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[ix], 1e-12));
+        auto const localDerivative = this->layout.template deriv<Direction::X>(this->By, {lcl_idx});
+        EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[lcl_idx[0]], 1e-12));
     }
 }
 
@@ -57,33 +55,28 @@ TYPED_TEST(a1DDerivative, DXBY1D)
 
 TYPED_TEST(a1DDerivative, DXEZ1D)
 {
-    std::string filename = std::string("dxEz_interpOrder_")
-                           + std::to_string(TestFixture::interp_order) + std::string("_1d.txt");
-    auto expDerValue = read(filename);
-
-    auto gei_p_X = this->layout.ghostEndIndex(QtyCentering::primal, Direction::X);
+    auto const filename = std::string("dxEz_interpOrder_")
+                          + std::to_string(TestFixture::interp_order) + std::string("_1d.txt");
+    auto const expDerValue = read(filename);
 
-    auto psi_d_X = this->layout.physicalStartIndex(QtyCentering::dual, Direction::X);
-    auto pei_d_X = this->layout.physicalEndIndex(QtyCentering::dual, Direction::X);
-
-    for (auto ix = 0u; ix <= gei_p_X; ++ix)
+    for (auto const [amr_idx, lcl_idx] : this->layout.ghost_amr_lcl_idx(this->Ez))
     {
-        Point<double, 1> point = this->layout.fieldNodeCoordinates(this->Ez, {0.}, ix);
-        this->Ez(ix)           = std::cos(2 * M_PI / 5. * point[0]);
+        auto const point  = this->layout.fieldNodeCoordinates(this->Ez, amr_idx);
+        this->Ez(lcl_idx) = std::cos(2 * M_PI / 5. * point[0]);
     }
 
-    for (auto ix = psi_d_X; ix <= pei_d_X; ++ix)
+    for (auto const lcl_idx : this->layout.AMRToLocal(this->layout.AMRBox()))
     {
-        auto localDerivative = this->layout.template deriv<Direction::X>(this->Ez, {ix});
-        EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[ix], 1e-12));
+        auto const localDerivative = this->layout.template deriv<Direction::X>(this->Ez, {lcl_idx});
+        EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[lcl_idx[0]], 1e-12));
     }
 }
 
 
 
-// -----------------------------------------------------------------------------
-//              2D case
-// -----------------------------------------------------------------------------
+// // -----------------------------------------------------------------------------
+// //              2D case
+// // -----------------------------------------------------------------------------
 
 using layoutImpls2D
     = ::testing::Types<GridLayoutImplYee<2, 1>, GridLayoutImplYee<2, 2>, GridLayoutImplYee<2, 3>>;
@@ -94,159 +87,105 @@ TYPED_TEST_SUITE(a2DDerivative, layoutImpls2D);
 
 TYPED_TEST(a2DDerivative, DXBY2D)
 {
-    std::string filename = std::string("dxBy_interpOrder_")
-                           + std::to_string(TestFixture::interp_order) + std::string("_2d.txt");
-    auto expDerValue = read(filename);
-
-    auto gei_d_X = this->layout.ghostEndIndex(QtyCentering::dual, Direction::X);
-    auto gei_p_Y = this->layout.ghostEndIndex(QtyCentering::primal, Direction::Y);
-    auto psi_p_X = this->layout.physicalStartIndex(QtyCentering::primal, Direction::X);
-    auto pei_p_X = this->layout.physicalEndIndex(QtyCentering::primal, Direction::X);
-    auto psi_p_Y = this->layout.physicalStartIndex(QtyCentering::primal, Direction::Y);
-    auto pei_p_Y = this->layout.physicalEndIndex(QtyCentering::primal, Direction::Y);
-
-    for (auto ix = 0u; ix <= gei_d_X; ++ix)
+    auto const filename = std::string("dxBy_interpOrder_")
+                          + std::to_string(TestFixture::interp_order) + std::string("_2d.txt");
+    auto const expDerValue = read(filename);
+
+
+    for (auto const [amr_idx, lcl_idx] : this->layout.ghost_amr_lcl_idx(this->By))
     {
-        for (auto iy = 0u; iy <= gei_p_Y; ++iy)
-        {
-            Point<double, 2> point = this->layout.fieldNodeCoordinates(this->By, {0., 0.}, ix, iy);
-            this->By(ix, iy)
-                = std::cos(2 * M_PI / 5. * point[0]) * std::sin(2 * M_PI / 6. * point[1]);
-        }
+        Point<double, 2> point = this->layout.fieldNodeCoordinates(this->By, amr_idx);
+        this->By(lcl_idx) = std::cos(2 * M_PI / 5. * point[0]) * std::sin(2 * M_PI / 6. * point[1]);
     }
 
-    std::array<std::uint32_t, 2> nPts_
-        = this->layout.allocSizeDerived(HybridQuantity::Scalar::By, Direction::X);
+    auto const nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::By, Direction::X);
+
 
-    for (auto ix = psi_p_X; ix <= pei_p_X; ++ix)
+    for (auto const lcl_idx : this->layout.AMRToLocal(this->layout.AMRBox()))
     {
-        for (auto iy = psi_p_Y; iy <= pei_p_Y; ++iy)
-        {
-            auto localDerivative = this->layout.template deriv<Direction::X>(this->By, {ix, iy});
-            auto index_          = ix * nPts_[1] + iy;
-            EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
-        }
+        auto const localDerivative = this->layout.template deriv<Direction::X>(this->By, lcl_idx);
+        auto index_                = lcl_idx[0] * nPts_[1] + lcl_idx[1];
+        EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
     }
 }
 
 
 TYPED_TEST(a2DDerivative, DYBY2D)
 {
-    std::string filename = std::string("dyBy_interpOrder_")
-                           + std::to_string(TestFixture::interp_order) + std::string("_2d.txt");
-    auto expDerValue = read(filename);
+    auto const filename = std::string("dyBy_interpOrder_")
+                          + std::to_string(TestFixture::interp_order) + std::string("_2d.txt");
+    auto const expDerValue = read(filename);
 
-    auto gei_d_X = this->layout.ghostEndIndex(QtyCentering::dual, Direction::X);
-    auto gei_p_Y = this->layout.ghostEndIndex(QtyCentering::primal, Direction::Y);
 
-    auto psi_d_X = this->layout.physicalStartIndex(QtyCentering::dual, Direction::X);
-    auto pei_d_X = this->layout.physicalEndIndex(QtyCentering::dual, Direction::X);
-    auto psi_d_Y = this->layout.physicalStartIndex(QtyCentering::dual, Direction::Y);
-    auto pei_d_Y = this->layout.physicalEndIndex(QtyCentering::dual, Direction::Y);
-
-    for (auto ix = 0u; ix <= gei_d_X; ++ix)
+    for (auto const [amr_idx, lcl_idx] : this->layout.ghost_amr_lcl_idx(this->By))
     {
-        for (auto iy = 0u; iy <= gei_p_Y; ++iy)
-        {
-            Point<double, 2> point = this->layout.fieldNodeCoordinates(this->By, {0., 0.}, ix, iy);
-            this->By(ix, iy)
-                = std::cos(2 * M_PI / 5. * point[0]) * std::sin(2 * M_PI / 6. * point[1]);
-        }
+        Point<double, 2> point = this->layout.fieldNodeCoordinates(this->By, amr_idx);
+        this->By(lcl_idx) = std::cos(2 * M_PI / 5. * point[0]) * std::sin(2 * M_PI / 6. * point[1]);
     }
 
-    auto nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::By, Direction::Y);
+    auto const nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::By, Direction::Y);
 
-    for (auto ix = psi_d_X; ix <= pei_d_X; ++ix)
+    for (auto const lcl_idx : this->layout.AMRToLocal(this->layout.AMRBox()))
     {
-        for (auto iy = psi_d_Y; iy <= pei_d_Y; ++iy)
-        {
-            auto localDerivative = this->layout.template deriv<Direction::Y>(this->By, {ix, iy});
-            auto index_          = ix * nPts_[1] + iy;
-            EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
-        }
+        auto const localDerivative = this->layout.template deriv<Direction::Y>(this->By, lcl_idx);
+        auto index_                = lcl_idx[0] * nPts_[1] + lcl_idx[1];
+        EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
     }
 }
 
 
 TYPED_TEST(a2DDerivative, DXEZ2D)
 {
-    std::string filename = std::string("dxEz_interpOrder_")
-                           + std::to_string(TestFixture::interp_order) + std::string("_2d.txt");
-    auto expDerValue = read(filename);
-
-    auto gei_p_X = this->layout.ghostEndIndex(QtyCentering::primal, Direction::X);
-    auto gei_p_Y = this->layout.ghostEndIndex(QtyCentering::primal, Direction::Y);
+    auto const filename = std::string("dxEz_interpOrder_")
+                          + std::to_string(TestFixture::interp_order) + std::string("_2d.txt");
+    auto const expDerValue = read(filename);
 
-    auto psi_d_X = this->layout.physicalStartIndex(QtyCentering::dual, Direction::X);
-    auto pei_d_X = this->layout.physicalEndIndex(QtyCentering::dual, Direction::X);
-    auto psi_p_Y = this->layout.physicalStartIndex(QtyCentering::primal, Direction::Y);
-    auto pei_p_Y = this->layout.physicalEndIndex(QtyCentering::primal, Direction::Y);
 
-    for (auto ix = 0u; ix <= gei_p_X; ++ix)
+    for (auto const [amr_idx, lcl_idx] : this->layout.ghost_amr_lcl_idx(this->Ez))
     {
-        for (auto iy = 0u; iy <= gei_p_Y; ++iy)
-        {
-            Point<double, 2> point = this->layout.fieldNodeCoordinates(this->Ez, {0., 0.}, ix, iy);
-            this->Ez(ix, iy)
-                = std::cos(2 * M_PI / 5. * point[0]) * std::sin(2 * M_PI / 6. * point[1]);
-        }
+        Point<double, 2> point = this->layout.fieldNodeCoordinates(this->Ez, amr_idx);
+        this->Ez(lcl_idx) = std::cos(2 * M_PI / 5. * point[0]) * std::sin(2 * M_PI / 6. * point[1]);
     }
 
-    auto nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::Ez, Direction::X);
+    auto const nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::Ez, Direction::X);
 
-    for (auto ix = psi_d_X; ix <= pei_d_X; ++ix)
+    for (auto const lcl_idx : this->layout.AMRToLocal(this->layout.AMRBox()))
     {
-        for (auto iy = psi_p_Y; iy <= pei_p_Y; ++iy)
-        {
-            auto localDerivative = this->layout.template deriv<Direction::X>(this->Ez, {ix, iy});
-            auto index_          = ix * nPts_[1] + iy;
-            EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
-        }
+        auto const localDerivative = this->layout.template deriv<Direction::X>(this->Ez, lcl_idx);
+        auto index_                = lcl_idx[0] * nPts_[1] + lcl_idx[1];
+        EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
     }
 }
 
 
 TYPED_TEST(a2DDerivative, DYEZ2D)
 {
-    std::string filename = std::string("dyEz_interpOrder_")
-                           + std::to_string(TestFixture::interp_order) + std::string("_2d.txt");
-    auto expDerValue = read(filename);
-
-    auto gei_p_X = this->layout.ghostEndIndex(QtyCentering::primal, Direction::X);
-    auto gei_p_Y = this->layout.ghostEndIndex(QtyCentering::primal, Direction::Y);
-    auto psi_p_X = this->layout.physicalStartIndex(QtyCentering::primal, Direction::X);
-    auto pei_p_X = this->layout.physicalEndIndex(QtyCentering::primal, Direction::X);
-    auto psi_d_Y = this->layout.physicalStartIndex(QtyCentering::dual, Direction::Y);
-    auto pei_d_Y = this->layout.physicalEndIndex(QtyCentering::dual, Direction::Y);
-
-    for (auto ix = 0u; ix <= gei_p_X; ++ix)
+    auto const filename = std::string("dyEz_interpOrder_")
+                          + std::to_string(TestFixture::interp_order) + std::string("_2d.txt");
+    auto const expDerValue = read(filename);
+
+
+    for (auto const [amr_idx, lcl_idx] : this->layout.ghost_amr_lcl_idx(this->Ez))
     {
-        for (auto iy = 0u; iy <= gei_p_Y; ++iy)
-        {
-            auto point = this->layout.fieldNodeCoordinates(this->Ez, {0., 0.}, ix, iy);
-            this->Ez(ix, iy)
-                = std::cos(2 * M_PI / 5. * point[0]) * std::sin(2 * M_PI / 6. * point[1]);
-        }
+        auto point        = this->layout.fieldNodeCoordinates(this->Ez, amr_idx);
+        this->Ez(lcl_idx) = std::cos(2 * M_PI / 5. * point[0]) * std::sin(2 * M_PI / 6. * point[1]);
     }
 
-    auto nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::Ez, Direction::Y);
+    auto const nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::Ez, Direction::Y);
 
-    for (auto ix = psi_p_X; ix <= pei_p_X; ++ix)
+    for (auto const lcl_idx : this->layout.AMRToLocal(this->layout.AMRBox()))
     {
-        for (auto iy = psi_d_Y; iy <= pei_d_Y; ++iy)
-        {
-            auto localDerivative = this->layout.template deriv<Direction::Y>(this->Ez, {ix, iy});
-            auto index_          = ix * nPts_[1] + iy;
-            EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
-        }
+        auto const localDerivative = this->layout.template deriv<Direction::Y>(this->Ez, lcl_idx);
+        auto index_                = lcl_idx[0] * nPts_[1] + lcl_idx[1];
+        EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
     }
 }
 
 
 
-// -----------------------------------------------------------------------------
-//              3D case
-// -----------------------------------------------------------------------------
+// // -----------------------------------------------------------------------------
+// //              3D case
+// // -----------------------------------------------------------------------------
 
 using layoutImpls3D
     = ::testing::Types<GridLayoutImplYee<3, 1>, GridLayoutImplYee<3, 2>, GridLayoutImplYee<3, 3>>;
@@ -257,48 +196,25 @@ TYPED_TEST_SUITE(a3DDerivative, layoutImpls3D);
 
 TYPED_TEST(a3DDerivative, DXBY3D)
 {
-    std::string filename = std::string("dxBy_interpOrder_")
-                           + std::to_string(TestFixture::interp_order) + std::string("_3d.txt");
-    auto expDerValue = read(filename);
-
-    auto gei_d_X = this->layout.ghostEndIndex(QtyCentering::dual, Direction::X);
-    auto gei_p_Y = this->layout.ghostEndIndex(QtyCentering::primal, Direction::Y);
-    auto gei_d_Z = this->layout.ghostEndIndex(QtyCentering::dual, Direction::Z);
-    auto psi_p_X = this->layout.physicalStartIndex(QtyCentering::primal, Direction::X);
-    auto pei_p_X = this->layout.physicalEndIndex(QtyCentering::primal, Direction::X);
-    auto psi_p_Y = this->layout.physicalStartIndex(QtyCentering::primal, Direction::Y);
-    auto pei_p_Y = this->layout.physicalEndIndex(QtyCentering::primal, Direction::Y);
-    auto psi_d_Z = this->layout.physicalStartIndex(QtyCentering::dual, Direction::Z);
-    auto pei_d_Z = this->layout.physicalEndIndex(QtyCentering::dual, Direction::Z);
-
-    for (auto ix = 0u; ix <= gei_d_X; ++ix)
+    auto const filename = std::string("dxBy_interpOrder_")
+                          + std::to_string(TestFixture::interp_order) + std::string("_3d.txt");
+    auto const expDerValue = read(filename);
+
+
+    for (auto const [amr_idx, lcl_idx] : this->layout.ghost_amr_lcl_idx(this->By))
     {
-        for (auto iy = 0u; iy <= gei_p_Y; ++iy)
-        {
-            for (auto iz = 0u; iz <= gei_d_Z; ++iz)
-            {
-                auto point = this->layout.fieldNodeCoordinates(this->By, {0., 0., 0.}, ix, iy, iz);
-                this->By(ix, iy, iz) = std::sin(2 * M_PI / 5. * point[0])
-                                       * std::cos(2 * M_PI / 6. * point[1])
-                                       * std::sin(2 * M_PI / 12. * point[2]);
-            }
-        }
+        auto point        = this->layout.fieldNodeCoordinates(this->By, amr_idx);
+        this->By(lcl_idx) = std::sin(2 * M_PI / 5. * point[0]) * std::cos(2 * M_PI / 6. * point[1])
+                            * std::sin(2 * M_PI / 12. * point[2]);
     }
 
-    auto nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::By, Direction::X);
+    auto const nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::By, Direction::X);
 
-    for (auto ix = psi_p_X; ix <= pei_p_X; ++ix)
+    for (auto const lcl_idx : this->layout.AMRToLocal(this->layout.AMRBox()))
     {
-        for (auto iy = psi_p_Y; iy <= pei_p_Y; ++iy)
-        {
-            for (auto iz = psi_d_Z; iz <= pei_d_Z; ++iz)
-            {
-                auto localDerivative
-                    = this->layout.template deriv<Direction::X>(this->By, {ix, iy, iz});
-                auto index_ = ix * nPts_[1] * nPts_[2] + iy * nPts_[2] + iz;
-                EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
-            }
-        }
+        auto const localDerivative = this->layout.template deriv<Direction::X>(this->By, lcl_idx);
+        auto index_ = lcl_idx[0] * nPts_[1] * nPts_[2] + lcl_idx[1] * nPts_[2] + lcl_idx[2];
+        EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
     }
 }
 
@@ -306,48 +222,24 @@ TYPED_TEST(a3DDerivative, DXBY3D)
 
 TYPED_TEST(a3DDerivative, DYBY3D)
 {
-    std::string filename = std::string("dyBy_interpOrder_")
-                           + std::to_string(TestFixture::interp_order) + std::string("_3d.txt");
-    auto expDerValue = read(filename);
-
-    auto gei_d_X = this->layout.ghostEndIndex(QtyCentering::dual, Direction::X);
-    auto gei_p_Y = this->layout.ghostEndIndex(QtyCentering::primal, Direction::Y);
-    auto gei_d_Z = this->layout.ghostEndIndex(QtyCentering::dual, Direction::Z);
-    auto psi_d_X = this->layout.physicalStartIndex(QtyCentering::dual, Direction::X);
-    auto pei_d_X = this->layout.physicalEndIndex(QtyCentering::dual, Direction::X);
-    auto psi_d_Y = this->layout.physicalStartIndex(QtyCentering::dual, Direction::Y);
-    auto pei_d_Y = this->layout.physicalEndIndex(QtyCentering::dual, Direction::Y);
-    auto psi_d_Z = this->layout.physicalStartIndex(QtyCentering::dual, Direction::Z);
-    auto pei_d_Z = this->layout.physicalEndIndex(QtyCentering::dual, Direction::Z);
-
-    for (auto ix = 0u; ix <= gei_d_X; ++ix)
+    auto const filename = std::string("dyBy_interpOrder_")
+                          + std::to_string(TestFixture::interp_order) + std::string("_3d.txt");
+    auto const expDerValue = read(filename);
+
+    for (auto const [amr_idx, lcl_idx] : this->layout.ghost_amr_lcl_idx(this->By))
     {
-        for (auto iy = 0u; iy <= gei_p_Y; ++iy)
-        {
-            for (auto iz = 0u; iz <= gei_d_Z; ++iz)
-            {
-                auto point = this->layout.fieldNodeCoordinates(this->By, {0., 0., 0.}, ix, iy, iz);
-                this->By(ix, iy, iz) = std::sin(2 * M_PI / 5. * point[0])
-                                       * std::cos(2 * M_PI / 6. * point[1])
-                                       * std::sin(2 * M_PI / 12. * point[2]);
-            }
-        }
+        auto point        = this->layout.fieldNodeCoordinates(this->By, amr_idx);
+        this->By(lcl_idx) = std::sin(2 * M_PI / 5. * point[0]) * std::cos(2 * M_PI / 6. * point[1])
+                            * std::sin(2 * M_PI / 12. * point[2]);
     }
 
-    auto nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::By, Direction::Y);
+    auto const nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::By, Direction::Y);
 
-    for (auto ix = psi_d_X; ix <= pei_d_X; ++ix)
+    for (auto const lcl_idx : this->layout.AMRToLocal(this->layout.AMRBox()))
     {
-        for (auto iy = psi_d_Y; iy <= pei_d_Y; ++iy)
-        {
-            for (auto iz = psi_d_Z; iz <= pei_d_Z; ++iz)
-            {
-                auto localDerivative
-                    = this->layout.template deriv<Direction::Y>(this->By, {ix, iy, iz});
-                auto index_ = ix * nPts_[1] * nPts_[2] + iy * nPts_[2] + iz;
-                EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
-            }
-        }
+        auto const localDerivative = this->layout.template deriv<Direction::Y>(this->By, lcl_idx);
+        auto index_ = lcl_idx[0] * nPts_[1] * nPts_[2] + lcl_idx[1] * nPts_[2] + lcl_idx[2];
+        EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
     }
 }
 
@@ -355,49 +247,24 @@ TYPED_TEST(a3DDerivative, DYBY3D)
 
 TYPED_TEST(a3DDerivative, DZBY3D)
 {
-    std::string filename = std::string("dzBy_interpOrder_")
-                           + std::to_string(TestFixture::interp_order) + std::string("_3d.txt");
-    auto expDerValue = read(filename);
-
-    auto gei_d_X = this->layout.ghostEndIndex(QtyCentering::dual, Direction::X);
-    auto gei_p_Y = this->layout.ghostEndIndex(QtyCentering::primal, Direction::Y);
-    auto gei_d_Z = this->layout.ghostEndIndex(QtyCentering::dual, Direction::Z);
-
-    auto psi_d_X = this->layout.physicalStartIndex(QtyCentering::dual, Direction::X);
-    auto pei_d_X = this->layout.physicalEndIndex(QtyCentering::dual, Direction::X);
-    auto psi_p_Y = this->layout.physicalStartIndex(QtyCentering::primal, Direction::Y);
-    auto pei_p_Y = this->layout.physicalEndIndex(QtyCentering::primal, Direction::Y);
-    auto psi_p_Z = this->layout.physicalStartIndex(QtyCentering::primal, Direction::Z);
-    auto pei_p_Z = this->layout.physicalEndIndex(QtyCentering::primal, Direction::Z);
-
-    for (auto ix = 0u; ix <= gei_d_X; ++ix)
+    auto const filename = std::string("dzBy_interpOrder_")
+                          + std::to_string(TestFixture::interp_order) + std::string("_3d.txt");
+    auto const expDerValue = read(filename);
+
+    for (auto const [amr_idx, lcl_idx] : this->layout.ghost_amr_lcl_idx(this->By))
     {
-        for (auto iy = 0u; iy <= gei_p_Y; ++iy)
-        {
-            for (auto iz = 0u; iz <= gei_d_Z; ++iz)
-            {
-                auto point = this->layout.fieldNodeCoordinates(this->By, {0., 0., 0.}, ix, iy, iz);
-                this->By(ix, iy, iz) = std::sin(2 * M_PI / 5. * point[0])
-                                       * std::cos(2 * M_PI / 6. * point[1])
-                                       * std::sin(2 * M_PI / 12. * point[2]);
-            }
-        }
+        auto point        = this->layout.fieldNodeCoordinates(this->By, amr_idx);
+        this->By(lcl_idx) = std::sin(2 * M_PI / 5. * point[0]) * std::cos(2 * M_PI / 6. * point[1])
+                            * std::sin(2 * M_PI / 12. * point[2]);
     }
 
-    auto nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::By, Direction::Z);
+    auto const nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::By, Direction::Z);
 
-    for (auto ix = psi_d_X; ix <= pei_d_X; ++ix)
+    for (auto const lcl_idx : this->layout.AMRToLocal(this->layout.AMRBox()))
     {
-        for (auto iy = psi_p_Y; iy <= pei_p_Y; ++iy)
-        {
-            for (auto iz = psi_p_Z; iz <= pei_p_Z; ++iz)
-            {
-                auto localDerivative
-                    = this->layout.template deriv<Direction::Z>(this->By, {ix, iy, iz});
-                auto index_ = ix * nPts_[1] * nPts_[2] + iy * nPts_[2] + iz;
-                EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
-            }
-        }
+        auto const localDerivative = this->layout.template deriv<Direction::Z>(this->By, lcl_idx);
+        auto index_ = lcl_idx[0] * nPts_[1] * nPts_[2] + lcl_idx[1] * nPts_[2] + lcl_idx[2];
+        EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
     }
 }
 
@@ -405,48 +272,24 @@ TYPED_TEST(a3DDerivative, DZBY3D)
 
 TYPED_TEST(a3DDerivative, DXEZ3D)
 {
-    std::string filename = std::string("dxEz_interpOrder_")
-                           + std::to_string(TestFixture::interp_order) + std::string("_3d.txt");
-    auto expDerValue = read(filename);
-
-    auto gei_p_X = this->layout.ghostEndIndex(QtyCentering::primal, Direction::X);
-    auto gei_p_Y = this->layout.ghostEndIndex(QtyCentering::primal, Direction::Y);
-    auto gei_d_Z = this->layout.ghostEndIndex(QtyCentering::dual, Direction::Z);
-    auto psi_d_X = this->layout.physicalStartIndex(QtyCentering::dual, Direction::X);
-    auto pei_d_X = this->layout.physicalEndIndex(QtyCentering::dual, Direction::X);
-    auto psi_p_Y = this->layout.physicalStartIndex(QtyCentering::primal, Direction::Y);
-    auto pei_p_Y = this->layout.physicalEndIndex(QtyCentering::primal, Direction::Y);
-    auto psi_d_Z = this->layout.physicalStartIndex(QtyCentering::dual, Direction::Z);
-    auto pei_d_Z = this->layout.physicalEndIndex(QtyCentering::dual, Direction::Z);
-
-    for (auto ix = 0u; ix <= gei_p_X; ++ix)
+    auto const filename = std::string("dxEz_interpOrder_")
+                          + std::to_string(TestFixture::interp_order) + std::string("_3d.txt");
+    auto const expDerValue = read(filename);
+
+    for (auto const [amr_idx, lcl_idx] : this->layout.ghost_amr_lcl_idx(this->Ez))
     {
-        for (auto iy = 0u; iy <= gei_p_Y; ++iy)
-        {
-            for (auto iz = 0u; iz <= gei_d_Z; ++iz)
-            {
-                auto point = this->layout.fieldNodeCoordinates(this->Ez, {0., 0., 0.}, ix, iy, iz);
-                this->Ez(ix, iy, iz) = std::sin(2 * M_PI / 5. * point[0])
-                                       * std::cos(2 * M_PI / 6. * point[1])
-                                       * std::sin(2 * M_PI / 12. * point[2]);
-            }
-        }
+        auto point        = this->layout.fieldNodeCoordinates(this->Ez, amr_idx);
+        this->Ez(lcl_idx) = std::sin(2 * M_PI / 5. * point[0]) * std::cos(2 * M_PI / 6. * point[1])
+                            * std::sin(2 * M_PI / 12. * point[2]);
     }
 
-    auto nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::Ez, Direction::X);
+    auto const nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::Ez, Direction::X);
 
-    for (auto ix = psi_d_X; ix <= pei_d_X; ++ix)
+    for (auto const lcl_idx : this->layout.AMRToLocal(this->layout.AMRBox()))
     {
-        for (auto iy = psi_p_Y; iy <= pei_p_Y; ++iy)
-        {
-            for (auto iz = psi_d_Z; iz <= pei_d_Z; ++iz)
-            {
-                auto localDerivative
-                    = this->layout.template deriv<Direction::X>(this->Ez, {ix, iy, iz});
-                auto index_ = ix * nPts_[1] * nPts_[2] + iy * nPts_[2] + iz;
-                EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
-            }
-        }
+        auto const localDerivative = this->layout.template deriv<Direction::X>(this->Ez, lcl_idx);
+        auto index_ = lcl_idx[0] * nPts_[1] * nPts_[2] + lcl_idx[1] * nPts_[2] + lcl_idx[2];
+        EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
     }
 }
 
@@ -454,48 +297,24 @@ TYPED_TEST(a3DDerivative, DXEZ3D)
 
 TYPED_TEST(a3DDerivative, DYEZ3D)
 {
-    std::string filename = std::string("dyEz_interpOrder_")
-                           + std::to_string(TestFixture::interp_order) + std::string("_3d.txt");
-    auto expDerValue = read(filename);
-
-    auto gei_p_X = this->layout.ghostEndIndex(QtyCentering::primal, Direction::X);
-    auto gei_p_Y = this->layout.ghostEndIndex(QtyCentering::primal, Direction::Y);
-    auto gei_d_Z = this->layout.ghostEndIndex(QtyCentering::dual, Direction::Z);
-    auto psi_p_X = this->layout.physicalStartIndex(QtyCentering::primal, Direction::X);
-    auto pei_p_X = this->layout.physicalEndIndex(QtyCentering::primal, Direction::X);
-    auto psi_d_Y = this->layout.physicalStartIndex(QtyCentering::dual, Direction::Y);
-    auto pei_d_Y = this->layout.physicalEndIndex(QtyCentering::dual, Direction::Y);
-    auto psi_d_Z = this->layout.physicalStartIndex(QtyCentering::dual, Direction::Z);
-    auto pei_d_Z = this->layout.physicalEndIndex(QtyCentering::dual, Direction::Z);
-
-    for (auto ix = 0u; ix <= gei_p_X; ++ix)
+    auto const filename = std::string("dyEz_interpOrder_")
+                          + std::to_string(TestFixture::interp_order) + std::string("_3d.txt");
+    auto const expDerValue = read(filename);
+
+    for (auto const [amr_idx, lcl_idx] : this->layout.ghost_amr_lcl_idx(this->Ez))
     {
-        for (auto iy = 0u; iy <= gei_p_Y; ++iy)
-        {
-            for (auto iz = 0u; iz <= gei_d_Z; ++iz)
-            {
-                auto point = this->layout.fieldNodeCoordinates(this->Ez, {0., 0., 0.}, ix, iy, iz);
-                this->Ez(ix, iy, iz) = std::sin(2 * M_PI / 5. * point[0])
-                                       * std::cos(2 * M_PI / 6. * point[1])
-                                       * std::sin(2 * M_PI / 12. * point[2]);
-            }
-        }
+        auto point        = this->layout.fieldNodeCoordinates(this->Ez, amr_idx);
+        this->Ez(lcl_idx) = std::sin(2 * M_PI / 5. * point[0]) * std::cos(2 * M_PI / 6. * point[1])
+                            * std::sin(2 * M_PI / 12. * point[2]);
     }
 
-    auto nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::Ez, Direction::Y);
+    auto const nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::Ez, Direction::Y);
 
-    for (auto ix = psi_p_X; ix <= pei_p_X; ++ix)
+    for (auto const lcl_idx : this->layout.AMRToLocal(this->layout.AMRBox()))
     {
-        for (auto iy = psi_d_Y; iy <= pei_d_Y; ++iy)
-        {
-            for (auto iz = psi_d_Z; iz <= pei_d_Z; ++iz)
-            {
-                auto localDerivative
-                    = this->layout.template deriv<Direction::Y>(this->Ez, {ix, iy, iz});
-                auto index_ = ix * nPts_[1] * nPts_[2] + iy * nPts_[2] + iz;
-                EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
-            }
-        }
+        auto const localDerivative = this->layout.template deriv<Direction::Y>(this->Ez, lcl_idx);
+        auto index_ = lcl_idx[0] * nPts_[1] * nPts_[2] + lcl_idx[1] * nPts_[2] + lcl_idx[2];
+        EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
     }
 }
 
@@ -503,47 +322,23 @@ TYPED_TEST(a3DDerivative, DYEZ3D)
 
 TYPED_TEST(a3DDerivative, DZEZ3D)
 {
-    std::string filename = std::string("dzEz_interpOrder_")
-                           + std::to_string(TestFixture::interp_order) + std::string("_3d.txt");
-    auto expDerValue = read(filename);
-
-    auto gei_p_X = this->layout.ghostEndIndex(QtyCentering::primal, Direction::X);
-    auto gei_p_Y = this->layout.ghostEndIndex(QtyCentering::primal, Direction::Y);
-    auto gei_d_Z = this->layout.ghostEndIndex(QtyCentering::dual, Direction::Z);
-    auto psi_p_X = this->layout.physicalStartIndex(QtyCentering::primal, Direction::X);
-    auto pei_p_X = this->layout.physicalEndIndex(QtyCentering::primal, Direction::X);
-    auto psi_p_Y = this->layout.physicalStartIndex(QtyCentering::primal, Direction::Y);
-    auto pei_p_Y = this->layout.physicalEndIndex(QtyCentering::primal, Direction::Y);
-    auto psi_p_Z = this->layout.physicalStartIndex(QtyCentering::primal, Direction::Z);
-    auto pei_p_Z = this->layout.physicalEndIndex(QtyCentering::primal, Direction::Z);
-
-    for (auto ix = 0u; ix <= gei_p_X; ++ix)
+    auto const filename = std::string("dzEz_interpOrder_")
+                          + std::to_string(TestFixture::interp_order) + std::string("_3d.txt");
+    auto const expDerValue = read(filename);
+
+    for (auto const [amr_idx, lcl_idx] : this->layout.ghost_amr_lcl_idx(this->Ez))
     {
-        for (auto iy = 0u; iy <= gei_p_Y; ++iy)
-        {
-            for (auto iz = 0u; iz <= gei_d_Z; ++iz)
-            {
-                auto point = this->layout.fieldNodeCoordinates(this->Ez, {0., 0., 0.}, ix, iy, iz);
-                this->Ez(ix, iy, iz) = std::sin(2 * M_PI / 5. * point[0])
-                                       * std::cos(2 * M_PI / 6. * point[1])
-                                       * std::sin(2 * M_PI / 12. * point[2]);
-            }
-        }
+        auto point        = this->layout.fieldNodeCoordinates(this->Ez, amr_idx);
+        this->Ez(lcl_idx) = std::sin(2 * M_PI / 5. * point[0]) * std::cos(2 * M_PI / 6. * point[1])
+                            * std::sin(2 * M_PI / 12. * point[2]);
     }
 
-    auto nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::Ez, Direction::Z);
+    auto const nPts_ = this->layout.allocSizeDerived(HybridQuantity::Scalar::Ez, Direction::Z);
 
-    for (auto ix = psi_p_X; ix <= pei_p_X; ++ix)
+    for (auto const lcl_idx : this->layout.AMRToLocal(this->layout.AMRBox()))
     {
-        for (auto iy = psi_p_Y; iy <= pei_p_Y; ++iy)
-        {
-            for (auto iz = psi_p_Z; iz <= pei_p_Z; ++iz)
-            {
-                auto localDerivative
-                    = this->layout.template deriv<Direction::Z>(this->Ez, {ix, iy, iz});
-                auto index_ = ix * nPts_[1] * nPts_[2] + iy * nPts_[2] + iz;
-                EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
-            }
-        }
+        auto const localDerivative = this->layout.template deriv<Direction::Z>(this->Ez, lcl_idx);
+        auto index_ = lcl_idx[0] * nPts_[1] * nPts_[2] + lcl_idx[1] * nPts_[2] + lcl_idx[2];
+        EXPECT_THAT(localDerivative, ::testing::DoubleNear(expDerValue[index_], 1e-12));
     }
 }
diff --git a/tests/core/data/gridlayout/gridlayout_deriv.hpp b/tests/core/data/gridlayout/gridlayout_deriv.hpp
index 9cf6e4b2e..34eb8694b 100644
--- a/tests/core/data/gridlayout/gridlayout_deriv.hpp
+++ b/tests/core/data/gridlayout/gridlayout_deriv.hpp
@@ -24,19 +24,21 @@ std::vector<double> read(std::string filename);
 template<typename GridLayoutImpl>
 class a1DDerivative : public ::testing::Test
 {
-protected:
-    GridLayout<GridLayoutImpl> layout;
-    static constexpr std::size_t interp_order = GridLayoutImpl::interp_order;
-    Grid<NdArrayVector<1>, HybridQuantity::Scalar> By;
-    Grid<NdArrayVector<1>, HybridQuantity::Scalar> Ez;
-
 public:
+    using GridLayout_t = GridLayout<GridLayoutImpl>;
+
     a1DDerivative()
         : layout{{{0.1}}, {50}, Point{0.}}
         , By{"By", HybridQuantity::Scalar::By, layout.allocSize(HybridQuantity::Scalar::By)}
         , Ez{"Ez", HybridQuantity::Scalar::Ez, layout.allocSize(HybridQuantity::Scalar::Ez)}
     {
     }
+
+protected:
+    GridLayout_t layout;
+    static constexpr std::size_t interp_order = GridLayoutImpl::interp_order;
+    Grid<NdArrayVector<1>, HybridQuantity::Scalar> By;
+    Grid<NdArrayVector<1>, HybridQuantity::Scalar> Ez;
 };
 
 
@@ -44,19 +46,21 @@ class a1DDerivative : public ::testing::Test
 template<typename GridLayoutImpl>
 class a2DDerivative : public ::testing::Test
 {
-protected:
-    GridLayout<GridLayoutImpl> layout;
-    static constexpr std::size_t interp_order = GridLayoutImpl::interp_order;
-    Grid<NdArrayVector<2>, HybridQuantity::Scalar> By;
-    Grid<NdArrayVector<2>, HybridQuantity::Scalar> Ez;
-
 public:
+    using GridLayout_t = GridLayout<GridLayoutImpl>;
+
     a2DDerivative()
         : layout{{{0.1, 0.2}}, {50, 30}, Point{0., 0.}}
         , By{"By", HybridQuantity::Scalar::By, layout.allocSize(HybridQuantity::Scalar::By)}
         , Ez{"Ez", HybridQuantity::Scalar::Ez, layout.allocSize(HybridQuantity::Scalar::Ez)}
     {
     }
+
+protected:
+    GridLayout_t layout;
+    static constexpr std::size_t interp_order = GridLayoutImpl::interp_order;
+    Grid<NdArrayVector<2>, HybridQuantity::Scalar> By;
+    Grid<NdArrayVector<2>, HybridQuantity::Scalar> Ez;
 };
 
 
@@ -64,19 +68,20 @@ class a2DDerivative : public ::testing::Test
 template<typename GridLayoutImpl>
 class a3DDerivative : public ::testing::Test
 {
-protected:
-    GridLayout<GridLayoutImpl> layout;
-    static constexpr std::size_t interp_order = GridLayoutImpl::interp_order;
-    Grid<NdArrayVector<3>, HybridQuantity::Scalar> By;
-    Grid<NdArrayVector<3>, HybridQuantity::Scalar> Ez;
-
 public:
+    using GridLayout_t = GridLayout<GridLayoutImpl>;
     a3DDerivative()
         : layout{{{0.1, 0.2, 0.3}}, {50, 30, 40}, Point{0., 0., 0.}}
         , By{"By", HybridQuantity::Scalar::By, layout.allocSize(HybridQuantity::Scalar::By)}
         , Ez{"Ez", HybridQuantity::Scalar::Ez, layout.allocSize(HybridQuantity::Scalar::Ez)}
     {
     }
+
+protected:
+    GridLayout_t layout;
+    static constexpr std::size_t interp_order = GridLayoutImpl::interp_order;
+    Grid<NdArrayVector<3>, HybridQuantity::Scalar> By;
+    Grid<NdArrayVector<3>, HybridQuantity::Scalar> Ez;
 };
 
 
diff --git a/tests/core/data/gridlayout/gridlayout_field_centered_coord.hpp b/tests/core/data/gridlayout/gridlayout_field_centered_coord.hpp
index e7a363012..a1360b2f6 100644
--- a/tests/core/data/gridlayout/gridlayout_field_centered_coord.hpp
+++ b/tests/core/data/gridlayout/gridlayout_field_centered_coord.hpp
@@ -1,14 +1,14 @@
 #ifndef TESTS_CORE_DATA_GRIDLAYOUT_GRIDLAYOUT_FIELD_CENTERED_COORD_HPP
 #define TESTS_CORE_DATA_GRIDLAYOUT_GRIDLAYOUT_FIELD_CENTERED_COORD_HPP
 
-#include <array>
 
-#include "core/data/grid/gridlayout.hpp"
-#include "gridlayout_base_params.hpp"
-#include "gridlayout_params.hpp"
-#include "gridlayout_utilities.hpp"
 #include "core/utilities/point/point.hpp"
 
+#include "gridlayout_params.hpp"
+#include "gridlayout_base_params.hpp"
+
+#include <array>
+
 using namespace PHARE::core;
 
 template<typename GridLayoutImpl>
@@ -16,25 +16,10 @@ struct GridLayoutFieldCenteringParam
 {
     GridLayoutTestParam<GridLayoutImpl> base;
 
-    std::vector<std::array<std::uint32_t, GridLayoutImpl::dimension>> iCellForCentering;
+    std::vector<Point<int, GridLayoutImpl::dimension>> iCellForCentering;
     std::vector<std::array<double, GridLayoutImpl::dimension>> expectedPosition;
     std::vector<std::array<double, GridLayoutImpl::dimension>> actualPosition;
 
-    template<typename Array, std::size_t... I>
-    auto fieldCoord_impl(Array const& array, std::index_sequence<I...>)
-    {
-        auto& field  = base.field;
-        auto& layout = base.layout;
-        auto& origin = base.origin;
-
-        return layout->fieldNodeCoordinates(*field, origin, array[I]...);
-    }
-
-    template<typename T, std::size_t N, typename Indices = std::make_index_sequence<N>>
-    auto fieldCoord(const std::array<T, N>& array)
-    {
-        return fieldCoord_impl(array, Indices{});
-    }
 
     void init()
     {
@@ -46,18 +31,8 @@ struct GridLayoutFieldCenteringParam
 
         for (auto&& iCell : iCellForCentering)
         {
-            Point<double, GridLayoutImpl::dimension> pos;
-            pos = fieldCoord(iCell);
-
-            std::array<double, GridLayoutImpl::dimension> actualPos;
-
-            for (std::size_t iDim = 0; iDim < GridLayoutImpl::dimension; ++iDim)
-            {
-                actualPos[iDim] = pos[iDim];
-            }
-
-
-            actualPosition.push_back(actualPos);
+            auto const pos = layout->fieldNodeCoordinates(*field, iCell);
+            actualPosition.push_back(*pos);
         }
     }
 };
@@ -83,7 +58,7 @@ auto createFieldCenteringParam()
 
     std::string layoutName{"yee"};
 
-    const std::map<std::string, HybridQuantity::Scalar> namesToQuantity{
+    std::map<std::string, HybridQuantity::Scalar> const namesToQuantity{
         {"Bx", HybridQuantity::Scalar::Bx}, {"By", HybridQuantity::Scalar::By},
         {"Bz", HybridQuantity::Scalar::Bz}, {"Ex", HybridQuantity::Scalar::Ex},
         {"Ey", HybridQuantity::Scalar::Ey}, {"Ez", HybridQuantity::Scalar::Ez},
@@ -112,9 +87,8 @@ auto createFieldCenteringParam()
 
         params.emplace_back();
 
-        // NOTE: before c++17 Point{origin} cannot deduce the corect type
-        params.back().base = createParam<GridLayoutImpl>(
-            dl, nbCell, Point<double, GridLayoutImpl::dimension>{origin});
+
+        params.back().base = createParam<GridLayoutImpl>(dl, nbCell, Point{origin});
 
         auto quantityIt = namesToQuantity.find(quantity);
         if (quantityIt != namesToQuantity.end())
@@ -130,8 +104,9 @@ auto createFieldCenteringParam()
         auto quantityIt = namesToQuantity.find(quantity);
         if (quantityIt != namesToQuantity.end())
         {
-            auto hqIndex = static_cast<int>(quantityIt->second);
+            auto hqIndex = static_cast<std::size_t>(quantityIt->second);
 
+            assert(hqIndex < params.size());
             auto& param = params[hqIndex];
 
             param.iCellForCentering.push_back(icell);
diff --git a/tests/core/data/gridlayout/gridlayout_laplacian.cpp b/tests/core/data/gridlayout/gridlayout_laplacian.cpp
index 24ee8555c..402691fbc 100644
--- a/tests/core/data/gridlayout/gridlayout_laplacian.cpp
+++ b/tests/core/data/gridlayout/gridlayout_laplacian.cpp
@@ -31,7 +31,8 @@ TYPED_TEST(a1DLaplacian, LaplacianJx1D)
 
     for (auto ix = gsi_X; ix <= gei_X; ++ix)
     {
-        auto point   = this->layout.fieldNodeCoordinates(this->Jx, Point{0.}, ix);
+        auto point = this->layout.fieldNodeCoordinates(
+            this->Jx, this->layout.localToAMR(Point{ix}.as_signed()));
         this->Jx(ix) = std::sinh(0.1 * point[0]);
     }
 
@@ -59,7 +60,8 @@ TYPED_TEST(a1DLaplacian, LaplacianJy1D)
 
     for (auto ix = gsi_X; ix <= gei_X; ++ix)
     {
-        auto point   = this->layout.fieldNodeCoordinates(this->Jy, Point{0.}, ix);
+        auto point = this->layout.fieldNodeCoordinates(
+            this->Jy, this->layout.localToAMR(Point{ix}.as_signed()));
         this->Jy(ix) = std::sinh(0.3 * point[0]);
     }
 
@@ -87,7 +89,8 @@ TYPED_TEST(a1DLaplacian, LaplacianJz1D)
 
     for (auto ix = gsi_X; ix <= gei_X; ++ix)
     {
-        auto point   = this->layout.fieldNodeCoordinates(this->Jz, Point{0.}, ix);
+        auto point = this->layout.fieldNodeCoordinates(
+            this->Jz, this->layout.localToAMR(Point{ix}.as_signed()));
         this->Jz(ix) = std::sinh(0.2 * point[0]);
     }
 
@@ -131,7 +134,8 @@ TYPED_TEST(a2DLaplacian, LaplacianJx2D)
     {
         for (auto iy = gsi_Y; iy <= gei_Y; ++iy)
         {
-            auto point       = this->layout.fieldNodeCoordinates(this->Jx, Point{0., 0.}, ix, iy);
+            auto point = this->layout.fieldNodeCoordinates(
+                this->Jx, this->layout.localToAMR(Point{ix, iy}.as_signed()));
             this->Jx(ix, iy) = std::sinh(0.1 * point[0]) * std::cosh(0.1 * point[1]);
         }
     }
@@ -173,7 +177,8 @@ TYPED_TEST(a2DLaplacian, LaplacianJy2D)
     {
         for (auto iy = gsi_Y; iy <= gei_Y; ++iy)
         {
-            auto point       = this->layout.fieldNodeCoordinates(this->Jy, Point{0., 0.}, ix, iy);
+            auto point = this->layout.fieldNodeCoordinates(
+                this->Jy, this->layout.localToAMR(Point{ix, iy}.as_signed()));
             this->Jy(ix, iy) = std::sinh(0.3 * point[0]) * std::cosh(0.3 * point[1]);
         }
     }
@@ -215,7 +220,8 @@ TYPED_TEST(a2DLaplacian, LaplacianJz2D)
     {
         for (auto iy = gsi_Y; iy <= gei_Y; ++iy)
         {
-            auto point       = this->layout.fieldNodeCoordinates(this->Jz, Point{0., 0.}, ix, iy);
+            auto point = this->layout.fieldNodeCoordinates(
+                this->Jz, this->layout.localToAMR(Point{ix, iy}.as_signed()));
             this->Jz(ix, iy) = std::sinh(0.2 * point[0]) * std::cosh(0.2 * point[1]);
         }
     }
@@ -275,8 +281,8 @@ TYPED_TEST(a3DLaplacian, LaplacianJx3D)
         {
             for (auto iz = gsi_Z; iz <= gei_Z; ++iz)
             {
-                auto point
-                    = this->layout.fieldNodeCoordinates(this->Jx, Point{0., 0., 0.}, ix, iy, iz);
+                auto point = this->layout.fieldNodeCoordinates(
+                    this->Jx, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
                 this->Jx(ix, iy, iz) = std::sinh(0.1 * point[0]) * std::cosh(0.1 * point[1])
                                        * std::tanh(0.1 * point[2]);
             }
@@ -330,8 +336,8 @@ TYPED_TEST(a3DLaplacian, LaplacianJy3D)
         {
             for (auto iz = gsi_Z; iz <= gei_Z; ++iz)
             {
-                auto point
-                    = this->layout.fieldNodeCoordinates(this->Jy, Point{0., 0., 0.}, ix, iy, iz);
+                auto point = this->layout.fieldNodeCoordinates(
+                    this->Jy, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
                 this->Jy(ix, iy, iz) = std::sinh(0.3 * point[0]) * std::cosh(0.3 * point[1])
                                        * std::tanh(0.3 * point[2]);
             }
@@ -385,8 +391,8 @@ TYPED_TEST(a3DLaplacian, LaplacianJz3D)
         {
             for (auto iz = gsi_Z; iz <= gei_Z; ++iz)
             {
-                auto point
-                    = this->layout.fieldNodeCoordinates(this->Jz, Point{0., 0., 0.}, ix, iy, iz);
+                auto point = this->layout.fieldNodeCoordinates(
+                    this->Jz, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
                 this->Jz(ix, iy, iz) = std::sinh(0.2 * point[0]) * std::cosh(0.2 * point[1])
                                        * std::tanh(0.2 * point[2]);
             }
diff --git a/tests/core/data/gridlayout/test_main.cpp b/tests/core/data/gridlayout/test_main.cpp
index 0f4f44837..bd9c6785f 100644
--- a/tests/core/data/gridlayout/test_main.cpp
+++ b/tests/core/data/gridlayout/test_main.cpp
@@ -1,9 +1,8 @@
-#include "core/data/grid/gridlayout.hpp"
-#include "core/data/grid/gridlayoutimplyee.hpp"
-#include "gridlayout_test.hpp"
-#include "core/utilities/types.hpp"
 
-#include "gmock/gmock.h"
+
+
+
+
 #include "gtest/gtest.h"
 
 
diff --git a/tests/core/data/maxwellian_particle_initializer/test_maxwellian_particle_initializer.cpp b/tests/core/data/maxwellian_particle_initializer/test_maxwellian_particle_initializer.cpp
index f3f4899cb..5c3f513e0 100644
--- a/tests/core/data/maxwellian_particle_initializer/test_maxwellian_particle_initializer.cpp
+++ b/tests/core/data/maxwellian_particle_initializer/test_maxwellian_particle_initializer.cpp
@@ -65,7 +65,7 @@ TEST_F(AMaxwellianParticleInitializer1D, loadsParticlesInTheDomain)
     {
         EXPECT_TRUE(particle.iCell[0] >= 50 && particle.iCell[0] <= 99);
         auto pos       = positionAsPoint(particle, layout);
-        auto endDomain = layout.origin()[0] + layout.nbrCells()[0] * layout.meshSize()[0];
+        auto endDomain = (layout.AMRBox().upper[0] + 1) * layout.meshSize()[0];
 
         if (!((pos[0] > 0.) and (pos[0] < endDomain)))
             std::cout << "position : " << pos[0] << " not in domain (0," << endDomain << ")\n";
diff --git a/tests/core/data/particles/test_main.cpp b/tests/core/data/particles/test_main.cpp
index f3ad991c1..b34feec12 100644
--- a/tests/core/data/particles/test_main.cpp
+++ b/tests/core/data/particles/test_main.cpp
@@ -80,14 +80,13 @@ TEST_F(AParticle, CanBeReducedToAnAbsolutePositionPoint)
     GridLayout<GridLayoutImplYee<3, 1>> layout{meshSize, nbrCells, origin,
                                                Box{Point{40, 60, 80}, Point{59, 89, 119}}};
 
-    auto iCell            = layout.AMRToLocal(Point{part.iCell});
+    auto iCell            = part.iCell;
     auto p                = positionAsPoint(part, layout);
     auto startIndexes     = layout.physicalStartIndex(QtyCentering::primal);
     auto expectedPosition = Point<double, 3>{};
     for (auto i = 0u; i < 3; ++i)
     {
-        expectedPosition[i]
-            = origin[i] + meshSize[i] * (iCell[i] - startIndexes[i] + part.delta[i]);
+        expectedPosition[i] = meshSize[i] * (iCell[i] + part.delta[i]);
         EXPECT_DOUBLE_EQ(expectedPosition[i], p[i]);
     }
 }
diff --git a/tests/core/data/particles/test_particle_array_consistency.cpp b/tests/core/data/particles/test_particle_array_consistency.cpp
index e46062374..b603a4157 100644
--- a/tests/core/data/particles/test_particle_array_consistency.cpp
+++ b/tests/core/data/particles/test_particle_array_consistency.cpp
@@ -1,5 +1,3 @@
-
-
 #include "phare_core.hpp"
 #include "core/utilities/types.hpp"
 #include "core/data/particles/particle_array.hpp"
@@ -29,9 +27,9 @@ PHARE::core::Particle<dim> particle(ICell const& icell)
 template<typename ParticleArray_t, typename Box_t>
 void add_particles_in(ParticleArray_t& particles, Box_t const& box)
 {
-    for (auto const& bix : box)
+    for (auto const& amr_idx : box)
         for (std::size_t i = 0; i < ppc; ++i)
-            particles.emplace_back(particle<ParticleArray_t::dimension>(*bix));
+            particles.emplace_back(particle<ParticleArray_t::dimension>(*amr_idx));
 }
 
 
diff --git a/tests/core/numerics/ampere/test_main.cpp b/tests/core/numerics/ampere/test_main.cpp
index ec9827539..738c8f588 100644
--- a/tests/core/numerics/ampere/test_main.cpp
+++ b/tests/core/numerics/ampere/test_main.cpp
@@ -27,7 +27,7 @@ using namespace PHARE::core;
 
 struct GridLayoutMock1D
 {
-    static const auto dimension = 1u;
+    static auto const dimension = 1u;
 
     template<auto direction>
     double deriv(FieldMock<1> const& /*f*/, MeshIndex<1u> /*mi*/)
@@ -42,7 +42,7 @@ struct GridLayoutMock1D
 
 struct GridLayoutMock2D
 {
-    static const auto dimension = 2u;
+    static auto const dimension = 2u;
 
     template<auto direction>
     double deriv(FieldMock<dimension> const& /*f*/, MeshIndex<2u> /*mi*/)
@@ -57,7 +57,7 @@ struct GridLayoutMock2D
 
 struct GridLayoutMock3D
 {
-    static const auto dimension = 3u;
+    static auto const dimension = 3u;
 
     template<auto direction>
     double deriv(FieldMock<dimension> const& /*f*/, MeshIndex<3u> /*mi*/)
@@ -205,9 +205,10 @@ TEST_F(Ampere1DTest, ampere1DCalculatedOk)
 
     for (std::uint32_t ix = gsi_d_X; ix <= gei_d_X; ++ix)
     {
-        auto point = this->layout.fieldNodeCoordinates(By, Point{0.}, ix);
-        By(ix)     = std::cos(2 * M_PI / 5. * point[0]);
-        Bz(ix)     = std::sin(2 * M_PI / 5. * point[0]);
+        auto point
+            = this->layout.fieldNodeCoordinates(By, this->layout.localToAMR(Point{ix}.as_signed()));
+        By(ix) = std::cos(2 * M_PI / 5. * point[0]);
+        Bz(ix) = std::sin(2 * M_PI / 5. * point[0]);
     }
 
     ampere.setLayout(&layout);
@@ -249,7 +250,8 @@ TEST_F(Ampere2DTest, ampere2DCalculatedOk)
     {
         for (std::uint32_t iy = gsi_d_Y; iy <= gei_d_Y; ++iy)
         {
-            auto point = this->layout.fieldNodeCoordinates(Bx, Point{0., 0.}, ix, iy);
+            auto point = this->layout.fieldNodeCoordinates(
+                Bx, layout.localToAMR(Point{ix, iy}.as_signed()));
             Bx(ix, iy) = std::cos(2 * M_PI / 5. * point[0]) * std::sin(2 * M_PI / 6. * point[1]);
         }
     }
@@ -258,7 +260,8 @@ TEST_F(Ampere2DTest, ampere2DCalculatedOk)
     {
         for (std::uint32_t iy = gsi_p_Y; iy <= gei_p_Y; ++iy)
         {
-            auto point = this->layout.fieldNodeCoordinates(By, Point{0., 0.}, ix, iy);
+            auto point = this->layout.fieldNodeCoordinates(
+                By, layout.localToAMR(Point{ix, iy}.as_signed()));
             By(ix, iy) = std::cos(2 * M_PI / 5. * point[0]) * std::tanh(2 * M_PI / 6. * point[1]);
         }
     }
@@ -267,7 +270,8 @@ TEST_F(Ampere2DTest, ampere2DCalculatedOk)
     {
         for (std::uint32_t iy = gsi_d_Y; iy <= gei_d_Y; ++iy)
         {
-            auto point = this->layout.fieldNodeCoordinates(Bz, Point{0., 0.}, ix, iy);
+            auto point = this->layout.fieldNodeCoordinates(
+                Bz, layout.localToAMR(Point{ix, iy}.as_signed()));
             Bz(ix, iy) = std::sin(2 * M_PI / 5. * point[0]) * std::tanh(2 * M_PI / 6. * point[1]);
         }
     }
@@ -352,7 +356,7 @@ TEST_F(Ampere3DTest, ampere3DCalculatedOk)
             for (std::uint32_t iz = gsi_d_Z; iz <= gei_d_Z; ++iz)
             {
                 Point<double, 3> point = this->layout.fieldNodeCoordinates(
-                    Bx, Point<double, 3>{0., 0., 0.}, ix, iy, iz);
+                    Bx, layout.localToAMR(Point{ix, iy, iz}.as_signed()));
                 Bx(ix, iy, iz) = std::sin(2 * M_PI / 5. * point[0])
                                  * std::cos(2 * M_PI / 6. * point[1])
                                  * std::tanh(2 * M_PI / 12. * point[2]);
@@ -367,7 +371,7 @@ TEST_F(Ampere3DTest, ampere3DCalculatedOk)
             for (std::uint32_t iz = gsi_d_Z; iz <= gei_d_Z; ++iz)
             {
                 Point<double, 3> point = this->layout.fieldNodeCoordinates(
-                    By, Point<double, 3>{0., 0., 0.}, ix, iy, iz);
+                    By, layout.localToAMR(Point{ix, iy, iz}.as_signed()));
                 By(ix, iy, iz) = std::tanh(2 * M_PI / 5. * point[0])
                                  * std::sin(2 * M_PI / 6. * point[1])
                                  * std::cos(2 * M_PI / 12. * point[2]);
@@ -382,7 +386,7 @@ TEST_F(Ampere3DTest, ampere3DCalculatedOk)
             for (std::uint32_t iz = gsi_p_Z; iz <= gei_p_Z; ++iz)
             {
                 Point<double, 3> point = this->layout.fieldNodeCoordinates(
-                    Bz, Point<double, 3>{0., 0., 0.}, ix, iy, iz);
+                    Bz, layout.localToAMR(Point{ix, iy, iz}.as_signed()));
                 Bz(ix, iy, iz) = std::cos(2 * M_PI / 5. * point[0])
                                  * std::tanh(2 * M_PI / 6. * point[1])
                                  * std::sin(2 * M_PI / 12. * point[2]);
diff --git a/tests/core/numerics/faraday/test_main.cpp b/tests/core/numerics/faraday/test_main.cpp
index 09637a3d3..8c437ba8a 100644
--- a/tests/core/numerics/faraday/test_main.cpp
+++ b/tests/core/numerics/faraday/test_main.cpp
@@ -27,7 +27,7 @@ using namespace PHARE::core;
 
 struct GridLayoutMock1D
 {
-    static const auto dimension = 1u;
+    static auto const dimension = 1u;
 
     template<auto direction>
     double deriv(FieldMock<1> const& /*f*/, MeshIndex<1u> /*mi*/)
@@ -41,7 +41,7 @@ struct GridLayoutMock1D
 
 struct GridLayoutMock2D
 {
-    static const auto dimension = 2u;
+    static auto const dimension = 2u;
 
     template<auto direction>
     double deriv(FieldMock<dimension> const& /*f*/, MeshIndex<2u> /*mi*/)
@@ -55,7 +55,7 @@ struct GridLayoutMock2D
 
 struct GridLayoutMock3D
 {
-    static const auto dimension = 3u;
+    static auto const dimension = 3u;
 
 
     template<auto direction>
@@ -234,7 +234,8 @@ TEST_F(Faraday1DTest, Faraday1DCalculatedOk)
 
     for (auto ix = gsi_p_X; ix <= gei_p_X; ++ix)
     {
-        auto point = this->layout.fieldNodeCoordinates(Ey, Point{0.}, ix);
+        auto point
+            = this->layout.fieldNodeCoordinates(Ey, this->layout.localToAMR(Point{ix}.as_signed()));
 
         Ey(ix) = std::cos(2 * M_PI / 5. * point[0]);
         Ez(ix) = std::sin(2 * M_PI / 5. * point[0]);
@@ -245,7 +246,8 @@ TEST_F(Faraday1DTest, Faraday1DCalculatedOk)
 
     for (auto ix = gsi_d_X; ix <= gei_d_X; ++ix)
     {
-        auto point = this->layout.fieldNodeCoordinates(By, Point{0.}, ix);
+        auto point
+            = this->layout.fieldNodeCoordinates(By, this->layout.localToAMR(Point{ix}.as_signed()));
 
         By(ix) = std::tanh(point[0] - 5. / 2.);
         Bz(ix) = std::tanh(point[0] - 5. / 2.);
@@ -294,7 +296,8 @@ TEST_F(Faraday2DTest, Faraday2DCalculatedOk)
     {
         for (auto iy = gsi_p_Y; iy <= gei_p_Y; ++iy)
         {
-            auto point = this->layout.fieldNodeCoordinates(Ex, Point{0., 0.}, ix, iy);
+            auto point = this->layout.fieldNodeCoordinates(
+                Ex, this->layout.localToAMR(Point{ix, iy}.as_signed()));
 
             Ex(ix, iy) = std::cos(2 * M_PI / 5. * point[0]) * std::sin(2 * M_PI / 6. * point[1]);
         }
@@ -304,7 +307,8 @@ TEST_F(Faraday2DTest, Faraday2DCalculatedOk)
     {
         for (auto iy = gsi_d_Y; iy <= gei_d_Y; ++iy)
         {
-            auto point = this->layout.fieldNodeCoordinates(Ey, Point{0., 0.}, ix, iy);
+            auto point = this->layout.fieldNodeCoordinates(
+                Ey, this->layout.localToAMR(Point{ix, iy}.as_signed()));
 
             Ey(ix, iy) = std::cos(2 * M_PI / 5. * point[0]) * std::tanh(2 * M_PI / 6. * point[1]);
         }
@@ -314,7 +318,8 @@ TEST_F(Faraday2DTest, Faraday2DCalculatedOk)
     {
         for (auto iy = gsi_p_Y; iy <= gei_p_Y; ++iy)
         {
-            auto point = this->layout.fieldNodeCoordinates(Ez, Point{0., 0.}, ix, iy);
+            auto point = this->layout.fieldNodeCoordinates(
+                Ez, this->layout.localToAMR(Point{ix, iy}.as_signed()));
 
             Ez(ix, iy) = std::sin(2 * M_PI / 5. * point[0]) * std::tanh(2 * M_PI / 6. * point[1]);
         }
@@ -324,7 +329,8 @@ TEST_F(Faraday2DTest, Faraday2DCalculatedOk)
     {
         for (auto iy = gsi_d_Y; iy <= gei_d_Y; ++iy)
         {
-            auto point = this->layout.fieldNodeCoordinates(Bx, Point{0., 0.}, ix, iy);
+            auto point = this->layout.fieldNodeCoordinates(
+                Bx, this->layout.localToAMR(Point{ix, iy}.as_signed()));
 
             Bx(ix, iy) = std::tanh(point[0] - 5. / 2.) * std::tanh(point[1] - 6. / 2.);
         }
@@ -334,7 +340,8 @@ TEST_F(Faraday2DTest, Faraday2DCalculatedOk)
     {
         for (auto iy = gsi_p_Y; iy <= gei_p_Y; ++iy)
         {
-            auto point = this->layout.fieldNodeCoordinates(By, Point{0., 0.}, ix, iy);
+            auto point = this->layout.fieldNodeCoordinates(
+                By, this->layout.localToAMR(Point{ix, iy}.as_signed()));
 
             By(ix, iy) = std::tanh(point[0] - 5. / 2.) * std::tanh(point[1] - 6. / 2.);
         }
@@ -344,7 +351,8 @@ TEST_F(Faraday2DTest, Faraday2DCalculatedOk)
     {
         for (auto iy = gsi_d_Y; iy <= gei_d_Y; ++iy)
         {
-            auto point = this->layout.fieldNodeCoordinates(Bz, Point{0., 0.}, ix, iy);
+            auto point = this->layout.fieldNodeCoordinates(
+                Bz, this->layout.localToAMR(Point{ix, iy}.as_signed()));
 
             Bz(ix, iy) = std::tanh(point[0] - 5. / 2.) * std::tanh(point[1] - 6. / 2.);
         }
@@ -433,7 +441,8 @@ TEST_F(Faraday3DTest, Faraday3DCalculatedOk)
         {
             for (auto iz = gsi_p_Z; iz <= gei_p_Z; ++iz)
             {
-                auto point = this->layout.fieldNodeCoordinates(Ex, Point{0., 0., 0.}, ix, iy, iz);
+                auto point = this->layout.fieldNodeCoordinates(
+                    Ex, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
 
                 Ex(ix, iy, iz) = std::sin(2 * M_PI / 5. * point[0])
                                  * std::cos(2 * M_PI / 6. * point[1])
@@ -448,7 +457,8 @@ TEST_F(Faraday3DTest, Faraday3DCalculatedOk)
         {
             for (auto iz = gsi_p_Z; iz <= gei_p_Z; ++iz)
             {
-                auto point = this->layout.fieldNodeCoordinates(Ey, Point{0., 0., 0.}, ix, iy, iz);
+                auto point = this->layout.fieldNodeCoordinates(
+                    Ey, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
 
                 Ey(ix, iy, iz) = std::tanh(2 * M_PI / 5. * point[0])
                                  * std::sin(2 * M_PI / 6. * point[1])
@@ -463,7 +473,8 @@ TEST_F(Faraday3DTest, Faraday3DCalculatedOk)
         {
             for (auto iz = gsi_d_Z; iz <= gei_d_Z; ++iz)
             {
-                auto point = this->layout.fieldNodeCoordinates(Ez, Point{0., 0., 0.}, ix, iy, iz);
+                auto point = this->layout.fieldNodeCoordinates(
+                    Ez, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
 
                 Ez(ix, iy, iz) = std::cos(2 * M_PI / 5. * point[0])
                                  * std::tanh(2 * M_PI / 6. * point[1])
@@ -478,7 +489,8 @@ TEST_F(Faraday3DTest, Faraday3DCalculatedOk)
         {
             for (auto iz = gsi_d_Z; iz <= gei_d_Z; ++iz)
             {
-                auto point = this->layout.fieldNodeCoordinates(Bx, Point{0., 0., 0.}, ix, iy, iz);
+                auto point = this->layout.fieldNodeCoordinates(
+                    Bx, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
 
                 Bx(ix, iy, iz) = std::tanh(point[0] - 5. / 2.) * std::tanh(point[1] - 6. / 2.)
                                  * std::tanh(point[2] - 12. / 2.);
@@ -492,7 +504,8 @@ TEST_F(Faraday3DTest, Faraday3DCalculatedOk)
         {
             for (auto iz = gsi_d_Z; iz <= gei_d_Z; ++iz)
             {
-                auto point = this->layout.fieldNodeCoordinates(By, Point{0., 0., 0.}, ix, iy, iz);
+                auto point = this->layout.fieldNodeCoordinates(
+                    By, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
 
                 By(ix, iy, iz) = std::tanh(point[0] - 5. / 2.) * std::tanh(point[1] - 6. / 2.)
                                  * std::tanh(point[2] - 12. / 2.);
@@ -506,7 +519,8 @@ TEST_F(Faraday3DTest, Faraday3DCalculatedOk)
         {
             for (auto iz = gsi_p_Z; iz <= gei_p_Z; ++iz)
             {
-                auto point = this->layout.fieldNodeCoordinates(Bz, Point{0., 0., 0.}, ix, iy, iz);
+                auto point = this->layout.fieldNodeCoordinates(
+                    Bz, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
 
                 Bz(ix, iy, iz) = std::tanh(point[0] - 5. / 2.) * std::tanh(point[1] - 6. / 2.)
                                  * std::tanh(point[2] - 12. / 2.);
diff --git a/tests/core/numerics/ion_updater/test_updater.cpp b/tests/core/numerics/ion_updater/test_updater.cpp
index 656813af7..e4ffcbc32 100644
--- a/tests/core/numerics/ion_updater/test_updater.cpp
+++ b/tests/core/numerics/ion_updater/test_updater.cpp
@@ -619,10 +619,12 @@ struct IonUpdaterTest : public ::testing::Test
             std::vector<std::size_t> ixes;
             std::vector<double> x;
 
-            for (auto ix = ix0; ix < ix1; ++ix)
+            // We do not use the primal box as the last primal is incomplete.
+            // This is because level ghosts are only interpolated if they enter the domain
+            for (auto const [amr_idx, lcl_idx] : this->layout.amr_lcl_idx())
             {
-                ixes.emplace_back(ix);
-                x.emplace_back(layout.cellCenteredCoordinates(ix)[0]);
+                ixes.emplace_back(lcl_idx[0]);
+                x.emplace_back(layout.cellCenteredCoordinates(amr_idx)[0]);
             }
 
             auto functionXPtr = function(x); // keep alive
diff --git a/tests/core/numerics/ohm/test_main.cpp b/tests/core/numerics/ohm/test_main.cpp
index e5d338891..7ca7c1718 100644
--- a/tests/core/numerics/ohm/test_main.cpp
+++ b/tests/core/numerics/ohm/test_main.cpp
@@ -100,7 +100,8 @@ struct OhmTest : public ::testing::Test
 
             for (auto ix = gsi_p_X; ix <= gei_p_X; ++ix)
             {
-                auto point = this->layout.fieldNodeCoordinates(n, Point<double, 1>{0.}, ix);
+                auto point = this->layout.fieldNodeCoordinates(
+                    n, this->layout.localToAMR(Point{ix}.as_signed()));
 
                 n(ix)  = std::cosh(0.5 * point[0]);
                 Vx(ix) = std::sinh(0.2 * point[0]);
@@ -114,7 +115,8 @@ struct OhmTest : public ::testing::Test
 
             for (auto ix = gsi_d_X; ix <= gei_d_X; ++ix)
             {
-                auto point = this->layout.fieldNodeCoordinates(Bz, Point<double, 1>{0.}, ix);
+                auto point = this->layout.fieldNodeCoordinates(
+                    Bz, this->layout.localToAMR(Point{ix}.as_signed()));
 
                 By(ix) = std::cosh(0.3 * point[0]);
                 Bz(ix) = std::cosh(0.4 * point[0]);
@@ -137,8 +139,8 @@ struct OhmTest : public ::testing::Test
             {
                 for (auto iy = gsi_p_Y; iy <= gei_p_Y; ++iy)
                 {
-                    auto point
-                        = this->layout.fieldNodeCoordinates(n, Point<double, 2>{0., 0.}, ix, iy);
+                    auto point = this->layout.fieldNodeCoordinates(
+                        n, this->layout.localToAMR(Point{ix, iy}.as_signed()));
 
                     n(ix, iy)  = std::cosh(0.5 * point[0]) * std::cosh(0.5 * point[1]);
                     Vx(ix, iy) = std::sinh(0.2 * point[0]) * std::sinh(0.2 * point[1]);
@@ -149,8 +151,8 @@ struct OhmTest : public ::testing::Test
                 }
                 for (auto iy = gsi_d_Y; iy <= gei_d_Y; ++iy)
                 {
-                    auto point
-                        = this->layout.fieldNodeCoordinates(Bx, Point<double, 2>{0., 0.}, ix, iy);
+                    auto point = this->layout.fieldNodeCoordinates(
+                        Bx, this->layout.localToAMR(Point{ix, iy}.as_signed()));
 
                     Bx(ix, iy) = std::cosh(0.2 * point[0]) * std::cosh(0.2 * point[1]);
                     Jy(ix, iy) = std::tanh(0.3 * point[0]) * std::tanh(0.3 * point[1]);
@@ -160,16 +162,16 @@ struct OhmTest : public ::testing::Test
             {
                 for (auto iy = gsi_p_Y; iy <= gei_p_Y; ++iy)
                 {
-                    auto point
-                        = this->layout.fieldNodeCoordinates(Jx, Point<double, 2>{0., 0.}, ix, iy);
+                    auto point = this->layout.fieldNodeCoordinates(
+                        Jx, this->layout.localToAMR(Point{ix, iy}.as_signed()));
 
                     By(ix, iy) = std::cosh(0.3 * point[0]) * std::cosh(0.3 * point[1]);
                     Jx(ix, iy) = std::tanh(0.2 * point[0]) * std::tanh(0.2 * point[1]);
                 }
                 for (auto iy = gsi_d_Y; iy <= gei_d_Y; ++iy)
                 {
-                    auto point
-                        = this->layout.fieldNodeCoordinates(Bz, Point<double, 2>{0., 0.}, ix, iy);
+                    auto point = this->layout.fieldNodeCoordinates(
+                        Bz, this->layout.localToAMR(Point{ix, iy}.as_signed()));
 
                     Bz(ix, iy) = std::cosh(0.4 * point[0]) * std::cosh(0.4 * point[1]);
                 }
@@ -198,7 +200,7 @@ struct OhmTest : public ::testing::Test
                     for (auto iz = gsi_p_Z; iz <= gei_p_Z; ++iz)
                     {
                         auto point = this->layout.fieldNodeCoordinates(
-                            n, Point<double, 3>{0., 0., 0.}, ix, iy, iz);
+                            n, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
 
                         n(ix, iy, iz) = std::cosh(0.5 * point[0]) * std::cosh(0.5 * point[1])
                                         * std::cosh(0.5 * point[2]);
@@ -214,7 +216,7 @@ struct OhmTest : public ::testing::Test
                     for (auto iz = gsi_d_Z; iz <= gei_d_Z; ++iz)
                     {
                         auto point = this->layout.fieldNodeCoordinates(
-                            Jz, Point<double, 3>{0., 0., 0.}, ix, iy, iz);
+                            Jz, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
 
                         Jz(ix, iy, iz) = std::tanh(0.4 * point[0]) * std::tanh(0.4 * point[1])
                                          * std::tanh(0.4 * point[2]);
@@ -225,7 +227,7 @@ struct OhmTest : public ::testing::Test
                     for (auto iz = gsi_p_Z; iz <= gei_p_Z; ++iz)
                     {
                         auto point = this->layout.fieldNodeCoordinates(
-                            Jy, Point<double, 3>{0., 0., 0.}, ix, iy, iz);
+                            Jy, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
 
                         Jy(ix, iy, iz) = std::tanh(0.3 * point[0]) * std::tanh(0.3 * point[1])
                                          * std::tanh(0.3 * point[2]);
@@ -233,7 +235,7 @@ struct OhmTest : public ::testing::Test
                     for (auto iz = gsi_d_Z; iz <= gei_d_Z; ++iz)
                     {
                         auto point = this->layout.fieldNodeCoordinates(
-                            Bx, Point<double, 3>{0., 0., 0.}, ix, iy, iz);
+                            Bx, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
 
                         Bx(ix, iy, iz) = std::cosh(0.2 * point[0]) * std::cosh(0.2 * point[1])
                                          * std::cosh(0.2 * point[2]);
@@ -247,7 +249,7 @@ struct OhmTest : public ::testing::Test
                     for (auto iz = gsi_p_Z; iz <= gei_p_Z; ++iz)
                     {
                         auto point = this->layout.fieldNodeCoordinates(
-                            Jx, Point<double, 3>{0., 0., 0.}, ix, iy, iz);
+                            Jx, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
 
                         Jx(ix, iy, iz) = std::tanh(0.2 * point[0]) * std::tanh(0.2 * point[1])
                                          * std::tanh(0.2 * point[2]);
@@ -255,7 +257,7 @@ struct OhmTest : public ::testing::Test
                     for (auto iz = gsi_d_Z; iz <= gei_d_Z; ++iz)
                     {
                         auto point = this->layout.fieldNodeCoordinates(
-                            By, Point<double, 3>{0., 0., 0.}, ix, iy, iz);
+                            By, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
 
                         By(ix, iy, iz) = std::cosh(0.3 * point[0]) * std::cosh(0.3 * point[1])
                                          * std::cosh(0.3 * point[2]);
@@ -266,7 +268,7 @@ struct OhmTest : public ::testing::Test
                     for (auto iz = gsi_p_Z; iz <= gei_p_Z; ++iz)
                     {
                         auto point = this->layout.fieldNodeCoordinates(
-                            Bz, Point<double, 3>{0., 0., 0.}, ix, iy, iz);
+                            Bz, this->layout.localToAMR(Point{ix, iy, iz}.as_signed()));
 
                         Bz(ix, iy, iz) = std::cosh(0.4 * point[0]) * std::cosh(0.4 * point[1])
                                          * std::cosh(0.4 * point[2]);
diff --git a/tests/initializer/test_initializer.cpp b/tests/initializer/test_initializer.cpp
index 2215eab68..64356d920 100644
--- a/tests/initializer/test_initializer.cpp
+++ b/tests/initializer/test_initializer.cpp
@@ -62,7 +62,6 @@ TEST(APythonDataProvider, providesAValidTree)
     auto layout = input["simulation"]["grid"]["layout_type"].to<std::string>();
     auto nx     = input["simulation"]["grid"]["nbr_cells"]["x"].to<int>();
     auto dx     = input["simulation"]["grid"]["meshsize"]["x"].to<double>();
-    auto origin = input["simulation"]["grid"]["origin"]["x"].to<double>();
 
     auto pusherName
         = input["simulation"]["algo"]["ion_updater"]["pusher"]["name"].to<std::string>();
@@ -93,7 +92,6 @@ TEST(APythonDataProvider, providesAValidTree)
     EXPECT_EQ(65, nx);
     EXPECT_DOUBLE_EQ(1. / 65., dx);
     EXPECT_DOUBLE_EQ(0.001, dt);
-    EXPECT_DOUBLE_EQ(0., origin);
     EXPECT_EQ("yee", layout);
 
     EXPECT_EQ("modified_boris", pusherName);