LoopStructural 1.6.3__tar.gz → 1.6.5__tar.gz

{loopstructural-1.6.3 → loopstructural-1.6.5}/LoopStructural/datatypes/_point.py

@@ -123,12 +123,15 @@ class VectorPoints:
     def from_dict(self, d):
         return VectorPoints(d['locations'], d['vectors'], d['name'], d.get('properties', None))
 
-    def vtk(self, geom='arrow', scale=1.0, scale_function=None, tolerance=0.05):
+    def vtk(self, geom='arrow', scale=1.0, scale_function=None, normalise=True, tolerance=0.05):
         import pyvista as pv
 
         vectors = np.copy(self.vectors)
+        if normalise:
+            norm = np.linalg.norm(vectors, axis=1)
+            vectors[norm > 0, :] /= norm[norm > 0][:, None]
         if scale_function is not None:
-            vectors /= np.linalg.norm(vectors, axis=1)[:, None]
+            # vectors /= np.linalg.norm(vectors, axis=1)[:, None]
             vectors *= scale_function(self.locations)[:, None]
         points = pv.PolyData(self.locations)
         points.point_data.set_vectors(vectors, 'vectors')

{loopstructural-1.6.3 → loopstructural-1.6.5}/LoopStructural/interpolators/supports/_3d_structured_grid.py

@@ -342,9 +342,6 @@ class StructuredGrid(BaseStructuredSupport):
         idc, inside = self.position_to_cell_corners(evaluation_points)
         T = np.zeros((idc.shape[0], 3, 8))
         T[inside, :, :] = self.get_element_gradient_for_location(evaluation_points[inside, :])[1]
-        # indices = np.array([self.position_to_cell_index(evaluation_points)])
-        # idc = self.global_indicies(indices.swapaxes(0,1))
-        # print(idc)
         if np.max(idc[inside, :]) > property_array.shape[0]:
             cix, ciy, ciz = self.position_to_cell_index(evaluation_points)
             if not np.all(cix[inside] < self.nsteps_cells[0]):

{loopstructural-1.6.3 → loopstructural-1.6.5}/LoopStructural/modelling/__init__.py

@@ -25,5 +25,3 @@ except (LoopImportError, ImportError):
     logger.warning(
         "Cannot use LoopProjectfileProcessor: Loop project file cannot be imported, try installing LoopProjectFile"
     )
-# from LoopStructural.modelling.features import StructuralFrame
-# from LoopStructural.modelling.features.fault import FaultSegment

{loopstructural-1.6.3 → loopstructural-1.6.5}/LoopStructural/modelling/core/geological_model.py

@@ -649,7 +649,7 @@ class GeologicalModel:
             for g in stratigraphic_column.keys():
                 for u in stratigraphic_column[g].keys():
                     stratigraphic_column[g][u]["colour"] = cmap_colours[ci, :]
