compute overlap

Author: nicolasaunai

pyphare/pyphare/pharesee/geometry.py

@@ -190,7 +190,84 @@ def periodicity_shifts(domain_box):
     return shifts
 
 
+def possible_periodic_shifts(box, domain_box):
+    from pyphare.core.box import shift
+
+    boxes = []
+    dim = domain_box.ndim
+
+    if dim == 1:
+        for ishift in (-1, 0, 1):
+            ioffset = ishift * domain_box.shape[0]
+            offset = ioffset
+
+            shifted = shift(box, offset)
+            boxes += [(offset, shifted)]
+    if dim == 2:
+        for ishift in (-1, 0, 1):
+            ioffset = ishift * domain_box.shape[0]
+            for jshift in (-1, 0, 1):
+                joffset = jshift * domain_box.shape[1]
+                offset = [ioffset, joffset]
+                shifted = shift(box, offset)
+                boxes += [(offset, shifted)]
+    if dim == 3:
+        for ishift in (-1, 0, 1):
+            ioffset = ishift * domain_box.shape[0]
+            for jshift in (-1, 0, 1):
+                joffset = jshift * domain_box.shape[1]
+                for kshift in (-1, 0, 1):
+                    koffset = kshift * domain_box.shape[2]
+
+                    offset = [ioffset, joffset, koffset]
+                    shifted = shift(box, offset)
+                    boxes += [(offset, shifted)]
+    return boxes
+
+
 def compute_overlaps(patches, domain_box):
+    overlaps = []
+    zero_offset = [0] * domain_box.ndim if domain_box.ndim > 1 else 0
+
+    for ip, refPatch in enumerate(patches):
+        for cmpPatch in patches[ip:]:
+
+            for ref_pdname, ref_pd in refPatch.patch_datas.items():
+                cmp_pd = cmpPatch.patch_datas[ref_pdname]
+
+                gb_ref = ref_pd.ghost_box
+                gb_cmp = cmp_pd.ghost_box
+
+                for offset, shifted_cmp in possible_periodic_shifts(gb_cmp, domain_box):
+                    overlap = gb_ref * shifted_cmp
+                    if overlap is not None and not np.all(
+                        overlap.shape == gb_ref.shape
+                    ):
+                        if ref_pd.quantity == "field":
+                            overlap = toFieldBox(overlap, ref_pd)
+
+                        overlaps.append(
+                            {
+                                "pdatas": (ref_pd, cmp_pd),
+                                "patches": (refPatch, cmpPatch),
+                                "box": overlap,
+                                "offset": (zero_offset, offset),
+                            }
+                        )
+                        if offset != zero_offset:
+                            overlaps.append(
+                                {
+                                    "pdatas": (ref_pd, cmp_pd),
+                                    "patches": (refPatch, cmpPatch),
+                                    "box": overlap,
+                                    "offset": (zero_offset, offset),
+                                }
+                            )
+
+    return overlaps
+
+
+def compute_overlaps_(patches, domain_box):
     """
     returns a list of overlaps for all patch datas in given patches
     and for a domain box. An overlap is defined as an intersection of

pyphare/pyphare_tests/test_pharesee/test_geometry.py

@@ -27,7 +27,7 @@ def setup_hierarchy(self, dim, interp_order, nbr_cells, refinement_boxes, **kwar
             domain_size=domain_size,
             cell_width=domain_size / nbr_cells,
             refinement_boxes=refinement_boxes,
-            **kwargs
+            **kwargs,
         )
 
     # used for tests without ddt hierarchy overrides
@@ -78,18 +78,20 @@ def test_overlaps(self):
         }
 
         overlaps = hierarchy_overlaps(hierarchy)
+        tested_overlaps = {
+            ilvl: [
+                {"box": overlap["box"], "offset": overlap["offset"]}
+                for overlap in overlaps[ilvl]
+            ]
+            for ilvl in range(len(hierarchy.patch_levels))
+        }
 
         for ilvl, lvl in enumerate(hierarchy.patch_levels):
             self.assertEqual(len(expected[ilvl]), len(overlaps[ilvl]))
 
-            for exp, actual in zip(expected[ilvl], overlaps[ilvl]):
-                act_box = actual["box"]
-                act_offset = actual["offset"]
-                exp_box = exp["box"]
-                exp_offset = exp["offset"]
-
-                self.assertEqual(act_box, exp_box)
-                self.assertEqual(act_offset, exp_offset)
+            for actual in tested_overlaps[ilvl]:
+                if actual not in expected[ilvl]:
+                    raise AssertionError(f"Unexpected overlap: {actual}")
 
     def test_touch_border(self):
         hierarchy = self.basic_hierarchy()

pyphare/pyphare_tests/test_pharesee/test_geometry_2d.py

@@ -114,15 +114,19 @@ def test_overlaps(self, refinement_boxes, expected):
         )
 
         level_overlaps = hierarchy_overlaps(hierarchy)
+        tested_overlaps = {
+            ilvl: [
+                {"box": overlap["box"], "offset": overlap["offset"]}
+                for overlap in level_overlaps[ilvl]
+            ]
+            for ilvl in expected.keys()
+        }
         for ilvl, lvl in enumerate(hierarchy.levels().items()):
             if ilvl not in expected:
                 continue
             self.assertEqual(len(expected[ilvl]), len(level_overlaps[ilvl]))
-            for exp, actual in zip(expected[ilvl], level_overlaps[ilvl]):
-                self.assertEqual(actual["box"], exp["box"])
-                self.assertTrue(
-                    (np.asarray(actual["offset"]) == np.asarray(exp["offset"])).all()
-                )
+            for actual in tested_overlaps[ilvl]:
+                self.assertTrue(actual in expected[ilvl])
 
         if 1 in level_overlaps:
             fig = hierarchy.plot_2d_patches(
@@ -163,14 +167,16 @@ def test_large_patchoverlaps(self, expected):
         level_overlaps = hierarchy_overlaps(hierarchy)
         ilvl = 0
         overlap_boxes = []
+        tested_overlaps = {
+            0: [
+                {"box": overlap["box"], "offset": overlap["offset"]}
+                for overlap in level_overlaps[ilvl]
+            ]
+        }
 
-        self.assertEqual(len(expected), len(level_overlaps[ilvl]))
-        for exp, actual in zip(expected, level_overlaps[ilvl]):
-            self.assertEqual(actual["box"], exp["box"])
-            self.assertTrue(
-                (np.asarray(actual["offset"]) == np.asarray(exp["offset"])).all()
-            )
-            overlap_boxes += [actual["box"]]
+        self.assertEqual(len(expected), len(tested_overlaps[ilvl]))
+        for actual in tested_overlaps[ilvl]:
+            self.assertTrue(actual in expected)
 
         fig = hierarchy.plot_2d_patches(
             ilvl,