fix: changing structural frames to have a setup

method rather than a build method. As the building is done
by the Featurebuilders

LoopStructural/modelling/core/geological_model.py

@@ -763,7 +763,7 @@ def create_and_add_fold_frame(self, foldframe_data, tol=None,**kwargs):
         self._add_faults(fold_frame_builder[1])
         self._add_faults(fold_frame_builder[2])
         kwargs['tol'] = tol
-        fold_frame_builder.build_arguments = kwargs
+        fold_frame_builder.setup(**kwargs)
         fold_frame = fold_frame_builder.frame
         # for i in range(3):
         #     self._add_unconformity_above(fold_frame[i])
@@ -876,14 +876,16 @@ def create_and_add_folded_fold_frame(self, fold_frame_data,
             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])
-
+    
         for i in range(3):
             self._add_faults(fold_frame_builder[i])
         # build feature
         kwargs['frame'] = FoldFrame
         kwargs['tol'] = tol
-        fold_frame_builder.build_arguments = kwargs
+        fold_frame_builder.setup(**kwargs)
+        # fold_frame_builder.build_arguments = kwargs
         folded_fold_frame = fold_frame_builder.frame
+        folded_fold_frame.builder = fold_frame_builder
 
         folded_fold_frame.type = 'structuralframe'
         # see if any unconformities are above this feature if so add region
@@ -1237,7 +1239,7 @@ def create_and_add_fault(self,
             fault_frame_builder.add_splay(kwargs['splay'],kwargs['splayregion'])
 
         kwargs['tol'] = tol
-        fault_frame = fault_frame_builder.build(**kwargs)
+        fault_frame = fault_frame_builder.setup(**kwargs)
 
 
         fault = FaultSegment(fault_frame, displacement=displacement_scaled,

LoopStructural/modelling/features/structural_frame_builder.py

@@ -117,7 +117,7 @@ def add_data_from_data_frame(self, data_frame):
             self.builders[i].add_data_from_data_frame(data_frame.loc[data_frame['coord'] == i,:])
 
 
-    def build(self, w1=1., w2=1., w3=1., frame=StructuralFrame, **kwargs):
+    def setup(self, w1=1., w2=1., w3=1., **kwargs):
         """
         Build the structural frame
         Parameters
@@ -133,89 +133,58 @@ def build(self, w1=1., w2=1., w3=1., frame=StructuralFrame, **kwargs):
         -------
 
         """
-        gxxgy = 1
-        gxxgz = 1
-        gyxgz = 1
+        w1 = 1
+        w2 = 1
+        w3 = 1
         step = kwargs.get('step', 10)
         if 'gxxgy' in kwargs:
+            logger.warning('gxxgy depreciated please use w1')
             gxxgy = kwargs['gxxgy']
         if 'gxxgz' in kwargs:
+            logger.warning('gxxgz depreciated please use w2')
             gxxgz = kwargs['gxxgz']
         if 'gyxgz' in kwargs:
+            logger.warning('gyxgz depreciated please use w3')
             gyxgz = kwargs['gyxgz']
 
         # set regularisation so the the main surface (foliation, fault) is smooth
         # and the fields are allowed to vary more
         regularisation = kwargs.pop('regularisation', [1., 1., 1.])
         # initialise features as none then where data exists build
-        gx_feature = None
-        gy_feature = None
-        gz_feature = None
-        fold = None
         if len(self.builders[0].data) > 0:
             logger.info("Building %s coordinate 0"%self.name)
-            gx_feature = self.builders[0].feature
             kwargs['regularisation']=regularisation[0]
             self.builders[0].build_arguments = kwargs
-
-            # remove fold from kwargs
-
             fold = kwargs.pop('fold', None)
-        if gx_feature is None:
-            logger.warning(
-                "Not enough constraints for structural frame coordinate 0, \n"
-                "Add some more and try again.")
+
         # make sure that all of the coordinates are using the same region
-        if gx_feature is not None and gx_feature.interpolator.region_function is not None:
-            self.builders[1].interpolator.set_region(gx_feature.interpolator.region_function)
-            self.builders[2].interpolator.set_region(gx_feature.interpolator.region_function)
-            if 'data_region' in kwargs:
-                kwargs.pop('data_region')
-            if 'region' in kwargs:
-                kwargs.pop('region')
         if len(self.builders[2].data) > 0:
             logger.info("Building %s coordinate 2"%self.name)
-            # if gy_feature is not None:
-            #     self.builders[
-            #     2].interpolator.add_gradient_orthogonal_constraint(
-            #         np.arange(0, self.support.n_elements),
-            #         gy_feature.evaluate_gradient(self.support.barycentre),
-            #         w=gyxgz)
-            if gx_feature is not None and gxxgz>0:
-                self.builders[2].add_orthogonal_feature(gx_feature, gxxgz,step=step)
-            gz_feature = self.builders[2].feature
+            if w2 > 0:
+                self.builders[2].add_orthogonal_feature(self.builders[0].feature, w2,step=step)
             kwargs['regularisation'] = regularisation[2]
             self.builders[2].build_arguments = kwargs
 
         if len(self.builders[1].data) > 0:
             logger.info("Building %s coordinate 1"%self.name)
-            if gx_feature is not None and gxxgy>0:
-                self.builders[1].add_orthogonal_feature(gx_feature, gxxgy,step=step)
-            if gz_feature is not None and gyxgz>0:
-                self.builders[1].add_orthogonal_feature(gz_feature, gyxgz,step=step)
-            gy_feature = self.builders[1].feature
+            if w1 > 0:
+                self.builders[1].add_orthogonal_feature(self.builders[0].feature, w1, step=step)
+            if w3 > 0 and len(self.builders[2].data) > 0:
+                self.builders[1].add_orthogonal_feature(self.builders[2].feature, w2, step=step)
             kwargs['regularisation'] = regularisation[1]
             self.builders[1].build_arguments = kwargs
 
 
-        if gy_feature is None:
-            logger.warning(
-                "Not enough constraints for structural frame coordinate 1, \n"
-                "Add some more and try again.")
-
+
         if len(self.builders[2].data) == 0:
-            if gy_feature is not None:
                 logger.debug(
                     "Creating analytical structural frame coordinate 2")
-                gz_feature = CrossProductGeologicalFeature(self.name + '_2',
-                                                           gy_feature,
-                                                           gx_feature)
-            if gy_feature is None or gx_feature is None:
-                logger.warning(
-                    "Not enough constraints for fold frame coordinate 1, \n"
-                    "Add some more and try again.")
+                c3 = CrossProductGeologicalFeature(self.name + '_2',
+                                                           self._frame[0],
+                                                           self._frame[1])
+                self._frame[2] = c3
+
         # use the frame argument to build a structural frame
-        return frame(self.name, [gx_feature, gy_feature, gz_feature],fold=fold)
     def update(self):
         for i in range(3):
             self.builders[i].update()