resqpy 4.18.11__py3-none-any.whl → 5.1.0__py3-none-any.whl

resqpy/__init__.py

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

resqpy/grid/__init__.py

@@ -1,14 +1,13 @@
 """The Grid Module."""
 
 __all__ = [
-    'Grid', 'RegularGrid', 'extract_grid_parent', 'establish_zone_property_kind', 'find_cell_for_x_sect_xz',
-    'grid_flavour', 'is_regular_grid', 'any_grid'
+    'Grid', 'RegularGrid', 'extract_grid_parent', 'find_cell_for_x_sect_xz', 'grid_flavour', 'is_regular_grid',
+    'any_grid'
 ]
 
 from ._grid import Grid
 from ._regular_grid import RegularGrid
 from ._grid_types import grid_flavour, is_regular_grid, any_grid
-from ._moved_functions import establish_zone_property_kind
 from ._extract_functions import extract_grid_parent, extent_kji_from_root
 from ._points_functions import find_cell_for_x_sect_xz
 

resqpy/grid/_grid.py

@@ -680,13 +680,7 @@ class Grid(BaseResqpy):
         return _create_grid_xml(self, ijk, ext_uuid, add_as_part, add_relationships, write_active, write_geometry,
                                 use_lattice, use_parametric_lines)
 
-    def x_section_points(self, axis, ref_slice0 = 0, plus_face = False, masked = False):
-        """Deprecated: please use `unsplit_x_section_points` instead."""
-        warnings.warn('Deprecated: please use `unsplit_x_section_points` instead.', DeprecationWarning)
-
-        return unsplit_x_section_points(self, axis, ref_slice0 = ref_slice0, plus_face = plus_face, masked = masked)
-
-    # The implementations of the below functions have been moved to separate modules.
+    # the implementations of the functions below have been moved to separate modules
 
     def cell_geometry_is_defined(self, cell_kji0 = None, cell_geometry_is_defined_root = None, cache_array = True):
         """Returns True if the geometry of the specified cell is defined.

resqpy/grid_surface/_find_faces.py

@@ -558,6 +558,8 @@ def find_faces_to_represent_surface_regular_dense_optimised(grid,
         to a grid connection set; use the non-dense version of the function for a reduced memory footprint;
         this function is DEPRECATED pending proving of newer find_faces_to_represent_surface_regular_optimised()
     """
+    warnings.warn('DEPRECATED: grid_surface.find_faces_to_represent_surface_regular_dense_optimised() function; ' +
+                  'use find_faces_to_represent_surface_regular_optimised() instead')
 
     assert isinstance(grid, grr.RegularGrid)
     assert grid.is_aligned
@@ -878,7 +880,8 @@ def find_faces_to_represent_surface_regular_optimised(grid,
                                                       return_properties = None,
                                                       raw_bisector = False,
                                                       n_batches = 20,
-                                                      packed_bisectors = False):
+                                                      packed_bisectors = False,
+                                                      patch_indices = None):
     """Returns a grid connection set containing those cell faces which are deemed to represent the surface.
 
     argumants:
@@ -914,11 +917,14 @@ def find_faces_to_represent_surface_regular_optimised(grid,
            threading allows some parallelism between the batches)
         packed_bisectors (bool, default False): if True and return properties include 'grid bisector' then
            non curtain bisectors are returned in packed form
+        patch_indices (numpy int array, optional): if present, an array over grid cells indicating which 
+           patch of surface is applicable in terms of a bisector, for each cell
 
     returns:
         gcs  or  (gcs, gcs_props)
         where gcs is a new GridConnectionSet with a single feature, not yet written to hdf5 nor xml created;
-        gcs_props is a dictionary mapping from requested return_properties string to numpy array
+        gcs_props is a dictionary mapping from requested return_properties string to numpy array (or tuple
+            of numpy array and curtain bool in the case of grid bisector)
 
     notes:
         this function is designed for aligned regular grids only;
@@ -927,7 +933,9 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         no trimming of the surface is carried out here: for computational efficiency, it is recommended
         to trim first;
         organisational objects for the feature are created if needed;
-        if the offset return property is requested, the implicit units will be the z units of the grid's crs
+        if the offset return property is requested, the implicit units will be the z units of the grid's crs;
+        if patch_indices is present and grid bisectors are being returned, a composite bisector array is returned
+        with elements set from individual bisectors for each patch of surface
     """
 
     assert isinstance(grid, grr.RegularGrid)
