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

LoopStructural/modelling/features/_geological_feature.py

@@ -2,10 +2,11 @@
 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
-from ...interpolators import GeologicalInterpolator, DiscreteInterpolator
+from ...interpolators import GeologicalInterpolator
 import numpy as np
 from typing import Optional, List, Union
 from ...datatypes import ValuePoints, VectorPoints
@@ -131,7 +132,9 @@ class GeologicalFeature(BaseFeature):
             v[nanmask] = v[~nanmask][i]
         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:
         """
 
         Parameters
@@ -147,6 +150,17 @@ class GeologicalFeature(BaseFeature):
         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
 
         self.builder.up_to_date()
 
@@ -156,16 +170,38 @@ class GeologicalFeature(BaseFeature):
         # 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.interpolator.evaluate_value(tetrahedron_faulted.reshape(-1, 3)).reshape(
+                (-1, 4)
+            )
+            v[mask, :] = gradient_from_tetrahedron(tetrahedron[mask, :, :], values[mask])
 
-            if issubclass(type(self.interpolator), DiscreteInterpolator):
-                points = self.interpolator.support.nodes
-            else:
-                raise NotImplementedError(
-                    "Faulted feature gradients are only supported by DiscreteInterpolator at the moment."
-                )
-            points_faulted = self._apply_faults(points)
-            values = self.interpolator.evaluate_value(points_faulted)
-            v[mask, :] = self.interpolator.support.evaluate_gradient(pos[mask, :], values)
             return v
         pos = self._apply_faults(pos)
         if mask.dtype not in [int, bool]:

LoopStructural/modelling/features/_structural_frame.py

@@ -115,7 +115,7 @@ class StructuralFrame(BaseFeature):
         """
         return self.features[i]
 
-    def evaluate_value(self, evaluation_points, ignore_regions=False):
+    def evaluate_value(self, pos, ignore_regions=False):
         """
         Evaluate the value of the structural frame for the points.
         Can optionally only evaluate one coordinate
@@ -129,14 +129,14 @@ class StructuralFrame(BaseFeature):
         -------
 
         """
-        v = np.zeros(evaluation_points.shape)  # create new 3d array of correct length
+        v = np.zeros(pos.shape)  # create new 3d array of correct length
         v[:] = np.nan
-        v[:, 0] = self.features[0].evaluate_value(evaluation_points, ignore_regions=ignore_regions)
-        v[:, 1] = self.features[1].evaluate_value(evaluation_points, ignore_regions=ignore_regions)
-        v[:, 2] = self.features[2].evaluate_value(evaluation_points, ignore_regions=ignore_regions)
+        v[:, 0] = self.features[0].evaluate_value(pos, ignore_regions=ignore_regions)
+        v[:, 1] = self.features[1].evaluate_value(pos, ignore_regions=ignore_regions)
+        v[:, 2] = self.features[2].evaluate_value(pos, ignore_regions=ignore_regions)
         return v
 
-    def evaluate_gradient(self, evaluation_points, i=None, ignore_regions=False):
+    def evaluate_gradient(self, pos, i=None, ignore_regions=False):
         """
         Evaluate the gradient of the structural frame.
         Can optionally only evaluate the ith coordinate
@@ -151,19 +151,11 @@ class StructuralFrame(BaseFeature):
 
         """
         if i is not None:
-            return self.features[i].support.evaluate_gradient(
-                evaluation_points, ignore_regions=ignore_regions
-            )
+            return self.features[i].support.evaluate_gradient(pos, ignore_regions=ignore_regions)
         return (
-            self.features[0].support.evaluate_gradient(
-                evaluation_points, ignore_regions=ignore_regions
-            ),
-            self.features[1].support.evaluate_gradient(
-                evaluation_points, ignore_regions=ignore_regions
-            ),
-            self.features[2].support.evaluate_gradient(
-                evaluation_points, ignore_regions=ignore_regions
-            ),
+            self.features[0].support.evaluate_gradient(pos, ignore_regions=ignore_regions),
+            self.features[1].support.evaluate_gradient(pos, ignore_regions=ignore_regions),
+            self.features[2].support.evaluate_gradient(pos, ignore_regions=ignore_regions),
         )
 
     def get_data(self, value_map: Optional[dict] = None) -> List[Union[ValuePoints, VectorPoints]]:

LoopStructural/modelling/features/_unconformity_feature.py

