resqpy 4.16.11__tar.gz → 4.17.1__tar.gz

{resqpy-4.16.11 → resqpy-4.17.1}/PKG-INFO

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

{resqpy-4.16.11 → resqpy-4.17.1}/pyproject.toml

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

{resqpy-4.16.11 → resqpy-4.17.1}/resqpy/__init__.py

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

{resqpy-4.16.11 → resqpy-4.17.1}/resqpy/fault/_grid_connection_set.py

@@ -10,6 +10,7 @@ import math as maths
 import numpy as np
 import pandas as pd
 
+import resqpy.grid as grr
 import resqpy.fault
 import resqpy.olio.read_nexus_fault as rnf
 import resqpy.olio.trademark as tm
@@ -118,7 +119,7 @@ class GridConnectionSet(BaseResqpy):
         self.cell_index_pairs = None  #: shape (count, 2); dtype int; index normalized for flattened array
         self.cell_index_pairs_null_value = -1  #: integer null value for array above
         self.grid_index_pairs = None  #: shape (count, 2); dtype int; optional; used if more than one grid referenced
-        self.face_index_pairs = None  #: shape (count, 2); dtype int32; local to cell, ie. range 0 to 5
+        self.face_index_pairs = None  #: shape (count, 2); dtype int8; local to cell, ie. range 0 to 5
         self.face_index_pairs_null_value = -1  #: integer null value for array above
         # NB face index values 0..5 usually mean [K-, K+, J+, I+, J-, I-] respectively but there is some ambiguity
         #    over I & J in the Energistics RESQML Usage Guide; see comments in DevOps backlog item 269001 for more info
@@ -129,17 +130,18 @@ class GridConnectionSet(BaseResqpy):
         self.feature_list = None  #: ordered list, actually of interpretations, indexed by feature_indices
         # feature list contains tuples: (content_type, uuid, title) for fault features (or other interpretations)
         self.property_collection = None  #: optional property.PropertyCollection
+        self.cell_index_dtype = np.int32  #: set to int64 if any grid is big, otherwise int32
 
         # NB: RESQML documentation is not clear which order is correct; should be kept consistent with same data in property.py
         # face_index_map maps from (axis, p01) to face index value in range 0..5
         # this is the default as indicated on page 139 (but not p. 180) of the RESQML Usage Gude v2.0.1
         # also assumes K is generally increasing downwards
         # see DevOps backlog item 269001 discussion for more information
-        #     self.face_index_map = np.array([[0, 1], [4, 2], [5, 3]], dtype = int)
-        self.face_index_map = np.array([[0, 1], [2, 4], [5, 3]], dtype = int)  # order: top, base, J-, I+, J+, I-
+        #     self.face_index_map = np.array([[0, 1], [4, 2], [5, 3]], dtype = np.int8)
+        self.face_index_map = np.array([[0, 1], [2, 4], [5, 3]], dtype = np.int8)  # order: top, base, J-, I+, J+, I-
         # and the inverse, maps from 0..5 to (axis, p01)
-        #     self.face_index_inverse_map = np.array([[0, 0], [0, 1], [1, 1], [2, 1], [1, 0], [2, 0]], dtype = int)
-        self.face_index_inverse_map = np.array([[0, 0], [0, 1], [1, 0], [2, 1], [1, 1], [2, 0]], dtype = int)
+        #     self.face_index_inverse_map = np.array([[0, 0], [0, 1], [1, 1], [2, 1], [1, 0], [2, 0]], dtype = np.int8)
+        self.face_index_inverse_map = np.array([[0, 0], [0, 1], [1, 0], [2, 1], [1, 1], [2, 0]], dtype = np.int8)
         # note: the rework_face_pairs() method, below, overwrites the face indices based on I, J cell indices
         if not title:
             title = feature_name
@@ -196,6 +198,110 @@ class GridConnectionSet(BaseResqpy):
                 self.cache_arrays()
             if find_properties:
                 self.extract_property_collection()
