resqpy 4.16.7__tar.gz → 4.16.8__tar.gz

{resqpy-4.16.7 → resqpy-4.16.8}/PKG-INFO

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

{resqpy-4.16.7 → resqpy-4.16.8}/pyproject.toml

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

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/__init__.py

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

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/fault/_gcs_functions.py

@@ -423,15 +423,15 @@ def combined_tr_mult_from_gcs_mults(model,
 
         if grid is None:  # first gcs: grab grid and initialise combined tr mult arrays
             grid = gcs.grid_list[0]
-            combo_trm_k = np.full((grid.nk + 1, grid.nj, grid.ni), np.NaN, dtype = float)
-            combo_trm_j = np.full((grid.nk, grid.nj + 1, grid.ni), np.NaN, dtype = float)
-            combo_trm_i = np.full((grid.nk, grid.nj, grid.ni + 1), np.NaN, dtype = float)
+            combo_trm_k = np.full((grid.nk + 1, grid.nj, grid.ni), np.nan, dtype = float)
+            combo_trm_j = np.full((grid.nk, grid.nj + 1, grid.ni), np.nan, dtype = float)
+            combo_trm_i = np.full((grid.nk, grid.nj, grid.ni + 1), np.nan, dtype = float)
         else:  # check same grid is referenced by this gcs
             assert bu.matching_uuids(gcs.grid_list[0].uuid, grid.uuid)
 
         # get gcs tr mult data in form of triplet of grid faces arrays
         gcs_trm_k, gcs_trm_j, gcs_trm_i = gcs.grid_face_arrays(tr_mult_uuid,
-                                                               default_value = np.NaN,
+                                                               default_value = np.nan,
                                                                active_only = active_only,
                                                                lazy = not sided,
                                                                baffle_uuid = baffle_uuid)

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/fault/_grid_connection_set.py

@@ -1558,7 +1558,7 @@ class GridConnectionSet(BaseResqpy):
                 log.info(
                     f'Property name {property_name} not found in extra_metadata for {self.model.citation_title_for_part(self.model.part_for_uuid(feature_uuid))}'
                 )
-                value_list.append(np.NaN)
+                value_list.append(np.nan)
             else:
                 value_list.append(float(feat.extra_metadata[property_name]))
         return value_list
@@ -2043,14 +2043,15 @@ class GridConnectionSet(BaseResqpy):
                          feature_index = None,
                          active_only = True,
                          lazy = False,
-                         baffle_uuid = None):
+                         baffle_uuid = None,
+                         dtype = None):
         """Creates a triplet of grid face numpy arrays populated from a property for this gcs.
 
         arguments:
             property_uuid (UUID): the uuid of the gcs property
             default_value (float or int, optional): the value to use in the grid property
                 on faces that do not appear in the grid connection set; will default to
-                np.NaN for continuous properties, -1 for categorical or discrete
+                np.nan for continuous properties, -1 for categorical or discrete
             feature_index (int, optional): if present, only faces for this feature are used
             active_only (bool, default True): if True and an active property exists for the
                 grid connection set, then only active faces are used when populating the
@@ -2061,6 +2062,8 @@ class GridConnectionSet(BaseResqpy):
             baffle_uuid (uuid, optional): if present, the uuid of a discrete (bool) property
                 of the gcs holding baffle flags; where True the output face value is set
                 to zero regardless of the main property value
+            dtype (type or str, optional): the element type for the returned arrays; defaults
+                to float for continuous properties or int for discrete properties; see notes
 
         returns:
             triple numpy arrays: identifying the K, J & I direction grid face property values;
@@ -2070,7 +2073,9 @@ class GridConnectionSet(BaseResqpy):
             can only be used on single grid gcs; gcs property must have indexable of faces;
             at present generates grid properties with indexable 'faces' not 'faces per cell',
             which might not be appropriate for grids with split pillars (structural faults);
-            points properties not currently supported; count must be 1
+            points properties not currently supported; count must be 1;
+            if the property is a boolean array and may have been written to hdf5 using packing,
+            then the dtype argument must be set to bool or np.uint8 to ensure unpacking
         """
 
         assert self.number_of_grids() == 1
