LoopStructural 1.6.12__tar.gz → 1.6.14__tar.gz

{loopstructural-1.6.12 → loopstructural-1.6.14}/LoopStructural/datatypes/_bounding_box.py

@@ -281,6 +281,7 @@ class BoundingBox:
             origin=origin,
             maximum=maximum,
             global_origin=self.global_origin,
+            nsteps=self.nsteps,
             dimensions=self.dimensions,
         )
 
@@ -387,7 +388,7 @@ class BoundingBox:
 
         if not local:
             coordinates = [
-                np.linspace(self.global_origin[i], self.global_maximum[i], nsteps[i])
+                np.linspace(self.global_origin[i]+self.origin[i], self.global_maximum[i], nsteps[i])
                 for i in range(self.dimensions)
             ]
         coordinate_grid = np.meshgrid(*coordinates, indexing="ij")

{loopstructural-1.6.12 → loopstructural-1.6.14}/LoopStructural/interpolators/__init__.py

@@ -83,8 +83,16 @@ from ..interpolators._p1interpolator import P1Interpolator
 try:
     from ..interpolators._surfe_wrapper import SurfeRBFInterpolator
 except ImportError:
-    logger.warning("Surfe is not installed, SurfeRBFInterpolator will not be available")
-    SurfeRBFInterpolator = None
+    class SurfeRBFInterpolator(GeologicalInterpolator):
+        """
+        Dummy class to handle the case where Surfe is not installed.
+        This will raise a warning when used.
+        """
+
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "Surfe cannot be imported. Please install Surfe. pip install surfe/ conda install -c loop3d surfe"
+            ) 
 interpolator_map = {
     InterpolatorType.BASE: GeologicalInterpolator,
     InterpolatorType.BASE_DISCRETE: DiscreteInterpolator,

{loopstructural-1.6.12 → loopstructural-1.6.14}/LoopStructural/interpolators/_finite_difference_interpolator.py

@@ -454,22 +454,28 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
                 )
             self.up_to_date = False
 
-    def add_regularisation(self, operator, w=0.1):
-        """
 
-        Parameters
-        ----------
-        operator
-        w
 
-        Returns
-        -------
+    # def assemble_borders(self, operator, w, name='regularisation'):
+    #     """
+    #     Adds a constraint to the border of the model to force the value to be equal to the value at the border
 
-        """
-        self.assemble_inner(operator, w)
-        # self.assemble_borders()
+    #     Parameters
+    #     ----------
+    #     operator : Operator
+    #         operator to use for the regularisation
+    #     w : double
+    #         weight of the regularisation
+
+    #     Returns
+    #     -------
+
+    #     """
+    #     # First get the global indicies of the pairs of neighbours this should be an
+    #     # Nx27 array for 3d and an Nx9 array for 2d
+
+    #     global_indexes = self.support.neighbour_global_indexes()
 
