LoopStructural 1.6.2__py3-none-any.whl → 1.6.5__py3-none-any.whl

LoopStructural/interpolators/_surfe_wrapper.py

@@ -2,15 +2,16 @@
 Wrapper for using surfepy
 """
 
-from ..utils.helper import get_vectors
+from ..utils.maths import get_vectors
 from ..interpolators import GeologicalInterpolator
 
 import numpy as np
 
 from ..utils import getLogger
+import surfepy
+from typing import Optional
 
 logger = getLogger(__name__)
-import surfepy
 
 
 class SurfeRBFInterpolator(GeologicalInterpolator):
@@ -19,6 +20,8 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
     def __init__(self, method="single_surface"):
         GeologicalInterpolator.__init__(self)
         self.surfe = None
+        if not method:
+            method = "single_surface"
         if method == "single_surface":
             logger.info("Using single surface interpolator")
             self.surfe = surfepy.Surfe_API(1)
@@ -29,7 +32,10 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
             logger.info("Using surfe horizon")
             self.surfe = surfepy.Surfe_API(4)
 
-    def add_gradient_ctr_pts(self):
+    def set_region(self, **kwargs):
+        pass
+
+    def add_gradient_constraints(self, w=1):
         points = self.get_gradient_constraints()
         if points.shape[0] > 0:
             logger.info("Adding ")
@@ -40,12 +46,12 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
             self.surfe.SetTangentConstraints(strike_vector)
             self.surfe.SetTangentConstraints(dip_vector)
 
-    def add_norm_ctr_pts(self):
+    def add_norm_constraints(self, w=1):
         points = self.get_norm_constraints()
         if points.shape[0] > 0:
             self.surfe.SetPlanarConstraints(points[:, :6])
 
-    def add_ctr_pts(self):
+    def add_value_constraints(self, w=1):
 
         points = self.get_value_constraints()
         if points.shape[0] > 0:
@@ -59,15 +65,39 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
                     points[i, 3],
                 )
 
-    def add_tangent_ctr_pts(self):
+    def add_interface_constraints(self, w=1):
+        pass
+
+    def add_value_inequality_constraints(self, w=1):
+        ## inequalities are causing a segfault
+        # points = self.get_value_inequality_constraints()
+        # if points.shape[0] > 0:
+        #     #
+        #     self.surfe.AddValueInequalityConstraints(points[:,0],points[:,1],points[:,2],points[:,3])
+        pass
+
+    def add_inequality_pairs_constraints(
+        self,
+        w: float = 1.0,
+        upper_bound=np.finfo(float).eps,
+        lower_bound=-np.inf,
+        pairs: Optional[list] = None,
+    ):
+        # self.surfe.Add
+        pass
+
+    def reset(self):
+        pass
+
+    def add_tangent_constraints(self, w=1):
         points = self.get_tangent_constraints()
         if points.shape[0] > 0:
             self.surfe.SetTangentConstraints(points[:, :6])
 
-    def _solve(self, **kwargs):
+    def solve_system(self, **kwargs):
         self.surfe.ComputeInterpolant()
 
-    def _setup_interpolator(self, **kwargs):
+    def setup_interpolator(self, **kwargs):
         """
         Setup the interpolator
 
@@ -90,10 +120,10 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
 
 
         """
-        self.add_gradient_ctr_pts()
-        self.add_norm_ctr_pts()
-        self.add_ctr_pts()
-        self.add_tangent_ctr_pts()
+        self.add_gradient_constraints()
+        self.add_norm_constraints()
+        self.add_value_constraints()
+        self.add_tangent_constraints()
 
         kernel = kwargs.get("kernel", "r3")
         logger.info("Setting surfe RBF kernel to %s" % kernel)

LoopStructural/interpolators/supports/_2d_base_unstructured.py

@@ -338,3 +338,19 @@ class BaseUnstructured2d(BaseSupport):
         """
         verts, c, tri, inside = self.get_element_for_location(pos, return_verts=False)
         return self.evaluate_shape_derivatives(pos, tri)
