resqpy 4.16.6__py3-none-any.whl → 4.16.8__py3-none-any.whl

resqpy/__init__.py

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

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/fault/_grid_connection_set.py

@@ -249,6 +249,7 @@ class GridConnectionSet(BaseResqpy):
         gcs.model = parent_model
         gcs.uuid = bu.new_uuid()  # not strictly necessary as append will cause a new uuid as well
         gcs.title = title
+        gcs.property_collection = None
         # append data from the remaining grid connection sets
         for another_uuid in gcs_uuid_list[1:]:
             another_gcs = GridConnectionSet(source_model, uuid = another_uuid)
@@ -1557,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
@@ -2042,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
@@ -2060,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;
@@ -2069,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
@@ -2077,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)
@@ -2085,10 +2091,12 @@ 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}')
 
         baffle_mask = None
@@ -2102,29 +2110,31 @@ class GridConnectionSet(BaseResqpy):
         ai = np.full((nk, nj, ni + 1), default_value, dtype = dtype)
 
         # populate arrays from faces of gcs, optionally filtered by feature index
-        cip, fip = self.list_of_cell_face_pairs_for_feature_index(None)
-        assert len(cip) == self.count and len(fip) == self.count
-        assert gcs_prop_array.shape == (self.count,)
-        if feature_index is None:
-            indices = np.arange(self.count, dtype = int)
-        else:
-            indices = self.indices_for_feature_index(feature_index)
-
-        side_list = ([0] if lazy else [0, 1])
+        cip, fip = self.list_of_cell_face_pairs_for_feature_index(feature_index)
 
         value_array = gcs_prop_array.copy()
+
         if baffle_mask is not None:
             value_array[baffle_mask] = 0  # will be cast to float (or bool) if needed
+
+        if feature_index is not None:
+            indices = self.indices_for_feature_index(feature_index)
+            value_array = value_array[indices]
+            if active_mask is not None:
+                active_mask = active_mask[indices]
+
         if active_mask is not None:
             cip = cip[active_mask, :, :]
             value_array = value_array[active_mask]
 
+        side_list = ([0] if lazy else [0, 1])
+
         for side in side_list:
             cell_kji0 = cip[:, side].copy()  # shape (N, 3)
             axis = fip[:, side, 0]  # shape (N,)
             polarity = fip[:, side, 1]  # shape (N,)
-            assert 0 <= np.min(axis) and np.max(axis) <= 2
-            assert 0 <= np.min(polarity) and np.max(polarity) <= 1
+            # assert 0 <= np.min(axis) and np.max(axis) <= 2
+            # assert 0 <= np.min(polarity) and np.max(polarity) <= 1
 
             axis_mask = (axis == 0).astype(bool)
             ak_kji0 = cell_kji0[axis_mask, :]

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/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/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/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/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/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/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/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/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/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/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/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/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/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':

{resqpy-4.16.6.dist-info → resqpy-4.16.8.dist-info}/METADATA

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

