LoopStructural 1.6.11__tar.gz → 1.6.13__tar.gz

{loopstructural-1.6.11 → loopstructural-1.6.13}/LoopStructural/datatypes/_bounding_box.py

@@ -326,9 +326,7 @@ class BoundingBox:
         if iy == -1:
             return self.origin[ix]
 
-        return self.bb[
-            ix,
-        ]
+        return self.bb[ix,]
 
     def __getitem__(self, name):
         if isinstance(name, str):
@@ -389,7 +387,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.11 → loopstructural-1.6.13}/LoopStructural/datatypes/_point.py

@@ -147,8 +147,8 @@ class VectorPoints:
         else:
             norm = np.linalg.norm(vectors, axis=1)
             vectors[norm > 0, :] /= norm[norm > 0][:, None]
-            norm = norm[norm > 0] / norm[norm > 0].max()
-            vectors *= norm[:, None]
+            norm[norm > 0] = norm[norm > 0] / norm[norm > 0].max()
+            vectors[norm > 0, :] *= norm[norm > 0, None]
         if scale_function is not None:
             # vectors /= np.linalg.norm(vectors, axis=1)[:, None]
             vectors *= scale_function(self.locations)[:, None]

{loopstructural-1.6.11 → loopstructural-1.6.13}/LoopStructural/interpolators/_finite_difference_interpolator.py

@@ -272,7 +272,12 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             idc[inside, :] = gi[node_idx[inside, :]]
             inside = np.logical_and(~np.any(idc == -1, axis=1), inside)
 
-            (vertices, T, elements, inside_,) = self.support.get_element_gradient_for_location(
+            (
+                vertices,
+                T,
+                elements,
+                inside_,
+            ) = self.support.get_element_gradient_for_location(
                 points[inside, : self.support.dimension]
             )
             # normalise constraint vector and scale element matrix by this
@@ -335,7 +340,12 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             # calculate unit vector for node gradients
             # this means we are only constraining direction of grad not the
             # magnitude
-            (vertices, T, elements, inside_,) = self.support.get_element_gradient_for_location(
+            (
+                vertices,
+                T,
+                elements,
+                inside_,
+            ) = self.support.get_element_gradient_for_location(
                 points[inside, : self.support.dimension]
             )
             # T*=np.product(self.support.step_vector)
@@ -422,7 +432,12 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             vectors[norm > 0, :] /= norm[norm > 0, None]
 
             # normalise element vector to unit vector for dot product
-            (vertices, T, elements, inside_,) = self.support.get_element_gradient_for_location(
+            (
+                vertices,
+                T,
+                elements,
+                inside_,
+            ) = self.support.get_element_gradient_for_location(
                 points[inside, : self.support.dimension]
             )
             T[norm > 0, :, :] /= norm[norm > 0, None, None]

{loopstructural-1.6.11 → loopstructural-1.6.13}/LoopStructural/interpolators/supports/_3d_base_structured.py

@@ -162,9 +162,9 @@ class BaseStructuredSupport(BaseSupport):
         length = self.maximum - origin
         length /= self.step_vector
         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
+        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"

{loopstructural-1.6.11 → loopstructural-1.6.13}/LoopStructural/interpolators/supports/_3d_structured_tetra.py

@@ -166,9 +166,9 @@ class TetMesh(BaseStructuredSupport):
         shared_face_index[:] = -1
         shared_face_index[row.reshape(-1, 3)[:, 0], :] = col.reshape(-1, 3)
 
-        self.shared_elements[
-            np.arange(self.shared_element_relationships.shape[0]), :
-        ] = shared_face_index
+        self.shared_elements[np.arange(self.shared_element_relationships.shape[0]), :] = (
+            shared_face_index
+        )
         # resize
         self.shared_elements = self.shared_elements[: len(self.shared_element_relationships), :]
 

{loopstructural-1.6.11 → loopstructural-1.6.13}/LoopStructural/interpolators/supports/_3d_unstructured_tetra.py

@@ -173,9 +173,9 @@ class UnStructuredTetMesh(BaseSupport):
         shared_face_index[:] = -1
         shared_face_index[row.reshape(-1, 3)[:, 0], :] = col.reshape(-1, 3)
 
-        self.shared_elements[
-            np.arange(self.shared_element_relationships.shape[0]), :
-        ] = shared_face_index
+        self.shared_elements[np.arange(self.shared_element_relationships.shape[0]), :] = (
+            shared_face_index
+        )
         # resize
         self.shared_elements = self.shared_elements[: len(self.shared_element_relationships), :]
         # flag = np.zeros(self.elements.shape[0])

{loopstructural-1.6.11 → loopstructural-1.6.13}/LoopStructural/interpolators/supports/_face_table.py

@@ -63,8 +63,8 @@ def _init_face_table(grid):
     shared_face_index = np.zeros((shared_faces.shape[0], grid.dimension), dtype=int)
     shared_face_index[:] = -1
     shared_face_index[row.reshape(-1, grid.dimension)[:, 0], :] = col.reshape(-1, grid.dimension)
-    grid._shared_elements[
-        np.arange(grid.shared_element_relationships.shape[0]), :
-    ] = shared_face_index
+    grid._shared_elements[np.arange(grid.shared_element_relationships.shape[0]), :] = (
+        shared_face_index
+    )
     # resize
     grid._shared_elements = grid.shared_elements[: len(grid.shared_element_relationships), :]

{loopstructural-1.6.11 → loopstructural-1.6.13}/LoopStructural/modelling/core/geological_model.py

@@ -598,12 +598,10 @@ class GeologicalModel:
                 * self._data.loc[mask, "polarity"].to_numpy()[:, None]
             )
             self._data.drop(["strike", "dip"], axis=1, inplace=True)
-        self._data[
-            ['X', 'Y', 'Z', 'val', 'nx', 'ny', 'nz', 'gx', 'gy', 'gz', 'tx', 'ty', 'tz']
-        ] = self._data[
-            ['X', 'Y', 'Z', 'val', 'nx', 'ny', 'nz', 'gx', 'gy', 'gz', 'tx', 'ty', 'tz']
-        ].astype(
-            float
+        self._data[['X', 'Y', 'Z', 'val', 'nx', 'ny', 'nz', 'gx', 'gy', 'gz', 'tx', 'ty', 'tz']] = (
+            self._data[
+                ['X', 'Y', 'Z', 'val', 'nx', 'ny', 'nz', 'gx', 'gy', 'gz', 'tx', 'ty', 'tz']
+            ].astype(float)
         )
 
     def set_model_data(self, data):
@@ -1805,7 +1803,9 @@ class GeologicalModel:
                     values.to_list(),
                     self.bounding_box,
                     name=names.loc[values.index].to_list(),
-                    colours=unit_table.loc[unit_table['feature_name'] == u, 'colour'].tolist()[1:], #we don't isosurface basement, no value
+                    colours=unit_table.loc[unit_table['feature_name'] == u, 'colour'].tolist()[
+                        1:
+                    ],  # we don't isosurface basement, no value
                 )
             )
 

{loopstructural-1.6.11 → loopstructural-1.6.13}/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.13/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,
+        )