LoopStructural 1.6.16__tar.gz → 1.6.18__tar.gz

{loopstructural-1.6.16 → loopstructural-1.6.18}/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-1.6.16 → loopstructural-1.6.18}/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-1.6.18/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-1.6.16 → loopstructural-1.6.18}/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 = []