+        self._set_cell_index_dtype()
+
+    @classmethod
+    def from_faces_indices(cls,
+                           grid,
+                           k_faces_kji0,
+                           j_faces_kji0,
+                           i_faces_kji0,
+                           remove_duplicates = True,
+                           k_properties = None,
+                           j_properties = None,
+                           i_properties = None,
+                           feature_name = None,
+                           feature_type = 'fault',
+                           create_organizing_objects_where_needed = True,
+                           title = None,
+                           originator = None,
+                           extra_metadata = None):
+        """Create a GridConnectionSet given a grid and 3 list-like arrays identifying faces by indices.
+        
+        arguments:
+            - grid (Grid): the single grid to be referenced by the grid connection set
+            - k_faces_kji0 (numpy int array of shape (Nk, 3)): indices of cells on negative side of desired K faces
+            - j_faces_kji0 (numpy int array of shape (Nj, 3)): indices of cells on negative side of desired J faces
+            - i_faces_kji0 (numpy int array of shape (Ni, 3)): indices of cells on negative side of desired I faces
+            - remove_duplicates (bool, default True): if True, indices are sorted and duplicates removed
+            - k_properties (list of 1D numpy arrays, optional): if present and remove_duplicates is True, each array
+              is sorted and has elements removed to keep them compatible with the indices
+            - j_properties (list of 1D numpy arrays, optional): if present and remove_duplicates is True, each array
+              is sorted and has elements removed to keep them compatible with the indices
+            - i_properties (list of 1D numpy arrays, optional): if present and remove_duplicates is True, each array
+              is sorted and has elements removed to keep them compatible with the indices
+            - feature_name (string, optional): the feature name to use when setting from faces
+            - feature_type (string, default 'fault'): 'fault', 'horizon' or 'geobody boundary'
+            - create_organizing_objects_where_needed (boolean, default True): if True, a fault interpretation object
+              and tectonic boundary feature object will be created if such objects do not exist for the feature;
+              if False, missing organizational objects will cause an error to be logged
+            - title (str, optional): the citation title to use for a new grid connection set
+            - originator (str, optional): the name of the person creating the new grid connection set, defaults to login id
+            - extra_metadata (dict, optional): string key, value pairs to add as extra metadata for the grid connection set
+
+        returns:
+            - a new GridConnectionSet populated based on the faces indices
+
+        notes:
+            - this method only supports creation of single grid connection sets
+            - the faces indices are for cells on the negative side of the face
+            - the paired cell is implicitly the neighbouring cell in the positive direction of the axis
+            - the indices must therefore not include the last cell in the axis, though this is not checked
+            - if properties are passed, they should be passed in list variables which have their elements
+              replaced; individual property arrays should therefore be extracted from the lists afterwards
+        """
+        assert isinstance(grid, grr.Grid)
+
+        gcs = cls(grid.model, title = title, originator = originator, extra_metadata = extra_metadata)
+
+        gcs._sort_out_organizing_objects(feature_type, feature_name, create_organizing_objects_where_needed)
+
+        nj_ni = grid.nj * grid.ni
+        if k_faces_kji0 is not None and len(k_faces_kji0) > 0:
+            ci = grid.natural_cell_indices(k_faces_kji0)
+            if remove_duplicates:
+                ci = _sort_and_remove_duplicates(ci, k_properties)
+            cip = np.empty((ci.size, 2), dtype = gcs.cell_index_dtype)
+            cip[:, 0] = ci
+            cip[:, 1] = ci + nj_ni
+            fip = np.empty(cip.shape, dtype = np.int8)
+            fip[:, 0] = gcs.face_index_map[0, 1]
+            fip[:, 1] = gcs.face_index_map[0, 0]
+        else:
+            cip = np.empty((0, 2), dtype = gcs.cell_index_dtype)
+            fip = np.empty((0, 2), dtype = np.int8)
+        if j_faces_kji0 is not None and len(j_faces_kji0) > 0:
+            ci = grid.natural_cell_indices(j_faces_kji0)
+            if remove_duplicates:
+                ci = _sort_and_remove_duplicates(ci, j_properties)
+            j_cip = np.empty((ci.size, 2), dtype = gcs.cell_index_dtype)
+            j_cip[:, 0] = ci
+            j_cip[:, 1] = ci + grid.ni
+            j_fip = np.empty(j_cip.shape, dtype = np.int8)
+            j_fip[:, 0] = gcs.face_index_map[1, 1]
+            j_fip[:, 1] = gcs.face_index_map[1, 0]
+            cip = np.concatenate((cip, j_cip), axis = 0)
+            fip = np.concatenate((fip, j_fip), axis = 0)
+            del j_cip, j_fip
+        if i_faces_kji0 is not None and len(i_faces_kji0) > 0:
+            ci = grid.natural_cell_indices(i_faces_kji0)
+            if remove_duplicates:
+                ci = _sort_and_remove_duplicates(ci, i_properties)
+            i_cip = np.empty((ci.size, 2), dtype = gcs.cell_index_dtype)
+            i_cip[:, 0] = ci
+            i_cip[:, 1] = ci + 1
+            i_fip = np.empty(i_cip.shape, dtype = np.int8)
+            i_fip[:, 0] = gcs.face_index_map[2, 1]
+            i_fip[:, 1] = gcs.face_index_map[2, 0]
+            cip = np.concatenate((cip, i_cip), axis = 0)
+            fip = np.concatenate((fip, i_fip), axis = 0)
+            del i_cip, i_fip
+        gcs.cell_index_pairs = cip
+        gcs.face_index_pairs = fip
+        gcs.count = len(gcs.cell_index_pairs)
+        gcs.feature_indices = np.zeros(gcs.count, dtype = np.int8)
+        assert len(gcs.face_index_pairs) == gcs.count
+        return gcs
 
     @classmethod
     def from_gcs_uuid_list(cls,
@@ -357,6 +463,14 @@ class GridConnectionSet(BaseResqpy):
             self.property_collection = rqp.PropertyCollection(support = self)
         return self.property_collection
 
+    def _set_cell_index_dtype(self):
+        """Determines whether to use int32 or int64 for normalised cell indices."""
+        self.cell_index_dtype = np.int32
+        for g in self.grid_list:
+            if g.is_big():
+                self.cell_index_dtype = np.int64
+                break
+
     def set_pairs_from_kelp(self,
                             kelp_0,
                             kelp_1,
@@ -394,7 +508,7 @@ class GridConnectionSet(BaseResqpy):
                 k_layer = np.zeros((grid.nk - 1, grid.ni), dtype = bool)
             else:
                 k_layer = np.zeros((grid.nk - 1, grid.nj), dtype = bool)
-            kelp_a = np.array(kelp_k, dtype = int).T
+            kelp_a = np.array(kelp_k, dtype = np.int32).T
             k_layer[kelp_a[0], kelp_a[1]] = True
             k_faces = np.zeros((grid.nk - 1, grid.nj, grid.ni), dtype = bool)
             if axis == 'J':
@@ -408,7 +522,7 @@ class GridConnectionSet(BaseResqpy):
                 j_layer = np.zeros((grid.nj - 1, grid.ni), dtype = bool)
             else:
                 j_layer = np.zeros((grid.nk, grid.nj - 1), dtype = bool)
-            kelp_a = np.array(kelp_j, dtype = int).T
+            kelp_a = np.array(kelp_j, dtype = np.int32).T
             j_layer[kelp_a[0], kelp_a[1]] = True
             j_faces = np.zeros((grid.nk, grid.nj - 1, grid.ni), dtype = bool)
             if axis == 'K':
@@ -422,7 +536,7 @@ class GridConnectionSet(BaseResqpy):
                 i_layer = np.zeros((grid.nj, grid.ni - 1), dtype = bool)
             else:
                 i_layer = np.zeros((grid.nk, grid.ni - 1), dtype = bool)
-            kelp_a = np.array(kelp_i, dtype = int).T
+            kelp_a = np.array(kelp_i, dtype = np.int32).T
             i_layer[kelp_a[0], kelp_a[1]] = True
             i_faces = np.zeros((grid.nk, grid.nj, grid.ni - 1), dtype = bool)
             if axis == 'K':
@@ -438,24 +552,13 @@ class GridConnectionSet(BaseResqpy):
                                        create_organizing_objects_where_needed,
                                        feature_type = feature_type)
 
-    def set_pairs_from_face_masks(
-            self,
-            k_faces,
-            j_faces,
-            i_faces,
-            feature_name,
-            create_organizing_objects_where_needed,
-            feature_type = 'fault',  # other feature_type values: 'horizon', 'geobody boundary'
-            k_sides = None,
-            j_sides = None,
-            i_sides = None):
-        """Sets cell_index_pairs and face_index_pairs based on triple face masks, using simple no throw pairing."""
-
+    def _sort_out_organizing_objects(self, feature_type, feature_name, create_organizing_objects_where_needed):
+        """Finds or creates interpretation and feature objects."""
         assert feature_type in ['fault', 'horizon', 'geobody boundary']
         if feature_name is None:
-            feature_name = 'feature from face masks'  # not sure this default is wise
+            feature_name = 'feature from faces'  # not sure this default is wise
         if len(self.grid_list) > 1:
-            log.warning('setting grid connection set pairs from face masks for first grid in list only')
+            log.warning('setting grid connection set pairs from faces for first grid in list only')
         grid = self.grid_list[0]
         if feature_type == 'fault':
             feature_flavour = 'TectonicBoundaryFeature'
@@ -512,6 +615,23 @@ class GridConnectionSet(BaseResqpy):
                 log.error('no interpretation found for feature: ' + feature_name)
                 return
         self.feature_list = [('obj_' + interpretation_flavour, fi_uuid, str(feature_name))]
+
+    def set_pairs_from_face_masks(
+            self,
+            k_faces,
+            j_faces,
+            i_faces,
+            feature_name,
+            create_organizing_objects_where_needed,
+            feature_type = 'fault',  # other feature_type values: 'horizon', 'geobody boundary'
+            k_sides = None,
+            j_sides = None,
+            i_sides = None):
+        """Sets cell_index_pairs and face_index_pairs based on triple face masks, using simple no throw pairing."""
+
+        self._sort_out_organizing_objects(feature_type, feature_name, create_organizing_objects_where_needed)
+
+        grid = self.grid_list[0]
         cell_pair_list = []
         face_pair_list = []
         nj_ni = grid.nj * grid.ni
@@ -548,10 +668,10 @@ class GridConnectionSet(BaseResqpy):
                 else:
                     cell_pair_list.append((cell, cell + 1))
                     face_pair_list.append((self.face_index_map[2, 1], self.face_index_map[2, 0]))
-        self.cell_index_pairs = np.array(cell_pair_list, dtype = int)
-        self.face_index_pairs = np.array(face_pair_list, dtype = int)
+        self.cell_index_pairs = np.array(cell_pair_list, dtype = self.cell_index_dtype)
+        self.face_index_pairs = np.array(face_pair_list, dtype = np.int8)
         self.count = len(self.cell_index_pairs)
-        self.feature_indices = np.zeros(self.count, dtype = int)
+        self.feature_indices = np.zeros(self.count, dtype = np.int8)
         assert len(self.face_index_pairs) == self.count
 
     def set_pairs_from_faces_df(self,
@@ -609,9 +729,9 @@ class GridConnectionSet(BaseResqpy):
             if success:
                 feature_index += 1
 
-        self.feature_indices = np.array(fi_list, dtype = int)
-        self.cell_index_pairs = np.array(cell_pair_list, dtype = int)
-        self.face_index_pairs = np.array(face_pair_list, dtype = int)
+        self.feature_indices = np.array(fi_list, dtype = np.int32)
+        self.cell_index_pairs = np.array(cell_pair_list, dtype = self.cell_index_dtype)
+        self.face_index_pairs = np.array(face_pair_list, dtype = np.int8)
         self.count = len(self.cell_index_pairs)
         assert len(self.face_index_pairs) == self.count
         if create_mult_prop and self.count > 0:
@@ -696,7 +816,7 @@ class GridConnectionSet(BaseResqpy):
         singleton.cell_index_pairs, singleton.face_index_pairs =  \
            self.raw_list_of_cell_face_pairs_for_feature_index(feature_index)
         singleton.count = singleton.cell_index_pairs.shape[0]
-        singleton.feature_indices = np.zeros((singleton.count,), dtype = int)
+        singleton.feature_indices = np.zeros((singleton.count,), dtype = np.int32)
         singleton.feature_list = [self.feature_list[feature_index]]
         return singleton
 
@@ -823,7 +943,7 @@ class GridConnectionSet(BaseResqpy):
                                         cache_array = True,
                                         object = self,
                                         array_attribute = 'cell_index_pairs',
-                                        dtype = 'int')
+                                        dtype = 'int64' if self.cell_index_dtype is np.int64 else 'int32')
 
         if self.face_index_pairs is None:
             log.debug('caching face index pairs from hdf5')
