3d(mostly)

.github/workflows/cmake_macos.yml

@@ -77,7 +77,7 @@ jobs:
         cmake $GITHUB_WORKSPACE -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON \
               -DENABLE_SAMRAI_TESTS=OFF -DCMAKE_C_COMPILER_LAUNCHER=ccache \
               -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DlowResourceTests=ON \
-              -DCMAKE_CXX_FLAGS="-DPHARE_DIAG_DOUBLES=1 -O2"
+              -DCMAKE_CXX_FLAGS="-DPHARE_DIAG_DOUBLES=1 -O2 -DPHARE_SIMULATORS=2"
 
     - name: Build
       working-directory: ${{runner.workspace}}/build

.github/workflows/cmake_ubuntu.yml

@@ -80,7 +80,7 @@ jobs:
         cmake $GITHUB_WORKSPACE -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON --fresh \
               -DCMAKE_C_COMPILER_LAUNCHER=ccache \
               -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-              -DlowResourceTests=ON -DdevMode=ON \
+              -DlowResourceTests=ON -DdevMode=ON -Dphare_configurator=ON \
               -DCMAKE_CXX_FLAGS="-DPHARE_DIAG_DOUBLES=1 -O2"
 
     - name: Build

pyphare/pyphare/core/box.py

@@ -67,6 +67,9 @@ def __eq__(self, other):
         return isinstance(other, Box) and (self.lower == other.lower).all() and (self.upper == other.upper).all()
 
     def __sub__(self, other):
+        if isinstance(other, (list, tuple)):
+            assert all([isinstance(item, Box) for item in other])
+            return remove_all(self, other)
         assert isinstance(other, Box)
         return remove(self, other)
 
@@ -183,5 +186,42 @@ def copy(arr, replace):
     return list(boxes.values())
 
 
+def remove_all(box, to_remove):
+    if len(to_remove) > 0:
+        remaining = box - to_remove[0]
+        for to_rm in to_remove[1:]:
+            tmp, remove = [], []
+            for i, rem in enumerate(remaining):
+                if rem * to_rm is not None:
+                    remove.append(i)
+                    tmp += rem - to_rm
+            for rm in reversed(remove):
+                del remaining[rm]
+            remaining += tmp
+        return remaining
+    return box
+
+
+
 def amr_to_local(box, ref_box):
     return Box(box.lower - ref_box.lower, box.upper - ref_box.lower)
+
+
+def select(data, box):
+    return data[tuple([slice(l, u + 1) for l,u in zip(box.lower, box.upper)])]
+
+class DataSelector:
+    """
+        can't assign return to function unless []
+        usage
+        DataSelector(data)[box] = val
+    """
+    def __init__(self, data):
+        self.data = data
+    def __getitem__(self, box_or_slice):
+        if isinstance(box_or_slice, Box):
+            return select(self.data, box_or_slice)
+        return self.data[box_or_slice]
+
+    def __setitem__(self, box_or_slice, val):
+        self.__getitem__(box_or_slice)[:] = val

pyphare/pyphare/core/gridlayout.py

@@ -331,6 +331,20 @@ def yeeCoords(self, knode, iStart, centering, direction, ds, origin, derivOrder)
 
         return x
 
