resqpy 4.15.3__tar.gz → 4.16.1__tar.gz

{resqpy-4.15.3 → resqpy-4.16.1}/PKG-INFO

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

{resqpy-4.15.3 → resqpy-4.16.1}/pyproject.toml

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

{resqpy-4.15.3 → resqpy-4.16.1}/resqpy/__init__.py

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

{resqpy-4.15.3 → resqpy-4.16.1}/resqpy/fault/_gcs_functions.py

@@ -439,29 +439,29 @@ def combined_tr_mult_from_gcs_mults(model,
 
         # merge in each of the three directional face arrays for this gcs with combined arrays
         for (combo_trm, gcs_trm) in [(combo_trm_k, gcs_trm_k), (combo_trm_j, gcs_trm_j), (combo_trm_i, gcs_trm_i)]:
-            mask = np.logical_not(np.isnan(gcs_trm))  # true where this tr mult is present
+            mask = np.logical_not(np.isnan(gcs_trm)).astype(bool)  # true where this tr mult is present
             clash_mask = np.logical_and(mask, np.logical_not(np.isnan(combo_trm)))  # true where combined value clashes
             if np.any(clash_mask):
                 if merge_mode == 'exception':
                     raise ValueError('gcs transmissibility multiplier conflict when merging')
                 if merge_mode == 'minimum':
-                    combo_trm[:] = np.where(clash_mask, np.minimum(combo_trm, gcs_trm), combo_trm)
+                    combo_trm[clash_mask] = np.minimum(combo_trm, gcs_trm)[clash_mask]
                 elif merge_mode == 'maximum':
-                    combo_trm[:] = np.where(clash_mask, np.maximum(combo_trm, gcs_trm), combo_trm)
+                    combo_trm[clash_mask] = np.maximum(combo_trm, gcs_trm)[clash_mask]
                 elif merge_mode == 'multiply':
-                    combo_trm[:] = np.where(clash_mask, combo_trm * gcs_trm, combo_trm)
+                    combo_trm[clash_mask] = (combo_trm * gcs_trm)[clash_mask]
                 else:
                     raise Exception(f'code failure with unrecognised merge mode {merge_mode}')
                 mask = np.logical_and(mask,
                                       np.logical_not(clash_mask))  # remove clash faces from mask (already handled)
             if np.any(mask):
-                combo_trm[:] = np.where(mask, gcs_trm, combo_trm)  # update combined array from individual array
+                combo_trm[mask] = gcs_trm[mask]  # update combined array from individual array
 
     # for each of the 3 combined tr mult arrays, replace unused values with the default fill value
     # also check that any set values are non-negative
     for combo_trm in (combo_trm_k, combo_trm_j, combo_trm_i):
         if fill_value is not None and not np.isnan(fill_value):
-            combo_trm[:] = np.where(np.isnan(combo_trm), fill_value, combo_trm)
+            combo_trm[:][np.isnan(combo_trm).astype(bool)] = fill_value
             assert np.all(combo_trm >= 0.0)
         else:
             assert np.all(np.logical_or(np.isnan(combo_trm), combo_trm >= 0.0))

{resqpy-4.15.3 → resqpy-4.16.1}/resqpy/fault/_grid_connection_set.py

@@ -2100,9 +2100,6 @@ class GridConnectionSet(BaseResqpy):
         ak = np.full((nk + 1, nj, ni), default_value, dtype = dtype)
         aj = np.full((nk, nj + 1, ni), default_value, dtype = dtype)
         ai = np.full((nk, nj, ni + 1), default_value, dtype = dtype)
-        # mk = np.zeros((nk + 1, nj, ni), dtype = bool)
-        # mj = np.zeros((nk, nj + 1, ni), dtype = bool)
-        # mi = np.zeros((nk, nj, ni + 1), dtype = bool)
 
         # populate arrays from faces of gcs, optionally filtered by feature index
         cip, fip = self.list_of_cell_face_pairs_for_feature_index(None)
@@ -2113,42 +2110,36 @@ class GridConnectionSet(BaseResqpy):
         else:
             indices = self.indices_for_feature_index(feature_index)
 
-        # opposing_count = 0
         side_list = ([0] if lazy else [0, 1])
-        for fi in indices:
-            # fi = int(i)
-            if active_mask is not None and not active_mask[fi]:
-                continue
-            value = gcs_prop_array[fi]
-            if baffle_mask is not None and baffle_mask[fi]:
-                value = 0  # will be cast to float (or bool) if needed when assigned below
-            for side in side_list:
-                cell_kji0 = cip[fi, side].copy()
-                # opposing = cell_kji0.copy()
-                axis, polarity = fip[fi, side]
-                assert 0 <= axis <= 2 and 0 <= polarity <= 1
-                cell_kji0[axis] += polarity
-                # opposing[axis] += (1 - polarity)
-                if axis == 0:
-                    ak[tuple(cell_kji0)] = value
-                    # mk[tuple(cell_kji0)] = True
-                    # if mk[tuple(opposing)]:
-                    #     opposing_count += 1
-                elif axis == 1:
-                    aj[tuple(cell_kji0)] = value
-                    # mj[tuple(cell_kji0)] = True
-                    # if mj[tuple(opposing)]:
-                    #     opposing_count += 1
-                else:
-                    ai[tuple(cell_kji0)] = value
-                    # mi[tuple(cell_kji0)] = True
-                    # if mi[tuple(opposing)]:
-                    #     opposing_count += 1
-
-        # if opposing_count:
-        #     log.warning(f'{opposing_count} suspicious opposing faces of {len(indices)} detected in gcs: {self.title}')
-        # else:
-        #     log.debug(f'no suspicious opposing faces detected in gcs: {self.title}')
+
+        value_array = gcs_prop_array.copy()
+        if baffle_mask is not None:
+            value_array[baffle_mask] = 0  # will be cast to float (or bool) if needed
+        if active_mask is not None:
+            cip = cip[active_mask, :, :]
+            value_array = value_array[active_mask]
+
+        for side in side_list:
+            cell_kji0 = cip[:, side].copy()  # shape (N, 3)
+            axis = fip[:, side, 0]  # shape (N,)
+            polarity = fip[:, side, 1]  # shape (N,)
+            assert 0 <= np.min(axis) and np.max(axis) <= 2
+            assert 0 <= np.min(polarity) and np.max(polarity) <= 1
+
+            axis_mask = (axis == 0).astype(bool)
+            ak_kji0 = cell_kji0[axis_mask, :]
+            ak_kji0[:, 0] += polarity[axis_mask]
+            ak[ak_kji0[:, 0], ak_kji0[:, 1], ak_kji0[:, 2]] = value_array[axis_mask]
+
+            axis_mask = (axis == 1).astype(bool)
+            aj_kji0 = cell_kji0[axis_mask, :]
+            aj_kji0[:, 1] += polarity[axis_mask]
+            aj[aj_kji0[:, 0], aj_kji0[:, 1], aj_kji0[:, 2]] = value_array[axis_mask]
+
+            axis_mask = (axis == 2).astype(bool)
+            ai_kji0 = cell_kji0[axis_mask, :]
+            ai_kji0[:, 2] += polarity[axis_mask]
+            ai[ai_kji0[:, 0], ai_kji0[:, 1], ai_kji0[:, 2]] = value_array[axis_mask]
 
         return (ak, aj, ai)
 

{resqpy-4.15.3 → resqpy-4.16.1}/resqpy/grid/_grid.py

@@ -2255,9 +2255,9 @@ class Grid(BaseResqpy):
         pc = self.extract_property_collection()
 
         if baffle_triplet is not None:
-            trm_k[1:-1] = np.where(baffle_triplet[0], 0.0, trm_k[1:-1])
-            trm_j[:, 1:-1] = np.where(baffle_triplet[1], 0.0, trm_j[:, 1:-1])
-            trm_i[:, :, 1:-1] = np.where(baffle_triplet[2], 0.0, trm_i[:, :, 1:-1])
+            trm_k[1:-1][baffle_triplet[0]] = 0.0
+            trm_j[:, 1:-1][baffle_triplet[1]] = 0.0
+            trm_i[:, :, 1:-1][baffle_triplet[2]] = 0.0
 
         if composite_property:
             tr_composite = np.concatenate((trm_k.flat, trm_j.flat, trm_i.flat))

{resqpy-4.15.3 → resqpy-4.16.1}/resqpy/property/_collection_create_xml.py

@@ -66,7 +66,7 @@ def _create_xml_property_kind(collection, p_node, find_local_property_kinds, pro
         property_kind = 'rock permeability'
     p_kind_node = rqet.SubElement(p_node, ns['resqml2'] + 'PropertyKind')
     p_kind_node.text = rqet.null_xml_text
-    if find_local_property_kinds and property_kind not in rqp_c.supported_property_kind_list:
+    if find_local_property_kinds and property_kind not in wam.valid_property_kinds():
         property_kind_uuid = pcga._get_property_kind_uuid(collection, property_kind_uuid, property_kind, uom, discrete)
 
     if property_kind_uuid is None:

{resqpy-4.15.3 → resqpy-4.16.1}/resqpy/property/property_common.py

@@ -12,18 +12,13 @@ import numpy as np
 import resqpy.property as rqp
 import resqpy.olio.uuid as bu
 import resqpy.olio.xml_et as rqet
-import resqpy.weights_and_measures as bwam
+import resqpy.weights_and_measures as wam
 
 # the following resqml property kinds and facet types are 'known about' by this module in relation to nexus
 # other property kinds should be handled okay but without any special treatment
 # see property_kind_and_facet_from_keyword() for simulator keyword to property kind and facet mapping
 
-supported_property_kind_list = [
-    'continuous', 'discrete', 'categorical', 'code', 'index', 'depth', 'rock volume', 'pore volume', 'volume',
-    'thickness', 'length', 'cell length', 'area', 'net to gross ratio', 'porosity', 'permeability thickness',
-    'permeability length', 'permeability rock', 'rock permeability', 'fluid volume', 'transmissibility', 'pressure',
-    'saturation', 'solution gas-oil ratio', 'vapor oil-gas ratio', 'property multiplier', 'thermodynamic temperature'
-]
+supported_property_kind_list = list(wam.valid_property_kinds())
 
 supported_local_property_kind_list = [
     'active', 'transmissibility multiplier', 'fault transmissibility', 'mat transmissibility'
@@ -326,7 +321,7 @@ def infer_property_kind(name, unit):
 
     # Currently unit is ignored
 
-    valid_kinds = bwam.valid_property_kinds()
+    valid_kinds = wam.valid_property_kinds()
 
     if name in valid_kinds:
         kind = name