resqpy 4.14.2__py3-none-any.whl → 5.1.6__py3-none-any.whl

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/_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/_extract_functions.py

@@ -445,7 +445,12 @@ def extract_stratigraphy(grid):
                                 object = grid,
                                 array_attribute = 'stratigraphic_units',
                                 dtype = 'int')
-    assert len(grid.stratigraphic_units) == grid.nk_plus_k_gaps
+    if (len(grid.stratigraphic_units) != grid.nk_plus_k_gaps):
+        log.error("Unable to load Stratigraphy," +
+                  f" the number of stratigraphic units {len(grid.stratigraphic_units)}" +
+                  f" does not equal the number of layers plus gaps {grid.nk_plus_k_gaps}")
+        grid.stratigraphic_column_rank_uuid = None
+        grid.stratigraphic_units = None
 
 
 def extract_children(grid):
@@ -501,7 +506,7 @@ def extract_inactive_mask(grid, check_pinchout = False):
     geom_defined = grr_dg.cell_geometry_is_defined_ref(grid)
     if grid.inactive is None:
         if geom_defined is None or geom_defined is True:
-            grid.inactive = np.zeros(tuple(grid.extent_kji))  # ie. all active
+            grid.inactive = np.zeros(tuple(grid.extent_kji), dtype = bool)  # ie. all active
         else:
             grid.inactive = np.logical_not(grr_dg.cell_geometry_is_defined_ref(grid))
     if check_pinchout:
@@ -524,6 +529,7 @@ def extract_inactive_mask(grid, check_pinchout = False):
             active_gpc = rprop.selective_version_of_collection(active_gpc,
                                                                time_index = grid.time_index,
                                                                time_series_uuid = grid.time_series_uuid)
+            active_parts = active_gpc.parts()
         else:
             active_parts = []
             for part in active_gpc.parts():

resqpy/grid/_grid.py

@@ -15,6 +15,7 @@ import resqpy.grid as grr
 import resqpy.grid_surface as rqgs
 import resqpy.fault as rqf
 import resqpy.property as rqp
+import resqpy.lines as rql
 import resqpy.olio.grid_functions as gf
 import resqpy.olio.uuid as bu
 import resqpy.olio.write_hdf5 as rwh5
@@ -75,7 +76,8 @@ class Grid(BaseResqpy):
                  geometry_required = True,
                  title = None,
                  originator = None,
-                 extra_metadata = {}):
+                 extra_metadata = {},
+                 load_inactive = True):
         """Create a Grid object and optionally populate from xml tree.
 
         arguments:
@@ -91,6 +93,8 @@ class Grid(BaseResqpy):
               ignored if loading from xml
            extra_metadata (dict, optional): dictionary of extra metadata items to add to the grid;
               ignored if loading from xml
+           load_inactive (bool, default True): if True and uuid is provided, the inactive attribubte is
+              populated if a property of kind 'active' is found for the grid
 
         returns:
            a newly created Grid object
@@ -147,6 +151,8 @@ class Grid(BaseResqpy):
             self.title = 'ROOT'
 
         if uuid is not None:
+            if load_inactive:
+                self.extract_inactive_mask()
             if geometry_required:
                 assert self.geometry_root is not None, 'grid geometry not present in xml'
             if find_properties:
@@ -185,7 +191,6 @@ class Grid(BaseResqpy):
         self.extract_parent()
         self.extract_children()
         # self.create_column_pillar_mapping()  # mapping now created on demand in other methods
-        self.extract_inactive_mask()
         self.extract_stratigraphy()
         self.get_represented_interpretation()
 
@@ -265,6 +270,10 @@ class Grid(BaseResqpy):
             return np.count_nonzero(self.array_cell_geometry_is_defined)
         return None
 
+    def is_big(self):
+        """Returns True if number of cells exceeds 2^31 - 1, otherwise False."""
+        return (np.prod(self.extent_kji) >= 2_147_483_648)
+
     def natural_cell_index(self, cell_kji0):
         """Returns a single integer for the cell, being the index into a flattened array."""
 
@@ -671,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.
@@ -1489,6 +1492,86 @@ class Grid(BaseResqpy):
         """
         return z_corner_point_depths(self, order = order)
 
