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

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")
 
@@ -282,6 +286,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 +394,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))

LoopStructural/modelling/features/fold/_foldframe.py

@@ -100,8 +100,8 @@ class FoldFrame(StructuralFrame):
         # self.features[0].faults_enabled = False
         # self.features[1].faults_enabled = False
 
-        gpoints = feature_builder.interpolator.get_gradient_constraints()[:, :6]
-        npoints = feature_builder.interpolator.get_norm_constraints()[:, :6]
+        gpoints = feature_builder.get_gradient_constraints()[:, :6]
+        npoints = feature_builder.get_norm_constraints()[:, :6]
         points = []
         if gpoints.shape[0] > 0:
             points.append(gpoints)
@@ -173,8 +173,8 @@ class FoldFrame(StructuralFrame):
 
         """
         self.features[0].faults_enabled = False
-        gpoints = feature_builder.interpolator.get_gradient_constraints()[:, :6]
-        npoints = feature_builder.interpolator.get_norm_constraints()[:, :6]
+        gpoints = feature_builder.get_gradient_constraints()[:, :6]
+        npoints = feature_builder.get_norm_constraints()[:, :6]
         points = []
         if gpoints.shape[0] > 0:
             points.append(gpoints)

LoopStructural/modelling/features/fold/_svariogram.py

@@ -1,11 +1,11 @@
 import numpy as np
-
+from typing import List, Tuple, Optional
 from ....utils import getLogger
 
 logger = getLogger(__name__)
 
 
-def find_peaks_and_troughs(x, y):
+def find_peaks_and_troughs(x: np.ndarray, y: np.ndarray) -> Tuple[List, List]:
     """
 
     Parameters
@@ -24,7 +24,7 @@ def find_peaks_and_troughs(x, y):
     finding the change in derivative
     """
     if len(x) != len(y):
-        return False
+        raise ValueError("Cannot guess wavelength, x and y must be the same length")
     pairsx = []
     pairsy = []
     # #TODO numpyize
@@ -51,55 +51,46 @@ class SVariogram:
     The SVariogram is an experimental semi-variogram.
     """
 
-    def __init__(self, xdata, ydata):
-        self.xdata = xdata
-        self.ydata = ydata
+    def __init__(self, xdata: np.ndarray, ydata: np.ndarray):
+        self.xdata = np.asarray(xdata)
+        self.ydata = np.asarray(ydata)
+        mask = np.logical_or(np.isnan(self.xdata), np.isnan(self.ydata))
+        self.xdata = self.xdata[~mask]
+        self.ydata = self.ydata[~mask]
+        ## maybe check that xdata is not too big here, if it is then this should be done
+        ## using another library maybe gstools?
         self.dist = np.abs(self.xdata[:, None] - self.xdata[None, :])
         self.variance_matrix = (self.ydata[:, None] - self.ydata[None, :]) ** 2
         self.lags = None
         self.variogram = None
-        self.wavelength_guess = [None, None]
+        self.wavelength_guesses = []
 
-    def calc_semivariogram(self, lag=None, nlag=None, lags=None):
+    def initialise_lags(self, step: Optional[float] = None, nsteps: Optional[int] = None):
         """
-        Calculate a semi-variogram for the x and y data for this object.
-        You can specify the lags as an array or specify the step size and
-        number of steps.
-        If neither are specified then the lags are created to be the average
-        spacing of the data
+        Initialise the lags for the s-variogram
 
         Parameters
         ----------
-        step:   float
-                lag distance for the s-variogram
-        nstep:  int
-                number of lags for the s-variogram
-        lags:   array
-                num
+        lag: float
+            lag distance for the s-variogram
+        nlag: int
+            number of lags for the s-variogram
 
         Returns
         -------
 
         """
-        logger.info("Calculating S-Variogram")
-        if lag is not None:
-            step = lag
-            logger.info(f"Using lag: {step} kwarg for S-variogram")
-
-        if nlag is not None:
-            nstep = nlag
-            logger.info(f"Using nlag {nstep} kwarg for s-variogram")
 
-            self.lags = np.arange(step / 2.0, nstep * step, step)
-
-        if nlag is None and lag is not None:
-            nstep = int(np.ceil((np.nanmax(self.xdata) - np.nanmin(self.xdata)) / step))
-            logger.info(f"Using lag kwarg but calculating nlag as {nstep} for s-variogram")
+        if nsteps is not None and step is not None:
+            logger.info(f"Using nlag {nsteps} kwarg for s-variogram")
+            logger.info(f"Using lag: {step} kwarg for S-variogram")
+            self.lags = np.arange(step / 2.0, nsteps * step, step)
 
-            self.lags = np.arange(step / 2.0, nstep * step, step)
+        if nsteps is None and step is not None:
+            nsteps = int(np.ceil((np.nanmax(self.xdata) - np.nanmin(self.xdata)) / step))
+            logger.info(f"Using lag kwarg but calculating nlag as {nsteps} for s-variogram")
 
-        if lags is not None:
-            self.lags = lags
+            self.lags = np.arange(step / 2.0, nsteps * step, step)
 
         if self.lags is None:
             # time to guess the step size
@@ -109,15 +100,50 @@ class SVariogram:
 
             step = np.nanmean(np.nanmin(d, axis=1)) * 4.0
             # find number of steps to cover range in data
