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

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)

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

@@ -0,0 +1,253 @@
+from abc import ABCMeta, abstractmethod
+from ast import List
+from typing import Union, Optional
+import numpy as np
+import numpy.typing as npt
+from .._svariogram import SVariogram
+from scipy.optimize import curve_fit
+
+from .....utils import getLogger
+
+logger = getLogger(__name__)
+
+
+class BaseFoldRotationAngleProfile(metaclass=ABCMeta):
+
+    def __init__(
+        self,
+        rotation_angle: Optional[npt.NDArray[np.float64]] = None,
+        fold_frame_coordinate: Optional[npt.NDArray[np.float64]] = None,
+    ):
+        """Base class for fold rotation angle functions
+
+        Parameters
+        ----------
+        rotation_angle : npt.NDArray[np.float64], optional
+            the calculated fold rotation angle from observations in degrees, by default None
+        fold_frame_coordinate : npt.NDArray[np.float64], optional
+            fold frame coordinate scalar field value, by default None
+        """
+
+        self.rotation_angle = rotation_angle
+        self.fold_frame_coordinate = fold_frame_coordinate
+        self._evaluation_points = None
+        self._observers = []
+        self._svariogram = None
+
+    @property
+    def svario(self) -> SVariogram:
+        if self.fold_frame_coordinate is None or self.rotation_angle is None:
+            raise ValueError("Fold rotation angle and fold frame coordinate must be set")
+        if self._svariogram is None:
+            self._svariogram = SVariogram(self.fold_frame_coordinate, self.rotation_angle)
+        return self._svariogram
+
+    @svario.setter
+    def svario(self, value: SVariogram):
+        if isinstance(value, SVariogram):
+            self._svariogram = value
+        else:
+            logger.error("svario must be an instance of SVariogram")
+            raise ValueError("svario must be an instance of SVariogram")
+
+    def add_observer(self, watcher):
+        self._observers.append(watcher)
+
+    def notify_observers(self):
+        for observer in self._observers:
+            observer.set_not_up_to_date(self)
+
+    def calculate_misfit(
+        self,
+        rotation_angle: np.ndarray,
+        fold_frame_coordinate: np.ndarray,
+    ) -> np.ndarray:
+        """Calculate the rotation angle for the fold frame coordinate and return the misfit
+
+        Parameters
+        ----------
+        params : dict, optional
+            Any parameters required to fit the function to the data, by default {}
+        rotation_angle : np.ndarray
+            fold rotation angle in degrees
+        fold_frame_coordinate : np.ndarray
+            fold frame coordinate
+
+        Returns
+        -------
+        misfit : np.ndarray
+            returns misfit in degrees"""
+        return np.tan(np.deg2rad(rotation_angle)) - np.tan(
+            np.deg2rad(self.__call__(fold_frame_coordinate))
+        )
+
+    def estimate_wavelength(
+        self, svariogram_parameters: dict = {}, wavelength_number: int = 1
+    ) -> Union[float, np.ndarray]:
+        """Estimate the wavelength of the fold profile using the svariogram parameters
+
+        Parameters
+        ----------
+        svariogram_parameters : dict
+            svariogram parameters
+
+        Returns
+        -------
+        float
+            estimated wavelength
+        """
+        wl = self.svario.find_wavelengths(**svariogram_parameters)
+        if wavelength_number == 1:
+            return wl[0]
+        return wl
+
+    @property
+    def evaluation_points(self):
+        """Return the evaluation points for the fold rotation angle function
+
+        Returns
+        -------
+        np.ndarray
+            evaluation points
+        """
+        if self._evaluation_points is not None:
+            return self._evaluation_points
+        return np.linspace(
+            np.min(self.fold_frame_coordinate), np.max(self.fold_frame_coordinate), 300
+        )
+
+    @evaluation_points.setter
+    def evaluation_points(self, value):
+        self._evaluation_points = value
+
+    def fit(self, params: dict = {}) -> bool:
+        """
+
+        Parameters
+        ----------
+        params : dict, optional
+            _description_, by default {}
+
+        Returns
+        -------
+        bool
+            _description_
+        """
+        if len(self.params) > 0:
+            success = False
+            if self.rotation_angle is None or self.fold_frame_coordinate is None:
+                logger.error("Fold rotation angle and fold frame coordinate must be set")
+                return False
+            guess = params.get(
+                "guess",
+                self.initial_guess(
+                    wavelength=params.get("wavelength", None),
+                    reset=params.get("reset", False),
+                    svariogram_parameters=params.get("svariogram_parameters", {}),
+                    calculate_wavelength=params.get("calculate_wavelength", True),
+                ),
+            )
+            mask = np.logical_or(
+                ~np.isnan(self.fold_frame_coordinate), ~np.isnan(self.rotation_angle)
+            )
+            logger.info(f"Percentage of points not used {np.sum(~mask)/len(mask)*100}")
+            try:
+                logger.info(f"Trying to fit fold rotation angle with guess {guess}")
+                logger.info(f"Fold profile type: {self.__class__.__name__}")
+                res = curve_fit(
+                    self._function,
+                    self.fold_frame_coordinate[mask],
+                    np.tan(np.deg2rad(self.rotation_angle[mask])),
+                    p0=guess,
+                    full_output=True,
+                )
+                logger.info(f'Fit results: {res[0]}')
+                guess = res[0]
+                logger.info(res[3])
+                success = True
+            except Exception as _e:
+                logger.error("Could not fit curve to S-Plot, check the wavelength")
+            try:
+                self.update_params(guess)
+            except Exception as _e:
+                logger.error("Could not update parameters")
+                return False
+            return success
+        return True
+
+    @abstractmethod
+    def update_params(self, params: Union[List, npt.NDArray[np.float64]]) -> None:
+        """Update the parameters of the fold rotation angle function
+
+        Parameters
+        ----------
+        params : dict
+            parameters to update
+        """
+        pass
+
+    @abstractmethod
+    def initial_guess(
+        self,
+        wavelength: Optional[float] = None,
+        calculate_wavelength: bool = True,
+        svariogram_parameters: dict = {},
+        reset: bool = False,
+    ) -> np.ndarray:
+        """_summary_
+
+        Parameters
+        ----------
+        selfcalculate_wavelength : bool, optional
+            _description_, by default True
+        svariogram_parameters : dict, optional
+            _description_, by default {}
+        reset : bool, optional
+            _description_, by default False
+
+        Returns
+        -------
+        np.ndarray
+            _description_
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def _function(s, *args, **kwargs):
+        """This is the function that is used to calculate the fold rotation angle
+        for a given fold frame coordinate
+        it is not called directly but is used by the __call__ method
+
+        Parameters
+        ----------
+        s
+        *args
+
+        Returns
+        -------
+        _description_
+        """
+        pass
+
+    def plot(self, ax=None, show_data=True, **kwargs):
+        """Plot the fold rotation angle function
+
+        Parameters
+        ----------
+        ax : _description_, optional
+            _description_, by default None
+        **kwargs
+            passed to matplotlib plot
+        """
+        if ax is None:
+            import matplotlib.pyplot as plt
+
+            fig, ax = plt.subplots()
+        if show_data:
+            ax.scatter(self.fold_frame_coordinate, self.rotation_angle, c="r")
+        ax.plot(self.evaluation_points, self(self.evaluation_points), **kwargs)
+        return ax
+
+    def __call__(self, s):
+        return np.rad2deg(np.arctan(self._function(s, **self.params)))

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

@@ -0,0 +1,153 @@
+from ._base_fold_rotation_angle import BaseFoldRotationAngleProfile
+import numpy as np
+import numpy.typing as npt
+from typing import Optional, List, Union
+from .....utils import getLogger
+
+logger = getLogger(__name__)
+
+
+class FourierSeriesFoldRotationAngleProfile(BaseFoldRotationAngleProfile):
+    def __init__(
+        self,
+        rotation_angle: Optional[npt.NDArray[np.float64]] = None,
+        fold_frame_coordinate: Optional[npt.NDArray[np.float64]] = None,
+        c0=0,
+        c1=0,
+        c2=0,
+        w=1,
+    ):
+        """_summary_
+
+        Parameters
+        ----------
+        rotation_angle : Optional[npt.NDArray[np.float64]], optional
+            _description_, by default None
+        fold_frame_coordinate : Optional[npt.NDArray[np.float64]], optional
+            _description_, by default None
+        c0 : int, optional
+            _description_, by default 0
+        c1 : int, optional
+            _description_, by default 0
+        c2 : int, optional
+            _description_, by default 0
+        w : int, optional
+            _description_, by default 1
+        """
+        super().__init__(rotation_angle, fold_frame_coordinate)
+        self._c0 = c0
+        self._c1 = c1
+        self._c2 = c2
+        self._w = w
+
+    @property
+    def c0(self):
+        return self._c0
+
+    @c0.setter
+    def c0(self, value):
+        self.notify_observers()
+        self._c0 = value
+
+    @property
+    def c1(self):
+        return self._c1
+
+    @c1.setter
+    def c1(self, value):
+        self.notify_observers()
+        self._c1 = value
+
+    @property
+    def c2(self):
+        return self._c2
+
+    @c2.setter
+    def c2(self, value):
+        self.notify_observers()
+        self._c2 = value
+
+    @property
+    def w(self):
+        return self._w
+
+    @w.setter
+    def w(self, value):
+        if value <= 0:
+            raise ValueError('wavelength must be greater than 0')
+        self.notify_observers()
+        self._w = value
+
+    @staticmethod
+    def _function(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 v
+
+    def initial_guess(
+        self,
+        wavelength: Optional[float] = None,
+        calculate_wavelength: bool = True,
+        svariogram_parameters: dict = {},
+        reset: bool = False,
+    ):
+        # reset the fold paramters before fitting
+        # otherwise use the current values to fit
+        if reset:
+            self.c0 = np.mean(np.arctan(np.deg2rad(self.rotation_angle)))
+            self.c1 = 0
+            self.c2 = np.max(np.arctan(np.deg2rad(self.rotation_angle)))
+            self.w = 1
+        if calculate_wavelength:
+            self.w = self.estimate_wavelength(svariogram_parameters=svariogram_parameters)
+        if wavelength is not None:
+            self.w = wavelength
+        guess = [self.c0, self.c1, self.c2, self.w]
+        return guess
+
+    @property
+    def params(self):
+        return {
+            "c0": self.c0,
+            "c1": self.c1,
+            "c2": self.c2,
+            "w": self.w,
+        }
+
+    @params.setter
+    def params(self, params):
+        for key in params:
+            if key == 'w':
+                if params[key] <= 0:
+                    raise ValueError('wavelength must be greater than 0')
+            setattr(self, key, params[key])
+        self.c0 = params["c0"]
+        self.c1 = params["c1"]
+        self.c2 = params["c2"]
+        self.w = params["w"]
+
+    def update_params(self, params: Union[List[float], npt.NDArray[np.float64]]):
+        if len(params) != 4:
+            raise ValueError('params must have 4 elements')
+        self.c0 = params[0]
+        self.c1 = params[1]
+        self.c2 = params[2]
+        self.w = params[3]
+
+    def calculate_misfit(self, s, rotation_angle):
+        return np.tan(np.deg2rad(rotation_angle)) - np.tan(np.deg2rad(self.__call__(s)))