+    def frontier(self, set_z_zero = True, title = None, add_as_part = True, mode = 'mean'):
+        """Returns a frontier polygon (closed polyline) based on midpoints of edge coordinate lines, with z set to zero.
+        
+        arguments:
+            - set_z_zero (bool, default True): if True, the z values of the returned polyline are all set to zero; if False,
+              they are left at the midpoint z values from the edge coordinate lines
+            - title (str, optional): the citation title for the polyline; if None, one is generated using the grid title
+            - add_as_part (bool default True): if True, the xml is created for the polyline and it is added as a part to
+              the model; if False, the create_xml() method is not called fot the polyline
+            - mode (str, default 'mean'): one of 'mean', 'top', 'base', 'inner', 'outer' determining how a non-vertical
+              edge coordinate line is converted to a point to include in the frontier
+
+        returns:
+            - closed Polyline representing the frontier of the grid in plan view
+        """
+
+        def get_point(clep, mode, centrum):
+            if mode == 'mean':
+                return np.nanmean(clep, axis = 0)
+            if mode == 'top':
+                return clep[0]
+            if mode == 'base':
+                return clep[-1]
+            assert mode in ['inner', 'outer'], f'unrecognised frontier mode: {mode}'
+            vp = clep - np.expand_dims(centrum, axis = 0)
+            dp = np.sum(vp * vp, axis = -1)
+            if (dp[0] < dp[1] and mode == 'inner') or (dp[0] > dp[1] and mode == 'outer'):
+                return clep[0]
+            return clep[-1]
+
+        assert mode in ['mean', 'top', 'base', 'inner', 'outer']
+        coords = self.coordinate_line_end_points()
+        centrum = None
+        if mode in ['inner', 'outer']:
+            centrum = np.nanmean(np.concatenate((coords[0, 0], coords[0, -1], coords[-1, 0], coords[-1, -1]), axis = 0),
+                                 axis = 0)
+            assert not np.any(
+                np.isnan(centrum)), f'trying to make frontier polygon in mode {mode} when corners of grid not defined'
+        nj = self.nj
+        ni = self.ni
+        frontier = np.zeros((2 * (nj + ni), 3), dtype = float)
+        f_i = 0
+        for i in range(self.ni):
+            c = get_point(coords[0, i], mode, centrum)
+            if np.any(np.isnan(c)):
+                continue
+            frontier[f_i] = c
+            f_i += 1
+        for j in range(self.nj):
+            c = get_point(coords[j, ni], mode, centrum)
+            if np.any(np.isnan(c)):
+                continue
+            frontier[f_i] = c
+            f_i += 1
+        for i in range(self.ni, 0, -1):
+            c = get_point(coords[nj, i], mode, centrum)
+            if np.any(np.isnan(c)):
+                continue
+            frontier[f_i] = c
+            f_i += 1
+        for j in range(self.nj, 0, -1):
+            c = get_point(coords[j, 0], mode, centrum)
+            if np.any(np.isnan(c)):
+                continue
+            frontier[f_i] = c
+            f_i += 1
+        assert 4 <= f_i <= 2 * (nj + ni), 'failed to define frontier polygon (NaNs in grid geometry?)'
+        if set_z_zero:
+            frontier[:, 2] = 0.0
+        if not title:
+            title = f'frontier of {self.title}'
+        pl = rql.Polyline(self.model,
+                          set_coord = frontier[:f_i],
+                          set_crs = self.crs_uuid,
+                          is_closed = True,
+                          title = title)
+        if add_as_part:
+            pl.create_xml()
+        return pl
+
     def corner_points(self, cell_kji0 = None, points_root = None, cache_resqml_array = True, cache_cp_array = False):
         """Returns a numpy array of corner points for a single cell or the whole grid.
 
@@ -2255,9 +2338,9 @@ class Grid(BaseResqpy):
         pc = self.extract_property_collection()
 
         if baffle_triplet is not None:
-            trm_k[1:-1] = np.where(baffle_triplet[0], 0.0, trm_k[1:-1])
-            trm_j[:, 1:-1] = np.where(baffle_triplet[1], 0.0, trm_j[:, 1:-1])
-            trm_i[:, :, 1:-1] = np.where(baffle_triplet[2], 0.0, trm_i[:, :, 1:-1])
+            trm_k[1:-1][baffle_triplet[0]] = 0.0
+            trm_j[:, 1:-1][baffle_triplet[1]] = 0.0
+            trm_i[:, :, 1:-1][baffle_triplet[2]] = 0.0
 
         if composite_property:
             tr_composite = np.concatenate((trm_k.flat, trm_j.flat, trm_i.flat))

resqpy/grid/_grid_types.py

@@ -51,13 +51,15 @@ def is_regular_grid(grid_root):
     return grid_flavour(grid_root) == 'IjkBlockGrid'
 
 
-def any_grid(parent_model, uuid = None, find_properties = True):
+def any_grid(parent_model, uuid = None, find_properties = True, load_inactive = True):
     """Returns a Grid or RegularGrid or UnstructuredGrid object depending on the extra metadata in the xml.
 
     arguments:
         parent_model (Model): the model within which the grid exists
         uuid (UUID): the uuid of the grid object to be instantiated
         find_properties (bool, default True): passed onward to the instantiation method
