LoopStructural 1.6.19__tar.gz → 1.6.21__tar.gz

{loopstructural-1.6.19 → loopstructural-1.6.21}/LoopStructural/interpolators/_p1interpolator.py

@@ -6,8 +6,9 @@ import logging
 
 import numpy as np
 
-from ._discrete_interpolator import DiscreteInterpolator
 
+from ._discrete_interpolator import DiscreteInterpolator
+from . import InterpolatorType
 logger = logging.getLogger(__name__)
 
 
@@ -37,7 +38,7 @@ class P1Interpolator(DiscreteInterpolator):
             "tpw": 1.0,
             "ipw": 1.0,
         }
-
+        self.type = InterpolatorType.PIECEWISE_LINEAR
     def add_gradient_constraints(self, w=1.0):
         pass
 

{loopstructural-1.6.19 → loopstructural-1.6.21}/LoopStructural/interpolators/_p2interpolator.py

@@ -8,6 +8,7 @@ from typing import Optional, Callable
 import numpy as np
 
 from ..interpolators import DiscreteInterpolator
+from . import InterpolatorType
 
 logger = logging.getLogger(__name__)
 
@@ -41,7 +42,7 @@ class P2Interpolator(DiscreteInterpolator):
             "tpw": 1.0,
             "ipw": 1.0,
         }
-
+        self.type = InterpolatorType.PIECEWISE_QUADRATIC
     def setup_interpolator(self, **kwargs):
         """
         Searches through kwargs for any interpolation weights and updates

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

@@ -21,6 +21,7 @@ from ...modelling.features import (
     UnconformityFeature,
     StructuralFrame,
     GeologicalFeature,
+    BaseFeature,
     FeatureType,
 )
 from ...modelling.features.fold import (
@@ -341,7 +342,7 @@ class GeologicalModel:
         feature : GeologicalFeature
             the geological feature to set
         """
-        if not isinstance(feature, GeologicalFeature):
+        if not issubclass(type(feature), BaseFeature):
             raise TypeError("feature must be a GeologicalFeature")
         if feature.name != feature_name:
             raise ValueError("feature name does not match key")
@@ -616,7 +617,7 @@ class GeologicalModel:
         series_surface_name: str,
         *,
         index: Optional[int] = None,
-        series_surface_data: Optional[pd.DataFrame] = None,
+        data: Optional[pd.DataFrame] = None,
         interpolatortype: str = "FDI",
         nelements: int = LoopStructuralConfig.nelements,
         tol=None,
@@ -671,13 +672,13 @@ class GeologicalModel:
             **kwargs,
         )
         # add data
-        if series_surface_data is None:
-            series_surface_data = self.data.loc[self.data["feature_name"] == series_surface_name]
+        if data is None:
+            data = self.data.loc[self.data["feature_name"] == series_surface_name]
 
-        if series_surface_data.shape[0] == 0:
+        if data.shape[0] == 0:
             logger.warning("No data for {series_surface_data}, skipping")
             return
-        series_builder.add_data_from_data_frame(self.prepare_data(series_surface_data))
+        series_builder.add_data_from_data_frame(self.prepare_data(data))
         self._add_faults(series_builder, features=faults)
 
         # build feature
@@ -696,7 +697,7 @@ class GeologicalModel:
         fold_frame_name: str,
         *,
         index: Optional[int] = None,
-        fold_frame_data=None,
+        data=None,
         interpolatortype="FDI",
         nelements=LoopStructuralConfig.nelements,
         tol=None,
@@ -746,12 +747,12 @@ class GeologicalModel:
             **kwargs,
         )
         # add data
-        if fold_frame_data is None:
-            fold_frame_data = self.data.loc[self.data["feature_name"] == fold_frame_name]
-        if fold_frame_data.shape[0] == 0:
+        if data is None:
+            data = self.data.loc[self.data["feature_name"] == fold_frame_name]
+        if data.shape[0] == 0:
             logger.warning(f"No data for {fold_frame_name}, skipping")
             return
-        fold_frame_builder.add_data_from_data_frame(self.prepare_data(fold_frame_data))
+        fold_frame_builder.add_data_from_data_frame(self.prepare_data(data))
         self._add_faults(fold_frame_builder[0])
         self._add_faults(fold_frame_builder[1])
         self._add_faults(fold_frame_builder[2])
@@ -770,7 +771,7 @@ class GeologicalModel:
         foliation_name,
         *,
         index: Optional[int] = None,
-        foliation_data=None,
+        data=None,
         interpolatortype="DFI",
         nelements=LoopStructuralConfig.nelements,
         buffer=0.1,
