LoopStructural 1.6.1__py3-none-any.whl

LoopStructural/modelling/features/_geological_feature.py

@@ -0,0 +1,288 @@
+"""
+Geological features
+"""
+
+from ...modelling.features import BaseFeature
+from ...utils import getLogger
+from ...modelling.features import FeatureType
+from ...interpolators import GeologicalInterpolator, DiscreteInterpolator
+import numpy as np
+from typing import Optional, List, Union
+from ...datatypes import ValuePoints, VectorPoints
+
+from ...utils import LoopValueError
+
+logger = getLogger(__name__)
+
+
+class GeologicalFeature(BaseFeature):
+    """
+    Geological feature is class that is used to represent a geometrical element in a geological
+    model. For example foliations, fault planes, fold rotation angles etc.
+
+    Attributes
+    ----------
+    name : string
+        should be a unique name for the geological feature
+    support : a ScalarField
+        holds the property values for the feature and links to the
+        support geometry
+    data : list
+        list containing geological data
+    region : list
+        list of boolean functions defining whether the feature is
+        active
+    faults : list
+        list of FaultSegments that affect this feature
+    """
+
+    def __init__(
+        self,
+        name: str,
+        interpolator: GeologicalInterpolator,
+        builder=None,
+        regions: list = [],
+        faults: list = [],
+        model=None,
+    ):
+        """Default constructor for geological feature
+
+        Parameters
+        ----------
+        name: str
+        interpolator : GeologicalInterpolator
+        builder : GeologicalFeatureBuilder
+        region : list
+        faults : list
+        model : GeologicalModel
+
+
+        """
+        BaseFeature.__init__(self, name, model, faults, regions, builder)
+        self.name = name
+        self.interpolator = interpolator
+        self.builder = builder
+        self.type = FeatureType.INTERPOLATED
+
+    def to_json(self):
+        """
+        Returns a json representation of the geological feature
+
+        Returns
+        -------
+        json : dict
+            json representation of the geological feature
+        """
+        json = super().to_json()
+        print(self.name, json)
+        json["interpolator"] = self.interpolator.to_json()
+        return json
+
+    def is_valid(self):
+        return self.interpolator.valid
+
+    def __getitem__(self, key):
+        return self._attributes[key]
+
+    def __setitem__(self, key, item):
+        self._attributes[key] = item
+
+    def set_model(self, model):
+        self.model = model
+
+    def evaluate_value(self, pos: np.ndarray, ignore_regions=False, fillnan=None) -> np.ndarray:
+        """
+        Evaluate the scalar field value of the geological feature at the locations
+        specified
+
+        Parameters
+        ----------
+        evaluation_points : np.ndarray
+            location to evaluate the scalar value
+
+        Returns
+        -------
+        values : numpy array
+            numpy array containing evaluated values
+
+        """
+        if pos.shape[1] != 3:
+            raise LoopValueError("Need Nx3 array of xyz points to evaluate value")
+        # TODO need to add a generic type checker for all methods
+        # if evaluation_points is not a numpy array try and convert
+        # otherwise error
+        evaluation_points = np.asarray(pos)
+        self.builder.up_to_date()
+        # check if the points are within the display region
+        v = np.zeros(evaluation_points.shape[0])
+        v[:] = np.nan
+        mask = self._calculate_mask(pos, ignore_regions=ignore_regions)
+        evaluation_points = self._apply_faults(evaluation_points)
+        if mask.dtype not in [int, bool]:
+            logger.error(f"Unable to evaluate value for {self.name}")
+        else:
+            v[mask] = self.interpolator.evaluate_value(evaluation_points[mask, :])
+        if fillnan == 'nearest':
+            import scipy.spatial as spatial
+
+            nanmask = np.isnan(v)
+            tree = spatial.cKDTree(evaluation_points[~nanmask, :])
+            _d, i = tree.query(evaluation_points[nanmask, :])
+            v[nanmask] = v[~nanmask][i]
+        return v
+
+    def evaluate_gradient(self, pos: np.ndarray, ignore_regions=False) -> np.ndarray:
+        """
+
+        Parameters
+        ----------
+        locations : numpy array
+            location where the gradient is being evaluated
+
+        Returns
+        -------
+
+
+        """
+        if pos.shape[1] != 3:
+            raise LoopValueError("Need Nx3 array of xyz points to evaluate gradient")
+        logger.info(f'Calculating gradient for {self.name}')
+
+        self.builder.up_to_date()
+
+        v = np.zeros(pos.shape)
+        v[:] = np.nan
+        mask = self._calculate_mask(pos, ignore_regions=ignore_regions)
+        # evaluate the faults on the nodes of the faulted feature support
+        # then evaluate the gradient at these points
+        if len(self.faults) > 0:
+
+            if issubclass(type(self.interpolator), DiscreteInterpolator):
+                points = self.interpolator.support.nodes
+            else:
+                raise NotImplementedError(
+                    "Faulted feature gradients are only supported by DiscreteInterpolator at the moment."
+                )
+            points_faulted = self._apply_faults(points)
+            values = self.interpolator.evaluate_value(points_faulted)
+            v[mask, :] = self.interpolator.support.evaluate_gradient(pos[mask, :], values)
+            return v
+        pos = self._apply_faults(pos)
+        if mask.dtype not in [int, bool]:
+            logger.error(f"Unable to evaluate gradient for {self.name}")
+        else:
+            v[mask, :] = self.interpolator.evaluate_gradient(pos[mask, :])
+        logger.info(f'Gradient calculated for {self.name}')
+        return v
+
+    def evaluate_gradient_misfit(self):
+        """
+
+        Returns
+        -------
+        misfit : np.array(N,dtype=double)
+            dot product between interpolated gradient and constraints
+        """
+        self.builder.up_to_date()
+        grad = self.interpolator.get_gradient_constraints()
+        norm = self.interpolator.get_norm_constraints()
+
+        dot = []
+        if grad.shape[0] > 0:
+            grad /= np.linalg.norm(grad, axis=1)[:, None]
+            model_grad = self.evaluate_gradient(grad[:, :3])
+            dot.append(np.einsum("ij,ij->i", model_grad, grad[:, :3:6]).tolist())
+
+        if norm.shape[0] > 0:
+            norm /= np.linalg.norm(norm, axis=1)[:, None]
+            model_norm = self.evaluate_gradient(norm[:, :3])
+            dot.append(np.einsum("ij,ij->i", model_norm, norm[:, :3:6]))
+
+        return np.array(dot)
+
+    def evaluate_value_misfit(self):
+        """
+
+        Returns
+        -------
+        misfit : np.array(N,dtype=double)
+            difference between interpolated scalar field and value constraints
+        """
+        self.builder.up_to_date()
+
+        locations = self.interpolator.get_value_constraints()
+        diff = np.abs(locations[:, 3] - self.evaluate_value(locations[:, :3]))
+        diff /= self.max() - self.min()
+        return diff
+
+    def copy(self, name=None):
+        if not name:
+            name = f"{self.name}_copy"
+        feature = GeologicalFeature(
+            name=name,
+            faults=self.faults,
+            regions=[],  # feature.regions.copy(),  # don't want to share regionsbetween unconformity and # feature.regions,
+            builder=self.builder,
+            model=self.model,
+            interpolator=self.interpolator,
+        )
+        return feature
+
+    def get_data(self, value_map: Optional[dict] = None) -> List[Union[ValuePoints, VectorPoints]]:
+        """Return the data associated with this geological feature
+
+        Parameters
+        ----------
+        value_map : Optional[dict], optional
+            A dictionary to map scalar values to another property, by default None
+
+        Returns
+        -------
+        List[Union[ValuePoints, VectorPoints]]
+            A container of either ValuePoints or VectorPoints
+        """
+
+        if self.builder is None:
+            return []
+        value_constraints = self.builder.get_value_constraints()
+        gradient_constraints = self.builder.get_gradient_constraints()
+        norm_constraints = self.builder.get_norm_constraints()
+        data = []
+        if gradient_constraints.shape[0] > 0:
+
+            data.append(
+                VectorPoints(
+                    locations=self.model.rescale(gradient_constraints[:, :3]),
+                    vectors=gradient_constraints[:, 3:6],
+                    name=f'{self.name}+_gradient',
+                )
+            )
+        if norm_constraints.shape[0] > 0:
+            data.append(
+                VectorPoints(
+                    locations=self.model.rescale(norm_constraints[:, :3]),
+                    vectors=norm_constraints[:, 3:6],
+                    name=f'{self.name}_norm',
+                )
+            )
+        if value_constraints.shape[0] > 0:
+            if value_map is not None:
+                for name, v in value_map.items():
+                    data.append(
+                        ValuePoints(
+                            locations=self.model.rescale(
+                                value_constraints[value_constraints == v, :3]
+                            ),
+                            values=value_constraints[value_constraints == v, 3],
+                            name=f"{name}_value",
+                        )
+                    )
+            else:
+                data.append(
+                    ValuePoints(
+                        locations=self.model.rescale(value_constraints[:, :3]),
+                        values=value_constraints[:, 3],
+                        name=f"{self.name}_value",
+                    )
+                )
+        return data

