resfo-utilities 0.0.3__tar.gz → 0.1.1__tar.gz

{resfo_utilities-0.0.3 → resfo_utilities-0.1.1}/PKG-INFO

@@ -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.0.3 → resfo_utilities-0.1.1}/pyproject.toml

@@ -15,7 +15,7 @@ classifiers=[
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
 ]
-dependencies = ["numpy","resfo", "matplotlib", "scipy"]
+dependencies = ["numpy","resfo", "scipy"]
 dynamic=["version"]
 
 authors = [

resfo_utilities-0.1.1/src/resfo_utilities/__init__.py

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

{resfo_utilities-0.0.3 → resfo_utilities-0.1.1}/src/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 → resfo_utilities-0.1.1}/src/resfo_utilities.egg-info/PKG-INFO

@@ -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.0.3 → resfo_utilities-0.1.1}/src/resfo_utilities.egg-info/requires.txt

@@ -1,6 +1,5 @@
 numpy
 resfo
-matplotlib
 scipy
 
 [dev]

{resfo_utilities-0.0.3 → resfo_utilities-0.1.1}/tests/unit/test_cornerpoint_grid.py

@@ -1,11 +1,17 @@
-from resfo_utilities import CornerpointGrid, InvalidEgridFileError, MapAxes
+from resfo_utilities import (
+    CornerpointGrid,
+    InvalidEgridFileError,
+    MapAxes,
+    InvalidGridError,
+)
 import resfo
 import pytest
 from io import BytesIO
 import numpy as np
 from numpy.testing import assert_allclose
-from hypothesis import given, assume
+from hypothesis import given, assume, example
 import hypothesis.strategies as st
+from hypothesis.extra.numpy import arrays, from_dtype
 from itertools import product
 
 
@@ -80,6 +86,47 @@ def test_that_read_egrid_raises_invalid_egrid_file_when_mapaxes_has_too_many_val
         CornerpointGrid.read_egrid(write_to_buffer([("MAPAXES ", [1.0])]))
 
 