@@ -19,7 +19,7 @@ class UnconformityFeature(GeologicalFeature):
         # just don't link the regions
         GeologicalFeature.__init__(
             self,
-            name=f"{feature.name}_unconformity",
+            name=f"__{feature.name}_unconformity",
             faults=feature.faults,
             regions=[],  # feature.regions.copy(),  # don't want to share regionsbetween unconformity and # feature.regions,
             builder=feature.builder,
@@ -75,9 +75,9 @@ class UnconformityFeature(GeologicalFeature):
             true if above the unconformity, false if below
         """
         if self.sign:
-            return self.evaluate_value(pos) < self.value
+            return self.evaluate_value(pos) <= self.value
         if not self.sign:
-            return self.evaluate_value(pos) > self.value
+            return self.evaluate_value(pos) >= self.value
 
     def __call__(self, pos) -> np.ndarray:
         return self.evaluate(pos)

LoopStructural/modelling/features/builders/_base_builder.py

@@ -29,6 +29,12 @@ class BaseBuilder:
         self._build_arguments = {}
         self.faults = []
 
+    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__}"
+        )
+        self._up_to_date = False
+
     @property
     def model(self):
         return self._model
@@ -46,6 +52,7 @@ class BaseBuilder:
         # self._build_arguments = {}
         for k, i in build_arguments.items():
             if i != self._build_arguments.get(k, None):
+                logger.info(f"Setting {k} to {i} for {self.name}")
                 self._build_arguments[k] = i
                 ## if build_arguments change then flag to reinterpolate
                 self._up_to_date = False
@@ -107,5 +114,6 @@ class BaseBuilder:
         -------
 
         """
+        logger.info(f'Adding fault {fault.name} to {self.name}')
         self._up_to_date = False
         self.faults.append(fault)

LoopStructural/modelling/features/builders/_folded_feature_builder.py

@@ -1,5 +1,5 @@
 from ....modelling.features.builders import GeologicalFeatureBuilder
-from ....modelling.features.fold import FoldRotationAngle
+from ....modelling.features.fold.fold_function import FoldRotationType, get_fold_rotation_profile
 import numpy as np
 
 from ....utils import getLogger, InterpolatorError
@@ -19,6 +19,8 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
         name="Feature",
         region=None,
         svario=True,
+        axis_profile_type=FoldRotationType.FOURIER_SERIES,
+        limb_profile_type=FoldRotationType.FOURIER_SERIES,
         **kwargs,
     ):
         """Builder for creating a geological feature using fold constraints
@@ -36,6 +38,7 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
         region : _type_, optional
             _description_, by default None
         """
+        # create the feature builder, this intialises the interpolator
         GeologicalFeatureBuilder.__init__(
             self,
             interpolatortype=interpolatortype,
@@ -45,11 +48,27 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
             region=region,
             **kwargs,
         )
+        # link the interpolator to the fold object
         self.interpolator.fold = fold
         self.fold = fold
         self.fold_weights = fold_weights
         self.kwargs = kwargs
         self.svario = svario
+        self.axis_profile_type = axis_profile_type
+        self.limb_profile_type = limb_profile_type
+
+    @property
+    def fold_axis_rotation(self):
+        if self.fold.fold_axis_rotation is None:
+            self.set_fold_axis()
+        return self.fold.fold_axis_rotation
+
+    @property
+    def fold_limb_rotation(self):
+        _axis = self.fold.fold_axis  # get axis to make sure its initialised
+        if self.fold.fold_limb_rotation is None:
+            self.set_fold_limb_rotation()
+        return self.fold.fold_limb_rotation
 
     def set_fold_axis(self):
         """calculates the fold axis/ fold axis rotation and adds this to the fold"""
@@ -67,31 +86,41 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
             if not self.fold.foldframe[1].is_valid():
                 raise InterpolatorError("Fold frame direction coordinate is not valid")
             far, fad = self.fold.foldframe.calculate_fold_axis_rotation(self)
-            fold_axis_rotation = FoldRotationAngle(far, fad, svario=self.svario)
-            a_wl = kwargs.get("axis_wl", None)
+            fold_axis_rotation = get_fold_rotation_profile(self.axis_profile_type, far, fad)
             if "axis_function" in kwargs:
                 # allow predefined function to be used
                 fold_axis_rotation.set_function(kwargs["axis_function"])
             else:
-                fold_axis_rotation.fit_fourier_series(wl=a_wl)
+                fold_axis_rotation.fit(params={'wavelength': kwargs.get("axis_wl", None)})
             self.fold.fold_axis_rotation = fold_axis_rotation
+            fold_axis_rotation.add_observer(self)
 
     def set_fold_limb_rotation(self):
         """Calculates the limb rotation of the fold and adds it to the fold object"""
         kwargs = self.kwargs