@@ -816,7 +817,7 @@ class GeologicalModel:
             fold_frame = self.features[-1]
         assert isinstance(fold_frame, FoldFrame), "Please specify a FoldFrame"
 
-        fold = FoldEvent(fold_frame, name=f"Fold_{foliation_data}", invert_norm=invert_fold_norm)
+        fold = FoldEvent(fold_frame, name=f"Fold_{foliation_name}", invert_norm=invert_fold_norm)
 
         if interpolatortype != "DFI":
             logger.warning("Folded foliation only supports DFI interpolator, changing to DFI")
@@ -831,12 +832,12 @@ class GeologicalModel:
             model=self,
             **kwargs,
         )
-        if foliation_data is None:
-            foliation_data = self.data.loc[self.data["feature_name"] == foliation_name]
-        if foliation_data.shape[0] == 0:
+        if data is None:
+            data = self.data.loc[self.data["feature_name"] == foliation_name]
+        if data.shape[0] == 0:
             logger.warning(f"No data for {foliation_name}, skipping")
             return
-        series_builder.add_data_from_data_frame(self.prepare_data(foliation_data))
+        series_builder.add_data_from_data_frame(self.prepare_data(data))
 
         self._add_faults(series_builder)
         # series_builder.add_data_to_interpolator(True)
@@ -847,7 +848,7 @@ class GeologicalModel:
         # series_feature = series_builder.build(**kwargs)
         series_feature = series_builder.feature
         series_builder.update_build_arguments(kwargs)
-        series_feature.type = FeatureType.INTERPOLATED
+        series_feature.type = FeatureType.FOLDED
         series_feature.fold = fold
 
         self._add_feature(series_feature,index)
@@ -858,7 +859,7 @@ class GeologicalModel:
         fold_frame_name: str,
         *,
         index: Optional[int] = None,
-        fold_frame_data: Optional[pd.DataFrame] = None,
+        data: Optional[pd.DataFrame] = None,
         interpolatortype="FDI",
         nelements=LoopStructuralConfig.nelements,
         fold_frame=None,
@@ -913,7 +914,7 @@ class GeologicalModel:
             logger.info("Using last feature as fold frame")
             fold_frame = self.features[-1]
         assert isinstance(fold_frame, FoldFrame), "Please specify a FoldFrame"
-        fold = FoldEvent(fold_frame, name=f"Fold_{fold_frame_data}")
+        fold = FoldEvent(fold_frame, name=f"Fold_{fold_frame_name}")
 
         interpolatortypes = [
             "DFI",
@@ -930,9 +931,9 @@ class GeologicalModel:
             model=self,
             **kwargs,
         )
-        if fold_frame_data is None:
-            fold_frame_data = self.data[self.data["feature_name"] == fold_frame_name]
-        fold_frame_builder.add_data_from_data_frame(self.prepare_data(fold_frame_data))
+        if data is None:
+            data = self.data[self.data["feature_name"] == fold_frame_name]
+        fold_frame_builder.add_data_from_data_frame(self.prepare_data(data))
 
         for i in range(3):
             self._add_faults(fold_frame_builder[i])
@@ -1293,7 +1294,7 @@ class GeologicalModel:
         displacement: float,
         *,
         index: Optional[int] = None,
-        fault_data: Optional[pd.DataFrame] = None,
+        data: Optional[pd.DataFrame] = None,
         interpolatortype="FDI",
         tol=None,
         fault_slip_vector=None,
@@ -1387,9 +1388,9 @@ class GeologicalModel:
             model=self,
             **kwargs,
         )
-        if fault_data is None:
-            fault_data = self.data.loc[self.data["feature_name"] == fault_name]
-        if fault_data.shape[0] == 0:
+        if data is None:
+            data = self.data.loc[self.data["feature_name"] == fault_name]
+        if data.shape[0] == 0:
             logger.warning(f"No data for {fault_name}, skipping")
             return
 