LoopStructural/modelling/features/_lambda_geological_feature.py

@@ -0,0 +1,93 @@
+"""
+Geological features
+"""
+
+from ...modelling.features import BaseFeature
+from ...utils import getLogger
+from ...modelling.features import FeatureType
+import numpy as np
+from typing import Callable, Optional
+
+logger = getLogger(__name__)
+
+
+class LambdaGeologicalFeature(BaseFeature):
+
+    def __init__(
+        self,
+        function: Optional[Callable[[np.ndarray], np.ndarray]] = None,
+        name: str = "unnamed_lambda",
+        gradient_function: Optional[Callable[[np.ndarray], np.ndarray]] = None,
+        model=None,
+        regions: list = [],
+        faults: list = [],
+        builder=None,
+    ):
+        """A lambda geological feature is a wrapper for a geological
+        feature that has a function at the base. This can be then used
+        in place of a geological feature.
+
+        Parameters
+        ----------
+        function : _type_, optional
+            _description_, by default None
+        name : str, optional
+            _description_, by default "unnamed_lambda"
+        gradient_function : _type_, optional
+            _description_, by default None
+        model : _type_, optional
+            _description_, by default None
+        regions : list, optional
+            _description_, by default []
+        faults : list, optional
+            _description_, by default []
+        builder : _type_, optional
+            _description_, by default None
+        """
+        BaseFeature.__init__(self, name, model, faults, regions, builder)
+        self.type = FeatureType.LAMBDA
+        self.function = function
+        self.gradient_function = gradient_function
+
+    def evaluate_value(self, pos: np.ndarray, ignore_regions=False) -> np.ndarray:
+        """_summary_
+
+        Parameters
+        ----------
+        xyz : np.ndarray
+            _description_
+
+        Returns
+        -------
+        np.ndarray
+            _description_
+        """
+        v = np.zeros((pos.shape[0]))
+        if self.function is None:
+            v[:] = np.nan
+        else:
+            v[:] = self.function(pos)
+        return v
+
+    def evaluate_gradient(self, pos: np.ndarray, ignore_regions=False) -> np.ndarray:
+        """_summary_
+
+        Parameters
+        ----------
+        xyz : np.ndarray
+            _description_
+
+        Returns
+        -------
+        np.ndarray
+            _description_
+        """
+        v = np.zeros((pos.shape[0], 3))
+        if self.gradient_function is None:
+            v[:, :] = np.nan
+        else:
+            v[:, :] = self.gradient_function(pos)
+        return v
+
+    def get_data(self, value_map: Optional[dict] = None):
+        return

LoopStructural/modelling/features/_region.py

@@ -0,0 +1,18 @@
+class Region:
+    def __init__(self, feature, value, sign):
+        self.feature = feature
+        self.value = value
+        self.sign = sign
+
+    def __call__(self, xyz):
+        if self.sign:
+            return self.feature.evaluate_value(xyz) > 0
+        else:
+            return self.feature.evaluate_value(xyz) < 0
+
+    def to_json(self):
+        return {
+            "feature": self.feature.name,
+            "value": self.value,
+            "sign": self.sign,
+        }

LoopStructural/modelling/features/_structural_frame.py

@@ -0,0 +1,186 @@
+"""
+Structural frames
+"""
+
+from ..features import BaseFeature, FeatureType
+import numpy as np
+from ...utils import getLogger
+from typing import Optional, List, Union
+from ...datatypes import ValuePoints, VectorPoints
+
+logger = getLogger(__name__)
+
+
+class StructuralFrame(BaseFeature):
+    def __init__(self, name: str, features: list, fold=None, model=None):
+        """
+        Structural frame is a curvilinear coordinate system defined by
+        structural observations associated with a fault or fold.
+
+        Parameters
+        ----------
+        name - name of the structural frame
+        features - list of features to build the frame with
+        """
+        BaseFeature.__init__(self, name, model, [], [], None)
+        self.features = features
+        self.fold = fold
+        self.type = FeatureType.STRUCTURALFRAME
+
+    def to_json(self):
+        """
+        Return a json representation of the structural frame
+
+        Returns
+        -------
+        json : dict
+            json representation of the structural frame
+        """
+        json = {}
+        json["name"] = self.name
+        json["features"] = [f.name for f in self.features]
+        json["type"] = self.type
+        return json
+
+    def __getitem__(self, key):
+        """
+
+        Parameters
+        ----------
+        key index of feature to access
+
+        Returns
+        -------
+        the structural frame geological feature
+        """
+        return self.features[key]
+
+    def __setitem__(self, key, value):
+        """
+
+        Parameters
+        ----------
+        item index of feature to access
+
+        Returns
+        -------
+        the structural frame geological feature
+        """
+        self.features[key] = value
+
+    def set_model(self, model):
+        """Link the model that created the frame to the frame
+        and the features that make up the frame
+
+        Parameters
+        ----------
+        model : GeologicalModel
+            the geological model that created the fold frame
+        """
+        self.model = model
+        for f in self.features:
+            if f is None:
+                continue
+            f.set_model(model)
+
+    @property
+    def model(self):
+        return self._model
+
+    @model.setter
+    def model(self, model):
+        # causes circular import, could delay import?
+        # if type(model) == GeologicalModel:
+        for f in self.features:
+            if f is None:
+                continue
+            f.model = model
+
+    def add_region(self, region):
+        self.regions.append(region)
+        for i in range(3):
+            self.features[i].regions = self.regions
+
+    def get_feature(self, i):
+        """
+        Return the ith feature
+
+        Parameters
+        ----------
+        i
+
+        Returns
+        -------
+
+        """
+        return self.features[i]
+
+    def evaluate_value(self, evaluation_points, ignore_regions=False):
+        """
+        Evaluate the value of the structural frame for the points.
+        Can optionally only evaluate one coordinate
+
+        Parameters
+        ----------
+        evaluation_points
+        i
+
+        Returns
+        -------
+
+        """
+        v = np.zeros(evaluation_points.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)
+        return v
+
+    def evaluate_gradient(self, evaluation_points, i=None, ignore_regions=False):
+        """
+        Evaluate the gradient of the structural frame.
+        Can optionally only evaluate the ith coordinate
+
+        Parameters
+        ----------
+        evaluation_points
+        i
+
+        Returns
+        -------
+
+        """
+        if i is not None:
+            return self.features[i].support.evaluate_gradient(
+                evaluation_points, 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
+            ),
+        )
+
+    def get_data(self, value_map: Optional[dict] = None) -> List[Union[ValuePoints, VectorPoints]]:
+        """Return the data associated with the features in the
+        structural frame
+
+        Parameters
+        ----------
+        value_map : Optional[dict], optional
+            map scalar values to another property, by default None
+
+        Returns
+        -------
+        List
+            container of value or vector points
+        """
+        data = []
+        for f in self.features:
+            data.extend(f.get_data(value_map))
+        return data

LoopStructural/modelling/features/_unconformity_feature.py

@@ -0,0 +1,83 @@
+from ...modelling.features import GeologicalFeature
+from ...modelling.features import FeatureType
+
+import numpy as np
+
+
+class UnconformityFeature(GeologicalFeature):
+    """ """
+
+    def __init__(self, feature: GeologicalFeature, value: float, sign=True, onlap=False):
+        """
+
+        Parameters
+        ----------
+        feature
+        value
+        """
+        # create a shallow(ish) copy of the geological feature
+        # just don't link the regions
+        GeologicalFeature.__init__(
+            self,
+            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,
+            model=feature.model,
+            interpolator=feature.interpolator,
+        )
+        self.value = value
+        self.type = FeatureType.UNCONFORMITY if onlap is False else FeatureType.ONLAPUNCONFORMITY
+        self.sign = sign
+        self.parent = feature
+
+    @property
+    def faults(self):
+        return self.parent.faults
+
+    def to_json(self):
+        json = super().to_json()
+        json["value"] = self.value
+        json["sign"] = self.sign
+        json["parent"] = self.parent.name
+        return json
+
+    def inverse(self):
+        """Returns an unconformity feature with the sign flipped
+        The feature is a shallow copy with the parent being set to
+        the parent of this feature
+
+        Returns
+        -------
+        UnconformityFeature
+            _description_
+        """
+        uc = UnconformityFeature(
+            self.parent,
+            self.value,
+            sign=not self.sign,
+            onlap=self.type == FeatureType.ONLAPUNCONFORMITY,
+        )
+        uc.name = self.name + "_inverse"
+        return uc
+
+    def evaluate(self, pos: np.ndarray) -> np.ndarray:
+        """
+
+        Parameters
+        ----------
+        pos : numpy array
+            locations to evaluate whether below or above unconformity
+
+        Returns
+        -------
+        np.ndarray.dtype(bool)
+            true if above the unconformity, false if below
+        """
+        if self.sign:
+            return self.evaluate_value(pos) < self.value
+        if not self.sign:
+            return self.evaluate_value(pos) > self.value
+
+    def __call__(self, pos) -> np.ndarray:
+        return self.evaluate(pos)

LoopStructural/modelling/features/builders/__init__.py

@@ -0,0 +1,5 @@
+from ._base_builder import BaseBuilder
+from ._geological_feature_builder import GeologicalFeatureBuilder
+from ._folded_feature_builder import FoldedFeatureBuilder
+from ._structural_frame_builder import StructuralFrameBuilder
+from ._fault_builder import FaultBuilder