+        # need to calculate the fold axis before the fold limb rotation angle
+        if self.fold.fold_axis is None:
+            self.set_fold_axis()
         # give option of passing own fold limb rotation function
-        flr, fld = self.fold.foldframe.calculate_fold_limb_rotation(
-            self, self.fold.get_fold_axis_orientation
-        )
-        fold_limb_rotation = FoldRotationAngle(flr, fld, svario=self.svario)
-        l_wl = kwargs.get("limb_wl", None)
+        flr, fld = self.calculate_fold_limb_rotation_angle()
+
+        fold_limb_rotation = get_fold_rotation_profile(self.limb_profile_type, flr, fld)
         if "limb_function" in kwargs:
             # allow for predefined functions to be used
             fold_limb_rotation.set_function(kwargs["limb_function"])
         else:
-            fold_limb_rotation.fit_fourier_series(wl=l_wl, **kwargs)
+            fold_limb_rotation.fit(params={'wavelength': kwargs.get("limb_wl", None)})
+
         self.fold.fold_limb_rotation = fold_limb_rotation
+        fold_limb_rotation.add_observer(self)
+
+    def calculate_fold_limb_rotation_angle(self):
+        flr, fld = self.fold.foldframe.calculate_fold_limb_rotation(
+            self, self.fold.get_fold_axis_orientation
+        )
+        return flr, fld
 
+    # def
     def build(self, data_region=None, constrained=None, **kwargs):
         """the main function to run the interpolation and set up the parameters
 
@@ -115,15 +144,17 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
         self.add_data_to_interpolator(constrained=constrained)
         if not self.fold.foldframe[0].is_valid():
             raise InterpolatorError("Fold frame main coordinate is not valid")
-        self.set_fold_axis()
-        self.set_fold_limb_rotation()
+        if self.fold.fold_axis is None:
+            self.set_fold_axis()
+        if self.fold.fold_limb_rotation is None:
+            self.set_fold_limb_rotation()
         logger.info("Adding fold to {}".format(self.name))
         self.interpolator.fold = self.fold
         # if we have fold weights use those, otherwise just use default
         # self.interpolator.add_fold_constraints(**self.fold_weights)
-        kwargs["fold_weights"] = self.fold_weights
+        # kwargs["fold_weights"] = self.fold_weights
         if "cgw" not in kwargs:
             # try adding very small cg
             kwargs["cgw"] = 0.0
         # now the fold is set up run the standard interpolation
-        super().build(self, data_region=data_region, **kwargs)
+        return super().build(data_region=data_region, **kwargs)

LoopStructural/modelling/features/builders/_geological_feature_builder.py

@@ -67,7 +67,7 @@ class GeologicalFeatureBuilder(BaseBuilder):
                 "interpolator is {} and must be a GeologicalInterpolator".format(type(interpolator))
             )
         self._interpolator = interpolator
-
+        self._up_to_date = self._interpolator.up_to_date
         header = (
             xyz_names()
             + val_name()
@@ -93,6 +93,13 @@ class GeologicalFeatureBuilder(BaseBuilder):
         self._orthogonal_features = {}
         self._equality_constraints = {}
 
+    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__}"
+        )
+        self._up_to_date = False
+        self._interpolator.up_to_date = False
+
     @property
     def interpolator(self):
         return self._interpolator
@@ -109,6 +116,7 @@ class GeologicalFeatureBuilder(BaseBuilder):
         else:
             self._interpolation_region = RegionEverywhere()
             self._interpolator.set_region(region=self._interpolation_region)
+        logger.info(f'Setting interpolation region {self.name}')
         self._up_to_date = False
 
     def add_data_from_data_frame(self, data_frame, overwrite=False):
@@ -156,6 +164,8 @@ class GeologicalFeatureBuilder(BaseBuilder):
             logger.error("Cannot cast {} as integer, setting step to 1".format(step))
             step = 1
         self._orthogonal_features[feature.name] = [feature, w, region, step, B]
+
+        logger.info(f"Adding orthogonal constraint {feature.name} to {self.name}")
         self._up_to_date = False
 
     def add_data_to_interpolator(self, constrained=False, force_constrained=False, **kwargs):
@@ -315,12 +325,13 @@ class GeologicalFeatureBuilder(BaseBuilder):
                     self.interpolator.support.barycentre[element_idx[::step], :],
                     vector[element_idx[::step], :],
                     w=w,
-                    B=B,
+                    b=B,
                     name=f'{feature.name}_orthogonal',
                 )
 
     def add_equality_constraints(self, feature, region, scalefactor=1.0):
         self._equality_constraints[feature.name] = [feature, region, scalefactor]
+        logger.info(f'Adding equality constraints to {self.name}')
         self._up_to_date = False
 
     def install_equality_constraints(self):
@@ -463,19 +474,22 @@ class GeologicalFeatureBuilder(BaseBuilder):
         Apply the fault to the model grid to ensure that the support
         is big enough to capture the faulted feature.
         """