+    def meshCoords(self, qty):
+        ndim = self.ndim
+        assert ndim > 0 and ndim < 4
+        x = self.yeeCoordsFor(qty, "x")
+        if ndim == 1:
+            return x
+        y = self.yeeCoordsFor(qty, "y")
+        if ndim == 2:
+            X,Y = np.meshgrid(x,y,indexing="ij")
+            return np.array([X.flatten(),Y.flatten()]).T.reshape((len(x), len(y), ndim))
+        z = self.yeeCoordsFor(qty, "z")
+        X ,Y, Z = np.meshgrid(x,y,z,indexing="ij")
+        return np.array([X.flatten(), Y.flatten(), Z.flatten()]).T.reshape((len(x), len(y), len(z), ndim))
+
     def yeeCoordsFor(self, qty, direction, withGhosts=True, **kwargs):
         """
         from a qty and a direction, returns a 1d array containing

pyphare/pyphare/pharein/simulation.py

@@ -194,9 +194,13 @@ def check_boundaries(ndim, **kwargs):
     3: [4, 5, 8, 9, 25]
   },
   3: {
-    1: [6, 7, 8, 9, 12, 13, 14, 15, 18, 19, 20, 21, 26, 27],
-    2: [6, 7, 8, 9, 12, 13, 14, 15, 18, 19, 20, 21, 26, 27, 64],
-    3: [6, 7, 8, 9, 12, 13, 14, 15, 18, 19, 20, 21, 26, 27, 125]
+    1: [6, 12],
+    2: [6, 12],
+    3: [6, 12]
+    # full below
+    # 1: [6, 7, 8, 9, 12, 13, 14, 15, 18, 19, 20, 21, 26, 27],
+    # 2: [6, 7, 8, 9, 12, 13, 14, 15, 18, 19, 20, 21, 26, 27, 64],
+    # 3: [6, 7, 8, 9, 12, 13, 14, 15, 18, 19, 20, 21, 26, 27, 125]
   }
 } # Default refined_particle_nbr per dim/interp is considered index 0 of list
 def check_refined_particle_nbr(ndim, **kwargs):

pyphare/pyphare/pharesee/geometry.py

@@ -49,13 +49,25 @@ def domain_border_ghost_boxes(domain_box, patches):
     elif domain_box.ndim == 2:
         upper_x, upper_y = domain_box.upper
         return {
-          "bottom" : Box((0, 0,), (upper_x, ghost_box_width)),
-          "top" : Box((0, upper_y - ghost_box_width), (upper_x, upper_y)),
           "left" : Box((0, 0), (ghost_box_width, upper_y)),
           "right" : Box((upper_x - ghost_box_width, 0), (upper_x, upper_y)),
+          "bottom" : Box((0, 0,), (upper_x, ghost_box_width)),
+          "top" : Box((0, upper_y - ghost_box_width), (upper_x, upper_y)),
         }
 
-    raise ValueError("Unhandeled dimension")
+    else:
+        upper_x, upper_y, upper_z = domain_box.upper
+        return {
+          "left"   : Box((0, 0, 0), (ghost_box_width, upper_y,upper_z)),
+          "right"  : Box((upper_x - ghost_box_width, 0, 0), (upper_x, upper_y,upper_z)),
+          "bottom" : Box((0, 0, 0), (upper_x, ghost_box_width,upper_z)),
+          "top"    : Box((0, upper_y - ghost_box_width, 0), (upper_x, upper_y,upper_z)),
+          "front"  : Box((0, 0, 0)     , (upper_x, upper_y, ghost_box_width)),
+          "back"   : Box((0, 0, upper_z - ghost_box_width), (upper_x, upper_y,upper_z)),
+        }
+
+
+
 
 def touch_domain_border(box, domain_box, border):
     if border == "upper":
@@ -68,15 +80,22 @@ def touch_domain_border(box, domain_box, border):
 
 def periodicity_shifts(domain_box):
 
+    shifts = {}
+
     if domain_box.ndim == 1:
         shape_x = domain_box.shape
-        return {
+        shifts = {
             "left" : shape_x,
             "right" : -shape_x,
         }
+        shifts.update({"leftright" : [shifts["left"], shifts["right"]]})
 
     if domain_box.ndim == 2:
         shape_x, shape_y = domain_box.shape
+    if domain_box.ndim == 3:
+        shape_x, shape_y, shape_z = domain_box.shape
+
+    if domain_box.ndim > 1:
         shifts = {
             "left" : [(shape_x, 0)],
             "right" : [(-shape_x, 0)],
@@ -104,13 +123,33 @@ def periodicity_shifts(domain_box):
           "topleftright" : [
               *shifts["leftright"], *shifts["top"],
               shifts["topleft"][-1], shifts["topright"][-1]],
-          "bottomtopleftright" : [ # one patch covers domain
+          "leftrightbottomtop" : [ # one patch covers domain
               *shifts["bottomleft"], *shifts["topright"],
               shifts["bottomright"][-1], shifts["topleft"][-1]]
         })
 
     if domain_box.ndim == 3:
-        raise ValueError("Unhandeled dimension")
+        front = {
+            f"{k}front" : [(v[0], v[1], shape_z) for v in l] for k,l in shifts.items()
+        }
+        back = {
+            f"{k}back" : [([v[0], v[1], -shape_z]) for v in l] for k,l in shifts.items()
+        }
+
+        shifts = {k : [([v[0], v[1], 0]) for v in l] for k,l in shifts.items()}
+
+        shifts.update(front)
+        shifts.update(back)
+        shifts.update({
+            "back" :   [(0, 0, -shape_z)],
+            "front" :  [(0, 0, shape_z)],
+            "leftrightbottomtopfrontback" : [
+                *shifts["bottomleftfront"], *shifts["bottomrightback"],
+                *shifts["topleftfront"], *shifts["toprightback"],
+            ]
+        })
+
+    shifts = {"".join(sorted(k)) : l for k,l in shifts.items()}
 
     return shifts
 
@@ -206,7 +245,7 @@ def borders_per(patch):
 
     for patch_i, ref_patch in enumerate(border_patches):
 
-        in_sides = borders_per_patch[ref_patch]
+        in_sides = "".join(sorted(borders_per_patch[ref_patch]))
         assert in_sides in shifts
 
         for ref_pdname, ref_pd in ref_patch.patch_datas.items():
@@ -249,6 +288,7 @@ def hierarchy_overlaps(hierarchy, time=0):
 
 
 
+
 def get_periodic_list(patches, domain_box, n_ghosts):
     """
     given a list of patches and a domain box the function
