resfo-utilities 0.0.3__py3-none-any.whl → 0.1.1__py3-none-any.whl

resfo_utilities/__init__.py

@@ -1,3 +1,8 @@
-from ._cornerpoint_grid import CornerpointGrid, InvalidEgridFileError, MapAxes
+from ._cornerpoint_grid import (
+    CornerpointGrid,
+    InvalidEgridFileError,
+    MapAxes,
+    InvalidGridError,
+)
 
-__all__ = ["CornerpointGrid", "InvalidEgridFileError", "MapAxes"]
+__all__ = ["CornerpointGrid", "InvalidEgridFileError", "MapAxes", "InvalidGridError"]

resfo_utilities/_cornerpoint_grid.py

@@ -7,7 +7,6 @@ import numpy as np
 import resfo
 import scipy.optimize
 import warnings
-from matplotlib.path import Path
 import heapq
 from functools import cached_property
 
@@ -16,6 +15,10 @@ class InvalidEgridFileError(ValueError):
     pass
 
 
+class InvalidGridError(ValueError):
+    pass
+
+
 @dataclass
 class MapAxes:
     """The axes of the map coordinate system.
@@ -108,6 +111,19 @@ class CornerpointGrid:
     zcorn: npt.NDArray[np.float32]
     map_axes: MapAxes | None = None
 
+    def __post_init__(self) -> None:
+        if len(self.coord.shape) != 4 or self.coord.shape[2:4] != (2, 3):
+            raise InvalidGridError(f"coord had invalid dimensions {self.coord.shape}")
+        if len(self.zcorn.shape) != 4 or self.zcorn.shape[-1] != 8:
+            raise InvalidGridError(f"zcorn had invalid dimensions {self.zcorn.shape}")
+        ni = self.coord.shape[0] - 1
+        nj = self.coord.shape[1] - 1
+        if self.zcorn.shape[0] != ni or self.zcorn.shape[1] != nj:
+            raise InvalidGridError(
+                "zcorn and coord dimensions do not match:"
+                f" {self.zcorn.shape} vs {self.coord.shape}"
+            )
+
     @classmethod
     def read_egrid(cls, file_like: str | os.PathLike[str] | IO[Any]) -> Self:
         """Read the global grid from an .EGRID or .FEGRID file.
@@ -272,6 +288,10 @@ class CornerpointGrid:
         if map_coordinates and self.map_axes is not None:
             points = self.map_axes.transform_map_points(points)
 
+        dims = self.zcorn.shape[0:3]
+        top = self._pillars_z_plane_intersection(self.zcorn.min())
+        bot = self._pillars_z_plane_intersection(self.zcorn.max())
+
         # This algorithm will for each point p calculate the mesh surface that
         # is the intersection of the pillars with the plane z=p[2]. Then it searches
         # through the quad with a heuristical search that orders each neighbour by
@@ -285,19 +305,24 @@ class CornerpointGrid:
         class Quad:
             """The quad at index i,j"""
 
-            mesh: npt.NDArray[np.float32]
             i: int
             j: int
             p: npt.NDArray[np.float32]
+            i_neighbourhood: int
+            j_neighbourhood: int
 
             @cached_property
             def vertices(self) -> npt.NDArray[np.float32]:
                 return np.array(
                     [
-                        self.mesh[self.i, self.j],
-                        self.mesh[self.i + 1, self.j],
-                        self.mesh[self.i + 1, self.j + 1],
-                        self.mesh[self.i, self.j + 1],
+                        top[self.i, self.j],
+                        top[self.i + 1, self.j],
+                        top[self.i + 1, self.j + 1],
+                        top[self.i, self.j + 1],
+                        bot[self.i, self.j],
+                        bot[self.i + 1, self.j],
+                        bot[self.i + 1, self.j + 1],
+                        bot[self.i, self.j + 1],
                     ],
                     dtype=np.float32,
                 )
@@ -334,53 +359,63 @@ class CornerpointGrid:
                     return False
                 return bool(self.distance_from_bounds < other.distance_from_bounds)
 
