origin made global

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")

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)

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"]

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

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,54 +156,43 @@ 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:
            SAMRAI::xfer::RefineTimeTransaction::packStream(tbox::MessageStream&stream)
 
           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(), //
+        };
     }
 
 

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,15 +202,13 @@ 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
     : HierarchyRestarter{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")}
 {

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,18 +18,20 @@ 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
             = std::apply([&](auto&... args) { return init(args...); }, coords);
         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]);
     }
 };