resqpy 4.12.0__tar.gz → 4.12.2__tar.gz

{resqpy-4.12.0 → resqpy-4.12.2}/PKG-INFO

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

{resqpy-4.12.0 → resqpy-4.12.2}/pyproject.toml

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

{resqpy-4.12.0 → resqpy-4.12.2}/resqpy/__init__.py

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

{resqpy-4.12.0 → resqpy-4.12.2}/resqpy/lines/_polyline.py

@@ -8,15 +8,15 @@ import math as maths
 import numpy as np
 import warnings
 
-import resqpy.olio.intersection as meet
-import resqpy.lines
+import resqpy.crs as rqc
+import resqpy.lines._common as rql_c
 import resqpy.property as rqp
 import resqpy.olio.point_inclusion as pip
 import resqpy.olio.uuid as bu
 import resqpy.olio.vector_utilities as vu
 import resqpy.olio.write_hdf5 as rwh5
 import resqpy.olio.xml_et as rqet
-import resqpy.lines._common as rql_c
+import resqpy.olio.intersection as meet
 from resqpy.olio.xml_namespaces import curly_namespace as ns
 
 
@@ -330,21 +330,17 @@ class Polyline(rql_c._BasePolyline):
         return result
 
     def is_clockwise(self, trust_metadata = True):
-        """Returns True if first non-straight triplet of nodes is clockwise in the xy plane; False if anti-clockwise.
-
-        note:
-           this method currently assumes that the xy axes are left-handed
-        """
+        """Returns True if closed polyline is clockwise when viewed from above; False if anti-clockwise."""
 
+        assert self.isclosed, 'Polyline.is_clockwise() called for open polyline (only applicable to closed polylines)'
         if trust_metadata and self.extra_metadata is not None and 'is_clockwise' in self.extra_metadata.keys():
             return str(self.extra_metadata['is_clockwise']).lower() == 'true'
-        result = None
-        for node in range(3, len(self.coordinates)):
-            cw = vu.clockwise(self.coordinates[node - 2], self.coordinates[node - 1], self.coordinates[node])
-            if cw == 0.0:
-                continue  # striaght line section
-            result = (cw > 0.0)
-            break
+        centre = np.mean(self.coordinates, axis = 0)
+        cw = vu.clockwise(centre, self.coordinates[0], self.coordinates[1])
+        result = (cw > 0.0)
+        crs = rqc.Crs(self.model, uuid = self.crs_uuid)
+        if crs.is_right_handed_xy():
+            result = not result
         if result is not None:
             self.append_extra_metadata({'is_clockwise': str(result).lower()})
         return result
@@ -716,8 +712,8 @@ class Polyline(rql_c._BasePolyline):
 
         assert mode in ['square', 'perimeter', 'circle']
         assert 0.0 <= norm_x <= 1.0 and 0.0 <= norm_y <= 1.0
-        assert self.is_convex(
-        ), 'attempt to find denormalised x,y within a polyline that is not a closed convex polygon'
+        assert self.is_convex(),  \
+            'attempt to find denormalised x,y within a polyline that is not a closed convex polygon'
         centre_xy = self.balanced_centre()[:2]
         x, y = None, None
         if mode == 'square':

{resqpy-4.12.0 → resqpy-4.12.2}/resqpy/lines/_polyline_set.py

@@ -466,23 +466,29 @@ class PolylineSet(rql_c._BasePolyline):
             closed_node = rqet.find_nested_tags(self.root, ['LinePatch', 'ClosedPolylines'])
             if closed_node is not None:
                 closed_array[:] = self.get_bool_array(closed_node)
+            else:
+                closed_array = None
         if coordinates is None:
             coordinates = self.coordinates
         if crs_uuid is None:
             crs_uuid = self.crs_uuid
         if rep_int_root is None:
             rep_int_root = self.rep_int_root