@@ -1405,7 +1406,7 @@ class GeologicalModel:
         if intermediate_axis:
             intermediate_axis = intermediate_axis
         fault_frame_builder.create_data_from_geometry(
-            fault_frame_data=self.prepare_data(fault_data),
+            fault_frame_data=self.prepare_data(data),
             fault_center=fault_center,
             fault_normal_vector=fault_normal_vector,
             fault_slip_vector=fault_slip_vector,

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

@@ -222,8 +222,8 @@ class StratigraphicColumn(Observable['StratigraphicColumn']):
         if basement:
             self.add_basement()
             
-        else:
-            self.order = []
+        
+        self.order = []
         self.group_mapping = {}
         self.notify('column_cleared')
     def add_unit(self, name,*, colour=None, thickness=None, where='top',id=None):
@@ -460,7 +460,7 @@ class StratigraphicColumn(Observable['StratigraphicColumn']):
         with self.freeze_notifications():
             self.clear(basement=False)
             elements_data = data.get("elements", [])
-            for element_data in elements_data:
+            for element_data in reversed(elements_data):
                 if "unconformity_type" in element_data:
                     element = StratigraphicUnconformity.from_dict(element_data)
                 else:

{loopstructural-1.6.19 → loopstructural-1.6.21}/LoopStructural/modelling/features/_base_geological_feature.py

@@ -271,7 +271,7 @@ class BaseFeature(metaclass=ABCMeta):
 
     def surfaces(
         self,
-        value: Union[float, int, List[Union[float, int]]],
+        value: Optional[Union[float, int, List[Union[float, int]]]] = None,
         bounding_box=None,
         name: Optional[Union[List[str], str]] = None,
         colours: Optional[Union[str, np.ndarray]] = None,
@@ -293,6 +293,7 @@ class BaseFeature(metaclass=ABCMeta):
                 raise ValueError("Must specify bounding box")
             bounding_box = self.model.bounding_box
         regions = self.regions
+        
         try:
             self.regions = [
                 r for r in self.regions if r.name != self.name and r.parent.name != self.name

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

@@ -0,0 +1,39 @@
+from LoopStructural.modelling.features.fold import FoldEvent, FoldFrame
+from LoopStructural.modelling.features.builders import FoldedFeatureBuilder, StructuralFrameBuilder
+def add_fold_to_feature(feature, fold_frame,**kwargs):
+    if not isinstance(fold_frame, FoldFrame):
+        raise ValueError("fold_frame must be a FoldFrame instance")
+        
+    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
+
+def convert_feature_to_structural_frame(feature, **kwargs):
+    """
+    Convert a geological feature to a structural frame by adding the feature to the frame
+
+    Parameters
+    ----------
+    feature : GeologicalFeature
+        the geological feature to convert
+    
+    Returns
+    -------
+    StructuralFrame
+        the updated structural frame with the feature added
+    """
+    builder = feature.builder
+
+    new_builder = StructuralFrameBuilder.from_feature_builder(
+        builder,
+        **kwargs
+    )
+    return new_builder.frame
+    

{loopstructural-1.6.19 → loopstructural-1.6.21}/LoopStructural/modelling/features/_structural_frame.py

@@ -134,7 +134,7 @@ class StructuralFrame(BaseFeature):
         v[:, 0] = self.features[0].evaluate_value(pos, ignore_regions=ignore_regions)
         v[:, 1] = self.features[1].evaluate_value(pos, ignore_regions=ignore_regions)
         v[:, 2] = self.features[2].evaluate_value(pos, ignore_regions=ignore_regions)
-        return v
+        return v[:,0]
 
     def evaluate_gradient(self, pos, i=None, ignore_regions=False):
         """
@@ -152,11 +152,7 @@ class StructuralFrame(BaseFeature):
         """
         if i is not None:
             return self.features[i].support.evaluate_gradient(pos, ignore_regions=ignore_regions)
-        return (
-            self.features[0].support.evaluate_gradient(pos, ignore_regions=ignore_regions),
-            self.features[1].support.evaluate_gradient(pos, ignore_regions=ignore_regions),
-            self.features[2].support.evaluate_gradient(pos, ignore_regions=ignore_regions),
-        )
+        return self.features[0].support.evaluate_gradient(pos, ignore_regions=ignore_regions)            
 
     def get_data(self, value_map: Optional[dict] = None) -> List[Union[ValuePoints, VectorPoints]]:
         """Return the data associated with the features in the

{loopstructural-1.6.19 → loopstructural-1.6.21}/LoopStructural/modelling/features/builders/_fault_builder.py

@@ -226,7 +226,7 @@ class FaultBuilder(StructuralFrameBuilder):
                 self.maximum = self.model.bounding_box.maximum
                 return
             major_axis = np.max(distance)
-            logger.warning(f"Fault major axis using map length: {major_axis}")
+            logger.info(f"Fault major axis using map length: {major_axis}")
 
         if minor_axis is None:
             logger.info(f"Fault minor axis not set, using half major axis: {major_axis/2}")

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

@@ -1,5 +1,6 @@
 from ....modelling.features.builders import GeologicalFeatureBuilder
 from ....modelling.features.fold.fold_function import FoldRotationType, get_fold_rotation_profile
+from ....modelling.features import FeatureType
 import numpy as np
 
 from ....utils import getLogger, InterpolatorError
@@ -48,11 +49,13 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
             region=region,
             **kwargs,
         )
+        self._feature.type = FeatureType.FOLDED
         # link the interpolator to the fold object
         self.interpolator.fold = fold
         self.fold = fold
         self.fold_weights = fold_weights
-        self.kwargs = kwargs
+        self.update_build_arguments(kwargs)
+        # self.kwargs = kwargs
         self.svario = svario
         self.axis_profile_type = axis_profile_type
         self.limb_profile_type = limb_profile_type
@@ -87,7 +90,7 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
 
     def set_fold_axis(self):
         """calculates the fold axis/ fold axis rotation and adds this to the fold"""
-        kwargs = self.kwargs
+        kwargs = self.build_arguments
         fold_axis = kwargs.get("fold_axis", None)
         if fold_axis is not None:
             fold_axis = np.array(fold_axis)
@@ -112,7 +115,7 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
 
     def set_fold_limb_rotation(self):
         """Calculates the limb rotation of the fold and adds it to the fold object"""
-        kwargs = self.kwargs
+        kwargs = self.build_arguments
         # need to calculate the fold axis before the fold limb rotation angle
         if self.fold.fold_axis is None:
             self.set_fold_axis()

{loopstructural-1.6.19 → loopstructural-1.6.21}/LoopStructural/modelling/features/builders/_structural_frame_builder.py

@@ -7,6 +7,7 @@ from typing import Union
 from LoopStructural.utils.exceptions import LoopException
 
 import numpy as np
+import copy
 
 from ....utils import getLogger
 from ....datatypes import BoundingBox
@@ -120,6 +121,39 @@ class StructuralFrameBuilder:
             model=self.model,
         )
         self._frame.builder = self
+
+    @classmethod
+    def from_feature_builder(cls, feature_builder, **kwargs):
+        """
+        Create a structural frame builder from an existing feature builder
+
+        Parameters
+        ----------
+        feature_builder - a geological feature builder
+        kwargs
+
+        Returns
+        -------
+
+        """
+        if not isinstance(feature_builder, GeologicalFeatureBuilder):
+            raise LoopException(
+                f"feature_builder is {type(feature_builder)} and must be a GeologicalFeatureBuilder"
+            )
+        if hasattr(feature_builder, 'fold'):
+            logger.warning("feature builder has a fold - using this to create a folded frame")
+            kwargs['fold'] = copy.deepcopy(feature_builder.fold)
+        builder  = cls(
+            interpolatortype=[feature_builder.interpolator.type]*3,
+            bounding_box=feature_builder.model.bounding_box,
+            nelements=[feature_builder.interpolator.n_elements]*3,
+            name=feature_builder.name,
+            model=feature_builder.model,
+            **kwargs
+        )
+        builder.add_data_from_data_frame(feature_builder.data)
+        return builder
+
     @property
     def build_arguments(self):
         return self.builders[0].build_arguments

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

@@ -1,6 +1,5 @@
 """ """
 
-from ._fold import FoldEvent
 from ._svariogram import SVariogram
 from ._fold_rotation_angle_feature import FoldRotationAngleFeature
 from ._foldframe import FoldFrame

{loopstructural-1.6.19 → loopstructural-1.6.21}/LoopStructural/modelling/features/fold/_foldframe.py

@@ -19,7 +19,24 @@ class FoldFrame(StructuralFrame):
         features
         """
         super().__init__(name, features, fold, model)
+    @classmethod
+    def from_structural_frame(cls, frame, fold=None):
+        """
+        Create a FoldFrame from an existing StructuralFrame
+
+        Parameters
+        ----------
+        frame - StructuralFrame
+            the structural frame to convert to a fold frame
+        fold - FoldEvent, optional
+            the fold event to associate with the fold frame
 
+        Returns
+        -------
+        FoldFrame
+            the new fold frame
+        """
+        return cls(frame.name, frame.features, fold, frame.model)
     def calculate_fold_axis_rotation(self, feature_builder, fold_axis=None):
         """
         Calculate the fold axis rotation angle by finding the angle between the

loopstructural-1.6.21/LoopStructural/version.py

@@ -0,0 +1 @@
+__version__ = "1.6.21"

{loopstructural-1.6.19 → loopstructural-1.6.21}/LoopStructural.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: LoopStructural
-Version: 1.6.19
+Version: 1.6.21
 Summary: 3D geological modelling
 Author-email: Lachlan Grose <lachlan.grose@monash.edu>
 License: MIT

{loopstructural-1.6.19 → loopstructural-1.6.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: LoopStructural
-Version: 1.6.19
+Version: 1.6.21
 Summary: 3D geological modelling
 Author-email: Lachlan Grose <lachlan.grose@monash.edu>
 License: MIT

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

@@ -1,13 +0,0 @@
-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.19/LoopStructural/version.py

@@ -1 +0,0 @@
-__version__ = "1.6.19"