resqpy 4.5.0__py3-none-any.whl → 4.6.3__py3-none-any.whl

resqpy/grid_surface/_find_faces.py

@@ -24,7 +24,7 @@ import resqpy.olio.vector_utilities as vec
 # note: resqpy.grid_surface._grid_surface_cuda will be imported by the find_faces_to_represent_surface() function if needed
 
 
-def find_faces_to_represent_surface_staffa(grid, surface, name, feature_type = 'fault', progress_fn = None):
+def find_faces_to_represent_surface_staffa(grid, surface, name, feature_type = "fault", progress_fn = None):
     """Returns a grid connection set containing those cell faces which are deemed to represent the surface.
 
     note:
@@ -92,11 +92,11 @@ def find_faces_to_represent_surface_staffa(grid, surface, name, feature_type = '
     # log.debug('finding surface triangle boxes')
     t, p = surface.triangles_and_points()
     if not bu.matching_uuids(grid.crs_uuid, surface.crs_uuid):
-        log.debug('converting from surface crs to grid crs')
+        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, p)
     triangles = p[t]
-    assert triangles.size > 0, 'no triangles in surface'
+    assert triangles.size > 0, "no triangles in surface"
     triangle_boxes = np.empty((triangles.shape[0], 2, 3))
     triangle_boxes[:, 0, :] = np.amin(triangles, axis = 1)
     triangle_boxes[:, 1, :] = np.amax(triangles, axis = 1)
@@ -120,26 +120,32 @@ def find_faces_to_represent_surface_staffa(grid, surface, name, feature_type = '
                     progress_fn(progress_base + progress_batch * (float(j) / float(grid.nj)))
                 for i in range(grid.ni):
                     if column_k_vector_boxes is not None and bx.boxes_overlap(batch_box, column_k_vector_boxes[j, i]):
-                        full_intersects = meet.line_set_triangles_intersects(centre_points[:-1, j, i],
-                                                                             k_vectors[:, j, i],
-                                                                             triangles[ti_base:ti_end],
-                                                                             line_segment = True)
+                        full_intersects = meet.line_set_triangles_intersects(
+                            centre_points[:-1, j, i],
+                            k_vectors[:, j, i],
+                            triangles[ti_base:ti_end],
+                            line_segment = True,
+                        )
                         distilled_intersects, _, _ = meet.distilled_intersects(full_intersects)
                         k_faces[distilled_intersects, j, i] = True
-                    if j < grid.nj - 1 and column_j_vector_boxes is not None and bx.boxes_overlap(
-                            batch_box, column_j_vector_boxes[j, i]):
-                        full_intersects = meet.line_set_triangles_intersects(centre_points[:, j, i],
-                                                                             j_vectors[:, j, i],
-                                                                             triangles[ti_base:ti_end],
-                                                                             line_segment = True)
+                    if (j < grid.nj - 1 and column_j_vector_boxes is not None and
+                            bx.boxes_overlap(batch_box, column_j_vector_boxes[j, i])):
+                        full_intersects = meet.line_set_triangles_intersects(
+                            centre_points[:, j, i],
+                            j_vectors[:, j, i],
+                            triangles[ti_base:ti_end],
+                            line_segment = True,
+                        )
                         distilled_intersects, _, _ = meet.distilled_intersects(full_intersects)
                         j_faces[distilled_intersects, j, i] = True
-                    if i < grid.ni - 1 and column_i_vector_boxes is not None and bx.boxes_overlap(
-                            batch_box, column_i_vector_boxes[j, i]):
-                        full_intersects = meet.line_set_triangles_intersects(centre_points[:, j, i],
-                                                                             i_vectors[:, j, i],
-                                                                             triangles[ti_base:ti_end],
-                                                                             line_segment = True)
+                    if (i < grid.ni - 1 and column_i_vector_boxes is not None and
+                            bx.boxes_overlap(batch_box, column_i_vector_boxes[j, i])):
+                        full_intersects = meet.line_set_triangles_intersects(
+                            centre_points[:, j, i],
+                            i_vectors[:, j, i],
+                            triangles[ti_base:ti_end],
+                            line_segment = True,
+                        )
                         distilled_intersects, _, _ = meet.distilled_intersects(full_intersects)
                         i_faces[distilled_intersects, j, i] = True
         ti_base = ti_end
@@ -152,14 +158,16 @@ def find_faces_to_represent_surface_staffa(grid, surface, name, feature_type = '
     # log.debug('face counts: K: ' + str(np.count_nonzero(k_faces)) +
     #                      '; J: ' + str(np.count_nonzero(j_faces)) +
     #                      '; I: ' + str(np.count_nonzero(i_faces)))
-    gcs = rqf.GridConnectionSet(grid.model,
-                                grid = grid,
-                                k_faces = k_faces,
-                                j_faces = j_faces,
-                                i_faces = i_faces,
-                                feature_name = name,
-                                feature_type = feature_type,
-                                create_organizing_objects_where_needed = True)
+    gcs = rqf.GridConnectionSet(
+        grid.model,
+        grid = grid,
+        k_faces = k_faces,
+        j_faces = j_faces,
+        i_faces = i_faces,
+        feature_name = name,
+        feature_type = feature_type,
+        create_organizing_objects_where_needed = True,
+    )
 
     if progress_fn is not None:
         progress_fn(1.0)
@@ -167,16 +175,18 @@ def find_faces_to_represent_surface_staffa(grid, surface, name, feature_type = '
     return gcs
 
 
-def find_faces_to_represent_surface_regular(grid,
-                                            surface,
-                                            name,
-                                            title = None,
-                                            centres = None,
-                                            agitate = False,
-                                            feature_type = 'fault',
-                                            progress_fn = None,
-                                            consistent_side = False,
-                                            return_properties = None):
+def find_faces_to_represent_surface_regular(
+    grid,
+    surface,
+    name,
+    title = None,
+    centres = None,
+    agitate = False,
+    feature_type = "fault",
+    progress_fn = None,
+    consistent_side = False,
+    return_properties = None,
+):
     """Returns a grid connection set containing those cell faces which are deemed to represent the surface.
 
     arguments:
@@ -224,9 +234,9 @@ def find_faces_to_represent_surface_regular(grid,
     return_normal_vectors = False
     return_offsets = False
     if return_properties:
-        assert all([p in ['offset', 'normal vector'] for p in return_properties])
-        return_normal_vectors = ('normal vector' in return_properties)
-        return_offsets = ('offset' in return_properties)
+        assert all([p in ["offset", "normal vector"] for p in return_properties])
+        return_normal_vectors = "normal vector" in return_properties
+        return_offsets = "offset" in return_properties
 
     if title is None:
         title = name
@@ -234,34 +244,38 @@ def find_faces_to_represent_surface_regular(grid,
     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}')
+    log.debug(f"intersecting surface {surface.title} with regular grid {grid.title}")
+    log.debug(f"grid extent kji: {grid.extent_kji}")
 
-    grid_dxyz = (grid.block_dxyz_dkji[2, 0], grid.block_dxyz_dkji[1, 1], grid.block_dxyz_dkji[0, 2])
+    grid_dxyz = (
+        grid.block_dxyz_dkji[2, 0],
+        grid.block_dxyz_dkji[1, 1],
+        grid.block_dxyz_dkji[0, 2],
+    )
     if centres is None:
         centres = grid.centre_point(use_origin = True)
     if consistent_side:
-        log.debug('making all triangles clockwise')
+        log.debug("making all triangles clockwise")
         # note: following will shuffle order of vertices within t cached in surface
         surface.make_all_clockwise_xy(reorient = True)
     t, p = surface.triangles_and_points()
-    assert t is not None and p is not None, f'surface {surface.title} is empty'
+    assert t is not None and p is not None, f"surface {surface.title} is empty"
     if agitate:
         p += 1.0e-5 * (np.random.random(p.shape) - 0.5)
-    log.debug(f'surface: {surface.title}; p0: {p[0]}; crs uuid: {surface.crs_uuid}')
-    log.debug(f'surface min xyz: {np.min(p, axis = 0)}')
-    log.debug(f'surface max xyz: {np.max(p, axis = 0)}')
+    log.debug(f"surface: {surface.title}; p0: {p[0]}; crs uuid: {surface.crs_uuid}")
+    log.debug(f"surface min xyz: {np.min(p, axis = 0)}")
+    log.debug(f"surface max xyz: {np.max(p, axis = 0)}")
     if not bu.matching_uuids(grid.crs_uuid, surface.crs_uuid):
-        log.debug('converting from surface crs to grid crs')
+        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, p)
         surface.crs_uuid = grid.crs.uuid
-        log.debug(f'surface: {surface.title}; p0: {p[0]}; crs uuid: {surface.crs_uuid}')
-        log.debug(f'surface min xyz: {np.min(p, axis = 0)}')
-        log.debug(f'surface max xyz: {np.max(p, axis = 0)}')
+        log.debug(f"surface: {surface.title}; p0: {p[0]}; crs uuid: {surface.crs_uuid}")
+        log.debug(f"surface min xyz: {np.min(p, axis = 0)}")
+        log.debug(f"surface max xyz: {np.max(p, axis = 0)}")
 
-    log.debug(f'centres min xyz: {np.min(centres.reshape((-1, 3)), axis = 0)}')
-    log.debug(f'centres max xyz: {np.max(centres.reshape((-1, 3)), axis = 0)}')
+    log.debug(f"centres min xyz: {np.min(centres.reshape((-1, 3)), axis = 0)}")
+    log.debug(f"centres max xyz: {np.max(centres.reshape((-1, 3)), axis = 0)}")
 
     t_count = len(t)
 
