resqpy 5.1.7__tar.gz → 5.1.9__tar.gz

{resqpy-5.1.7 → resqpy-5.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: resqpy
-Version: 5.1.7
+Version: 5.1.9
 Summary: Python API for working with RESQML models
 License: MIT
 Keywords: RESQML

{resqpy-5.1.7 → resqpy-5.1.9}/pyproject.toml

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

{resqpy-5.1.7 → resqpy-5.1.9}/resqpy/__init__.py

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

{resqpy-5.1.7 → resqpy-5.1.9}/resqpy/grid_surface/_find_faces.py

@@ -881,7 +881,8 @@ def find_faces_to_represent_surface_regular_optimised(grid,
                                                       raw_bisector = False,
                                                       n_batches = 20,
                                                       packed_bisectors = False,
-                                                      patch_indices = None):
+                                                      patch_indices = None,
+                                                      direction = 'IJK'):
     """Returns a grid connection set containing those cell faces which are deemed to represent the surface.
 
     argumants:
@@ -919,6 +920,8 @@ def find_faces_to_represent_surface_regular_optimised(grid,
            non curtain bisectors are returned in packed form
         patch_indices (numpy int array, optional): if present, an array over grid cells indicating which 
            patch of surface is applicable in terms of a bisector, for each cell
+        direction (str, default 'IJK'): indicates which face directions to include; one of 'I', 'J', 'K',
+           'IJ', IK', 'JK', 'IJK"
 
     returns:
         gcs  or  (gcs, gcs_props)
@@ -935,7 +938,8 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         organisational objects for the feature are created if needed;
         if the offset return property is requested, the implicit units will be the z units of the grid's crs;
         if patch_indices is present and grid bisectors are being returned, a composite bisector array is returned
-        with elements set from individual bisectors for each patch of surface
+        with elements set from individual bisectors for each patch of surface;
+        if generating a grid bisector property then direction will typically need to be 'IJK'
     """
 
     assert isinstance(grid, grr.RegularGrid)
@@ -1018,7 +1022,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     k_depths = None
     k_offsets = None
     k_props = None
-    if nk > 1:
+    if nk > 1 and 'K' in direction:
         # log.debug("searching for k faces")
 
         k_hits, k_depths = vec.points_in_triangles_aligned_unified(grid.ni, grid.nj, 0, 1, 2, p, n_batches)
@@ -1061,7 +1065,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     j_depths = None
     j_offsets = None
     j_props = None
-    if grid.nj > 1:
+    if grid.nj > 1 and 'J' in direction:
         # log.debug("searching for J faces")
 
         j_hits, j_depths = vec.points_in_triangles_aligned_unified(grid.ni, nk, 0, 2, 1, p, n_batches)
@@ -1113,7 +1117,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     i_depths = None
     i_offsets = None
     i_props = None
-    if grid.ni > 1:
+    if grid.ni > 1 and 'I' in direction:
         # log.debug("searching for I faces")
 
         i_hits, i_depths = vec.points_in_triangles_aligned_unified(grid.nj, nk, 1, 2, 0, p, n_batches)

{resqpy-5.1.7 → resqpy-5.1.9}/resqpy/multi_processing/wrappers/grid_surface_mp.py

@@ -50,7 +50,8 @@ def find_faces_to_represent_surface_regular_wrapper(
         n_threads: int = 20,
         patchwork: bool = False,
         grid_patching_property_uuid: Optional[Union[UUID, str]] = None,
-        surface_patching_property_uuid: Optional[Union[UUID, str]] = None) ->  \
+        surface_patching_property_uuid: Optional[Union[UUID, str]] = None,
+        direction = 'IJK') ->  \
             Tuple[int, bool, str, List[Union[UUID, str]]]:
     """Multiprocessing wrapper function of find_faces_to_represent_surface_regular_optimised.
 
@@ -116,6 +117,8 @@ def find_faces_to_represent_surface_regular_wrapper(
         surface_patching_property_uuid (uuid, optional): required if patchwork is True, the uuid of a discrete or
            categorical property on the patches of the surface, identifying the value of the grid patching property
            that each patch relates to
+        direction (str, default 'IJK'): indicates which face directions to include; one of 'I', 'J', 'K',
+           'IJ', IK', 'JK', 'IJK"
 
     returns:
         Tuple containing:
@@ -134,6 +137,7 @@ def find_faces_to_represent_surface_regular_wrapper(
           the shift being in the +ve z hemisphere; in either case the direction of the shift is perpendicular
           to the average plane of the original points
         - patchwork is not compatible with re-triangulation
+        - if grid bisector is included in return properties, direction will usually need to be 'IJK'
     """
     tmp_dir = Path(parent_tmp_dir) / f"{uuid.uuid4()}"
     tmp_dir.mkdir(parents = True, exist_ok = True)
@@ -302,7 +306,8 @@ def find_faces_to_represent_surface_regular_wrapper(
                                                                      raw_bisector = raw_bisector,
                                                                      n_batches = n_threads,
                                                                      packed_bisectors = use_pack,
-                                                                     patch_indices = patch_indices)
+                                                                     patch_indices = patch_indices,
+                                                                     direction = direction)
 
     success = False
 

{resqpy-5.1.7 → resqpy-5.1.9}/resqpy/surface/_tri_mesh.py

@@ -9,6 +9,7 @@ import numpy as np
 
 import resqpy.crs as rqc
 import resqpy.surface as rqs
+import resqpy.weights_and_measures as wam
 import resqpy.olio.vector_utilities as vec
 import resqpy.olio.uuid as bu
 
@@ -568,6 +569,27 @@ class TriMesh(rqs.Mesh):
 
         return p
 
+    def area(self, required_uom = None):
+        """Returns approximate area of tri mesh based on proportion of non-NaN z values.
+
+        arguments:
+            - required_uom (str, optional): RESQML area unit of measure string for result
+
+        returns:
+            - float being the approximate area of the tri mesh in its xy projection
+
+        note:
+            - default uom is crs xy_units squared
+        """
+        a = 1.0 - (float(np.count_nonzero(np.isnan(self.full_array_ref()[..., 2]))) / float(self.nj * self.ni))
+        a *= float((self.nj - 1) * (self.ni - 1)) * self.t_side * self.t_side * root_3_by_2
+        if required_uom is not None:
+            crs = rqc.Crs(self.model, uuid = self.crs_uuid)
+            if required_uom != crs.xy_units + '2':
+                uom = ('ft' if crs.xy_units.startswith('ft') else crs.xy_units) + '2'
+                a = wam.convert(a, uom, required_uom)
+        return a
+
     def is_compatible_with(self, other_tri_mesh):
         """Returns True if this tri mesh has the same xy points as the other."""