LoopStructural 1.6.1__py3-none-any.whl → 1.6.6__py3-none-any.whl

LoopStructural/modelling/features/fault/_fault_segment.py

@@ -1,8 +1,9 @@
+from LoopStructural.utils.maths import regular_tetraherdron_for_points, gradient_from_tetrahedron
 from ....modelling.features.fault._fault_function_feature import (
     FaultDisplacementFeature,
 )
 from ....modelling.features import FeatureType
-from ....modelling.features.fault._fault_function import BaseFault, BaseFault3D
+from ....modelling.features.fault._fault_function import BaseFault, BaseFault3D, FaultDisplacement
 from ....utils import getLogger, NegativeRegion, PositiveRegion
 from ....modelling.features import StructuralFrame
 
@@ -21,7 +22,14 @@ class FaultSegment(StructuralFrame):
     """
 
     def __init__(
-        self, features, name, faultfunction=None, steps=10, displacement=1.0, fold=None, model=None
+        self,
+        name: str,
+        features: list,
+        faultfunction=None,
+        steps=10,
+        displacement=1.0,
+        fold=None,
+        model=None,
     ):
         """
         A slip event of a fault
@@ -36,10 +44,10 @@ class FaultSegment(StructuralFrame):
             how many integration steps for faults
         kwargs
         """
-        StructuralFrame.__init__(self, features, name, fold, model)
+        StructuralFrame.__init__(self, name=name, features=features, fold=fold, model=model)
         self.type = FeatureType.FAULT
         self.displacement = displacement
-        self._faultfunction = BaseFault.fault_displacement
+        self._faultfunction = BaseFault().fault_displacement
         self.steps = steps
         self.regions = []
         self.faults_enabled = True
@@ -57,10 +65,13 @@ class FaultSegment(StructuralFrame):
     def faultfunction(self, value):
         if callable(value):
             self._faultfunction = value
+        if issubclass(FaultDisplacement, type(value)):
+            self._faultfunction = value
+
         elif isinstance(value, str) and value == "BaseFault":
-            self._faultfunction = BaseFault.fault_displacement
+            self._faultfunction = BaseFault().fault_displacement
         elif isinstance(value, str) and value == "BaseFault3D":
-            self._faultfunction = BaseFault3D.fault_displacement
+            self._faultfunction = BaseFault3D().fault_displacement
         else:
             raise ValueError("Fault function must be a function or BaseFault")
 
@@ -110,6 +121,26 @@ class FaultSegment(StructuralFrame):
     def displacementfeature(self):
         return FaultDisplacementFeature(self, self.faultfunction, name=self.name, model=self.model)
 
+    def fault_ellipsoid(self, **kwargs):
+        try:
+            import pyvista as pv
+
+            fault_ellipsoid = pv.PolyData(
+                self.model.rescale(self.fault_centre[None, :], inplace=False)
+            )
+            fault_ellipsoid["norm"] = self.builder.fault_normal_vector[None, :]
+
+            geom = pv.ParametricEllipsoid(
+                self.fault_minor_axis,
+                self.fault_major_axis,
+                self.fault_intermediate_axis,
+            )
+            ellipsoid = fault_ellipsoid.glyph(geom=geom, **kwargs)
+            return ellipsoid
+        except ImportError:
+            logger.error("pyvista not installed")
+            return None
+
     def set_fault_offset(self, offset: float):
         self.fault_offset = offset
 
@@ -173,7 +204,7 @@ class FaultSegment(StructuralFrame):
         return np.abs(v) > threshold
         # return np.all(np.logical_and(v > -1,v<1),axis=1)
 
-    def evaluate_value(self, locations):
+    def evaluate_value(self, locations, ignore_regions=False):
         """
         Return the value of the fault surface scalar field
 
@@ -198,7 +229,10 @@ class FaultSegment(StructuralFrame):
         #     except:
         #         logger.error("nan slicing")
         # v[mask] = self.__getitem__(0).evaluate_value(locations[mask, :])