+
+    def vtk(self, node_properties={}, cell_properties={}):
+        """
+        Create a vtk unstructured grid from the mesh
+        """
+        import pyvista as pv
+
+        grid = pv.UnstructuredGrid()
+        grid.points = self.nodes
+        grid.cell_types = np.ones(self.elements.shape[0]) * pv.vtk.VTK_TRIANGLE
+        grid.cells = np.c_[np.ones(self.elements.shape[0]) * 3, self.elements]
+        for key, value in node_properties.items():
+            grid.point_data[key] = value
+        for key, value in cell_properties.items():
+            grid.cell_data[key] = value
+        return grid

LoopStructural/interpolators/supports/_2d_structured_grid.py

@@ -5,10 +5,11 @@ Cartesian grid for fold interpolator
 
 import logging
 
-from typing import Tuple
 import numpy as np
 from . import SupportType
 from ._base_support import BaseSupport
+from typing import Dict, Tuple
+from .._operator import Operator
 
 logger = logging.getLogger(__name__)
 
@@ -33,7 +34,7 @@ class StructuredGrid2D(BaseSupport):
         step_vector - 2d list or numpy array of int
         """
         self.type = SupportType.StructuredGrid2D
-        self.nsteps = np.array(nsteps)
+        self.nsteps = np.ceil(np.array(nsteps)).astype(int)
         self.step_vector = np.array(step_vector)
         self.origin = np.array(origin)
         self.maximum = origin + self.nsteps * self.step_vector
@@ -261,13 +262,22 @@ class StructuredGrid2D(BaseSupport):
         if "indexes" in kwargs:
             indexes = kwargs["indexes"]
         if "indexes" not in kwargs:
-            ii = []
-            jj = []
-            for i in range(1, self.nsteps[0] - 1):
-                for j in range(1, self.nsteps[1] - 1):
-                    ii.append(i)
-                    jj.append(j)
-            indexes = np.array([ii, jj])
+            gi = np.arange(self.n_nodes)
+            indexes = self.global_index_to_node_index(gi)
+            edge_mask = (
+                (indexes[:, 0] > 0)
+                & (indexes[:, 0] < self.nsteps[0] - 1)
+                & (indexes[:, 1] > 0)
+                & (indexes[:, 1] < self.nsteps[1] - 1)
+            )
+            indexes = indexes[edge_mask, :].T
+            # ii = []
+            # jj = []
+            # for i in range(1, self.nsteps[0] - 1):
+            #     for j in range(1, self.nsteps[1] - 1):
+            #         ii.append(i)
+            #         jj.append(j)
+            # indexes = np.array([ii, jj])
         # indexes = np.array(indexes).T
         if indexes.ndim != 2:
             print(indexes.ndim)
@@ -460,3 +470,28 @@ class StructuredGrid2D(BaseSupport):
 
     def onGeometryChange(self):
         pass
+
+    def vtk(self, node_properties={}, cell_properties={}):
+        raise NotImplementedError("VTK output not implemented for structured grid")
+        pass
+
+    def get_operators(self, weights: Dict[str, float]) -> Dict[str, Tuple[np.ndarray, float]]:
+        """Get
+
+        Parameters
+        ----------
+        weights : Dict[str, float]
+            _description_
+
+        Returns
+        -------
+        Dict[str, Tuple[np.ndarray, float]]
+            _description_
+        """
+        # in a map we only want the xy operators
+        operators = {
+            'dxy': (Operator.Dxy_mask[1, :, :], weights['dxy'] * 2),
+            'dxx': (Operator.Dxx_mask[1, :, :], weights['dxx']),
+            'dyy': (Operator.Dyy_mask[1, :, :], weights['dyy']),
+        }
+        return operators

LoopStructural/interpolators/supports/_3d_base_structured.py

@@ -134,7 +134,15 @@ class BaseStructuredSupport(BaseSupport):
         origin = np.array(origin)
         length = self.maximum - origin
         length /= self.step_vector
-        self._nsteps = np.ceil(length).astype(int)
+        self._nsteps = np.ceil(length).astype(np.int64)
+        self._nsteps[self._nsteps == 0] = (
+            3  # need to have a minimum of 3 elements to apply the finite difference mask
+        )
+        if np.any(~(self._nsteps > 0)):
+            logger.error(
+                f"Cannot resize the interpolation support. The proposed number of steps is {self._nsteps}, these must be all > 0"
+            )
+            raise ValueError("Cannot resize the interpolation support.")
         self._origin = origin
         self.onGeometryChange()
 
@@ -150,7 +158,13 @@ class BaseStructuredSupport(BaseSupport):
         maximum = np.array(maximum, dtype=float)
         length = maximum - self.origin
         length /= self.step_vector
-        self._nsteps = np.ceil(length).astype(int) + 1
+        self._nsteps = np.ceil(length).astype(np.int64)
+        self._nsteps[self._nsteps == 0] = 3
+        if np.any(~(self._nsteps > 0)):
+            logger.error(
+                f"Cannot resize the interpolation support. The proposed number of steps is {self._nsteps}, these must be all > 0"
+            )
+            raise ValueError("Cannot resize the interpolation support.")
         self.onGeometryChange()
 
     @property
@@ -236,6 +250,7 @@ class BaseStructuredSupport(BaseSupport):
         cell_indexes[inside, 0] = x[inside] // self.step_vector[None, 0]
         cell_indexes[inside, 1] = y[inside] // self.step_vector[None, 1]
         cell_indexes[inside, 2] = z[inside] // self.step_vector[None, 2]
+
         return cell_indexes, inside
 
     def position_to_cell_global_index(self, pos):
@@ -331,12 +346,9 @@ class BaseStructuredSupport(BaseSupport):
         return corner_indexes
 
     def position_to_cell_corners(self, pos):
-
         cell_indexes, inside = self.position_to_cell_index(pos)
         corner_indexes = self.cell_corner_indexes(cell_indexes)
-
         globalidx = self.global_node_indices(corner_indexes)
-
         # if global index is not inside the support set to -1
         globalidx[~inside] = -1
         return globalidx, inside
@@ -451,7 +463,7 @@ class BaseStructuredSupport(BaseSupport):
         # all elements are the same size
         return 1.0
 
-    def vtk(self):
+    def vtk(self, node_properties={}, cell_properties={}):
         try:
             import pyvista as pv
         except ImportError:
@@ -464,4 +476,9 @@ class BaseStructuredSupport(BaseSupport):
             [np.zeros(self.elements.shape[0], dtype=int)[:, None] + 8, self.elements]
         )
         elements = elements.flatten()
-        return pv.UnstructuredGrid(elements, celltype, self.nodes)
+        grid = pv.UnstructuredGrid(elements, celltype, self.nodes)
+        for key, value in node_properties.items():
+            grid[key] = value
+        for key, value in cell_properties.items():
+            grid.cell_arrays[key] = value
+        return grid

LoopStructural/interpolators/supports/_3d_structured_grid.py

@@ -5,8 +5,10 @@ Cartesian grid for fold interpolator
 
 import numpy as np
 
-from ._3d_base_structured import BaseStructuredSupport
+from LoopStructural.interpolators._operator import Operator
 
+from ._3d_base_structured import BaseStructuredSupport
+from typing import Dict, Tuple
 from . import SupportType
 
 from LoopStructural.utils import getLogger
@@ -158,13 +160,18 @@ class StructuredGrid(BaseStructuredSupport):
         if "indexes" in kwargs:
             indexes = kwargs["indexes"]
         if "indexes" not in kwargs:
-            indexes = np.array(
-                np.meshgrid(
-                    np.arange(1, self.nsteps[0] - 1),
-                    np.arange(1, self.nsteps[1] - 1),
-                    np.arange(1, self.nsteps[2] - 1),
-                )
-            ).reshape((3, -1))
+            gi = np.arange(self.n_nodes)
+            indexes = self.global_index_to_node_index(gi)
+            edge_mask = (
+                (indexes[:, 0] > 0)
+                & (indexes[:, 0] < self.nsteps[0] - 1)
+                & (indexes[:, 1] > 0)
+                & (indexes[:, 1] < self.nsteps[1] - 1)
+                & (indexes[:, 2] > 0)
+                & (indexes[:, 2] < self.nsteps[2] - 1)
+            )
+            indexes = indexes[edge_mask, :].T
+
         # indexes = np.array(indexes).T
         if indexes.ndim != 2:
             return
@@ -291,7 +298,6 @@ class StructuredGrid(BaseStructuredSupport):
             )
         idc, inside = self.position_to_cell_corners(evaluation_points)
         # print(idc[inside,:], self.n_nodes,inside)
-
         if idc.shape[0] != inside.shape[0]:
             raise ValueError("index does not match number of nodes")
         v = np.zeros(idc.shape)
@@ -336,9 +342,6 @@ class StructuredGrid(BaseStructuredSupport):
         idc, inside = self.position_to_cell_corners(evaluation_points)
         T = np.zeros((idc.shape[0], 3, 8))
         T[inside, :, :] = self.get_element_gradient_for_location(evaluation_points[inside, :])[1]
-        # indices = np.array([self.position_to_cell_index(evaluation_points)])
-        # idc = self.global_indicies(indices.swapaxes(0,1))
-        # print(idc)
         if np.max(idc[inside, :]) > property_array.shape[0]:
             cix, ciy, ciz = self.position_to_cell_index(evaluation_points)
             if not np.all(cix[inside] < self.nsteps_cells[0]):
@@ -468,3 +471,26 @@ class StructuredGrid(BaseStructuredSupport):
             "type": self.type.numerator,
             **super().to_dict(),
         }
+
+    def get_operators(self, weights: Dict[str, float]) -> Dict[str, Tuple[np.ndarray, float]]:
+        """Gets the operators specific to this support
+
+        Parameters
+        ----------
+        weights : Dict[str, float]
+            weight value per operator
+
+        Returns
+        -------
+        operators
+            A dictionary with a numpy array and float weight
+        """
+        operators = {
+            'dxy': (Operator.Dxy_mask, weights['dxy'] / 4),
+            'dyz': (Operator.Dyz_mask, weights['dyz'] / 4),
+            'dxz': (Operator.Dxz_mask, weights['dxz'] / 4),
+            'dxx': (Operator.Dxx_mask, weights['dxx'] / 1),
+            'dyy': (Operator.Dyy_mask, weights['dyy'] / 1),
+            'dzz': (Operator.Dzz_mask, weights['dzz'] / 1),
+        }
+        return operators

LoopStructural/interpolators/supports/_3d_structured_tetra.py

@@ -729,8 +729,7 @@ class TetMesh(BaseStructuredSupport):
 
         return neighbours
 
-    @property
-    def vtk(self):
+    def vtk(self, node_properties={}, cell_properties={}):
         try:
             import pyvista as pv
         except ImportError:
@@ -743,4 +742,9 @@ class TetMesh(BaseStructuredSupport):
             [np.zeros(self.elements.shape[0], dtype=int)[:, None] + 4, self.elements]
         )
         elements = elements.flatten()
-        return pv.UnstructuredGrid(elements, celltype, self.nodes)
+        grid = pv.UnstructuredGrid(elements, celltype, self.nodes)
+        for prop in node_properties:
+            grid[prop] = node_properties[prop]
+        for prop in cell_properties:
+            grid.cell_arrays[prop] = cell_properties[prop]
+        return grid

LoopStructural/interpolators/supports/_3d_unstructured_tetra.py

@@ -621,7 +621,7 @@ class UnStructuredTetMesh(BaseSupport):
         """
         return self.neighbours
 