{resqpy-4.16.6.dist-info → resqpy-4.16.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-resqpy/__init__.py,sha256=HShUsMyW_Opst0QwCwfVL9ZeafR-pFfMTCvvDzmU6rU,556
+resqpy/__init__.py,sha256=KePPe4noY_Ul661qHQxi-2dxmtmaw7TVFqT9bx2kV80,556
 resqpy/crs.py,sha256=R7DfcTP5xGv5pu9Y8RHA2WVM9DjBCSVMoHcz4RmQ7Yw,27646
 resqpy/derived_model/__init__.py,sha256=NFvMSOKI3cxmH7lAbddV43JjoUj-r2G7ExEfOqinD1I,1982
 resqpy/derived_model/_add_edges_per_column_property_array.py,sha256=cpW3gwp6MSYIrtvFmCjoJXcyUsgGuCDbgmwlJCJebUs,6410
@@ -24,13 +24,13 @@ resqpy/derived_model/_unsplit_grid.py,sha256=aqcdyn4WhDy7Kys3wnb55QwVXehmir4VW7T
 resqpy/derived_model/_zonal_grid.py,sha256=H-IGMudUV-tiRHZqvl9B1wxMQNjeAM2zHvTllNiagPA,18825
 resqpy/derived_model/_zone_layer_ranges_from_array.py,sha256=4pHkp7yqvkif_pC59VEK0g0JeFx7kt8mqhqADTOcucI,4358
 resqpy/fault/__init__.py,sha256=IStX_EhPnppIExf_mgYrBddC4KP26VcqblcfXiBT614,996
-resqpy/fault/_gcs_functions.py,sha256=wMP4gnzT6Smv1RKGex0fdcadzj2xmanyusNA-D_ebfI,29569
-resqpy/fault/_grid_connection_set.py,sha256=IEG9duPzPmVge-7yX70mcfmFSdU8MSR1sbQmRoSjlyE,117203
+resqpy/fault/_gcs_functions.py,sha256=NRyhKkYChRaKDUIQ6pfVQiD67e4TTm3LnBvWEPtpkDU,29569
+resqpy/fault/_grid_connection_set.py,sha256=icHKPcoGLUapWt33vL5dHMubah7kXUI7fAk8LU20LFU,117732
 resqpy/grid/__init__.py,sha256=WsfOnR5lHcnpJEx8ZZ3lhd4dImEiieJLM7eFPxMi3u8,692
 resqpy/grid/_cell_properties.py,sha256=pbyAK2eV9n4teOxm2q5hyBinohEbevFPrCfMcpGiqUU,20689
 resqpy/grid/_connection_sets.py,sha256=-277bh9pMoeESSzy9oZehL-vc82aMGZuSLQs2KJ4Wfg,10120
 resqpy/grid/_create_grid_xml.py,sha256=p-jKo1BZ-DlhEYixVzadtY-QsqA8ygcXvMYS_TvQCjg,22837
-resqpy/grid/_defined_geometry.py,sha256=qkkfiSh8hzhTaW3vEot77mFWgApZl92Cb552b-xyjpQ,32297
+resqpy/grid/_defined_geometry.py,sha256=QYQ3wLbPrlPobgUi9R1izTD4JD9qMGf5eyqbM68Hg-0,32297
 resqpy/grid/_extract_functions.py,sha256=n_SmfkvEssX09SrlvUMe7y-4eOuVckhL_M6tFTg1bRg,28203
 resqpy/grid/_face_functions.py,sha256=0I7O6DDz7nJWczi_G2bE3L2XUr4acxREwKygXWEp6F4,16516
 resqpy/grid/_faults.py,sha256=OmukVoLpdrndqDxwE6Rj7Ul5tj3FUQVPhE0raH2FHpg,12236
@@ -40,7 +40,7 @@ resqpy/grid/_intervals_info.py,sha256=ODjDz22n8U9pSpO0Muj8mJr2hYWauFDzgcVQ0RM3cs
 resqpy/grid/_moved_functions.py,sha256=XboxA0pE55j-P_x5g051WheVamxkAatQGbU5aq2GkaE,604
 resqpy/grid/_pillars.py,sha256=WXvLjORlNHnm0KI3qgoRtCyXdcT9vQBkJDQWL2wtJwg,7243
 resqpy/grid/_pixel_maps.py,sha256=Aqn9dpDKjX_v8BnWMdN__ulqjeuXfE6W2_Z7EDaUqdE,5386
-resqpy/grid/_points_functions.py,sha256=bJkU7JoCF8t_TW43OzWenEmqTgmVMYbj8YXtIvj9EHg,70585
+resqpy/grid/_points_functions.py,sha256=72dCLWHrOUM9xSwSaEuxPUA__b6WAdk5rbeWatILdaI,70585
 resqpy/grid/_regular_grid.py,sha256=6lXWSsgzVAB4QwGOwhB7Gb9_kiU2rNM55xWIf9qT3GI,45758
 resqpy/grid/_transmissibility.py,sha256=cLtuVaLgBQqRXa-_YQ5mjR_QC842Jxn2d-Hl6171yOY,22575
 resqpy/grid/_write_hdf5_from_caches.py,sha256=s3gcoilsFCCSw_wjnTjWe1xMHEWr_cessoGVgzqiqVI,9707
@@ -48,7 +48,7 @@ resqpy/grid/_write_nexus_corp.py,sha256=yEVfiObsedEAXX6UG6ZTf56kZnQVkd3lLqE2NpL-
 resqpy/grid/_xyz.py,sha256=RLQWOdM_DRoCj4JypwB5gUJ78HTdk5JnZHSeAzuU634,13087
 resqpy/grid_surface/__init__.py,sha256=iyK3_Vlg9mXffc_1gjvRdKwQE0zicbNXya0tryHkr04,2593
 resqpy/grid_surface/_blocked_well_populate.py,sha256=MQIHf7Sh_XR3cUCfGhvlu4Xl498DtIKH2ffo4iud93w,35843
-resqpy/grid_surface/_find_faces.py,sha256=frwC2pTuFkHkBdmrLjx7X43e1Crtjh9TfHrgsbhIiAw,65534
+resqpy/grid_surface/_find_faces.py,sha256=CRt0jBl28WUdsqW7kp9LUMHXVjWge6vtFjl4qBMT9HA,65537
 resqpy/grid_surface/_grid_skin.py,sha256=D0cjHkcuT5KCKb-8EZfXgh0GgJj3kzOBS2wVNXg4bfY,26056
 resqpy/grid_surface/_grid_surface.py,sha256=l2NJo7Kiucolbb_TlLPC7NGdksg_JahkihfsrJVq99w,14379
 resqpy/grid_surface/_trajectory_intersects.py,sha256=Och9cZYU9Y7ofovhPzsLyIblRUl2xj9_5nHH3fMZp-A,22498
@@ -69,7 +69,7 @@ resqpy/multi_processing/__init__.py,sha256=ZRudHfN9aaZjxvat7t8BZr6mwMi9baiCNjczw
 resqpy/multi_processing/_multiprocessing.py,sha256=bnCKfSC1tWwvZmZ7BZqCyje0C93m6q7HZPxNpx8xoxA,7301
 resqpy/multi_processing/wrappers/__init__.py,sha256=7vjuTWdHnp3rN9Ud8ljpDnt1NbBAyhA08lv-sQ9Kf3o,72
 resqpy/multi_processing/wrappers/blocked_well_mp.py,sha256=_2fEsSmJVQCnbQIjTHqmnNEugfhN1KvX-o4ZbvtChdI,5952
-resqpy/multi_processing/wrappers/grid_surface_mp.py,sha256=WYJK_vkTPq3pjOYnSm6uJswQqbpiqM0NXfC1pI53tl0,23348
+resqpy/multi_processing/wrappers/grid_surface_mp.py,sha256=ZIYH34BfdFY7wkcxX3VycJtaFGL4NRpa8tQY391SzQs,23409
 resqpy/multi_processing/wrappers/mesh_mp.py,sha256=0VYoqtgBFfrlyYB6kkjbdrRQ5FKe6t5pHJO3wD9b8Fc,5793
 resqpy/olio/__init__.py,sha256=j2breqKYVufhw5k8qS2uZwB3tUKT7FhdZ23ninS75YA,84
 resqpy/olio/ab_toolbox.py,sha256=bZlAhOJVS0HvIYBW0Lg68re17N8eltoQhIUh0xuUyVc,2147
@@ -94,13 +94,13 @@ resqpy/olio/relperm.py,sha256=VSyqVz_OsjCL9tB7jBnjVdLA4F5yiKYJthIghux8_aI,17135
 resqpy/olio/simple_lines.py,sha256=qaR11W5UPgRmtMeFQ-pXg0jOvkJZ_XPzSUpAXqeYtlc,12189
 resqpy/olio/time.py,sha256=LtoSIf1A6wunHSpDgKsSGEr0rbcSQyy35TgJvY37PrI,760
 resqpy/olio/trademark.py,sha256=p_EWvUUnfalOA0RC94fSWMDgdGY9-FdZuGtAjg3wNcY,822
-resqpy/olio/transmission.py,sha256=ojMRvzMOulb-S3FHnkR3ouIBTXA4knI0drDOt_WACso,61869
+resqpy/olio/transmission.py,sha256=auz_12TKtSPy6Fv3wmKn5lXPRAEnn2tYVyTQfsj37xU,61869
 resqpy/olio/triangulation.py,sha256=JA4LN4uASqkN_gx4eE_cAHNOJfTqAQQPYET_cLPJuU8,45621
 resqpy/olio/uuid.py,sha256=JRMi-RZNeGm8tGNloIwTATzNtdj29lBQDV9OILboPRI,7324
 resqpy/olio/vdb.py,sha256=lQYuK1kr1Wnucq2EoKgT6lrR7vloCemnCKZktzBcLUc,45231
-resqpy/olio/vector_utilities.py,sha256=V4DRixcJPtM6Z0i_eHxu9HA-gLiRTj3rXKEsChKA-j4,53546
+resqpy/olio/vector_utilities.py,sha256=zPJHAcdEvuHNm2L3ldEHztBxVSHVJaSSClCO4ooFRG8,53546
 resqpy/olio/volume.py,sha256=F1pMnDoJ4ricy4dfdLuLuK1xkVgJckL9V06tUeyK6Wc,6185
-resqpy/olio/wellspec_keywords.py,sha256=MqrXRSzVfXAKUhiJkop3EwoVdKEjgZRwHYBJjx2IW8Q,26265
+resqpy/olio/wellspec_keywords.py,sha256=QHITeHjd24HGvGVFKcTvtlqRn5v8Gq4d4Pe4dqyw3Gk,26265
 resqpy/olio/write_data.py,sha256=bIX7ilMkXWCMz_zQh-Gqk56sNzng4W5l4BahW2EV7Kw,5142
 resqpy/olio/write_hdf5.py,sha256=KXB2L6Qz3TFb9yDjT-Ty0CXgjyq0nhVp3GADlekWhMQ,19055
 resqpy/olio/xml_et.py,sha256=aPjxr2XWvYcwlnckL_UiZmd5EGEoIfy_JxeOKOk3vwQ,25322
@@ -134,8 +134,8 @@ resqpy/property/_collection_get_attributes.py,sha256=MlontPfGo00lxt0SpB49YG9PRsi
 resqpy/property/_collection_support.py,sha256=77_DG-0pzhMWdG_mNDiGfihXD7Pp-CvDSGCV8ZlDjj4,5889
 resqpy/property/_property.py,sha256=JcG7h6k4cJ4l3WC_VCsvoqHM3FBxrnUuxbIK2Ono1M0,24426
 resqpy/property/attribute_property_set.py,sha256=gATFe-vI00GrgaJNMHSKbM0xmlxIsO5DT1qRSU9snYI,12295
-resqpy/property/grid_property_collection.py,sha256=bLWCTfhmpDsagBaXXb8XXHL46Cy78HL_NGWpPFZAgdw,66946
-resqpy/property/property_collection.py,sha256=i5YL4GdehsI1cR8gtnfERMwcXsT964AMmegey3hNfww,152167
+resqpy/property/grid_property_collection.py,sha256=oZr2uZ06Rvc_Ddt4Qykm4vlZJOCqIdw5PYsWudbGPc4,66946
+resqpy/property/property_collection.py,sha256=Ax1wzqE9xfsMaIIKVlVTxNaDRZ4RpEK9ZcBEf_JDtWU,152167
 resqpy/property/property_common.py,sha256=wf429weNtgf6J4gCNNoRwj64elQvUPI_ZWzg4qI7l6c,35993
 resqpy/property/property_kind.py,sha256=6SK0La09eisHPYOSgdx69K_Ordrq0x2tz4IAyurVyY8,5557
 resqpy/property/string_lookup.py,sha256=eH-lbLRbb8JKtO91FTtyuYseRGwPkmsghcXbKUTvVgI,7737
@@ -163,9 +163,9 @@ resqpy/surface/_base_surface.py,sha256=LsWrDrbuuaEVRgf2Dlbc-6ZvGQpjtrKuxF7Jjebvl
 resqpy/surface/_combined_surface.py,sha256=8TnNbSywjej6tW_vRr5zoVgBbvnadCaqWk6WyHWHTYQ,3082
 resqpy/surface/_mesh.py,sha256=bhHfIjRg9xWhv1aWW9oDhTK6LlwS5rZBST1ONJuG8pg,42192
 resqpy/surface/_pointset.py,sha256=niTkBik9hAvqrY8340K1TRG7mg4FMQbbp12WZiiXPMs,27416
-resqpy/surface/_surface.py,sha256=yXWHCmcjdsqOPpoLr106VEcKRLpYxQhbm1WL9nj40Rc,70786
-resqpy/surface/_tri_mesh.py,sha256=rqWk64m9mL4Gzk-R1bI-ThA0OEBdMUFjHyezbGMd0gg,26465
-resqpy/surface/_tri_mesh_stencil.py,sha256=0FgsWSPUIIt3k9_-FURy4J2idA3Ps2AXWJpcFX1o8OU,16087
+resqpy/surface/_surface.py,sha256=mylFBhkxey5pQBd_Tmn56bFtNn35ldw9M-yCXUvxHco,70786
+resqpy/surface/_tri_mesh.py,sha256=o_s_vHHMIb1BbfTGUtXOm7c6ODXPTTIuSlX4HFR1yrg,26465
+resqpy/surface/_tri_mesh_stencil.py,sha256=eXt_HIKvsXGsjQ7nm_NbozR6ProQxPbeO52r79j80ig,16087
 resqpy/surface/_triangulated_patch.py,sha256=cmZVssA5Yde0JzgawkahlZFNFcmgxJS59HxirOu7nQ4,25907
 resqpy/time_series/__init__.py,sha256=jiB3HJUWe47OOJTVmRJ4Gh5vm-XdMaMXmD52kAGr2zY,1074
 resqpy/time_series/_any_time_series.py,sha256=43q5hV-VKReZ6rRMEFHx977OVcOKwPvWOJbB9fj3SFQ,8755
@@ -176,7 +176,7 @@ resqpy/time_series/_time_duration.py,sha256=bzRf0fynlB68KUYKa0Ih7qwd4ZJnRjl_Y6Ax
 resqpy/time_series/_time_series.py,sha256=ceCuFbmYmppx0jBitdyjtSKkcLxjZ-qyhFN_HQX-3CQ,10818
 resqpy/unstructured/__init__.py,sha256=8te-ghWhkDGe0QaLDClvVEkSMtnDtX46K1QODmJU8Xw,603
 resqpy/unstructured/_hexa_grid.py,sha256=bRzx0PHUtOziEeVk7nZv5aQlogYnqvtbrVMTXsSVcQU,15328
-resqpy/unstructured/_prism_grid.py,sha256=qXurRLWNIvuqr4-ZpmjMg6uqmtClKrtCNB6e0PDVi4M,35856
+resqpy/unstructured/_prism_grid.py,sha256=rejFlW6yukHicGeBc5gNZQom2q7gwuB2zEK1QEwEXw0,35856
 resqpy/unstructured/_pyramid_grid.py,sha256=qDn7FlhLfDuqJYS88tomwuv5CH7RJd7avl-qK7CUy_4,7862
 resqpy/unstructured/_tetra_grid.py,sha256=IkRRaxulhH42fE2EysLI9gfUf19YoO3nFA_Uq6CrxmI,12453
 resqpy/unstructured/_unstructured_grid.py,sha256=OTYOSGrKoE51KpRhn4818tdvmZ-q9nmahk_7wC56mvc,51550
@@ -184,7 +184,7 @@ resqpy/weights_and_measures/__init__.py,sha256=Kp1pPZFH4rS5_PkCERZBEzGoat6n_dSS0
 resqpy/weights_and_measures/nexus_units.py,sha256=pHqcFbe-8nyqozFgN5Ce-W-UvEnXQ6yiaX3dP1ONtAQ,5434
 resqpy/weights_and_measures/weights_and_measures.py,sha256=1WnrmhtcyCgY2crClNddmfwtf33JdVZy9wNhqPQIvuc,16210
 resqpy/well/__init__.py,sha256=v5_gd7sSPRM9q2KsLiLWaw3jbnXFZkou38qeB7_HSN4,990
-resqpy/well/_blocked_well.py,sha256=XszaLuRs-McCEP9jjQkpflPqTyaez3v-F0H5qa01UjM,192115
+resqpy/well/_blocked_well.py,sha256=ZMuasUs_c3SIBMnF05tEAM44X3okC30YiF-iDryS64o,192115
 resqpy/well/_deviation_survey.py,sha256=d3u31JbBqMCsaz6MUrtZium90wrC3omtm46A755fvgk,23115
 resqpy/well/_md_datum.py,sha256=rRrDQckTJwZtIEh28dlgXj32kcBSu-ZvHFYZOiQsyqg,7154
 resqpy/well/_trajectory.py,sha256=QGFgdYVvA_gJth3n-RaFPS71S5KGgECnNMx0dp1r4Tw,52771
@@ -194,7 +194,7 @@ resqpy/well/_wellbore_marker_frame.py,sha256=xvYH2_2Ie3a18LReFymbUrZboOx7Rhv5DOD
 resqpy/well/blocked_well_frame.py,sha256=Lg7TgynfPv9WkklXTLt9VN6uBXWUqX1LI-Xmv_FBqYk,22555
 resqpy/well/well_object_funcs.py,sha256=LYTcC07ezlBxClfrug_B4iXXZUkXDPgsVufNzp361Wo,24703
 resqpy/well/well_utils.py,sha256=zwpYjT85nXAwWBhYB1Pygu2SgouZ-44k6hEOnpoMfBI,5969
-resqpy-4.16.6.dist-info/LICENSE,sha256=2duHPIkKQyESMdQ4hKjL8CYEsYRHXaYxt0YQkzsUYE4,1059
-resqpy-4.16.6.dist-info/METADATA,sha256=nKWccolEPWrZ8qsjWUWMrrbdDSGX1uFvnJOtD7hJySI,4028
-resqpy-4.16.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-resqpy-4.16.6.dist-info/RECORD,,
+resqpy-4.16.8.dist-info/LICENSE,sha256=2duHPIkKQyESMdQ4hKjL8CYEsYRHXaYxt0YQkzsUYE4,1059
+resqpy-4.16.8.dist-info/METADATA,sha256=iffFlvprjtp-dkRvmXhdy0uQ4gngo_adfj7frRrWFqU,4028
+resqpy-4.16.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+resqpy-4.16.8.dist-info/RECORD,,