resqpy 4.18.3__py3-none-any.whl → 4.18.4__py3-none-any.whl

resqpy/__init__.py

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

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,18 @@ 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)
+    print(f'**** array shape: {array.shape}; dtype: {array.dtype}')
 
     return array, is_curtain
 
@@ -2028,20 +2013,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 +2039,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 +2075,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 +2085,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 +2285,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.dist-info → resqpy-4.18.4.dist-info}/METADATA

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

{resqpy-4.18.3.dist-info → resqpy-4.18.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-resqpy/__init__.py,sha256=h-xRZeh8uYnzFHKt-aS_ERySkjCO9kcZ31zV2u3C86k,556
+resqpy/__init__.py,sha256=3l-Kxew1egDvWafAvymh-cOYinz6WxZkG5dEkZXBBQk,556
 resqpy/crs.py,sha256=R7DfcTP5xGv5pu9Y8RHA2WVM9DjBCSVMoHcz4RmQ7Yw,27646
 resqpy/derived_model/__init__.py,sha256=NFvMSOKI3cxmH7lAbddV43JjoUj-r2G7ExEfOqinD1I,1982
 resqpy/derived_model/_add_edges_per_column_property_array.py,sha256=cpW3gwp6MSYIrtvFmCjoJXcyUsgGuCDbgmwlJCJebUs,6410
@@ -48,7 +48,7 @@ resqpy/grid/_write_nexus_corp.py,sha256=yEVfiObsedEAXX6UG6ZTf56kZnQVkd3lLqE2NpL-
 resqpy/grid/_xyz.py,sha256=RLQWOdM_DRoCj4JypwB5gUJ78HTdk5JnZHSeAzuU634,13087
 resqpy/grid_surface/__init__.py,sha256=IlPwm6G7P_Vg_w7JHqSs-d_oxk2QmFtWGTk_vvr1qm8,2911
 resqpy/grid_surface/_blocked_well_populate.py,sha256=Lme1AR-nLWOUlNnmHMVThk6jEg_lAZxWWtL82Yksppw,35867
-resqpy/grid_surface/_find_faces.py,sha256=YyZ2x453BgBaBaOYII1yIXCyEi6_LML2s4zJCtG4wGQ,105201
+resqpy/grid_surface/_find_faces.py,sha256=sgMvBX8kduq2taAe1RRHpUjn1iCgex1F8cAJVG9hqJY,106856
 resqpy/grid_surface/_grid_skin.py,sha256=D0cjHkcuT5KCKb-8EZfXgh0GgJj3kzOBS2wVNXg4bfY,26056
 resqpy/grid_surface/_grid_surface.py,sha256=l2NJo7Kiucolbb_TlLPC7NGdksg_JahkihfsrJVq99w,14379
 resqpy/grid_surface/_trajectory_intersects.py,sha256=Och9cZYU9Y7ofovhPzsLyIblRUl2xj9_5nHH3fMZp-A,22498
@@ -194,7 +194,7 @@ resqpy/well/_wellbore_marker_frame.py,sha256=xvYH2_2Ie3a18LReFymbUrZboOx7Rhv5DOD
 resqpy/well/blocked_well_frame.py,sha256=Rx8jwkCjchseDZaTttPkA1-f6l7W6vRGrxWtDHlEPx8,22560
 resqpy/well/well_object_funcs.py,sha256=tWufc8wahihzMEO-Ou1dncIttrf4bNo1qmLgh3I2pOM,24717
 resqpy/well/well_utils.py,sha256=zwpYjT85nXAwWBhYB1Pygu2SgouZ-44k6hEOnpoMfBI,5969
-resqpy-4.18.3.dist-info/LICENSE,sha256=2duHPIkKQyESMdQ4hKjL8CYEsYRHXaYxt0YQkzsUYE4,1059
-resqpy-4.18.3.dist-info/METADATA,sha256=7giwDE8PWXV3N0JGfUqPHqe0NbLsxVQrjz-gu1W1oZ0,4028
-resqpy-4.18.3.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-resqpy-4.18.3.dist-info/RECORD,,
+resqpy-4.18.4.dist-info/LICENSE,sha256=2duHPIkKQyESMdQ4hKjL8CYEsYRHXaYxt0YQkzsUYE4,1059
+resqpy-4.18.4.dist-info/METADATA,sha256=G_V0kUoVekOZesVDi5IaV1HZWvTRT_tvA1qdB3gsKHw,4028
+resqpy-4.18.4.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+resqpy-4.18.4.dist-info/RECORD,,