@@ -957,7 +965,10 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         return_flange_bool = "flange bool" in return_properties
         if return_flange_bool:
             return_triangles = True
-
+    patchwork = return_bisector and patch_indices is not None
+    if patchwork:
+        return_triangles = True  # triangle numbers are used to infer patch index
+        assert patch_indices.shape == tuple(grid.extent_kji)
     if title is None:
         title = name
 
@@ -1163,7 +1174,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
                                                    k_faces_kji0 = k_faces_kji0,
                                                    j_faces_kji0 = j_faces_kji0,
                                                    i_faces_kji0 = i_faces_kji0,
-                                                   remove_duplicates = True,
+                                                   remove_duplicates = not patchwork,
                                                    k_properties = k_props,
                                                    j_properties = j_props,
                                                    i_properties = i_props,
@@ -1174,6 +1185,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     # log.debug('finished coversion to gcs')
 
     # NB. following assumes faces have been added to gcs in a particular order!
+    all_tris = None
     if return_triangles:
         # log.debug('preparing triangles array')
         k_triangles = np.empty((0,), dtype = np.int32) if k_props is None else k_props.pop(0)
@@ -1184,6 +1196,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         assert all_tris.shape == (gcs.count,)
 
     # NB. following assumes faces have been added to gcs in a particular order!
+    all_depths = None
     if return_depths:
         # log.debug('preparing depths array')
         k_depths = np.empty((0,), dtype = np.float64) if k_props is None else k_props.pop(0)
@@ -1194,6 +1207,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         assert all_depths.shape == (gcs.count,)
 
     # NB. following assumes faces have been added to gcs in a particular order!
+    all_offsets = None
     if return_offsets:
         # log.debug('preparing offsets array')
         k_offsets = np.empty((0,), dtype = np.float64) if k_props is None else k_props[0]
@@ -1203,6 +1217,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         # log.debug(f'gcs count: {gcs.count}; all offsets shape: {all_offsets.shape}')
         assert all_offsets.shape == (gcs.count,)
 