@@ -269,23 +283,25 @@ def find_faces_to_represent_surface_regular(grid,
 
     # K direction (xy projection)
     if grid.nk > 1:
-        log.debug('searching for k faces')
+        log.debug("searching for k faces")
         k_faces = np.zeros((grid.nk - 1, grid.nj, grid.ni), dtype = bool)
         k_sides = np.zeros((grid.nk - 1, grid.nj, grid.ni), dtype = bool)
-        k_offsets = np.full((grid.nk - 1, grid.nj, grid.ni), np.nan) if return_offsets else None
-        k_normals = np.full((grid.nk - 1, grid.nj, grid.ni, 3), np.nan) if return_normal_vectors else None
+        k_offsets = (np.full((grid.nk - 1, grid.nj, grid.ni), np.nan) if return_offsets else None)
+        k_normals = (np.full((grid.nk - 1, grid.nj, grid.ni, 3), np.nan) if return_normal_vectors else None)
         k_centres = centres[0, :, :].reshape((-1, 3))
-        k_hits = vec.points_in_triangles(p, t, k_centres, projection = 'xy', edged = True).reshape(
+        k_hits = vec.points_in_triangles(p, t, k_centres, projection = "xy", edged = True).reshape(
             (t_count, grid.nj, grid.ni))
         del k_centres
         if consistent_side:
-            cwt = (vec.clockwise_triangles(p, t, projection = 'xy') >= 0.0)
+            cwt = vec.clockwise_triangles(p, t, projection = "xy") >= 0.0
         for k_t, k_j, k_i in np.stack(np.where(k_hits), axis = -1):
-            xyz = meet.line_triangle_intersect(centres[0, k_j, k_i],
-                                               centres[-1, k_j, k_i] - centres[0, k_j, k_i],
-                                               p[t[k_t]],
-                                               line_segment = True,
-                                               t_tol = 1.0e-6)
+            xyz = meet.line_triangle_intersect(
+                centres[0, k_j, k_i],
+                centres[-1, k_j, k_i] - centres[0, k_j, k_i],
+                p[t[k_t]],
+                line_segment = True,
+                t_tol = 1.0e-6,
+            )
             if xyz is None:  # meeting point is outwith grid
                 continue
             k_face = int((xyz[2] - centres[0, k_j, k_i, 2]) / grid_dxyz[2])
@@ -299,15 +315,15 @@ def find_faces_to_represent_surface_regular(grid,
                 k_sides[k_face, k_j, k_i] = cwt[k_t]
             if return_offsets:
                 # compute offset as z diff between xyz and face
-                k_offsets[k_face, k_j, k_i] =  \
-                    xyz[2] - 0.5 * (centres[k_face, k_j, k_i, 2] + centres[k_face + 1, k_j, k_i, 2])
+                k_offsets[k_face, k_j,
+                          k_i] = xyz[2] - 0.5 * (centres[k_face, k_j, k_i, 2] + centres[k_face + 1, k_j, k_i, 2])
             if return_normal_vectors:
                 k_normals[k_face, k_j, k_i] = vec.triangle_normal_vector(p[t[k_t]])
                 # todo: if consistent side, could deliver information about horizon surface inversion
                 if k_normals[k_face, k_j, k_i, 2] > 0.0:
                     k_normals[k_face, k_j, k_i] = -k_normals[k_face, k_j, k_i]  # -ve z hemisphere normal
         del k_hits
-        log.debug(f'k face count: {np.count_nonzero(k_faces)}')
+        log.debug(f"k face count: {np.count_nonzero(k_faces)}")
     else:
         k_faces = None
         k_sides = None
@@ -318,23 +334,25 @@ def find_faces_to_represent_surface_regular(grid,
 
     # J direction (xz projection)
     if grid.nj > 1:
-        log.debug('searching for j faces')
+        log.debug("searching for j faces")
         j_faces = np.zeros((grid.nk, grid.nj - 1, grid.ni), dtype = bool)
         j_sides = np.zeros((grid.nk, grid.nj - 1, grid.ni), dtype = bool)
-        j_offsets = np.full((grid.nk, grid.nj - 1, grid.ni), np.nan) if return_offsets else None
-        j_normals = np.full((grid.nk, grid.nj - 1, grid.ni, 3), np.nan) if return_normal_vectors else None
+        j_offsets = (np.full((grid.nk, grid.nj - 1, grid.ni), np.nan) if return_offsets else None)
+        j_normals = (np.full((grid.nk, grid.nj - 1, grid.ni, 3), np.nan) if return_normal_vectors else None)
         j_centres = centres[:, 0, :].reshape((-1, 3))
-        j_hits = vec.points_in_triangles(p, t, j_centres, projection = 'xz', edged = True).reshape(
+        j_hits = vec.points_in_triangles(p, t, j_centres, projection = "xz", edged = True).reshape(
             (t_count, grid.nk, grid.ni))
         del j_centres
         if consistent_side:
-            cwt = (vec.clockwise_triangles(p, t, projection = 'xz') >= 0.0)
+            cwt = vec.clockwise_triangles(p, t, projection = "xz") >= 0.0
         for j_t, j_k, j_i in np.stack(np.where(j_hits), axis = -1):
-            xyz = meet.line_triangle_intersect(centres[j_k, 0, j_i],
-                                               centres[j_k, -1, j_i] - centres[j_k, 0, j_i],
-                                               p[t[j_t]],
-                                               line_segment = True,
-                                               t_tol = 1.0e-6)
+            xyz = meet.line_triangle_intersect(
+                centres[j_k, 0, j_i],
+                centres[j_k, -1, j_i] - centres[j_k, 0, j_i],
+                p[t[j_t]],
+                line_segment = True,
+                t_tol = 1.0e-6,
+            )
             if xyz is None:  # meeting point is outwith grid
                 continue
             j_face = int((xyz[1] - centres[j_k, 0, j_i, 1]) / grid_dxyz[1])
@@ -348,14 +366,14 @@ def find_faces_to_represent_surface_regular(grid,
                 j_sides[j_k, j_face, j_i] = cwt[j_t]
             if return_offsets:
                 # compute offset as y diff between xyz and face
-                j_offsets[j_k, j_face, j_i] =  \
-                    xyz[1] - 0.5 * (centres[j_k, j_face, j_i, 1] + centres[j_k, j_face + 1, j_i, 1])
+                j_offsets[j_k, j_face,
+                          j_i] = xyz[1] - 0.5 * (centres[j_k, j_face, j_i, 1] + centres[j_k, j_face + 1, j_i, 1])
             if return_normal_vectors:
                 j_normals[j_k, j_face, j_i] = vec.triangle_normal_vector(p[t[j_t]])
                 if j_normals[j_k, j_face, j_i, 2] > 0.0:
                     j_normals[j_k, j_face, j_i] = -j_normals[j_k, j_face, j_i]  # -ve z hemisphere normal
         del j_hits
-        log.debug(f'j face count: {np.count_nonzero(j_faces)}')
+        log.debug(f"j face count: {np.count_nonzero(j_faces)}")
     else:
         j_faces = None
         j_sides = None
@@ -366,23 +384,25 @@ def find_faces_to_represent_surface_regular(grid,
 
     # I direction (yz projection)
     if grid.ni > 1:
-        log.debug('searching for i faces')
+        log.debug("searching for i faces")
         i_faces = np.zeros((grid.nk, grid.nj, grid.ni - 1), dtype = bool)
         i_sides = np.zeros((grid.nk, grid.nj, grid.ni - 1), dtype = bool)
-        i_offsets = np.full((grid.nk, grid.nj, grid.ni - 1), np.nan) if return_offsets else None
-        i_normals = np.full((grid.nk, grid.nj, grid.ni - 1, 3), np.nan) if return_normal_vectors else None
+        i_offsets = (np.full((grid.nk, grid.nj, grid.ni - 1), np.nan) if return_offsets else None)
+        i_normals = (np.full((grid.nk, grid.nj, grid.ni - 1, 3), np.nan) if return_normal_vectors else None)
         i_centres = centres[:, :, 0].reshape((-1, 3))
-        i_hits = vec.points_in_triangles(p, t, i_centres, projection = 'yz', edged = True).reshape(
+        i_hits = vec.points_in_triangles(p, t, i_centres, projection = "yz", edged = True).reshape(
             (t_count, grid.nk, grid.nj))
         del i_centres
         if consistent_side:
-            cwt = (vec.clockwise_triangles(p, t, projection = 'yz') >= 0.0)
+            cwt = vec.clockwise_triangles(p, t, projection = "yz") >= 0.0
         for i_t, i_k, i_j in np.stack(np.where(i_hits), axis = -1):
-            xyz = meet.line_triangle_intersect(centres[i_k, i_j, 0],
-                                               centres[i_k, i_j, -1] - centres[i_k, i_j, 0],
-                                               p[t[i_t]],
-                                               line_segment = True,
-                                               t_tol = 1.0e-6)
+            xyz = meet.line_triangle_intersect(
+                centres[i_k, i_j, 0],
+                centres[i_k, i_j, -1] - centres[i_k, i_j, 0],
+                p[t[i_t]],
+                line_segment = True,
+                t_tol = 1.0e-6,
+            )
             if xyz is None:  # meeting point is outwith grid
                 continue
             i_face = int((xyz[0] - centres[i_k, i_j, 0, 0]) / grid_dxyz[0])
@@ -396,14 +416,14 @@ def find_faces_to_represent_surface_regular(grid,
                 i_sides[i_k, i_j, i_face] = cwt[i_t]
             if return_offsets:
                 # compute offset as x diff between xyz and face
-                i_offsets[i_k, i_j, i_face] =  \
-                    xyz[0] - 0.5 * (centres[i_k, i_j, i_face, 0] + centres[i_k, i_j, i_face + 1, 0])
+                i_offsets[i_k, i_j,
+                          i_face] = xyz[0] - 0.5 * (centres[i_k, i_j, i_face, 0] + centres[i_k, i_j, i_face + 1, 0])
             if return_normal_vectors:
                 i_normals[i_k, i_j, i_face] = vec.triangle_normal_vector(p[t[i_t]])
                 if i_normals[i_k, i_j, i_face, 2] > 0.0:
                     i_normals[i_k, i_j, i_face] = -i_normals[i_k, i_j, i_face]  # -ve z hemisphere normal
         del i_hits
-        log.debug(f'i face count: {np.count_nonzero(i_faces)}')
+        log.debug(f"i face count: {np.count_nonzero(i_faces)}")
     else:
         i_faces = None
         i_sides = None
@@ -417,36 +437,38 @@ def find_faces_to_represent_surface_regular(grid,
         j_sides = None
         i_sides = None
 
-    log.debug('converting face sets into grid connection set')
-    gcs = rqf.GridConnectionSet(grid.model,
-                                grid = grid,
-                                k_faces = k_faces,
-                                j_faces = j_faces,
-                                i_faces = i_faces,
-                                k_sides = k_sides,
-                                j_sides = j_sides,
-                                i_sides = i_sides,
-                                feature_name = name,
-                                feature_type = feature_type,
-                                title = title,
-                                create_organizing_objects_where_needed = True)
+    log.debug("converting face sets into grid connection set")
+    gcs = rqf.GridConnectionSet(
+        grid.model,
+        grid = grid,
+        k_faces = k_faces,
+        j_faces = j_faces,
+        i_faces = i_faces,
+        k_sides = k_sides,
+        j_sides = j_sides,
+        i_sides = i_sides,
+        feature_name = name,
+        feature_type = feature_type,
+        title = title,
+        create_organizing_objects_where_needed = True,
+    )
 
     # NB. following assumes faces have been added to gcs in a particular order!
     if return_offsets:
-        k_offsets_list = np.empty((0,)) if k_offsets is None else k_offsets[np.where(k_faces)]
-        j_offsets_list = np.empty((0,)) if j_offsets is None else j_offsets[np.where(j_faces)]
-        i_offsets_list = np.empty((0,)) if i_offsets is None else i_offsets[np.where(i_faces)]
+        k_offsets_list = (np.empty((0,)) if k_offsets is None else k_offsets[np.where(k_faces)])
+        j_offsets_list = (np.empty((0,)) if j_offsets is None else j_offsets[np.where(j_faces)])
+        i_offsets_list = (np.empty((0,)) if i_offsets is None else i_offsets[np.where(i_faces)])
         all_offsets = _all_offsets(grid.crs, k_offsets_list, j_offsets_list, i_offsets_list)
-        log.debug(f'gcs count: {gcs.count}; all offsets shape: {all_offsets.shape}')
+        log.debug(f"gcs count: {gcs.count}; all offsets shape: {all_offsets.shape}")
         assert all_offsets.shape == (gcs.count,)
 
     # NB. following assumes faces have been added to gcs in a particular order!
     if return_normal_vectors:
-        k_normals_list = np.empty((0, 3)) if k_normals is None else k_normals[np.where(k_faces)]
-        j_normals_list = np.empty((0, 3)) if j_normals is None else j_normals[np.where(j_faces)]
-        i_normals_list = np.empty((0, 3)) if i_normals is None else i_normals[np.where(i_faces)]
+        k_normals_list = (np.empty((0, 3)) if k_normals is None else k_normals[np.where(k_faces)])
+        j_normals_list = (np.empty((0, 3)) if j_normals is None else j_normals[np.where(j_faces)])
+        i_normals_list = (np.empty((0, 3)) if i_normals is None else i_normals[np.where(i_faces)])
         all_normals = np.concatenate((k_normals_list, j_normals_list, i_normals_list), axis = 0)
-        log.debug(f'gcs count: {gcs.count}; all normals shape: {all_normals.shape}')
+        log.debug(f"gcs count: {gcs.count}; all normals shape: {all_normals.shape}")
         assert all_normals.shape == (gcs.count, 3)
         if grid.crs.xy_units != grid.crs.z_units:
             wam.convert_lengths(all_normals[:, 2], grid.crs.z_units, grid.crs.xy_units)
@@ -459,24 +481,26 @@ def find_faces_to_represent_surface_regular(grid,
     if return_properties:
         props_dict = {}
         if return_offsets:
-            props_dict['offset'] = all_offsets
+            props_dict["offset"] = all_offsets
         if return_normal_vectors:
-            props_dict['normal vector'] = all_normals
+            props_dict["normal vector"] = all_normals
         return (gcs, props_dict)
 
     return gcs
 
 
-def find_faces_to_represent_surface_regular_optimised(grid,
-                                                      surface,
-                                                      name,
-                                                      title = None,
-                                                      agitate = False,
-                                                      feature_type = 'fault',
-                                                      is_curtain = False,
-                                                      progress_fn = None,
-                                                      return_properties = None,
-                                                      raw_bisector = False):
+def find_faces_to_represent_surface_regular_optimised(
+    grid,
+    surface,
+    name,
+    title = None,
+    agitate = False,
+    feature_type = "fault",
+    is_curtain = False,
+    progress_fn = None,
+    return_properties = None,
+    raw_bisector = False,
+):
     """Returns a grid connection set containing those cell faces which are deemed to represent the surface.
 
     argumants:
@@ -532,15 +556,21 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     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
+            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)
+        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
 
@@ -550,25 +580,29 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     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"intersecting surface {surface.title} with regular grid {grid.title}")
     # log.debug(f'grid extent kji: {grid.extent_kji}')
 
-    grid_dxyz = (grid.block_dxyz_dkji[2, 0], grid.block_dxyz_dkji[1, 1], grid.block_dxyz_dkji[0, 2])
+    grid_dxyz = (
+        grid.block_dxyz_dkji[2, 0],
+        grid.block_dxyz_dkji[1, 1],
+        grid.block_dxyz_dkji[0, 2],
+    )
     triangles, points = surface.triangles_and_points()
-    assert triangles is not None and points is not None, f'surface {surface.title} is empty'
+    assert (triangles is not None and points is not None), f"surface {surface.title} is empty"
     if agitate:
         points += 1.0e-5 * (np.random.random(points.shape) - 0.5)
-    # log.debug(f'surface: {surface.title}; p0: {points[0]}; crs uuid: {surface.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)}')
     if not bu.matching_uuids(grid.crs_uuid, surface.crs_uuid):
-        log.debug('converting from surface crs to grid crs')
+        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)}')
+        # log.debug(f'surface max xyz: {np.max(points, axis = 0)}')
 
     nk = 1 if is_curtain else grid.nk
     # K direction (xy projection)
@@ -586,11 +620,23 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         axis = 2
         index1 = 1
         index2 = 2
-        k_faces, k_offsets, k_triangles =  \
-            intersect_numba(axis, index1, index2, k_hits, nk, points,
-                            triangles, grid_dxyz, k_faces,
-                            return_depths, k_depths,
-                            return_offsets, k_offsets, return_triangles, k_triangles)
+        k_faces, k_offsets, k_triangles = intersect_numba(
+            axis,
+            index1,
+            index2,
+            k_hits,
+            nk,
+            points,
+            triangles,
+            grid_dxyz,
+            k_faces,
+            return_depths,
+            k_depths,
+            return_offsets,
+            k_offsets,
+            return_triangles,
+            k_triangles,
+        )
         del k_hits
         del p_xy
         log.debug(f"k face count: {np.count_nonzero(k_faces)}")
@@ -617,11 +663,23 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         axis = 1
         index1 = 0
         index2 = 2
-        j_faces, j_offsets, j_triangles =  \
-            intersect_numba(axis, index1, index2, j_hits, grid.nj, points,
-                            triangles, grid_dxyz, j_faces,
-                            return_depths, j_depths,
-                            return_offsets, j_offsets, return_triangles, j_triangles)
+        j_faces, j_offsets, j_triangles = intersect_numba(
+            axis,
+            index1,
+            index2,
+            j_hits,
+            grid.nj,
+            points,
+            triangles,
+            grid_dxyz,
+            j_faces,
+            return_depths,
+            j_depths,
+            return_offsets,
+            j_offsets,
+            return_triangles,
+            j_triangles,
+        )
         del j_hits
         del p_xz
         if is_curtain and grid.nk > 1:  # expand arrays to all layers
@@ -653,11 +711,23 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         axis = 0
         index1 = 0
         index2 = 1
-        i_faces, i_offsets, i_triangles =  \
-            intersect_numba(axis, index1, index2, i_hits, grid.ni, points,
-                            triangles, grid_dxyz, i_faces,
-                            return_depths, i_depths,
-                            return_offsets, i_offsets, return_triangles, i_triangles)
+        i_faces, i_offsets, i_triangles = intersect_numba(
+            axis,
+            index1,
+            index2,
+            i_hits,
+            grid.ni,
+            points,
+            triangles,
+            grid_dxyz,
+            i_faces,
+            return_depths,
+            i_depths,
+            return_offsets,
+            i_offsets,
+            return_triangles,
+            i_triangles,
+        )
         del i_hits
         del p_yz
         if is_curtain and grid.nk > 1:  # expand arrays to all layers
@@ -696,9 +766,9 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     # NB. following assumes faces have been added to gcs in a particular order!
     if return_triangles:
         # log.debug('preparing triangles array')
-        k_tri_list = np.empty((0,)) if k_triangles is None else k_triangles[where_true(k_faces)]
-        j_tri_list = np.empty((0,)) if j_triangles is None else j_triangles[where_true(j_faces)]
-        i_tri_list = np.empty((0,)) if i_triangles is None else i_triangles[where_true(i_faces)]
+        k_tri_list = (np.empty((0,)) if k_triangles is None else k_triangles[_where_true(k_faces)])
+        j_tri_list = (np.empty((0,)) if j_triangles is None else j_triangles[_where_true(j_faces)])
+        i_tri_list = (np.empty((0,)) if i_triangles is None else i_triangles[_where_true(i_faces)])
         all_tris = np.concatenate((k_tri_list, j_tri_list, i_tri_list), axis = 0)
         # log.debug(f'gcs count: {gcs.count}; all triangles shape: {all_tris.shape}')
         assert all_tris.shape == (gcs.count,)
@@ -706,9 +776,9 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     # NB. following assumes faces have been added to gcs in a particular order!
     if return_depths:
         # log.debug('preparing depths array')
-        k_depths_list = np.empty((0,)) if k_depths is None else k_depths[where_true(k_faces)]
-        j_depths_list = np.empty((0,)) if j_depths is None else j_depths[where_true(j_faces)]
-        i_depths_list = np.empty((0,)) if i_depths is None else i_depths[where_true(i_faces)]
+        k_depths_list = (np.empty((0,)) if k_depths is None else k_depths[_where_true(k_faces)])
+        j_depths_list = (np.empty((0,)) if j_depths is None else j_depths[_where_true(j_faces)])
+        i_depths_list = (np.empty((0,)) if i_depths is None else i_depths[_where_true(i_faces)])
         all_depths = np.concatenate((k_depths_list, j_depths_list, i_depths_list), axis = 0)
         # log.debug(f'gcs count: {gcs.count}; all depths shape: {all_depths.shape}')
         assert all_depths.shape == (gcs.count,)
@@ -716,19 +786,19 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     # NB. following assumes faces have been added to gcs in a particular order!
     if return_offsets:
         # log.debug('preparing offsets array')
-        k_offsets_list = np.empty((0,)) if k_offsets is None else k_offsets[where_true(k_faces)]
-        j_offsets_list = np.empty((0,)) if j_offsets is None else j_offsets[where_true(j_faces)]
-        i_offsets_list = np.empty((0,)) if i_offsets is None else i_offsets[where_true(i_faces)]
+        k_offsets_list = (np.empty((0,)) if k_offsets is None else k_offsets[_where_true(k_faces)])
+        j_offsets_list = (np.empty((0,)) if j_offsets is None else j_offsets[_where_true(j_faces)])
+        i_offsets_list = (np.empty((0,)) if i_offsets is None else i_offsets[_where_true(i_faces)])
         all_offsets = _all_offsets(grid.crs, k_offsets_list, j_offsets_list, i_offsets_list)
         # 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',
+        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}"
+        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()
         all_flange = np.take(flange_array, all_tris)
@@ -737,46 +807,46 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     # note: following is a grid cells property, not a gcs property
     if return_bisector:
         if is_curtain:
-            log.debug('preparing columns bisector')
+            log.debug("preparing columns bisector")
             bisector = column_bisector_from_faces((grid.nj, grid.ni), j_faces[0], i_faces[0])
             # log.debug('finished preparing columns bisector')
         else:
-            log.debug('preparing cells bisector')
+            log.debug("preparing cells bisector")
             bisector, is_curtain = bisector_from_faces(tuple(grid.extent_kji), k_faces, j_faces, i_faces, raw_bisector)
             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')
+        log.debug("preparing cells shadow")
         shadow = shadow_from_faces(tuple(grid.extent_kji), k_faces)
 
     if progress_fn is not None:
         progress_fn(1.0)
 
-    log.debug(f'finishing find_faces_to_represent_surface_regular_optimised for {name}')
+    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
+            props_dict["triangle"] = all_tris
         if return_depths:
-            props_dict['depth'] = all_depths
+            props_dict["depth"] = all_depths
         if return_offsets:
-            props_dict['offset'] = all_offsets
+            props_dict["offset"] = all_offsets
         if return_bisector:
-            props_dict['grid bisector'] = (bisector, is_curtain)
+            props_dict["grid bisector"] = (bisector, is_curtain)
         if return_shadow:
-            props_dict['grid shadow'] = shadow
+            props_dict["grid shadow"] = shadow
         if return_flange_bool:
-            props_dict['flange bool'] = all_flange
+            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):
+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.
 
     arguments:
@@ -797,44 +867,49 @@ def find_faces_to_represent_surface(grid, surface, name, mode = 'auto', feature_
         this is a wrapper function selecting between more specialised functions; use those directly for more options
     """
 
-    log.debug('finding cell faces for surface')
-    if mode == 'auto':
+    log.debug("finding cell faces for surface")
+    if mode == "auto":
         if isinstance(grid, grr.RegularGrid) and grid.is_aligned:
-            mode = 'regular_optimised'
+            mode = "regular_optimised"
         else:
-            mode = 'staffa'
-    if mode == 'staffa':
+            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':
+    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':
+    elif mode == "regular_optimised":
         return find_faces_to_represent_surface_regular_optimised(grid,
                                                                  surface,
                                                                  name,
                                                                  feature_type = feature_type,
                                                                  progress_fn = progress_fn)
-    elif mode == 'regular_cuda':
+    elif mode == "regular_cuda":
         import resqpy.grid_surface.grid_surface_cuda as rgs_c
+
         return rgs_c.find_faces_to_represent_surface_regular_cuda_mgpu(grid,
                                                                        surface,
                                                                        name,
                                                                        feature_type = feature_type,
                                                                        progress_fn = progress_fn)
-    log.critical('unrecognised mode: ' + str(mode))
+    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,
+) -> Tuple[np.ndarray, bool]:
     """Creates a boolean array denoting the bisection of the grid by the face sets.
 
     arguments:
@@ -861,9 +936,14 @@ def bisector_from_faces(  # type: ignore
     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_)
+    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_,
+    )
 
     # Seeding the bisector array from (0, 0, 0) up to the first faces that represent the surface.
     boundary_values = tuple(boundary.values())
@@ -886,19 +966,25 @@ def bisector_from_faces(  # type: ignore
                         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)
+                            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.
     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]
+                                     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]
+                                     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"]]
+                                     boundary["i_min"]:boundary["i_max"],]
     while True:
         changing_array[:] = False
 
@@ -927,7 +1013,7 @@ def bisector_from_faces(  # type: ignore
     # Setting up the full bisectors array and assigning the bounding box values.
     array = np.zeros(grid_extent_kji, dtype = np.bool_)
     array[boundary["k_min"]:boundary["k_max"] + 1, boundary["j_min"]:boundary["j_max"] + 1,
-          boundary["i_min"]:boundary["i_max"] + 1] = bounding_array
+          boundary["i_min"]:boundary["i_max"] + 1,] = bounding_array
 
     # Setting values outside of the bounding box.
     if boundary["k_max"] != grid_extent_kji[0] - 1 and np.any(bounding_array[-1, :, :]):
@@ -946,7 +1032,7 @@ 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).'
+    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]
@@ -1005,7 +1091,7 @@ def column_bisector_from_faces(grid_extent_ji: Tuple[int, int], j_faces: np.ndar
         # j faces
         c[1:, :] = np.logical_or(c[1:, :], np.logical_and(a[:-1, :], open_j))
         c[:-1, :] = np.logical_or(c[:-1, :], np.logical_and(a[1:, :], open_j))
-        # i faces
+        # i faces
         c[:, 1:] = np.logical_or(c[:, 1:], np.logical_and(a[:, :-1], open_i))
         c[:, :-1] = np.logical_or(c[:, :-1], np.logical_and(a[:, 1:], open_i))
         c[:] = np.logical_and(c, np.logical_not(a))
@@ -1013,7 +1099,7 @@ def column_bisector_from_faces(grid_extent_ji: Tuple[int, int], j_faces: np.ndar
             break
         a[:] = np.logical_or(a, c)
     if np.all(a):
-        log.warning('curtain is leaky or misses grid when setting column bisector')
+        log.warning("curtain is leaky or misses grid when setting column bisector")
     # log.debug(f'returning bisector with count: {np.count_nonzero(a)} of {a.size}; shape: {a.shape}')
     return a
 
@@ -1055,8 +1141,11 @@ def shadow_from_faces(extent_kji, k_faces):
 
 
 def get_boundary(  # type: ignore
-        k_faces: np.ndarray, j_faces: np.ndarray, i_faces: np.ndarray, grid_extent_kji: Tuple[int, int,
-                                                                                              int]) -> Dict[str, int]:
+    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:
@@ -1086,24 +1175,24 @@ def get_boundary(  # type: ignore
 
     for f_i, faces in enumerate([k_faces, j_faces, i_faces]):
 
-        # NB. k, j & i for rest of loop refer to indices of faces, regardless of which face set is being processed
+        # NB. k, j & i for rest of loop refer to indices of faces, regardless of which face set is being processed
 
-        where_k, where_j, where_i = where_true(faces)
+        where_k, where_j, where_i = _where_true(faces)
 
         if len(where_k) == 0:
             continue
 
         min_k = where_k[0]  # optimisation if np.where() guaranteed to return results in natural order
         max_k = where_k[-1]
-        # min_k = np.amin(where_k)
-        # max_k = np.amax(where_k)
+        # min_k = np.amin(where_k)
+        # max_k = np.amax(where_k)
         min_j = np.amin(where_j)
         max_j = np.amax(where_j)
         min_i = np.amin(where_i)
         max_i = np.amax(where_i)
 
         # include cells on both sides of internal faces
-        # and add buffer slice where edge of grid not reached by surface faces
+        # and add buffer slice where edge of grid not reached by surface faces
         if f_i == 0:
             max_k += 1
         else:
@@ -1127,38 +1216,38 @@ 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["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
             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["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
 
     return boundary  # type: ignore
 
 
-@njit
-def where_true(data: np.ndarray):
+@njit  # pragma: no cover
+def _where_true(data: np.ndarray):
     """Jitted NumPy 'where' function to improve performance on subsequent calls."""
     return np.where(data)
 
 
-@njit
-def first_true(array: np.ndarray) -> Optional[int]:  # type: ignore
+@njit  # pragma: no cover
+def _first_true(array: np.ndarray) -> Optional[int]:  # type: ignore
     """Returns the index + 1 of the first True value in the array."""
     for idx, val in np.ndenumerate(array):
         if val:
@@ -1166,11 +1255,24 @@ def first_true(array: np.ndarray) -> Optional[int]:  # type: ignore
     return array.size
 
 
-@njit
-def intersect_numba(axis: int, index1: int, index2: int, hits: np.ndarray, n_axis: int, points: np.ndarray,
-                    triangles: np.ndarray, grid_dxyz: Tuple[float], faces: np.ndarray, return_depths: bool,
-                    depths: np.ndarray, return_offsets: bool, offsets: np.ndarray, return_triangles: bool,
-                    triangle_per_face: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+@njit  # pragma: no cover
+def intersect_numba(
+    axis: int,
+    index1: int,
+    index2: int,
+    hits: np.ndarray,
+    n_axis: int,
+    points: np.ndarray,
+    triangles: np.ndarray,
+    grid_dxyz: Tuple[float],
+    faces: np.ndarray,
+    return_depths: bool,
+    depths: np.ndarray,
+    return_offsets: bool,
+    offsets: np.ndarray,
+    return_triangles: bool,
+    triangle_per_face: np.ndarray,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Finds the faces that intersect the surface in 3D.
 
     arguments:
@@ -1204,12 +1306,12 @@ def intersect_numba(axis: int, index1: int, index2: int, hits: np.ndarray, n_axi
     for i in prange(len(hits)):
         tri, d1, d2 = hits[i]
 
-        # Line start point in 3D which had a projection hit.
+        # Line start point in 3D which had a projection hit.
         centre_point_start = np.zeros(3, dtype = np.float64) + grid_dxyz[axis] / 2
         centre_point_start[2 - index1] = (d1 + 0.5) * grid_dxyz[2 - index1]
         centre_point_start[2 - index2] = (d2 + 0.5) * grid_dxyz[2 - index2]
 
-        # Line end point in 3D.
+        # Line end point in 3D.
         centre_point_end = np.copy(centre_point_start)
         centre_point_end[axis] = grid_dxyz[axis] * (n_axis - 0.5)
 
@@ -1248,9 +1350,15 @@ def intersect_numba(axis: int, index1: int, index2: int, hits: np.ndarray, n_axi
     return faces, offsets, triangle_per_face
 
 
-@njit
-def _seed_array(point: Tuple[int, int, int], k_faces: np.ndarray, j_faces: np.ndarray, i_faces: np.ndarray,
-                boundary: Tuple[int, int, int, int, int, int], array: np.ndarray) -> Tuple[np.ndarray, int, int, int]:
+@njit  # pragma: no cover
+def _seed_array(
+    point: Tuple[int, int, int],
+    k_faces: np.ndarray,
+    j_faces: np.ndarray,
+    i_faces: np.ndarray,
+    boundary: Tuple[int, int, int, int, int, int],
+    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:
@@ -1279,17 +1387,17 @@ def _seed_array(point: Tuple[int, int, int], k_faces: np.ndarray, j_faces: np.nd
 
     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[boundary[0]:boundary[1], boundary[2] + j, boundary[4] + 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[boundary[0] + k, boundary[2]:boundary[3], boundary[4] + 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[boundary[0] + k, boundary[2] + j, boundary[4]:boundary[5]])
         array[k, j, :first_i] = True
 
     return array, first_k, first_j, first_i