resqpy 4.17.0__py3-none-any.whl → 4.17.1__py3-none-any.whl

resqpy/grid_surface/_find_faces.py

@@ -495,18 +495,18 @@ def find_faces_to_represent_surface_regular(
     return gcs
 
 
-def find_faces_to_represent_surface_regular_optimised(grid,
-                                                      surface,
-                                                      name,
-                                                      title = None,
-                                                      agitate = False,
-                                                      random_agitation = False,
-                                                      feature_type = "fault",
-                                                      is_curtain = False,
-                                                      progress_fn = None,
-                                                      return_properties = None,
-                                                      raw_bisector = False,
-                                                      n_batches = 20):
+def find_faces_to_represent_surface_regular_dense_optimised(grid,
+                                                            surface,
+                                                            name,
+                                                            title = None,
+                                                            agitate = False,
+                                                            random_agitation = False,
+                                                            feature_type = "fault",
+                                                            is_curtain = False,
+                                                            progress_fn = None,
+                                                            return_properties = None,
+                                                            raw_bisector = False,
+                                                            n_batches = 20):
     """Returns a grid connection set containing those cell faces which are deemed to represent the surface.
 
     argumants:
@@ -553,7 +553,10 @@ 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;
+        this version of the function uses fully explicit boolean arrays to capture the faces before conversion
+        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()
     """
 
     assert isinstance(grid, grr.RegularGrid)
@@ -602,6 +605,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     t_dtype = np.int32 if len(triangles) < 2_000_000_000 else np.int64
     assert (triangles is not None and points is not None), f"surface {surface.title} is empty"
     if agitate:
+        points = points.copy()
         if random_agitation:
             points += 1.0e-5 * (np.random.random(points.shape) - 0.5)
         else:
@@ -828,7 +832,8 @@ def find_faces_to_represent_surface_regular_optimised(grid,
             # log.debug('finished preparing columns bisector')
         else:
             log.debug("preparing cells bisector")
-            bisector, is_curtain = bisector_from_faces(tuple(grid.extent_kji), k_faces, j_faces, i_faces, raw_bisector)
+            bisector, is_curtain = bisector_from_faces(tuple(grid.extent_kji), k_faces, j_faces, i_faces, raw_bisector,
+                                                       False)
             if is_curtain:
                 bisector = bisector[0]  # reduce to a columns property
 
@@ -862,6 +867,386 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     return gcs
 
 
+def find_faces_to_represent_surface_regular_optimised(grid,
+                                                      surface,
+                                                      name,
+                                                      title = None,
+                                                      agitate = False,
+                                                      random_agitation = False,
+                                                      feature_type = "fault",
+                                                      is_curtain = False,
+                                                      progress_fn = None,
+                                                      return_properties = None,
+                                                      raw_bisector = False,
+                                                      n_batches = 20):
+    """Returns a grid connection set containing those cell faces which are deemed to represent the surface.
+
+    argumants:
+        grid (RegularGrid): the grid for which to create a grid connection set representation of the surface;
+           must be aligned, ie. I with +x, J with +y, K with +z and local origin of (0.0, 0.0, 0.0)
+        surface (Surface): the surface to be intersected with the grid
+        name (str): the feature name to use in the grid connection set
+        title (str, optional): the citation title to use for the grid connection set; defaults to name
+        agitate (bool, default False): if True, the points of the surface are perturbed by a small
+           offset, which can help if the surface has been built from a regular mesh with a periodic resonance
+           with the grid
+        random_agitation (bool, default False): if True, the agitation is by a small random distance; if False,
+           a constant positive shift of 5.0e-6 is applied to x, y & z values; ignored if agitate is False
+        feature_type (str, default 'fault'): 'fault', 'horizon' or 'geobody boundary'
+        is_curtain (bool, default False): if True, only the top layer of the grid is processed and the bisector
+           property, if requested, is generated with indexable element columns
+        progress_fn (f(x: float), optional): a callback function to be called at intervals by this function;
+           the argument will progress from 0.0 to 1.0 in unspecified and uneven increments
+        return_properties (List[str]): if present, a list of property arrays to calculate and
+           return as a dictionary; recognised values in the list are 'triangle', 'depth', 'offset',
+           'flange bool', 'grid bisector', or 'grid shadow';
+           triangle is an index into the surface triangles of the triangle detected for the gcs face; depth is
+           the z value of the intersection point of the inter-cell centre vector with a triangle in the surface;
+           offset is a measure of the distance between the centre of the cell face and the intersection point;
+           grid bisector is a grid cell boolean property holding True for the set of cells on one
+           side of the surface, deemed to be shallower;
+           grid shadow is a grid cell int8 property holding 0: cell neither above nor below a K face of the
+           gridded surface, 1 cell is above K face(s), 2 cell is below K face(s), 3 cell is between K faces;
+           the returned dictionary has the passed strings as keys and numpy arrays as values
+        raw_bisector (bool, default False): if True and grid bisector is requested then it is left in a raw
+           form without assessing which side is shallower (True values indicate same side as origin cell)
+        n_batches (int, default 20): the number of batches of triangles to use at the low level (numba multi
+           threading allows some parallelism between the batches)
+
+    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
+
+    notes:
+        this function is designed for aligned regular grids only;
+        this function can handle the surface and grid being in different coordinate reference systems, as
+        long as the implicit parent crs is shared;
+        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
+    """
+
+    assert isinstance(grid, grr.RegularGrid)
+    assert grid.is_aligned
+    return_triangles = False
+    return_depths = False
+    return_offsets = False
+    return_bisector = False
+    return_shadow = False
+    return_flange_bool = False
+    if return_properties:
+        assert all([
+            p in [
+                "triangle",
+                "depth",
+                "offset",
+                "grid bisector",
+                "grid shadow",
+                "flange bool",
+            ] for p in return_properties
+        ])
+        return_triangles = "triangle" in return_properties
+        return_depths = "depth" in return_properties
+        return_offsets = "offset" in return_properties
+        return_bisector = "grid bisector" in return_properties
+        return_shadow = "grid shadow" in return_properties
+        return_flange_bool = "flange bool" in return_properties
+        if return_flange_bool:
+            return_triangles = True
+
+    if title is None:
+        title = name
+
+    if progress_fn is not None:
+        progress_fn(0.0)
+
+    log.debug(f"intersecting surface {surface.title} with regular grid {grid.title}")
+    # log.debug(f'grid extent kji: {grid.extent_kji}')
+
+    triangles, points = surface.triangles_and_points(copy = True)
+    surface.decache_triangles_and_points()
+
+    t_dtype = np.int32 if len(triangles) < 2_147_483_648 else np.int64
+
+    assert (triangles is not None and points is not None), f"surface {surface.title} is empty"
+    if agitate:
+        if random_agitation:
+            points += 1.0e-5 * (np.random.random(points.shape) - 0.5)
+        else:
+            points += 5.0e-6
+    # log.debug(f'surface: {surface.title}; p0: {points[0]}; crs uuid: {surface.crs_uuid}')
+    # log.debug(f'surface min xyz: {np.min(points, axis = 0)}')
+    # log.debug(f'surface max xyz: {np.max(points, axis = 0)}')
+    if not bu.matching_uuids(grid.crs_uuid, surface.crs_uuid):
+        log.debug("converting from surface crs to grid crs")
+        s_crs = rqc.Crs(surface.model, uuid = surface.crs_uuid)
+        s_crs.convert_array_to(grid.crs, points)
+        surface.crs_uuid = grid.crs.uuid
+        # log.debug(f'surface: {surface.title}; p0: {points[0]}; crs uuid: {surface.crs_uuid}')
+        # log.debug(f'surface min xyz: {np.min(points, axis = 0)}')
+        # log.debug(f'surface max xyz: {np.max(points, axis = 0)}')
+
+    # convert surface points to work with unit cube grid cells
+    dx = grid.block_dxyz_dkji[2, 0]
+    dy = grid.block_dxyz_dkji[1, 1]
+    dz = grid.block_dxyz_dkji[0, 2]
+    points[:, 0] /= dx
+    points[:, 1] /= dy
+    points[:, 2] /= dz
+    points[:] -= 0.5
+    p = points[triangles]
+
+    nk = 1 if is_curtain else grid.nk
+    # K direction (xy projection)
+    k_faces_kji0 = None
+    k_triangles = None
+    k_depths = None
+    k_offsets = None
+    k_props = None
+    if nk > 1:
+        # log.debug("searching for k faces")
+
+        k_hits, k_depths = vec.points_in_triangles_aligned_unified(grid.ni, grid.nj, 0, 1, 2, p, n_batches)
+
+        k_faces = np.floor(k_depths)
+        mask = np.logical_and(k_faces >= 0, k_faces < nk - 1)
+
+        if np.any(mask):
+            k_hits = k_hits[mask, :]
+            k_faces = k_faces[mask]
+            k_depths = k_depths[mask]
+            k_triangles = k_hits[:, 0]
+            k_faces_kji0 = np.empty((len(k_faces), 3), dtype = np.int32)
+            k_faces_kji0[:, 0] = k_faces
+            k_faces_kji0[:, 1] = k_hits[:, 1]
+            k_faces_kji0[:, 2] = k_hits[:, 2]
+            if return_offsets:
+                k_offsets = (k_depths - k_faces.astype(np.float64) - 0.5) * dz
+            if return_depths:
+                k_depths[:] += 0.5
+                k_depths[:] *= dz
+            k_props = []
+            if return_triangles:
+                k_props.append(k_triangles)
+            if return_depths:
+                k_props.append(k_depths)
+            if return_offsets:
+                k_props.append(k_offsets)
+            log.debug(f"k face count: {len(k_faces_kji0)}")
+
+        del k_hits
+        del k_faces
+
+    if progress_fn is not None:
+        progress_fn(0.3)
+
+    # J direction (xz projection)
+    j_faces_kji0 = None
+    j_triangles = None
+    j_depths = None
+    j_offsets = None
+    j_props = None
+    if grid.nj > 1:
+        # log.debug("searching for J faces")
+
+        j_hits, j_depths = vec.points_in_triangles_aligned_unified(grid.ni, grid.nk, 0, 2, 1, p, n_batches)
+
+        j_faces = np.floor(j_depths)
+        mask = np.logical_and(j_faces >= 0, j_faces < grid.nj - 1)
+
+        if np.any(mask):
+            j_hits = j_hits[mask, :]
+            j_faces = j_faces[mask]
+            j_depths = j_depths[mask]
+            j_triangles = j_hits[:, 0]
+            j_faces_kji0 = np.empty((len(j_faces), 3), dtype = np.int32)
+            j_faces_kji0[:, 0] = j_hits[:, 1]
+            j_faces_kji0[:, 1] = j_faces
+            j_faces_kji0[:, 2] = j_hits[:, 2]
+            if return_offsets:
+                j_offsets = (j_depths - j_faces.astype(np.float64) - 0.5) * dy
+            if return_depths:
+                j_depths[:] += 0.5
+                j_depths[:] *= dy
+            if is_curtain and grid.nk > 1:  # expand arrays to all layers
+                j_faces = np.repeat(np.expand_dims(j_faces_kji0, axis = 0), grid.nk, axis = 0)
+                j_faces[:, :, 0] = np.expand_dims(np.arange(grid.nk, dtype = np.int32), axis = -1)
+                j_faces_kji0 = j_faces.reshape((-1, 3))
+                j_triangles = np.repeat(j_triangles, grid.nk, axis = 0)
+                if return_offsets:
+                    j_offsets = np.repeat(j_offsets, grid.nk, axis = 0)
+                if return_depths:
+                    j_depths = np.repeat(j_depths, grid.nk, axis = 0)
+            j_props = []
+            if return_triangles:
+                j_props.append(j_triangles)
+            if return_depths:
+                j_props.append(j_depths)
+            if return_offsets:
+                j_props.append(j_offsets)
+            log.debug(f"j face count: {len(j_faces_kji0)}")
+
+        del j_hits
+        del j_faces
+
+    if progress_fn is not None:
+        progress_fn(0.6)
+
+    # I direction (yz projection)
+    i_faces_kji0 = None
+    i_triangles = None
+    i_depths = None
+    i_offsets = None
+    i_props = None
+    if grid.ni > 1:
+        # log.debug("searching for I faces")
+
+        i_hits, i_depths = vec.points_in_triangles_aligned_unified(grid.nj, grid.nk, 1, 2, 0, p, n_batches)
+
+        i_faces = np.floor(i_depths)
+        mask = np.logical_and(i_faces >= 0, i_faces < grid.ni - 1)
+
+        if np.any(mask):
+            i_hits = i_hits[mask, :]
+            i_faces = i_faces[mask]
+            i_depths = i_depths[mask]
+            i_triangles = i_hits[:, 0]
+            i_faces_kji0 = np.empty((len(i_faces), 3), dtype = np.int32)
+            i_faces_kji0[:, 0] = i_hits[:, 1]
+            i_faces_kji0[:, 1] = i_hits[:, 2]
+            i_faces_kji0[:, 2] = i_faces
+            if return_offsets:
+                i_offsets = (i_depths - i_faces.astype(np.float64) - 0.5) * dx
+            if return_depths:
+                i_depths[:] += 0.5
+                i_depths[:] *= dx
+            if is_curtain and grid.nk > 1:  # expand arrays to all layers
+                i_faces = np.repeat(np.expand_dims(i_faces_kji0, axis = 0), grid.nk, axis = 0)
+                i_faces[:, :, 0] = np.expand_dims(np.arange(grid.nk, dtype = np.int32), axis = -1)
+                i_faces_kji0 = i_faces.reshape((-1, 3))
+                i_triangles = np.repeat(i_triangles, grid.nk, axis = 0)
+                if return_offsets:
+                    i_offsets = np.repeat(i_offsets, grid.nk, axis = 0)
+                if return_depths:
+                    i_depths = np.repeat(i_depths, grid.nk, axis = 0)
+            i_props = []
+            if return_triangles:
+                i_props.append(i_triangles)
+            if return_depths:
+                i_props.append(i_depths)
+            if return_offsets:
+                i_props.append(i_offsets)
+            log.debug(f"i face count: {len(i_faces_kji0)}")
+
+        del i_hits
+        del i_faces
+
+    if progress_fn is not None:
+        progress_fn(0.9)
+
+    log.debug("converting face sets into grid connection set")
+    # NB: kji0 arrays in internal face protocol: used as cell_kji0 with polarity of 1
+    # property lists have elements replaced with sorted and filtered equivalents
+    gcs = rqf.GridConnectionSet.from_faces_indices(grid = grid,
+                                                   k_faces_kji0 = k_faces_kji0,
+                                                   j_faces_kji0 = j_faces_kji0,
+                                                   i_faces_kji0 = i_faces_kji0,
+                                                   remove_duplicates = True,
+                                                   k_properties = k_props,
+                                                   j_properties = j_props,
+                                                   i_properties = i_props,
+                                                   feature_name = name,
+                                                   feature_type = feature_type,
+                                                   create_organizing_objects_where_needed = True,
+                                                   title = title)
+    # log.debug('finished coversion to gcs')
+
+    # NB. following assumes faces have been added to gcs in a particular order!
+    if return_triangles:
+        # log.debug('preparing triangles array')
+        k_triangles = np.emptry((0,), dtype = np.int32) if k_props is None else k_props.pop(0)
+        j_triangles = np.emptry((0,), dtype = np.int32) if j_props is None else j_props.pop(0)
+        i_triangles = np.emptry((0,), dtype = np.int32) if i_props is None else i_props.pop(0)
+        all_tris = np.concatenate((k_triangles, j_triangles, i_triangles), axis = 0)
+        # log.debug(f'gcs count: {gcs.count}; all triangles shape: {all_tris.shape}')
+        assert all_tris.shape == (gcs.count,)
+
+    # NB. following assumes faces have been added to gcs in a particular order!
+    if return_depths:
+        # log.debug('preparing depths array')
+        k_depths = np.emptry((0,), dtype = np.float64) if k_props is None else k_props.pop(0)
+        j_depths = np.emptry((0,), dtype = np.float64) if j_props is None else j_props.pop(0)
+        i_depths = np.emptry((0,), dtype = np.float64) if i_props is None else i_props.pop(0)
+        all_depths = np.concatenate((k_depths, j_depths, i_depths), axis = 0)
+        # log.debug(f'gcs count: {gcs.count}; all depths shape: {all_depths.shape}')
+        assert all_depths.shape == (gcs.count,)
+
+    # NB. following assumes faces have been added to gcs in a particular order!
+    if return_offsets:
+        # log.debug('preparing offsets array')
+        k_offsets = np.emptry((0,), dtype = np.float64) if k_props is None else k_props[0]
+        j_offsets = np.emptry((0,), dtype = np.float64) if j_props is None else j_props[0]
+        i_offsets = np.emptry((0,), dtype = np.float64) if i_props is None else i_props[0]
+        all_offsets = _all_offsets(grid.crs, k_offsets, j_offsets, i_offsets)
+        # log.debug(f'gcs count: {gcs.count}; all offsets shape: {all_offsets.shape}')
+        assert all_offsets.shape == (gcs.count,)
+
+    if return_flange_bool:
+        # log.debug('preparing flange array')
+        flange_bool_uuid = surface.model.uuid(title = "flange bool",
+                                              obj_type = "DiscreteProperty",
+                                              related_uuid = surface.uuid)
+        assert (flange_bool_uuid is not None), f"No flange bool property found for surface: {surface.title}"
+        flange_bool = rqp.Property(surface.model, uuid = flange_bool_uuid)
+        flange_array = flange_bool.array_ref(dtype = bool)
+        all_flange = np.take(flange_array, all_tris)
+        assert all_flange.shape == (gcs.count,)
+
+    # note: following is a grid cells property, not a gcs property
+    if return_bisector:
+        if is_curtain:
+            log.debug("preparing columns bisector")
+            bisector = column_bisector_from_face_indices((grid.nj, grid.ni), j_faces_kji0[:, 1:], i_faces_kji0[:, 1:])
+            # log.debug('finished preparing columns bisector')
+        else:
+            log.debug("preparing cells bisector")
+            bisector, is_curtain = bisector_from_faces(tuple(grid.extent_kji), k_faces_kji0, j_faces_kji0, i_faces_kji0,
+                                                       raw_bisector, True)
+            if is_curtain:
+                bisector = bisector[0]  # reduce to a columns property
+
+    # note: following is a grid cells property, not a gcs property
+    if return_shadow:
+        log.debug("preparing cells shadow")
+        shadow = shadow_from_face_indices(tuple(grid.extent_kji), k_faces_kji0)
+
+    if progress_fn is not None:
+        progress_fn(1.0)
+
+    log.debug(f"finishing find_faces_to_represent_surface_regular_optimised for {name}")
+
+    # if returning properties, construct dictionary
+    if return_properties:
+        props_dict = {}
+        if return_triangles:
+            props_dict["triangle"] = all_tris
+        if return_depths:
+            props_dict["depth"] = all_depths
+        if return_offsets:
+            props_dict["offset"] = all_offsets
+        if return_bisector:
+            props_dict["grid bisector"] = (bisector, is_curtain)
+        if return_shadow:
+            props_dict["grid shadow"] = shadow
+        if return_flange_bool:
+            props_dict["flange bool"] = all_flange
+        return (gcs, props_dict)
+
+    return gcs
+
+
 def find_faces_to_represent_surface(grid, surface, name, mode = "auto", feature_type = "fault", progress_fn = None):
     """Returns a grid connection set containing those cell faces which are deemed to represent the surface.
 
@@ -889,19 +1274,7 @@ def find_faces_to_represent_surface(grid, surface, name, mode = "auto", feature_
             mode = "regular_optimised"
         else:
             mode = "staffa"
-    if mode == "staffa":
-        return find_faces_to_represent_surface_staffa(grid,
-                                                      surface,
-                                                      name,
-                                                      feature_type = feature_type,
-                                                      progress_fn = progress_fn)
-    elif mode == "regular":
-        return find_faces_to_represent_surface_regular(grid,
-                                                       surface,
-                                                       name,
-                                                       feature_type = feature_type,
-                                                       progress_fn = progress_fn)
-    elif mode == "regular_optimised":
+    if mode == "regular_optimised":
         return find_faces_to_represent_surface_regular_optimised(grid,
                                                                  surface,
                                                                  name,
@@ -915,177 +1288,129 @@ def find_faces_to_represent_surface(grid, surface, name, mode = "auto", feature_
                                                                        name,
                                                                        feature_type = feature_type,
                                                                        progress_fn = progress_fn)
+    elif mode == "staffa":
+        return find_faces_to_represent_surface_staffa(grid,
+                                                      surface,
+                                                      name,
+                                                      feature_type = feature_type,
+                                                      progress_fn = progress_fn)
+    elif mode == "regular_dense":
+        return find_faces_to_represent_surface_regular_dense_optimised(grid,
+                                                                       surface,
+                                                                       name,
+                                                                       feature_type = feature_type,
+                                                                       progress_fn = progress_fn)
+    elif mode == "regular":
+        return find_faces_to_represent_surface_regular(grid,
+                                                       surface,
+                                                       name,
+                                                       feature_type = feature_type,
+                                                       progress_fn = progress_fn)
     log.critical("unrecognised mode: " + str(mode))
     return None
 
 
 def bisector_from_faces(  # type: ignore
-    grid_extent_kji: Tuple[int, int, int],
-    k_faces: np.ndarray,
-    j_faces: np.ndarray,
-    i_faces: np.ndarray,
-    raw_bisector: bool,
-) -> Tuple[np.ndarray, bool]:
+        grid_extent_kji: Tuple[int, int, int], k_faces: np.ndarray, j_faces: np.ndarray, i_faces: np.ndarray,
+        raw_bisector: bool, using_indices: bool) -> Tuple[np.ndarray, bool]:
     """Creates a boolean array denoting the bisection of the grid by the face sets.
 
     arguments:
-        grid_extent_kji (Tuple[int, int, int]): the shape of the grid.
-        k_faces (np.ndarray): a boolean array of which faces represent the surface in the k dimension.
-        j_faces (np.ndarray): a boolean array of which faces represent the surface in the j dimension.
-        i_faces (np.ndarray): a boolean array of which faces represent the surface in the i dimension.
+        - grid_extent_kji (Tuple[int, int, int]): the shape of the grid
+        - k_faces (np.ndarray): a boolean array of which faces represent the surface in the k dimension
+        - j_faces (np.ndarray): a boolean array of which faces represent the surface in the j dimension
+        - i_faces (np.ndarray): a boolean array of which faces represent the surface in the i dimension
+        - raw_bisector (bool): if True, the bisector is returned without determining which side is shallower
+        - using_indices (bool): if True, k_faces etc. are list-like arrays of kji indices; if False, they
+          are full boolean arrays covering the internal faces
 
     returns:
         Tuple containing:
-
         - array (np.ndarray): boolean bisectors array where values are True for cells on the side
-            of the surface that has a lower mean k index on average and False for cells on the other side.
+          of the surface that has a lower mean k index on average and False for cells on the other side.
         - is_curtain (bool): True if the surface is a curtain (vertical), otherwise False.
 
     notes:
-        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.
+        - 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
+        - a value of False for using_indices is DEPRECATED, pending proving of newer indices based approach
     """
     assert len(grid_extent_kji) == 3
 
-    # Finding the surface boundary (includes a buffer slice where surface does not reach edge of grid).
-    boundary = get_boundary(k_faces, j_faces, i_faces, grid_extent_kji)
-
-    # Setting up the bisector array for the bounding box.
-    bounding_array = np.zeros(
-        (
-            boundary["k_max"] - boundary["k_min"] + 1,
-            boundary["j_max"] - boundary["j_min"] + 1,
-            boundary["i_max"] - boundary["i_min"] + 1,
-        ),
-        dtype = np.bool_,
-    )
+    # find the surface boundary (includes a buffer slice where surface does not reach edge of grid)
+    if using_indices:
+        box = get_boundary_from_indices(k_faces, j_faces, i_faces, grid_extent_kji)
+        # set k_faces as bool arrays covering box
+        k_faces, j_faces, i_faces = _box_face_arrays_from_indices(k_faces, j_faces, i_faces, box)
+    else:
+        box = get_boundary(k_faces, j_faces, i_faces, grid_extent_kji)
+        # switch k_faces etc. to box coverage
+        k_faces = k_faces[box[0, 0]:box[1, 0] - 1, box[0, 1]:box[1, 1], box[0, 2]:box[1, 2]]
+        j_faces = j_faces[box[0, 0]:box[1, 0], box[0, 1]:box[1, 1] - 1, box[0, 2]:box[1, 2]]
+        i_faces = i_faces[box[0, 0]:box[1, 0], box[0, 1]:box[1, 1], box[0, 2]:box[1, 2] - 1]
 
-    # Seeding the bisector array from (0, 0, 0) up to the first faces that represent the surface.
-    boundary_values = tuple(boundary.values())
-    bounding_array, first_k, first_j, first_i = _seed_array((0, 0, 0), k_faces, j_faces, i_faces, boundary_values,
-                                                            bounding_array)
-    points = set()
-    for dimension, first_true in enumerate([first_k, first_j, first_i]):
-        for dimension_value in range(1, first_true):
-            point = [0, 0, 0]
-            point[dimension] = dimension_value
-            point = tuple(point)  # type: ignore
-            bounding_array, first_k_sub, first_j_sub, first_i_sub = _seed_array(point, k_faces, j_faces, i_faces,
-                                                                                boundary_values, bounding_array)
-            for sub_dimension, first_true_sub in enumerate([first_k_sub, first_j_sub, first_i_sub]):
-                if dimension != sub_dimension:
-                    for sub_dimension_value in range(1, first_true_sub):
-                        point = [0, 0, 0]
-                        point[dimension] = dimension_value
-                        point[sub_dimension] = sub_dimension_value
-                        point = tuple(point)  # type: ignore
-                        if point not in points:
-                            points.add(point)
-                            bounding_array, _, _, _ = _seed_array(
-                                point,
-                                k_faces,
-                                j_faces,
-                                i_faces,
-                                boundary_values,
-                                bounding_array,
-                            )
-
-    # Setting up the array for the changing values.
-    changing_array = np.zeros_like(bounding_array, dtype = np.bool_)
-
-    # Repeatedly spreading True values to neighbouring cells that are not the other side of a face.
-    # yapf: disable
-    open_k = np.logical_not(k_faces)[
-        boundary["k_min"]:boundary["k_max"],
-        boundary["j_min"]:boundary["j_max"] + 1,
-        boundary["i_min"]:boundary["i_max"] + 1,
-    ]
-    open_j = np.logical_not(j_faces)[
-        boundary["k_min"]:boundary["k_max"] + 1,
-        boundary["j_min"]:boundary["j_max"],
-        boundary["i_min"]:boundary["i_max"] + 1,
-    ]
-    open_i = np.logical_not(i_faces)[
-        boundary["k_min"]:boundary["k_max"] + 1,
-        boundary["j_min"]:boundary["j_max"] + 1,
-        boundary["i_min"]:boundary["i_max"],
-    ]
-    # yapf: enable
-    while True:
-        changing_array[:] = False
-
-        # k faces
-        changing_array[1:, :, :] = np.logical_and(bounding_array[:-1, :, :], open_k)
-        changing_array[:-1, :, :] = np.logical_or(changing_array[:-1, :, :],
-                                                  np.logical_and(bounding_array[1:, :, :], open_k))
+    box_shape = box[1, :] - box[0, :]
 
-        # j faces
-        changing_array[:, 1:, :] = np.logical_or(changing_array[:, 1:, :],
-                                                 np.logical_and(bounding_array[:, :-1, :], open_j))
-        changing_array[:, :-1, :] = np.logical_or(changing_array[:, :-1, :],
-                                                  np.logical_and(bounding_array[:, 1:, :], open_j))
+    # set up the bisector array for the bounding box
+    box_array = np.zeros(box_shape, dtype = np.bool_)
 
-        # i faces
-        changing_array[:, :, 1:] = np.logical_or(changing_array[:, :, 1:],
-                                                 np.logical_and(bounding_array[:, :, :-1], open_i))
-        changing_array[:, :, :-1] = np.logical_or(changing_array[:, :, :-1],
-                                                  np.logical_and(bounding_array[:, :, 1:], open_i))
+    # seed the bisector box array at (0, 0, 0)
+    box_array[0, 0, 0] = True
 
-        changing_array[:] = np.logical_and(changing_array, np.logical_not(bounding_array))
-        if np.count_nonzero(changing_array) == 0:
-            break
-        bounding_array = np.logical_or(bounding_array, changing_array)
+    # prepare to spread True values to neighbouring cells that are not the other side of a face
+    open_k = np.logical_not(k_faces)
+    open_j = np.logical_not(j_faces)
+    open_i = np.logical_not(i_faces)
 
-    # Setting up the full bisectors array and assigning the bounding box values.
+    # populate bisector array for box
+    _fill_bisector(box_array, open_k, open_j, open_i)
+
+    # set up the full bisectors array and assigning the bounding box values
     array = np.zeros(grid_extent_kji, dtype = np.bool_)
-    # yapf: disable
-    array[
-        boundary["k_min"]:boundary["k_max"] + 1,
-        boundary["j_min"]:boundary["j_max"] + 1,
-        boundary["i_min"]:boundary["i_max"] + 1,
-    ] = bounding_array
-    # yapf: enable
-
-    # Setting values outside of the bounding box.
-    if boundary["k_max"] != grid_extent_kji[0] - 1 and np.any(bounding_array[-1, :, :]):
-        array[boundary["k_max"] + 1:, :, :] = True
-    if boundary["k_min"] != 0:
-        array[:boundary["k_min"], :, :] = True
-    if boundary["j_max"] != grid_extent_kji[1] - 1 and np.any(bounding_array[:, -1, :]):
-        array[:, boundary["j_max"] + 1:, :] = True
-    if boundary["j_min"] != 0:
-        array[:, :boundary["j_min"], :] = True
-    if boundary["i_max"] != grid_extent_kji[2] - 1 and np.any(bounding_array[:, :, -1]):
-        array[:, :, boundary["i_max"] + 1:] = True
-    if boundary["i_min"] != 0:
-        array[:, :, :boundary["i_min"]] = True
-
-    # Check all array elements are not the same.
+    array[box[0, 0]:box[1, 0], box[0, 1]:box[1, 1], box[0, 2]:box[1, 2]] = box_array
+
+    # set bisector values outside of the bounding box
+    _set_bisector_outside_box(array, box, box_array)
+
+    # 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.
-    layer_cell_count = grid_extent_kji[1] * grid_extent_kji[2]
-    array_k_sum = 0
-    array_opposite_k_sum = 0
-    is_curtain = False
-    for k in range(grid_extent_kji[0]):
-        array_layer_count = np.count_nonzero(array[k])
-        array_k_sum += (k + 1) * array_layer_count
-        array_opposite_k_sum += (k + 1) * (layer_cell_count - array_layer_count)
-    array_mean_k = float(array_k_sum) / float(true_count)
-    array_opposite_mean_k = float(array_opposite_k_sum) / float(cell_count - true_count)
-    if array_mean_k > array_opposite_mean_k and not raw_bisector:
-        array[:] = np.logical_not(array)
-    if abs(array_mean_k - array_opposite_mean_k) <= 0.001:
-        # log.warning('unable to determine which side of surface is shallower')
-        is_curtain = True
+    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)
 
     return array, is_curtain
 
 
+def column_bisector_from_face_indices(grid_extent_ji: Tuple[int, int], j_faces_ji0: np.ndarray,
+                                      i_faces_ji0: np.ndarray) -> np.ndarray:
+    """Returns a numpy bool array denoting the bisection of the top layer of the grid by the curtain face sets.
+
+    arguments:
+        - grid_extent_ji (pair of int): the shape of a layer of the grid
+        - j_faces_ji0, i_faces_ji0 (2D numpy int arrays of shape (N, 2)): indices of faces within a layer
+
+    returns:
+        numpy bool array of shape grid_extent_ji, set True for cells on one side of the face sets;
+        set False for cells on othe side
+
+    notes:
+        - 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 the False part
+        - the resulting array is suitable for use as a grid property with indexable element of columns
+        - the array is set True for the side of the curtain that contains cell [0, 0]
+    """
+    assert len(grid_extent_ji) == 2
+    j_faces = np.zeros((grid_extent_ji[0] - 1, grid_extent_ji[1]), dtype = np.bool_)
+    i_faces = np.zeros((grid_extent_ji[0], grid_extent_ji[1] - 1), dtype = np.bool_)
+    j_faces[j_faces_ji0[:, 0], j_faces_ji0[:, 1]] = True
+    i_faces[i_faces_ji0[:, 0], i_faces_ji0[:, 1]] = True
+    return column_bisector_from_faces(grid_extent_ji, j_faces, i_faces)
+
+
 def column_bisector_from_faces(grid_extent_ji: Tuple[int, int], j_faces: np.ndarray, i_faces: np.ndarray) -> np.ndarray:
     """Returns a numpy bool array denoting the bisection of the top layer of the grid by the curtain face sets.
 
@@ -1136,6 +1461,42 @@ def column_bisector_from_faces(grid_extent_ji: Tuple[int, int], j_faces: np.ndar
     return a
 
 
+def shadow_from_face_indices(extent_kji, kji0):
+    """Returns a numpy int8 array indicating whether cells are above, below or between K faces.
+
+    arguments:
+        extent_kji (triple int): the shape of the grid
+        kji0 (numpy int array of shape (N, 3)): indices where a K face is present
+
+    returns:
+        numpy int8 array of shape extent_kji; values are: 0 neither above nor below a K face;
+            1: above any K faces in the column; 2 below any K faces in the column;
+            3: between K faces (one or more above and one or more below)
+    """
+    assert len(extent_kji) == 3
+    limit = extent_kji[0] - 1  # maximum number of iterations needed to spead shadow
+    shadow = np.zeros(extent_kji, dtype = np.int8)
+    shadow[kji0[:, 0], kji0[:, 1], kji0[:, 2]] = 1
+    shadow[kji0[:, 0] + 1, kji0[:, 1], kji0[:, 2]] += 2
+    for _ in range(limit):
+        c = np.logical_and(shadow[:-1] == 0, shadow[1:] == 1)
+        if np.count_nonzero(c) == 0:
+            break
+        shadow[:-1][c] = 1
+    for _ in range(limit):
+        c = np.logical_and(shadow[1:] == 0, shadow[:-1] == 2)
+        if np.count_nonzero(c) == 0:
+            break
+        shadow[1:][c] = 2
+    for _ in range(limit):
+        c = np.logical_and(shadow[:-1] >= 2, shadow[1:] == 1)
+        if np.count_nonzero(c) == 0:
+            break
+        shadow[:-1][c] = 3
+        shadow[1:][c] = 3
+    return shadow
+
+
 def shadow_from_faces(extent_kji, k_faces):
     """Returns a numpy int8 array indicating whether cells are above, below or between K faces.
 
@@ -1177,8 +1538,8 @@ def get_boundary(  # type: ignore
     j_faces: np.ndarray,
     i_faces: np.ndarray,
     grid_extent_kji: Tuple[int, int, int],
-) -> Dict[str, int]:
-    """Cretaes a dictionary of the indices that bound the surface (where the faces are True).
+) -> np.ndarray:
+    """Cretaes a box of the indices that bound the surface (where the faces are True).
 
     arguments:
         k_faces (np.ndarray): a boolean array of which faces represent the surface in the k dimension
@@ -1187,21 +1548,14 @@ def get_boundary(  # type: ignore
         grid_extent_kji (Tuple[int, int, int]): the shape of the grid
 
     returns:
-        boundary (Dict[str, int]): a dictionary of the indices that bound the surface
+        int array of shape (2, 3): bounding box in python protocol (max values have been incremented)
 
     note:
         input faces arrays are for internal grid faces (ie. extent reduced by 1 in axis of faces);
         a buffer slice is included where the surface does not reach the edge of the grid
     """
 
-    boundary = {
-        "k_min": None,
-        "k_max": None,
-        "j_min": None,
-        "j_max": None,
-        "i_min": None,
-        "i_max": None,
-    }
+    boundary = np.zeros((2, 3), dtype = np.int32)
 
     starting = True
 
@@ -1248,26 +1602,72 @@ def get_boundary(  # type: ignore
                 max_i += 1
 
         if starting:
-            boundary["k_min"] = min_k
-            boundary["k_max"] = max_k
-            boundary["j_min"] = min_j
-            boundary["j_max"] = max_j
-            boundary["i_min"] = min_i
-            boundary["i_max"] = max_i
+            boundary[0, 0] = min_k
+            boundary[1, 0] = max_k
+            boundary[0, 1] = min_j
+            boundary[1, 1] = max_j
+            boundary[0, 2] = min_i
+            boundary[1, 2] = max_i
             starting = False
         else:
-            if min_k < boundary["k_min"]:
-                boundary["k_min"] = min_k
-            if max_k > boundary["k_max"]:
-                boundary["k_max"] = max_k
-            if min_j < boundary["j_min"]:
-                boundary["j_min"] = min_j
-            if max_j > boundary["j_max"]:
-                boundary["j_max"] = max_j
-            if min_i < boundary["i_min"]:
-                boundary["i_min"] = min_i
-            if max_i > boundary["i_max"]:
-                boundary["i_max"] = max_i
+            if min_k < boundary[0, 0]:
+                boundary[0, 0] = min_k
+            if max_k > boundary[1, 0]:
+                boundary[1, 0] = max_k
+            if min_j < boundary[0, 1]:
+                boundary[0, 1] = min_j
+            if max_j > boundary[1, 1]:
+                boundary[1, 1] = max_j
+            if min_i < boundary[0, 2]:
+                boundary[0, 2] = min_i
+            if max_i > boundary[1, 2]:
+                boundary[1, 2] = max_i
+
+    boundary[1, :] += 1  # increment max values to give python protocol box
+
+    return boundary  # type: ignore
+
+
+def get_boundary_dict(  # type: ignore
+    k_faces: np.ndarray,
+    j_faces: np.ndarray,
+    i_faces: np.ndarray,
+    grid_extent_kji: Tuple[int, int, int],
+) -> Dict[str, int]:
+    """Cretaes a dictionary of the indices that bound the surface (where the faces are True).
+
+    arguments:
+        k_faces (np.ndarray): a boolean array of which faces represent the surface in the k dimension
+        j_faces (np.ndarray): a boolean array of which faces represent the surface in the j dimension
+        i_faces (np.ndarray): a boolean array of which faces represent the surface in the i dimension
+        grid_extent_kji (Tuple[int, int, int]): the shape of the grid
+
+    returns:
+        boundary (Dict[str, int]): a dictionary of the indices that bound the surface
+
+    note:
+        input faces arrays are for internal grid faces (ie. extent reduced by 1 in axis of faces);
+        a buffer slice is included where the surface does not reach the edge of the grid;
+        max values are not increment, ie. need to be incremented to be used as an upper end of a python range
+    """
+
+    boundary = {
+        "k_min": None,
+        "k_max": None,
+        "j_min": None,
+        "j_max": None,
+        "i_min": None,
+        "i_max": None,
+    }
+
+    box = get_boundary(k_faces, j_faces, i_faces, grid_extent_kji)
+
+    boundary["k_min"] = box[0, 0]
+    boundary["k_max"] = box[1, 0] - 1
+    boundary["j_min"] = box[0, 1]
+    boundary["j_max"] = box[1, 1] - 1
+    boundary["i_min"] = box[0, 2]
+    boundary["i_max"] = box[1, 2] - 1
 
     return boundary  # type: ignore
 
@@ -1279,7 +1679,7 @@ def _where_true(data: np.ndarray):
 
 
 @njit  # pragma: no cover
-def _first_true(array: np.ndarray) -> Optional[int]:  # type: ignore
+def _first_true(array: np.ndarray) -> int:  # type: ignore
     """Returns the index + 1 of the first True value in the array."""
     for idx, val in np.ndenumerate(array):
         if val:
@@ -1370,6 +1770,7 @@ def intersect_numba(
         face_idx[index2] = d2
         face_idx[2 - axis] = face
 
+        # dangerous: relies on indivisible read-modify-write of memory word containing multiple faces elements
         faces[face_idx[0], face_idx[1], face_idx[2]] = True
 
         if return_depths:
@@ -1388,19 +1789,19 @@ def _seed_array(
     k_faces: np.ndarray,
     j_faces: np.ndarray,
     i_faces: np.ndarray,
-    boundary: Tuple[int, int, int, int, int, int],
+    box: np.ndarray,
     array: np.ndarray,
 ) -> Tuple[np.ndarray, int, int, int]:
     """Sets values of the array True up until a face is hit in each direction.
 
     arguments:
-        point (Tuple[int, int, int]): coordinates of the initial seed point.
-        k_faces (np.ndarray): a boolean array of which faces represent the surface in the k dimension.
-        j_faces (np.ndarray): a boolean array of which faces represent the surface in the j dimension.
-        i_faces (np.ndarray): a boolean array of which faces represent the surface in the i dimension.
-        boundary (Tuple[int, int, int, int, int, int]): the boundaries of the surface given in the order
-            (minimum k, maximum k, minimum j, maximum j, minimum i, maximum i).
-        array (np.ndarray): boolean array that will be seeded.
+
+        - point (Tuple[int, int, int]): coordinates of the initial seed point
+        - k_faces (np.ndarray): a boolean array of which faces represent the surface in the k dimension
+        - j_faces (np.ndarray): a boolean array of which faces represent the surface in the j dimension
+        - i_faces (np.ndarray): a boolean array of which faces represent the surface in the i dimension
+        - box (numpy int array of shape (2, 3)): the boundaries of the surface in python protocol
+        - array (np.ndarray): boolean array that will be seeded
 
     returns:
         Tuple containing:
@@ -1412,6 +1813,10 @@ def _seed_array(
             array size in the j direction if there are no j faces.
         - first_i (int): the index of the first i face in the i direction from the seed point or the
             array size in the i direction if there are no i faces.
+
+    note:
+
+        - this function is DEPRECATED as it is no longer in use
     """
     k = point[0]
     j = point[1]
@@ -1419,17 +1824,17 @@ def _seed_array(
 
     first_k = 0
     if k == 0:
-        first_k = _first_true(k_faces[boundary[0]:boundary[1], boundary[2] + j, boundary[4] + i])
+        first_k = _first_true(k_faces[box[0, 0]:box[1, 0] - 1, box[0, 1] + j, box[0, 2] + i])
         array[:first_k, j, i] = True
 
     first_j = 0
     if j == 0:
-        first_j = _first_true(j_faces[boundary[0] + k, boundary[2]:boundary[3], boundary[4] + i])
+        first_j = _first_true(j_faces[box[0, 0] + k, box[0, 1]:box[1, 1] - 1, box[0, 2] + i])
         array[k, :first_j, i] = True
 
     first_i = 0
     if i == 0:
-        first_i = _first_true(i_faces[boundary[0] + k, boundary[2] + j, boundary[4]:boundary[5]])
+        first_i = _first_true(i_faces[box[0, 0] + k, box[0, 1] + j, box[0, 2]:box[1, 2] - 1])
         array[k, j, :first_i] = True
 
     return array, first_k, first_j, first_i
@@ -1441,3 +1846,116 @@ def _all_offsets(crs, k_offsets_list, j_offsets_list, i_offsets_list):
     ji_offsets = np.concatenate((j_offsets_list, i_offsets_list), axis = 0)
     wam.convert_lengths(ji_offsets, crs.xy_units, crs.z_units)
     return np.concatenate((k_offsets_list, ji_offsets), axis = 0)
+
+
+@njit  # pragma: no cover
+def _fill_bisector(bisect: np.ndarray, open_k: np.ndarray, open_j: np.ndarray, open_i: np.ndarray):
+    change = np.zeros(bisect.shape, dtype = np.bool_)
+    nk: int = bisect.shape[0]
+    nj: int = bisect.shape[1]
+    ni: int = bisect.shape[2]
+    going: bool = True
+    while going:
+        going = False
+        change[:] = False
+        for k in range(nk):
+            for j in range(nj):
+                for i in range(ni):
+                    if bisect[k, j, i]:
+                        continue
+                    if ((k and bisect[k - 1, j, i] and open_k[k - 1, j, i]) or
+                        (j and bisect[k, j - 1, i] and open_j[k, j - 1, i]) or
+                        (i and bisect[k, j, i - 1] and open_i[k, j, i - 1]) or
+                        (k < nk - 1 and bisect[k + 1, j, i] and open_k[k, j, i]) or
+                        (j < nj - 1 and bisect[k, j + 1, i] and open_j[k, j, i]) or
+                        (i < ni - 1 and bisect[k, j, i + 1] and open_i[k, j, i])):
+                        bisect[k, j, i] = True
+                        going = True
+                        continue
+
+
+@njit  # pragma: no cover
+def _shallow_or_curtain(a: np.ndarray, true_count: int, raw: bool) -> bool:
+    # negate the bool array if it minimises the mean k and determine if the bisector indicates a curtain
+    assert a.ndim == 3
+    layer_cell_count: int = a.shape[1] * a.shape[2]
+    k_sum: int = 0
+    opposite_k_sum: int = 0
+    is_curtain: bool = False
+    layer_count: int = 0
+    for k in range(a.shape[0]):
+        layer_count = np.count_nonzero(a[k])
+        k_sum += (k + 1) * layer_count
+        opposite_k_sum += (k + 1) * (layer_cell_count - layer_count)
+    mean_k: float = float(k_sum) / float(true_count)
+    opposite_mean_k: float = float(opposite_k_sum) / float(a.size - true_count)
+    if mean_k > opposite_mean_k and not raw:
+        a[:] = np.logical_not(a)
+    if abs(mean_k - opposite_mean_k) <= 0.001:
+        # log.warning('unable to determine which side of surface is shallower')
+        is_curtain = True
+    return is_curtain
+
+
+def _set_bisector_outside_box(a: np.ndarray, box: np.ndarray, box_array: np.ndarray):
+    # set values outside of the bounding box
+    if box[1, 0] < a.shape[0] and np.any(box_array[-1, :, :]):
+        a[box[1, 0]:, :, :] = True
+    if box[0, 0] != 0:
+        a[:box[0, 0], :, :] = True
+    if box[1, 1] < a.shape[1] and np.any(box_array[:, -1, :]):
+        a[:, box[1, 1]:, :] = True
+    if box[0, 1] != 0:
+        a[:, :box[0, 1], :] = True
+    if box[1, 2] < a.shape[2] and np.any(box_array[:, :, -1]):
+        a[:, :, box[1, 2]:] = True
+    if box[0, 2] != 0:
+        a[:, :, :box[0, 2]] = True
+
+
+def _box_face_arrays_from_indices(k_faces: np.ndarray, j_faces: np.ndarray, i_faces: np.ndarray,
+                                  box: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    box_shape = box[1, :] - box[0, :]
+    k_a = np.zeros((box_shape[0] - 1, box_shape[1], box_shape[2]), dtype = np.bool_)
+    j_a = np.zeros((box_shape[0], box_shape[1] - 1, box_shape[2]), dtype = np.bool_)
+    i_a = np.zeros((box_shape[0], box_shape[1], box_shape[2] - 1), dtype = np.bool_)
+    ko = box[0, 0]
+    jo = box[0, 1]
+    io = box[0, 2]
+    _set_face_array(k_a, k_faces, ko, jo, io)
+    _set_face_array(j_a, j_faces, ko, jo, io)
+    _set_face_array(i_a, i_faces, ko, jo, io)
+    return k_a, j_a, i_a
+
+
+@njit  # pragma: no cover
+def _set_face_array(a: np.ndarray, indices: np.ndarray, ko: int, jo: int, io: int):
+    for ind in range(len(indices)):
+        k = indices[ind, 0] - ko
+        j = indices[ind, 1] - jo
+        i = indices[ind, 2] - io
+        a[k, j, i] = True
+
+
+def get_boundary_from_indices(k_faces: np.ndarray, j_faces: np.ndarray, i_faces: np.ndarray,
+                              grid_extent_kji: Tuple[int, int, int]) -> np.ndarray:
+    """Return python protocol box containing indices"""
+    k_min_kji0 = np.min(k_faces, axis = 0)
+    k_max_kji0 = np.max(k_faces, axis = 0)
+    j_min_kji0 = np.min(j_faces, axis = 0)
+    j_max_kji0 = np.max(j_faces, axis = 0)
+    i_min_kji0 = np.min(i_faces, axis = 0)
+    i_max_kji0 = np.max(i_faces, axis = 0)
+    box = np.empty((2, 3), dtype = np.int32)
+    box[0, 0] = min(k_min_kji0[0], j_min_kji0[0], i_min_kji0[0])
+    box[0, 1] = min(k_min_kji0[1], j_min_kji0[1], i_min_kji0[1])
+    box[0, 2] = min(k_min_kji0[2], j_min_kji0[2], i_min_kji0[2])
+    box[1, 0] = max(k_max_kji0[0], j_max_kji0[0], i_max_kji0[0]) + 1
+    box[1, 1] = max(k_max_kji0[1], j_max_kji0[1], i_max_kji0[1]) + 1
+    box[1, 2] = max(k_max_kji0[2], j_max_kji0[2], i_max_kji0[2]) + 1
+    box[0, :] = np.maximum(box[0, :] - 1, 0)
+    # include buffer layer where box does not reach edge of grid
+    extent_kji = np.array(grid_extent_kji, dtype = np.int32)
+    assert np.all(box[1] <= grid_extent_kji)
+    box[1, :] = np.minimum(box[1, :] + 1, extent_kji)
+    return box