@@ -2078,7 +2083,7 @@ class GridConnectionSet(BaseResqpy):
         active_mask = None
         if active_only:
             pc = self.extract_property_collection()
-            active_mask = pc.single_array_ref(property_kind = 'active')
+            active_mask = pc.single_array_ref(property_kind = 'active', dtype = bool)
             if active_mask is not None:
                 assert active_mask.shape == (self.count,)
         gcs_prop = rqp.Property(self.model, uuid = property_uuid)
@@ -2086,10 +2091,11 @@ class GridConnectionSet(BaseResqpy):
         assert bu.matching_uuids(gcs_prop.collection.support_uuid, self.uuid)
         assert gcs_prop.count() == 1
         assert not gcs_prop.is_points()
-        dtype = float if gcs_prop.is_continuous() else int
+        if dtype is None:
+            dtype = float if gcs_prop.is_continuous() else int
         if default_value is None:
-            default_value = -1 if dtype is int else np.NaN
-        gcs_prop_array = gcs_prop.array_ref()
+            default_value = -1 if dtype is int else np.nan
+        gcs_prop_array = gcs_prop.array_ref(dtype = dtype)
         assert gcs_prop_array.shape == (self.count,)
         log.debug(f'preparing grid face arrays from gcs property: {gcs_prop.title}; from gcs:{self.title}')
 

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/grid/_defined_geometry.py

@@ -293,7 +293,7 @@ def set_geometry_is_defined(grid,
 
     assert not np.all(nan_mask), 'grid does not have any geometry defined'
 
-    points[np.where(np.repeat(np.expand_dims(nan_mask, axis = nan_mask.ndim), 3, axis = -1))] = np.NaN
+    points[np.where(np.repeat(np.expand_dims(nan_mask, axis = nan_mask.ndim), 3, axis = -1))] = np.nan
 
     surround_z = grid.xyz_box(lazy = False)[1 if grid.z_inc_down() else 0, 2]
 
@@ -335,7 +335,7 @@ def set_geometry_is_defined(grid,
     if nullify_partial_pillars:
         partial_pillar_mask = np.logical_and(pillar_defined_mask, np.any(nan_mask, axis = 0).flatten())
         if np.any(partial_pillar_mask):
-            points.reshape((grid.nk_plus_k_gaps + 1, -1, 3))[:, partial_pillar_mask, :] = np.NaN
+            points.reshape((grid.nk_plus_k_gaps + 1, -1, 3))[:, partial_pillar_mask, :] = np.nan
             grid.geometry_defined_for_all_pillars_cached = False
             cells_update_needed = True
     elif complete_partial_pillars:
@@ -416,7 +416,7 @@ def __handle_areal_dots(areal_dots, grid, nan_mask):
         primaries = (grid.nj + 1) * (grid.ni + 1)
         nan_mask[:, :primaries] = np.logical_or(nan_mask[:, :primaries], dot_mask.reshape((-1, primaries)))
     else:
-        nan_mask = np.where(dot_mask, np.NaN, nan_mask)
+        nan_mask = np.where(dot_mask, np.nan, nan_mask)
     return nan_mask
 
 

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/grid/_points_functions.py

@@ -790,7 +790,7 @@ def corner_points(grid, cell_kji0 = None, points_root = None, cache_resqml_array
     # note: this function returns a derived object rather than a native resqml object
 
     def one_cell_cp(grid, cell_kji0, points_root, cache_array):
-        cp = np.full((2, 2, 2, 3), np.NaN)
+        cp = np.full((2, 2, 2, 3), np.nan)
         if not grr_dg.geometry_defined_for_all_cells(grid):
             if not grr_dg.cell_geometry_is_defined(grid, cell_kji0 = cell_kji0, cache_array = cache_array):
                 return cp

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/grid_surface/_find_faces.py

@@ -815,7 +815,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
                                               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()
+        flange_array = flange_bool.array_ref(dtype = bool)
         all_flange = np.take(flange_array, all_tris)
         assert all_flange.shape == (gcs.count,)
 
@@ -994,12 +994,23 @@ def bisector_from_faces(  # type: ignore
     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,]
-    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: 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
 
@@ -1027,8 +1038,13 @@ 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
+    # 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, :, :]):
@@ -1140,18 +1156,18 @@ def shadow_from_faces(extent_kji, k_faces):
         c = np.logical_and(shadow[:-1] == 0, shadow[1:] == 1)
         if np.count_nonzero(c) == 0:
             break
-        shadow[:-1] = np.where(c, 1, shadow[:-1])
+        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:] = np.where(c, 2, shadow[1:])
+        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] = np.where(c, 3, shadow[:-1])
-        shadow[1:] = np.where(c, 3, shadow[1:])
+        shadow[:-1][c] = 3
+        shadow[1:][c] = 3
     return shadow
 
 

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/multi_processing/wrappers/grid_surface_mp.py

@@ -235,7 +235,8 @@ def find_faces_to_represent_surface_regular_wrapper(
                                            property_kind = 'flange bool',
                                            find_local_property_kind = True,
                                            indexable_element = 'faces',
-                                           discrete = True)
+                                           discrete = True,
+                                           dtype = np.uint8)
         uuid_list.append(flange_p.uuid)
     uuid_list.append(surface_uuid)
 

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/olio/transmission.py

