fix: refactoring fold profiles to allow for easy user modification of fold geometry

* fix: refactoring fold rotation angle and svariogram

* adding trigo and fourier series fold profile classes
also added a base class to inheret fold profile from

* adding some type hints to svariogram

* get the data from the builder not the interpolator

this means the interpolation isn't required before we can calculate fold profiles

* adding observed update for when fold profile parameters change.

This flags the interpolator/builder as not up to date triggering a reinterpolation

* updating folded feature builder to use the new fold profile classes

* set interpolator as not up to date when builder is not up to date

* adding lambda fold profile, for proving a custom function

* getter/factory for building fold profile object

* linting

* removing old rotation angle

* removing unused/commentred code

* fixing import errors

* fold rotation plotter uses the svario

* catch exception when fold paramters are not able to be updated

* add getters for fold axis/limb profiles for builder

Author: lachlangrose

LoopStructural/modelling/features/builders/_base_builder.py

@@ -29,6 +29,12 @@ def __init__(self, model, name: str = "Feature"):
         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

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 @@ def __init__(
         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 @@ def __init__(
         region : _type_, optional
             _description_, by default None
         """
+        # create the feature builder, this intialises the interpolator
         GeologicalFeatureBuilder.__init__(
             self,
             interpolatortype=interpolatortype,
@@ -45,11 +48,27 @@ def __init__(
             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 @@ def set_fold_axis(self):
             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,8 +144,10 @@ def build(self, data_region=None, constrained=None, **kwargs):
         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

LoopStructural/modelling/features/builders/_geological_feature_builder.py

@@ -67,7 +67,7 @@ def __init__(
                 "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 @@ def __init__(
         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

LoopStructural/modelling/features/builders/_structural_frame_builder.py

@@ -235,3 +235,8 @@ def update(self):
     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/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