-        return self.__getitem__(0).evaluate_value(locations)
+        return self.__getitem__(0).evaluate_value(locations, ignore_regions=ignore_regions)
+
+    def ellipsoid(self):
+        pass
 
     def mean(self):
         return self.__getitem__(0).mean()
@@ -234,6 +268,7 @@ class FaultSegment(StructuralFrame):
                 logger.error("nan slicing ")
         # need to scale with fault displacement
         v[mask, :] = self.__getitem__(1).evaluate_gradient(locations[mask, :])
+        v[mask, :] /= np.linalg.norm(v[mask, :], axis=1)[:, None]
         scale = self.displacementfeature.evaluate_value(locations[mask, :])
         v[mask, :] *= scale[:, None]
         return v
@@ -282,6 +317,7 @@ class FaultSegment(StructuralFrame):
         -------
 
         """
+        logger.info(f'Applying fault {self.name} to points {points.shape}')
         steps = self.steps
         newp = np.copy(points).astype(float)
         # evaluate fault function for all points
@@ -389,51 +425,12 @@ class FaultSegment(StructuralFrame):
         # the nodes of the tetrahedron are then restored by the fault and then gradient is
         # recalculated using the updated node positions but the original corner values
 
-        regular_tetrahedron = np.array(
-            [
-                [np.sqrt(8 / 9), 0, -1 / 3],
-                [-np.sqrt(2 / 9), np.sqrt(2 / 3), -1 / 3],
-                [-np.sqrt(2 / 9), -np.sqrt(2 / 3), -1 / 3],
-                [0, 0, 1],
-            ]
-        )
-        regular_tetrahedron *= scale_parameter
-        xyz = vector[:, :3]
-        tetrahedron = np.zeros((xyz.shape[0], 4, 3))
-        tetrahedron[:] = xyz[:, None, :]
-        tetrahedron[:, :, :] += regular_tetrahedron[None, :, :]
-
-        vectors = vector[:, 3:]
-        corners = np.einsum('ikj,ij->ik', tetrahedron - xyz[:, None, :], vectors)
-        tetrahedron = tetrahedron.reshape(-1, 3)
-        tetrahedron = self.apply_to_points(tetrahedron)
-        tetrahedron = tetrahedron.reshape(-1, 4, 3)
-        m = np.array(
-            [
-                [
-                    (tetrahedron[:, 1, 0] - tetrahedron[:, 0, 0]),
-                    (tetrahedron[:, 1, 1] - tetrahedron[:, 0, 1]),
-                    (tetrahedron[:, 1, 2] - tetrahedron[:, 0, 2]),
-                ],
-                [
-                    (tetrahedron[:, 2, 0] - tetrahedron[:, 0, 0]),
-                    (tetrahedron[:, 2, 1] - tetrahedron[:, 0, 1]),
-                    (tetrahedron[:, 2, 2] - tetrahedron[:, 0, 2]),
-                ],
-                [
-                    (tetrahedron[:, 3, 0] - tetrahedron[:, 0, 0]),
-                    (tetrahedron[:, 3, 1] - tetrahedron[:, 0, 1]),
-                    (tetrahedron[:, 3, 2] - tetrahedron[:, 0, 2]),
-                ],
-            ]
-        )
-        I = np.array([[-1.0, 1.0, 0.0, 0.0], [-1.0, 0.0, 1.0, 0.0], [-1.0, 0.0, 0.0, 1.0]])
-        m = np.swapaxes(m, 0, 2)
-        element_gradients = np.linalg.inv(m)
-
-        element_gradients = element_gradients.swapaxes(1, 2)
-        element_gradients = element_gradients @ I
-        v = np.sum(element_gradients * corners[:, None, :], axis=2)
+        tetrahedron = regular_tetraherdron_for_points(vector[:, :3], scale_parameter)
+        corners = np.einsum('ikj,ij->ik', tetrahedron - vector[:, None, :3], vector[:, 3:])
+
+        tetrahedron = self.apply_to_points(tetrahedron.reshape(-1, 3)).reshape(-1, 4, 3)
+        v = gradient_from_tetrahedron(tetrahedron, corners)
+
         return v
 
     def add_abutting_fault(self, abutting_fault_feature, positive=None):

LoopStructural/modelling/features/fold/__init__.py

@@ -4,6 +4,5 @@
 
 from ._fold import FoldEvent
 from ._svariogram import SVariogram
-from ._fold_rotation_angle_feature import FoldRotationAngleFeature, fourier_series
+from ._fold_rotation_angle_feature import FoldRotationAngleFeature
 from ._foldframe import FoldFrame
-from ._fold_rotation_angle import FoldRotationAngle

LoopStructural/modelling/features/fold/_fold_rotation_angle_feature.py

@@ -1,6 +1,4 @@
-import numpy as np
 from ....modelling.features import BaseFeature
-
 from ....utils import getLogger
 
 logger = getLogger(__name__)
@@ -44,24 +42,3 @@ class FoldRotationAngleFeature(BaseFeature):
         s1 = self.fold_frame.features[0].evaluate_value(location)
         r = self.rotation(s1)
         return r
-
-
-def fourier_series(x, c0, c1, c2, w):
-    """
-
-    Parameters
-    ----------
-    x
-    c0
-    c1
-    c2
-    w
-
-    Returns
-    -------
-
-    """
-    v = np.array(x.astype(float))
-    # v.fill(c0)
-    v = c0 + c1 * np.cos(2 * np.pi / w * x) + c2 * np.sin(2 * np.pi / w * x)
-    return np.rad2deg(np.arctan(v))

LoopStructural/modelling/features/fold/_foldframe.py

@@ -100,8 +100,8 @@ class FoldFrame(StructuralFrame):
         # self.features[0].faults_enabled = False
         # self.features[1].faults_enabled = False
 
-        gpoints = feature_builder.interpolator.get_gradient_constraints()[:, :6]
-        npoints = feature_builder.interpolator.get_norm_constraints()[:, :6]
+        gpoints = feature_builder.get_gradient_constraints()[:, :6]
+        npoints = feature_builder.get_norm_constraints()[:, :6]
         points = []
         if gpoints.shape[0] > 0:
             points.append(gpoints)
@@ -173,8 +173,8 @@ class FoldFrame(StructuralFrame):
 
         """
         self.features[0].faults_enabled = False
-        gpoints = feature_builder.interpolator.get_gradient_constraints()[:, :6]
-        npoints = feature_builder.interpolator.get_norm_constraints()[:, :6]
+        gpoints = feature_builder.get_gradient_constraints()[:, :6]
+        npoints = feature_builder.get_norm_constraints()[:, :6]
         points = []
         if gpoints.shape[0] > 0:
             points.append(gpoints)

LoopStructural/modelling/features/fold/_svariogram.py

@@ -1,11 +1,11 @@
 import numpy as np
-
+from typing import List, Tuple, Optional
 from ....utils import getLogger
 
 logger = getLogger(__name__)
 
 
-def find_peaks_and_troughs(x, y):
+def find_peaks_and_troughs(x: np.ndarray, y: np.ndarray) -> Tuple[List, List]:
     """
 
     Parameters
@@ -24,7 +24,7 @@ def find_peaks_and_troughs(x, y):
     finding the change in derivative
     """
     if len(x) != len(y):
-        return False
+        raise ValueError("Cannot guess wavelength, x and y must be the same length")
     pairsx = []
     pairsy = []
     # #TODO numpyize
@@ -51,55 +51,46 @@ class SVariogram:
     The SVariogram is an experimental semi-variogram.
     """
 
-    def __init__(self, xdata, ydata):
-        self.xdata = xdata
-        self.ydata = ydata
+    def __init__(self, xdata: np.ndarray, ydata: np.ndarray):
+        self.xdata = np.asarray(xdata)
+        self.ydata = np.asarray(ydata)
+        mask = np.logical_or(np.isnan(self.xdata), np.isnan(self.ydata))
+        self.xdata = self.xdata[~mask]
+        self.ydata = self.ydata[~mask]
+        ## maybe check that xdata is not too big here, if it is then this should be done
+        ## using another library maybe gstools?
         self.dist = np.abs(self.xdata[:, None] - self.xdata[None, :])
         self.variance_matrix = (self.ydata[:, None] - self.ydata[None, :]) ** 2
         self.lags = None
         self.variogram = None
-        self.wavelength_guess = [None, None]
+        self.wavelength_guesses = []
 
-    def calc_semivariogram(self, lag=None, nlag=None, lags=None):
+    def initialise_lags(self, step: Optional[float] = None, nsteps: Optional[int] = None):
         """
-        Calculate a semi-variogram for the x and y data for this object.
-        You can specify the lags as an array or specify the step size and
-        number of steps.
-        If neither are specified then the lags are created to be the average
-        spacing of the data
+        Initialise the lags for the s-variogram
 
         Parameters
         ----------
-        step:   float
-                lag distance for the s-variogram
-        nstep:  int
-                number of lags for the s-variogram
-        lags:   array
-                num
+        lag: float
+            lag distance for the s-variogram
+        nlag: int
+            number of lags for the s-variogram
 
         Returns
         -------
 
         """
-        logger.info("Calculating S-Variogram")
-        if lag is not None:
-            step = lag
-            logger.info(f"Using lag: {step} kwarg for S-variogram")
-
-        if nlag is not None:
-            nstep = nlag
-            logger.info(f"Using nlag {nstep} kwarg for s-variogram")
 
-            self.lags = np.arange(step / 2.0, nstep * step, step)
-
-        if nlag is None and lag is not None:
-            nstep = int(np.ceil((np.nanmax(self.xdata) - np.nanmin(self.xdata)) / step))
-            logger.info(f"Using lag kwarg but calculating nlag as {nstep} for s-variogram")
+        if nsteps is not None and step is not None:
+            logger.info(f"Using nlag {nsteps} kwarg for s-variogram")
+            logger.info(f"Using lag: {step} kwarg for S-variogram")
+            self.lags = np.arange(step / 2.0, nsteps * step, step)
 
-            self.lags = np.arange(step / 2.0, nstep * step, step)
+        if nsteps is None and step is not None:
+            nsteps = int(np.ceil((np.nanmax(self.xdata) - np.nanmin(self.xdata)) / step))
+            logger.info(f"Using lag kwarg but calculating nlag as {nsteps} for s-variogram")
 
-        if lags is not None:
-            self.lags = lags
+            self.lags = np.arange(step / 2.0, nsteps * step, step)
 
         if self.lags is None:
             # time to guess the step size
@@ -109,15 +100,50 @@ class SVariogram:
 
             step = np.nanmean(np.nanmin(d, axis=1)) * 4.0
             # find number of steps to cover range in data
-            nstep = int(np.ceil((np.nanmax(self.xdata) - np.nanmin(self.xdata)) / step))
-            if nstep > 200:
-                logger.warning(f"Variogram has too many steps: {nstep}, using 200")
-                maximum = step * nstep
+            nsteps = int(np.ceil((np.nanmax(self.xdata) - np.nanmin(self.xdata)) / step))
+            if nsteps > 200:
+                logger.warning(f"Variogram has too many steps: {nsteps}, using 200")
+                maximum = step * nsteps
                 nstep = 200
                 step = maximum / nstep
-            self.lags = np.arange(step / 2.0, nstep * step, step)
+            self.lags = np.arange(step / 2.0, nsteps * step, step)
             logger.info(
-                f"Using average minimum nearest neighbour distance as lag distance size {step} and using {nstep} lags"
+                f"Using average minimum nearest neighbour distance as lag distance size {step} and using {nsteps} lags"
+            )
+
+    def calc_semivariogram(
+        self,
+        step: Optional[float] = None,
+        nsteps: Optional[int] = None,
+        lags: Optional[np.ndarray] = None,
+    ):
+        """
+        Calculate a semi-variogram for the x and y data for this object.
+        You can specify the lags as an array or specify the step size and
+        number of steps.
+        If neither are specified then the lags are created to be the average
+        spacing of the data
+
+        Parameters
+        ----------
+        step:   float
+                lag distance for the s-variogram
+        nstep:  int
+                number of lags for the s-variogram
+        lags:   array
+                num
+
+        Returns
+        -------
+
+        """
+        logger.info("Calculating S-Variogram")
+        if lags is not None:
+            self.lags = lags
+        self.initialise_lags(step, nsteps)
+        if self.lags is None:
+            raise ValueError(
+                "S-Variogram cannot calculate the variogram step size, please specify either step or nsteps"
             )
         tol = self.lags[1] - self.lags[0]
         self.variogram = np.zeros(self.lags.shape)
@@ -133,7 +159,12 @@ class SVariogram:
                 self.variogram[i] = np.mean(self.variance_matrix[logic])
         return self.lags, self.variogram, npairs
 
-    def find_wavelengths(self, **kwargs):
+    def find_wavelengths(
+        self,
+        step: Optional[float] = None,
+        nsteps: Optional[int] = None,
+        lags: Optional[np.ndarray] = None,
+    ) -> List:
         """
         Picks the wavelengths of the fold by finding the maximum and
         minimums of the s-variogram