+
         polys = []
         count = 0
         for i in range(len(count_perpol)):
             if i != len(count_perpol) - 1:
                 subset = coordinates[count:int(count_perpol[i]) + count].copy()
             else:
-                subset = coordinates[count:int(count_perpol[i]) + count + 1].copy()
-            if vu.isclose(subset[0], subset[-1]):
-                isclosed = True
+                subset = coordinates[count:int(count_perpol[i]) + count + 1].copy()  # is this correct?
+            duplicated_end_points = np.all(np.isclose(subset[0], subset[-1])) and len(subset) > 2
+            if closed_array is None:
+                isclosed = duplicated_end_points
             else:
                 isclosed = closed_array[i]
+            if isclosed and duplicated_end_points:
+                subset = subset[:-1]
             count += int(count_perpol[i])
             subtitle = f"{self.title} {i+1}"
             polys.append(

{resqpy-4.12.0 → resqpy-4.12.2}/resqpy/well/_blocked_well.py

@@ -1,7 +1,7 @@
 """BlockedWell class."""
 
 # Nexus is a registered trademark of the Halliburton Company
-# RMS and ROXAR are registered trademarks of Roxar Software Solutions AS, an Emerson company
+# RMS and ROXAR are registered trademarks of Roxar Software Solutions AS, an AspenTech company
 
 import logging
 
@@ -301,7 +301,20 @@ class BlockedWell(BaseResqpy):
         gi_node = rqet.find_tag(node, 'GridIndices')
         assert gi_node is not None, 'blocked well grid indices hdf5 reference not found in xml'
         rqwu.load_hdf5_array(self, gi_node, 'grid_indices', dtype = 'int')
-        assert self.grid_indices is not None and self.grid_indices.ndim == 1 and self.grid_indices.size == self.node_count - 1
+        # assert self.grid_indices is not None and self.grid_indices.ndim == 1 and self.grid_indices.size == self.node_count - 1
+        # temporary code to handle blocked wells with incorrectly shaped grid indices wrt. nodes
+        assert self.grid_indices is not None and self.grid_indices.ndim == 1
+        if self.grid_indices.size != self.node_count - 1:
+            if self.grid_indices.size == self.cell_count and self.node_count == 2 * self.cell_count:
+                log.warning(f'handling node duplication or missing unblocked intervals in blocked well: {self.title}')
+
+                expanded_grid_indices = np.full(self.node_count - 1, -1, dtype = int)
+                expanded_grid_indices[::2] = self.grid_indices
+                self.grid_indices = expanded_grid_indices
+            else:
+                raise ValueError(
+                    f'incorrect grid indices size with respect to node count in blocked well: {self.title}')
+        # end of temporary code
         unique_grid_indices = np.unique(self.grid_indices)  # sorted list of unique values
         self.gridind_null = rqet.find_tag_int(gi_node, 'NullValue')
         if self.gridind_null is None:
@@ -1477,6 +1490,10 @@ class BlockedWell(BaseResqpy):
 
         grid_crs_list = self.__verify_number_of_grids_and_crs_units(column_list = column_list)
 
+        if doing_kh or doing_xyz or doing_angles or doing_entry_exit:
+            for grid in self.grid_list:
+                grid.cache_all_geometry_arrays()
+
         k_face_check = np.zeros((2, 2), dtype = int)
         k_face_check[1, 1] = 1  # now represents entry, exit of K-, K+
         k_face_check_end = k_face_check.copy()
@@ -3057,7 +3074,7 @@ class BlockedWell(BaseResqpy):
                     if BlockedWell.__is_float_column(col_name):
                         form = '{0:>' + str(width) + '.3f}'
                         value = row[col_name]
-                        if col_name == 'ANGLA' and (np.isnan(value) or value is None):
+                        if col_name == 'ANGLA' and (pd.isna(row[col_name]) or value is None or np.isnan(value)):
                             value = 0.0
                         fp.write(sep + form.format(float(value)))
                     else: