LoopStructural 1.6.16__py3-none-any.whl → 1.6.18__py3-none-any.whl

LoopStructural/__init__.py

@@ -20,6 +20,7 @@ ch.setLevel(logging.WARNING)
 loggers = {}
 from .modelling.core.geological_model import GeologicalModel
 from .modelling.core.stratigraphic_column import StratigraphicColumn
+from .modelling.core.fault_topology import FaultTopology
 from .interpolators._api import LoopInterpolator
 from .interpolators import InterpolatorBuilder
 from .datatypes import BoundingBox

LoopStructural/interpolators/_geological_interpolator.py

@@ -166,8 +166,7 @@ class GeologicalInterpolator(metaclass=ABCMeta):
         """
         if points.shape[1] == self.dimensions * 2:
             points = np.hstack([points, np.ones((points.shape[0], 1))])
-            logger.warning(f"No weight provided for normal constraints, all weights are set to 1")
-            raise Warning
+            logger.info("No weight provided for normal constraints, all weights are set to 1")
         if points.shape[1] < self.dimensions * 2 + 1:
             raise ValueError("Normal constraints must at least have X,Y,Z,nx,ny,nz")
         self.n_n = points.shape[0]

LoopStructural/modelling/core/fault_topology.py

@@ -0,0 +1,234 @@
+from ..features.fault import FaultSegment
+from ...utils import Observable
+from .stratigraphic_column import StratigraphicColumn
+import enum
+import numpy as np
+class FaultRelationshipType(enum.Enum):
+    ABUTTING = "abutting"
+    FAULTED = "faulted"
+    NONE = "none"
+
+class FaultTopology(Observable['FaultTopology']):
+    """A graph representation of the relationships between faults and the
+     relationship with stratigraphic units.
+    """
+    def __init__(self, stratigraphic_column: 'StratigraphicColumn'):
+        super().__init__()
+        self.faults = []
+        self.stratigraphic_column = stratigraphic_column
+        self.adjacency = {}
+        self.stratigraphy_fault_relationships = {}
+    def add_fault(self, fault: FaultSegment):
+        """
+        Adds a fault to the fault topology.
+        """
+        if not isinstance(fault, str):
+            raise TypeError("Expected a fault name.")
+
+        self.faults.append(fault)
+        self.notify('fault_added', fault=fault)
+
+    def remove_fault(self, fault: str):
+        """
+        Removes a fault from the fault topology.
+        """
+        if fault not in self.faults:
+            raise ValueError(f"Fault {fault} not found in the topology.")
+        
+        self.faults.remove(fault)
+        # Remove any relationships involving this fault
+        self.adjacency = {k: v for k, v in self.adjacency.items() if fault not in k}
+        self.stratigraphy_fault_relationships = {
+            k: v for k, v in self.stratigraphy_fault_relationships.items() if k[1] != fault
+        }
+        self.notify('fault_removed', fault=fault)
+        
+    def add_abutting_relationship(self, fault_name: str, abutting_fault: str):
+        """
+        Adds an abutting relationship between two faults.
+        """
+        if fault_name not in self.faults or abutting_fault not in self.faults:
+            raise ValueError("Both faults must be part of the fault topology.")
+
+        if fault_name not in self.adjacency:
+            self.adjacency[fault_name] = []
+
+        self.adjacency[(fault_name, abutting_fault)] = FaultRelationshipType.ABUTTING
+        self.notify('abutting_relationship_added', {'fault': fault_name, 'abutting_fault': abutting_fault})
+    def add_stratigraphy_fault_relationship(self, unit_name:str, fault_name: str):
+        """
+        Adds a relationship between a stratigraphic unit and a fault.
+        """
+        if fault_name not in self.faults:
+            raise ValueError("Fault must be part of the fault topology.")
+
+        if unit_name is None:
+            raise ValueError(f"No stratigraphic group found for unit name: {unit_name}")
+        self.stratigraphy_fault_relationships[(unit_name,fault_name)] = True
+
+        self.notify('stratigraphy_fault_relationship_added', {'unit': unit_name, 'fault': fault_name})
+    def add_faulted_relationship(self, fault_name: str, faulted_fault_name: str):
+        """
+        Adds a faulted relationship between two faults.
+        """
+        if fault_name not in self.faults or faulted_fault_name not in self.faults:
+            raise ValueError("Both faults must be part of the fault topology.")
+
+        if fault_name not in self.adjacency:
+            self.adjacency[fault_name] = []
+
+        self.adjacency[(fault_name, faulted_fault_name)] = FaultRelationshipType.FAULTED
+        self.notify('faulted_relationship_added', {'fault': fault_name, 'faulted_fault': faulted_fault_name})
+    def remove_fault_relationship(self, fault_name: str, related_fault_name: str):
+        """
+        Removes a relationship between two faults.
+        """
+        if (fault_name, related_fault_name) in self.adjacency:
+            del self.adjacency[(fault_name, related_fault_name)]
+        elif (related_fault_name, fault_name) in self.adjacency:
+            del self.adjacency[(related_fault_name, fault_name)]
+        else:
+            raise ValueError(f"No relationship found between {fault_name} and {related_fault_name}.")
+        self.notify('fault_relationship_removed', {'fault': fault_name, 'related_fault': related_fault_name})
+    def update_fault_relationship(self, fault_name: str, related_fault_name: str, new_relationship_type: FaultRelationshipType):
+        if new_relationship_type == FaultRelationshipType.NONE:
+            self.adjacency.pop((fault_name, related_fault_name), None)
+        else:
+            self.adjacency[(fault_name, related_fault_name)] = new_relationship_type
+        self.notify('fault_relationship_updated', {'fault': fault_name, 'related_fault': related_fault_name, 'new_relationship_type': new_relationship_type})
+    def change_relationship_type(self, fault_name: str, related_fault_name: str, new_relationship_type: FaultRelationshipType):
+        """
+        Changes the relationship type between two faults.
+        """
+        if (fault_name, related_fault_name) in self.adjacency:
+            self.adjacency[(fault_name, related_fault_name)] = new_relationship_type
+
+        else:
+            raise ValueError(f"No relationship found between {fault_name} and {related_fault_name}.")
+        self.notify('relationship_type_changed', {'fault': fault_name, 'related_fault': related_fault_name, 'new_relationship_type': new_relationship_type})
+    def get_fault_relationships(self, fault_name: str):
+        """
+        Returns a list of relationships for a given fault.
+        """
+        relationships = []
+        for (f1, f2), relationship_type in self.adjacency.items():
+            if f1 == fault_name or f2 == fault_name:
+                relationships.append((f1, f2, relationship_type))
+        return relationships
+    def get_fault_relationship(self, fault_name: str, related_fault_name: str):
+        """
+        Returns the relationship type between two faults.
+        """
+        return self.adjacency.get((fault_name, related_fault_name), FaultRelationshipType.NONE)
+    def get_faults(self):
+        """
+        Returns a list of all faults in the topology.
+        """
+        return self.faults
+
+    def get_stratigraphy_fault_relationships(self):
+        """
+        Returns a dictionary of stratigraphic unit to fault relationships.
+        """
+        return self.stratigraphy_fault_relationships
+    def get_fault_stratigraphic_unit_relationships(self):
+        units_group_pairs = self.stratigraphic_column.get_group_unit_pairs() 
+        matrix = np.zeros((len(self.faults), len(units_group_pairs)), dtype=int)
+        for i, fault in enumerate(self.faults):
+            for j, (unit_name, _group) in enumerate(units_group_pairs):
+                if (unit_name, fault) in self.stratigraphy_fault_relationships:
+                    matrix[i, j] = 1
+
+        return matrix
+    def get_fault_stratigraphic_relationship(self, unit_name: str, fault:str) -> bool:
+        """
+        Returns a dictionary of fault to stratigraphic unit relationships.
+        """
+        if unit_name is None:
+            raise ValueError(f"No stratigraphic group found for unit name: {unit_name}")
+        if (unit_name, fault) not in self.stratigraphy_fault_relationships:
+            return False
+        return self.stratigraphy_fault_relationships[(unit_name, fault)]
+
+    def update_fault_stratigraphy_relationship(self, unit_name: str, fault_name: str, flag: bool = True):
+        """
+        Updates the relationship between a stratigraphic unit and a fault.
+        """
+        if not flag:
+            if (unit_name, fault_name) in self.stratigraphy_fault_relationships:
+                del self.stratigraphy_fault_relationships[(unit_name, fault_name)]
+        else:
+            self.stratigraphy_fault_relationships[(unit_name, fault_name)] = flag
+
+        self.notify('stratigraphy_fault_relationship_updated', {'unit': unit_name, 'fault': fault_name})
+
+    def remove_fault_stratigraphy_relationship(self, unit_name: str, fault_name: str):
+        """
+        Removes a relationship between a stratigraphic unit and a fault.
+        """
+        if (unit_name, fault_name) not in self.stratigraphy_fault_relationships:
+            raise ValueError(f"No relationship found between unit {unit_name} and fault {fault_name}.")
+        else:
+            self.stratigraphy_fault_relationships.pop((unit_name, fault_name), None)
+
+        self.notify('stratigraphy_fault_relationship_removed', {'unit': unit_name, 'fault': fault_name})
+    def get_matrix(self):
+        """
+        Returns a matrix representation of the fault relationships.
+        """
+        matrix = np.zeros((len(self.faults), len(self.faults)), dtype=int)
+        for (fault_name, related_fault_name), relationship_type in self.adjacency.items():
+            fault_index = self.faults.index(next(f for f in self.faults if f == fault_name))
+            related_fault_index = self.faults.index(next(f for f in self.faults if f == related_fault_name))
+            if relationship_type == FaultRelationshipType.ABUTTING:
+                matrix[fault_index, related_fault_index] = 1
+            elif relationship_type == FaultRelationshipType.FAULTED:
+                matrix[fault_index, related_fault_index] = 2
+        return matrix
+
+    def to_dict(self):
+        """
+        Returns a dictionary representation of the fault topology.
+        """
+        return {
+            "faults": self.faults,
+            "adjacency": self.adjacency,
+            "stratigraphy_fault_relationships": self.stratigraphy_fault_relationships,
+        }
+
+    def update_from_dict(self, data):
+        """
+        Updates the fault topology from a dictionary representation.
+        """
+        with self.freeze_notifications():
+            self.faults.extend(data.get("faults", []))
+            adjacency = data.get("adjacency", {})
+            stratigraphy_fault_relationships = data.get("stratigraphy_fault_relationships", {})
+            for (fault,abutting_fault) in adjacency.values():
+                if fault not in self.faults:
+                    self.add_fault(fault)
+                if abutting_fault not in self.faults:
+                    self.add_fault(abutting_fault)
+                self.add_abutting_relationship(fault, abutting_fault)
+            for unit_name, fault_names in stratigraphy_fault_relationships.items():
+                for fault_name in fault_names:
+                    if fault_name not in self.faults:
+                        self.add_fault(fault_name)
+                    self.add_stratigraphy_fault_relationship(unit_name, fault_name)
+
+    @classmethod
+    def from_dict(cls, data):
+        """
+        Creates a FaultTopology instance from a dictionary representation.
+        """
+        from .stratigraphic_column import StratigraphicColumn
+        stratigraphic_column = data.get("stratigraphic_column",None)
+        if not isinstance(stratigraphic_column, StratigraphicColumn):
+            if isinstance(stratigraphic_column, dict):
+                stratigraphic_column = StratigraphicColumn.from_dict(stratigraphic_column)
+        elif not isinstance(stratigraphic_column, StratigraphicColumn):
+            raise TypeError("Expected 'stratigraphic_column' to be a StratigraphicColumn instance or dict.")
+
+        topology = cls(stratigraphic_column)
+        topology.update_from_dict(data)
+        return topology

LoopStructural/modelling/core/geological_model.py

@@ -6,7 +6,7 @@ from ...utils import getLogger
 
 import numpy as np
 import pandas as pd
-from typing import List, Optional
+from typing import List, Optional, Union, Dict
 import pathlib
 from ...modelling.features.fault import FaultSegment
 
@@ -123,8 +123,7 @@ class GeologicalModel:
         self.feature_name_index = {}
         self._data = pd.DataFrame()  # None
 
-        self.stratigraphic_column = StratigraphicColumn()
-
+        self._stratigraphic_column = StratigraphicColumn()
 
         self.tol = 1e-10 * np.max(self.bounding_box.maximum - self.bounding_box.origin)
         self._dtm = None
@@ -187,7 +186,6 @@ class GeologicalModel:
         ].astype(float)
         return data
 
-
         if "type" in data:
             logger.warning("'type' is deprecated replace with 'feature_name' \n")
             data.rename(columns={"type": "feature_name"}, inplace=True)
@@ -409,7 +407,6 @@ class GeologicalModel:
         """
         return [f.name for f in self.faults]
 
-
     def to_file(self, file):
         """Save a model to a pickle file requires dill
 
@@ -506,10 +503,34 @@ class GeologicalModel:
         self._data = data.copy()
         # self._data[['X','Y','Z']] = self.bounding_box.project(self._data[['X','Y','Z']].to_numpy())
 
-
     def set_model_data(self, data):
         logger.warning("deprecated method. Model data can now be set using the data attribute")
         self.data = data.copy()
+    @property
+    def stratigraphic_column(self):
+        """Get the stratigraphic column of the model
+
+        Returns
+        -------
+        StratigraphicColumn
+            the stratigraphic column of the model
+        """
+        return self._stratigraphic_column
+    @stratigraphic_column.setter
+    def stratigraphic_column(self, stratigraphic_column: Union[StratigraphicColumn,Dict]):
+        """Set the stratigraphic column of the model
+
+        Parameters
+        ----------
+        stratigraphic_column : StratigraphicColumn
+            the stratigraphic column to set
+        """
+        if isinstance(stratigraphic_column, dict):
+            self.set_stratigraphic_column(stratigraphic_column)
+            return
+        elif not isinstance(stratigraphic_column, StratigraphicColumn):
+            raise ValueError("stratigraphic_column must be a StratigraphicColumn object")
+        self._stratigraphic_column = stratigraphic_column
 
     def set_stratigraphic_column(self, stratigraphic_column, cmap="tab20"):
         """
