resqpy 5.0.0__tar.gz → 5.1.1__tar.gz

{resqpy-5.0.0 → resqpy-5.1.1}/PKG-INFO

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

{resqpy-5.0.0 → resqpy-5.1.1}/pyproject.toml

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

{resqpy-5.0.0 → resqpy-5.1.1}/resqpy/__init__.py

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

{resqpy-5.0.0 → resqpy-5.1.1}/resqpy/grid_surface/_find_faces.py

@@ -880,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:
@@ -916,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;
@@ -929,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)
@@ -959,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
 
@@ -1165,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,
@@ -1176,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)
@@ -1186,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)
@@ -1196,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]
@@ -1205,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",
@@ -1217,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)
@@ -1230,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)
@@ -1249,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)
@@ -1261,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
@@ -1363,7 +1421,7 @@ 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
@@ -1408,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
 
@@ -1482,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
 
@@ -1572,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
 
@@ -2227,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-5.0.0 → resqpy-5.1.1}/resqpy/model/_forestry.py

@@ -686,17 +686,23 @@ def _copy_referenced_parts(model, other_model, realization, consolidate, force,
             resident_uuid_int = model.consolidation.map[ref_uuid_int]
             assert resident_uuid_int is not None
             # find referring node for ref_uuid_int and modify its reference to resident_uuid_int
-            if reference_node_dict is None:
+            if reference_node_dict is None:  # now mapping uuid int to list of nodes
                 ref_nodes = rqet.list_obj_references(root_node)
                 reference_node_dict = {}
                 for ref_node in ref_nodes:
                     uuid_node = rqet.find_tag(ref_node, 'UUID')
                     uuid_int = bu.uuid_from_string(uuid_node.text).int
-                    reference_node_dict[uuid_int] = uuid_node
-            uuid_node = reference_node_dict[ref_uuid_int]
-            uuid_node.text = str(bu.uuid_from_int(resident_uuid_int))
-            reference_node_dict.pop(ref_uuid_int)
-            reference_node_dict[resident_uuid_int] = uuid_node
+                    if uuid_int in reference_node_dict:
+                        reference_node_dict[uuid_int].append(uuid_node)
+                    else:
+                        reference_node_dict[uuid_int] = [uuid_node]
+            uuid_node_list = reference_node_dict.pop(ref_uuid_int)
+            for uuid_node in uuid_node_list:
+                uuid_node.text = str(bu.uuid_from_int(resident_uuid_int))
+            if resident_uuid_int in reference_node_dict:
+                reference_node_dict[resident_uuid_int] += uuid_node_list
+            else:
+                reference_node_dict[resident_uuid_int] = uuid_node_list
 
 
 def _copy_relationships_for_present_targets(model, other_model, consolidate, force, resident_uuid, root_node):

{resqpy-5.0.0 → resqpy-5.1.1}/resqpy/model/_model.py

@@ -2100,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:
@@ -2110,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,

{resqpy-5.0.0 → resqpy-5.1.1}/resqpy/multi_processing/wrappers/grid_surface_mp.py

@@ -4,8 +4,10 @@ import logging
 
 log = logging.getLogger(__name__)
 
+import os
 import numpy as np
 import uuid
+import ast
 from typing import Tuple, Union, List, Optional, Callable
 from pathlib import Path
 from uuid import UUID
@@ -18,33 +20,38 @@ import resqpy.surface as rqs
 import resqpy.olio.uuid as bu
 
 
-def find_faces_to_represent_surface_regular_wrapper(index: int,
-                                                    parent_tmp_dir: str,
-                                                    use_index_as_realisation: bool,
-                                                    grid_epc: str,
-                                                    grid_uuid: Union[UUID, str],
-                                                    surface_epc: str,
-                                                    surface_uuid: Union[UUID, str],
-                                                    name: str,
-                                                    title: Optional[str] = None,
-                                                    agitate: bool = False,
-                                                    random_agitation: bool = False,
-                                                    feature_type: str = 'fault',
-                                                    trimmed: bool = False,
-                                                    is_curtain = False,
-                                                    extend_fault_representation: bool = False,
-                                                    flange_inner_ring = False,
-                                                    saucer_parameter = None,
-                                                    retriangulate: bool = False,
-                                                    related_uuid = None,
-                                                    progress_fn: Optional[Callable] = None,
-                                                    extra_metadata = None,
-                                                    return_properties: Optional[List[str]] = None,
-                                                    raw_bisector: bool = False,
-                                                    use_pack: bool = False,
-                                                    flange_radius = None,
-                                                    reorient = True,
-                                                    n_threads = 20) -> Tuple[int, bool, str, List[Union[UUID, str]]]:
+def find_faces_to_represent_surface_regular_wrapper(
+        index: int,
+        parent_tmp_dir: str,
+        use_index_as_realisation: bool,
+        grid_epc: str,
+        grid_uuid: Union[UUID, str],
+        surface_epc: str,
+        surface_uuid: Union[UUID, str],
+        name: str,
+        title: Optional[str] = None,
+        agitate: bool = False,
+        random_agitation: bool = False,
+        feature_type: str = 'fault',
+        trimmed: bool = False,
+        is_curtain = False,
+        extend_fault_representation: bool = False,
+        flange_inner_ring: bool = False,
+        saucer_parameter: Optional[float] = None,
+        retriangulate: bool = False,
+        related_uuid: Optional[Union[UUID, str]] = None,
+        progress_fn: Optional[Callable] = None,
+        extra_metadata = None,
+        return_properties: Optional[List[str]] = None,
+        raw_bisector: bool = False,
+        use_pack: bool = False,
+        flange_radius: Optional[float] = None,
+        reorient: bool = True,
+        n_threads: int = 20,
+        patchwork: bool = False,
+        grid_patching_property_uuid: Optional[Union[UUID, str]] = None,
+        surface_patching_property_uuid: Optional[Union[UUID, str]] = None) ->  \
+            Tuple[int, bool, str, List[Union[UUID, str]]]:
     """Multiprocessing wrapper function of find_faces_to_represent_surface_regular_optimised.
 
     arguments:
@@ -98,8 +105,17 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
         flange_radius (float, optional): the radial distance to use for outer flange extension points; if None,
            a large value will be calculated from the grid size; units are xy units of grid crs
         reorient (bool, default True):  if True, the points are reoriented to minimise the
-              z range prior to retriangulation (ie. z axis is approximate normal to plane of points), to enhace the triangulation
+           z range prior to retriangulation (ie. z axis is approximate normal to plane of points), to enhace the triangulation
         n_threads (int, default 20): the number of parallel threads to use in numba points in triangles function
+        patchwork (bool, default False): if True and grid bisector is included in return properties, a compostite
+           bisector is generated, based on individual ones for each patch of the surface; the following two
+           arguments must be set if patchwork is True
+        grid_patching_property_uuid (uuid, optional): required if patchwork is True, the uuid of a discrete or
+           categorical cells property on the grid which will be used to determine which patch of the surface is
+           relevant to a cell
+        surface_patching_property_uuid (uuid, optional): required if patchwork is True, the uuid of a discrete or
+           categorical property on the patches of the surface, identifying the value of the grid patching property
+           that each patch relates to
 
     returns:
         Tuple containing:
@@ -109,18 +125,15 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
             - uuid_list (List[str]): list of UUIDs of relevant objects
 
     notes:
-        Use this function as argument to the multiprocessing function; it will create a new model that is saved
-        in a temporary epc file and returns the required values, which are used in the multiprocessing function to
-        recombine all the objects into a single epc file;
-        the saucer_parameter is interpreted in one of two ways: (1) +ve fractoinal values between zero and one
-        are the fractional distance from the centre of the points to its rim at which to sample the surface for
-        extrapolation and thereby modify the recumbent z of flange points; 0 will usually give shallower and
-        smoother saucer; larger values (must be less than one) will lead to stronger and more erratic saucer
-        shape in flange; (2) other values between -90.0 and 90.0 are interpreted as an angle to apply out of
-        the plane of the original points, to give a simple (and less computationally demanding) saucer shape;
-        +ve angles result in the shift being in the direction of the -ve z hemisphere; -ve angles result in
-        the shift being in the +ve z hemisphere; in either case the direction of the shift is perpendicular
-        to the average plane of the original points
+        - use this function as argument to the multiprocessing function; it will create a new model that is saved
+          in a temporary epc file and returns the required values, which are used in the multiprocessing function to
+          recombine all the objects into a single epc file
+        - the saucer_parameter is between -90.0 and 90.0 and is interpreted as an angle to apply out of
+          the plane of the original points, to give a simple saucer shape;
+          +ve angles result in the shift being in the direction of the -ve z hemisphere; -ve angles result in
+          the shift being in the +ve z hemisphere; in either case the direction of the shift is perpendicular
+          to the average plane of the original points
+        - patchwork is not compatible with re-triangulation
     """
     tmp_dir = Path(parent_tmp_dir) / f"{uuid.uuid4()}"
     tmp_dir.mkdir(parents = True, exist_ok = True)
@@ -148,12 +161,20 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
     if flange_radius is None:
         flange_radius = 5.0 * np.sum(np.array(grid.extent_kji, dtype = float) * np.array(grid.aligned_dxyz()))
     s_model = rq.Model(surface_epc, quiet = True)
-    model.copy_uuid_from_other_model(s_model, uuid = str(surface_uuid))
+    surface_uuid = str(surface_uuid)
+    model.copy_uuid_from_other_model(s_model, uuid = surface_uuid)
+    if surface_patching_property_uuid is not None:
+        model.copy_uuid_from_other_model(s_model, uuid = surface_patching_property_uuid)
+        uuid_list.append(surface_patching_property_uuid)
     repr_type = model.type_of_part(model.part(uuid = surface_uuid), strip_obj = True)
     assert repr_type in ['TriangulatedSetRepresentation', 'PointSetRepresentation']
+    assert repr_type == 'TriangulatedSetRepresentation' or not patchwork,  \
+        'patchwork only implemented for triangulated set surfaces'
+
     extended = False
     retriangulated = False
     flange_bool = None
+
     if repr_type == 'PointSetRepresentation':
         # trim pointset to grid xyz box
         pset = rqs.PointSet(model, uuid = surface_uuid)
@@ -193,19 +214,26 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
         inherit_interpretation_relationship(model, surface_uuid, surf.uuid)
         surface_uuid = surf.uuid
 
-    surface = rqs.Surface(parent_model = model, uuid = str(surface_uuid))
+    surface = rqs.Surface(parent_model = model, uuid = surface_uuid)
     surf_title = surface.title
     assert surf_title
     surface.change_crs(grid.crs)
+    normal_vector = None
+    if reorient:
+        normal_vector = surface.normal()
+    if patchwork:  # disable trimming as whole patches could be trimmed out, changing the patch indexing from that expected
+        trimmed = True
     if not trimmed and surface.triangle_count() > 100:
         if not surf_title.endswith('trimmed'):
             surf_title += ' trimmed'
         trimmed_surf = rqs.Surface(model, crs_uuid = grid.crs.uuid, title = surf_title)
         # trimmed_surf.set_to_trimmed_surface(surf, xyz_box = xyz_box, xy_polygon = parent_seg.polygon)
         trimmed_surf.set_to_trimmed_surface(surface, xyz_box = grid.xyz_box(local = True))
+        trimmed_surf.extra_metadata = surface.extra_metadata
         surface = trimmed_surf
         trimmed = True
     if (extend_fault_representation and not extended) or (retriangulate and not retriangulated):
+        assert not patchwork, 'extension or re-triangulation are not compatible with patchwork'
         _, p = surface.triangles_and_points()
         pset = rqs.PointSet(model, points_array = p, crs_uuid = grid.crs.uuid, title = surf_title)
         if extend_fault_representation and not surf_title.endswith('extended'):
@@ -218,7 +246,8 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
                                                  flange_inner_ring = flange_inner_ring,
                                                  saucer_parameter = saucer_parameter,
                                                  flange_radial_distance = flange_radius,
-                                                 make_clockwise = False)
+                                                 make_clockwise = False,
+                                                 normal_vector = normal_vector)
         del pset
         extended = extend_fault_representation
         retriangulated = True