@@ -278,38 +318,50 @@ def get_periodic_list(patches, domain_box, n_ghosts):
             shift_patch(first_patch, domain_box.shape)
             sorted_patches.append(first_patch)
 
-    if dim == 2:
+        return sorted_patches
+
+    dbu = domain_box.upper
 
+    if dim == 2:
         sides = {
-            "bottom":Box([0, 0], [domain_box.upper[0], 0]),
-            "top":   Box([0, domain_box.upper[1]], [domain_box.upper[0], domain_box.upper[1]]),
-            "left" : Box([0, 0], [0, domain_box.upper[1]]),
-            "right": Box([domain_box.upper[0], 0], [domain_box.upper[0], domain_box.upper[1]])
+            "left" : Box([0, 0], [0, dbu[1]]),
+            "right": Box([dbu[0], 0], [dbu[0], dbu[1]]),
+            "bottom":Box([0, 0], [dbu[0], 0]),
+            "top":   Box([0, dbu[1]], [dbu[0], dbu[1]]),
         }
 
-        shifts = periodicity_shifts(domain_box)
+    else:
+        sides = {
+            "left"  : Box([0, 0, 0]     , [0, dbu[1], dbu[2]]),
+            "right" : Box([dbu[0], 0, 0], [dbu[0], dbu[1], dbu[2]]),
+            "bottom": Box([0, 0, 0]     , [dbu[0], 0, dbu[2]]),
+            "top"   : Box([0, dbu[1], 0], [dbu[0], dbu[1], dbu[2]]),
+            "front" : Box([0, 0, 0]     , [dbu[0], dbu[1], 0]),
+            "back"  : Box([0, 0, dbu[2]], [dbu[0], dbu[1], dbu[2]]),
+        }
 
-        def borders_per(box):
-            return "".join([key for key, side in sides.items() if box * side is not None])
+    shifts = periodicity_shifts(domain_box)
 
-        for patch in patches:
+    def borders_per(box):
+        return "".join([key for key, side in sides.items() if box * side is not None])
 
-            in_sides = borders_per(boxm.grow(patch.box, n_ghosts))
+    for patch in patches:
 
-            if in_sides in shifts: # in_sides might be empty, so no borders
-                for shift in shifts[in_sides]:
-                    patch_copy = copy(patch)
-                    shift_patch(patch_copy, shift)
-                    sorted_patches.append(patch_copy)
+        in_sides = "".join(sorted(borders_per(boxm.grow(patch.box, n_ghosts))))
 