+        if self.interpolator.support is not None:
 
-        origin = self.interpolator.support.origin
-        maximum = self.interpolator.support.maximum
-        pts = self.model.bounding_box.with_buffer(buffer).regular_grid(local=True)
-        for f in self.faults:
-            pts = f.apply_to_points(pts)
+            origin = self.interpolator.support.origin
+            maximum = self.interpolator.support.maximum
+            pts = self.model.bounding_box.with_buffer(buffer).regular_grid(local=True)
+            for f in self.faults:
+                pts = f.apply_to_points(pts)
 
-        origin[origin > np.min(pts, axis=0)] = np.min(pts, axis=0)[origin > np.min(pts, axis=0)]
-        maximum[maximum < np.max(pts, axis=0)] = np.max(pts, axis=0)[maximum < np.max(pts, axis=0)]
-        self.interpolator.support.origin = origin
-        self.interpolator.support.maximum = maximum
+            origin[origin > np.min(pts, axis=0)] = np.min(pts, axis=0)[origin > np.min(pts, axis=0)]
+            maximum[maximum < np.max(pts, axis=0)] = np.max(pts, axis=0)[
+                maximum < np.max(pts, axis=0)
+            ]
+            self.interpolator.support.origin = origin
+            self.interpolator.support.maximum = maximum
 
-    def build(self, fold=None, fold_weights={}, data_region=None, **kwargs):
+    def build(self, data_region=None, **kwargs):
         """
         Runs the interpolation and builds the geological feature
 
@@ -536,7 +550,9 @@ class GeologicalFeatureBuilder(BaseBuilder):
         logger.info(f'running interpolation for {self.name}')
 
         self.interpolator.solve_system(
-            solver=kwargs.get('solver', None), solver_kwargs=kwargs.get('solver_kwargs', {})
+            solver=kwargs.get('solver', 'cg'),
+            tol=kwargs.get('tol', None),
+            solver_kwargs=kwargs.get('solver_kwargs', {}),
         )
         logger.info(f'Finished building  {self.name}')
         self._up_to_date = True

LoopStructural/modelling/features/builders/_structural_frame_builder.py

@@ -235,3 +235,8 @@ class StructuralFrameBuilder:
     def up_to_date(self, callback=None):
         for i in range(3):
             self.builders[i].up_to_date(callback=callback)
+
+    def set_not_up_to_date(self, caller):
+
+        for i in range(3):
+            self.builders[i].set_not_up_to_date(caller)

LoopStructural/modelling/features/fault/__init__.py

@@ -1,3 +1,3 @@
-from ._fault_function import Composite, CubicFunction, Ones, Zeros
+from ._fault_function import Composite, CubicFunction, Ones, Zeros, FaultDisplacement
 from ._fault_function_feature import FaultDisplacementFeature
 from ._fault_segment import FaultSegment

LoopStructural/modelling/features/fault/_fault_function.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod, ABCMeta
-from typing import Optional
+from typing import Optional, List
 import numpy as np
 
 from ....utils import getLogger
@@ -367,6 +367,24 @@ class FaultDisplacement:
         gz = CubicFunction.from_dict(data["gz"])
         return cls(gx=gx, gy=gy, gz=gz)
 
+    def plot(self, range=(-1, 1), axs: Optional[List] = None):
+        try:
+            import matplotlib.pyplot as plt
+
+            if axs is None:
+                fig, ax = plt.subplots(1, 3, figsize=(15, 5))
+            for i, (name, f) in enumerate(zip(["gx", "gy", "gz"], [self.gx, self.gy, self.gz])):
+                x = np.linspace(range[0], range[1], 100)
+                ax[i].plot(x, f(x), label=name)
+                ax[i].set_title(name)
+                ax[i].set_xlabel("Fault frame coordinate")
+                ax[i].set_ylabel("Displacement")
+                ax[i].legend()
+
+        except ImportError:
+            logger.warning("matplotlib not installed, not plotting")
+            return
+
 
 class BaseFault(object):
     """ """

LoopStructural/modelling/features/fault/_fault_segment.py

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

LoopStructural/modelling/features/fold/__init__.py

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

LoopStructural/modelling/features/fold/_fold_rotation_angle_feature.py

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