@@ -242,7 +271,23 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
                                            discrete = True,
                                            dtype = np.uint8)
         uuid_list.append(flange_p.uuid)
-    uuid_list.append(surface_uuid)
+
+    if not patchwork:
+        uuid_list.append(surface_uuid)
+
+    patch_indices = None
+    if patchwork:  # generate a patch indices array over grid cells based on supplied patching properties
+        assert grid_patching_property_uuid is not None and surface_patching_property_uuid is not None
+        g_patching_array = rqp.Property(g_model, uuid = grid_patching_property_uuid).array_ref()
+        assert g_patching_array.shape == tuple(grid.extent_kji)
+        s_patches_array = rqp.Property(model, uuid = surface_patching_property_uuid).array_ref()
+        patch_count = surface.number_of_patches()
+        assert s_patches_array.shape == (patch_count,)
+        p_dtype = (np.int8 if s_patches_array.shape[0] < 128 else np.int32)
+        patch_indices = np.full(g_patching_array.shape, -1, dtype = p_dtype)
+        for patch in range(patch_count):
+            gp = s_patches_array[patch]
+            patch_indices[(g_patching_array == gp).astype(bool)] = patch
 
     returns = rqgs.find_faces_to_represent_surface_regular_optimised(grid,
                                                                      surface,
@@ -256,7 +301,8 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
                                                                      return_properties,
                                                                      raw_bisector = raw_bisector,
                                                                      n_batches = n_threads,
-                                                                     packed_bisectors = use_pack)
+                                                                     packed_bisectors = use_pack,
+                                                                     patch_indices = patch_indices)
 
     success = False
 
@@ -286,6 +332,7 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
 
     if success and return_properties is not None and len(return_properties):
         log.debug(f'{name} requested properties: {return_properties}')
+        assert isinstance(returns, tuple)
         properties = returns[1]
         realisation = index if use_index_as_realisation else None
         property_collection = rqp.PropertyCollection(support = gcs)
@@ -346,6 +393,7 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
                 if grid_pc is None:
                     grid_pc = rqp.PropertyCollection()
                     grid_pc.set_support(support = grid)
+                assert array.ndim == (2 if is_curtain else 3)
                 grid_pc.add_cached_array_to_imported_list(array,
                                                           f"from find_faces function for {surface.title}",
                                                           f'{surface.title} {p_name}',