fix: transitioning fold frame building into

on demand interpolation

LoopStructural/modelling/core/geological_model.py

@@ -890,67 +890,27 @@ def create_and_add_folded_fold_frame(self, fold_frame_data,
         interpolators = [fold_interpolator, gy_fold_interpolator,
                          frame_interpolator.copy()]
         fold_frame_builder = StructuralFrameBuilder(
-            interpolators=interpolators, name=fold_frame_data, **kwargs)
+            interpolators=interpolators, name=fold_frame_data, fold=fold, **kwargs)
         fold_frame_builder.add_data_from_data_frame(
             self.data[self.data['feature_name'] == fold_frame_data])
 
-        ## add the data to the interpolator for the main foliation
-        fold_frame_builder[0].add_data_to_interpolator(True)
-
-        if "fold_axis" in kwargs:
-            logger.info("Using cylindrical fold axis")
-            fold.fold_axis = kwargs['fold_axis']
-        if "av_fold_axis" in kwargs:
-            logger.info("Using average intersection lineation for \n"
-            "fold axis")
-            _calculate_average_intersection(fold_frame_builder[0], fold_frame,
-                                            fold)
-
-        if fold.fold_axis is None:
-            logger.info("Fitting fold axis rotation angle")
-            far, fad = fold_frame.calculate_fold_axis_rotation(
-                fold_frame_builder[0])
-            fold_axis_rotation = FoldRotationAngle(far, fad)
-            a_wl = kwargs.get("axis_wl", None)
-            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.fold_axis_rotation = fold_axis_rotation
-        # give option of passing own fold limb rotation function
-        flr, fld = fold_frame.calculate_fold_limb_rotation(
-            fold_frame_builder[0])
-        fold_limb_rotation = FoldRotationAngle(flr, fld)
-        l_wl = kwargs.get("limb_wl", None)
-        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)
-        fold.fold_limb_rotation = fold_limb_rotation
-        # fold_limb_fitter = kwargs.get("fold_limb_function",
-        # _interpolate_fold_limb_rotation_angle)
-        # fold_limb_fitter(series_builder, fold_frame, fold, result, **kwargs)
-        kwargs['fold_weights'] = kwargs.get('fold_weights', {})
-
         for i in range(3):
             self._add_faults(fold_frame_builder[i])
         # build feature
-        kwargs['fold'] = fold
-        self._add_faults(fold_frame_builder[0])
-        self._add_faults(fold_frame_builder[1])
-        self._add_faults(fold_frame_builder[2])
-        fold_frame = fold_frame_builder.build(**kwargs, tol=tol,frame=FoldFrame)
-        fold_frame.type = 'structuralframe'
+        kwargs['frame'] = FoldFrame
+        kwargs['tol'] = tol
+        fold_frame_builder.build_arguments = kwargs
+        folded_fold_frame = fold_frame_builder.feature
+
+        folded_fold_frame.type = 'structuralframe'
         # see if any unconformities are above this feature if so add region
         # for i in range(3):
         #     self._add_unconformity_above(fold_frame[i])
 
-        self._add_feature(fold_frame)
+        self._add_feature(folded_fold_frame)
 
 
-        return fold_frame
+        return folded_fold_frame
 
     def _add_faults(self, feature_builder, features=None):
         """Adds all existing faults to a geological feature builder 

LoopStructural/modelling/features/structural_frame_builder.py

@@ -14,6 +14,7 @@
     CrossProductGeologicalFeature
 from LoopStructural.modelling.features import \
     GeologicalFeatureInterpolator
+from LoopStructural.modelling.fold import FoldedFeatureBuilder
 from LoopStructural.modelling.features import StructuralFrame
 
 
@@ -56,8 +57,12 @@ def __init__(self, interpolator=None, interpolators=None, **kwargs):
             else:
                 raise BaseException("Missing interpolator")
         # self.builders
-        self.builders.append(
-            GeologicalFeatureInterpolator(interpolators[0],
+        if 'fold' in kwargs:
+            self.builders.append(FoldedFeatureBuilder(interpolators[0],
+                                          name=self.name + '_0',
+                                          **kwargs))
+        else:
+            self.builders.append(GeologicalFeatureInterpolator(interpolators[0],
                                           name=self.name + '_0',
                                           **kwargs))  # ,region=self.region))
         self.builders.append(
@@ -68,6 +73,10 @@ def __init__(self, interpolator=None, interpolators=None, **kwargs):
             GeologicalFeatureInterpolator(interpolators[2],
                                           name=self.name + '_2',
                                           **kwargs))  # ,region=self.region))
+
+        self._frame = frame(self.name, [gx_feature, gy_feature, gz_feature],fold=fold)
+    @property
+
 
     def __getitem__(self, item):
         return self.builders[item]

LoopStructural/modelling/fold/fold_builder.py

@@ -1,15 +1,20 @@
 from ..features import GeologicalFeatureInterpolator
+from . import FoldRotationAngle
 
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 class FoldedFeatureBuilder(GeologicalFeatureInterpolator):
 
     def __init__(self,interpolator,fold,fold_weights={},name='Feature',region=None,**kwargs):
         GeologicalFeatureInterpolator.__init__(self,interpolator,name=name,region=region,**kwargs)
         self.fold = fold
         self.fold_weights = fold_weights
         self.kwargs = kwargs
-
+        self.svario = True
 
     def set_fold_axis(self):
+        """calculates the fold axis/ fold axis rotation and adds this to the fold 
+        """
         kwargs = self.kwargs
         fold_axis = kwargs.get('fold_axis',None)
         if fold_axis is not None:
@@ -18,11 +23,11 @@ def set_fold_axis(self):
                 self.fold.fold_axis = fold_axis
 
         if "av_fold_axis" in kwargs:
-            _calculate_average_intersection(series_builder, fold_frame, fold)
+            _calculate_average_intersection(series_builder, fold.foldframe, fold)
         if self.fold.fold_axis is None:
-            far, fad = self.fold.fold_frame.calculate_fold_axis_rotation(
+            far, fad = self.fold.foldframe.calculate_fold_axis_rotation(
                 self)
-            fold_axis_rotation = FoldRotationAngle(far, fad,svario=svario)
+            fold_axis_rotation = FoldRotationAngle(far, fad,svario=self.svario)
             a_wl = kwargs.get("axis_wl", None)
             if 'axis_function' in kwargs:
                 # allow predefined function to be used
@@ -32,18 +37,20 @@ def set_fold_axis(self):
             self.fold.fold_axis_rotation = fold_axis_rotation
 
     def set_fold_limb_rotation(self):
+        """Calculates the limb rotation of the fold and adds it to the fold object
+        """
         kwargs = self.kwargs
         # give option of passing own fold limb rotation function
-        flr, fld = self.fold.fold_frame.calculate_fold_limb_rotation(
+        flr, fld = self.fold.foldframe.calculate_fold_limb_rotation(
             self, self.fold.get_fold_axis_orientation)
-        fold_limb_rotation = FoldRotationAngle(flr, fld,svario=svario)
+        fold_limb_rotation = FoldRotationAngle(flr, fld,svario=self.svario)
         l_wl = kwargs.get("limb_wl", None)
         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.fold_limb_rotation = fold_limb_rotation
+        self.fold.fold_limb_rotation = fold_limb_rotation
 
     def build(self, data_region=None, **kwargs):
         """[summary]