-    # def assemble_borders(self, operator, w):
 
     def assemble_inner(self, operator, w, name='regularisation'):
         """

{loopstructural-1.6.12 → loopstructural-1.6.14}/LoopStructural/interpolators/_p1interpolator.py

@@ -146,7 +146,7 @@ class P1Interpolator(DiscreteInterpolator):
         self.reset()
         for key in kwargs:
             if "regularisation" in kwargs:
-                self.interpolation_weights["cgw"] = 0.1 * kwargs["regularisation"]
+                self.interpolation_weights["cgw"] = kwargs["regularisation"]
             self.up_to_date = False
             self.interpolation_weights[key] = kwargs[key]
         if self.interpolation_weights["cgw"] > 0.0:

{loopstructural-1.6.12 → loopstructural-1.6.14}/LoopStructural/interpolators/supports/_3d_structured_grid.py

@@ -437,8 +437,9 @@ class StructuredGrid(BaseStructuredSupport):
         T[:, 2, 6] = (1 - local_coords[:, 0]) * local_coords[:, 1]
         T[:, 2, 3] = -local_coords[:, 0] * local_coords[:, 1]
         T[:, 2, 7] = local_coords[:, 0] * local_coords[:, 1]
-        T /= self.step_vector[0]
-
+        T[:, 0, :] /= self.step_vector[None, 0]
+        T[:, 1, :] /= self.step_vector[None, 1]
+        T[:, 2, :] /= self.step_vector[None, 2]
         return vertices, T, elements, inside
 
     def get_element_for_location(self, pos: np.ndarray):

{loopstructural-1.6.12 → loopstructural-1.6.14}/LoopStructural/modelling/__init__.py

@@ -22,6 +22,14 @@ from ..modelling.input import (
 try:
     from ..modelling.input.project_file import LoopProjectfileProcessor
 except (LoopImportError, ImportError):
-    logger.warning(
-        "Cannot use LoopProjectfileProcessor: Loop project file cannot be imported, try installing LoopProjectFile"
-    )
+    class LoopProjectfileProcessor(ProcessInputData):
+        """
+        Dummy class to handle the case where LoopProjectFile is not installed.
+        This will raise a warning when used.
+        """
+
+        def __init__(self, *args, **kwargs):
+            raise LoopImportError(
+                "LoopProjectFile cannot be imported. Please install LoopProjectFile."
+            )
+    

{loopstructural-1.6.12 → loopstructural-1.6.14}/LoopStructural/modelling/features/_base_geological_feature.py

@@ -229,7 +229,7 @@ class BaseFeature(metaclass=ABCMeta):
         """
         Evaluate the gradient of the feature at a given position.
         """
-
+    
         raise NotImplementedError
 
     def min(self):

loopstructural-1.6.14/LoopStructural/modelling/features/_lambda_geological_feature.py

@@ -0,0 +1,161 @@
+"""
+Geological features
+"""
+from LoopStructural.utils.maths import regular_tetraherdron_for_points, gradient_from_tetrahedron
+from ...modelling.features import BaseFeature
+from ...utils import getLogger
+from ...modelling.features import FeatureType
+import numpy as np
+from typing import Callable, Optional
+from ...utils import LoopValueError
+
+logger = getLogger(__name__)
+
+
+class LambdaGeologicalFeature(BaseFeature):
+    def __init__(
+        self,
+        function: Optional[Callable[[np.ndarray], np.ndarray]] = None,
+        name: str = "unnamed_lambda",
+        gradient_function: Optional[Callable[[np.ndarray], np.ndarray]] = None,
+        model=None,
+        regions: Optional[list] = None,
+        faults: Optional[list] = None,
+        builder=None,
+    ):
+        """A lambda geological feature is a wrapper for a geological
+        feature that has a function at the base. This can be then used
+        in place of a geological feature.
+
+        Parameters
+        ----------
+        function : _type_, optional
+            _description_, by default None
+        name : str, optional
+            _description_, by default "unnamed_lambda"
+        gradient_function : _type_, optional
+            _description_, by default None
+        model : _type_, optional
+            _description_, by default None
+        regions : list, optional
+            _description_, by default []
+        faults : list, optional
+            _description_, by default []
+        builder : _type_, optional
+            _description_, by default None
+        """
+        BaseFeature.__init__(self, name, model, faults if faults is not None else [], regions if regions is not None else [], builder)
+        self.type = FeatureType.LAMBDA
+        self.function = function
+        self.gradient_function = gradient_function
+        self.regions = regions if regions is not None else []
+
+    def evaluate_value(self, pos: np.ndarray, ignore_regions=False) -> np.ndarray:
+        """_summary_
+
+        Parameters
+        ----------
+        xyz : np.ndarray
+            _description_
+
+        Returns
+        -------
+        np.ndarray
+            _description_
+        """
+        v = np.zeros((pos.shape[0]))
+        v[:] = np.nan
+
+        mask = self._calculate_mask(pos, ignore_regions=ignore_regions)
+        pos = self._apply_faults(pos)
+        if self.function is not None:
+
+            v[mask] = self.function(pos[mask,:])
+        return v
+
+    def evaluate_gradient(self, pos: np.ndarray, ignore_regions=False,element_scale_parameter=None) -> np.ndarray:
+        """_summary_
+
+        Parameters
+        ----------
+        xyz : np.ndarray
+            _description_
+
+        Returns
+        -------
+        np.ndarray
+            _description_
+        """
+        if pos.shape[1] != 3:
+            raise LoopValueError("Need Nx3 array of xyz points to evaluate gradient")
+        logger.info(f'Calculating gradient for {self.name}')
+        if element_scale_parameter is None:
+            if self.model is not None:
+                element_scale_parameter = np.min(self.model.bounding_box.step_vector) / 10
+            else:
+                element_scale_parameter = 1
+        else:
+            try:
+                element_scale_parameter = float(element_scale_parameter)
+            except ValueError:
+                logger.error("element_scale_parameter must be a float")
+                element_scale_parameter = 1
+        v = np.zeros((pos.shape[0], 3))
+        v = np.zeros(pos.shape)
+        v[:] = np.nan
+        mask = self._calculate_mask(pos, ignore_regions=ignore_regions)
+        # evaluate the faults on the nodes of the faulted feature support
+        # then evaluate the gradient at these points
+        if len(self.faults) > 0:
+            # generate a regular tetrahedron for each point
+            # we will then move these points by the fault and then recalculate the gradient.
+            # this should work...
+            resolved = False
+            tetrahedron = regular_tetraherdron_for_points(pos, element_scale_parameter)
+
+            while resolved:
+                for f in self.faults:
+                    v = (
+                        f[0]
+                        .evaluate_value(tetrahedron.reshape(-1, 3), fillnan='nearest')
+                        .reshape(tetrahedron.shape[0], 4)
+                    )
+                    flag = np.logical_or(np.all(v > 0, axis=1), np.all(v < 0, axis=1))
+                    if np.any(~flag):
+                        logger.warning(
+                            f"Points are too close to fault {f[0].name}. Refining the tetrahedron"
+                        )
+                        element_scale_parameter *= 0.5
+                        tetrahedron = regular_tetraherdron_for_points(pos, element_scale_parameter)
+
+                resolved = True
+
+            tetrahedron_faulted = self._apply_faults(np.array(tetrahedron.reshape(-1, 3))).reshape(
+                tetrahedron.shape
+            )
+
+            values = self.function(tetrahedron_faulted.reshape(-1, 3)).reshape(
+                (-1, 4)
+            )
+            v[mask, :] = gradient_from_tetrahedron(tetrahedron[mask, :, :], values[mask])
+
+            return v
+        if self.gradient_function is None:
+            v[:, :] = np.nan
+        else:
+            v[:, :] = self.gradient_function(pos)
+        return v
+
+    def get_data(self, value_map: Optional[dict] = None):
+        return
+
+    def copy(self, name: Optional[str] = None):
+        return LambdaGeologicalFeature(
+            self.function,
+            name if name is not None else f'{self.name}_copy',
+            self.gradient_function,
+            self.model,
+            self.regions,
+            self.faults,
+            self.builder,
+        )