+        load_inactive (bool, default True): if True and uuid is provided, the inactive attribubte is
+            populated if a property of kind 'active' is found for the grid
 
     note:
         full list of resqpy grid class objects which could be returned:
@@ -70,17 +72,30 @@ def any_grid(parent_model, uuid = None, find_properties = True):
     if flavour is None:
         return None
     if flavour == 'IjkGrid':
-        return grr.Grid(parent_model, uuid = uuid, find_properties = find_properties)
+        return grr.Grid(parent_model, uuid = uuid, find_properties = find_properties, load_inactive = load_inactive)
     if flavour == 'IjkBlockGrid':
-        return grr.RegularGrid(parent_model, extent_kji = None, uuid = uuid, find_properties = find_properties)
+        return grr.RegularGrid(parent_model,
+                               extent_kji = None,
+                               uuid = uuid,
+                               find_properties = find_properties,
+                               load_inactive = load_inactive)
     if flavour == 'UnstructuredGrid':
-        return rug.UnstructuredGrid(parent_model, uuid = uuid, find_properties = find_properties)
+        return rug.UnstructuredGrid(parent_model,
+                                    uuid = uuid,
+                                    find_properties = find_properties,
+                                    load_inactive = load_inactive)
     if flavour == 'TetraGrid':
-        return rug.TetraGrid(parent_model, uuid = uuid, find_properties = find_properties)
+        return rug.TetraGrid(parent_model,
+                             uuid = uuid,
+                             find_properties = find_properties,
+                             load_inactive = load_inactive)
     if flavour == 'HexaGrid':
-        return rug.HexaGrid(parent_model, uuid = uuid, find_properties = find_properties)
+        return rug.HexaGrid(parent_model, uuid = uuid, find_properties = find_properties, load_inactive = load_inactive)
     if flavour == 'PyramidGrid':
         return rug.PyramidGrid(parent_model, uuid = uuid, find_properties = find_properties)
     if flavour == 'PrismGrid':
-        return rug.PrismGrid(parent_model, uuid = uuid, find_properties = find_properties)
+        return rug.PrismGrid(parent_model,
+                             uuid = uuid,
+                             find_properties = find_properties,
+                             load_inactive = load_inactive)
     return None

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/_regular_grid.py

@@ -46,7 +46,8 @@ class RegularGrid(grr_g.Grid):
                  find_properties = True,
                  title = None,
                  originator = None,
