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

LoopStructural/modelling/core/stratigraphic_column.py

@@ -0,0 +1,473 @@
+import enum
+from typing import Dict
+import numpy as np
+from LoopStructural.utils import rng, getLogger
+
+logger = getLogger(__name__)
+logger.info("Imported LoopStructural Stratigraphic Column module")
+class UnconformityType(enum.Enum):
+    """
+    An enumeration for different types of unconformities in a stratigraphic column.
+    """
+
+    ERODE = 'erode'
+    ONLAP = 'onlap'
+
+
+class StratigraphicColumnElementType(enum.Enum):
+    """
+    An enumeration for different types of elements in a stratigraphic column.
+    """
+
+    UNIT = 'unit'
+    UNCONFORMITY = 'unconformity'
+
+
+class StratigraphicColumnElement:
+    """
+    A class to represent an element in a stratigraphic column, which can be a unit or a topological object
+    for example unconformity.
+    """
+
+    def __init__(self, uuid=None):
+        """
+        Initializes the StratigraphicColumnElement with a uuid.
+        """
+        if uuid is None:
+            import uuid as uuid_module
+
+            uuid = str(uuid_module.uuid4())
+        self.uuid = uuid
+
+
+class StratigraphicUnit(StratigraphicColumnElement):
+    """
+    A class to represent a stratigraphic unit.
+    """
+
+    def __init__(self, *, uuid=None, name=None, colour=None, thickness=None, data=None):
+        """
+        Initializes the StratigraphicUnit with a name and an optional description.
+        """
+        super().__init__(uuid)
+        self.name = name
+        if colour is None:
+            colour = rng.random(3)
+        self.colour = colour
+        self.thickness = thickness
+        self.data = data
+        self.element_type = StratigraphicColumnElementType.UNIT
+
+    def to_dict(self):
+        """
+        Converts the stratigraphic unit to a dictionary representation.
+        """
+        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}
+
+    @classmethod
+    def from_dict(cls, data):
+        """
+        Creates a StratigraphicUnit from a dictionary representation.
+        """
+        if not isinstance(data, dict):
+            raise TypeError("Data must be a dictionary")
+        name = data.get("name")
+        colour = data.get("colour")
+        thickness = data.get("thickness", None)
+        uuid = data.get("uuid", None)
+        return cls(uuid=uuid, name=name, colour=colour, thickness=thickness)
+
+    def __str__(self):
+        """
+        Returns a string representation of the stratigraphic unit.
+        """
+        return (
+            f"StratigraphicUnit(name={self.name}, colour={self.colour}, thickness={self.thickness})"
+        )
+
+
+class StratigraphicUnconformity(StratigraphicColumnElement):
+    """
+    A class to represent a stratigraphic unconformity, which is a surface of discontinuity in the stratigraphic record.
+    """
+
+    def __init__(
+        self, *, uuid=None, name=None, unconformity_type: UnconformityType = UnconformityType.ERODE
+    ):
+        """
+        Initializes the StratigraphicUnconformity with a name and an optional description.
+        """
+        super().__init__(uuid)
+
+        self.name = name
+        if unconformity_type not in [UnconformityType.ERODE, UnconformityType.ONLAP]:
+            raise ValueError("Invalid unconformity type")
+        self.unconformity_type = unconformity_type
+        self.element_type = StratigraphicColumnElementType.UNCONFORMITY
+
+    def to_dict(self):
+        """
+        Converts the stratigraphic unconformity to a dictionary representation.
+        """
+        return {
+            "uuid": self.uuid,
+            "name": self.name,
+            "unconformity_type": self.unconformity_type.value,
+        }
+
+    def __str__(self):
+        """
+        Returns a string representation of the stratigraphic unconformity.
+        """
+        return (
+            f"StratigraphicUnconformity(name={self.name}, "
+            f"unconformity_type={self.unconformity_type.value})"
+        )
+
+    @classmethod
+    def from_dict(cls, data):
+        """
+        Creates a StratigraphicUnconformity from a dictionary representation.
+        """
+        if not isinstance(data, dict):
+            raise TypeError("Data must be a dictionary")
+        name = data.get("name")
+        unconformity_type = UnconformityType(
+            data.get("unconformity_type", UnconformityType.ERODE.value)
+        )
+        uuid = data.get("uuid", None)
+        return cls(uuid=uuid, name=name, unconformity_type=unconformity_type)
+class StratigraphicGroup:
+    """
+    A class to represent a group of stratigraphic units.
+    This class is not fully implemented and serves as a placeholder for future development.
+    """
+
+    def __init__(self, name=None, units=None):
+        """
+        Initializes the StratigraphicGroup with a name and an optional list of units.
+        """
+        self.name = name
+        self.units = units if units is not None else []
+
+
+class 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.
+    """
+
+    def __init__(self):
+        """
+        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)]
+        self.group_mapping = {}
+    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)]
+        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)
+
+        if where == 'top':
+            self.order.append(unit)
+        elif where == 'bottom':
+            self.order.insert(0, unit)
+        else:
+            raise ValueError("Invalid 'where' argument. Use 'top' or 'bottom'.")
+
+        return unit
+
+    def remove_unit(self, uuid):
+        """
+        Removes a unit or unconformity from the stratigraphic column by its uuid.
+        """
+        for i, element in enumerate(self.order):
+            if element.uuid == uuid:
+                del self.order[i]
+                return True
+        return False
+
+    def add_unconformity(self, name, *, unconformity_type=UnconformityType.ERODE, where='top' ):
+        unconformity = StratigraphicUnconformity(
+            uuid=None, name=name, unconformity_type=unconformity_type
+        )
+
+        if where == 'top':
+            self.order.append(unconformity)
+        elif where == 'bottom':
+            self.order.insert(0, unconformity)
+        else:
+            raise ValueError("Invalid 'where' argument. Use 'top' or 'bottom'.")
+        return unconformity
+
+    def get_element_by_index(self, index):
+        """
+        Retrieves an element by its index from the stratigraphic column.
+        """
+        if index < 0 or index >= len(self.order):
+            raise IndexError("Index out of range")
+        return self.order[index]
+
+    def get_unit_by_name(self, name):
+        """
+        Retrieves a unit by its name from the stratigraphic column.
+        """
+        for unit in self.order:
+            if isinstance(unit, StratigraphicUnit) and unit.name == name:
+                return unit
+
+        return None
+    def get_unconformity_by_name(self, name):
+        """
+        Retrieves an unconformity by its name from the stratigraphic column.
+        """
+        for unconformity in self.order:
+            if isinstance(unconformity, StratigraphicUnconformity) and unconformity.name == name:
+                return unconformity
+
+        return None
+    def get_element_by_uuid(self, uuid):
+        """
+        Retrieves an element by its uuid from the stratigraphic column.
+        """
+        for element in self.order:
+            if element.uuid == uuid:
+                return element
+        raise KeyError(f"No element found with uuid: {uuid}")
+    def add_element(self, element):
+        """
+        Adds a StratigraphicColumnElement to the stratigraphic column.
+        """
+        if isinstance(element, StratigraphicColumnElement):
+            self.order.append(element)
+        else:
+            raise TypeError("Element must be an instance of StratigraphicColumnElement")
+
+    def get_elements(self):
+        """
+        Returns a list of all elements in the stratigraphic column.
+        """
+        return self.order
+
+    def get_groups(self):
+        groups = []
+        i=0
+        group = StratigraphicGroup(
+            name=(
+                f'Group_{i}'
+                if f'Group_{i}' not in self.group_mapping
+                else self.group_mapping[f'Group_{i}']
+            )
+        )
+        for e in reversed(self.order):
+            if isinstance(e, StratigraphicUnit):
+                group.units.append(e)
+            else:
+                if group.units:
+                    groups.append(group)
+                    i+=1
+                    group = StratigraphicGroup(
+                        name=(
+                            f'Group_{i}'
+                            if f'Group_{i}' not in self.group_mapping
+                            else self.group_mapping[f'Group_{i}']
+                        )
+                    )
+        if group:
+            groups.append(group)
+        return groups
+
+    def get_unitname_groups(self):
+        groups = self.get_groups()
+        groups_list = []
+        group = []
+        for g in groups:
+            group = [u.name for u in g.units if isinstance(u, StratigraphicUnit)]
+            groups_list.append(group)
+        return groups_list
+        
+
+    def __getitem__(self, uuid):
+        """
+        Retrieves an element by its uuid from the stratigraphic column.
+        """
+        for element in self.order:
+            if element.uuid == uuid:
+                return element
+        raise KeyError(f"No element found with uuid: {uuid}")
+
+    def update_order(self, new_order):
+        """
+        Updates the order of elements in the stratigraphic column based on a new order list.
+        """
+        if not isinstance(new_order, list):
+            raise TypeError("New order must be a list")
+        self.order = [
+            self.__getitem__(uuid) for uuid in new_order if self.__getitem__(uuid) is not None
+        ]
+
+    def update_element(self, unit_data: Dict):
+        """
+        Updates an existing element in the stratigraphic column with new data.
+        :param unit_data: A dictionary containing the updated data for the element.
+        """
+        if not isinstance(unit_data, dict):
+            raise TypeError("unit_data must be a dictionary")
+        element = self.__getitem__(unit_data['uuid'])
+        if isinstance(element, StratigraphicUnit):
+            element.name = unit_data.get('name', element.name)
+            element.colour = unit_data.get('colour', element.colour)
+            element.thickness = unit_data.get('thickness', element.thickness)
+        elif isinstance(element, StratigraphicUnconformity):
+            element.name = unit_data.get('name', element.name)
+            element.unconformity_type = UnconformityType(
+                unit_data.get('unconformity_type', element.unconformity_type.value)
+            )
+
+    def __str__(self):
+        """
+        Returns a string representation of the stratigraphic column, listing all elements.
+        """
+        return "\n".join([f"{i+1}. {element}" for i, element in enumerate(self.order)])
+
+    def to_dict(self):
+        """
+        Converts the stratigraphic column to a dictionary representation.
+        """
+        return {
+            "elements": [element.to_dict() for element in self.order],
+        }
+    def update_from_dict(self, data):
+        """
+        Updates the stratigraphic column from a dictionary representation.
+        """
+        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)
+    @classmethod
+    def from_dict(cls, data):
+        """
+        Creates a StratigraphicColumn from a dictionary representation.
+        """
+        if not isinstance(data, dict):
+            raise TypeError("Data must be a dictionary")
+        column = cls()
+        column.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)
+            column.add_element(element)
+        return column
+
+    def get_isovalues(self) -> Dict[str, float]:
+        """
+        Returns a dictionary of isovalues for the stratigraphic units in the column.
+        """
+        surface_values = {}
+        for g in reversed(self.get_groups()):
+            v = 0
+            for u in g.units:
+                surface_values[u.name] = {'value':v,'group':g.name,'colour':u.colour}
+                v += u.thickness
+        return surface_values
+
+    def plot(self,*, ax=None, **kwargs):
+        import matplotlib.pyplot as plt
+        from matplotlib import cm
+        from matplotlib.patches import Polygon
+        from matplotlib.collections import PatchCollection
+        n_units = 0  # count how many discrete colours (number of stratigraphic units)
+        xmin = 0
+        ymin = 0
+        ymax = 1
+        xmax = 1
+        fig = None
+        if ax is None:
+            fig, ax = plt.subplots(figsize=(2, 10))
+        patches = []  # stores the individual stratigraphic unit polygons
+
+        total_height = 0
+        prev_coords = [0, 0]
+
+        # iterate through groups, skipping faults
+        for u in reversed(self.order):
+            if u.element_type == StratigraphicColumnElementType.UNCONFORMITY:
+                logger.info(f"Plotting unconformity {u.name} of type {u.unconformity_type.value}")
+                ax.axhline(y=total_height, linestyle='--', color='black')
+                ax.annotate(
+                    getattr(u, 'name', 'Unconformity'),
+                    xy=(xmin, total_height),
+                    fontsize=8,
+                    ha='left',
+                )
+
+                total_height -= 0.05  # Adjust height slightly for visual separation
+                continue
+
+            if u.element_type == StratigraphicColumnElementType.UNIT:
+                logger.info(f"Plotting unit {u.name} of type {u.element_type}")
+
+                n_units += 1
+
+                ymax = total_height
+                ymin = ymax - (getattr(u, 'thickness', np.nan) if not np.isinf(getattr(u, 'thickness', np.nan)) else np.nanmean([getattr(e, 'thickness', np.nan) for e in self.order if not np.isinf(getattr(e, 'thickness', np.nan))]))
+
+                if not np.isfinite(ymin):
+                    ymin = prev_coords[1] - (prev_coords[1] - prev_coords[0]) * (1 + rng.random())
+
+                total_height = ymin
+
+                prev_coords = (ymin, ymax)
+
+                polygon_points = np.array([[xmin, ymin], [xmax, ymin], [xmax, ymax], [xmin, ymax]])
+                patches.append(Polygon(polygon_points))
+                ax.annotate(getattr(u, 'name', 'Unknown'), xy=(xmin+(xmax-xmin)/2, (ymax-ymin)/2+ymin), fontsize=8, ha='left')
+
+        if 'cmap' not in kwargs:
+            import matplotlib.colors as colors
+
+            colours = []
+            boundaries = []
+            data = []
+            for i, u in enumerate(self.order):
+                if u.element_type != StratigraphicColumnElementType.UNIT:
+                    continue
+                data.append((i, u.colour))
+                colours.append(u.colour)
+                boundaries.append(i)  # print(u,v)
+            cmap = colors.ListedColormap(colours)
+        else:
+            cmap = cm.get_cmap(kwargs['cmap'], n_units - 1)
+        p = PatchCollection(patches, cmap=cmap)
+
+        colors = np.arange(len(patches))
+        p.set_array(np.array(colors))
+
+        ax.add_collection(p)
+
+        ax.set_ylim(total_height - (total_height - prev_coords[0]) * 0.1, 0)
+
+        ax.axis("off")
+
+        return fig

