resqpy 4.18.3__tar.gz → 4.18.5__tar.gz

{resqpy-4.18.3 → resqpy-4.18.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: resqpy
-Version: 4.18.3
+Version: 4.18.5
 Summary: Python API for working with RESQML models
 Home-page: https://github.com/bp/resqpy
 License: MIT

{resqpy-4.18.3 → resqpy-4.18.5}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "poetry.masonry.api"
 
 [tool.poetry]
 name = "resqpy"
-version = "4.18.3" # Set at build time
+version = "4.18.5" # Set at build time
 description = "Python API for working with RESQML models"
 authors = ["BP"]
 license = "MIT"

{resqpy-4.18.3 → resqpy-4.18.5}/resqpy/__init__.py

@@ -28,6 +28,6 @@
 
 import logging
 
-__version__ = "4.18.3"  # Set at build time
+__version__ = "4.18.5"  # Set at build time
 log = logging.getLogger(__name__)
 log.info(f"Imported resqpy version {__version__}")

{resqpy-4.18.3 → resqpy-4.18.5}/resqpy/grid_surface/_find_faces.py

@@ -24,27 +24,6 @@ import resqpy.olio.vector_utilities as vec
 # note: resqpy.grid_surface._grid_surface_cuda will be imported by the find_faces_to_represent_surface() function if needed
 
 
-@njit  # pragma: no cover
-def _bitwise_count_njit(a: np.ndarray) -> int:
-    """Deprecated: only needed till numpy versions < 2.0.0 are dropped."""
-    c: int = 0
-    c += np.count_nonzero(np.bitwise_and(a, 0x01))
-    c += np.count_nonzero(np.bitwise_and(a, 0x02))
-    c += np.count_nonzero(np.bitwise_and(a, 0x04))
-    c += np.count_nonzero(np.bitwise_and(a, 0x08))
-    c += np.count_nonzero(np.bitwise_and(a, 0x10))
-    c += np.count_nonzero(np.bitwise_and(a, 0x20))
-    c += np.count_nonzero(np.bitwise_and(a, 0x40))
-    c += np.count_nonzero(np.bitwise_and(a, 0x80))
-    return c
-
-
-if hasattr(np, 'bitwise_count'):
-    bitwise_count = np.bitwise_count
-else:
-    bitwise_count = _bitwise_count_njit
-
-
 def find_faces_to_represent_surface_staffa(grid, surface, name, feature_type = "fault", progress_fn = None):
     """Returns a grid connection set containing those cell faces which are deemed to represent the surface.
 
@@ -1585,12 +1564,17 @@ def packed_bisector_from_face_indices(  # type: ignore
     _set_packed_bisector_outside_box(array, box, box_array, grid_extent_kji[2] % 8)
 
     # check all array elements are not the same
-    true_count = np.sum(bitwise_count(array))  # note: will usually include some padding bits, so not so true!
+    if hasattr(np, 'bitwise_count'):
+        true_count = np.sum(np.bitwise_count(array))
+    else:
+        true_count = _bitwise_count_njit(array)  # note: will usually include some padding bits, so not so true!
     cell_count = np.prod(grid_extent_kji)
     assert (0 < true_count < cell_count), "face set for surface is leaky or empty (surface does not intersect grid)"
 
     # negate the array if it minimises the mean k and determine if the surface is a curtain
-    is_curtain = _packed_shallow_or_curtain(array, true_count, raw_bisector)
+    is_curtain = _packed_shallow_or_curtain_temp_bitwise_count(array, true_count, raw_bisector)
+    # todo: switch to numpy bitwise_count when numba supports it and resqpy has dropped older numpy versions
+    # is_curtain = _packed_shallow_or_curtain(array, true_count, raw_bisector)
 
     return array, is_curtain
 
@@ -2028,20 +2012,22 @@ def _fill_bisector(bisect: np.ndarray, open_k: np.ndarray, open_j: np.ndarray, o
                         going = True
 
 
-# TODO: uncomment njit
-#@njit  # pragma: no cover
+@njit  # pragma: no cover
 def _fill_packed_bisector(bisect: np.ndarray, open_k: np.ndarray, open_j: np.ndarray, open_i: np.ndarray):
     nk: int = bisect.shape[0]
     nj: int = bisect.shape[1]
     ni: int = bisect.shape[2]
     going: bool = True
+    m: np.uint8 = np.uint8(0)
+    om: np.uint8 = np.uint8(0)
+    oi: np.uint8 = np.uint8(0)
     while going:
         going = False
         for k in range(nk):
             for j in range(nj):
                 for i in range(ni):
-                    m = bisect[k, j, i]  # 8 bools packed into a uint8
-                    if bisect[k, j, i] == 255:  # all 8 values already set
+                    m = np.uint8(bisect[k, j, i])  # 8 bools packed into a uint8
+                    if bisect[k, j, i] == np.uint8(0xFF):  # all 8 values already set
                         continue
                     om = m  # copy to check for changes later
                     if k:
@@ -2052,14 +2038,14 @@ def _fill_packed_bisector(bisect: np.ndarray, open_k: np.ndarray, open_j: np.nda
                         m |= (bisect[k, j - 1, i] & open_j[k, j - 1, i])
                     if j < nj - 1:
                         m |= (bisect[k, j + 1, i] & open_j[k, j, i])
-                    oi = open_i[k, j, i]
-                    m |= (m >> 1) & (oi >> 1)
-                    m |= (m << 1) & oi
+                    oi = np.uint8(open_i[k, j, i])  # type: ignore
+                    m |= (m >> 1) & (oi >> 1)  # type: ignore
+                    m |= (m << 1) & oi  # type: ignore
                     # handle rollover bits for I
-                    if i and (bisect[k, j, i - 1] & open_i[k, j, i - 1] & 1):
-                        m |= 0x80
+                    if i and (bisect[k, j, i - 1] & open_i[k, j, i - 1] & np.uint8(0x01)):
+                        m |= np.uint8(0x80)
                     if (i < ni - 1) and (oi & 1) and (bisect[k, j, i + 1] & 0x80):
-                        m |= 1
+                        m |= np.uint8(0x01)
                     if m != om:
                         bisect[k, j, i] = m
                         going = True
@@ -2088,8 +2074,7 @@ def _shallow_or_curtain(a: np.ndarray, true_count: int, raw: bool) -> bool:
     return is_curtain
 
 
-# TODO: uncomment njit
-#@njit  # pragma: no cover
+@njit  # pragma: no cover
 def _packed_shallow_or_curtain(a: np.ndarray, true_count: int, raw: bool) -> bool:
     # negate the packed bool array if it minimises the mean k and determine if the bisector indicates a curtain
     assert a.ndim == 3
@@ -2099,13 +2084,38 @@ def _packed_shallow_or_curtain(a: np.ndarray, true_count: int, raw: bool) -> boo
     is_curtain: bool = False
     layer_count: int = 0
     for k in range(a.shape[0]):
-        layer_count = np.sum(bitwise_count(a[k]))
+        # np.bitwise_count() not yet supported by numba
+        layer_count = np.sum(np.bitwise_count(a[k]), dtype = np.int64)  # type: ignore
         k_sum += (k + 1) * layer_count
         opposite_k_sum += (k + 1) * (layer_cell_count - layer_count)
     mean_k: float = float(k_sum) / float(true_count)
     opposite_mean_k: float = float(opposite_k_sum) / float(8 * a.size - true_count)
     if mean_k > opposite_mean_k and not raw:
-        a[:] = np.invert(a, dtype = np.uint8)
+        a[:] = np.invert(a)
+    if abs(mean_k - opposite_mean_k) <= 0.001:
+        # log.warning('unable to determine which side of surface is shallower')
+        is_curtain = True
+    return is_curtain
+
+
+@njit  # pragma: no cover
+def _packed_shallow_or_curtain_temp_bitwise_count(a: np.ndarray, true_count: int, raw: bool) -> bool:
+    # negate the packed bool array if it minimises the mean k and determine if the bisector indicates a curtain
+    assert a.ndim == 3
+    # note: following 'cell count' includes padding bits
+    layer_cell_count: np.int64 = 8 * a.shape[1] * a.shape[2]  # type: ignore
+    k_sum: np.int64 = 0  # type: ignore
+    opposite_k_sum: np.int64 = 0  # type: ignore
+    is_curtain: bool = False
+    layer_count: np.int64 = 0  # type: ignore
+    for k in range(a.shape[0]):
+        layer_count = _bitwise_count_njit(a[k])
+        k_sum += (k + 1) * layer_count
+        opposite_k_sum += (k + 1) * (layer_cell_count - layer_count)
+    mean_k: float = float(k_sum) / float(true_count)
+    opposite_mean_k: float = float(opposite_k_sum) / float(8 * a.size - true_count)
+    if mean_k > opposite_mean_k and not raw:
+        a[:] = np.invert(a)
     if abs(mean_k - opposite_mean_k) <= 0.001:
         # log.warning('unable to determine which side of surface is shallower')
         is_curtain = True
@@ -2274,3 +2284,18 @@ def _shape_packed(unpacked_shape):
     head = list(unpacked_shape[:-1])
     head.append(shrunken)
     return tuple(head)
+
+
+@njit  # pragma: no cover
+def _bitwise_count_njit(a: np.ndarray) -> np.int64:
+    """Deprecated: only needed till numpy versions < 2.0.0 are dropped."""
+    c: np.int64 = 0  # type: ignore
+    c += np.count_nonzero(np.bitwise_and(a, 0x01))
+    c += np.count_nonzero(np.bitwise_and(a, 0x02))
+    c += np.count_nonzero(np.bitwise_and(a, 0x04))
+    c += np.count_nonzero(np.bitwise_and(a, 0x08))
+    c += np.count_nonzero(np.bitwise_and(a, 0x10))
+    c += np.count_nonzero(np.bitwise_and(a, 0x20))
+    c += np.count_nonzero(np.bitwise_and(a, 0x40))
+    c += np.count_nonzero(np.bitwise_and(a, 0x80))
+    return c

{resqpy-4.18.3 → resqpy-4.18.5}/resqpy/multi_processing/wrappers/grid_surface_mp.py

@@ -353,7 +353,7 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
                                                           ('vertical' if is_curtain else 'sloping'),
                                                           realization = realisation,
                                                           indexable_element = "columns" if is_curtain else "cells",
-                                                          pre_packed = use_pack)
+                                                          pre_packed = False if is_curtain else use_pack)
             elif p_name == 'grid shadow':
                 if grid_pc is None:
                     grid_pc = rqp.PropertyCollection()