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

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

@@ -165,8 +165,19 @@ class ProcessInputData:
             unit_id = 1
             val = self._stratigraphic_value()
             for name, sg in self._stratigraphic_order:
+                # set the oldest unit to be the basement.
+                # this has no observed basal contact and then
+                # top of the unit is the 0 isovalue.
+                # this is the minimum of the next unit
                 stratigraphic_column[name] = {}
-                for i, g in enumerate(reversed(sg)):
+                stratigraphic_column[name][sg[-1]] = {
+                    "max": 0,
+                    "min": -np.inf,
+                    "id": unit_id,
+                    "colour": self.colours[sg[-1]],
+                }
+                # iterate through the remaining units (in reverse)
+                for g in reversed(sg[:-1]):
                     if g in self.thicknesses:
                         stratigraphic_column[name][g] = {
                             "max": val[g] + self.thicknesses[g],
@@ -174,10 +185,6 @@ class ProcessInputData:
                             "id": unit_id,
                             "colour": self.colours[g],
                         }
-                        if i == 0:
-                            stratigraphic_column[name][g]["min"] = 0
-                        if i == len(sg) - 1:
-                            stratigraphic_column[name][g]["max"] = np.inf
 
                     unit_id += 1
             # add faults into the column
@@ -438,9 +445,22 @@ class ProcessInputData:
         stratigraphic_value = {}
         for _name, sg in self.stratigraphic_order:
             value = 0.0  # reset for each supergroup
-            for g in reversed(sg):
+            if sg[0] not in self.thicknesses or self.thicknesses[sg[0]] <= 0:
+                self.thicknesses[sg[0]] = (
+                    np.inf
+                )  # make the top unit infinite as it should extend to the top of the model
+            for g in reversed(
+                sg[:-1]
+            ):  # don't add the last unit as we never see the base of this unit.
+                # It should be "basement"
                 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
@@ -463,30 +483,13 @@ class ProcessInputData:
 
     @property
     def contacts(self):
-        return self._contacts
-
-    @contacts.setter
-    def contacts(self, contacts):
-        """Function to convert input contact to loopstructural input
-
-        either uses the thickness values or assigns unique ids given
-        the units named in stratigraphic order
-
-        Returns
-        -------
-        DataFrame
-            data frame with x,y,y,val/interface,feature_name
-        """
-        if contacts is None:
-            return
-        contacts = contacts.copy()
-        self._update_feature_names(contacts)
+        contacts = self._contacts.copy()
         if self._use_thickness:
             contacts["val"] = np.nan
             for k, v in self._stratigraphic_value().items():
                 contacts.loc[contacts["name"] == k, "val"] = v
 
-            self._contacts = contacts.loc[
+            contacts = contacts.loc[
                 ~np.isnan(contacts["val"]), ["X", "Y", "Z", "feature_name", "val"]
             ]
         if not self._use_thickness:
@@ -494,10 +497,28 @@ class ProcessInputData:
             interface_val = 0
             for k in self._stratigraphic_value().keys():
                 contacts.loc[contacts["name"] == k, "interface"] = interface_val
-            self._contacts = contacts.loc[
+            contacts = contacts.loc[
                 ~np.isnan(contacts["interface"]),
                 ["X", "Y", "Z", "feature_name", "interface"],
             ]
+        return contacts
+
+    @contacts.setter
+    def contacts(self, contacts):
+        """Function to convert input contact to loopstructural input
+
+        either uses the thickness values or assigns unique ids given
+        the units named in stratigraphic order
+
+        Returns
+        -------
+        DataFrame
+            data frame with x,y,y,val/interface,feature_name
+        """
+        if contacts is None:
+            return
+        self._contacts = contacts.copy()
+        self._update_feature_names(self._contacts)
 
     @property
     def contact_orientations(self):

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)
@@ -33,24 +34,48 @@ class LoopProjectfileProcessor(ProcessInputData):
                 projectfile["stratigraphicLog"].ThicknessMedian,
             )
         )