@@ -834,7 +954,7 @@ class GridConnectionSet(BaseResqpy):
                                         cache_array = True,
                                         object = self,
                                         array_attribute = 'face_index_pairs',
-                                        dtype = 'int32')
+                                        dtype = 'int8')
 
         if len(self.grid_list) > 1 and self.grid_index_pairs is None:
             grid_index_node = rqet.find_tag(self.root, 'GridIndexPairs')
@@ -845,7 +965,7 @@ class GridConnectionSet(BaseResqpy):
                                         cache_array = True,
                                         object = self,
                                         array_attribute = 'grid_index_pairs',
-                                        dtype = 'int')
+                                        dtype = 'int32' if len(self.grid_list) > 127 else 'int8')
 
         if self.feature_list is None:
             return
@@ -854,18 +974,18 @@ class GridConnectionSet(BaseResqpy):
         if self.feature_indices is None:
             log.debug('caching feature indices')
             elements_node = rqet.find_nested_tags(interp_root, ['InterpretationIndices', 'Elements'])
-            #         elements_node = rqet.find_nested_tags(interp_root, ['FaultIndices', 'Elements'])
+            # elements_node = rqet.find_nested_tags(interp_root, ['FaultIndices', 'Elements'])
             h5_key_pair = self.model.h5_uuid_and_path_for_node(elements_node, tag = 'Values')
             assert h5_key_pair is not None
             self.model.h5_array_element(h5_key_pair,
                                         cache_array = True,
                                         object = self,
                                         array_attribute = 'feature_indices',
-                                        dtype = 'uint32')
+                                        dtype = 'int32')
             assert self.feature_indices.shape == (self.count,)
 
             cl_node = rqet.find_nested_tags(interp_root, ['InterpretationIndices', 'CumulativeLength'])