@@ -260,10 +260,10 @@ def half_cell_t_irregular(grid,
             zero_length_mask = np.logical_or(np.any(np.isnan(half_axis_vectors), axis = -1),
                                              half_axis_length_sqr < tolerance_sqr)
             minus_face_t = np.where(
-                zero_length_mask, np.NaN,
+                zero_length_mask, np.nan,
                 perm_k * np.sum(half_axis_vectors * minus_face_areas, axis = -1) / half_axis_length_sqr)
             plus_face_t = np.where(
-                zero_length_mask, np.NaN,
+                zero_length_mask, np.nan,
                 perm_k * np.sum(half_axis_vectors * plus_face_areas, axis = -1) / half_axis_length_sqr)
 
         elif axis == 1:  # j
@@ -303,10 +303,10 @@ def half_cell_t_irregular(grid,
             half_axis_length_sqr = np.sum(half_axis_vectors * half_axis_vectors, axis = -1)
             zero_length_mask = (half_axis_length_sqr < tolerance_sqr)
             minus_face_t = np.where(
-                zero_length_mask, np.NaN,
+                zero_length_mask, np.nan,
                 perm_j * np.sum(half_axis_vectors * minus_face_areas, axis = -1) / half_axis_length_sqr)
             plus_face_t = np.where(
-                zero_length_mask, np.NaN,
+                zero_length_mask, np.nan,
                 perm_j * np.sum(half_axis_vectors * plus_face_areas, axis = -1) / half_axis_length_sqr)
 
         else:  # i
@@ -345,10 +345,10 @@ def half_cell_t_irregular(grid,
             half_axis_length_sqr = np.sum(half_axis_vectors * half_axis_vectors, axis = -1)
             zero_length_mask = (half_axis_length_sqr < tolerance_sqr)
             minus_face_t = np.where(
-                zero_length_mask, np.NaN,
+                zero_length_mask, np.nan,
                 perm_i * np.sum(half_axis_vectors * minus_face_areas, axis = -1) / half_axis_length_sqr)
             plus_face_t = np.where(
-                zero_length_mask, np.NaN,
+                zero_length_mask, np.nan,
                 perm_i * np.sum(half_axis_vectors * plus_face_areas, axis = -1) / half_axis_length_sqr)
 
         if axis != 0 and ntg is not None:
@@ -417,14 +417,14 @@ def half_cell_t_vertical_prism(vpg,
     # compute transmissibilities
     tr = np.zeros((vpg.cell_count, 5), dtype = float)
     # vertical
-    tr[:, 0] = np.where(half_thickness < tolerance, np.NaN, (perm_k.reshape(
+    tr[:, 0] = np.where(half_thickness < tolerance, np.nan, (perm_k.reshape(
         (vpg.nk, -1)) * triangle_areas / half_thickness)).flatten()
     tr[:, 1] = tr[:, 0]
     # horizontal
     # TODO: compute dip adjustments for non-vertical transmissibilities
     dt_full = np.empty((vpg.nk, vpg.cell_count // vpg.nk, 3), dtype = float)
     dt_full[:] = d_t
-    tr[:, 2:] = np.where(dt_full < tolerance, np.NaN,
+    tr[:, 2:] = np.where(dt_full < tolerance, np.nan,
                          triple_perm_horizontal.reshape((vpg.nk, -1, 3)) * a_t.reshape((1, -1, 3)) / dt_full).reshape(
                              (-1, 3))
     if ntg is not None:

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/olio/vector_utilities.py

@@ -999,7 +999,7 @@ def vertical_intercept_nan(x: float, x_value_0: float, x_value_1: float, y_value
         y (float): y value of the straight line segment between point 1 and point 2,
             evaluated at x; if x is outside the x values range, y is NaN
     """
-    y = np.NaN
+    y = np.nan
     if x_value_1 < x_value_0:
         x_value_0, x_value_1 = x_value_1, x_value_0
         y_value_0, y_value_1 = y_value_1, y_value_0

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/olio/wellspec_keywords.py

@@ -482,11 +482,11 @@ def get_well_data(
                     if column_list[col_index].upper() == "GRID":
                         data[col].append("ROOT")
                     else:
-                        data[col].append(np.NaN)
+                        data[col].append(np.nan)
                 else:
                     value = words[column_map[col_index]]
                     if value == "NA":
-                        data[col].append(np.NaN)
+                        data[col].append(np.nan)
                     elif value == "#":
                         data[col].append(value)
                     elif value:
@@ -496,7 +496,7 @@ def get_well_data(
         else:
             for col, value in zip(columns_present, words[:len(columns_present)]):
                 if value == "NA":
-                    data[col].append(np.NaN)
+                    data[col].append(np.nan)
                 elif value == "#":
                     data[col].append(value)
                 elif value:

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/property/grid_property_collection.py

@@ -824,7 +824,7 @@ def _coarsening_sum(coarsening, a, axis = None):
     return a_coarsened
 
 
-def _coarsening_weighted_mean(coarsening, a, fine_weight, coarse_weight = None, zero_weight_result = np.NaN):
+def _coarsening_weighted_mean(coarsening, a, fine_weight, coarse_weight = None, zero_weight_result = np.nan):
     a_coarsened = np.empty(tuple(coarsening.coarse_extent_kji))
     assert a.shape == tuple(coarsening.fine_extent_kji)
     assert fine_weight.shape == a.shape

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/property/property_collection.py

@@ -1085,17 +1085,17 @@ class PropertyCollection():
         return meta
 
     def null_value_for_part(self, part):
-        """Returns the null value for the (discrete) property part; np.NaN for continuous parts.
+        """Returns the null value for the (discrete) property part; np.nan for continuous parts.
 
         arguments:
            part (string): the part name for which the null value is required
 
         returns:
-           int or np.NaN
+           int or np.nan
         """
 
         if self.continuous_for_part(part):
-            return np.NaN
+            return np.nan
         return self.element_for_part(part, 19)
 
     def continuous_for_part(self, part):
@@ -1683,7 +1683,7 @@ class PropertyCollection():
            exclude_inactive (boolean, default True): elements which are flagged as inactive in the supporting representation
               are masked out if this argument is True
            exclude_value (float or int, optional): if present, elements which match this value are masked out; if not None
-              then usually set to np.NaN for continuous data or null_value_for_part() for discrete data
+              then usually set to np.nan for continuous data or null_value_for_part() for discrete data
            points (boolean, default False): if True, the simple array is expected to have an extra dimension of extent 3,
               relative to the inactive attribute of the support
 
@@ -1771,7 +1771,7 @@ class PropertyCollection():
            representation object with the attribute name 'inactive', to multiple properties (this will only work
            if the indexable element is set to the typical value for the class of supporting representation, eg.
            'cells' for grid objects); if exclude_null is set True then null value elements will also be masked out
-           (as long as masked is True); however, it is recommended simply to use np.NaN values in floating point
+           (as long as masked is True); however, it is recommended simply to use np.nan values in floating point
            property arrays if the commonality is not needed;
            set use_pack True if the hdf5 data may have been written with a similar setting
 
@@ -1948,7 +1948,7 @@ class PropertyCollection():
               the maximum realization number present and slices for any missing realizations will be filled with fill_value;
               if False, the extent of the first axis will only cpver the number pf realizations actually present (see also notes)
            fill_value (int or float, optional): the value to use for missing realization slices; if None, will default to
-              np.NaN if data is continuous, -1 otherwise; irrelevant if fill_missing is False
+              np.nan if data is continuous, -1 otherwise; irrelevant if fill_missing is False
            indexable_element (string, optional): the indexable element for the properties in the collection; if None, will
               be determined from the data
 
@@ -1968,7 +1968,7 @@ class PropertyCollection():
         r_list, continuous = pcga._realizations_array_ref_initial_checks(self)
 
         if fill_value is None:
-            fill_value = np.NaN if continuous else -1
+            fill_value = np.nan if continuous else -1
         if indexable_element is None:
             indexable_element = self.indexable_for_part(self.parts()[0])
 
@@ -1997,7 +1997,7 @@ class PropertyCollection():
               the maximum time index present and slices for any missing indices will be filled with fill_value; if False,
               the extent of the first axis will only cpver the number pf time indices actually present (see also notes)
            fill_value (int or float, optional): the value to use for missing time index slices; if None, will default to
-              np.NaN if data is continuous, -1 otherwise; irrelevant if fill_missing is False
+              np.nan if data is continuous, -1 otherwise; irrelevant if fill_missing is False
            indexable_element (string, optional): the indexable element for the properties in the collection; if None, will
               be determined from the data
 
@@ -2018,7 +2018,7 @@ class PropertyCollection():
         ti_list, continuous = pcga._time_array_ref_initial_checks(self)
 
         if fill_value is None:
-            fill_value = np.NaN if continuous else -1
+            fill_value = np.nan if continuous else -1
 
         if indexable_element is None:
             indexable_element = self.indexable_for_part(self.parts()[0])

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/surface/_surface.py

@@ -1029,7 +1029,7 @@ class Surface(rqsb.BaseSurface):
         t, p = self.triangles_and_points(patch = patch)
         p_list = vec.points_in_triangles_njit(sample_xy, p[t], 1)
         vertical = np.array((0.0, 0.0, 1.0), dtype = float)
-        z = np.full(sample_xy.shape[0], np.NaN, dtype = float)
+        z = np.full(sample_xy.shape[0], np.nan, dtype = float)
         for triangle_index, p_index, _ in p_list:
             # todo: replace following with cheaper trilinear interpolation, given vertical intersection line
             xyz = meet.line_triangle_intersect_numba(sample_xy[p_index], vertical, p[t[triangle_index]], t_tol = 0.05)

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/surface/_tri_mesh.py

@@ -241,8 +241,8 @@ class TriMesh(rqs.Mesh):
         fy[am] = 1.0 - fy[am]
         j[mask] = -1
         i[mask] = -1
-        fx[mask] = np.NaN
-        fy[mask] = np.NaN
+        fx[mask] = np.nan
+        fy[mask] = np.nan
 
         return (np.stack((j, i), axis = -1), np.stack((1.0 - (fx + fy), fx, fy), axis = -1))
 

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/surface/_tri_mesh_stencil.py

@@ -94,7 +94,7 @@ class TriMeshStencil:
         # convert into representation more njit & numpy friendly
         self.start_ip = np.array([ip for (ip, _, _) in half_hex], dtype = int)
         self.row_length = np.array([rl for (_, rl, _) in half_hex], dtype = int)
-        self.half_hex = np.full((self.n, 2 * self.n - 1), np.NaN, dtype = float)
+        self.half_hex = np.full((self.n, 2 * self.n - 1), np.nan, dtype = float)
         for jp in range(self.n):
             self.half_hex[jp, :self.row_length[jp]] = half_hex[jp][2]
 
@@ -210,7 +210,7 @@ class TriMeshStencil:
 
     # todo: class methods for mexican hat
 
-    def apply(self, tri_mesh, handle_nan = True, border_value = np.NaN, preserve_nan = False, title = None):
+    def apply(self, tri_mesh, handle_nan = True, border_value = np.nan, preserve_nan = False, title = None):
         """Return a new tri mesh with z values generated by applying the stencil to z values of an existing tri mesh.
 
         arguments:
@@ -250,7 +250,7 @@ class TriMeshStencil:
             if not np.any(nan_mask):
                 nan_mask = None
         z_values[border:border + tri_mesh.nj, border:border + tri_mesh.ni] = tm_z
-        applied = np.full((e_nj, e_ni), np.NaN, dtype = float)
+        applied = np.full((e_nj, e_ni), np.nan, dtype = float)
 
         if handle_nan:
             _apply_stencil_nanmean(self.n, self.start_ip, self.row_length, self.half_hex, z_values, applied, border,
@@ -262,7 +262,7 @@ class TriMeshStencil:
         # restore NaN values where they were present in input, if requested
         tm_z_applied = applied[border:border + tri_mesh.nj, border:border + tri_mesh.ni]
         if nan_mask is not None:
-            tm_z_applied[nan_mask] = np.NaN
+            tm_z_applied[nan_mask] = np.nan
 
         # create a new tri mesh object using the values from the applied array for z
         tm = rqs.TriMesh(tri_mesh.model,

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/unstructured/_prism_grid.py

@@ -335,7 +335,7 @@ class VerticalPrismGrid(PrismGrid):
             if surf == 0:
                 # allow NaN entries to handle unused distant circumcentres in Voronoi graph data
                 # assert not np.any(nan_lines), 'top surface does not cover all column points'
-                single_intersects[nan_lines] = np.NaN
+                single_intersects[nan_lines] = np.nan
             else:
                 single_intersects[nan_lines] = points[surf - 1][nan_lines]
             # populate z values for layer of points

{resqpy-4.16.7 → resqpy-4.16.8}/resqpy/well/_blocked_well.py

@@ -2579,7 +2579,7 @@ class BlockedWell(BaseResqpy):
                                entry_xyz, exit_xyz, ee_crs, pc, pc_titles, ci):
         """Get the x, y and z location of the midpoint of the interval."""
 
-        xyz = (np.NaN, np.NaN, np.NaN)
+        xyz = (np.nan, np.nan, np.nan)
         if doing_xyz:
             xyz = self.__get_xyz_if_doing_xyz(length_mode = length_mode,
                                               md = md,
@@ -2734,7 +2734,7 @@ class BlockedWell(BaseResqpy):
                 dtype = np.int32
             else:
                 null_value = None
-                na_value = np.NaN
+                na_value = np.nan
                 dtype = float
             # 'SKIN': use defaults for now; todo: create local property kind for skin
             if column == 'STAT':