LoopStructural 1.6.17__tar.gz → 1.6.19__tar.gz

{loopstructural-1.6.17 → loopstructural-1.6.19}/LoopStructural/__init__.py

@@ -7,6 +7,9 @@ LoopStructural
 import logging
 from logging.config import dictConfig
 
+from dataclasses import dataclass
+
+
 __all__ = ["GeologicalModel"]
 import tempfile
 from pathlib import Path
@@ -18,6 +21,14 @@ formatter = logging.Formatter("%(levelname)s: %(asctime)s: %(filename)s:%(lineno
 ch.setFormatter(formatter)
 ch.setLevel(logging.WARNING)
 loggers = {}
+@dataclass
+class LoopStructuralConfig:
+    """
+    Configuration for LoopStructural 
+    """
+   
+    nelements: int = 10_000
+
 from .modelling.core.geological_model import GeologicalModel
 from .modelling.core.stratigraphic_column import StratigraphicColumn
 from .modelling.core.fault_topology import FaultTopology

{loopstructural-1.6.17 → loopstructural-1.6.19}/LoopStructural/modelling/core/geological_model.py

@@ -2,6 +2,7 @@
 Main entry point for creating a geological model
 """
 
+from LoopStructural import LoopStructuralConfig
 from ...utils import getLogger
 
 import numpy as np
@@ -330,7 +331,21 @@ class GeologicalModel:
             name of the feature to return
         """
         return self.get_feature_by_name(feature_name)
+    def __setitem__(self, feature_name, feature):
+        """Set a feature in the model using feature_name_index
 
+        Parameters
+        ----------
+        feature_name : string
+            name of the feature to set
+        feature : GeologicalFeature
+            the geological feature to set
+        """
+        if not isinstance(feature, GeologicalFeature):
+            raise TypeError("feature must be a GeologicalFeature")
+        if feature.name != feature_name:
+            raise ValueError("feature name does not match key")
+        self._add_feature(feature)
     def __contains__(self, feature_name):
         return feature_name in self.feature_name_index
 
@@ -426,7 +441,7 @@ class GeologicalModel:
         except pickle.PicklingError:
             logger.error("Error saving file")
 
-    def _add_feature(self, feature):
+    def _add_feature(self, feature, index: Optional[int] = None):
         """
         Add a feature to the model stack
 
@@ -443,9 +458,18 @@ class GeologicalModel:
             )
             self.features[self.feature_name_index[feature.name]] = feature
         else:
-            self.features.append(feature)
-            self.feature_name_index[feature.name] = len(self.features) - 1
-            logger.info(f"Adding {feature.name} to model at location {len(self.features)}")
+            if index is not None:
+                if index < 0 or index > len(self.features):
+                    raise IndexError(f"Index {index} out of bounds for features list")
+                self.features.insert(index, feature)
+                self.feature_name_index[feature.name] = index
+                logger.info(f"Adding {feature.name} to model at location {index}")
+                for index, feature in enumerate(self.features):
+                    self.feature_name_index[feature.name] = index
+            else:
+                self.features.append(feature)
+                self.feature_name_index[feature.name] = len(self.features) - 1
+                logger.info(f"Adding {feature.name} to model at location {len(self.features)}")
         self._add_domain_fault_above(feature)
         if feature.type == FeatureType.INTERPOLATED:
             self._add_unconformity_above(feature)
@@ -553,21 +577,24 @@ class GeologicalModel:
         }
 
         """
-        self.stratigraphic_column.clear()
+        self.stratigraphic_column.clear(basement=False)
         # if the colour for a unit hasn't been specified we can just sample from
         # a colour map e.g. tab20
         logger.info("Adding stratigraphic column to model")
         DeprecationWarning(
             "set_stratigraphic_column is deprecated, use model.stratigraphic_column.add_units instead"
         )
-        for g in stratigraphic_column.keys():
+        for i, g in enumerate(stratigraphic_column.keys()):
+            if g == 'faults':
+                logger.info('Not adding faults to stratigraphic column')
+                continue
             for u in stratigraphic_column[g].keys():
                 thickness = 0
                 if "min" in stratigraphic_column[g][u] and "max" in stratigraphic_column[g][u]:
                     min_val = stratigraphic_column[g][u]["min"]
                     max_val = stratigraphic_column[g][u].get("max", None)
                     thickness = max_val - min_val if max_val is not None else None
-                logger.warning(
+                logger.info(
                     f"""
                                model.stratigraphic_column.add_unit({u},
                                colour={stratigraphic_column[g][u].get("colour", None)},
@@ -578,17 +605,20 @@ class GeologicalModel:
                     colour=stratigraphic_column[g][u].get("colour", None),
                     thickness=thickness,
                 )
+
             self.stratigraphic_column.add_unconformity(
                 name=''.join([g, 'unconformity']),
             )
+            self.stratigraphic_column.group_mapping[f'Group_{i}'] = g
 
     def create_and_add_foliation(
         self,
         series_surface_name: str,
         *,
-        series_surface_data: pd.DataFrame = None,
+        index: Optional[int] = None,
+        series_surface_data: Optional[pd.DataFrame] = None,
         interpolatortype: str = "FDI",
-        nelements: int = 1000,
+        nelements: int = LoopStructuralConfig.nelements,
         tol=None,
         faults=None,
         **kwargs,
@@ -658,16 +688,17 @@ class GeologicalModel:
         # could just pass a regular grid of points - mask by any above unconformities??
 
         series_feature.type = FeatureType.INTERPOLATED
-        self._add_feature(series_feature)
+        self._add_feature(series_feature,index=index)
         return series_feature
 
     def create_and_add_fold_frame(
         self,
         fold_frame_name: str,
         *,
+        index: Optional[int] = None,
         fold_frame_data=None,
         interpolatortype="FDI",
-        nelements=1000,
+        nelements=LoopStructuralConfig.nelements,
         tol=None,
         buffer=0.1,
         **kwargs,
@@ -730,7 +761,7 @@ class GeologicalModel:
 
         fold_frame.type = FeatureType.STRUCTURALFRAME
         fold_frame.builder = fold_frame_builder
-        self._add_feature(fold_frame)
+        self._add_feature(fold_frame,index=index)
 
         return fold_frame
 
@@ -738,9 +769,10 @@ class GeologicalModel:
         self,
         foliation_name,
         *,
+        index: Optional[int] = None,
         foliation_data=None,
         interpolatortype="DFI",
-        nelements=10000,
+        nelements=LoopStructuralConfig.nelements,
         buffer=0.1,
         fold_frame=None,
         svario=True,
@@ -818,16 +850,17 @@ class GeologicalModel:
         series_feature.type = FeatureType.INTERPOLATED
         series_feature.fold = fold
 
-        self._add_feature(series_feature)
+        self._add_feature(series_feature,index)
         return series_feature
 
     def create_and_add_folded_fold_frame(
         self,
         fold_frame_name: str,
         *,
+        index: Optional[int] = None,
         fold_frame_data: Optional[pd.DataFrame] = None,
         interpolatortype="FDI",
-        nelements=10000,
+        nelements=LoopStructuralConfig.nelements,
         fold_frame=None,
         tol=None,
         **kwargs,
@@ -913,7 +946,7 @@ class GeologicalModel:
 
         folded_fold_frame.type = FeatureType.STRUCTURALFRAME
 
-        self._add_feature(folded_fold_frame)
+        self._add_feature(folded_fold_frame,index=index)
 
         return folded_fold_frame
 
@@ -976,14 +1009,14 @@ class GeologicalModel:
 
         interpolatortype = kwargs.get("interpolatortype", "PLI")
         # buffer = kwargs.get("buffer", 0.1)
-        nelements = kwargs.get("nelements", 1e2)
+        nelements = kwargs.get("nelements", LoopStructuralConfig.nelements)
 
         weights = [gxxgz, gxxgy, gyxgz]
 
         intrusion_frame_builder = IntrusionFrameBuilder(
             interpolatortype=interpolatortype,
             bounding_box=self.bounding_box.with_buffer(kwargs.get("buffer", 0.1)),
-            nelements=kwargs.get("nelements", 1e2),
+            nelements=kwargs.get("nelements", LoopStructuralConfig.nelements),
             name=intrusion_frame_name,
             model=self,
             **kwargs,
@@ -1126,7 +1159,7 @@ class GeologicalModel:
                 feature.add_region(f)
                 break
 
-    def add_unconformity(self, feature: GeologicalFeature, value: float) -> UnconformityFeature:
+    def add_unconformity(self, feature: GeologicalFeature, value: float, index: Optional[int] = None) -> UnconformityFeature:
         """
         Use an existing feature to add an unconformity to the model.
 
@@ -1163,10 +1196,10 @@ class GeologicalModel:
             else:
                 f.add_region(uc_feature)
         # now add the unconformity to the feature list
-        self._add_feature(uc_feature)
+        self._add_feature(uc_feature,index=index)
         return uc_feature
 
-    def add_onlap_unconformity(self, feature: GeologicalFeature, value: float) -> GeologicalFeature:
+    def add_onlap_unconformity(self, feature: GeologicalFeature, value: float, index: Optional[int] = None) -> GeologicalFeature:
         """
         Use an existing feature to add an unconformity to the model.
 
@@ -1194,12 +1227,18 @@ class GeologicalModel:
                 continue
             if f != feature:
                 f.add_region(uc_feature)
-        self._add_feature(uc_feature.inverse())
+        self._add_feature(uc_feature.inverse(),index=index)
 
         return uc_feature
 
     def create_and_add_domain_fault(
-        self, fault_surface_data, *, nelements=10000, interpolatortype="FDI", **kwargs
+        self,
+        fault_surface_data,
+        *,
+        nelements=LoopStructuralConfig.nelements,
+        interpolatortype="FDI",
+        index: Optional[int] = None,
+        **kwargs,
     ):
         """
         Parameters
@@ -1240,7 +1279,7 @@ class GeologicalModel:
         domain_fault = domain_fault_feature_builder.feature
         domain_fault_feature_builder.update_build_arguments(kwargs)
         domain_fault.type = FeatureType.DOMAINFAULT
-        self._add_feature(domain_fault)
+        self._add_feature(domain_fault, index=index)
         self._add_domain_fault_below(domain_fault)
 
         domain_fault_uc = UnconformityFeature(domain_fault, 0)
@@ -1253,6 +1292,7 @@ class GeologicalModel:
         fault_name: str,
         displacement: float,
         *,
+        index: Optional[int] = None,
         fault_data: Optional[pd.DataFrame] = None,
         interpolatortype="FDI",
         tol=None,
@@ -1342,7 +1382,7 @@ class GeologicalModel:
         fault_frame_builder = FaultBuilder(
             interpolatortype,
             bounding_box=self.bounding_box,
-            nelements=kwargs.pop("nelements", 1e4),
+            nelements=kwargs.pop("nelements", LoopStructuralConfig.nelements),
             name=fault_name,
             model=self,
             **kwargs,
@@ -1397,7 +1437,7 @@ class GeologicalModel:
                 break
         if displacement == 0:
             fault.type = FeatureType.INACTIVEFAULT
-        self._add_feature(fault)
+        self._add_feature(fault,index=index)
 
         return fault
 
@@ -1513,18 +1553,18 @@ class GeologicalModel:
         if self.stratigraphic_column is None:
             logger.warning("No stratigraphic column defined")
             return strat_id
-        
+
         s_id = 0
         for g in reversed(self.stratigraphic_column.get_groups()):
             feature_id = self.feature_name_index.get(g.name, -1)
             if feature_id >= 0:
                 vals = self.features[feature_id].evaluate_value(xyz)
                 for u in g.units:
-                    strat_id[np.logical_and(vals < u.max, vals > u.min)] = s_id 
+                    strat_id[np.logical_and(vals < u.max(), vals > u.min())] = s_id
                     s_id += 1
             if feature_id == -1:
                 logger.error(f"Model does not contain {g.name}")
-        
+
         return strat_id
 
     def evaluate_model_gradient(self, points: np.ndarray, *, scale: bool = True) -> np.ndarray:
@@ -1546,16 +1586,13 @@ class GeologicalModel:
         if scale:
             xyz = self.scale(xyz, inplace=False)
         grad = np.zeros(xyz.shape)
-        for group in reversed(self.stratigraphic_column.keys()):
-            if group == "faults":
-                continue
-            feature_id = self.feature_name_index.get(group, -1)
+        for g in reversed(self.stratigraphic_column.get_groups()):
+            feature_id = self.feature_name_index.get(g.name, -1)
             if feature_id >= 0:
-                feature = self.features[feature_id]
-                gradt = feature.evaluate_gradient(xyz)
+                gradt = self.features[feature_id].evaluate_gradient(xyz)
                 grad[~np.isnan(gradt).any(axis=1)] = gradt[~np.isnan(gradt).any(axis=1)]
             if feature_id == -1:
-                logger.error(f"Model does not contain {group}")
+                logger.error(f"Model does not contain {g.name}")
 
         return grad
 
@@ -1725,16 +1762,7 @@ class GeologicalModel:
         ids : list
             list of unique stratigraphic ids, featurename, unit name and min and max scalar values
         """
-        ids = []
-        if self.stratigraphic_column is None:
-            logger.warning('No stratigraphic column defined')
-            return ids
-        for group in self.stratigraphic_column.keys():
-            if group == "faults":
-                continue
-            for name, series in self.stratigraphic_column[group].items():
-                ids.append([series["id"], group, name, series['min'], series['max']])
-        return ids
+        return self.stratigraphic_column.get_stratigraphic_ids()
 
     def get_fault_surfaces(self, faults: List[str] = []):
         surfaces = []

{loopstructural-1.6.17 → loopstructural-1.6.19}/LoopStructural/modelling/core/stratigraphic_column.py

@@ -1,7 +1,7 @@
 import enum
 from typing import Dict, Optional, List, Tuple
 import numpy as np
-from LoopStructural.utils import rng, getLogger, Observable
+from LoopStructural.utils import rng, getLogger, Observable, random_colour
 logger = getLogger(__name__)
 logger.info("Imported LoopStructural Stratigraphic Column module")
 class UnconformityType(enum.Enum):
@@ -39,24 +39,59 @@ class StratigraphicColumnElement:
         self.uuid = uuid
 
 
-class StratigraphicUnit(StratigraphicColumnElement):
+class StratigraphicUnit(StratigraphicColumnElement, Observable['StratigraphicUnit']):
     """
     A class to represent a stratigraphic unit.
     """
 
-    def __init__(self, *, uuid=None, name=None, colour=None, thickness=None, data=None):
+    def __init__(self, *, uuid=None, name=None, colour=None, thickness=None, data=None, id=None):
         """
         Initializes the StratigraphicUnit with a name and an optional description.
         """
-        super().__init__(uuid)
+        StratigraphicColumnElement.__init__(self, uuid)
+        Observable.__init__(self)
         self.name = name
         if colour is None:
             colour = rng.random(3)
         self.colour = colour
-        self.thickness = thickness
+        self._thickness = thickness
         self.data = data
         self.element_type = StratigraphicColumnElementType.UNIT
-
+        self.id = id
+        self.min_value = None  # Minimum scalar field value for the unit
+        self.max_value = None  # Maximum scalar field value for the unit
+    @property
+    def id(self):
+        return self._id
+    @property
+    def thickness(self):
+        return self._thickness
+    @thickness.setter
+    def thickness(self, value):
+        """
+        Sets the thickness of the unit.
+        """
+        self._thickness = value
+        self.notify('unit/thickness_updated', unit=self)
+    @id.setter
+    def id(self, value):
+        """
+        Sets the ID of the unit.
+        """
+        if not isinstance(value, int):
+            raise TypeError("ID must be an integer")
+        self._id = value
+        self.notify('unit/id_updated', unit=self)
+    def min(self):
+        """
+        Returns the minimum value of the unit.
+        """
+        return self.min_value if self.min_value is not None else 0
+    def max(self):
+        """
+        Returns the maximum value of the unit.
+        """
+        return self.max_value if self.max_value is not None else np.inf
     def to_dict(self):
         """
         Converts the stratigraphic unit to a dictionary representation.
@@ -64,7 +99,7 @@ class StratigraphicUnit(StratigraphicColumnElement):
         colour = self.colour
         if isinstance(colour, np.ndarray):
             colour = colour.astype(float).tolist()
-        return {"name": self.name, "colour": colour, "thickness": self.thickness, 'uuid': self.uuid}
+        return {"name": self.name, "colour": colour, "thickness": self.thickness, 'uuid': self.uuid, 'id': self.id}
 
     @classmethod
     def from_dict(cls, data):
@@ -77,7 +112,7 @@ class StratigraphicUnit(StratigraphicColumnElement):
         colour = data.get("colour")
         thickness = data.get("thickness", None)
         uuid = data.get("uuid", None)
-        return cls(uuid=uuid, name=name, colour=colour, thickness=thickness)
+        return cls(uuid=uuid, name=name, colour=colour, thickness=thickness, id=data.get("id", None))
 
     def __str__(self):
         """
@@ -164,20 +199,37 @@ class StratigraphicColumn(Observable['StratigraphicColumn']):
         Initializes the StratigraphicColumn with a name and a list of layers.
         """
         super().__init__()
-        self.order = [StratigraphicUnit(name='Basement', colour='grey', thickness=np.inf),StratigraphicUnconformity(name='Base Unconformity', unconformity_type=UnconformityType.ERODE)]
+        self.order = []
+        self.add_basement()
         self.group_mapping = {}
-    def clear(self,basement=True):
+
+    def get_new_id(self):
+        """
+        Generates a new unique ID for a stratigraphic unit.
+        """
+        if not self.order:
+            return 0
+        return max([u.id for u in self.order if isinstance(u, StratigraphicUnit)], default=0) + 1
+    def add_basement(self):
+        self.add_unit(name='Basement', colour='grey', thickness=np.inf)
+        self.add_unconformity(
+            name='Base Unconformity', unconformity_type=UnconformityType.ERODE
+        )
+    def clear(self, basement=True):
         """
         Clears the stratigraphic column, removing all elements.
         """
         if basement:
-            self.order = [StratigraphicUnit(name='Basement', colour='grey', thickness=np.inf),StratigraphicUnconformity(name='Base Unconformity', unconformity_type=UnconformityType.ERODE)]
+            self.add_basement()
+            
         else:
             self.order = []
         self.group_mapping = {}
         self.notify('column_cleared')
-    def add_unit(self, name,*, colour=None, thickness=None, where='top'):
-        unit = StratigraphicUnit(name=name, colour=colour, thickness=thickness)
+    def add_unit(self, name,*, colour=None, thickness=None, where='top',id=None):
+        if id is None:
+            id = self.get_new_id()
+        unit = StratigraphicUnit(name=name, colour=colour, thickness=thickness, id=id)
 
         if where == 'top':
             self.order.append(unit)
@@ -185,7 +237,9 @@ class StratigraphicColumn(Observable['StratigraphicColumn']):
             self.order.insert(0, unit)
         else:
             raise ValueError("Invalid 'where' argument. Use 'top' or 'bottom'.")
+        unit.attach(self.update_unit_values,'unit/*')
         self.notify('unit_added', unit=unit)
+        self.update_unit_values()  # Update min and max values after adding a unit
         return unit
 
     def remove_unit(self, uuid):
@@ -197,7 +251,7 @@ class StratigraphicColumn(Observable['StratigraphicColumn']):
                 del self.order[i]
                 self.notify('unit_removed', uuid=uuid)
                 return True
-        
+
         return False
 
     def add_unconformity(self, name, *, unconformity_type=UnconformityType.ERODE, where='top' ):
@@ -249,7 +303,7 @@ class StratigraphicColumn(Observable['StratigraphicColumn']):
             if element.uuid == uuid:
                 return element
         raise KeyError(f"No element found with uuid: {uuid}")
-    
+
     def get_group_for_unit_name(self, unit_name:str) -> Optional[StratigraphicGroup]:
         """
         Retrieves the group for a given unit name.
@@ -300,7 +354,15 @@ class StratigraphicColumn(Observable['StratigraphicColumn']):
         if group:
             groups.append(group)
         return groups
+    def get_stratigraphic_ids(self) -> List[List[str]]:
+        ids = []
+        for group in self.get_groups():
+            if group == "faults":
+                continue
 
+            for unit in group.units:
+                ids.append([unit.id, group, unit.name, unit.min(), unit.max()])
+        return ids
     def get_unitname_groups(self):
         groups = self.get_groups()
         groups_list = []
@@ -309,7 +371,7 @@ class StratigraphicColumn(Observable['StratigraphicColumn']):
             group = [u.name for u in g.units if isinstance(u, StratigraphicUnit)]
             groups_list.append(group)
         return groups_list
-    
+
     def get_group_unit_pairs(self) -> List[Tuple[str,str]]:
         """
         Returns a list of tuples containing group names and unit names.
@@ -341,6 +403,20 @@ class StratigraphicColumn(Observable['StratigraphicColumn']):
             self.__getitem__(uuid) for uuid in new_order if self.__getitem__(uuid) is not None
         ]
         self.notify('order_updated', new_order=self.order)
+        self.update_unit_values()  # Update min and max values after updating the order
+    def update_unit_values(self, *, observable: Optional["Observable"] = None, event: Optional[str]= None):
+        """
+        Updates the min and max values for each unit based on their position in the column.
+        """
+        # If the event is not 'unit/*', skip the update
+        if event is not None and event != 'unit/*':
+            return
+        cumulative_thickness = 0
+        for element in self.order:
+            if isinstance(element, StratigraphicUnit):
+                element.min_value = cumulative_thickness
+                element.max_value = cumulative_thickness + (element.thickness or 0)
+                cumulative_thickness = element.max_value
 
     def update_element(self, unit_data: Dict):
         """
@@ -360,6 +436,7 @@ class StratigraphicColumn(Observable['StratigraphicColumn']):
                 unit_data.get('unconformity_type', element.unconformity_type.value)
             )
         self.notify('element_updated', element=element)
+        self.update_unit_values()  # Update min and max values after updating an element
 
     def __str__(self):
         """
@@ -498,3 +575,29 @@ class StratigraphicColumn(Observable['StratigraphicColumn']):
         ax.axis("off")
 
         return fig
+    
+    def cmap(self):
+        try:
+            import matplotlib.colors as colors
+
+            colours = []
+            boundaries = []
+            data = []
+            for group in self.get_groups():
+                for u in group.units:
+                    colour = u.colour
+                    if not isinstance(colour, str):
+                        try:
+                            u.colour = colors.to_hex(colour)
+                        except ValueError:
+                            logger.warning(f"Cannot convert colour {colour} to hex, using default")
+                            u.colour = random_colour()
+                    data.append((u.id, u.colour))
+                    colours.append(u.colour)
+                    boundaries.append(u.id)
+             # print(u,v)
+            cmap = colors.ListedColormap(colours)
+        except ImportError:
+            logger.warning("Cannot use predefined colours as I can't import matplotlib")
+            cmap = "tab20"
+        return cmap

loopstructural-1.6.19/LoopStructural/modelling/features/_feature_converters.py

@@ -0,0 +1,13 @@
+from LoopStructural.modelling.features.fold import FoldEvent
+from LoopStructural.modelling.features.builders import FoldedFeatureBuilder
+def add_fold_to_feature(feature, fold_frame,**kwargs):
+    fold = FoldEvent(fold_frame, name=f"Fold_{feature.name}", invert_norm=kwargs.get('invert_fold_norm', False))
+
+    builder = FoldedFeatureBuilder.from_feature_builder(
+        feature.builder,
+        fold, 
+        **kwargs
+    )
+    feature = builder.feature
+    feature.fold = fold
+    return feature

{loopstructural-1.6.17 → loopstructural-1.6.19}/LoopStructural/modelling/features/_geological_feature.py

@@ -77,7 +77,7 @@ class GeologicalFeature(BaseFeature):
         print(self.name, json)
         json["interpolator"] = self.interpolator.to_json()
         return json
-
+    
     def is_valid(self):
         return self.interpolator.valid
 

{loopstructural-1.6.17 → loopstructural-1.6.19}/LoopStructural/modelling/features/builders/_folded_feature_builder.py

@@ -56,7 +56,22 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
         self.svario = svario
         self.axis_profile_type = axis_profile_type
         self.limb_profile_type = limb_profile_type
-
+    @classmethod
+    def from_feature_builder(cls, feature_builder, fold, **kwargs):
+        """Create a FoldedFeatureBuilder from an existing feature builder"""
+        if not isinstance(feature_builder, GeologicalFeatureBuilder):
+            logger.error(f'Feature builder is {type(feature_builder)} not GeologicalFeatureBuilder')
+            raise TypeError("feature_builder must be an instance of GeologicalFeatureBuilder")
+        builder = cls(
+            interpolatortype='DFI',
+            bounding_box=feature_builder.model.bounding_box,
+            fold=fold,
+            nelements=feature_builder.interpolator.n_elements,
+            name=feature_builder.name,
+            **kwargs
+        )
+        builder.data = feature_builder.data
+        return builder
     @property
     def fold_axis_rotation(self):
         if self.fold.fold_axis_rotation is None:

{loopstructural-1.6.17 → loopstructural-1.6.19}/LoopStructural/modelling/features/builders/_geological_feature_builder.py

@@ -168,6 +168,9 @@ class GeologicalFeatureBuilder(BaseBuilder):
         -------
 
         """
+        logger.info('Adding data to interpolator for {}'.format(self.name))
+        logger.info(f"Data shape: {self.data.shape}")
+        logger.info(f'Constrained: {constrained}, force_constrained: {force_constrained}')
         if self.data_added:
             logger.info("Data already added to interpolator")
             return

{loopstructural-1.6.17 → loopstructural-1.6.19}/LoopStructural/modelling/features/fold/__init__.py

@@ -4,3 +4,4 @@ from ._fold import FoldEvent
 from ._svariogram import SVariogram
 from ._fold_rotation_angle_feature import FoldRotationAngleFeature
 from ._foldframe import FoldFrame
+from ._fold import FoldEvent

{loopstructural-1.6.17 → loopstructural-1.6.19}/LoopStructural/modelling/features/fold/_svariogram.py

@@ -189,6 +189,9 @@ class SVariogram:
         # find the extrema of the average curve
         res = find_peaks_and_troughs(np.array(averagex), np.array(averagey))
         px2, py2 = res
+        logger.info(f"Found {len(px2)} peaks and troughs in the s-variogram")
+        for i in range(len(px2)):
+            logger.info(f"Peak {i}: {px2[i]} {py2[i]}")
         wl1 = 0.0
         wl1py = 0.0
         for i in range(len(px)):