-            #         cl_node = rqet.find_nested_tags(interp_root, ['FaultIndices', 'CumulativeLength'])
+            # cl_node = rqet.find_nested_tags(interp_root, ['FaultIndices', 'CumulativeLength'])
             h5_key_pair = self.model.h5_uuid_and_path_for_node(cl_node, tag = 'Values')
             assert h5_key_pair is not None
             self.model.h5_array_element(h5_key_pair,
@@ -873,8 +993,8 @@ class GridConnectionSet(BaseResqpy):
                                         object = self,
                                         array_attribute = 'fi_cl',
                                         dtype = 'uint32')
-            assert self.fi_cl.shape == (
-                self.count,), 'connection set face pair(s) not assigned to exactly one feature'  # rough check
+            assert self.fi_cl.shape == (self.count,),  \
+                'connection set face pair(s) not assigned to exactly one feature'  # rough check
 
         # delattr(self, 'fi_cl')  # assumed to be one-to-one mapping, so cumulative length is discarded
 
@@ -1196,7 +1316,7 @@ class GridConnectionSet(BaseResqpy):
             # uuid/InterpretationIndices/elements  (N,)  uint32
             h5_reg.register_dataset(self.uuid, 'InterpretationIndices/elements', self.feature_indices)
             # uuid/InterpretationIndices/cumulativeLength  (N,)  uint32
