LoopStructural 1.6.12__py3-none-any.whl → 1.6.14__py3-none-any.whl

LoopStructural/datatypes/_bounding_box.py

@@ -281,6 +281,7 @@ class BoundingBox:
             origin=origin,
             maximum=maximum,
             global_origin=self.global_origin,
+            nsteps=self.nsteps,
             dimensions=self.dimensions,
         )
 
@@ -387,7 +388,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/interpolators/__init__.py

@@ -83,8 +83,16 @@ from ..interpolators._p1interpolator import P1Interpolator
 try:
     from ..interpolators._surfe_wrapper import SurfeRBFInterpolator
 except ImportError:
-    logger.warning("Surfe is not installed, SurfeRBFInterpolator will not be available")
-    SurfeRBFInterpolator = None
+    class SurfeRBFInterpolator(GeologicalInterpolator):
+        """
+        Dummy class to handle the case where Surfe is not installed.
+        This will raise a warning when used.
+        """
+
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "Surfe cannot be imported. Please install Surfe. pip install surfe/ conda install -c loop3d surfe"
+            ) 
 interpolator_map = {
     InterpolatorType.BASE: GeologicalInterpolator,
     InterpolatorType.BASE_DISCRETE: DiscreteInterpolator,

LoopStructural/interpolators/_finite_difference_interpolator.py

@@ -454,22 +454,28 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
                 )
             self.up_to_date = False
 
-    def add_regularisation(self, operator, w=0.1):
-        """
 
-        Parameters
-        ----------
-        operator
-        w
 
-        Returns
-        -------
+    # def assemble_borders(self, operator, w, name='regularisation'):
+    #     """
+    #     Adds a constraint to the border of the model to force the value to be equal to the value at the border
 
-        """
-        self.assemble_inner(operator, w)
-        # self.assemble_borders()
+    #     Parameters
+    #     ----------
+    #     operator : Operator
+    #         operator to use for the regularisation
+    #     w : double
+    #         weight of the regularisation
+
+    #     Returns
+    #     -------
+
+    #     """
+    #     # First get the global indicies of the pairs of neighbours this should be an
+    #     # Nx27 array for 3d and an Nx9 array for 2d
+
+    #     global_indexes = self.support.neighbour_global_indexes()
 
-    # def assemble_borders(self, operator, w):
 
     def assemble_inner(self, operator, w, name='regularisation'):
         """

LoopStructural/interpolators/_p1interpolator.py

@@ -146,7 +146,7 @@ class P1Interpolator(DiscreteInterpolator):
         self.reset()
         for key in kwargs:
             if "regularisation" in kwargs:
-                self.interpolation_weights["cgw"] = 0.1 * kwargs["regularisation"]
+                self.interpolation_weights["cgw"] = kwargs["regularisation"]
             self.up_to_date = False
             self.interpolation_weights[key] = kwargs[key]
         if self.interpolation_weights["cgw"] > 0.0:

LoopStructural/interpolators/supports/_3d_structured_grid.py

@@ -437,8 +437,9 @@ class StructuredGrid(BaseStructuredSupport):
         T[:, 2, 6] = (1 - local_coords[:, 0]) * local_coords[:, 1]
         T[:, 2, 3] = -local_coords[:, 0] * local_coords[:, 1]
         T[:, 2, 7] = local_coords[:, 0] * local_coords[:, 1]
-        T /= self.step_vector[0]
-
+        T[:, 0, :] /= self.step_vector[None, 0]
+        T[:, 1, :] /= self.step_vector[None, 1]
+        T[:, 2, :] /= self.step_vector[None, 2]
         return vertices, T, elements, inside
 
     def get_element_for_location(self, pos: np.ndarray):

LoopStructural/modelling/__init__.py

@@ -22,6 +22,14 @@ from ..modelling.input import (
 try:
     from ..modelling.input.project_file import LoopProjectfileProcessor
 except (LoopImportError, ImportError):
-    logger.warning(
-        "Cannot use LoopProjectfileProcessor: Loop project file cannot be imported, try installing LoopProjectFile"
-    )
+    class LoopProjectfileProcessor(ProcessInputData):
+        """
+        Dummy class to handle the case where LoopProjectFile is not installed.
+        This will raise a warning when used.
+        """
+
+        def __init__(self, *args, **kwargs):
+            raise LoopImportError(
+                "LoopProjectFile cannot be imported. Please install LoopProjectFile."
+            )
+    

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/modelling/features/_lambda_geological_feature.py

@@ -1,12 +1,13 @@
 """
 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__)
 
@@ -18,8 +19,8 @@ class LambdaGeologicalFeature(BaseFeature):
         name: str = "unnamed_lambda",
         gradient_function: Optional[Callable[[np.ndarray], np.ndarray]] = None,
         model=None,
-        regions: list = [],
-        faults: list = [],
+        regions: Optional[list] = None,
+        faults: Optional[list] = None,
         builder=None,
     ):
         """A lambda geological feature is a wrapper for a geological
@@ -43,10 +44,11 @@ class LambdaGeologicalFeature(BaseFeature):
         builder : _type_, optional
             _description_, by default None
         """
-        BaseFeature.__init__(self, name, model, faults, regions, builder)
+        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_
@@ -62,13 +64,16 @@ class LambdaGeologicalFeature(BaseFeature):
             _description_
         """
         v = np.zeros((pos.shape[0]))
-        if self.function is None:
-            v[:] = np.nan
-        else:
-            v[:] = self.function(pos)
+        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) -> np.ndarray:
+    def evaluate_gradient(self, pos: np.ndarray, ignore_regions=False,element_scale_parameter=None) -> np.ndarray:
         """_summary_
 
         Parameters
@@ -81,7 +86,60 @@ class LambdaGeologicalFeature(BaseFeature):
         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:

LoopStructural/modelling/features/builders/_fault_builder.py

@@ -3,7 +3,6 @@ from typing import Union
 from LoopStructural.utils.maths import rotation
 from ._structural_frame_builder import StructuralFrameBuilder
 from .. import AnalyticalGeologicalFeature
-from LoopStructural.utils import get_vectors
 import numpy as np
 import pandas as pd
 from ....utils import getLogger
@@ -52,8 +51,11 @@ class FaultBuilder(StructuralFrameBuilder):
         self.frame.model = model
         self.origin = np.array([np.nan, np.nan, np.nan])
         self.maximum = np.array([np.nan, np.nan, np.nan])  # self.model.bounding_box[1, :]
+
+        if bounding_box is None:
+            raise ValueError("BoundingBox cannot be None")
+
         # define a maximum area to mesh adding buffer to model
-        # buffer = .2
         self.minimum_origin = bounding_box.with_buffer(fault_bounding_box_buffer).origin
         self.maximum_maximum = bounding_box.with_buffer(fault_bounding_box_buffer).maximum
 
@@ -66,8 +68,23 @@ class FaultBuilder(StructuralFrameBuilder):
         self.fault_centre = None
 
     def update_geometry(self, points):
+        """
+        Update the geometry of the fault by adjusting the origin and maximum bounds
+        based on the provided points.
+
+        Parameters
+        ----------
+        points : numpy.ndarray
+            Array of points used to update the fault geometry.
+        """
+        if self.origin is None or self.maximum is None:
+            raise ValueError("Origin and maximum must be initialized before updating geometry.")
+
         self.origin = np.nanmin(np.array([np.min(points, axis=0), self.origin]), axis=0)
         self.maximum = np.nanmax(np.array([np.max(points, axis=0), self.maximum]), axis=0)