LoopStructural/modelling/features/_base_geological_feature.py

@@ -244,7 +244,7 @@ class BaseFeature(metaclass=ABCMeta):
         if self.model is None:
             return 0
 
-        return np.nanmin(self.evaluate_value(self.model.regular_grid((10, 10, 10))))
+        return np.nanmin(self.evaluate_value(self.model.regular_grid(nsteps=(10, 10, 10))))
 
     def max(self):
         """Calculate the maximum value of the geological feature
@@ -257,7 +257,7 @@ class BaseFeature(metaclass=ABCMeta):
         """
         if self.model is None:
             return 0
-        return np.nanmax(self.evaluate_value(self.model.regular_grid((10, 10, 10))))
+        return np.nanmax(self.evaluate_value(self.model.regular_grid(nsteps=(10, 10, 10))))
 
     def __tojson__(self):
         regions = [r.name for r in self.regions]
@@ -347,6 +347,42 @@ class BaseFeature(metaclass=ABCMeta):
         grid.cell_properties[self.name] = value
         return grid
 
+    def gradient_norm_scalar_field(self, bounding_box=None):
+        """Create a scalar field for the gradient norm of the feature
+
+        Parameters
+        ----------
+        bounding_box : Optional[BoundingBox], optional
+            bounding box to evaluate the scalar field in, by default None
+
+        Returns
+        -------
+        np.ndarray
+            scalar field of the gradient norm
+        """
+        if bounding_box is None:
+            if self.model is None:
+                raise ValueError("Must specify bounding box")
+            bounding_box = self.model.bounding_box
+        grid = bounding_box.structured_grid(name=self.name)
+        value = np.linalg.norm(
+            self.evaluate_gradient(bounding_box.regular_grid(local=False, order='F')),
+            axis=1,
+        )
+        if self.model is not None:
+            value = np.linalg.norm(
+                self.evaluate_gradient(
+                    self.model.scale(bounding_box.regular_grid(local=False, order='F'))
+                ),
+                axis=1,
+            )
+        grid.properties[self.name] = value
+
+        value = np.linalg.norm(
+            self.evaluate_gradient(bounding_box.cell_centres(order='F')), axis=1
+        )
+        grid.cell_properties[self.name] = value
+        return grid
     def vector_field(self, bounding_box=None, tolerance=0.05, scale=1.0):
         """Create a vector field for the feature
 

LoopStructural/modelling/features/builders/_fault_builder.py

@@ -150,6 +150,7 @@ class FaultBuilder(StructuralFrameBuilder):
             np.logical_and(fault_frame_data["coord"] == 0, fault_frame_data["val"] == 0),
             ["X", "Y"],
         ].to_numpy()
+        self.fault_dip = fault_dip
         if fault_normal_vector is None:
             if fault_frame_data.loc[
             np.logical_and(fault_frame_data["coord"] == 0, fault_frame_data["nx"].notna())].shape[0]>0:

LoopStructural/modelling/features/builders/_geological_feature_builder.py

@@ -452,7 +452,7 @@ class GeologicalFeatureBuilder(BaseBuilder):
         self.interpolator.support.rotation_xy = rotation
         self._up_to_date = False
 
-        while self.interpolator.nx < 100:
+        while self.interpolator.dof < 100:
             self.interpolator.support.step_vector = self.interpolator.support.step_vector * 0.9
 
     def check_interpolation_geometry(self, data, buffer=0.3):

LoopStructural/modelling/features/fault/_fault_segment.py

@@ -104,7 +104,7 @@ class FaultSegment(StructuralFrame):
         if self.builder is None:
             raise ValueError("Fault builder not set")
         return self.builder.fault_major_axis
-
+    
     @property
     def fault_intermediate_axis(self):
         if self.builder is None:

LoopStructural/modelling/intrusions/intrusion_builder.py

@@ -82,7 +82,7 @@ class IntrusionBuilder(BaseBuilder):
         if spacing is None:
             spacing = self.model.nsteps
 
-        grid_points = self.model.regular_grid(spacing, shuffle=False)
+        grid_points = self.model.regular_grid(nsteps=spacing, shuffle=False)
 
         grid_points_coord0 = self.intrusion_frame[0].evaluate_value(grid_points)
 

LoopStructural/modelling/intrusions/intrusion_frame_builder.py

@@ -168,7 +168,7 @@ class IntrusionFrameBuilder(StructuralFrameBuilder):
         if spacing is None:
             spacing = self.model.nsteps
 
-        grid_points = self.model.regular_grid(spacing, shuffle=False)
+        grid_points = self.model.regular_grid(nsteps=spacing, shuffle=False)
 
         self.grid_to_evaluate_ifx = grid_points
 

LoopStructural/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: LoopStructural
-Version: 1.6.14
+Version: 1.6.16
 Summary: 3D geological modelling
 Author-email: Lachlan Grose <lachlan.grose@monash.edu>
 License: MIT
@@ -34,7 +34,7 @@ Requires-Dist: tqdm; extra == "all"
 Provides-Extra: visualisation
 Requires-Dist: matplotlib; extra == "visualisation"
 Requires-Dist: pyvista; extra == "visualisation"
-Requires-Dist: loopstructuralviusualisation>=0.1.14; extra == "visualisation"
+Requires-Dist: loopstructuralvisualisation>=0.1.14; extra == "visualisation"
 Provides-Extra: export
 Requires-Dist: geoh5py; extra == "export"
 Requires-Dist: pyevtk; extra == "export"