resqpy 4.18.10__py3-none-any.whl → 5.0.0__py3-none-any.whl

resqpy/__init__.py

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

resqpy/grid/__init__.py

@@ -1,14 +1,13 @@
 """The Grid Module."""
 
 __all__ = [
-    'Grid', 'RegularGrid', 'extract_grid_parent', 'establish_zone_property_kind', 'find_cell_for_x_sect_xz',
-    'grid_flavour', 'is_regular_grid', 'any_grid'
+    'Grid', 'RegularGrid', 'extract_grid_parent', 'find_cell_for_x_sect_xz', 'grid_flavour', 'is_regular_grid',
+    'any_grid'
 ]
 
 from ._grid import Grid
 from ._regular_grid import RegularGrid
 from ._grid_types import grid_flavour, is_regular_grid, any_grid
-from ._moved_functions import establish_zone_property_kind
 from ._extract_functions import extract_grid_parent, extent_kji_from_root
 from ._points_functions import find_cell_for_x_sect_xz
 

resqpy/grid/_grid.py

@@ -680,13 +680,7 @@ class Grid(BaseResqpy):
         return _create_grid_xml(self, ijk, ext_uuid, add_as_part, add_relationships, write_active, write_geometry,
                                 use_lattice, use_parametric_lines)
 
-    def x_section_points(self, axis, ref_slice0 = 0, plus_face = False, masked = False):
-        """Deprecated: please use `unsplit_x_section_points` instead."""
-        warnings.warn('Deprecated: please use `unsplit_x_section_points` instead.', DeprecationWarning)
-
-        return unsplit_x_section_points(self, axis, ref_slice0 = ref_slice0, plus_face = plus_face, masked = masked)
-
-    # The implementations of the below functions have been moved to separate modules.
+    # the implementations of the functions below have been moved to separate modules
 
     def cell_geometry_is_defined(self, cell_kji0 = None, cell_geometry_is_defined_root = None, cache_array = True):
         """Returns True if the geometry of the specified cell is defined.

resqpy/grid_surface/_find_faces.py

@@ -558,6 +558,8 @@ def find_faces_to_represent_surface_regular_dense_optimised(grid,
         to a grid connection set; use the non-dense version of the function for a reduced memory footprint;
         this function is DEPRECATED pending proving of newer find_faces_to_represent_surface_regular_optimised()
     """
+    warnings.warn('DEPRECATED: grid_surface.find_faces_to_represent_surface_regular_dense_optimised() function; ' +
+                  'use find_faces_to_represent_surface_regular_optimised() instead')
 
     assert isinstance(grid, grr.RegularGrid)
     assert grid.is_aligned