-                 extra_metadata = {}):
+                 extra_metadata = {},
+                 load_inactive = True):
         """Creates a regular grid object based on dxyz, or derived from a Mesh object.
 
         arguments:
@@ -82,6 +83,8 @@ class RegularGrid(grr_g.Grid):
               ignored if loading from xml
            extra_metadata (dict, optional): dictionary of extra metadata items to add to the grid;
               ignored if loading from xml
+           load_inactive (bool, default True): if True and uuid is provided, the inactive attribubte is
+              populated if a property of kind 'active' is found for the grid
 
         returns:
            a newly created RegularGrid object with inheritance from the Grid class
@@ -184,7 +187,8 @@ class RegularGrid(grr_g.Grid):
                              geometry_required = False,
                              title = title,
                              originator = originator,
-                             extra_metadata = extra_metadata)
+                             extra_metadata = extra_metadata,
+                             load_inactive = load_inactive)
 
         self.geometry_defined_for_all_cells_cached = True
         self.geometry_defined_for_all_pillars_cached = True

resqpy/grid_surface/__init__.py

@@ -1,33 +1,19 @@
 """Classes for RESQML objects related to surfaces."""
 
 __all__ = [
-    "GridSkin",
-    "generate_untorn_surface_for_layer_interface",
-    "generate_torn_surface_for_layer_interface",
-    "generate_torn_surface_for_x_section",
-    "generate_untorn_surface_for_x_section",
-    "point_is_within_cell",
-    "create_column_face_mesh_and_surface",
-    "find_intersections_of_trajectory_with_surface",
-    "find_intersections_of_trajectory_with_layer_interface",
-    "find_first_intersection_of_trajectory_with_surface",
+    "GridSkin", "generate_untorn_surface_for_layer_interface", "generate_torn_surface_for_layer_interface",
+    "generate_torn_surface_for_x_section", "generate_untorn_surface_for_x_section", "point_is_within_cell",
+    "create_column_face_mesh_and_surface", "find_intersections_of_trajectory_with_surface",
+    "find_intersections_of_trajectory_with_layer_interface", "find_first_intersection_of_trajectory_with_surface",
     "find_first_intersection_of_trajectory_with_layer_interface",
     "find_first_intersection_of_trajectory_with_cell_surface",
-    "find_intersection_of_trajectory_interval_with_column_face",
-    "trajectory_grid_overlap",
-    "populate_blocked_well_from_trajectory",
-    "generate_surface_for_blocked_well_cells",
-    "find_faces_to_represent_surface_staffa",
-    "find_faces_to_represent_surface_regular",
-    "find_faces_to_represent_surface_regular_optimised",
-    "find_faces_to_represent_surface",
-    "bisector_from_faces",
-    "column_bisector_from_faces",
-    "shadow_from_faces",
-    "get_boundary",
-    "_where_true",
-    "_first_true",
-    "intersect_numba",
+    "find_intersection_of_trajectory_interval_with_column_face", "trajectory_grid_overlap",
+    "populate_blocked_well_from_trajectory", "generate_surface_for_blocked_well_cells",
+    "find_faces_to_represent_surface_staffa", "find_faces_to_represent_surface_regular",
+    "find_faces_to_represent_surface_regular_optimised", "find_faces_to_represent_surface_regular_dense_optimised",
+    "find_faces_to_represent_surface", "bisector_from_faces", "bisector_from_face_indices",
+    "packed_bisector_from_face_indices", "column_bisector_from_faces", "shadow_from_faces", "get_boundary",
+    "get_boundary_dict", "_where_true", "_first_true", "intersect_numba", "get_box"
 ]
 
 from ._grid_skin import GridSkin
@@ -52,19 +38,12 @@ from ._blocked_well_populate import (
     populate_blocked_well_from_trajectory,
     generate_surface_for_blocked_well_cells,
 )
-from ._find_faces import (
-    find_faces_to_represent_surface_staffa,
-    find_faces_to_represent_surface_regular,
-    find_faces_to_represent_surface_regular_optimised,
-    find_faces_to_represent_surface,
-    bisector_from_faces,
-    column_bisector_from_faces,
-    shadow_from_faces,
-    get_boundary,
-    _where_true,
-    _first_true,
-    intersect_numba,
-)
+from ._find_faces import (find_faces_to_represent_surface_staffa, find_faces_to_represent_surface_regular,
+                          find_faces_to_represent_surface_regular_optimised,
+                          find_faces_to_represent_surface_regular_dense_optimised, find_faces_to_represent_surface,
+                          bisector_from_faces, bisector_from_face_indices, packed_bisector_from_face_indices,
+                          column_bisector_from_faces, shadow_from_faces, get_boundary, get_boundary_dict, _where_true,
+                          _first_true, intersect_numba, get_box)
 
 # Set "module" attribute of all public objects to this path.
 for _name in __all__:

resqpy/grid_surface/_blocked_well_populate.py

@@ -118,7 +118,7 @@ def populate_blocked_well_from_trajectory(blocked_well,
         if xyz is None:
             log.error('failed to lazily find intersection of trajectory with top surface of grid')
             return None
-        cell_kji0 = np.array((0, col_ji0[0], col_ji0[1]), dtype = int)
+        cell_kji0 = np.array((0, col_ji0[0], col_ji0[1]), dtype = np.int32)
         axis = 0
         polarity = 0
 
@@ -133,7 +133,7 @@ def populate_blocked_well_from_trajectory(blocked_well,
         else:
             log.debug(f"skin intersection x,y,z: {xyz}; knot: {entry_knot}; cell kji0: {cell_kji0}; face: "
                       f"{'KJI'[axis]}{'-+'[polarity]}")
-            cell_kji0 = np.array(cell_kji0, dtype = int)
+            cell_kji0 = np.array(cell_kji0, dtype = np.int32)
 
     previous_kji0 = cell_kji0.copy()
     previous_kji0[axis] += polarity * 2 - 1  # note: previous may legitimately be 'beyond' edge of grid
@@ -244,9 +244,9 @@ def populate_blocked_well_from_trajectory(blocked_well,
 
     blocked_well.node_mds = np.array(node_mds_list, dtype = float)
     blocked_well.node_count = node_count
-    blocked_well.grid_indices = np.array(grid_indices_list, dtype = int)
-    blocked_well.cell_indices = np.array(cell_indices_list, dtype = int)
-    blocked_well.face_pair_indices = np.array(face_pairs_list, dtype = int)
+    blocked_well.grid_indices = np.array(grid_indices_list, dtype = np.int32)
+    blocked_well.cell_indices = np.array(cell_indices_list, dtype = np.int64)
+    blocked_well.face_pair_indices = np.array(face_pairs_list, dtype = np.int8)
     blocked_well.cell_count = cell_count
     blocked_well.grid_list = [grid]