@@ -539,14 +560,14 @@ class GeologicalModel:
         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()):
             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)},
@@ -557,9 +578,11 @@ 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+1}'] = g
 
     def create_and_add_foliation(
         self,
@@ -1400,7 +1423,6 @@ class GeologicalModel:
 
         return self.bounding_box.reproject(points, inplace=inplace)
 
-
     # TODO move scale to bounding box/transformer
     def scale(self, points: np.ndarray, *, inplace: bool = False) -> np.ndarray:
         """Take points in UTM coordinates and reproject
@@ -1419,7 +1441,6 @@ class GeologicalModel:
         """
         return self.bounding_box.project(np.array(points).astype(float), inplace=inplace)
 
-
     def regular_grid(self, *, nsteps=None, shuffle=True, rescale=False, order="C"):
         """
         Return a regular grid within the model bounding box
@@ -1494,22 +1515,18 @@ class GeologicalModel:
         if self.stratigraphic_column is None:
             logger.warning("No stratigraphic column defined")
             return strat_id
-        for group in reversed(self.stratigraphic_column.keys()):
-            if group == "faults":
-                continue
-            feature_id = self.feature_name_index.get(group, -1)
+        
+        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:
-                feature = self.features[feature_id]
-                vals = feature.evaluate_value(xyz)
-                for series in self.stratigraphic_column[group].values():
-                    strat_id[
-                        np.logical_and(
-                            vals < series.get("max", feature.max()),
-                            vals > series.get("min", feature.min()),
-                        )
-                    ] = series["id"]
+                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
+                    s_id += 1
             if feature_id == -1:
-                logger.error(f"Model does not contain {group}")
+                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:
@@ -1710,16 +1727,8 @@ 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/modelling/core/stratigraphic_column.py

@@ -1,8 +1,7 @@
 import enum
-from typing import Dict
+from typing import Dict, Optional, List, Tuple
 import numpy as np
-from LoopStructural.utils import rng, getLogger
-
+from LoopStructural.utils import rng, getLogger, Observable
 logger = getLogger(__name__)
 logger.info("Imported LoopStructural Stratigraphic Column module")
 class UnconformityType(enum.Enum):
@@ -40,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.
@@ -154,7 +188,7 @@ class StratigraphicGroup:
         self.units = units if units is not None else []
 
 
-class StratigraphicColumn:
+class StratigraphicColumn(Observable['StratigraphicColumn']):
     """
     A class to represent a stratigraphic column, which is a vertical section of the Earth's crust
     showing the sequence of rock layers and their relationships.
@@ -164,20 +198,38 @@ class StratigraphicColumn:
         """
         Initializes the StratigraphicColumn with a name and a list of layers.
         """
-        self.order = [StratigraphicUnit(name='Basement', colour='grey', thickness=np.inf),StratigraphicUnconformity(name='Base Unconformity', unconformity_type=UnconformityType.ERODE)]
+        super().__init__()
+        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 = {}
-
-    def add_unit(self, name,*, colour=None, thickness=None, where='top'):
-        unit = StratigraphicUnit(name=name, colour=colour, thickness=thickness)
+        self.notify('column_cleared')
+    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:
             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):