@@ -1363,6 +1365,7 @@ def bisector_from_faces(  # type: ignore
           assigned to either the True or False part
         - this function is DEPRECATED, pending proving of newer indices based approach
     """
+    warnings.warn('DEPRECATED: grid_surface.bisector_from_faces() function; use bisector_from_face_indices() instead')
     assert len(grid_extent_kji) == 3
 
     # find the surface boundary (includes a buffer slice where surface does not reach edge of grid)

resqpy/lines/_polyline.py

@@ -25,25 +25,22 @@ class Polyline(rql_c._BasePolyline):
 
     resqml_type = 'PolylineRepresentation'
 
-    def __init__(
-            self,
-            parent_model,
-            uuid = None,
-            set_bool = None,  #: DEPRECATED
-            set_coord = None,
-            set_crs = None,
-            is_closed = None,
-            title = None,
-            rep_int_root = None,
-            originator = None,
-            extra_metadata = None):
+    def __init__(self,
+                 parent_model,
+                 uuid = None,
+                 set_coord = None,
+                 set_crs = None,
+                 is_closed = None,
+                 title = None,
+                 rep_int_root = None,
+                 originator = None,
+                 extra_metadata = None):
         """Initialises a new polyline object.
 
         arguments:
             parent_model (model.Model object): the model which the new PolylineRepresentation belongs to
             uuid (uuid.UUID, optional): the uuid of an existing RESQML PolylineRepresentation from which
                 to initialise the resqpy Polyline
-            set_bool (boolean, optional): DEPRECATED: synonym for is_closed argument
             set_coord (numpy float array, optional): an ordered set of xyz values used to define a new polyline;
                 last dimension of array must have extent 3; ignored if uuid is not None
             set_crs (uuid.UUID, optional): the uuid of a crs to be used when initialising from coordinates;
@@ -65,10 +62,6 @@ class Polyline(rql_c._BasePolyline):
         """
 
         self.model = parent_model
-        if set_bool is not None:
-            warnings.warn('DEPRECATED: use is_closed argument instead of set_bool, in Polyline initialisation')
-            if is_closed is None:
-                is_closed = set_bool
         self.isclosed = is_closed
         self.nodepatch = None
         self.crs_uuid = set_crs
@@ -466,22 +459,20 @@ class Polyline(rql_c._BasePolyline):
         if cache and self.centre is not None:
             return self.centre
         assert mode in ['weighted', 'sampled']
-        if mode == 'sampled':  # this mode is deprecated as it simply approximates the weighted mode
-            sample_points = self.equidistant_points(n, in_xy = in_xy)
-            centre = np.mean(sample_points, axis = 0)
-        else:  # 'weighted'
-            sum = np.zeros(3)
-            seg_count = len(self.coordinates) - 1
-            if self.isclosed:
-                seg_count += 1
-            d = 2 if in_xy else 3
-            p1 = np.zeros(3)
-            p2 = np.zeros(3)
-            for seg_index in range(seg_count):
-                successor = (seg_index + 1) % len(self.coordinates)
-                p1[:d], p2[:d] = self.coordinates[seg_index, :d], self.coordinates[successor, :d]
-                sum += (p1 + p2) * vu.naive_length(p2 - p1)
-            centre = sum / (2.0 * self.full_length(in_xy = in_xy))
+        if mode != 'weighted':  # ignore any other mode, ie. sampled
+            warnings.warn('DEPRECATED: weighted mode is only mode now supported for Polyline.balanced_centre()')
+        sum = np.zeros(3)
+        seg_count = len(self.coordinates) - 1
+        if self.isclosed:
+            seg_count += 1
+        d = 2 if in_xy else 3
+        p1 = np.zeros(3)
+        p2 = np.zeros(3)
+        for seg_index in range(seg_count):
+            successor = (seg_index + 1) % len(self.coordinates)
+            p1[:d], p2[:d] = self.coordinates[seg_index, :d], self.coordinates[successor, :d]
+            sum += (p1 + p2) * vu.naive_length(p2 - p1)
+        centre = sum / (2.0 * self.full_length(in_xy = in_xy))
         if cache:
             self.centre = centre
         return centre

resqpy/model/_model.py

@@ -1340,7 +1340,8 @@ class Model():
            an hdf5 file name is cached once determined for a given ext uuid; to clear the cache,
            call the h5_clear_filename_cache() method
         """
-
+        if isinstance(override, bool):
+            warnings.warn('DEPRECATED: boolean override argument to Model.h5_file_name(); use string instead')
         return m_h._h5_file_name(self, uuid = uuid, override = override, file_must_exist = file_must_exist)
 
     def h5_access(self, uuid = None, mode = 'r', override = 'default', file_path = None):
@@ -1366,7 +1367,8 @@ class Model():
            an exception will be raised if the hdf5 file cannot be opened; note that sometimes another
            piece of code accessing the file might cause a 'resource unavailable' exception
         """
-
+        if isinstance(override, bool):
+            warnings.warn('DEPRECATED: boolean override argument to Model.h5_access(); use string instead')
         return m_h._h5_access(self, uuid = uuid, mode = mode, override = override, file_path = file_path)
 
     def h5_release(self):

resqpy/multi_processing/wrappers/grid_surface_mp.py

@@ -43,6 +43,7 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
                                                     raw_bisector: bool = False,
                                                     use_pack: bool = False,
                                                     flange_radius = None,
+                                                    reorient = True,
                                                     n_threads = 20) -> Tuple[int, bool, str, List[Union[UUID, str]]]:
     """Multiprocessing wrapper function of find_faces_to_represent_surface_regular_optimised.
 
@@ -96,6 +97,8 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
            packed format, which will only be readable by resqpy based applications
         flange_radius (float, optional): the radial distance to use for outer flange extension points; if None,
            a large value will be calculated from the grid size; units are xy units of grid crs
+        reorient (bool, default True):  if True, the points are reoriented to minimise the
+              z range prior to retriangulation (ie. z axis is approximate normal to plane of points), to enhace the triangulation
         n_threads (int, default 20): the number of parallel threads to use in numba points in triangles function
 
     returns:
@@ -176,7 +179,7 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
         surf = rqs.Surface(model, crs_uuid = grid.crs.uuid, title = surf_title)
         flange_bool = surf.set_from_point_set(pset,
                                               convexity_parameter = 2.0,
-                                              reorient = True,
+                                              reorient = reorient,
                                               extend_with_flange = extend_fault_representation,
                                               flange_inner_ring = flange_inner_ring,
                                               saucer_parameter = saucer_parameter,
@@ -210,7 +213,7 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
         surface = rqs.Surface(model, crs_uuid = grid.crs.uuid, title = surf_title)
         flange_bool = surface.set_from_point_set(pset,
                                                  convexity_parameter = 2.0,
-                                                 reorient = True,
+                                                 reorient = reorient,
                                                  extend_with_flange = extend_fault_representation,
                                                  flange_inner_ring = flange_inner_ring,
                                                  saucer_parameter = saucer_parameter,

resqpy/olio/read_nexus_fault.py

@@ -64,7 +64,10 @@ def load_nexus_fault_mult_table_from_list(file_as_list):
                         outdata[mask] = np.concatenate(d_elems)
                         df = pd.DataFrame(outdata)
                         for column in df.columns:
-                            df[column] = pd.to_numeric(df[column], errors = 'ignore')
+                            try:
+                                df[column] = pd.to_numeric(df[column], errors = "coerce")
+                            except ValueError:
+                                pass
                         df.columns = ['i1', 'i2', 'j1', 'j2', 'k1', 'k2', 'mult']
                         df['grid'] = grid
                         df['name'] = name
@@ -114,7 +117,10 @@ def load_nexus_fault_mult_table_from_list(file_as_list):
                 outdata[mask] = np.concatenate(d_elems)
                 df = pd.DataFrame(outdata)
                 for column in df.columns:
-                    df[column] = pd.to_numeric(df[column], errors = 'ignore')
+                    try:
+                        df[column] = pd.to_numeric(df[column], errors = "coerce")
+                    except ValueError:
+                        pass
                 df.columns = ['i1', 'i2', 'j1', 'j2', 'k1', 'k2', 'mult']
                 df['grid'] = grid
                 df['name'] = name

resqpy/olio/relperm.py

@@ -91,7 +91,7 @@ class RelPerm(DataFrame):
             processed_phase_combo_checks.get(processed_phase_combo)(df)
             # ensure that missing capillary pressure values are stored as np.nan
             if 'Pc' in df.columns:
-                df['Pc'].replace('None', np.nan, inplace = True)
+                df['Pc'] = df['Pc'].replace('None', np.nan)
             # convert all values in the dataframe to numeric type
             df[df.columns] = df[df.columns].apply(pd.to_numeric, errors = 'coerce')
             # ensure that no other column besides Pc has missing values

resqpy/olio/triangulation.py

@@ -25,7 +25,7 @@ import resqpy.olio.vector_utilities as vec
 
 def _dt_scipy(points: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
     """Calculates the Delaunay triangulation for an array of points and the convex hull indices.
-    
+
     arguments:
         points (np.ndarray): coordinates of the points to triangulate; array has shape
             (npoints, ndim)
@@ -871,6 +871,7 @@ def surrounding_xy_ring(p,
        numpy float array of shape (N, 3) being xyz points in surrounding ring(s); z is set constant to
        mean value of z in p (optionally adjussted based on saucer_angle);
        N is count if inner_ring is False, 3 * count if True
+       radius used for ring of additional points
     """
 
     def make_ring(count, centre, radius, saucer_angle):
@@ -898,8 +899,8 @@ def surrounding_xy_ring(p,
         inner_radius = p_radius * 1.1
         assert radius > inner_radius
         in_ring = make_ring(2 * count, centre, inner_radius, saucer_angle)
-        return np.concatenate((in_ring, ring), axis = 0)
-    return ring
+        return np.concatenate((in_ring, ring), axis = 0), radius
+    return ring, radius
 
 
 def edges(t):

resqpy/olio/volume.py

@@ -77,26 +77,6 @@ def tetra_cell_volume(cp, centre = None, off_hand = False):
     return v / 6.0
 
 
-def tetra_volumes_slow(cp, centres = None, off_hand = False):
-    """Returns volume array for all hexahedral cells assuming bilinear faces, using loop over cells."""
-
-    # NB: deprecated, superceded by much faster function below
-    # todo: handle NaNs
-    # Pagoda style corner point data
-    assert cp.ndim == 7
-
-    flat = cp.reshape(-1, 2, 2, 2, 3)
-    cells = flat.shape[0]
-    if centres is None:
-        centres = np.mean(flat, axis = (1, 2, 3))
-    else:
-        centres = centres.reshape((-1, 3))
-    volumes = np.zeros(cells)
-    for cell in range(cells):
-        volumes[cell] = tetra_cell_volume(flat[cell], centre = centres[cell], off_hand = off_hand)
-    return volumes.reshape(cp.shape[0:3])
-
-
 def tetra_volumes(cp, centres = None, off_hand = False):
     """Returns volume array for all hexahedral cells assuming bilinear faces, using numpy operations.
 

resqpy/property/__init__.py

@@ -8,7 +8,8 @@ __all__ = [
     'reformat_column_edges_from_resqml_format', 'same_property_kind', 'selective_version_of_collection',
     'supported_local_property_kind_list', 'supported_property_kind_list', 'supported_facet_type_list',
     'expected_facet_type_dict', 'create_transmisibility_multiplier_property_kind',
-    'property_kind_and_facet_from_keyword', 'guess_uom', 'property_parts', 'property_part', 'make_aps_key'
+    'property_kind_and_facet_from_keyword', 'guess_uom', 'property_parts', 'property_part', 'make_aps_key',
+    'establish_zone_property_kind'
 ]
 
 from .property_common import property_collection_for_keyword,  \
@@ -27,7 +28,7 @@ from .property_common import property_collection_for_keyword,  \
     guess_uom,  \
     property_parts,  \
     property_part
-from .property_kind import PropertyKind, create_transmisibility_multiplier_property_kind
+from .property_kind import PropertyKind, create_transmisibility_multiplier_property_kind, establish_zone_property_kind
 from .string_lookup import StringLookup
 from .property_collection import PropertyCollection
 from .attribute_property_set import AttributePropertySet, ApsProperty, make_aps_key

resqpy/property/property_collection.py

@@ -760,7 +760,8 @@ class PropertyCollection():
                   title = None,
                   title_mode = None,
                   related_uuid = None,
-                  const_value = None):
+                  const_value = None,
+                  extra = None):
         """Returns a single part selected by those arguments which are not None.
 
            multiple_handling (string, default 'exception'): one of 'exception', 'none', 'first', 'oldest', 'newest'
@@ -799,7 +800,8 @@ class PropertyCollection():
                                                                 title = title,
                                                                 title_mode = title_mode,
                                                                 related_uuid = related_uuid,
-                                                                const_value = const_value)
+                                                                const_value = const_value,
+                                                                extra = extra)
         parts_list = temp_collection.parts()
         if len(parts_list) == 0:
             return None
@@ -832,7 +834,8 @@ class PropertyCollection():
                          title = None,
                          title_mode = None,
                          related_uuid = None,
-                         use_pack = True):
+                         use_pack = True,
+                         extra = None):
         """Returns the array of data for a single part selected by those arguments which are not None.
 
         arguments:
@@ -849,7 +852,7 @@ class PropertyCollection():
 
         Other optional arguments:
         realization, support_uuid, continuous, points, count, indexable, property_kind, facet_type, facet,
-        citation_title, time_series_uuid, time_index, uom, string_lookup_id, categorical, related_uuid:
+        citation_title, time_series_uuid, time_index, uom, string_lookup_id, categorical, related_uuid, extra:
 
         For each of these arguments: if None, then all members of collection pass this filter;
         if not None then only those members with the given value pass this filter;
@@ -885,7 +888,8 @@ class PropertyCollection():
                               multiple_handling = multiple_handling,
                               title = title,
                               title_mode = title_mode,
-                              related_uuid = related_uuid)
+                              related_uuid = related_uuid,
+                              extra = extra)
         if part is None:
             return None
         return self.cached_part_array_ref(part,

resqpy/rq_import/_grid_from_cp.py

@@ -511,8 +511,8 @@ class _GridFromCp:
                 assert len(where_defined) == 3 and len(where_defined[0]) > 0, 'no extant cell geometries'
                 sample_kji0 = (where_defined[0][0], where_defined[1][0], where_defined[2][0])
             sample_cp = self.__cp_array[sample_kji0]
-            self.__cell_ijk_lefthanded = (vec.clockwise(sample_cp[0, 0, 0], sample_cp[0, 1, 0], sample_cp[0, 0, 1]) >=
-                                          0.0)
+            self.__cell_ijk_lefthanded =  \
+                (vec.clockwise(sample_cp[0, 0, 0], sample_cp[0, 1, 0], sample_cp[0, 0, 1]) >= 0.0)
             if not self.grid.k_direction_is_down:
                 self.__cell_ijk_lefthanded = not self.__cell_ijk_lefthanded
             if self.__crs.is_right_handed_xyz():