-            nstep = int(np.ceil((np.nanmax(self.xdata) - np.nanmin(self.xdata)) / step))
-            if nstep > 200:
-                logger.warning(f"Variogram has too many steps: {nstep}, using 200")
-                maximum = step * nstep
+            nsteps = int(np.ceil((np.nanmax(self.xdata) - np.nanmin(self.xdata)) / step))
+            if nsteps > 200:
+                logger.warning(f"Variogram has too many steps: {nsteps}, using 200")
+                maximum = step * nsteps
                 nstep = 200
                 step = maximum / nstep
-            self.lags = np.arange(step / 2.0, nstep * step, step)
+            self.lags = np.arange(step / 2.0, nsteps * step, step)
             logger.info(
-                f"Using average minimum nearest neighbour distance as lag distance size {step} and using {nstep} lags"
+                f"Using average minimum nearest neighbour distance as lag distance size {step} and using {nsteps} lags"
+            )
+
+    def calc_semivariogram(
+        self,
+        step: Optional[float] = None,
+        nsteps: Optional[int] = None,
+        lags: Optional[np.ndarray] = None,
+    ):
+        """
+        Calculate a semi-variogram for the x and y data for this object.
+        You can specify the lags as an array or specify the step size and
+        number of steps.
+        If neither are specified then the lags are created to be the average
+        spacing of the data
+
+        Parameters
+        ----------
+        step:   float
+                lag distance for the s-variogram
+        nstep:  int
+                number of lags for the s-variogram
+        lags:   array
+                num
+
+        Returns
+        -------
+
+        """
+        logger.info("Calculating S-Variogram")
+        if lags is not None:
+            self.lags = lags
+        self.initialise_lags(step, nsteps)
+        if self.lags is None:
+            raise ValueError(
+                "S-Variogram cannot calculate the variogram step size, please specify either step or nsteps"
             )
         tol = self.lags[1] - self.lags[0]
         self.variogram = np.zeros(self.lags.shape)
@@ -133,7 +159,12 @@ class SVariogram:
                 self.variogram[i] = np.mean(self.variance_matrix[logic])
         return self.lags, self.variogram, npairs
 
-    def find_wavelengths(self, **kwargs):
+    def find_wavelengths(
+        self,
+        step: Optional[float] = None,
+        nsteps: Optional[int] = None,
+        lags: Optional[np.ndarray] = None,
+    ) -> List:
         """
         Picks the wavelengths of the fold by finding the maximum and
         minimums of the s-variogram
@@ -145,7 +176,7 @@ class SVariogram:
         ----------
         kwargs : object
         """
-        h, var, npairs = self.calc_semivariogram(**kwargs)
+        h, var, _npairs = self.calc_semivariogram(step=step, nsteps=nsteps, lags=lags)
 
         px, py = find_peaks_and_troughs(h, var)
 
@@ -156,7 +187,8 @@ class SVariogram:
             averagey.append((py[i] + py[i + 1]) / 2.0)
             i += 1  # iterate twice
         # find the extrema of the average curve
-        px2, py2 = find_peaks_and_troughs(averagex, averagey)
+        res = find_peaks_and_troughs(np.array(averagex), np.array(averagey))
+        px2, py2 = res
         wl1 = 0.0
         wl1py = 0.0
         for i in range(len(px)):
@@ -178,11 +210,14 @@ class SVariogram:
                         if wl2 > 0.0 and wl2 > wl1 * 2 and wl1py < py2[i]:
                             break
         if wl1 == 0.0 and wl2 == 0.0:
+            logger.warning(
+                'Could not automatically guess the wavelength, using 2x the range of the data'
+            )
             self.wavelength_guess = [2 * (np.max(self.xdata) - np.min(self.xdata)), 0.0]
             return self.wavelength_guess
         if np.isclose(wl1, 0.0):
             self.wavelength_guess = np.array([wl2 * 2.0, wl1 * 2.0])
-            return self.wavelength_guess
+            return [wl2]
         # wavelength is 2x the peak on the curve
-        self.wavelength_guess = np.array([wl1 * 2.0, wl2 * 2.0])
+        self.wavelength_guess = [wl1 * 2.0, wl2 * 2.0]
         return self.wavelength_guess

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

@@ -0,0 +1,27 @@
+from ._trigo_fold_rotation_angle import TrigoFoldRotationAngleProfile
+from ._fourier_series_fold_rotation_angle import FourierSeriesFoldRotationAngleProfile
+from enum import Enum
+from typing import Optional
+import numpy.typing as npt
+import numpy as np
+
+
+class FoldRotationType(Enum):
+    TRIGONOMETRIC = TrigoFoldRotationAngleProfile
+    FOURIER_SERIES = FourierSeriesFoldRotationAngleProfile
+    # ADDITIONAL = AdditionalFoldRotationAngle
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return self.name
+
+
+def get_fold_rotation_profile(
+    fold_rotation_type,
+    rotation_angle: Optional[npt.NDArray[np.float64]] = None,
+    fold_frame_coordinate: Optional[npt.NDArray[np.float64]] = None,
+    **kwargs,
+):
+    return fold_rotation_type.value(rotation_angle, fold_frame_coordinate, **kwargs)