+    all_flange = None
     if return_flange_bool:
         # log.debug('preparing flange array')
         flange_bool_uuid = surface.model.uuid(title = "flange bool",
@@ -1215,8 +1230,9 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         assert all_flange.shape == (gcs.count,)
 
     # note: following is a grid cells property, not a gcs property
+    bisector = None
     if return_bisector:
-        if is_curtain:
+        if is_curtain and not patchwork:
             log.debug("preparing columns bisector")
             if j_faces_kji0 is None:
                 j_faces_ji0 = np.empty((0, 2), dtype = np.int32)
@@ -1228,8 +1244,51 @@ def find_faces_to_represent_surface_regular_optimised(grid,
                 i_faces_ji0 = i_faces_kji0[:, 1:]
             bisector = column_bisector_from_face_indices((grid.nj, grid.ni), j_faces_ji0, i_faces_ji0)
             # log.debug('finished preparing columns bisector')
+        elif patchwork:
+            n_patches = surface.number_of_patches()
+            nkf = len(k_faces_kji0)
+            njf = len(j_faces_kji0)
+            nif = len(i_faces_kji0)
+            # fetch patch indices for triangle hits
+            assert all_tris is not None and len(all_tris) == nkf + njf + nif
+            patch_indices_k = surface.patch_indices_for_triangle_indices(all_tris[:nkf])
+            patch_indices_j = surface.patch_indices_for_triangle_indices(all_tris[nkf:nkf + njf])
+            patch_indices_i = surface.patch_indices_for_triangle_indices(all_tris[nkf + njf:])
+            # add extra dimension to bisector array (at axis 0) for patches
+            pb_shape = tuple([n_patches] + list(grid.extent_kji))
+            if packed_bisectors:
+                bisector = np.ones(_shape_packed(grid.extent_kji), dtype = np.uint8)
+            else:
+                bisector = np.ones(tuple(grid.extent_kji), dtype = np.bool_)
+            # populate 4D bisector with an axis zero slice for each patch
+            for patch in range(n_patches):
+                mask = (patch_indices == patch)
+                if np.count_nonzero(mask) == 0:
+                    log.warning(f'patch {patch} of surface {surface.title} is not applicable to any cells in grid')
+                    continue
+                if packed_bisectors:
+                    mask = np.packbits(mask, axis = -1)
+                    patch_bisector, is_curtain =  \
+                        packed_bisector_from_face_indices(tuple(grid.extent_kji),
+                                                          k_faces_kji0[(patch_indices_k == patch).astype(bool)],
+                                                          j_faces_kji0[(patch_indices_j == patch).astype(bool)],
+                                                          i_faces_kji0[(patch_indices_i == patch).astype(bool)],
+                                                          raw_bisector)
+                    bisector = np.bitwise_or(np.bitwise_and(mask, patch_bisector), bisector)
+                else:
+                    patch_bisector, is_curtain =  \
+                        bisector_from_face_indices(tuple(grid.extent_kji),
+                                                   k_faces_kji0[(patch_indices_k == patch).astype(bool)],
+                                                   j_faces_kji0[(patch_indices_j == patch).astype(bool)],
+                                                   i_faces_kji0[(patch_indices_i == patch).astype(bool)],
+                                                   raw_bisector)
+                    bisector[mask] = patch_bisector[mask]
+                if is_curtain:
+                    # TODO: downgrade following to debug once downstream functionality tested
+                    log.warning(f'ignoring curtain nature of bisector for patch {patch} of surface: {surface.title}')
+                    is_curtain = False
         else:
-            log.debug("preparing cells bisector")
+            log.debug("preparing singlular cells bisector")
             if ((k_faces_kji0 is None or len(k_faces_kji0) == 0) and
                 (j_faces_kji0 is None or len(j_faces_kji0) == 0) and (i_faces_kji0 is None or len(i_faces_kji0) == 0)):
                 bisector = np.ones((grid.nj, grid.ni), dtype = bool)
@@ -1247,6 +1306,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
                     bisector = bisector[0]  # reduce to a columns property
 
     # note: following is a grid cells property, not a gcs property
+    shadow = None
     if return_shadow:
         log.debug("preparing cells shadow")
         shadow = shadow_from_face_indices(tuple(grid.extent_kji), k_faces_kji0)
@@ -1259,7 +1319,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     # if returning properties, construct dictionary
     if return_properties:
         props_dict = {}
-        if return_triangles:
+        if 'triangle' in return_properties:
             props_dict["triangle"] = all_tris
         if return_depths:
             props_dict["depth"] = all_depths
@@ -1361,8 +1421,9 @@ def bisector_from_faces(  # type: ignore
         - the face sets must form a single 'sealed' cut of the grid (eg. not waving in and out of the grid)
         - any 'boxed in' parts of the grid (completely enclosed by bisecting faces) will be consistently
           assigned to either the True or False part
-        - this function is DEPRECATED, pending proving of newer indices based approach
+        - this function is DEPRECATED, use newer indices based approach instead: bisector_from_face_indices()
     """
+    warnings.warn('DEPRECATED: grid_surface.bisector_from_faces() function; use bisector_from_face_indices() instead')
     assert len(grid_extent_kji) == 3
 
     # find the surface boundary (includes a buffer slice where surface does not reach edge of grid)
@@ -1405,10 +1466,13 @@ def bisector_from_faces(  # type: ignore
     # check all array elements are not the same
     true_count = np.count_nonzero(array)
     cell_count = array.size
-    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 = _shallow_or_curtain(array, true_count, raw_bisector)
+    if 0 < true_count < cell_count:
+        # negate the array if it minimises the mean k and determine if the surface is a curtain
+        is_curtain = _shallow_or_curtain(array, true_count, raw_bisector)
+    else:
+        assert raw_bisector, 'face set for surface is leaky or empty (surface does not intersect grid)'
+        log.error('face set for surface is leaky or empty (surface does not intersect grid)')
+        is_curtain = False
 
     return array, is_curtain
 
@@ -1479,10 +1543,13 @@ def bisector_from_face_indices(  # type: ignore
     # check all array elements are not the same
     true_count = np.count_nonzero(array)
     cell_count = array.size
-    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 = _shallow_or_curtain(array, true_count, raw_bisector)
+    if 0 < true_count < cell_count:
+        # negate the array if it minimises the mean k and determine if the surface is a curtain
+        is_curtain = _shallow_or_curtain(array, true_count, raw_bisector)
+    else:
+        assert raw_bisector, 'face set for surface is leaky or empty (surface does not intersect grid)'
+        log.error('face set for surface is leaky or empty (surface does not intersect grid)')
+        is_curtain = False
 
     return array, is_curtain
 
@@ -1569,12 +1636,14 @@ def packed_bisector_from_face_indices(  # type: ignore
     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_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)
+    if 0 < true_count < cell_count:
+        # negate the array if it minimises the mean k and determine if the surface is a curtain
+        # TODO: switch to _packed_shallow_or_curtain_temp_bitwise_count() when numba supports np.bitwise_count()
+        is_curtain = _packed_shallow_or_curtain_temp_bitwise_count(array, true_count, raw_bisector)
+    else:
+        assert raw_bisector, 'face set for surface is leaky or empty (surface does not intersect grid)'
+        log.error('face set for surface is leaky or empty (surface does not intersect grid)')
+        is_curtain = False
 
     return array, is_curtain
 
@@ -2224,12 +2293,12 @@ def get_boundary_from_indices(  # type: ignore
         k_faces_kji0: Union[np.ndarray, None], j_faces_kji0: Union[np.ndarray, None],
         i_faces_kji0: Union[np.ndarray, None], grid_extent_kji: Tuple[int, int, int]) -> np.ndarray:
     """Return python protocol box containing indices"""
-    k_min_kji0 = None if k_faces_kji0 is None else np.min(k_faces_kji0, axis = 0)
-    k_max_kji0 = None if k_faces_kji0 is None else np.max(k_faces_kji0, axis = 0)
-    j_min_kji0 = None if j_faces_kji0 is None else np.min(j_faces_kji0, axis = 0)
-    j_max_kji0 = None if j_faces_kji0 is None else np.max(j_faces_kji0, axis = 0)
-    i_min_kji0 = None if i_faces_kji0 is None else np.min(i_faces_kji0, axis = 0)
-    i_max_kji0 = None if i_faces_kji0 is None else np.max(i_faces_kji0, axis = 0)
+    k_min_kji0 = None if (k_faces_kji0 is None or k_faces_kji0.size == 0) else np.min(k_faces_kji0, axis = 0)
+    k_max_kji0 = None if (k_faces_kji0 is None or k_faces_kji0.size == 0) else np.max(k_faces_kji0, axis = 0)
+    j_min_kji0 = None if (j_faces_kji0 is None or j_faces_kji0.size == 0) else np.min(j_faces_kji0, axis = 0)
+    j_max_kji0 = None if (j_faces_kji0 is None or j_faces_kji0.size == 0) else np.max(j_faces_kji0, axis = 0)
+    i_min_kji0 = None if (i_faces_kji0 is None or i_faces_kji0.size == 0) else np.min(i_faces_kji0, axis = 0)
+    i_max_kji0 = None if (i_faces_kji0 is None or i_faces_kji0.size == 0) else np.max(i_faces_kji0, axis = 0)
     box = np.empty((2, 3), dtype = np.int32)
     box[0, :] = grid_extent_kji
     box[1, :] = -1

resqpy/lines/_polyline.py

@@ -25,25 +25,22 @@ class Polyline(rql_c._BasePolyline):
 
     resqml_type = 'PolylineRepresentation'
 
-    def __init__(
-            self,
-            parent_model,
-            uuid = None,
-            set_bool = None,  #: DEPRECATED
-            set_coord = None,
-            set_crs = None,
-            is_closed = None,
-            title = None,
-            rep_int_root = None,
-            originator = None,
-            extra_metadata = None):
+    def __init__(self,
+                 parent_model,
+                 uuid = None,
+                 set_coord = None,
+                 set_crs = None,
+                 is_closed = None,
+                 title = None,
+                 rep_int_root = None,
+                 originator = None,
+                 extra_metadata = None):
         """Initialises a new polyline object.
 
         arguments:
             parent_model (model.Model object): the model which the new PolylineRepresentation belongs to
             uuid (uuid.UUID, optional): the uuid of an existing RESQML PolylineRepresentation from which
                 to initialise the resqpy Polyline
-            set_bool (boolean, optional): DEPRECATED: synonym for is_closed argument
             set_coord (numpy float array, optional): an ordered set of xyz values used to define a new polyline;
                 last dimension of array must have extent 3; ignored if uuid is not None
             set_crs (uuid.UUID, optional): the uuid of a crs to be used when initialising from coordinates;
@@ -65,10 +62,6 @@ class Polyline(rql_c._BasePolyline):
         """
 
         self.model = parent_model
-        if set_bool is not None:
-            warnings.warn('DEPRECATED: use is_closed argument instead of set_bool, in Polyline initialisation')
-            if is_closed is None:
-                is_closed = set_bool
         self.isclosed = is_closed
         self.nodepatch = None
         self.crs_uuid = set_crs
@@ -466,22 +459,20 @@ class Polyline(rql_c._BasePolyline):
         if cache and self.centre is not None:
             return self.centre
         assert mode in ['weighted', 'sampled']
-        if mode == 'sampled':  # this mode is deprecated as it simply approximates the weighted mode
-            sample_points = self.equidistant_points(n, in_xy = in_xy)
-            centre = np.mean(sample_points, axis = 0)
-        else:  # 'weighted'
-            sum = np.zeros(3)
-            seg_count = len(self.coordinates) - 1
-            if self.isclosed:
-                seg_count += 1
-            d = 2 if in_xy else 3
-            p1 = np.zeros(3)
-            p2 = np.zeros(3)
-            for seg_index in range(seg_count):
-                successor = (seg_index + 1) % len(self.coordinates)
-                p1[:d], p2[:d] = self.coordinates[seg_index, :d], self.coordinates[successor, :d]
-                sum += (p1 + p2) * vu.naive_length(p2 - p1)
-            centre = sum / (2.0 * self.full_length(in_xy = in_xy))
+        if mode != 'weighted':  # ignore any other mode, ie. sampled
+            warnings.warn('DEPRECATED: weighted mode is only mode now supported for Polyline.balanced_centre()')
+        sum = np.zeros(3)
+        seg_count = len(self.coordinates) - 1
+        if self.isclosed:
+            seg_count += 1
+        d = 2 if in_xy else 3
+        p1 = np.zeros(3)
+        p2 = np.zeros(3)
+        for seg_index in range(seg_count):
+            successor = (seg_index + 1) % len(self.coordinates)
+            p1[:d], p2[:d] = self.coordinates[seg_index, :d], self.coordinates[successor, :d]
+            sum += (p1 + p2) * vu.naive_length(p2 - p1)
+        centre = sum / (2.0 * self.full_length(in_xy = in_xy))
         if cache:
             self.centre = centre
         return centre

resqpy/model/_model.py

@@ -1340,7 +1340,8 @@ class Model():
            an hdf5 file name is cached once determined for a given ext uuid; to clear the cache,
            call the h5_clear_filename_cache() method
         """
-
+        if isinstance(override, bool):
+            warnings.warn('DEPRECATED: boolean override argument to Model.h5_file_name(); use string instead')
         return m_h._h5_file_name(self, uuid = uuid, override = override, file_must_exist = file_must_exist)
 
     def h5_access(self, uuid = None, mode = 'r', override = 'default', file_path = None):
@@ -1366,7 +1367,8 @@ class Model():
            an exception will be raised if the hdf5 file cannot be opened; note that sometimes another
            piece of code accessing the file might cause a 'resource unavailable' exception
         """
-
+        if isinstance(override, bool):
+            warnings.warn('DEPRECATED: boolean override argument to Model.h5_access(); use string instead')
         return m_h._h5_access(self, uuid = uuid, mode = mode, override = override, file_path = file_path)
 
     def h5_release(self):
@@ -2098,6 +2100,11 @@ class Model():
         if other_model is self:
             return part
         assert part is not None
+        # check whether already existing in this model
+        if part in self.parts_forest.keys():
+            return part
+        if m_c._type_of_part(other_model, part) == 'obj_EpcExternalPartReference':
+            return None
         if realization is not None:
             assert isinstance(realization, int) and realization >= 0
         if force:
@@ -2108,13 +2115,6 @@ class Model():
             self_h5_file_name = self.h5_file_name(file_must_exist = False)
         hdf5_copy_needed = not os.path.samefile(self_h5_file_name, other_h5_file_name)
 
-        # check whether already existing in this model
-        if part in self.parts_forest.keys():
-            return part
-
-        if m_c._type_of_part(other_model, part) == 'obj_EpcExternalPartReference':
-            return None
-
         return m_f._copy_part_from_other_model(self,
                                                other_model,
                                                part,