@@ -195,7 +249,9 @@ class StratigraphicColumn:
         for i, element in enumerate(self.order):
             if element.uuid == uuid:
                 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' ):
@@ -209,6 +265,7 @@ class StratigraphicColumn:
             self.order.insert(0, unconformity)
         else:
             raise ValueError("Invalid 'where' argument. Use 'top' or 'bottom'.")
+        self.notify('unconformity_added', unconformity=unconformity)
         return unconformity
 
     def get_element_by_index(self, index):
@@ -228,6 +285,7 @@ class StratigraphicColumn:
                 return unit
 
         return None
+
     def get_unconformity_by_name(self, name):
         """
         Retrieves an unconformity by its name from the stratigraphic column.
@@ -245,6 +303,15 @@ class 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.
+        """
+        for group in self.get_groups():
+            if any(unit.name == unit_name for unit in group.units):
+                return group
+        return None
     def add_element(self, element):
         """
         Adds a StratigraphicColumnElement to the stratigraphic column.
@@ -287,7 +354,15 @@ class 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 = []
@@ -296,7 +371,18 @@ class 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.
+        """
+        groups = self.get_groups()
+        group_unit_pairs = []
+        for g in groups:
+            for u in g.units:
+                if isinstance(u, StratigraphicUnit):
+                    group_unit_pairs.append((g.name, u.name))
+        return group_unit_pairs
 
     def __getitem__(self, uuid):
         """
@@ -316,6 +402,21 @@ class StratigraphicColumn:
         self.order = [
             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):
         """