-
+                    ci += 1
         self.stratigraphic_column = stratigraphic_column
 
     def create_and_add_foliation(
@@ -1809,7 +1809,7 @@ class GeologicalModel:
         grid = self.bounding_box.structured_grid(name=name)
 
         grid.cell_properties['stratigraphy'] = self.evaluate_model(
-            self.bounding_box.cell_centers(), scale=False
+            self.rescale(self.bounding_box.cell_centers())
         )
         return grid, self.stratigraphic_ids()
 

{loopstructural-1.6.3 → loopstructural-1.6.5}/LoopStructural/modelling/features/_base_geological_feature.py

@@ -291,11 +291,24 @@ class BaseFeature(metaclass=ABCMeta):
             if self.model is None:
                 raise ValueError("Must specify bounding box")
             bounding_box = self.model.bounding_box
-        callable = lambda xyz: self.evaluate_value(self.model.scale(xyz))
-        isosurfacer = LoopIsosurfacer(bounding_box, callable=callable)
-        if name is None and self.name is not None:
-            name = self.name
-        return isosurfacer.fit(value, name)
+        regions = self.regions
+        try:
+            self.regions = [
+                r for r in self.regions if r.name != self.name and r.parent.name != self.name
+            ]
+            callable = lambda xyz: self.evaluate_value(self.model.scale(xyz))
+            isosurfacer = LoopIsosurfacer(bounding_box, callable=callable)
+            if name is None and self.name is not None:
+                name = self.name
+            surfaces = isosurfacer.fit(value, name)
+        except Exception as e:
+            logger.error(f"Failed to create surface for {self.name} at value {value}")
+            logger.error(e)
+            surfaces = []
+        finally:
+            self.regions = regions
+
+        return surfaces
 
     def scalar_field(self, bounding_box=None):
         """Create a scalar field for the feature
@@ -341,10 +354,10 @@ class BaseFeature(metaclass=ABCMeta):
             if self.model is None:
                 raise ValueError("Must specify bounding box")
             bounding_box = self.model.bounding_box
-        grid = bounding_box.vtk()
-        points = grid.points
+        points = bounding_box.cell_centers()
         value = self.evaluate_gradient(points)
-
+        if self.model is not None:
+            points = self.model.rescale(points)
         return VectorPoints(points, value, self.name)
 
     @abstractmethod

{loopstructural-1.6.3 → loopstructural-1.6.5}/LoopStructural/modelling/features/_structural_frame.py

@@ -115,7 +115,7 @@ class StructuralFrame(BaseFeature):
         """
         return self.features[i]
 
-    def evaluate_value(self, evaluation_points, ignore_regions=False):
+    def evaluate_value(self, pos, ignore_regions=False):
         """
         Evaluate the value of the structural frame for the points.
         Can optionally only evaluate one coordinate
@@ -129,14 +129,14 @@ class StructuralFrame(BaseFeature):
         -------
 
         """
-        v = np.zeros(evaluation_points.shape)  # create new 3d array of correct length
+        v = np.zeros(pos.shape)  # create new 3d array of correct length
         v[:] = np.nan
-        v[:, 0] = self.features[0].evaluate_value(evaluation_points, ignore_regions=ignore_regions)
-        v[:, 1] = self.features[1].evaluate_value(evaluation_points, ignore_regions=ignore_regions)
-        v[:, 2] = self.features[2].evaluate_value(evaluation_points, ignore_regions=ignore_regions)
+        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
 
-    def evaluate_gradient(self, evaluation_points, i=None, ignore_regions=False):
+    def evaluate_gradient(self, pos, i=None, ignore_regions=False):
         """
         Evaluate the gradient of the structural frame.
         Can optionally only evaluate the ith coordinate
@@ -151,19 +151,11 @@ class StructuralFrame(BaseFeature):
 
         """
         if i is not None:
-            return self.features[i].support.evaluate_gradient(
-                evaluation_points, ignore_regions=ignore_regions
-            )
+            return self.features[i].support.evaluate_gradient(pos, ignore_regions=ignore_regions)
         return (
-            self.features[0].support.evaluate_gradient(
-                evaluation_points, ignore_regions=ignore_regions
-            ),
-            self.features[1].support.evaluate_gradient(
-                evaluation_points, ignore_regions=ignore_regions
-            ),
-            self.features[2].support.evaluate_gradient(
-                evaluation_points, ignore_regions=ignore_regions
-            ),
+            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),
         )
 
     def get_data(self, value_map: Optional[dict] = None) -> List[Union[ValuePoints, VectorPoints]]:

{loopstructural-1.6.3 → loopstructural-1.6.5}/LoopStructural/modelling/features/_unconformity_feature.py