-        fault_properties = self.projectfile.faultLog
-        fault_properties.rename(
-            columns={
-                "avgDisplacement": "displacement",
-                "influenceDistance": "minor_axis",
-                "verticalRadius": "intermediate_axis",
-                "horizontalRadius": "major_axis",
-                "name": "fault_name",
-            },
-            inplace=True,
-        )
-        fault_locations = fault_properties.reset_index()[["fault_name", "eventId"]].merge(
-            fault_locations, on="eventId"
-        )
-        fault_orientations = fault_properties.reset_index()[["fault_name", "eventId"]].merge(
-            fault_orientations, on="eventId"
-        )
-        fault_properties.set_index("fault_name", inplace=True)
+        fault_properties = None
+        fault_edges = None
+        fault_edge_properties = None
+        if self.projectfile.faultLog.shape[0] > 0:
+
+            fault_properties = self.projectfile.faultLog
+            fault_properties.rename(
+                columns={
+                    "avgDisplacement": "displacement",
+                    "influenceDistance": "minor_axis",
+                    "verticalRadius": "intermediate_axis",
+                    "horizontalRadius": "major_axis",
+                    "name": "fault_name",
+                },
+                inplace=True,
+            )
+            fault_locations = fault_properties.reset_index()[["fault_name", "eventId"]].merge(
+                fault_locations, on="eventId"
+            )
+            fault_orientations = fault_properties.reset_index()[["fault_name", "eventId"]].merge(
+                fault_orientations, on="eventId"
+            )
+            fault_properties.set_index("fault_name", inplace=True)
+            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"],
+                    }
+                )
         colours = dict(
             zip(
                 self.projectfile.stratigraphicLog.name,
@@ -63,6 +88,7 @@ class LoopProjectfileProcessor(ProcessInputData):
                 ],
             )
         )
+
         super().__init__(
             contacts=contacts,
             contact_orientations=orientations,
@@ -70,15 +96,15 @@ class LoopProjectfileProcessor(ProcessInputData):
                 ("sg", list(self.projectfile.stratigraphicLog.name))
             ],  # needs to be updated,
             thicknesses=thicknesses,
-            fault_orientations=fault_orientations,
-            fault_locations=fault_locations,
+            fault_orientations=fault_orientations if fault_orientations.shape[0] > 0 else None,
+            fault_locations=fault_locations if fault_locations.shape[0] > 0 else None,
             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/__init__.py

@@ -36,3 +36,4 @@ import numpy as np
 rng = np.random.default_rng()
 
 from ._surface import LoopIsosurfacer, surface_list
+from .colours import random_colour

LoopStructural/utils/_surface.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from typing import Optional, Union, Callable, List
+from collections.abc import Iterable
 import numpy as np
 import numpy.typing as npt
 from LoopStructural.utils.logging import getLogger
@@ -86,19 +87,25 @@ class LoopIsosurfacer:
         all_values = self.callable(self.bounding_box.regular_grid(local=False))
         ## set value to mean value if its not specified
         if values is None:
-            values = [(np.nanmax(all_values) - np.nanmin(all_values)) / 2]
-        if isinstance(values, list):
+            values = [((np.nanmax(all_values) - np.nanmin(all_values)) / 2) + np.nanmin(all_values)]
+        if isinstance(values, Iterable):
             isovalues = values
         elif isinstance(values, float):
             isovalues = [values]
+        if isinstance(values, int) and values == 0:
+            values = 0.0  # assume 0 isosurface is meant to be a float
+
         elif isinstance(values, int) and values < 1:
             raise ValueError(
                 "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}')

LoopStructural/utils/colours.py

@@ -0,0 +1,26 @@
+from LoopStructural.utils import rng
+
+
+def random_colour(n: int = 1, cmap='tab20'):
+    """
+    Generate a list of random colours
+
+    Parameters
+    ----------
+    n : int
+        Number of colours to generate
+    cmap : str, optional
+        Name of the matplotlib colour map to use, by default 'tab20'
+
+    Returns
+    -------
+    list
+        List of colours in the form of (r,g,b,a) tuples
+    """
+    import matplotlib.cm as cm
+
+    colours = []
+    for _i in range(n):
+        colours.append(cm.get_cmap(cmap)(rng.random()))
+
+    return colours

LoopStructural/utils/features.py

@@ -0,0 +1,5 @@
+from ..modelling.features import LambdaGeologicalFeature
+
+X = LambdaGeologicalFeature(lambda pos: pos[:, 0], name="x")
+Y = LambdaGeologicalFeature(lambda pos: pos[:, 1], name="y")
+Z = LambdaGeologicalFeature(lambda pos: pos[:, 2], name="z")

LoopStructural/utils/maths.py

@@ -244,3 +244,54 @@ def get_dip_vector(strike, dip):
         ]
     )
     return v
+
+
+def regular_tetraherdron_for_points(xyz, scale_parameter):
+    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
+    tetrahedron = np.zeros((xyz.shape[0], 4, 3))
+    tetrahedron[:] = xyz[:, None, :]
+    tetrahedron[:, :, :] += regular_tetrahedron[None, :, :]
+
+    return tetrahedron
+
+
+def gradient_from_tetrahedron(tetrahedron, value):
+    """
+    Calculate the gradient from a 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 * value[:, None, :], axis=2)
+    return v

LoopStructural/version.py

@@ -1 +1 @@
-__version__ = "1.6.2"
+__version__ = "1.6.5"