@@ -334,6 +435,8 @@ class StratigraphicColumn:
             element.unconformity_type = UnconformityType(
                 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):
         """
@@ -354,14 +457,15 @@ class StratigraphicColumn:
         """
         if not isinstance(data, dict):
             raise TypeError("Data must be a dictionary")
-        self.clear(basement=False)
-        elements_data = data.get("elements", [])
-        for element_data in elements_data:
-            if "unconformity_type" in element_data:
-                element = StratigraphicUnconformity.from_dict(element_data)
-            else:
-                element = StratigraphicUnit.from_dict(element_data)
-            self.add_element(element)
+        with self.freeze_notifications():
+            self.clear(basement=False)
+            elements_data = data.get("elements", [])
+            for element_data in elements_data:
+                if "unconformity_type" in element_data:
+                    element = StratigraphicUnconformity.from_dict(element_data)
+                else:
+                    element = StratigraphicUnit.from_dict(element_data)
+                self.add_element(element)
     @classmethod
     def from_dict(cls, data):
         """

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)):

LoopStructural/utils/__init__.py

@@ -38,3 +38,4 @@ rng = np.random.default_rng()
 
 from ._surface import LoopIsosurfacer, surface_list
 from .colours import random_colour, random_hex_colour
+from .observer import Callback, Disposable, Observable

LoopStructural/utils/_surface.py

@@ -115,12 +115,17 @@ class LoopIsosurfacer:
                 values,
             )
         logger.info(f'Isosurfacing at values: {isovalues}')
+        individual_names = False
         if name is None:
             names = ["surface"] * len(isovalues)
         if isinstance(name, str):
             names = [name] * len(isovalues)
+            if len(isovalues) == 1:
+                individual_names = True
         if isinstance(name, list):
             names = name
+            if len(names) == len(isovalues):
+                individual_names = True
         if colours is None:
             colours = [None] * len(isovalues)
         for name, isovalue, colour in zip(names, isovalues, colours):
@@ -151,7 +156,7 @@ class LoopIsosurfacer:
                     vertices=verts,
                     triangles=faces,
                     normals=normals,
-                    name=f"{name}_{isovalue}",
+                    name=name if individual_names else f"{name}_{isovalue}",
                     values=values,
                     colour=colour,
                 )

LoopStructural/utils/observer.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from contextlib import contextmanager
+from typing import Any, Generic, Protocol, TypeVar, runtime_checkable
+import threading
+import weakref
+
+__all__ = ["Observer", "Observable", "Disposable"]
+
+
+@runtime_checkable
+class Observer(Protocol):
+    """Objects implementing an *update* method can subscribe."""
+
+    def update(self, observable: "Observable", event: str, *args: Any, **kwargs: Any) -> None:
+        """Receive a notification."""
+
+
+Callback = Callable[["Observable", str, Any], None]
+T = TypeVar("T", bound="Observable")
+
+
+class Disposable:
+    """A small helper that detaches an observer when disposed."""
+
+    __slots__ = ("_detach",)
+
+    def __init__(self, detach: Callable[[], None]):
+        self._detach = detach
+
+    def dispose(self) -> None:  
+        """Detach the associated observer immediately."""
+
+        self._detach()
+
+    # Allow use as a context‑manager for temporary subscriptions
+    def __enter__(self) -> "Disposable":
+        return self
+
+    def __exit__(self, exc_type, exc, tb):  
+        self.dispose()
+        return False  # do not swallow exceptions
+
+
+class Observable(Generic[T]):
+    """Base‑class that provides Observer pattern plumbing."""
+
+    #: Internal storage: mapping *event* → WeakSet[Callback]
+    _observers: dict[str, weakref.WeakSet[Callback]]
+    _any_observers: weakref.WeakSet[Callback]
+    
+    def __init__(self) -> None:
+        self._lock = threading.RLock()
+        self._observers = {}
+        self._any_observers = weakref.WeakSet()
+        self._frozen = 0
+        self._pending: list[tuple[str, tuple[Any, ...], dict[str, Any]]] = []
+
+    # ‑‑‑ subscription api --------------------------------------------------
+    def attach(self, listener: Observer | Callback, event: str | None = None) -> Disposable:  
+        """Register *listener* for *event* (all events if *event* is None).
+
+        Returns a :class:`Disposable` so the caller can easily detach again.
+        """
+        callback: Callback = (
+            listener.update  # type: ignore[attr‑defined]
+            if isinstance(listener, Observer)  # type: ignore[misc]
+            else listener  # already a callable
+        )
+
+        with self._lock:
+            if event is None:
+                self._any_observers.add(callback)
+            else:
+                self._observers.setdefault(event, weakref.WeakSet()).add(callback)
+
+        return Disposable(lambda: self.detach(listener, event))
+
+    def detach(self, listener: Observer | Callback, event: str | None = None) -> None:  
+        """Unregister a previously attached *listener*."""
+
+        callback: Callback = (
+            listener.update  # type: ignore[attr‑defined]
+            if isinstance(listener, Observer)  # type: ignore[misc]
+            else listener
+        )
+
+        with self._lock:
+            if event is None:
+                self._any_observers.discard(callback)
+                for s in self._observers.values():
+                    s.discard(callback)
+            else:
+                self._observers.get(event, weakref.WeakSet()).discard(callback)
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state.pop('_lock', None)  # RLock cannot be pickled
+        state.pop('_observers', None)  # WeakSet cannot be pickled
+        state.pop('_any_observers', None)
+        return state
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        self._lock = threading.RLock()
+        self._observers = {}
+        self._any_observers = weakref.WeakSet()
+        self._frozen = 0
+    # ‑‑‑ notification api --------------------------------------------------
+    def notify(self: T, event: str, *args: Any, **kwargs: Any) -> None:  
+        """Notify observers that *event* happened."""
+
+        with self._lock:
+            if self._frozen:
+                # defer until freeze_notifications() exits
+                self._pending.append((event, args, kwargs))
+                return
+
+            observers = list(self._any_observers)
+            observers.extend(self._observers.get(event, ()))
+
+        # Call outside lock — prevent deadlocks if observers trigger other
+        # notifications.
+        for cb in observers:
+            try:
+                cb(self, event, *args, **kwargs)
+            except Exception:  # pragma: no cover
+                # Optionally log; never allow an observer error to break flow.
+                import logging
+
+                logging.getLogger(__name__).exception(
+                    "Unhandled error in observer %s for event %s", cb, event
+                )
+
+    # ‑‑‑ batching ----------------------------------------------------------
+    @contextmanager
+    def freeze_notifications(self):  
+        """Context manager that batches notifications until exit."""
+
+        with self._lock:
+            self._frozen += 1
+        try:
+            yield self
+        finally:
+            with self._lock:
+                self._frozen -= 1
+                if self._frozen == 0 and self._pending:
+                    pending = self._pending[:]
+                    self._pending.clear()
+            for event, args, kw in pending:  # type: ignore[has‑type]
+                self.notify(event, *args, **kw)

LoopStructural/version.py

@@ -1 +1 @@
-__version__ = "1.6.16"
+__version__ = "1.6.18"

{loopstructural-1.6.16.dist-info → loopstructural-1.6.18.dist-info}/METADATA

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

{loopstructural-1.6.16.dist-info → loopstructural-1.6.18.dist-info}/RECORD

@@ -1,5 +1,5 @@
-LoopStructural/__init__.py,sha256=3yLT09qS3rOrQtyxsECOTh98B3sKv2IrE_DIfTSu930,2022
-LoopStructural/version.py,sha256=DGM49nQ783oxeemzhU9PZifWC3GA5fiS9MnhU4zNfso,23
+LoopStructural/__init__.py,sha256=ZS5J2TI2OuhRE0o3EXmPbbjrvh1-Vy9RFwL7Hc1YBow,2079
+LoopStructural/version.py,sha256=4Zzb1p1N54zNXVm2h5jVUlkFjge9TszzpDGANK9ZNPM,23
 LoopStructural/datasets/__init__.py,sha256=ylb7fzJU_DyQ73LlwQos7VamqkDSGITbbnoKg7KAOmE,677
 LoopStructural/datasets/_base.py,sha256=FB_D5ybBYHoaNbycdkpZcRffzjrrL1xp9X0k-pyob9Y,7618
 LoopStructural/datasets/_example_models.py,sha256=Zg33IeUyh4C-lC0DRMLqCDP2IrX8L-gNV1WxJwBGjzM,113
@@ -45,7 +45,7 @@ LoopStructural/interpolators/_constant_norm.py,sha256=gGaDGDoEzfnL4b6386YwInCxIA
 LoopStructural/interpolators/_discrete_fold_interpolator.py,sha256=eDe0R1lcQ0AuMcv7zlpu5c-soCv7AybIqQAuN2vFE3M,6542
 LoopStructural/interpolators/_discrete_interpolator.py,sha256=bPGJ1CrvLmz3m86JkXAiw7WbfbGEeGXR5cklDX54PQU,26083
 LoopStructural/interpolators/_finite_difference_interpolator.py,sha256=qc7zpqJka16I7yv-GigjQxF0hWRRHyWpHm8dHersy_8,18712
-LoopStructural/interpolators/_geological_interpolator.py,sha256=hdi8mFwHp4G3Tv3lXDvQey8QrRIHuk3KRbJcKtBh918,11460
+LoopStructural/interpolators/_geological_interpolator.py,sha256=74tQUImZ9axkXUrWygl6vqspY3bsoHf_d3twVB30rho,11430
 LoopStructural/interpolators/_interpolator_builder.py,sha256=Z8bhmco5aSQX19A8It2SB_rG61wnlyshWfp3ivm8rU0,4586
 LoopStructural/interpolators/_interpolator_factory.py,sha256=fbjebXSe5IgTol1tnBlnsw9gD426v-TGkX3gquIg7LI,2782
 LoopStructural/interpolators/_interpolatortype.py,sha256=q8U9JGyFpO2FBA9XsMI5ojv3TV1LYqyvYHzLAbHcj9A,593
@@ -71,8 +71,9 @@ LoopStructural/interpolators/supports/_face_table.py,sha256=Hyj4Io63NkPRN8ab9uDH
 LoopStructural/interpolators/supports/_support_factory.py,sha256=XNAxnr-JS3KEhdsoZeJ-VaLTJwlvxgBuRMCqYrCDW18,1485
 LoopStructural/modelling/__init__.py,sha256=a-bq2gDhyUlcky5l9kl_IP3ExMdohkgYjQz2V8madQE,902
 LoopStructural/modelling/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-LoopStructural/modelling/core/geological_model.py,sha256=asAyjVkO-uILX8QQgM8oqdkBQQfCjFDpuXyy2wn8lwc,65150
-LoopStructural/modelling/core/stratigraphic_column.py,sha256=ZHquRb6S97KwB8K8pqEGRSDah0-FjU2uOqdor8NMuY4,16828
+LoopStructural/modelling/core/fault_topology.py,sha256=bChp5dnfc-4GJRENWxB14mEW_13uBMh5ZYRKbLdjweE,11195
+LoopStructural/modelling/core/geological_model.py,sha256=f6bkpXdKxr72OozUb1vdoosLcjzMIht8VNgNlONluVA,65570
+LoopStructural/modelling/core/stratigraphic_column.py,sha256=fmT51wInY3kei7Ya01cd5P5hcnhY5TkLBLJJwkUd_lE,20807
 LoopStructural/modelling/features/__init__.py,sha256=Vf-qd5EDBtJ1DpuXXyCcw2-wf6LWPRW5wzxDEO3vOc8,939
 LoopStructural/modelling/features/_analytical_feature.py,sha256=U_g86LgQhYY2359rdsDqpvziYwqrWkc5EdvhJARiUWo,3597
 LoopStructural/modelling/features/_base_geological_feature.py,sha256=kGyrbb8nNzfi-M8WSrVMEQYKtxThdcBxaji5HKXtAqw,13483
@@ -97,7 +98,7 @@ LoopStructural/modelling/features/fold/__init__.py,sha256=pOv20yQvshZozvmO_YFw2E
 LoopStructural/modelling/features/fold/_fold.py,sha256=bPnnLUSiF4uoMRg8aHoOSTPRgaM0JyLoRQPu5_A-J3w,5448
 LoopStructural/modelling/features/fold/_fold_rotation_angle_feature.py,sha256=CXLbFRQ3CrTMAcHmfdbKcmSvvLs9_6TLe0Wqi1pK2tg,892
 LoopStructural/modelling/features/fold/_foldframe.py,sha256=Rgf5aofN0OVDTZ2pzqLzAGlJUO2rnNm3aFvLSnH77yo,7669
-LoopStructural/modelling/features/fold/_svariogram.py,sha256=uzGaKZ5HGh8xZcsGGg68GUKVjkd5udLy7-4lh0NQc2Y,7765
+LoopStructural/modelling/features/fold/_svariogram.py,sha256=uLeBWZahEmystf8mpPJH_zKxp7hPyPJh0H5ROZO0pZs,7933
 LoopStructural/modelling/features/fold/fold_function/__init__.py,sha256=VqMjabsBd5GnPnDMXeKwXqtd0te2iXnvHxpf6jCC9YU,830
 LoopStructural/modelling/features/fold/fold_function/_base_fold_rotation_angle.py,sha256=5Bu_5xjyu4KL7thZ4fsh938Ep3Oyh5TL7_rfz_13Qng,8047
 LoopStructural/modelling/features/fold/fold_function/_fourier_series_fold_rotation_angle.py,sha256=Cjb6Pt6cdRoH3WGqFyJ2rHxnMe6SKvzRayA6hTuwZA8,4069
@@ -115,8 +116,8 @@ LoopStructural/modelling/intrusions/intrusion_builder.py,sha256=PtNLDreUZTGodMwt
 LoopStructural/modelling/intrusions/intrusion_feature.py,sha256=ESjtikHFJQzUnowbYiY7UZ_kYdV2QHobQoRJ2far9Vc,15489
 LoopStructural/modelling/intrusions/intrusion_frame_builder.py,sha256=YEJv2GURAL8bW6J1KscM69ZVx9yoKVQKF_gXbjB513I,40150
 LoopStructural/modelling/intrusions/intrusion_support_functions.py,sha256=wodakheMD62WJyoKnyX8UO-C1pje0I-5kHQEoDqShzo,13951
-LoopStructural/utils/__init__.py,sha256=t-vJQ0cF2DrjSRtAfuPEL4hc73XJyQno7PucBnd-fu8,950
-LoopStructural/utils/_surface.py,sha256=Eg7x1GGfELl7bPe21_wU96Dn4JWJNReEFxwq-aIV4A4,6165
+LoopStructural/utils/__init__.py,sha256=n-3PGnV-KEy4LOJkHZ6nlnoDyKDlfG6rJhXM0OgFYm0,1004
+LoopStructural/utils/_surface.py,sha256=M0ZYujrqu-pWz-Y8iAhZsgoDxvI5YZG4GyhtBHdbCfk,6389
 LoopStructural/utils/_transformation.py,sha256=peuLPH3BJ5DxnPbOuNKcqK4eXhAXdbT540L1OIsO3v0,5404
 LoopStructural/utils/colours.py,sha256=-KRf1MXKx4L8TXnwyiunmKAX4tfy0qG68fRadyfn_bM,1163
 LoopStructural/utils/config.py,sha256=ITGOtZTo2_QBwXkG_0AFANfE90J9siCXLzxypVmg9QA,414
@@ -128,12 +129,13 @@ LoopStructural/utils/json_encoder.py,sha256=5YNouf1TlhjEqOYgthd07MRXc0JLgxern-ny
 LoopStructural/utils/linalg.py,sha256=tBXyu6NXcG2AcPuzUMnkVI4ncZWtE_MPHGj2PLXRwfY,123
 LoopStructural/utils/logging.py,sha256=dIUWEsS2lT4G1dsf4ZYXknTR7eQkrgvGA4b_E0vMIRU,2402
 LoopStructural/utils/maths.py,sha256=KaLj9RHsxdaSkEHm4t0JEzykhiuETAV14KpjL6lknWY,10374
+LoopStructural/utils/observer.py,sha256=etHF2zhDWbrKAaIKAktdVLosD696o_B0P9rH3G5IzV0,5305
 LoopStructural/utils/regions.py,sha256=SjCC40GI7_n03G4mlcmvyrBgJFbxnvB3leBzXWco37o,3891
 LoopStructural/utils/typing.py,sha256=29uVSTZdzXXH-jdlaYyBWZ1gQ2-nlZ2-XoVgG_PXNFY,157
 LoopStructural/utils/utils.py,sha256=2Z4zVE6G752-SPmM29zebk82bROJxEwi_YiiJjcVED4,2438
 LoopStructural/visualisation/__init__.py,sha256=5BDgKor8-ae6DrS7IZybJ3Wq_pTnCchxuY4EgzA7v1M,318
-loopstructural-1.6.16.dist-info/licenses/LICENSE,sha256=ZqGeNFOgmYevj7Ld7Q-kR4lAxWXuBRUdUmPC6XM_py8,1071
-loopstructural-1.6.16.dist-info/METADATA,sha256=uvSdqdLD2MRCeE972hyitE5L5UfIne1o5uVRXzIPIPU,6453
-loopstructural-1.6.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-loopstructural-1.6.16.dist-info/top_level.txt,sha256=QtQErKzYHfg6ddxTQ1NyaTxXBVM6qAqrM_vxEPyXZLg,15
-loopstructural-1.6.16.dist-info/RECORD,,
+loopstructural-1.6.18.dist-info/licenses/LICENSE,sha256=ZqGeNFOgmYevj7Ld7Q-kR4lAxWXuBRUdUmPC6XM_py8,1071
+loopstructural-1.6.18.dist-info/METADATA,sha256=Ps1KAvAFlPgR11P0nbTfYrMlcPS6bX3OewD1UKRXEnU,6453
+loopstructural-1.6.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+loopstructural-1.6.18.dist-info/top_level.txt,sha256=QtQErKzYHfg6ddxTQ1NyaTxXBVM6qAqrM_vxEPyXZLg,15
+loopstructural-1.6.18.dist-info/RECORD,,