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

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)))

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

@@ -0,0 +1,46 @@
+from ._base_fold_rotation_angle import BaseFoldRotationAngleProfile
+import numpy as np
+import numpy.typing as npt
+from typing import Optional, Callable
+from .....utils import getLogger
+
+logger = getLogger(__name__)
+
+
+class LambdaFoldRotationAngleProfile(BaseFoldRotationAngleProfile):
+
+    def __init__(
+        self,
+        fn: Callable[[np.ndarray], np.ndarray],
+        rotation_angle: Optional[npt.NDArray[np.float64]] = None,
+        fold_frame_coordinate: Optional[npt.NDArray[np.float64]] = None,
+    ):
+        """The fold frame function using the lambda profile from Laurent 2016
+
+        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
+        lambda_ : float, optional
+            lambda parameter, by default 0
+        """
+        super().__init__(rotation_angle, fold_frame_coordinate)
+        self._function = fn
+
+    @property
+    def params(self):
+        return {}
+
+    def update_params(self, params):
+        pass
+
+    def initial_guess(
+        self,
+        wavelength: float | None = None,
+        calculate_wavelength: bool = True,
+        svariogram_parameters: dict = {},
+        reset: bool = False,
+    ) -> np.ndarray:
+        return np.array([])

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

@@ -0,0 +1,151 @@
+from ._base_fold_rotation_angle import BaseFoldRotationAngleProfile
+import numpy as np
+import numpy.typing as npt
+from typing import Optional, Union, List
+from .....utils import getLogger
+
+logger = getLogger(__name__)
+
+
+class TrigoFoldRotationAngleProfile(BaseFoldRotationAngleProfile):
+
+    def __init__(
+        self,
+        rotation_angle: Optional[npt.NDArray[np.float64]] = None,
+        fold_frame_coordinate: Optional[npt.NDArray[np.float64]] = None,
+        origin: float = 0,
+        wavelength: float = 0,
+        inflectionpointangle: float = 0,
+    ):
+        """The fold frame function using the trigo profile from Laurent 2016
+
+        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
+        origin : float, optional
+            phase shift parameter, by default 0
+        wavelength : float, optional
+            wavelength of the profile, by default 0
+        inflectionpointangle : float, optional
+            height of the profile, tightness of fold, by default 0
+        """
+        super().__init__(rotation_angle, fold_frame_coordinate)
+        self._origin = origin
+        self._wavelength = wavelength
+        self._inflectionpointangle = inflectionpointangle
+
+    @property
+    def origin(self):
+        return self._origin
+
+    @property
+    def wavelength(self):
+        return self._wavelength
+
+    @property
+    def inflectionpointangle(self):
+        return self._inflectionpointangle
+
+    @origin.setter
+    def origin(self, value):
+        if np.isfinite(value):
+            self.notify_observers()
+
+            self._origin = value
+        else:
+            raise ValueError("origin must be a finite number")
+
+    @wavelength.setter
+    def wavelength(self, value):
+        if np.isfinite(value):
+            self.notify_observers()
+
+            self._wavelength = value
+        else:
+            raise ValueError("wavelength must be a finite number")
+
+    @inflectionpointangle.setter
+    def inflectionpointangle(self, value):
+        if np.isfinite(value):
+            if value < np.deg2rad(-90) or value > np.deg2rad(90):
+                logger.error(f"Inflection point angle is {np.rad2deg(value)} degrees")
+                raise ValueError("inflectionpointangle must be between 0 and 90")
+            self.notify_observers()
+            self._inflectionpointangle = value
+
+        else:
+            raise ValueError("inflectionpointangle must be a finite number")
+
+    @property
+    def params(self):
+        return {
+            "origin": self.origin,
+            "wavelength": self.wavelength,
+            "inflectionpointangle": self.inflectionpointangle,
+        }
+
+    @staticmethod
+    def _function(s, origin, wavelength, inflectionpointangle):
+        """
+
+        Parameters
+        ----------
+        s
+        origin
+        wavelength
+        inflectionpointangle
+
+        Returns
+        -------
+
+        """
+        tan_alpha_delta_half = np.tan(inflectionpointangle)
+        tan_alpha_shift = 0
+        x = (s - origin) / wavelength
+        return tan_alpha_delta_half * np.sin(2 * np.pi * x) + tan_alpha_shift
+
+    # def __call__(self, fold_frame_coordinate):
+    #     return np.rad2deg(
+    #         np.tan(
+    #             self._function(
+    #                 fold_frame_coordinate, self.origin, self.wavelength, self.inflectionpointangle
+    #             )
+    #         )
+    #     )
+
+    def calculate_misfit(
+        self, rotation_angle: np.ndarray, fold_frame_coordinate: np.ndarray
+    ) -> np.ndarray:
+        return super().calculate_misfit(rotation_angle, fold_frame_coordinate)
+
+    def update_params(self, params: Union[List, npt.NDArray[np.float64]]) -> None:
+        self.origin = params[0]
+        self.wavelength = params[1]
+        self.inflectionpointangle = params[2]
+
+    def initial_guess(
+        self,
+        wavelength: Optional[float] = None,
+        calculate_wavelength: bool = True,
+        svariogram_parameters: dict = {},
+        reset: bool = True,
+    ):
+        # reset the fold paramters before fitting
+        # otherwise use the current values to fit
+        if reset:
+            self.origin = 0
+            self.wavelength = 0
+            self.inflectionpointangle = np.deg2rad(45)  # otherwise there is a numerical error
+        if calculate_wavelength:
+            self.wavelength = self.estimate_wavelength(svariogram_parameters=svariogram_parameters)
+        if wavelength is not None:
+            self.wavelength = wavelength
+        guess = [
+            self.fold_frame_coordinate.mean(),
+            self.wavelength,
+            np.max(np.arctan(np.deg2rad(self.rotation_angle))),
+        ]
+        return np.array(guess)