-        if self.zcorn.shape[0] <= 0 or self.zcorn.shape[1] <= 0:
+        if dims[0] <= 0 or dims[1] <= 0:
             return [None] * len(points)
 
         for p in points:
             found = False
-            mesh = self._pillars_z_plane_intersection(p[2])
             if prev_ij is None:
-                queue = [Quad(mesh, 0, 0, p)]
+                queue = [
+                    Quad(dims[0] // 2, dims[1] // 2, p, dims[0] // 2, dims[1] // 2)
+                ]
             else:
-                queue = [Quad(mesh, *prev_ij, p)]
+                queue = [Quad(*prev_ij, p, 1, 1)]
             visited = set([(queue[0].i, queue[0].j)])
             while queue:
                 node = heapq.heappop(queue)
-                vertices = node.vertices
                 i = node.i
                 j = node.j
 
                 # If the quad contains the point then search through each k index
                 # for that quad
-                if node.distance_from_bounds <= tolerance and Path(
-                    vertices
-                ).contains_points([p[0:2]], radius=tolerance):
-                    for k in range(self.zcorn.shape[2]):
+                if node.distance_from_bounds <= 2 * tolerance:
+                    for k in range(dims[2]):
                         zcorn = self.zcorn[i, j, k]
                         z = p[2]
                         # Prune by bounding box first then check whether point_in_cell
                         if (
-                            zcorn.min() - tolerance <= z <= zcorn.max() + tolerance
-                            and self.point_in_cell(p, i, j, k, map_coordinates=False)
+                            zcorn.min() - 2 * tolerance
+                            <= z
+                            <= zcorn.max() + 2 * tolerance
+                            and self.point_in_cell(
+                                p, i, j, k, tolerance=tolerance, map_coordinates=False
+                            )
                         ):
                             prev_ij = (i, j)
                             result.append((i, j, k))
                             found = True
                             break
+                if found:
                     break
 
                 # Add each neighbour to the queue if not visited
-                for di in (-1, 0, 1):
-                    ni = i + di
-                    if ni < 0 or ni >= self.zcorn.shape[0]:
-                        continue
-                    for dj in (-1, 0, 1):
-                        nj = j + dj
-                        if nj < 0 or nj >= self.zcorn.shape[1]:
-                            continue
+                size_i = node.i_neighbourhood
+                for di in (-1 * size_i, 0, size_i):
+                    ni = np.clip(i + di, 0, dims[0] - 1)
+                    size_j = node.j_neighbourhood
+                    for dj in (-1 * size_j, 0, size_j):
+                        nj = np.clip(j + dj, 0, dims[1] - 1)
                         if (ni, nj) not in visited:
-                            heapq.heappush(queue, Quad(mesh, ni, nj, p))
+                            heapq.heappush(
+                                queue,
+                                Quad(
+                                    ni,
+                                    nj,
+                                    p,
+                                    max(size_i // 2, 1),
+                                    max(size_j // 2, 1),
+                                ),
+                            )
                             visited.add((ni, nj))
             if not found:
                 result.append(None)
@@ -408,8 +443,23 @@ class CornerpointGrid:
         def twice(a: npt.NDArray[Any]) -> npt.NDArray[Any]:
             return np.concatenate([a, a])
 
-        t = (self.zcorn[i, j, k] - twice(top_z)) / twice(bot_z - top_z)
-        return twice(top) + t[:, np.newaxis] * twice(bot - top)
+        height_diff = twice(bot_z - top_z)
+
+        if np.any(height_diff == 0):
+            raise InvalidGridError(
+                f"Grid contains zero height pillars with different for cell {i, j, k}"
+            )
+
+        t = (self.zcorn[i, j, k] - twice(top_z)) / height_diff
+
+        result = twice(top) + t[:, np.newaxis] * twice(bot - top)
+
+        if not np.all(np.isfinite(result)):
+            raise InvalidGridError(
+                f"The corners of the cell at {i, j, k} is not well defined"
+            )
+
+        return result
 
     def point_in_cell(
         self,
@@ -444,7 +494,7 @@ class CornerpointGrid:
         if map_coordinates and self.map_axes is not None:
             points = self.map_axes.transform_map_points(points)
 
-        vertices = self.cell_corners(i, j, k).astype(np.float64)
+        vertices = self.cell_corners(i, j, k)
 
         corner_signs = np.array(
             [
@@ -480,9 +530,13 @@ class CornerpointGrid:
 
         solutions = []
         for point in points:
-            point = point.astype(np.float64)
-            initial_guess = 2 * (point - vertices[0]) / (vertices[6] - vertices[0]) - 1
-            initial_guess = np.clip(initial_guess, -1, 1)
+            point = point
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                initial_guess = (
+                    2 * (point - vertices[0]) / (vertices[7] - vertices[0]) - 1
+                )
+                initial_guess = np.clip(initial_guess, -1, 1)
             np.nan_to_num(initial_guess, copy=False)
             sol = scipy.optimize.least_squares(
                 residual(point),
@@ -498,7 +552,7 @@ class CornerpointGrid:
                 solutions.append(
                     bool(
                         np.all(np.abs(sol.x) <= 1.0 + tolerance)
-                        and np.linalg.norm(residual(point)(sol.x)) <= 1e-4 + tolerance
+                        and np.linalg.norm(residual(point)(sol.x)) <= tolerance
                     )
                 )
         return np.array(solutions, dtype=np.bool_)

{resfo_utilities-0.0.3.dist-info → resfo_utilities-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: resfo-utilities
-Version: 0.0.3
+Version: 0.1.1
 Summary: A utility library for working with the output of reservoir simulators.
 Author-email: Equinor <fg_sib-scout@equinor.com>
 Maintainer-email: Eivind Jahren <ejah@equinor.com>, Håkon Steinkopf Søhoel <hsoho@equinor.com>
@@ -19,7 +19,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: numpy
 Requires-Dist: resfo
-Requires-Dist: matplotlib
 Requires-Dist: scipy
 Provides-Extra: doc
 Requires-Dist: sphinx; extra == "doc"

resfo_utilities-0.1.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+resfo_utilities/__init__.py,sha256=AymNFhNg2Q8fQg2HfOFPDBlX2irU2fmizsSXf9YhWMg,205
+resfo_utilities/_cornerpoint_grid.py,sha256=bBgCT1nEVl7jir3REGxQ20dKS9FAGqnrQLZEpAvoDBg,21801
+resfo_utilities-0.1.1.dist-info/licenses/LICENSE.md,sha256=3IXI3x1RN4jDR2PonpWF1guc33zagcTgpq_VnboE3UU,7653
+resfo_utilities-0.1.1.dist-info/METADATA,sha256=ju1jI3YTp-579bYJAIUGqv4424CCjWEswsouKARW994,2330
+resfo_utilities-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+resfo_utilities-0.1.1.dist-info/top_level.txt,sha256=VjItoaJHqsDLhHEvCjEI5bN2sZy55tA-zlkl-CtggEU,16
+resfo_utilities-0.1.1.dist-info/RECORD,,

resfo_utilities-0.0.3.dist-info/RECORD

@@ -1,7 +0,0 @@
-resfo_utilities/__init__.py,sha256=_O7IbN2VxBuoWsSeVlQl6LSi_N0Tnb1YAOwiPNcy2i0,146
-resfo_utilities/_cornerpoint_grid.py,sha256=ZJleszWHKEeVyIsW0If3H3OWX64Tjdg_tgo-etlenA0,19905
-resfo_utilities-0.0.3.dist-info/licenses/LICENSE.md,sha256=3IXI3x1RN4jDR2PonpWF1guc33zagcTgpq_VnboE3UU,7653
-resfo_utilities-0.0.3.dist-info/METADATA,sha256=gRqzsGS6p87TNZQ6G57WI5exXkF4ICAwATdLN3ulUtk,2356
-resfo_utilities-0.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-resfo_utilities-0.0.3.dist-info/top_level.txt,sha256=VjItoaJHqsDLhHEvCjEI5bN2sZy55tA-zlkl-CtggEU,16
-resfo_utilities-0.0.3.dist-info/RECORD,,