-    def vtk(self):
+    def vtk(self, node_properties={}, cell_properties={}):
         try:
             import pyvista as pv
         except ImportError:
@@ -634,4 +634,10 @@ class UnStructuredTetMesh(BaseSupport):
             [np.zeros(self.elements.shape[0], dtype=int)[:, None] + 4, self.elements]
         )
         elements = elements.flatten()
-        return pv.UnstructuredGrid(elements, celltype, self.nodes)
+        grid = pv.UnstructuredGrid(elements, celltype, self.nodes)
+        for key, value in node_properties.items():
+            grid[key] = value
+        for key, value in cell_properties.items():
+            grid.cell_arrays[key] = value
+
+        return grid

LoopStructural/interpolators/supports/__init__.py

@@ -18,6 +18,7 @@ class SupportType(IntEnum):
     BaseStructured = 6
     TetMesh = 10
     P2UnstructuredTetMesh = 11
+    DataSupported = 12
 
 
 from ._2d_base_unstructured import BaseUnstructured2d
@@ -29,6 +30,11 @@ from ._3d_unstructured_tetra import UnStructuredTetMesh
 from ._3d_structured_tetra import TetMesh
 from ._3d_p2_tetra import P2UnstructuredTetMesh
 
+
+def no_support(*args, **kwargs):
+    return None
+
+
 support_map = {
     SupportType.StructuredGrid2D: StructuredGrid2D,
     SupportType.StructuredGrid: StructuredGrid,
@@ -37,6 +43,7 @@ support_map = {
     SupportType.P2Unstructured2d: P2Unstructured2d,
     SupportType.TetMesh: TetMesh,
     SupportType.P2UnstructuredTetMesh: P2UnstructuredTetMesh,
+    SupportType.DataSupported: no_support,
 }
 
 from ._support_factory import SupportFactory

LoopStructural/interpolators/supports/_base_support.py

@@ -112,3 +112,10 @@ class BaseSupport(metaclass=ABCMeta):
         Return the element size
         """
         pass
+
+    @abstractmethod
+    def vtk(self, node_properties={}, cell_properties={}):
+        """
+        Return a vtk object
+        """
+        pass

LoopStructural/modelling/__init__.py

@@ -6,12 +6,12 @@ Geological modelling classes and functions
 __all__ = [
     "GeologicalModel",
     "ProcessInputData",
-    "Loop3DView",
     "Map2LoopProcessor",
     "LoopProjectfileProcessor",
 ]
 from ..utils import getLogger
 from ..utils import LoopImportError
+from .core.geological_model import GeologicalModel
 
 logger = getLogger(__name__)
 from ..modelling.input import (
@@ -25,5 +25,3 @@ except (LoopImportError, ImportError):
     logger.warning(
         "Cannot use LoopProjectfileProcessor: Loop project file cannot be imported, try installing LoopProjectFile"
     )
-# from LoopStructural.modelling.features import StructuralFrame
-# from LoopStructural.modelling.features.fault import FaultSegment

LoopStructural/modelling/core/geological_model.py

@@ -649,7 +649,7 @@ class GeologicalModel:
             for g in stratigraphic_column.keys():
                 for u in stratigraphic_column[g].keys():
                     stratigraphic_column[g][u]["colour"] = cmap_colours[ci, :]
-
+                    ci += 1
         self.stratigraphic_column = stratigraphic_column
 
     def create_and_add_foliation(
@@ -825,8 +825,6 @@ class GeologicalModel:
 
         fold = FoldEvent(fold_frame, name=f"Fold_{foliation_data}", invert_norm=invert_fold_norm)
 
-        if "fold_weights" not in kwargs:
-            kwargs["fold_weights"] = {}
         if interpolatortype != "DFI":
             logger.warning("Folded foliation only supports DFI interpolator, changing to DFI")
             interpolatortype = "DFI"
@@ -1811,7 +1809,7 @@ class GeologicalModel:
         grid = self.bounding_box.structured_grid(name=name)
 
         grid.cell_properties['stratigraphy'] = self.evaluate_model(
-            self.bounding_box.cell_centers(), scale=False
+            self.rescale(self.bounding_box.cell_centers())
         )
         return grid, self.stratigraphic_ids()
 

LoopStructural/modelling/features/_analytical_feature.py

@@ -28,7 +28,16 @@ class AnalyticalGeologicalFeature(BaseFeature):
         list of FaultSegments that affect this feature
     """
 
-    def __init__(self, name, vector, origin, regions=[], faults=[], model=None, builder=None):
+    def __init__(
+        self,
+        name: str,
+        vector: np.ndarray,
+        origin: np.ndarray,
+        regions=[],
+        faults=[],
+        model=None,
+        builder=None,
+    ):
         BaseFeature.__init__(self, name, model, faults, regions, builder)
         self.vector = np.array(vector, dtype=float)
         self.origin = np.array(origin, dtype=float)
@@ -48,16 +57,16 @@ class AnalyticalGeologicalFeature(BaseFeature):
         json["origin"] = self.origin.tolist()
         return json
 
-    def evaluate_value(self, xyz, ignore_regions=False):
-        xyz = np.array(xyz)
-        if len(xyz.shape) == 1:
-            xyz = xyz[None, :]
-        if len(xyz.shape) != 2:
+    def evaluate_value(self, pos: np.ndarray, ignore_regions=False):
+        pos = np.array(pos)
+        if len(pos.shape) == 1:
+            pos = pos[None, :]
+        if len(pos.shape) != 2:
             raise ValueError("xyz must be a 1D or 2D array")
-        xyz2 = np.zeros(xyz.shape)
-        xyz2[:] = xyz[:]
+        xyz2 = np.zeros(pos.shape)
+        xyz2[:] = pos[:]
         for f in self.faults:
-            xyz2[:] = f.apply_to_points(xyz)
+            xyz2[:] = f.apply_to_points(pos)
         if self.model is not None:
             xyz2[:] = self.model.rescale(xyz2, inplace=False)
         xyz2[:] = xyz2 - self.origin
@@ -65,13 +74,13 @@ class AnalyticalGeologicalFeature(BaseFeature):
         distance = normal[0] * xyz2[:, 0] + normal[1] * xyz2[:, 1] + normal[2] * xyz2[:, 2]
         return distance / np.linalg.norm(self.vector)
 
-    def evaluate_gradient(self, xyz, ignore_regions=False):
-        xyz = np.array(xyz)
-        if len(xyz.shape) == 1:
-            xyz = xyz[None, :]
-        if len(xyz.shape) != 2:
-            raise ValueError("xyz must be a 1D or 2D array")
-        v = np.zeros(xyz.shape)
+    def evaluate_gradient(self, pos: np.ndarray, ignore_regions=False):
+        pos = np.array(pos)
+        if len(pos.shape) == 1:
+            pos = pos[None, :]
+        if len(pos.shape) != 2:
+            raise ValueError("pos must be a 1D or 2D array")
+        v = np.zeros(pos.shape)
         v[:, :] = self.vector[None, :]
         return v
 

LoopStructural/modelling/features/_base_geological_feature.py

@@ -291,11 +291,24 @@ class BaseFeature(metaclass=ABCMeta):
             if self.model is None:
                 raise ValueError("Must specify bounding box")
             bounding_box = self.model.bounding_box
-        callable = lambda xyz: self.evaluate_value(self.model.scale(xyz))
-        isosurfacer = LoopIsosurfacer(bounding_box, callable=callable)
-        if name is None and self.name is not None:
-            name = self.name
-        return isosurfacer.fit(value, name)
+        regions = self.regions
+        try:
+            self.regions = [
+                r for r in self.regions if r.name != self.name and r.parent.name != self.name
+            ]
+            callable = lambda xyz: self.evaluate_value(self.model.scale(xyz))
+            isosurfacer = LoopIsosurfacer(bounding_box, callable=callable)
+            if name is None and self.name is not None:
+                name = self.name
+            surfaces = isosurfacer.fit(value, name)
+        except Exception as e:
+            logger.error(f"Failed to create surface for {self.name} at value {value}")
+            logger.error(e)
+            surfaces = []
+        finally:
+            self.regions = regions
+
+        return surfaces
 
     def scalar_field(self, bounding_box=None):
         """Create a scalar field for the feature
@@ -341,10 +354,10 @@ class BaseFeature(metaclass=ABCMeta):
             if self.model is None:
                 raise ValueError("Must specify bounding box")
             bounding_box = self.model.bounding_box
-        grid = bounding_box.vtk()
-        points = grid.points
+        points = bounding_box.cell_centers()
         value = self.evaluate_gradient(points)
-
+        if self.model is not None:
+            points = self.model.rescale(points)
         return VectorPoints(points, value, self.name)
 
     @abstractmethod