LoopStructural 1.0.9__cp36-cp36m-win32.whl

LoopStructural/modelling/fault/fault_segment.py

@@ -0,0 +1,298 @@
+import logging
+
+from LoopStructural.modelling.fault.fault_function_feature import FaultDisplacementFeature
+from LoopStructural.modelling.fault.fault_function import BaseFault
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
+from concurrent.futures import ThreadPoolExecutor
+import numpy as np
+
+
+class FaultSegment:
+    """
+    Class for representing a slip event of a fault
+    """
+
+    def __init__(self, faultframe,
+                 faultfunction = None,
+                 steps = 3,
+                 displacement=1.,
+                 **kwargs):
+        """
+        A slip event of a fault
+
+        Parameters
+        ----------
+        faultframe : FaultFrame
+            the fault frame defining the faut geometry
+        faultfunction : function/lambda function
+            optional displacement function for spatially variable fault displacement
+        steps : int
+            how many integration steps for faults
+        kwargs
+        """
+        self.faultframe = faultframe
+        self.type = 'fault'
+        self.name = kwargs.get('name', self.faultframe.name)
+        self.displacement = displacement
+        self.faultfunction = faultfunction
+        if faultfunction == 'BaseFault':
+            self.faultfunction = BaseFault.fault_displacement
+        self.steps = steps
+        self.regions = []
+        self.faults_enabled = True
+        self.displacementfeature = None
+        self.model = None
+        if self.faultframe is not None:
+            self.displacementfeature = FaultDisplacementFeature(
+                self.faultframe, self.faultfunction, name = self.name)
+        self.builder = None
+    
+    def __getitem__(self, item):
+        """
+
+        Parameters
+        ----------
+        item
+
+        Returns
+        -------
+
+        """
+        return self.faultframe[item]
+    
+    def set_model(self, model):
+        """
+        Link a geological model to the feature
+
+        Parameters
+        ----------
+        model - GeologicalModel
+
+        Returns
+        -------
+
+        """
+        self.model = model
+
+    def set_displacement(self, displacement, scale = True):
+        """
+        Set the fault displacement to a new value
+
+        Parameters
+        ----------
+        displacement - double
+        scale - boolean
+
+        Returns
+        -------
+
+        """
+        if scale and self.model is not None:
+            self.displacement = displacement / self.model.scale_factor
+        elif not scale:
+                self.displacement = displacement
+        else:
+            logger.warning("Displacement not updated")
+
+    def toggle_faults(self):
+        """
+        Toggle faults that affect this fault segment
+
+        Returns
+        -------
+
+        """
+        self.faults_enabled = ~self.faults_enabled
+        for i in range(3):
+            self.faultframe[i].toggle_faults()
+
+    def add_region(self, region):
+        """
+
+        Parameters
+        ----------
+        region : boolean function(x,y,z)
+                A function that returns true if inside region, false if outside
+                can be passed as a lambda function e.g.
+                lambda pos : feature.evaluate_value(pos) > 0
+        Returns
+        -------
+
+        """
+
+        self.regions.append(region)
+
+    def evaluate(self, locations):
+        """
+        Evaluate which side of fault
+
+        Parameters
+        ----------
+        locations numpy array
+            location to evaluate
+
+        Returns
+        -------
+            boolean array true if on hanging wall, false if on footwall
+
+        """
+
+        return self.faultframe.features[0].evaluate_value(locations) > 0
+
+    def inside_volume(self,locations):
+        v = self.faultframe.evaluate_value(locations)
+        return np.all(np.logical_and(v > -1,v<1),axis=1)
+
+    def evaluate_value(self, locations):
+        """
+        Return the value of the fault surface scalar field
+
+        Parameters
+        ----------
+        locations - numpy array
+            location to evaluate scalar field
+
+        Returns
+        -------
+
+        """
+        v = np.zeros(locations.shape[0])
+        v[:] = np.nan
+        mask = np.zeros(locations.shape[0]).astype(bool)
+        mask[:] = True
+        # check regions
+        for r in self.regions:
+            mask = np.logical_and(mask, r(locations))
+        v[mask]=self.faultframe[0].evaluate_value(locations[mask, :])
+        return v
+
+    def mean(self):
+        return self.faultframe[0].mean()
+
+    def max(self):
+        return self.faultframe[0].max()
+
+    def min(self):
+        return self.faultframe[0].min()
+
+    def evaluate_gradient(self, locations):
+        """
+        Return the fault slip direction at the location
+
+        Parameters
+        ----------
+        locations - numpy array Nx3
+
+
+        Returns
+        -------
+
+        """
+        v = np.zeros(locations.shape)
+        v[:,:] = np.nan
+        mask = np.zeros(locations.shape[0]).astype(bool)
+        mask[:] = True
+        # check regions
+        for r in self.regions:
+            mask = np.logical_and(mask, r(locations))
+        # need to scale with fault displacement
+        v[mask,:] = self.faultframe[1].evaluate_gradient(locations[mask, :])
+        return v
+
+    def evaluate_displacement(self, points):
+        newp = np.copy(points).astype(float)
+        # evaluate fault function for all points then define mask for only points affected by fault
+        with ThreadPoolExecutor(max_workers=8) as executor:
+            # all of these operations should be independent so just run as different threads
+            gx_future = executor.submit(self.faultframe.features[0].evaluate_value, newp)
+            gy_future = executor.submit(self.faultframe.features[1].evaluate_value, newp)
+            gz_future = executor.submit(self.faultframe.features[2].evaluate_value, newp)
+            gx = gx_future.result()
+            gy = gy_future.result()
+            gz = gz_future.result()
+        d = np.zeros(gx.shape)
+        mask = np.logical_and(~np.isnan(gx),~np.isnan(gy))
+        mask = np.logical_and(mask,~np.isnan(gz))
+        d[~mask] = 0
+        gx_mask = np.zeros_like(mask,dtype=bool)
+        gx_mask[mask] = gx[mask] > 0
+        d[gx_mask] = 1.
+        if self.faultfunction is not None:
+            d[mask] = self.faultfunction(gx[mask], gy[mask], gz[mask])
+        return d
+    def apply_to_points(self, points):
+        """
+        Unfault the array of points
+
+        Parameters
+        ----------
+        points - numpy array Nx3
+
+        Returns
+        -------
+
+        """
+        steps = self.steps
+        newp = np.copy(points).astype(float)
+        # evaluate fault function for all points then define mask for only points affected by fault
+        with ThreadPoolExecutor(max_workers=8) as executor:
+            # all of these operations should be independent so just run as different threads
+            gx_future = executor.submit(self.faultframe.features[0].evaluate_value, newp)
+            gy_future = executor.submit(self.faultframe.features[1].evaluate_value, newp)
+            gz_future = executor.submit(self.faultframe.features[2].evaluate_value, newp)
+            gx = gx_future.result()
+            gy = gy_future.result()
+            gz = gz_future.result()
+        d = np.zeros(gx.shape)
+        mask = np.logical_and(~np.isnan(gx),~np.isnan(gy))
+        mask = np.logical_and(mask,~np.isnan(gz))
+        d[~mask] = 0
+        gx_mask = np.zeros_like(mask,dtype=bool)
+        gx_mask[mask] = gx[mask] > 0
+        d[gx_mask] = 1.
+        if self.faultfunction is not None:
+            d[mask] = self.faultfunction(gx[mask], gy[mask], gz[mask])
+        mask = np.abs(d) > 0.
+
+        d *= self.displacement
+        # calculate the fault frame for the evaluation points
+        for i in range(steps):
+            with ThreadPoolExecutor(max_workers=8) as executor:
+                # all of these operations should be independent so just run as different threads
+                gx_future = executor.submit(self.faultframe.features[0].evaluate_value, newp[mask, :])
+                g_future = executor.submit(self.faultframe.features[1].evaluate_gradient, newp[mask, :])
+                gy_future = executor.submit(self.faultframe.features[1].evaluate_value, newp[mask, :])
+                gz_future = executor.submit(self.faultframe.features[2].evaluate_value, newp[mask, :])
+                gx = gx_future.result()
+                g = g_future.result()
+                gy = gy_future.result()
+                gz = gz_future.result()
+            # # get the fault frame val/grad for the points
+            # determine displacement magnitude, for constant displacement
+            # hanging wall should be > 0
+            d = np.zeros(gx.shape)
+            mask2 = np.logical_and(~np.isnan(gx), ~np.isnan(gy))
+            mask2 = np.logical_and(mask2, ~np.isnan(gz))
+            d[~mask2] = 0
+            gx_mask2 = np.zeros_like(mask2,dtype=bool)
+            gx_mask2[mask2] = gx[mask2] > 0
+            # d[~np.isnan(gx)][gx[~np.isnan(gx)]>0] = 1
+            d[gx_mask2] = 1.
+            # d[mask2][gx[mask2] < 0] = 0.
+            # d[gx < 0] = 0.
+            if self.faultfunction is not None:
+                d[mask2] = self.faultfunction(gx[mask2], gy[mask2], gz[mask2])
+            d *= self.displacement
+            # normalise when length is >0
+            g_mag = np.zeros(g.shape[0])
+            g_mag[mask2] = np.linalg.norm(g[mask2], axis=1)
+            # g_mag = np.linalg.norm(g[mask2], axis=1)
+            g[g_mag > 0.] /= g_mag[g_mag > 0, None]
+            # multiply displacement vector by the displacement magnitude for
+            # step
+            g *= (1. / steps) * d[:, None]
+
+            # apply displacement
+            newp[mask, :] += g
+        return newp

LoopStructural/modelling/features/__init__.py

@@ -0,0 +1,8 @@
+# from .faulted_geological_feature import FaultedGeologicalFeature
+from .geological_feature import GeologicalFeature
+from .lambda_geological_feature import LambdaGeologicalFeature
+from .geological_feature_builder import GeologicalFeatureInterpolator
+from .region_feature import RegionFeature
+from .structural_frame import StructuralFrame
+from .structural_frame_builder import StructuralFrameBuilder
+from .unconformity_feature import UnconformityFeature

LoopStructural/modelling/features/cross_product_geological_feature.py

@@ -0,0 +1,90 @@
+"""
+"""
+import logging
+
+import numpy as np
+
+from LoopStructural.modelling.features.geological_feature import \
+    GeologicalFeature
+
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
+
+
+class CrossProductGeologicalFeature(GeologicalFeature):
+    """[summary]
+
+    [extended_summary]
+
+    Parameters
+    ----------
+    GeologicalFeature : [type]
+        [description]
+    """
+    def __init__(self, name, geological_feature_a, geological_feature_b):
+        """
+        Create a geological feature for a vector field using the cross
+        product between
+        two existing features
+        Parameters
+        ----------
+        name: feature name
+        geological_feature_a: first feature
+        geological_feature_b: second feature
+        """
+        super().__init__(name, None)
+        self.geological_feature_a = geological_feature_a
+        self.geological_feature_b = geological_feature_b
+        self.value_feature = None
+    def evaluate_gradient(self, locations):
+        """
+        Calculate the gradient of the geological feature by using numpy to
+        calculate the cross
+        product between the two existing feature gradients.
+        This means both features have to be evaluated for the locations
+        Parameters
+        ----------
+        locations
+
+        Returns
+        -------
+
+        """
+        v1 = self.geological_feature_a.evaluate_gradient(locations)
+        # v1 /= np.linalg.norm(v1,axis=1)[:,None]
+        v2 = self.geological_feature_b.evaluate_gradient(locations)
+        # v2 /= np.linalg.norm(v2,axis=1)[:,None]
+        return np.cross(v1,v2,
+                        axisa=1,
+                        axisb=1)
+
+    def evaluate_value(self, evaluation_points):
+        """
+        Return 0 because there is no value for this feature
+        Parameters
+        ----------
+        evaluation_points
+
+        Returns
+        -------
+
+        """
+        values = np.zeros(evaluation_points.shape[0])
+        if self.value_feature is not None:
+            values[:] = self.value_feature.evaluate_value(evaluation_points)
+        return values
+
+    def mean(self):
+        if self.value_feature:
+            return self.value_feature.mean()
+        return 0.
+
+    def min(self):
+        if self.value_feature:
+            return self.value_feature.min()
+        return 0.
+
+    def max(self):
+        if self.value_feature:
+            return self.value_feature.max()
+        return 0.

LoopStructural/modelling/features/geological_feature.py

@@ -0,0 +1,252 @@
+"""
+Geological features
+"""
+import logging
+
+import numpy as np
+
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
+
+
+class GeologicalFeature:
+    """
+    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, interpolator, builder=None, data=None, region=None, type=None, 
+                faults=[], fold = None):
+        """Default constructor for geological feature
+
+        Parameters
+        ----------
+        name: string
+        interpolator : GeologicalInterpolator
+        builder : GeologicalFeatureBuilder
+        data : 
+        region :
+        type :
+        faults : list
+
+        
+        """
+        self.name = name
+        self.interpolator = interpolator
+        self.ndim = 1
+        self.builder = builder
+        self.region = region
+        self.regions = []
+        self.type = type
+        self.faults = faults
+        self.faults_enabled = True
+        self.fold=fold
+        self._attributes = {}
+        self._attributes['feature'] = self
+        self._attributes['builder'] = self.builder
+        self._attributes['faults'] = self.faults
+        if region is None:
+            self.region = 'everywhere'
+        self.model = None
+
+    def __str__(self):
+        return self.name
+
+    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 toggle_faults(self):
+        """
+        Turn the fault off for a feature
+        This function is only really used for debugging or creating methods
+        explanation figures
+
+        Returns
+        -------
+
+        """
+        self.faults_enabled = ~self.faults_enabled
+
+    def add_region(self, region):
+        """
+        Adds a region where the geological feature is active to the model.
+
+        Parameters
+        ----------
+        region : boolean function(x,y,z)
+                returns true if inside region, false if outside
+                can be passed as a lambda function e.g.
+                lambda pos : feature.evaluate_value(pos) > 0
+
+        Returns
+        -------
+
+        """
+        self.regions.append(region)
+
+    def evaluate_value(self, evaluation_points):
+        """
+        Evaluate the scalar field value of the geological feature at the locations
+        specified
+
+        Parameters
+        ----------
+        evaluation_points : numpy array
+            location to evaluate the scalar value
+
+        Returns
+        -------
+        values : numpy array
+            numpy array containing evaluated values
+
+        """
+        #TODO need to add a generic type checker for all methods
+        #if evaluation_points is not a numpy array try and convert
+        #otherwise error
+        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 = np.zeros(evaluation_points.shape[0]).astype(bool)
+        mask[:] = True
+        # check regions
+        for r in self.regions:
+            mask = np.logical_and(mask, r(evaluation_points))
+        # apply faulting after working out which regions are visible
+        if self.faults_enabled:
+            for f in self.faults:
+                evaluation_points = f.apply_to_points(evaluation_points)
+        v[mask] = self.interpolator.evaluate_value(evaluation_points[mask, :])
+        return v
+
+    def evaluate_gradient(self, evaluation_points):
+        """
+
+        Parameters
+        ----------
+        locations : numpy array
+            location where the gradient is being evaluated
+
+        Returns
+        -------
+
+        """
+        self.builder.up_to_date()
+        v = np.zeros(evaluation_points.shape)
+        v[:] = np.nan
+        mask = np.zeros(evaluation_points.shape[0]).astype(bool)
+        mask[:] = True
+        # check regions
+        for r in self.regions:
+            mask = np.logical_and(mask, r(evaluation_points))
+
+        # apply faulting after working out which regions are visible
+        if self.faults_enabled:
+            for f in self.faults:
+                evaluation_points = f.apply_to_points(evaluation_points)
+        v[mask, :] = self.interpolator.evaluate_gradient(evaluation_points)
+
+        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 mean(self):
+        """
+        Calculate average of the support values
+
+        Returns
+        -------
+        mean : double
+            average value of the feature evaluated on a (10,10,10) grid in model area
+
+        """
+        if self.model is None:
+            return 0
+        return np.mean(self.evaluate_value(self.model.regular_grid((10,10,10))))
+
+    def min(self):
+        """
+
+        Returns
+        -------
+        min : double
+            min value of the feature evaluated on a (10,10,10) grid in model area
+        """
+        if self.model is None:
+            return 0
+        return np.nanmin(
+            self.evaluate_value(self.model.regular_grid((10, 10, 10))))
+
+    def max(self):
+        """
+        Calculate average of the support values
+
+        Returns
+        -------
+        max : double
+            max value of the feature evaluated on a (10,10,10) grid in model area
+        """
+        if self.model is None:
+            return 0
+        return np.nanmax(
+            self.evaluate_value(self.model.regular_grid((10, 10, 10))))
+
+