@@ -145,7 +176,7 @@ class SVariogram:
         ----------
         kwargs : object
         """
-        h, var, npairs = self.calc_semivariogram(**kwargs)
+        h, var, _npairs = self.calc_semivariogram(step=step, nsteps=nsteps, lags=lags)
 
         px, py = find_peaks_and_troughs(h, var)
 
@@ -156,7 +187,8 @@ class SVariogram:
             averagey.append((py[i] + py[i + 1]) / 2.0)
             i += 1  # iterate twice
         # find the extrema of the average curve
-        px2, py2 = find_peaks_and_troughs(averagex, averagey)
+        res = find_peaks_and_troughs(np.array(averagex), np.array(averagey))
+        px2, py2 = res
         wl1 = 0.0
         wl1py = 0.0
         for i in range(len(px)):
@@ -178,11 +210,14 @@ class SVariogram:
                         if wl2 > 0.0 and wl2 > wl1 * 2 and wl1py < py2[i]:
                             break
         if wl1 == 0.0 and wl2 == 0.0:
+            logger.warning(
+                'Could not automatically guess the wavelength, using 2x the range of the data'
+            )
             self.wavelength_guess = [2 * (np.max(self.xdata) - np.min(self.xdata)), 0.0]
             return self.wavelength_guess
         if np.isclose(wl1, 0.0):
             self.wavelength_guess = np.array([wl2 * 2.0, wl1 * 2.0])
-            return self.wavelength_guess
+            return [wl2]
         # wavelength is 2x the peak on the curve
-        self.wavelength_guess = np.array([wl1 * 2.0, wl2 * 2.0])
+        self.wavelength_guess = [wl1 * 2.0, wl2 * 2.0]
         return self.wavelength_guess

LoopStructural/modelling/features/fold/fold_function/__init__.py

@@ -0,0 +1,27 @@
+from ._trigo_fold_rotation_angle import TrigoFoldRotationAngleProfile
+from ._fourier_series_fold_rotation_angle import FourierSeriesFoldRotationAngleProfile
+from enum import Enum
+from typing import Optional
+import numpy.typing as npt
+import numpy as np
+
+
+class FoldRotationType(Enum):
+    TRIGONOMETRIC = TrigoFoldRotationAngleProfile
+    FOURIER_SERIES = FourierSeriesFoldRotationAngleProfile
+    # ADDITIONAL = AdditionalFoldRotationAngle
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return self.name
+
+
+def get_fold_rotation_profile(
+    fold_rotation_type,
+    rotation_angle: Optional[npt.NDArray[np.float64]] = None,
+    fold_frame_coordinate: Optional[npt.NDArray[np.float64]] = None,
+    **kwargs,
+):
+    return fold_rotation_type.value(rotation_angle, fold_frame_coordinate, **kwargs)