resqpy 5.1.0__tar.gz → 5.1.2__tar.gz

{resqpy-5.1.0 → resqpy-5.1.2}/PKG-INFO

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

{resqpy-5.1.0 → resqpy-5.1.2}/pyproject.toml

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

{resqpy-5.1.0 → resqpy-5.1.2}/resqpy/__init__.py

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

{resqpy-5.1.0 → resqpy-5.1.2}/resqpy/model/_forestry.py

@@ -686,17 +686,23 @@ def _copy_referenced_parts(model, other_model, realization, consolidate, force,
             resident_uuid_int = model.consolidation.map[ref_uuid_int]
             assert resident_uuid_int is not None
             # find referring node for ref_uuid_int and modify its reference to resident_uuid_int
-            if reference_node_dict is None:
+            if reference_node_dict is None:  # now mapping uuid int to list of nodes
                 ref_nodes = rqet.list_obj_references(root_node)
                 reference_node_dict = {}
                 for ref_node in ref_nodes:
                     uuid_node = rqet.find_tag(ref_node, 'UUID')
                     uuid_int = bu.uuid_from_string(uuid_node.text).int
-                    reference_node_dict[uuid_int] = uuid_node
-            uuid_node = reference_node_dict[ref_uuid_int]
-            uuid_node.text = str(bu.uuid_from_int(resident_uuid_int))
-            reference_node_dict.pop(ref_uuid_int)
-            reference_node_dict[resident_uuid_int] = uuid_node
+                    if uuid_int in reference_node_dict:
+                        reference_node_dict[uuid_int].append(uuid_node)
+                    else:
+                        reference_node_dict[uuid_int] = [uuid_node]
+            uuid_node_list = reference_node_dict.pop(ref_uuid_int)
+            for uuid_node in uuid_node_list:
+                uuid_node.text = str(bu.uuid_from_int(resident_uuid_int))
+            if resident_uuid_int in reference_node_dict:
+                reference_node_dict[resident_uuid_int] += uuid_node_list
+            else:
+                reference_node_dict[resident_uuid_int] = uuid_node_list
 
 
 def _copy_relationships_for_present_targets(model, other_model, consolidate, force, resident_uuid, root_node):

{resqpy-5.1.0 → resqpy-5.1.2}/resqpy/multi_processing/wrappers/grid_surface_mp.py

@@ -161,7 +161,8 @@ def find_faces_to_represent_surface_regular_wrapper(
     if flange_radius is None:
         flange_radius = 5.0 * np.sum(np.array(grid.extent_kji, dtype = float) * np.array(grid.aligned_dxyz()))
     s_model = rq.Model(surface_epc, quiet = True)
-    model.copy_uuid_from_other_model(s_model, uuid = str(surface_uuid))
+    surface_uuid = str(surface_uuid)
+    model.copy_uuid_from_other_model(s_model, uuid = surface_uuid)
     if surface_patching_property_uuid is not None:
         model.copy_uuid_from_other_model(s_model, uuid = surface_patching_property_uuid)
         uuid_list.append(surface_patching_property_uuid)
@@ -213,7 +214,7 @@ def find_faces_to_represent_surface_regular_wrapper(
         inherit_interpretation_relationship(model, surface_uuid, surf.uuid)
         surface_uuid = surf.uuid
 
-    surface = rqs.Surface(parent_model = model, uuid = str(surface_uuid))
+    surface = rqs.Surface(parent_model = model, uuid = surface_uuid)
     surf_title = surface.title
     assert surf_title
     surface.change_crs(grid.crs)

{resqpy-5.1.0 → resqpy-5.1.2}/resqpy/olio/vector_utilities.py

@@ -1363,6 +1363,24 @@ def triangle_normal_vector_numba(points):  # pragma: no cover
     return v / np.linalg.norm(v)
 
 
+@njit
+def triangles_normal_vectors(t: np.ndarray, p: np.ndarray) -> np.ndarray:  # pragma: no cover
+    """For a triangulated set, return an array of unit normal vectors (one per triangle).
+
+    note:
+        resulting vectors implicitly assume that xy & z units are the same; if this is not the case, adjust vectors
+        afterwards as required
+    """
+    nv = np.empty((len(t), 3), dtype = np.float64)
+    v = np.zeros(3, dtype = np.float64)
+    for ti in range(len(t)):
+        v[:] = np.cross(p[t[ti, 0]] - p[t[ti, 1]], p[t[ti, 0]] - p[t[ti, 2]])
+        if v[2] < 0.0:
+            v[:] = -v
+        nv[ti, :] = v / np.linalg.norm(v)
+    return nv
+
+
 def in_circumcircle(a, b, c, d):
     """Returns True if point d lies within the circumcircle pf ccw points a, b, c, projected onto xy plane.
 

{resqpy-5.1.0 → resqpy-5.1.2}/resqpy/surface/_surface.py

@@ -480,28 +480,32 @@ class Surface(rqsb.BaseSurface):
 
         old_crs = rqc.Crs(self.model, uuid = self.crs_uuid)
         self.crs_uuid = required_crs.uuid
-        if required_crs == old_crs or not self.patch_list:
+        if bu.matching_uuids(required_crs.uuid, old_crs.uuid) or not self.patch_list:
             log.debug(f'no crs change needed for {self.title}')
             return
+        equivalent_crs = (required_crs == old_crs)
         log.debug(f'crs change needed for {self.title} from {old_crs.title} to {required_crs.title}')
         for patch in self.patch_list:
-            patch.triangles_and_points()
-            required_crs.convert_array_from(old_crs, patch.points)
+            assert bu.matching_uuids(patch.crs_uuid, old_crs.uuid)
+            if not equivalent_crs:
+                patch.triangles_and_points()
+                required_crs.convert_array_from(old_crs, patch.points)
             patch.crs_uuid = self.crs_uuid
         self.triangles = None  # clear cached arrays for surface
         self.points = None
-        if self.extra_metadata.pop('rotation matrix', None) is not None:
-            log.warning(f'discarding rotation matrix extra metadata during crs change of: {self.title}')
-        self._load_normal_vector_from_extra_metadata()
-        if self.normal_vector is not None:
-            if required_crs.z_inc_down != old_crs.z_inc_down:
-                self.normal_vector[2] = -self.normal_vector[2]
-            theta = (wam.convert(required_crs.rotation, required_crs.rotation_units, 'dega') -
-                     wam.convert(old_crs.rotation, old_crs.rotation_units, 'dega'))
-            if not maths.isclose(theta, 0.0):
-                self.normal_vector = vec.rotate_vector(vec.rotation_matrix_3d_axial(2, theta), self.normal_vector)
-            self.extra_metadata['normal vector'] = str(
-                f'{self.normal_vector[0]},{self.normal_vector[1]},{self.normal_vector[2]}')
+        if not equivalent_crs:
+            if self.extra_metadata.pop('rotation matrix', None) is not None:
+                log.warning(f'discarding rotation matrix extra metadata during crs change of: {self.title}')
+            self._load_normal_vector_from_extra_metadata()
+            if self.normal_vector is not None:
+                if required_crs.z_inc_down != old_crs.z_inc_down:
+                    self.normal_vector[2] = -self.normal_vector[2]
+                theta = (wam.convert(required_crs.rotation, required_crs.rotation_units, 'dega') -
+                         wam.convert(old_crs.rotation, old_crs.rotation_units, 'dega'))
+                if not maths.isclose(theta, 0.0):
+                    self.normal_vector = vec.rotate_vector(vec.rotation_matrix_3d_axial(2, theta), self.normal_vector)
+                self.extra_metadata['normal vector'] = str(
+                    f'{self.normal_vector[0]},{self.normal_vector[1]},{self.normal_vector[2]}')
         self.uuid = bu.new_uuid()  # hope this doesn't cause problems
         assert self.root is None