-            one_to_one = np.arange(1, self.count + 1, dtype = int)
+            one_to_one = np.arange(1, self.count + 1, dtype = np.uint32)
             h5_reg.register_dataset(self.uuid, 'InterpretationIndices/cumulativeLength', one_to_one)
 
         h5_reg.write(file_name, mode = mode)
@@ -1371,11 +1491,16 @@ class GridConnectionSet(BaseResqpy):
                         include_both_sides = False,
                         use_minus = False,
                         trans_mult_uuid = None):
-        """Creates a Nexus include file holding MULT keywords and data. trans_mult_uuid (optional) is the uuid of a property on the gcs containing transmissibility multiplier values. If not provided values of 1.0 will be used."""
+        """Creates a Nexus include file holding MULT keywords and data. 
+
+        note:
+            trans_mult_uuid (optional) is the uuid of a property on the gcs containing transmissibility multiplier values;
+            If not provided values of 1.0 will be used
+        """
         if trans_mult_uuid is not None:
             self.extract_property_collection()
-            assert self.property_collection.part_in_collection(self.model.part_for_uuid(
-                trans_mult_uuid)), f'trans_mult_uuid provided is not part of collection {trans_mult_uuid}'
+            assert self.property_collection.part_in_collection(self.model.part_for_uuid(trans_mult_uuid)),  \
+                f'trans_mult_uuid provided is not part of collection {trans_mult_uuid}'
             tmult_array = self.property_collection.cached_part_array_ref(self.model.part_for_uuid(trans_mult_uuid))
             assert tmult_array is not None
         else:
@@ -1421,26 +1546,39 @@ class GridConnectionSet(BaseResqpy):
                 feature_name = self.feature_list[feature_index][2].split()[0].upper()
                 cell_index_pairs, face_index_pairs = self.list_of_cell_face_pairs_for_feature_index(feature_index)
                 if tmult_array is not None:
-                    feature_mask = np.where(self.feature_indices == feature_index, 1, 0)
+                    feature_mask = (self.feature_indices == feature_index)
                     feat_mult_array = np.extract(feature_mask, tmult_array)
                 else:
                     feat_mult_array = np.ones(shape = (cell_index_pairs.shape[0],), dtype = float)
                 for side in sides:
-                    both = np.empty((cell_index_pairs.shape[0], 6), dtype = int)  # axis, polarity, k, j, i, tmult
+                    both = np.empty((cell_index_pairs.shape[0], 5), dtype = np.int32)  # axis, polarity, k, j, i
                     both[:, :2] = face_index_pairs[:, side, :]  # axis, polarity
-                    both[:, 2:-1] = cell_index_pairs[:, side, :]  # k, j, i
-                    both[:, -1] = feat_mult_array.flatten()
-                    df = pd.DataFrame(both, columns = ['axis', 'polarity', 'k', 'j', 'i', 'tmult'])
-                    df = df.sort_values(by = ['axis', 'polarity', 'j', 'i', 'k', 'tmult'])
-                    both_sorted = np.empty(both.shape, dtype = int)
-                    both_sorted[:] = df
-                    cell_indices = both_sorted[:, 2:-1]
-                    face_indices = np.empty((both_sorted.shape[0], 2), dtype = int)
-                    face_indices[:, :] = both_sorted[:, :2]
-                    tmult_values = both_sorted[:, -1]
-                    del both_sorted
+                    both[:, 2:] = cell_index_pairs[:, side, :]  # k, j, i
+                    # both[:, -1] = feat_mult_array.flatten()
+                    # df = pd.DataFrame(both, columns = ['axis', 'polarity', 'k', 'j', 'i', 'tmult'])
+                    # df = df.sort_values(by = ['axis', 'polarity', 'j', 'i', 'k', 'tmult'])
+                    # both_sorted = np.empty(both.shape, dtype = np.int32)
+                    # both_sorted[:] = df
+                    si = np.argsort(both[:, 2])  # k
+                    msi = si
+                    both = both[si]
+                    si = np.argsort(both[:, 4], kind = 'stable')  # i
+                    msi = msi[si]
+                    both = both[si]
+                    si = np.argsort(both[:, 3], kind = 'stable')  # j
+                    msi = msi[si]
+                    both = both[si]
+                    si = np.argsort(both[:, 1], kind = 'stable')  # polarity
+                    msi = msi[si]
+                    both = both[si]
+                    si = np.argsort(both[:, 0], kind = 'stable')  # axis
+                    msi = msi[si]
+                    both = both[si]
+                    cell_indices = both[:, 2:]
+                    face_indices = np.empty((both.shape[0], 2), dtype = np.int8)
+                    face_indices[:, :] = both[:, :2]
+                    tmult_values = feat_mult_array[msi]
                     del both
-                    del df
                     k = None
                     i = j = k2 = axis = polarity = None  # only needed to placate flake8 which whinges incorrectly otherwise
                     for row in range(cell_indices.shape[0]):
@@ -1692,7 +1830,7 @@ class GridConnectionSet(BaseResqpy):
                     combined_values = property_value_by_column_edge.copy()
                 else:
                     combined_values = None
-                combined_index = np.full((fault_by_column_edge_mask.shape), -1, dtype = int)
+                combined_index = np.full((fault_by_column_edge_mask.shape), -1, dtype = np.int32)
                 combined_index = np.where(fault_by_column_edge_mask, feature, combined_index)
                 sum_unmasked = np.sum(fault_by_column_edge_mask)
             else:
@@ -1802,7 +1940,7 @@ class GridConnectionSet(BaseResqpy):
         def sorted_paired_cell_face_index_position(cell_face_index, a_or_b):
             # pair one side (a_or_b) of cell_face_index with its position, then sort
             count = len(cell_face_index)
-            sp = np.empty((count, 2), dtype = int)
+            sp = np.empty((count, 2), dtype = np.int32)
             sp[:, 0] = cell_face_index[:, a_or_b]
             sp[:, 1] = np.arange(count)
             t = [tuple(r) for r in sp]  # could use numpy fields based sort instead of tuple list?
@@ -1985,19 +2123,19 @@ class GridConnectionSet(BaseResqpy):
             for k0 in range(entry['k1'], entry['k2'] + 1):
                 for j0 in range(entry['j1'], entry['j2'] + 1):
                     for i0 in range(entry['i1'], entry['i2'] + 1):
-                        neighbour = np.array([k0, j0, i0], dtype = int)
+                        neighbour = np.array([k0, j0, i0], dtype = np.int32)
                         if fp:
                             neighbour[axis] += 1
                         else:
                             neighbour[axis] -= 1
                         fi_list.append(feature_index)
-                        cell_pair_list.append((grid.natural_cell_index(
-                            (k0, j0, i0)), grid.natural_cell_index(neighbour)))
+                        cell_pair_list.append((grid.natural_cell_index((k0, j0, i0)),  \
+                                               grid.natural_cell_index(neighbour)))
                         face_pair_list.append((self.face_index_map[axis, fp], self.face_index_map[axis, 1 - fp]))
                         if create_mult_prop:
                             mult_list.append(multiplier)
         if fi_root is not None and fault_const_mult and fault_mult_value is not None:
-            #patch extra_metadata into xml for new fault interpretation object
+            # patch extra_metadata into xml for new fault interpretation object
             rqet.create_metadata_xml(fi_root, {"Transmissibility multiplier": str(fault_mult_value)})
         return True, const_mult
 
@@ -2162,3 +2300,27 @@ def _copy_organisation_objects(target_model, source_model, gcs):
     for _, uuid, _ in gcs.feature_list:
         target_model.copy_uuid_from_other_model(source_model,
                                                 uuid)  # will copy related features as well as interpretations
+
+
+def _sort_and_remove_duplicates(a, props = None):
+    """Return copy of 1D array a, sorted and with duplicates removed; secondary arrays can be kept in alignment."""
+    if a is None or a.size <= 1:
+        return a
+    assert a.ndim == 1
+    si = None
+    no_props = (props is None or len(props) == 0)
+    if no_props:
+        a = np.sort(a)
+    else:
+        si = np.argsort(a)
+        a = a[si]
+    m = np.empty(a.size, dtype = bool)
+    m[0] = True
+    m[1:] = (a[1:] != a[:-1])
+    if np.all(m):
+        return a
+    if not no_props:
+        for i in range(len(props)):
+            p = props[i][si]
+            props[i] = p[m]
+    return a[m]

{resqpy-4.16.11 → resqpy-4.17.1}/resqpy/grid/_grid.py

@@ -265,6 +265,10 @@ class Grid(BaseResqpy):
             return np.count_nonzero(self.array_cell_geometry_is_defined)
         return None
 
+    def is_big(self):
+        """Returns True if number of cells exceeds 2^31 - 1, otherwise False."""
+        return (np.prod(self.extent_kji) >= 2_147_483_648)
+
     def natural_cell_index(self, cell_kji0):
         """Returns a single integer for the cell, being the index into a flattened array."""
 

{resqpy-4.16.11 → resqpy-4.17.1}/resqpy/grid_surface/__init__.py

@@ -20,11 +20,13 @@ __all__ = [
     "find_faces_to_represent_surface_staffa",
     "find_faces_to_represent_surface_regular",
     "find_faces_to_represent_surface_regular_optimised",
+    "find_faces_to_represent_surface_regular_dense_optimised",
     "find_faces_to_represent_surface",
     "bisector_from_faces",
     "column_bisector_from_faces",
     "shadow_from_faces",
     "get_boundary",
+    "get_boundary_dict",
     "_where_true",
     "_first_true",
     "intersect_numba",
@@ -56,11 +58,13 @@ from ._find_faces import (
     find_faces_to_represent_surface_staffa,
     find_faces_to_represent_surface_regular,
     find_faces_to_represent_surface_regular_optimised,
+    find_faces_to_represent_surface_regular_dense_optimised,
     find_faces_to_represent_surface,
     bisector_from_faces,
     column_bisector_from_faces,
     shadow_from_faces,
     get_boundary,
+    get_boundary_dict,
     _where_true,
     _first_true,
     intersect_numba,

{resqpy-4.16.11 → resqpy-4.17.1}/resqpy/grid_surface/_blocked_well_populate.py

@@ -118,7 +118,7 @@ def populate_blocked_well_from_trajectory(blocked_well,
         if xyz is None:
             log.error('failed to lazily find intersection of trajectory with top surface of grid')
             return None
-        cell_kji0 = np.array((0, col_ji0[0], col_ji0[1]), dtype = int)
+        cell_kji0 = np.array((0, col_ji0[0], col_ji0[1]), dtype = np.int32)
         axis = 0
         polarity = 0
 
@@ -133,7 +133,7 @@ def populate_blocked_well_from_trajectory(blocked_well,
         else:
             log.debug(f"skin intersection x,y,z: {xyz}; knot: {entry_knot}; cell kji0: {cell_kji0}; face: "
                       f"{'KJI'[axis]}{'-+'[polarity]}")
-            cell_kji0 = np.array(cell_kji0, dtype = int)
+            cell_kji0 = np.array(cell_kji0, dtype = np.int32)
 
     previous_kji0 = cell_kji0.copy()
     previous_kji0[axis] += polarity * 2 - 1  # note: previous may legitimately be 'beyond' edge of grid
@@ -244,9 +244,9 @@ def populate_blocked_well_from_trajectory(blocked_well,
 
     blocked_well.node_mds = np.array(node_mds_list, dtype = float)
     blocked_well.node_count = node_count
-    blocked_well.grid_indices = np.array(grid_indices_list, dtype = int)
-    blocked_well.cell_indices = np.array(cell_indices_list, dtype = int)
-    blocked_well.face_pair_indices = np.array(face_pairs_list, dtype = int)
+    blocked_well.grid_indices = np.array(grid_indices_list, dtype = np.int32)
+    blocked_well.cell_indices = np.array(cell_indices_list, dtype = np.int64)
+    blocked_well.face_pair_indices = np.array(face_pairs_list, dtype = np.int8)
     blocked_well.cell_count = cell_count
     blocked_well.grid_list = [grid]