-    if dim == 3:
-        raise ValueError("not yet implemented")
+        if in_sides in shifts: # in_sides might be empty, so no borders
+            for shift in shifts[in_sides]:
+                patch_copy = copy(patch)
+                shift_patch(patch_copy, shift)
+                sorted_patches.append(patch_copy)
 
     return sorted_patches
 
 
 
 
+
+
 def ghost_area_boxes(hierarchy, quantities, levelNbrs=[], time=0):
     """
     this function returns boxes representing ghost cell boxes for all levels
@@ -412,18 +464,7 @@ def level_ghost_boxes(hierarchy, quantities, levelNbrs=[], time=None):
 
                 for gabox in ghostAreaBoxes:
 
-                    remaining = gabox - check_patches[0].box
-
-                    for patch in check_patches[1:]:
-                        tmp = []
-                        remove = []
-                        for i, rem in enumerate(remaining):
-                            if rem * patch.box is not None:
-                                remove.append(i)
-                                tmp += rem - patch.box
-                        for rm in reversed(remove):
-                            del remaining[rm]
-                        remaining += tmp
+                    remaining = gabox - [p.box for p in check_patches]
 
                     if ilvl not in lvl_gaboxes:
                         lvl_gaboxes[ilvl] = {}

pyphare/pyphare/pharesee/hierarchy.py

@@ -100,13 +100,7 @@ def select(self, box):
 
         overlap = box * gbox
         if overlap is not None:
-            lower = self.layout.AMRToLocal(overlap.lower)
-            upper = self.layout.AMRToLocal(overlap.upper)
-
-            if box.ndim == 1:
-                return self.dataset[lower[0] : upper[0] + 1]
-            if box.ndim == 2:
-                return self.dataset[lower[0] : upper[0] + 1, lower[1] : upper[1] + 1]
+            return boxm.select(self.dataset, self.layout.AMRBoxToLocal(overlap))
         return np.array([])
 
     def __getitem__(self, box):
@@ -182,6 +176,8 @@ def grid():
         return mesh
 
 
+
+
 class ParticleData(PatchData):
     """
     Concrete type of PatchData representing particles in a region
@@ -1615,6 +1611,19 @@ def hierarchy_from_sim(simulator, qty, pop=""):
     return PatchHierarchy(patch_levels, domain_box, time=simulator.currentTime())
 
 
+def hierarchy_from_box(domain_box, ghosts_nbr):
+    """
+    constructs a basic hierarchy with one patch for level 0 as the entire domain
+    """
+    layout = GridLayout(domain_box, np.asarray([0] * domain_box.ndim), [.1] * domain_box.ndim, 1)
+    pdata = PatchData(layout, "qty")
+    object.__setattr__(pdata, "ghosts_nbr", np.asarray(ghosts_nbr))
+    object.__setattr__(pdata, "ghost_box", boxm.grow(layout.box, ghosts_nbr))
+    return PatchHierarchy(
+        {0 : PatchLevel(0, [Patch({"qty": pdata})])}, domain_box
+    )
+
+
 def hierarchy_from(
     simulator=None, qty=None, pop="", h5_filename=None, time=None, hier=None
 ):

res/amr/splitting.yml

@@ -99,3 +99,43 @@ dimension_2:
       delta:  1 2
       weight: .140625 .09375 .0625 .0234375 .015625 .00390625
 
+
+dimension_3:
+  interp_1:
+    N_particles_6:
+      delta:  .966431
+      weight: .166666
+
+    N_particles_12:
+      delta:  .74823
+      weight: .083333
+
+    N_particles_27:
+      delta:  1
+      weight: .125 .0625
+
+  interp_2:
+    N_particles_6:
+      delta:  1.149658
+      weight: .166666
+
+    N_particles_12:
+      delta:  .888184
+      weight: .083333
+
+    N_particles_27:
+      delta:  1.111333
+      weight: .099995 .055301
+
+  interp_3:
+    N_particles_6:
+      delta:  1.312622
+      weight: .166666
+
+    N_particles_12:
+      delta:  1.012756
+      weight: .083333
+
+    N_particles_27:
+      delta:  1.276815
+      weight: .104047 .05564