+def test_that_grid_with_invalid_coord_shape_raises():
+    with pytest.raises(InvalidGridError, match="coord had invalid dimensions"):
+        CornerpointGrid(
+            coord=np.array([], dtype=np.float32),
+            zcorn=np.array([[[[0, 0, 0, 0, 1, 1, 1, 1]]]], dtype=np.float32),
+        )
+
+
+def test_that_grid_with_invalid_zcorn_shape_raises():
+    with pytest.raises(InvalidGridError, match="zcorn had invalid dimensions"):
+        CornerpointGrid(
+            coord=np.array(
+                [
+                    [[[0, 0, 0], [0, 0, 1]], [[0, 1, 0], [0, 1, 1]]],
+                    [[[1, 0, 0], [1, 0, 1]], [[1, 1, 0], [1, 1, 1]]],
+                ],
+                dtype=np.float32,
+            ),
+            zcorn=np.array([], dtype=np.float32),
+        )
+
+
+def test_that_grid_with_zcorn_and_coord_shape_mismatch_raises():
+    with pytest.raises(
+        InvalidGridError, match="zcorn and coord dimensions do not match"
+    ):
+        CornerpointGrid(
+            coord=np.array(
+                [
+                    [[[0, 0, 0], [0, 0, 1]], [[0, 1, 0], [0, 1, 1]]],
+                    [[[1, 0, 0], [1, 0, 1]], [[1, 1, 0], [1, 1, 1]]],
+                ],
+                dtype=np.float32,
+            ),
+            zcorn=np.array(
+                [[[[0, 0, 0, 0, 1, 1, 1, 1]]], [[[0, 0, 0, 0, 1, 1, 1, 1]]]],
+                dtype=np.float32,
+            ),
+        )
+
+
 @pytest.mark.parametrize(
     "contents_after_global_grid",
     [
@@ -193,61 +240,6 @@ def test_that_read_egrid_fetches_the_geometry_from_the_global_grid_in_the_file(
     ]
 
 
-def test_that_pillars_z_plane_intersection_returns_meshgrid():
-    coord = np.array(
-        [
-            [
-                [[0.0, 0.0, 0.0], [1.0, 10.0, 100.0]],
-                [[10.0, 20.0, 0.0], [20.0, 30.0, 100.0]],
-            ]
-        ]
-    )
-    grid = CornerpointGrid(coord, None, None)
-    assert grid._pillars_z_plane_intersection(50.0).tolist() == [
-        [[0.5, 5.0], [15.0, 25.0]]
-    ]
-
-
-def test_that_pillars_z_plane_intersection_keeps_same_shape_as_coord_in_i_j_dimensions():
-    coord = np.array(
-        [
-            [
-                [[0.0, 1.0, 100.0], [0.0, 1.0, 200.0]],
-                [[2.0, 3.0, 101.0], [2.0, 3.0, 201.0]],
-                [[4.0, 5.0, 102.0], [4.0, 5.0, 202.0]],
-            ],
-            [
-                [[6.0, 7.0, 103.0], [6.0, 7.0, 203.0]],
-                [[8.0, 9.0, 104.0], [8.0, 9.0, 204.0]],
-                [[10.0, 11.0, 105.0], [10.0, 11.0, 205.0]],
-            ],
-            [
-                [[12.0, 13.0, 106.0], [12.0, 13.0, 206.0]],
-                [[14.0, 15.0, 107.0], [14.0, 15.0, 207.0]],
-                [[16.0, 17.0, 108.0], [16.0, 17.0, 208.0]],
-            ],
-        ]
-    )
-    grid = CornerpointGrid(coord, None, None)
-    assert grid._pillars_z_plane_intersection(50.0).tolist() == [
-        [
-            [0.0, 1.0],
-            [2.0, 3.0],
-            [4.0, 5.0],
-        ],
-        [
-            [6.0, 7.0],
-            [8.0, 9.0],
-            [10.0, 11.0],
-        ],
-        [
-            [12.0, 13.0],
-            [14.0, 15.0],
-            [16.0, 17.0],
-        ],
-    ]
-
-
 @pytest.fixture
 def unit_cell_grid():
     """A Corner point grid which just contains the unit cube as a cell"""
@@ -362,9 +354,12 @@ def regular_grids(draw):
     return CornerpointGrid(coord, zcorn)
 
 
+points = st.tuples(coordinates, coordinates, coordinates)
+
+
 @given(
     grid=regular_grids(),
-    point=st.tuples(coordinates, coordinates, coordinates),
+    point=points,
     data=st.data(),
 )
 def test_that_found_cell_contains_point(grid, point, data):
@@ -386,7 +381,7 @@ def test_that_found_cell_contains_point(grid, point, data):
 
 @given(
     grid=regular_grids(),
-    point=st.tuples(coordinates, coordinates, coordinates),
+    point=points,
     data=st.data(),
 )
 def test_that_on_regular_grids_point_in_cell_is_the_same_as_in_bounding_box(
@@ -560,3 +555,164 @@ def test_point_in_cell_considers_cells_as_trilinear_shapes(bottom_heights, x, y,
     assert grid.point_in_cell([x, y, z], 0, 0, 0, tolerance) == (
         z <= bottom_face_depth(x, y) and in_bounding_box((x, y, z))
     )
+
+
+def test_that_zero_height_pillar_is_invalid():
+    grid = CornerpointGrid(
+        coord=np.array(
+            [
+                [
+                    [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+                    [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+                ],
+                [
+                    [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+                    [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+                ],
+            ],
+            dtype=np.float32,
+        ),
+        zcorn=np.array(
+            [[[[0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0]]]], dtype=np.float32
+        ),
+        map_axes=None,
+    )
+    with pytest.raises(InvalidGridError, match="Grid contains zero height pillars"):
+        grid.cell_corners(0, 0, 0)
+
+
+def test_that_cells_with_infinite_pillars_are_invalid():
+    grid = CornerpointGrid(
+        coord=np.array(
+            [
+                [
+                    [[np.inf, np.inf, np.inf], [np.inf, np.inf, np.inf]],
+                    [[np.inf, np.inf, np.inf], [np.inf, np.inf, np.inf]],
+                ],
+                [
+                    [[np.inf, np.inf, np.inf], [np.inf, np.inf, np.inf]],
+                    [[np.inf, np.inf, np.inf], [np.inf, np.inf, np.inf]],
+                ],
+            ],
+            dtype=np.float32,
+        ),
+        zcorn=np.array(
+            [[[[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]]], dtype=np.float32
+        ),
+        map_axes=None,
+    )
+
+    with pytest.raises(InvalidGridError, match="The corners of the cell"):
+        grid.cell_corners(0, 0, 0)
+
+
+@st.composite
+def single_cell_grids(draw):
+    nice_elements = dict(
+        allow_nan=False, allow_infinity=False, max_value=2**12, min_value=-(2**12)
+    )
+    coord = draw(
+        arrays(
+            np.float32,
+            (2, 2, 2, 3),
+            elements=nice_elements,
+        )
+    )
+
+    for i in range(coord.shape[0]):
+        for j in range(coord.shape[1]):
+            bot_pillar_z = np.float32(coord[i, j, 0, 2] + 0.1)
+            coord[i, j, 1] = draw(
+                from_dtype(
+                    np.dtype(np.float32),
+                    **{
+                        **nice_elements,
+                        **dict(min_value=bot_pillar_z, max_value=2**14),
+                    },
+                )
+            )
+
+    grid = CornerpointGrid(
+        coord=coord,
+        zcorn=draw(arrays(np.float32, (1, 1, 1, 8), elements=nice_elements)),
+    )
+    try:
+        grid.cell_corners(0, 0, 0)
+    except InvalidGridError:
+        assume(False)
+    return grid
+
+
+@given(single_cell_grids(), points)
+@example(
+    grid=CornerpointGrid(
+        coord=np.array(
+            [
+                [
+                    [[1.0, 1.0, 1.0], [2.0, 2.0, 2.0]],
+                    [[1.0, 1.0, 1.0], [2.0, 2.0, 2.0]],
+                ],
+                [
+                    [[1.0, 1.0, 1.0], [2.0, 2.0, 2.0]],
+                    [[1.0, 1.0, 1.0], [2.0, 2.0, 2.0]],
+                ],
+            ],
+            dtype=np.float32,
+        ),
+        zcorn=np.array(
+            [[[[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]]], dtype=np.float32
+        ),
+        map_axes=None,
+    ),
+    point=(0.0, 0.0, 0.0),
+).via("discovered failure")
+@example(
+    grid=CornerpointGrid(
+        coord=np.array(
+            [
+                [
+                    [[0.0, 0.0, -1.0], [0.0, 0.0, 1.0]],
+                    [[0.0, 1.0, 0.0], [2.0, 1.0, 2.0]],
+                ],
+                [
+                    [[1.0, 0.0, -1.0], [1.0, 0.0, 1.0]],
+                    [[0.0, 1.0, -1.0], [0.0, 1.0, 1.0]],
+                ],
+            ],
+            dtype=np.float32,
+        ),
+        zcorn=np.array(
+            [[[[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]]], dtype=np.float32
+        ),
+        map_axes=None,
+    ),
+    point=(0.0, 0.0, 0.0),
+).via("constructed grid with bulging face")
+@example(
+    grid=CornerpointGrid(
+        coord=np.array(
+            [
+                [
+                    [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]],
+                    [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]],
+                ],
+                [
+                    [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]],
+                    [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]],
+                ],
+            ],
+            dtype=np.float32,
+        ),
+        zcorn=np.array(
+            [[[[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]]], dtype=np.float32
+        ),
+        map_axes=None,
+    ),
+    point=(0.0, 0.0, 9.999999747378752e-06),
+).via("discovered failure")
+def test_that_in_single_cell_grids_found_and_contains_are_the_same(
+    grid: CornerpointGrid, point: tuple[float, float, float]
+):
+    assert bool(grid.find_cell_containing_point([point])[0]) == grid.point_in_cell(
+        point, 0, 0, 0
+    )