@@ -19,7 +19,7 @@ class UnconformityFeature(GeologicalFeature):
         # just don't link the regions
         GeologicalFeature.__init__(
             self,
-            name=f"{feature.name}_unconformity",
+            name=f"__{feature.name}_unconformity",
             faults=feature.faults,
             regions=[],  # feature.regions.copy(),  # don't want to share regionsbetween unconformity and # feature.regions,
             builder=feature.builder,
@@ -75,9 +75,9 @@ class UnconformityFeature(GeologicalFeature):
             true if above the unconformity, false if below
         """
         if self.sign:
-            return self.evaluate_value(pos) < self.value
+            return self.evaluate_value(pos) <= self.value
         if not self.sign:
-            return self.evaluate_value(pos) > self.value
+            return self.evaluate_value(pos) >= self.value
 
     def __call__(self, pos) -> np.ndarray:
         return self.evaluate(pos)

{loopstructural-1.6.3 → loopstructural-1.6.5}/LoopStructural/modelling/features/fault/_fault_segment.py

@@ -114,6 +114,26 @@ class FaultSegment(StructuralFrame):
     def displacementfeature(self):
         return FaultDisplacementFeature(self, self.faultfunction, name=self.name, model=self.model)
 
+    def fault_ellipsoid(self, **kwargs):
+        try:
+            import pyvista as pv
+
+            fault_ellipsoid = pv.PolyData(
+                self.model.rescale(self.fault_centre[None, :], inplace=False)
+            )
+            fault_ellipsoid["norm"] = self.builder.fault_normal_vector[None, :]
+
+            geom = pv.ParametricEllipsoid(
+                self.fault_minor_axis,
+                self.fault_major_axis,
+                self.fault_intermediate_axis,
+            )
+            ellipsoid = fault_ellipsoid.glyph(geom=geom, **kwargs)
+            return ellipsoid
+        except ImportError:
+            logger.error("pyvista not installed")
+            return None
+
     def set_fault_offset(self, offset: float):
         self.fault_offset = offset
 
@@ -177,7 +197,7 @@ class FaultSegment(StructuralFrame):
         return np.abs(v) > threshold
         # return np.all(np.logical_and(v > -1,v<1),axis=1)
 
-    def evaluate_value(self, locations):
+    def evaluate_value(self, locations, ignore_regions=False):
         """
         Return the value of the fault surface scalar field
 
@@ -202,7 +222,10 @@ class FaultSegment(StructuralFrame):
         #     except:
         #         logger.error("nan slicing")
         # v[mask] = self.__getitem__(0).evaluate_value(locations[mask, :])
-        return self.__getitem__(0).evaluate_value(locations)
+        return self.__getitem__(0).evaluate_value(locations, ignore_regions=ignore_regions)
+
+    def ellipsoid(self):
+        pass
 
     def mean(self):
         return self.__getitem__(0).mean()

{loopstructural-1.6.3 → loopstructural-1.6.5}/LoopStructural/modelling/input/process_data.py

@@ -165,8 +165,19 @@ class ProcessInputData:
             unit_id = 1
             val = self._stratigraphic_value()
             for name, sg in self._stratigraphic_order:
+                # set the oldest unit to be the basement.
+                # this has no observed basal contact and then
+                # top of the unit is the 0 isovalue.
+                # this is the minimum of the next unit
                 stratigraphic_column[name] = {}
-                for i, g in enumerate(reversed(sg)):
+                stratigraphic_column[name][sg[-1]] = {
+                    "max": 0,
+                    "min": -np.inf,
+                    "id": unit_id,
+                    "colour": self.colours[sg[-1]],
+                }
+                # iterate through the remaining units (in reverse)
+                for g in reversed(sg[:-1]):
                     if g in self.thicknesses:
                         stratigraphic_column[name][g] = {
                             "max": val[g] + self.thicknesses[g],
@@ -174,10 +185,6 @@ class ProcessInputData:
                             "id": unit_id,
                             "colour": self.colours[g],
                         }
-                        if i == 0:
-                            stratigraphic_column[name][g]["min"] = 0
-                        if i == len(sg) - 1:
-                            stratigraphic_column[name][g]["max"] = np.inf
 
                     unit_id += 1
             # add faults into the column
@@ -438,7 +445,14 @@ class ProcessInputData:
         stratigraphic_value = {}
         for _name, sg in self.stratigraphic_order:
             value = 0.0  # reset for each supergroup
-            for g in reversed(sg):
+            if sg[0] not in self.thicknesses or self.thicknesses[sg[0]] <= 0:
+                self.thicknesses[sg[0]] = (
+                    np.inf
+                )  # make the top unit infinite as it should extend to the top of the model
+            for g in reversed(
+                sg[:-1]
+            ):  # don't add the last unit as we never see the base of this unit.
+                # It should be "basement"
                 if g not in self.thicknesses:
                     logger.warning(f"No thicknesses for {g}")
                     stratigraphic_value[g] = np.nan
@@ -469,30 +483,13 @@ class ProcessInputData:
 
     @property
     def contacts(self):
-        return self._contacts
-
-    @contacts.setter
-    def contacts(self, contacts):
-        """Function to convert input contact to loopstructural input
-
-        either uses the thickness values or assigns unique ids given
-        the units named in stratigraphic order
-
-        Returns
-        -------
-        DataFrame
-            data frame with x,y,y,val/interface,feature_name
-        """
-        if contacts is None:
-            return
-        contacts = contacts.copy()
-        self._update_feature_names(contacts)
+        contacts = self._contacts.copy()
         if self._use_thickness:
             contacts["val"] = np.nan
             for k, v in self._stratigraphic_value().items():
                 contacts.loc[contacts["name"] == k, "val"] = v
 
-            self._contacts = contacts.loc[
+            contacts = contacts.loc[
                 ~np.isnan(contacts["val"]), ["X", "Y", "Z", "feature_name", "val"]
             ]
         if not self._use_thickness:
@@ -500,10 +497,28 @@ class ProcessInputData:
             interface_val = 0
             for k in self._stratigraphic_value().keys():
                 contacts.loc[contacts["name"] == k, "interface"] = interface_val
-            self._contacts = contacts.loc[
+            contacts = contacts.loc[
                 ~np.isnan(contacts["interface"]),
                 ["X", "Y", "Z", "feature_name", "interface"],
             ]
+        return contacts
+
+    @contacts.setter
+    def contacts(self, contacts):
+        """Function to convert input contact to loopstructural input
+
+        either uses the thickness values or assigns unique ids given
+        the units named in stratigraphic order
+
+        Returns
+        -------
+        DataFrame
+            data frame with x,y,y,val/interface,feature_name
+        """
+        if contacts is None:
+            return
+        self._contacts = contacts.copy()
+        self._update_feature_names(self._contacts)
 
     @property
     def contact_orientations(self):

{loopstructural-1.6.3 → loopstructural-1.6.5}/LoopStructural/modelling/input/project_file.py

@@ -34,24 +34,48 @@ class LoopProjectfileProcessor(ProcessInputData):
                 projectfile["stratigraphicLog"].ThicknessMedian,
             )
         )
-        fault_properties = self.projectfile.faultLog
-        fault_properties.rename(
-            columns={
-                "avgDisplacement": "displacement",
-                "influenceDistance": "minor_axis",
-                "verticalRadius": "intermediate_axis",
-                "horizontalRadius": "major_axis",
-                "name": "fault_name",
-            },
-            inplace=True,
-        )
-        fault_locations = fault_properties.reset_index()[["fault_name", "eventId"]].merge(
-            fault_locations, on="eventId"
-        )
-        fault_orientations = fault_properties.reset_index()[["fault_name", "eventId"]].merge(
-            fault_orientations, on="eventId"
-        )
-        fault_properties.set_index("fault_name", inplace=True)
+        fault_properties = None
+        fault_edges = None
+        fault_edge_properties = None
+        if self.projectfile.faultLog.shape[0] > 0:
+
+            fault_properties = self.projectfile.faultLog
+            fault_properties.rename(
+                columns={
+                    "avgDisplacement": "displacement",
+                    "influenceDistance": "minor_axis",
+                    "verticalRadius": "intermediate_axis",
+                    "horizontalRadius": "major_axis",
+                    "name": "fault_name",
+                },
+                inplace=True,
+            )
+            fault_locations = fault_properties.reset_index()[["fault_name", "eventId"]].merge(
+                fault_locations, on="eventId"
+            )
+            fault_orientations = fault_properties.reset_index()[["fault_name", "eventId"]].merge(
+                fault_orientations, on="eventId"
+            )
+            fault_properties.set_index("fault_name", inplace=True)
+            for i in fault_relationships.index:
+                fault_relationships.loc[i, "Fault1"] = faultLog.loc[
+                    fault_relationships.loc[i, "eventId1"], "name"
+                ]
+                fault_relationships.loc[i, "Fault2"] = faultLog.loc[
+                    fault_relationships.loc[i, "eventId2"], "name"
+                ]
+            fault_edges = []
+            fault_edge_properties = []
+            for i in fault_relationships.index:
+                fault_edges.append(
+                    (fault_relationships.loc[i, "Fault1"], fault_relationships.loc[i, "Fault2"])
+                )
+                fault_edge_properties.append(
+                    {
+                        "type": fault_relationships.loc[i, "type"],
+                        "angle": fault_relationships.loc[i, "angle"],
+                    }
+                )
         colours = dict(
             zip(
                 self.projectfile.stratigraphicLog.name,
@@ -65,25 +89,6 @@ class LoopProjectfileProcessor(ProcessInputData):
             )
         )
 
-        for i in fault_relationships.index:
-            fault_relationships.loc[i, "Fault1"] = faultLog.loc[
-                fault_relationships.loc[i, "eventId1"], "name"
-            ]
-            fault_relationships.loc[i, "Fault2"] = faultLog.loc[
-                fault_relationships.loc[i, "eventId2"], "name"
-            ]
-        fault_edges = []
-        fault_edge_properties = []
-        for i in fault_relationships.index:
-            fault_edges.append(
-                (fault_relationships.loc[i, "Fault1"], fault_relationships.loc[i, "Fault2"])
-            )
-            fault_edge_properties.append(
-                {
-                    "type": fault_relationships.loc[i, "type"],
-                    "angle": fault_relationships.loc[i, "angle"],
-                }
-            )
         super().__init__(
             contacts=contacts,
             contact_orientations=orientations,
@@ -91,8 +96,8 @@ class LoopProjectfileProcessor(ProcessInputData):
                 ("sg", list(self.projectfile.stratigraphicLog.name))
             ],  # needs to be updated,
             thicknesses=thicknesses,
-            fault_orientations=fault_orientations,
-            fault_locations=fault_locations,
+            fault_orientations=fault_orientations if fault_orientations.shape[0] > 0 else None,
+            fault_locations=fault_locations if fault_locations.shape[0] > 0 else None,
             fault_properties=fault_properties,
             fault_edges=fault_edges,  # list(fault_graph.edges),
             colours=colours,

{loopstructural-1.6.3 → loopstructural-1.6.5}/LoopStructural/utils/__init__.py

@@ -36,3 +36,4 @@ import numpy as np
 rng = np.random.default_rng()
 
 from ._surface import LoopIsosurfacer, surface_list
+from .colours import random_colour

{loopstructural-1.6.3 → loopstructural-1.6.5}/LoopStructural/utils/_surface.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from typing import Optional, Union, Callable, List
+from collections.abc import Iterable
 import numpy as np
 import numpy.typing as npt
 from LoopStructural.utils.logging import getLogger
@@ -86,11 +87,14 @@ class LoopIsosurfacer:
         all_values = self.callable(self.bounding_box.regular_grid(local=False))
         ## set value to mean value if its not specified
         if values is None:
-            values = [(np.nanmax(all_values) - np.nanmin(all_values)) / 2]
-        if isinstance(values, list):
+            values = [((np.nanmax(all_values) - np.nanmin(all_values)) / 2) + np.nanmin(all_values)]
+        if isinstance(values, Iterable):
             isovalues = values
         elif isinstance(values, float):
             isovalues = [values]
+        if isinstance(values, int) and values == 0:
+            values = 0.0  # assume 0 isosurface is meant to be a float
+
         elif isinstance(values, int) and values < 1:
             raise ValueError(
                 "Number of isosurfaces must be greater than 1. Either use a positive integer or provide a list or float for a specific isovalue."

{loopstructural-1.6.3 → loopstructural-1.6.5}/LoopStructural/utils/colours.py

@@ -1,7 +1,7 @@
 from LoopStructural.utils import rng
 
 
-def random_colour(n: int, cmap='tab20'):
+def random_colour(n: int = 1, cmap='tab20'):
     """
     Generate a list of random colours
 

loopstructural-1.6.5/LoopStructural/version.py

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

{loopstructural-1.6.3 → loopstructural-1.6.5/LoopStructural.egg-info}/PKG-INFO

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

{loopstructural-1.6.3/LoopStructural.egg-info → loopstructural-1.6.5}/PKG-INFO

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

loopstructural-1.6.3/LoopStructural/version.py

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