+        # add a small buffer 10% of current length to the origin and maximum
+        self.origin = self.origin - 0.1 * (self.maximum - self.origin)
+        self.maximum = self.maximum + 0.1 * (self.maximum - self.origin)
         self.origin[self.origin < self.minimum_origin] = self.minimum_origin[
             self.origin < self.minimum_origin
         ]
@@ -93,144 +110,109 @@ class FaultBuilder(StructuralFrameBuilder):
         fault_dip_anisotropy=1.0,
         fault_pitch=None,
     ):
-        """Generate the required data for building a fault frame for a fault with the
-        specified parameters
+        """
+        Generate the required data for building a fault frame with the specified parameters.
 
         Parameters
         ----------
-        data : DataFrame,
-            model data
-        fault_center : np.array(3)
-            x,y,z coordinates of the fault center
-        normal_vector : np.array(3)
-            x,y,z components of normal vector to fault, single observation usually
-            average direction
-        slip_vector : np.array(3)
-            x,y,z components of slip vector for the fault, single observation usually
-            average direction
-        minor_axis : double
-            distance away from fault for the fault volume
-        major_axis : double
-            fault extent
-        intermediate_axis : double
-            fault volume radius in the slip direction
+        fault_frame_data : pandas.DataFrame
+            DataFrame containing fault frame data.
+        fault_center : array-like, optional
+            Coordinates of the fault center.
+        fault_normal_vector : array-like, optional
+            Normal vector of the fault.
+        fault_slip_vector : array-like, optional
+            Slip vector of the fault.
+        minor_axis : float, optional
+            Minor axis length of the fault.
+        major_axis : float, optional
+            Major axis length of the fault.
+        intermediate_axis : float, optional
+            Intermediate axis length of the fault.
+        w : float, default=1.0
+            Weighting factor for the fault data.
+        points : bool, default=False
+            Whether to include points in the fault data.
+        force_mesh_geometry : bool, default=False
+            Whether to force the use of mesh geometry.
+        fault_buffer : float, default=0.2
+            Buffer size around the fault.
+        fault_trace_anisotropy : float, default=1.0
+            Anisotropy factor for the fault trace.
+        fault_dip : float, default=90
+            Dip angle of the fault in degrees.
+        fault_dip_anisotropy : float, default=1.0
+            Anisotropy factor for the fault dip.
+        fault_pitch : float, optional
+            Pitch angle of the fault.
         """
-        trace_mask = np.logical_and(fault_frame_data["coord"] == 0, fault_frame_data["val"] == 0)
-        logger.info(f"There are {np.sum(trace_mask)} points on the fault trace")
-        if np.sum(trace_mask) == 0 and fault_center is None:
-            logger.error("You cannot model a fault without defining the location of the fault")
-            raise ValueError("There are no points on the fault trace")
-        # find the middle point on the fault trace if center is not provided
-        if fault_center is None:
-            trace_mask = np.logical_and(
-                fault_frame_data["coord"] == 0, fault_frame_data["val"] == 0
-            )
-            fault_center = fault_frame_data.loc[trace_mask, ["X", "Y", "Z"]].mean(axis=0).to_numpy()
-            dist = np.linalg.norm(
-                fault_center - fault_frame_data.loc[trace_mask, ["X", "Y", "Z"]].to_numpy(), axis=1
-            )
-            # make the nan points greater than the max dist 10 is arbitrary and doesn't matter
-            dist[np.isnan(dist)] = np.nanmax(dist) + 10
-            fault_center = fault_frame_data.loc[trace_mask, ["X", "Y", "Z"]].to_numpy()[
-                np.argmin(dist), :
-            ]
-        # get all of the gradient data associated with the fault trace
+        fault_trace = fault_frame_data.loc[
+            np.logical_and(fault_frame_data["coord"] == 0, fault_frame_data["val"] == 0),
+            ["X", "Y"],
+        ].to_numpy()
         if fault_normal_vector is None:
-            gradient_mask = np.logical_and(
-                fault_frame_data["coord"] == 0, ~np.isnan(fault_frame_data["gz"])
-            )
-            vector_data = fault_frame_data.loc[gradient_mask, ["gx", "gy", "gz"]].to_numpy()
-            normal_mask = np.logical_and(
-                fault_frame_data["coord"] == 0, ~np.isnan(fault_frame_data["nz"])
-            )
-            vector_data = np.vstack(
-                [
-                    vector_data,
-                    fault_frame_data.loc[normal_mask, ["nx", "ny", "nz"]].to_numpy(),
-                ]
-            )
+            if fault_frame_data.loc[
+            np.logical_and(fault_frame_data["coord"] == 0, fault_frame_data["nx"].notna())].shape[0]>0:
+                fault_normal_vector = fault_frame_data.loc[
+                    np.logical_and(fault_frame_data["coord"] == 0, fault_frame_data["nx"].notna()),
+                    ["nx", "ny", "nz"],
+                ].to_numpy().mean(axis=0)
 
-            if len(vector_data) == 0:
-                logger.warning(
-                    f"No orientation data for fault\n\
-                    Defaulting to a dip of {fault_dip}vertical fault"
-                )
-                # if the line is long enough, estimate the normal vector
-                # by finding the centre point of the line and calculating the tangnent
-                # of the two points
-                if fault_frame_data.loc[trace_mask, :].shape[0] > 3:
-
-                    pts = fault_frame_data.loc[trace_mask, ["X", "Y", "Z"]].to_numpy()
-                    dist = np.abs(np.linalg.norm(fault_center - pts, axis=1))
-                    # any nans just make them max distance + a bit
-                    dist[np.isnan(dist)] = np.nanmax(dist) + 10
-                    # idx = np.argsort(dist)
-                    # direction_vector = pts[idx[-1]] - pts[idx[-2]]
-                    # coefficients = np.polyfit(
-                    #     fault_frame_data.loc[trace_mask, "X"],
-                    #     fault_frame_data.loc[trace_mask, "Y"],
-                    #     1,
-                    # )
-                    # slope, intercept = coefficients
-                    slope, intercept = np.polyfit(
-                        pts[dist < 0.25 * np.nanmax(dist), 0],
-                        pts[dist < 0.25 * np.nanmax(dist), 1],
-                        1,
-                    )
-
-                    # # Create a direction vector using the slope
-                    direction_vector = np.array([1, slope, 0])
-                    direction_vector /= np.linalg.norm(direction_vector)
-                    rotation_matrix = rotation(direction_vector[None, :], [90 - fault_dip])
-                    vector_data = np.array(
-                        [
-                            [
-                                direction_vector[1],
-                                -direction_vector[0],
-                                0,
-                            ]
-                        ]
-                    )
-                    vector_data /= np.linalg.norm(vector_data, axis=1)
-                    vector_data = np.einsum("ijk,ik->ij", rotation_matrix, vector_data)
-
-                    vector_data /= np.linalg.norm(vector_data, axis=1)
-            fault_normal_vector = np.mean(vector_data, axis=0)
+            else:
 
-        logger.info(f"Fault normal vector: {fault_normal_vector}")
+                # Calculate fault strike using eigenvectors
+                pts = fault_trace - fault_trace.mean(axis=0)
+                # Calculate covariance matrix
+                cov_matrix = pts.T @ pts
+                # Get eigenvectors and eigenvalues
+                eigenvalues, eigenvectors = np.linalg.eigh(cov_matrix)
+                # Use eigenvector with largest eigenvalue as strike direction
+                strike_vector = eigenvectors[:, np.argmax(eigenvalues)]
+                strike_vector = np.append(strike_vector, 0)  # Add z component
+                strike_vector /= np.linalg.norm(strike_vector)
+
+                fault_normal_vector = np.cross(strike_vector, [0, 0, 1])
+                # Rotate the fault normal vector according to the fault dip
+                rotation_matrix = rotation(strike_vector[None, :], np.array([90 - fault_dip]))
+                fault_normal_vector = np.einsum("ijk,ik->ij", rotation_matrix, fault_normal_vector[None, :])[0]
+
+        if not isinstance(fault_normal_vector, np.ndarray):
+            fault_normal_vector = np.array(fault_normal_vector)
+
+        if fault_pitch is not None:
+            rotation_matrix = rotation(fault_normal_vector[None, :], np.array([fault_pitch]))
+            fault_slip_vector = np.einsum("ijk,ik->ij", rotation_matrix, fault_normal_vector[None, :])[0]
 
-        # estimate the fault slip vector
         if fault_slip_vector is None:
-            slip_mask = np.logical_and(
-                fault_frame_data["coord"] == 1, ~np.isnan(fault_frame_data["gz"])
-            )
-            fault_slip_data = fault_frame_data.loc[slip_mask, ["gx", "gy", "gz"]]
-
-            if len(fault_slip_data) == 0:
-                logger.warning(
-                    "There is no slip vector data for the fault, using vertical slip vector\n\
-                          projected onto fault surface estimating from fault normal"
-                )
-                strike_vector, dip_vector = get_vectors(fault_normal_vector[None, :])
-                fault_slip_vector = dip_vector[:, 0]
-                if fault_pitch is not None:
-                    print('using pitch')
-                    rotm = rotation(fault_normal_vector[None,:],[fault_pitch])
-                    print(rotm.shape,fault_slip_vector.shape)
-                    fault_slip_vector = np.einsum("ijk,k->ij", rotm, fault_slip_vector)[0,:]
-                logger.info(f"Estimated fault slip vector: {fault_slip_vector}")
-            else:
-                fault_slip_vector = fault_slip_data.mean(axis=0).to_numpy()
+            if fault_frame_data.loc[
+            np.logical_and(fault_frame_data["coord"] == 1, fault_frame_data["nx"].notna())].shape[0]>0:
+                fault_slip_vector = fault_frame_data.loc[
+                    np.logical_and(fault_frame_data["coord"] == 1, fault_frame_data["nx"].notna()),
+                    ["nx", "ny", "nz"],
+                ].to_numpy().mean(axis=0)
 
-        self.fault_normal_vector = fault_normal_vector
-        self.fault_slip_vector = fault_slip_vector
-
-        self.fault_centre = fault_center
-        if major_axis is None:
+            else:
+                fault_slip_vector = np.cross(fault_normal_vector, [1., 0., 0.])
+                if np.linalg.norm(fault_slip_vector) == 0:
+                    fault_slip_vector = np.cross(fault_normal_vector, [0., 1., 0.])
+                fault_slip_vector /= np.linalg.norm(fault_slip_vector)
+        if fault_center is None:
             fault_trace = fault_frame_data.loc[
                 np.logical_and(fault_frame_data["coord"] == 0, fault_frame_data["val"] == 0),
                 ["X", "Y"],
             ].to_numpy()
+            fault_center = fault_trace.mean(axis=0)
+            fault_center = np.array([fault_center[0], fault_center[1], 0.0])
+        if not isinstance(fault_center, np.ndarray):
+            fault_center = np.array(fault_center)
+        if fault_center.shape[0] != 3:
+            raise ValueError("fault_center must be a 3 element array")
+        self.fault_normal_vector = fault_normal_vector / np.linalg.norm(fault_normal_vector)
+        self.fault_slip_vector = fault_slip_vector / np.linalg.norm(fault_slip_vector)
+
+        self.fault_centre = fault_center
+        if major_axis is None:
+
             distance = np.linalg.norm(fault_trace[:, None, :] - fault_trace[None, :, :], axis=2)
             if len(distance) == 0 or np.sum(distance) == 0:
                 logger.warning("There is no fault trace for {}".format(self.name))
@@ -382,6 +364,7 @@ class FaultBuilder(StructuralFrameBuilder):
                             0,
                             w,
                         ]
+
             if major_axis is not None:
                 fault_tips[0, :] = fault_center[:3] + strike_vector * 0.5 * major_axis
                 fault_tips[1, :] = fault_center[:3] - strike_vector * 0.5 * major_axis
@@ -503,16 +486,14 @@ class FaultBuilder(StructuralFrameBuilder):
             self.origin - length * buffer, self.maximum + length * buffer, rotation
         )
 
-    def add_splay(self, splay, splayregion=None):
-        if splayregion is None:
+    def add_splay(self, splay, splay_region=None):
+        if splay_region is None:
 
-            def splayregion(xyz):
+            def default_splay_region(xyz):
                 pts = (
-                    self.builders[0].data[["X", "Y", "Z", "val"]].to_numpy()
+                    self.builders[0].data["X", "Y", "Z", "val"].to_numpy()
                 )  # get_value_constraints()
                 pts = pts[pts[:, 3] == 0, :]
-                # check whether the fault is on the hanging wall or footwall of splay fault
-
                 ext_field = splay[2].evaluate_value(pts[:, :3])
                 surf_field = splay[0].evaluate_value(pts[:, :3])
                 intersection_value = ext_field[np.nanargmin(np.abs(surf_field))]
@@ -531,19 +512,24 @@ class FaultBuilder(StructuralFrameBuilder):
                     )
                     return mask
 
+            splay_region = default_splay_region
+
         scalefactor = splay.fault_major_axis / self.fault_major_axis
-        self.builders[0].add_equality_constraints(splay, splayregion, scalefactor)
-        return splayregion
+        self.builders[0].add_equality_constraints(splay, splay_region, scalefactor)
+        return splay_region
 
     def add_fault_trace_anisotropy(self, w: float = 1.0):
-        """_summary_
+        """
+        Add fault trace anisotropy to the model.
 
         Parameters
         ----------
         w : float, optional
-            _description_, by default 1.0
+            Weighting factor for the anisotropy, by default 1.0
         """
         if w > 0:
+            if self.fault_normal_vector is None:
+                raise ValueError("fault_normal_vector must be initialized before adding anisotropy.")
 
             plane = np.array([0, 0, 1])
             strike_vector = (
@@ -553,24 +539,25 @@ class FaultBuilder(StructuralFrameBuilder):
             strike_vector = np.array([strike_vector[1], -strike_vector[0], 0])
 
             anisotropy_feature = AnalyticalGeologicalFeature(
-                vector=strike_vector, origin=[0, 0, 0], name="fault_trace_anisotropy"
+                vector=strike_vector, origin=np.array([0, 0, 0]), name="fault_trace_anisotropy"
             )
-            # print('adding fault trace anisotropy')
             self.builders[0].add_orthogonal_feature(
                 anisotropy_feature, w=w, region=None, step=1, B=0
             )
 
     def add_fault_dip_anisotropy(self, w: float = 1.0):
-        """_summary_
+        """
+        Add fault dip anisotropy to the model.
 
         Parameters
         ----------
-        dip : np.ndarray
-            _description_
         w : float, optional
-            _description_, by default 1.0
+            Weighting factor for the anisotropy, by default 1.0
         """
         if w > 0:
+            if self.fault_normal_vector is None:
+                raise ValueError("fault_normal_vector must be initialized before adding anisotropy.")
+
             plane = np.array([0, 0, 1])
             strike_vector = (
                 self.fault_normal_vector - np.dot(self.fault_normal_vector, plane) * plane
@@ -579,11 +566,11 @@ class FaultBuilder(StructuralFrameBuilder):
             strike_vector = np.array([strike_vector[1], -strike_vector[0], 0])
 
             dip_vector = np.cross(strike_vector, self.fault_normal_vector)
+            dip_vector /= np.linalg.norm(dip_vector)
 
             anisotropy_feature = AnalyticalGeologicalFeature(
-                vector=dip_vector, origin=[0, 0, 0], name="fault_dip_anisotropy"
+                vector=dip_vector, origin=np.array([0, 0, 0]), name="fault_dip_anisotropy"
             )
-            # print(f'adding fault dip anisotropy {anisotropy_feature.name}')
             self.builders[0].add_orthogonal_feature(
                 anisotropy_feature, w=w, region=None, step=1, B=0
             )

LoopStructural/modelling/features/builders/_geological_feature_builder.py

@@ -86,7 +86,7 @@ class GeologicalFeatureBuilder(BaseBuilder):
         self._orthogonal_features = {}
         self._equality_constraints = {}
         # add default parameters
-        self.update_build_arguments({'cpw':1.0,'npw':1.0,'regularisation':1.0,'nelements':self.interpolator.n_elements})
+        self.update_build_arguments({'cpw':1.0,'npw':1.0,'regularisation':.10,'nelements':self.interpolator.n_elements})
     def set_not_up_to_date(self, caller):
         logger.info(
             f"Setting {self.name} to not up to date from an instance of {caller.__class__.__name__}"

LoopStructural/modelling/features/fault/_fault_function.py

@@ -10,8 +10,10 @@ logger = getLogger(__name__)
 
 
 def smooth_peak(x):
-    return 0.25 * x**6 + 0.5 * x**4 - 1.75 * x**2 + 1
-
+    v = np.zeros(x.shape)
+    mask = np.logical_and(x >= -1, x <= 1)
+    v[mask] = x[mask] ** 4 - 2 * x[mask] ** 2 + 1
+    return v
 
 class FaultProfileFunction(metaclass=ABCMeta):
     def __init__(self):

LoopStructural/modelling/features/fault/_fault_segment.py

@@ -467,7 +467,7 @@ class FaultSegment(StructuralFrame):
             )
         self.abut[abutting_fault_feature.name] = abutting_region
         self.__getitem__(0).add_region(abutting_region)
-
+        return abutting_region
     def save(self, filename, scalar_field=True, slip_vector=True, surface=True):
         """
         Save the fault to a file

LoopStructural/utils/__init__.py

@@ -23,6 +23,7 @@ from .maths import (
     get_strike_vector,
     get_vectors,
     strikedip2vector,
+    plungeazimuth2vector,
     azimuthplunge2vector,
     normal_vector_to_strike_and_dip,
     rotate,

LoopStructural/utils/_surface.py

@@ -145,7 +145,7 @@ class LoopIsosurfacer:
             values = np.zeros(verts.shape[0]) + isovalue
             # need to add both global and local origin. If the bb is a buffer the local
             # origin may not be 0
-            verts += self.bounding_box.global_origin
+            verts += self.bounding_box.global_origin+self.bounding_box.origin
             surfaces.append(
                 Surface(
                     vertices=verts,

LoopStructural/utils/helper.py

@@ -107,30 +107,7 @@ def get_data_bounding_box(xyz, buffer):
     return bb, region
 
 
-# def azimuthplunge2vector(
-#     plunge: Union[np.ndarray, list], plunge_dir: Union[np.ndarray, list]
-# ) -> np.ndarray:
-#     """Convert plunge and plunge direction to a vector
-
-#     Parameters
-#     ----------
-#     plunge : Union[np.ndarray, list]
-#         array or array like of plunge values
-#     plunge_dir : Union[np.ndarray, list]
-#         array or array like of plunge direction values
-
-#     Returns
-#     -------
-#     np.array
-#         nx3 vector
-#     """
-#     plunge = np.deg2rad(plunge)
-#     plunge_dir = np.deg2rad(plunge_dir)
-#     vec = np.zeros(3)
-#     vec[0] = np.sin(plunge_dir) * np.cos(plunge)
-#     vec[1] = np.cos(plunge_dir) * np.cos(plunge)
-#     vec[2] = -np.sin(plunge)
-#     return vec
+
 
 
 def create_surface(bounding_box, nstep):

LoopStructural/utils/maths.py

@@ -28,20 +28,28 @@ def strikedip2vector(strike: NumericInput, dip: NumericInput) -> np.ndarray:
     vec /= np.linalg.norm(vec, axis=1)[:, None]
     return vec
 
-
 def azimuthplunge2vector(
+        plunge: NumericInput,
+        azimuth: NumericInput,
+        degrees: bool = True,
+) -> np.ndarray:
+    raise DeprecationWarning(
+        "azimuthplunge2vector is deprecated, use plungeazimuth2vector instead"
+    )
+
+def plungeazimuth2vector(
     plunge: NumericInput,
-    plunge_dir: NumericInput,
+    azimuth: NumericInput,
     degrees: bool = True,
 ) -> np.ndarray:
     """Convert plunge and plunge direction to a vector
 
     Parameters
     ----------
+    azimuth : Union[np.ndarray, list]
+        array or array like of plunge direction values
     plunge : Union[np.ndarray, list]
         array or array like of plunge values
-    plunge_dir : Union[np.ndarray, list]
-        array or array like of plunge direction values
 
     Returns
     -------
@@ -52,16 +60,16 @@ def azimuthplunge2vector(
         plunge = np.array([plunge], dtype=float)
     else:
         plunge = np.array(plunge, dtype=float)
-    if isinstance(plunge_dir, numbers.Number):
-        plunge_dir = np.array([plunge_dir], dtype=float)
+    if isinstance(azimuth, numbers.Number):
+        azimuth = np.array([azimuth], dtype=float)
     else:
-        plunge_dir = np.array(plunge_dir, dtype=float)
+        azimuth = np.array(azimuth, dtype=float)
     if degrees:
         plunge = np.deg2rad(plunge)
-        plunge_dir = np.deg2rad(plunge_dir)
+        azimuth = np.deg2rad(azimuth)
     vec = np.zeros((len(plunge), 3))
-    vec[:, 0] = np.sin(plunge_dir) * np.cos(plunge)
-    vec[:, 1] = np.cos(plunge_dir) * np.cos(plunge)
+    vec[:, 0] = np.sin(azimuth) * np.cos(plunge)
+    vec[:, 1] = np.cos(azimuth) * np.cos(plunge)
     vec[:, 2] = -np.sin(plunge)
     return vec
 
@@ -204,19 +212,21 @@ def get_vectors(normal: NumericInput) -> Tuple[np.ndarray, np.ndarray]:
 
 
 def get_strike_vector(strike: NumericInput, degrees: bool = True) -> np.ndarray:
-    """Return the vector aligned with the strike direction
+    """Return strike direction vector(s) from strike angle(s).
 
     Parameters
     ----------
-    strike : np.ndarray
-        strike direction
+    strike : NumericInput
+        Single strike angle or array-like of strike angles, measured clockwise from North.
     degrees : bool, optional
-        whether to return in degrees or radians, by default True
+        Whether the input angles are in degrees. If False, angles are assumed to be in radians.
+        Default is True.
 
     Returns
     -------
     np.ndarray
-        vector aligned with strike direction
+        Array of shape (3, n) where each column is a 3D unit vector (x, y, z) representing
+        the horizontal strike direction. The z-component is always 0.
 
     """
     if isinstance(strike, numbers.Number):
@@ -236,6 +246,21 @@ def get_strike_vector(strike: NumericInput, degrees: bool = True) -> np.ndarray:
 
 
 def get_dip_vector(strike, dip):
+    """Return the dip vector based on strike and dip angles.
+
+    Parameters
+    ----------
+    strike : float
+        Strike angle in degrees, measured clockwise from North.
+    dip : float
+        Dip angle in degrees, measured from the horizontal plane.
+
+    Returns
+    -------
+    np.ndarray
+        Unit vector (length 3) representing the dip direction in 3D space.
+
+    """
     v = np.array(
         [
             -np.cos(np.deg2rad(-strike)) * np.cos(-np.deg2rad(dip)),
@@ -247,6 +272,23 @@ def get_dip_vector(strike, dip):
 
 
 def regular_tetraherdron_for_points(xyz, scale_parameter):
+    """Generate regular tetrahedrons centered at given 3D points.
+
+    Parameters
+    ----------
+    xyz : np.ndarray
+        Array of shape (n, 3) representing the coordinates of n points in 3D space,
+        which will serve as the centers of the generated tetrahedrons.
+    scale_parameter : float
+        Scaling factor controlling the size of the regular tetrahedrons.
+
+    Returns
+    -------
+    np.ndarray
+        Array of shape (n, 4, 3) representing n regular tetrahedrons, where each
+        tetrahedron has 4 vertices in 3D space, positioned relative to the corresponding center point.
+
+    """
     regular_tetrahedron = np.array(
         [
             [np.sqrt(8 / 9), 0, -1 / 3],
@@ -264,8 +306,23 @@ def regular_tetraherdron_for_points(xyz, scale_parameter):
 
 
 def gradient_from_tetrahedron(tetrahedron, value):
-    """
-    Calculate the gradient from a tetrahedron
+    """Compute the gradient of values within tetrahedral elements
+
+    Parameters
+    ----------
+    tetrahedron : np.ndarray
+        Array of shape (n, 4, 3) representing the coordinates of tetrahedral elements,
+        where each tetrahedron is defined by 4 vertices in 3D space.
+    value : np.ndarray
+        Array of shape (n, 4) representing the scalar values at the 4 vertices
+        of each tetrahedron.
+
+    Returns
+    -------
+    np.ndarray
+        Array of shape (n, 3) representing the gradient vector of the scalar field
+        inside each tetrahedral element.
+
     """
     tetrahedron = tetrahedron.reshape(-1, 4, 3)
     m = np.array(

LoopStructural/utils/regions.py

@@ -1,9 +1,20 @@
 import numpy as np
+from abc import ABC, abstractmethod
+from typing import Tuple
 
+class BaseRegion(ABC):
+    @abstractmethod
+    def __init__(self, feature, vector=None, point=None):
+        self.feature = feature
+        self.vector = vector
+        self.point = point
+        self.name = None
+        self.parent = None
 
-class BaseRegion:
-    def __init__(self):
-        self.type = "BaseRegion"
+    @abstractmethod
+    def __call__(self, xyz) -> np.ndarray:
+        """Evaluate the region based on the input coordinates."""
+        pass
 
 
 class RegionEverywhere(BaseRegion):
@@ -23,19 +34,18 @@ class RegionFunction(BaseRegion):
     def __call__(self, xyz):
         return self.function(xyz)
 
-
-class PositiveRegion:
+class BaseSignRegion(BaseRegion):
     """Helper class for evaluating whether you are in the positive  region of a scalar field.
     If its outside of the support it will interpolate the average gradient at a point on the 0 isovalue
     and calculate the distance from this. Alternatively, a point and vector can be used to save computational time
     """
 
     def __init__(self, feature, vector=None, point=None):
-        self.feature = feature
-        self.vector = vector
-        self.point = point
+        super().__init__(feature, vector, point)
+        self.name = 'PositiveRegion'
+        self.parent = feature
 
-    def __call__(self, xyz):
+    def _calculate_value_and_distance(self, xyz)-> Tuple[np.ndarray, np.ndarray]:
         val = self.feature.evaluate_value(xyz)
         # find a point on/near 0 isosurface
         if self.point is None:
@@ -52,51 +62,45 @@ class PositiveRegion:
             average_gradient /= np.linalg.norm(average_gradient)
         else:
             average_gradient = self.vector
-        # distance = ((xyz[:,0] - centre[None,0])*average_gradient[0] +
-        #             (xyz[:,1] - centre[None,1])*average_gradient[1] +
-        #             ( xyz[:,2] - centre[None,2])*average_gradient[2])
-        distance = np.einsum("ij,j->i", centre[None, :] - xyz, average_gradient)
+
+        distance = np.einsum(
+            "ij,j->i", centre[None, :] - xyz, average_gradient.reshape(-1, 3)[0, :]
+        )
+        return val, distance
+
+
+class PositiveRegion(BaseSignRegion):
+    """Helper class for evaluating whether you are in the positive  region of a scalar field.
+    If its outside of the support it will interpolate the average gradient at a point on the 0 isovalue
+    and calculate the distance from this. Alternatively, a point and vector can be used to save computational time
+    """
+
+    def __init__(self, feature, vector=None, point=None):
+        super().__init__(feature, vector, point)
+        self.name = 'PositiveRegion'
+        self.parent = feature
+
+    def __call__(self, xyz) -> np.ndarray:
+        val, distance = self._calculate_value_and_distance(xyz)
         return np.logical_or(
             np.logical_and(~np.isnan(val), val > 0),
             np.logical_and(np.isnan(val), distance > 0),
         )
 
 
-class NegativeRegion:
+class NegativeRegion(BaseSignRegion):
     """Helper class for evaluating whether you are in the positive  region of a scalar field.
     If its outside of the support it will interpolate the average gradient at a point on the 0 isovalue
     and calculate the distance from this. Alternatively, a point and vector can be used to save computational time
     """
 
     def __init__(self, feature, vector=None, point=None):
-        self.feature = feature
-        self.vector = vector
-        self.point = point
+        super().__init__(feature, vector, point)
+        self.name = 'NegativeRegion'
+        self.parent = feature
 
-    def __call__(self, xyz):
-        val = self.feature.evaluate_value(xyz)
-        # find a point on/near 0 isosurface
-        if self.point is None:
-            mask = np.zeros(xyz.shape[0], dtype="bool")
-            mask[:] = val < 0
-            if np.sum(mask) == 0:
-                raise ValueError("Cannot find point on surface")
-            centre = xyz[mask, :][0, :]
-        else:
-            centre = self.point
-        if self.vector is None:
-            average_gradient = self.feature.evaluate_gradient(np.array([centre]))[0]
-            average_gradient[2] = 0
-            average_gradient /= np.linalg.norm(average_gradient)
-        else:
-            average_gradient = self.vector
-        distance = np.einsum("ij,j->i", xyz - centre[None, :], average_gradient)
-        # distance = ((xyz[:,0] - centre[None,0])*average_gradient[0] +
-        #             (xyz[:,1] - centre[None,1])*average_gradient[1] +
-        #             ( xyz[:,2] - centre[None,2])*average_gradient[2])
-        # return np.logical_or(np.logical_and(~np.isnan(val),val
-        #      < 0),
-        #      np.logical_and(np.isnan(val),distance>0))
+    def __call__(self, xyz) -> np.ndarray:
+        val, distance = self._calculate_value_and_distance(xyz)
         return np.logical_or(
             np.logical_and(~np.isnan(val), val < 0),
             np.logical_and(np.isnan(val), distance < 0),

LoopStructural/version.py

@@ -1 +1 @@
-__version__ = "1.6.12"
+__version__ = "1.6.14"

{loopstructural-1.6.12.dist-info → loopstructural-1.6.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: LoopStructural
-Version: 1.6.12
+Version: 1.6.14
 Summary: 3D geological modelling
 Author-email: Lachlan Grose <lachlan.grose@monash.edu>
 License: MIT

{loopstructural-1.6.12.dist-info → loopstructural-1.6.14.dist-info}/RECORD

@@ -1,5 +1,5 @@
 LoopStructural/__init__.py,sha256=fg_Vm1aMDYIf_CffTFopLsTx21u6deLaI7JMVpRYdOI,1378
-LoopStructural/version.py,sha256=1ThuVeMS5KlxvVTyorbbzJi1pftu6GNdFZ7WRJWlGVc,23
+LoopStructural/version.py,sha256=wWsaf5Mb6Lxn5-XiXSzm8MwgO3zmyC4OHxecUfU1mC8,23
 LoopStructural/datasets/__init__.py,sha256=ylb7fzJU_DyQ73LlwQos7VamqkDSGITbbnoKg7KAOmE,677
 LoopStructural/datasets/_base.py,sha256=FB_D5ybBYHoaNbycdkpZcRffzjrrL1xp9X0k-pyob9Y,7618
 LoopStructural/datasets/_example_models.py,sha256=Zg33IeUyh4C-lC0DRMLqCDP2IrX8L-gNV1WxJwBGjzM,113
@@ -29,7 +29,7 @@ LoopStructural/datasets/data/geological_map_data/stratigraphic_order.csv,sha256=
 LoopStructural/datasets/data/geological_map_data/stratigraphic_orientations.csv,sha256=RysyqUAIjY6iIDUfTh11n9QUQWXB_qxKnZeN_DqNzlY,26745
 LoopStructural/datasets/data/geological_map_data/stratigraphic_thickness.csv,sha256=pnSmG-wL8-kxuoHo_pgpJrfTmsZOzc8L0vxpBRh3r8A,355
 LoopStructural/datatypes/__init__.py,sha256=lVg64DnynMm58qvYTjLrcyWH7vk2ngr9JGMo5FaiALI,160
-LoopStructural/datatypes/_bounding_box.py,sha256=gXNKwhM3tCNuw_2PY92EoKJjJTI93fN-QQzlUl5Wjd0,18353
+LoopStructural/datatypes/_bounding_box.py,sha256=lSiROmnaRPANMjMTjy_LoOxF8olfoEkArrQ0Cq4DVmk,18400
 LoopStructural/datatypes/_point.py,sha256=qg3lXUA1rnu1N1cEWG0WvhvJuENfDgpEDIeYldWBaG8,7740
 LoopStructural/datatypes/_structured_grid.py,sha256=mc-UM1Gh_BjHFItuPE4FF5wvGzJnSqF2MTx_xvrwcTk,5088
 LoopStructural/datatypes/_surface.py,sha256=5BpPKVS4X3Kq1k3YxxAofKMgxdXhnOIcDi6NzKn2p2Q,6652
@@ -38,17 +38,17 @@ LoopStructural/export/file_formats.py,sha256=0xKyYSW4Jv_4jsXwusg-WO6PNUhZKd6HdWS
 LoopStructural/export/geoh5.py,sha256=jLFKC5EB0azT3PgJPtkJzi3_CG28RLgP2FuENAGCQMI,4313
 LoopStructural/export/gocad.py,sha256=cQ6v7ZD0CVubt3c2f9EwAYrziu5bEFSWBtx0uade5mg,3370
 LoopStructural/export/omf_wrapper.py,sha256=4vcF4WOQIVEYsWrfATgKCDh8nUybLTbrlXnCxZ_3fkU,3392
-LoopStructural/interpolators/__init__.py,sha256=8uFSHumlOuHzs_3i26DCW1QWO93en_AzAmUEJy5iUXA,3451
+LoopStructural/interpolators/__init__.py,sha256=BcCGY_9Hz_pNKibsdSKNn44U1RCFQ2yNfYCtJOXv8vU,3731
 LoopStructural/interpolators/_api.py,sha256=EC4ogG2uPq-z_pgNGd_eTieTl92eaZ-rjyoFwXiHL_s,7839
 LoopStructural/interpolators/_builders.py,sha256=B49KsxB8RRN6IHDfGT43nXWe_Av1SVVT8vm2Nh1oEiQ,6758
 LoopStructural/interpolators/_discrete_fold_interpolator.py,sha256=eDe0R1lcQ0AuMcv7zlpu5c-soCv7AybIqQAuN2vFE3M,6542
 LoopStructural/interpolators/_discrete_interpolator.py,sha256=i_joZ8HOf_s6Q2L8gHFnhkdtgyED1SjATxRsRd1HxRU,26038
-LoopStructural/interpolators/_finite_difference_interpolator.py,sha256=mZ89FWQZ5RbzhL9UYH8VzWME-28dy331KXtYtpqepHo,18351
+LoopStructural/interpolators/_finite_difference_interpolator.py,sha256=rF9hhIcJTTMmy3IAcv3DPfPpgOMn8Arxj8FtBM7UuvA,18704
 LoopStructural/interpolators/_geological_interpolator.py,sha256=hcQuyv1zYakJ7mcDFlLj-YarjnMQvlP6pVbK1KuxBWs,11195
 LoopStructural/interpolators/_interpolator_builder.py,sha256=Z8bhmco5aSQX19A8It2SB_rG61wnlyshWfp3ivm8rU0,4586
 LoopStructural/interpolators/_interpolator_factory.py,sha256=fbjebXSe5IgTol1tnBlnsw9gD426v-TGkX3gquIg7LI,2782
 LoopStructural/interpolators/_operator.py,sha256=PZOUzq9OMaJdG151dSLIo7AxRuhTj6-zEAzFZo-EOJU,1114
-LoopStructural/interpolators/_p1interpolator.py,sha256=4rjj4iaw2c8hOfBS9u8ycxzijYdmvpeijvhYRwUwZg0,8736
+LoopStructural/interpolators/_p1interpolator.py,sha256=-xTUMDe5slKpgMT-_7RB5voavLs-OmqN2qyd6RKu-gc,8730
 LoopStructural/interpolators/_p2interpolator.py,sha256=UT-As5RNsmOwHOzO_6FiRcAwlNHfi4ILbJw2LGpwKAw,10274
 LoopStructural/interpolators/_surfe_wrapper.py,sha256=Qdz-SuPBVh7gIw4-ZLdDqHkpezmq-Y3IhtRsbW417Xk,6837
 LoopStructural/interpolators/_cython/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -59,7 +59,7 @@ LoopStructural/interpolators/supports/_2d_structured_grid.py,sha256=Pt9fiXyTS-RT
 LoopStructural/interpolators/supports/_2d_structured_tetra.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 LoopStructural/interpolators/supports/_3d_base_structured.py,sha256=PYIkgWCTHk0OHn-T9wpF4ZFYnKyvXNZgUyqO7YcoFjU,16481
 LoopStructural/interpolators/supports/_3d_p2_tetra.py,sha256=CqGVJRUMxbPQZDhhopNt_s9gVhMqh4YbjQyDZonoyxc,11574
-LoopStructural/interpolators/supports/_3d_structured_grid.py,sha256=x9NoZRsl58iowcObavgb0nY_C335BmcIYgec9REsFpU,17366
+LoopStructural/interpolators/supports/_3d_structured_grid.py,sha256=ha32EmyN4EouxEeEPIMiQL3yq8zDHQZRcg2yOkiDPmY,17476
 LoopStructural/interpolators/supports/_3d_structured_tetra.py,sha256=5zUNtvEXDvbCHZCu6Fz9WjGbnrMaq-sYJqNUufyLcq8,26505
 LoopStructural/interpolators/supports/_3d_unstructured_tetra.py,sha256=_peXMTMxctuWNOL74AHxzw0b_1sP5glvbJigIvIkK9I,23867
 LoopStructural/interpolators/supports/__init__.py,sha256=V0JjixoBIUZVAo5MmqARR67xDOoQwnb4G3SXeOMRSyQ,1603
@@ -67,29 +67,29 @@ LoopStructural/interpolators/supports/_aabb.py,sha256=Z-kH_u6c6izak0aHG3Uo14PEKQ
 LoopStructural/interpolators/supports/_base_support.py,sha256=pYzsmeBu4kLaD9ZKsz_dfjVpfuAd00xENqOQC9Xw5QY,2501
 LoopStructural/interpolators/supports/_face_table.py,sha256=Hyj4Io63NkPRN8ab9uDHyec-2Kb8BLY_xBF6STNlvBw,3095
 LoopStructural/interpolators/supports/_support_factory.py,sha256=XNAxnr-JS3KEhdsoZeJ-VaLTJwlvxgBuRMCqYrCDW18,1485
-LoopStructural/modelling/__init__.py,sha256=oW7dz6c8K1A0VcW7-mVcyqcENUrtybCb3eVUNXFvMfA,656
+LoopStructural/modelling/__init__.py,sha256=a-bq2gDhyUlcky5l9kl_IP3ExMdohkgYjQz2V8madQE,902
 LoopStructural/modelling/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 LoopStructural/modelling/core/geological_model.py,sha256=okbEwjL8-wGKeWhvYE-1XSOE2C1nHX7M2AR__42pyAk,66464
 LoopStructural/modelling/features/__init__.py,sha256=Vf-qd5EDBtJ1DpuXXyCcw2-wf6LWPRW5wzxDEO3vOc8,939
 LoopStructural/modelling/features/_analytical_feature.py,sha256=U_g86LgQhYY2359rdsDqpvziYwqrWkc5EdvhJARiUWo,3597
-LoopStructural/modelling/features/_base_geological_feature.py,sha256=985aHq8z5riS7uS04mGBPd8UcPXFv0l_fPAdlE6Ydcc,12175
+LoopStructural/modelling/features/_base_geological_feature.py,sha256=hx1EmDGWCE8YhypWuet6SUfpoGQCSecXj6zTF-CLRRg,12179
 LoopStructural/modelling/features/_cross_product_geological_feature.py,sha256=GIyCHUdE6F-bse2e4puG9V2f7qRtDVfby5PRe2BboD4,3021
 LoopStructural/modelling/features/_geological_feature.py,sha256=u6pbKj9BujX1Ijj5eVdhwGDNjrIAI16CpiAn5n8g3RY,11279
-LoopStructural/modelling/features/_lambda_geological_feature.py,sha256=ieZiiMd8HCeVEIl3B406tsysT7iUEGcEUJXALjhjkeM,2924
+LoopStructural/modelling/features/_lambda_geological_feature.py,sha256=GiB19l6v5WvvR8CitATZvCwaOfRyLuzchoXzpNupsfM,5743
 LoopStructural/modelling/features/_projected_vector_feature.py,sha256=aifVLgn2spmK7GGlO0iHDewf1pFL-QoRzZEePTZwX1s,3017
 LoopStructural/modelling/features/_region.py,sha256=TB4qnoTDQM2VgRjgyODN839fKe3kuRYLllJj0xnDKXo,478
 LoopStructural/modelling/features/_structural_frame.py,sha256=e3QmNHLwuZc5PX3rLafocmBLNTclO90AXB4BRILCFC4,5044
 LoopStructural/modelling/features/_unconformity_feature.py,sha256=2Bx0BI38YLdcNvDWuP9E1pKFN4orEUq9aC8b5xG1UVk,2362
 LoopStructural/modelling/features/builders/__init__.py,sha256=Gqld1C-PcaXfJ8vpkWMDCmehmd3hZNYQk1knPtl59Bk,266
 LoopStructural/modelling/features/builders/_base_builder.py,sha256=N3txGC98V08A8-k2TLdoIWgWLfblZ91kaTvciPq_QVM,3750
-LoopStructural/modelling/features/builders/_fault_builder.py,sha256=3rNfRmMcMCrXMyc_hjltU30wTh041NWD6rShNVI2lCE,25999
+LoopStructural/modelling/features/builders/_fault_builder.py,sha256=CeQnvgDrgMIbyPV6nB0qnpY5PJG1OYTJIukRXv4df1E,25324
 LoopStructural/modelling/features/builders/_folded_feature_builder.py,sha256=1_0BVTzcvmFl6K3_lX-jF0tiMFPmS8j6vPeSLn9MbrE,6607
-LoopStructural/modelling/features/builders/_geological_feature_builder.py,sha256=jn2BiZlzXyWl0_TrsajpFR2wegGOpbuO5yFu2FamuYA,22014
+LoopStructural/modelling/features/builders/_geological_feature_builder.py,sha256=kWj8zjyWBpYoPU9Xih95UWzh0ta_oKga0fO45KnUeR0,22014
 LoopStructural/modelling/features/builders/_structural_frame_builder.py,sha256=ms3-fuFpDEarjzYU5W499TquOIlTwHPUibVxIypfmWY,8019
 LoopStructural/modelling/features/fault/__init__.py,sha256=4u0KfYzmoO-ddFGo9qd9ov0gBoLqBiPAUsaw5zhEOAQ,189
-LoopStructural/modelling/features/fault/_fault_function.py,sha256=Zr54uScKshNBalOFC2cZc1Lxh3dldTPZA-zOdMC0HkM,12578
+LoopStructural/modelling/features/fault/_fault_function.py,sha256=QEPh2jIvgD68hEJc5SM5xuMzZw-93V1me1ZbK9G2TB0,12655
 LoopStructural/modelling/features/fault/_fault_function_feature.py,sha256=4m0jVNx7ewrVI0pECI1wNciv8Cy8FzhZrYDjKJ_e2GU,2558
-LoopStructural/modelling/features/fault/_fault_segment.py,sha256=f3zohJsQ3h5KnlSPYL4eulRZN_Wl6e7IeVASfXE7lWA,18275
+LoopStructural/modelling/features/fault/_fault_segment.py,sha256=dNTCY0ZyC8krrL1suSnhywSE_i5V_VZ4DJ2BieirkhI,18305
 LoopStructural/modelling/features/fold/__init__.py,sha256=pOv20yQvshZozvmO_YFw2E7Prp9DExlm855N-0SnxbQ,175
 LoopStructural/modelling/features/fold/_fold.py,sha256=bPnnLUSiF4uoMRg8aHoOSTPRgaM0JyLoRQPu5_A-J3w,5448
 LoopStructural/modelling/features/fold/_fold_rotation_angle_feature.py,sha256=CXLbFRQ3CrTMAcHmfdbKcmSvvLs9_6TLe0Wqi1pK2tg,892
@@ -112,25 +112,25 @@ LoopStructural/modelling/intrusions/intrusion_builder.py,sha256=1cJjPyRUf3ZDkpwg
 LoopStructural/modelling/intrusions/intrusion_feature.py,sha256=ESjtikHFJQzUnowbYiY7UZ_kYdV2QHobQoRJ2far9Vc,15489
 LoopStructural/modelling/intrusions/intrusion_frame_builder.py,sha256=Q1TPHxREcrO7Rw71nUfACZHfYnISLjqlgkUNTPT324k,40143
 LoopStructural/modelling/intrusions/intrusion_support_functions.py,sha256=wodakheMD62WJyoKnyX8UO-C1pje0I-5kHQEoDqShzo,13951
-LoopStructural/utils/__init__.py,sha256=OJqNSu40SYJeC26IhoBBXDqQOogWjMGA-YokKVRrwMs,924
-LoopStructural/utils/_surface.py,sha256=vTVIkhjYC85CPyirtA4aMPi295fpo40QHzYOqeUS354,6140
+LoopStructural/utils/__init__.py,sha256=t-vJQ0cF2DrjSRtAfuPEL4hc73XJyQno7PucBnd-fu8,950
+LoopStructural/utils/_surface.py,sha256=Eg7x1GGfELl7bPe21_wU96Dn4JWJNReEFxwq-aIV4A4,6165
 LoopStructural/utils/_transformation.py,sha256=peuLPH3BJ5DxnPbOuNKcqK4eXhAXdbT540L1OIsO3v0,5404
 LoopStructural/utils/colours.py,sha256=-KRf1MXKx4L8TXnwyiunmKAX4tfy0qG68fRadyfn_bM,1163
 LoopStructural/utils/config.py,sha256=ITGOtZTo2_QBwXkG_0AFANfE90J9siCXLzxypVmg9QA,414
 LoopStructural/utils/dtm_creator.py,sha256=-yqGG0wyEJfTCCDghz058wull1q3zGFASjeu8oDgYnk,535
 LoopStructural/utils/exceptions.py,sha256=SJboJ7ncMqVX-ib7MMizClwMrFZRHQhjZr2eCnVwnQE,500
 LoopStructural/utils/features.py,sha256=WCatS4lYBrURNvWvWwhOsDVUod9KIPNq3x0OHPbWctU,241
-LoopStructural/utils/helper.py,sha256=An9NuRH16cASUWq2ZakHc1tZt_AvUpgx8tv4cyWZEQk,6581
+LoopStructural/utils/helper.py,sha256=2yt_kdQIhRfik2zSAu4UhPigAM7eif1OB093ddAYtXQ,5857
 LoopStructural/utils/json_encoder.py,sha256=5YNouf1TlhjEqOYgthd07MRXc0JLgxern-nyKSZ__ws,403
 LoopStructural/utils/linalg.py,sha256=tBXyu6NXcG2AcPuzUMnkVI4ncZWtE_MPHGj2PLXRwfY,123
 LoopStructural/utils/logging.py,sha256=dIUWEsS2lT4G1dsf4ZYXknTR7eQkrgvGA4b_E0vMIRU,2402
-LoopStructural/utils/maths.py,sha256=8iqdQdB2-bf14SzIzfFxvjWbzmPknqK9DI7CWEcW6XU,8402
-LoopStructural/utils/regions.py,sha256=LvcOCPudF4u95-GKBOZqXVxOEcR3cOFgFpcs5x43sMk,3914
+LoopStructural/utils/maths.py,sha256=KaLj9RHsxdaSkEHm4t0JEzykhiuETAV14KpjL6lknWY,10374
+LoopStructural/utils/regions.py,sha256=SjCC40GI7_n03G4mlcmvyrBgJFbxnvB3leBzXWco37o,3891
 LoopStructural/utils/typing.py,sha256=29uVSTZdzXXH-jdlaYyBWZ1gQ2-nlZ2-XoVgG_PXNFY,157
 LoopStructural/utils/utils.py,sha256=2Z4zVE6G752-SPmM29zebk82bROJxEwi_YiiJjcVED4,2438
 LoopStructural/visualisation/__init__.py,sha256=5BDgKor8-ae6DrS7IZybJ3Wq_pTnCchxuY4EgzA7v1M,318
-loopstructural-1.6.12.dist-info/licenses/LICENSE,sha256=ZqGeNFOgmYevj7Ld7Q-kR4lAxWXuBRUdUmPC6XM_py8,1071
-loopstructural-1.6.12.dist-info/METADATA,sha256=6zcpH_9vavQAKqe0iOdCrDLy4eFLdFy8m9kK6xTunvs,6454
-loopstructural-1.6.12.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-loopstructural-1.6.12.dist-info/top_level.txt,sha256=QtQErKzYHfg6ddxTQ1NyaTxXBVM6qAqrM_vxEPyXZLg,15
-loopstructural-1.6.12.dist-info/RECORD,,
+loopstructural-1.6.14.dist-info/licenses/LICENSE,sha256=ZqGeNFOgmYevj7Ld7Q-kR4lAxWXuBRUdUmPC6XM_py8,1071
+loopstructural-1.6.14.dist-info/METADATA,sha256=UVSv5pVjzLwcs6Wy5_0FSnis03MWuh9GseEH9dH4X44,6454
+loopstructural-1.6.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+loopstructural-1.6.14.dist-info/top_level.txt,sha256=QtQErKzYHfg6ddxTQ1NyaTxXBVM6qAqrM_vxEPyXZLg,15
+loopstructural-1.6.14.dist-info/RECORD,,

{loopstructural-1.6.12.dist-info → loopstructural-1.6.14.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any