LoopStructural/modelling/input/process_data.py

@@ -441,6 +441,12 @@ class ProcessInputData:
             for g in reversed(sg):
                 if g not in self.thicknesses:
                     logger.warning(f"No thicknesses for {g}")
+                    stratigraphic_value[g] = np.nan
+                if self.thicknesses[g] <= 0:
+                    logger.error(
+                        f"Thickness for {g} is less than or equal to 0\n Update the thickness value for {g} before continuing"
+                    )
+
                     stratigraphic_value[g] = np.nan
                 else:
                     stratigraphic_value[g] = value

LoopStructural/modelling/input/project_file.py

@@ -22,7 +22,8 @@ class LoopProjectfileProcessor(ProcessInputData):
         orientations = self.projectfile.stratigraphyOrientations
         fault_orientations = self.projectfile.faultOrientations
         fault_locations = self.projectfile.faultLocations
-
+        fault_relationships = self.projectfile["eventRelationships"]
+        faultLog = self.projectfile.faultLog.set_index("eventId")
         orientations.rename(columns=column_map, inplace=True)
         contacts.rename(columns=column_map, inplace=True)
         fault_locations.rename(columns=column_map, inplace=True)
@@ -63,6 +64,26 @@ class LoopProjectfileProcessor(ProcessInputData):
                 ],
             )
         )
+
+        for i in fault_relationships.index:
+            fault_relationships.loc[i, "Fault1"] = faultLog.loc[
+                fault_relationships.loc[i, "eventId1"], "name"
+            ]
+            fault_relationships.loc[i, "Fault2"] = faultLog.loc[
+                fault_relationships.loc[i, "eventId2"], "name"
+            ]
+        fault_edges = []
+        fault_edge_properties = []
+        for i in fault_relationships.index:
+            fault_edges.append(
+                (fault_relationships.loc[i, "Fault1"], fault_relationships.loc[i, "Fault2"])
+            )
+            fault_edge_properties.append(
+                {
+                    "type": fault_relationships.loc[i, "type"],
+                    "angle": fault_relationships.loc[i, "angle"],
+                }
+            )
         super().__init__(
             contacts=contacts,
             contact_orientations=orientations,
@@ -73,12 +94,12 @@ class LoopProjectfileProcessor(ProcessInputData):
             fault_orientations=fault_orientations,
             fault_locations=fault_locations,
             fault_properties=fault_properties,
-            fault_edges=[],  # list(fault_graph.edges),
+            fault_edges=fault_edges,  # list(fault_graph.edges),
             colours=colours,
             fault_stratigraphy=None,
             intrusions=None,
             use_thickness=use_thickness,
             origin=self.projectfile.origin,
             maximum=self.projectfile.maximum,
-            #                     fault_edge_properties=fault_edge_properties
+            fault_edge_properties=fault_edge_properties,
         )

LoopStructural/utils/_surface.py

@@ -96,9 +96,12 @@ class LoopIsosurfacer:
                 "Number of isosurfaces must be greater than 1. Either use a positive integer or provide a list or float for a specific isovalue."
             )
         elif isinstance(values, int):
+            var = np.nanmax(all_values) - np.nanmin(all_values)
+            # buffer slices by 5% to make sure that we don't get isosurface does't exist issues
+            buffer = var * 0.05
             isovalues = np.linspace(
-                np.nanmin(all_values) + np.finfo(float).eps,
-                np.nanmax(all_values) - np.finfo(float).eps,
+                np.nanmin(all_values) + buffer,
+                np.nanmax(all_values) - buffer,
                 values,
             )
         logger.info(f'Isosurfacing at values: {isovalues}')