LoopStructural 1.0.4__zip

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/fault/__init__.py

@@ -0,0 +1,3 @@
+from .fault_function import Composite, CubicFunction, Ones, Zeros
+from .fault_function_feature import FaultDisplacementFeature
+from .fault_segment import FaultSegment

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/fault/fault_function.py

@@ -0,0 +1,187 @@
+import logging
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class CubicFunction:
+    """
+
+    """
+    def __init__(self):
+        """
+        Class to represent a cubic function
+        """
+        self.A = []  # np.zeros((4,4))
+        self.B = []  # np.zeros((4))
+        self.max_v = 999999
+        self.min_v = -99999
+        self.w = None
+
+    def add_cstr(self, x, y):
+        self.A.append([x ** 3, x ** 2, x, 1.])
+        self.B.append(y)
+
+    def add_grad(self, x, g):
+        self.A.append([3 * x ** 2, 2 * x, 1., 0.])
+        self.B.append(g)
+
+    def add_max(self, max_v):
+        self.max_v = max_v
+
+    def add_min(self, min_v):
+        self.min_v = min_v
+
+    def __call__(self, v):
+        if len(self.B) < 3:
+            print("underdetermined")
+            return
+        if self.w is None:
+            A = np.array(self.A)
+            B = np.array(self.B)
+            ATA = A.T @ A
+            ATB = A.T @ B
+            self.w = np.linalg.lstsq(ATA, ATB, rcond=None)[0]
+        eva = self.w[0] * v ** 3 + self.w[1] * v ** 2 + self.w[2] * v + self.w[
+            3]
+        eva[v > self.max_v] = self.w[0] * self.max_v ** 3 + \
+                              self.w[1] * self.max_v ** 2 + self.w[
+                                  2] * self.max_v + self.w[3]
+        eva[v < self.min_v] = self.w[0] * self.min_v ** 3 + \
+                              self.w[1] * self.min_v ** 2 + self.w[
+                                  2] * self.min_v + self.w[3]
+        return eva
+
+
+class Composite():
+    """
+
+    """
+    def __init__(self, positive, negative):
+        self.positive = positive
+        self.negative = negative
+
+    def __call__(self, v):
+        v = np.array(v)
+        r = np.zeros(v.shape)
+        r[v > 0] = self.positive(v[v > 0])
+        r[v < 0] = self.negative(v[v < 0])
+        return r
+
+
+class Ones:
+    """
+
+    """
+    def __init__(self):
+        pass
+
+    def __call__(self, v):
+        v = np.array(v)
+        return np.ones(v.shape)
+
+
+class Zeros:
+    """
+
+    """
+    def __init__(self):
+        pass
+
+    def __call__(self, v):
+        v = np.array(v)
+        return np.zeros(v.shape)
+
+
+class FaultDisplacement:
+    """
+
+    """
+    def __init__(self, hw=None, fw=None, gx=None, gy=None, gz=None, **kwargs):
+        self.gx = gx
+        if hw is not None and fw is not None:
+            self.__gx = Composite(hw, fw)
+        self.gy = gy
+        self.gz = gz
+        self.gx_bounds = None
+        self.gy_bounds = None
+        self.gz_bounds = None
+
+        if self.gx == None:
+            print('Gx function none setting to ones')
+            self.gx = Ones()
+        if self.gy == None:
+            print('Gy function none setting to ones')
+            self.gy = Ones()
+        if self.gz == None:
+            print('Gz function none setting to ones')
+            self.gz = Ones()
+        if 'gxmax' in kwargs and 'gxmin' in kwargs:
+            self.gx_bounds = (kwargs['gxmin'], kwargs['gxmax'])
+
+        if 'gymax' in kwargs and 'gymin' in kwargs:
+            self.gy_bounds = (kwargs['gymin'], kwargs['gymax'])
+
+        if 'gzmax' in kwargs and 'gzmin' in kwargs:
+            self.gz_bounds = (kwargs['gzmin'], kwargs['gzmax'])
+
+    def __call__(self, gx, gy, gz):
+        if self.gx_bounds is not None:
+            mid =(self.gx_bounds[1]+self.gx_bounds[0])/2.
+            gx = (gx -mid) / (self.gx_bounds[1]-self.gx_bounds[0])
+        if self.gy_bounds is not None:
+            mid =  (self.gy_bounds[1]+self.gy_bounds[0])/2.
+            gy = (gy -mid) / (self.gy_bounds[1]-self.gy_bounds[0])
+        if self.gz_bounds is not None:
+            mid =(self.gz_bounds[1]+self.gz_bounds[0])/2.
+            gz = (gz -mid) / (self.gz_bounds[1]-self.gz_bounds[0])
+        return self.gx(gx)*self.gy(gy)*self.gz(gz)
+
+    def evaluate(self, gy, gz):
+        if self.gy_bounds is not None:
+            mid =  (self.gy_bounds[1]+self.gy_bounds[0])/2.
+            gy = (gy -mid) / (self.gy_bounds[1]-self.gy_bounds[0])
+        if self.gz_bounds is not None:
+            mid =(self.gz_bounds[1]+self.gz_bounds[0])/2.
+            gz = (gz -mid) / (self.gz_bounds[1]-self.gz_bounds[0])
+        return self.gy(gy)*self.gz(gz)
+
+
+class BaseFault(object):
+    """
+
+    """
+    hw = CubicFunction()
+    hw.add_cstr(0, 1)
+    hw.add_grad(0, 0)
+    hw.add_cstr(1, 0)
+    # hw.add_cstr(1,1)
+
+    hw.add_grad(1, 0)
+    hw.add_max(1)
+    fw = CubicFunction()
+    fw.add_cstr(0, -1)
+    fw.add_grad(0, 0)
+    fw.add_cstr(-1, 0)
+    fw.add_grad(-1, 0)
+    fw.add_min(-1)
+    # gyf = CubicFunction()
+    # gyf.add_cstr(-1, 0)
+    # gyf.add_cstr(1, 0)
+    # gyf.add_cstr(-0.2, 1)
+    # gyf.add_cstr(0.2, 1)
+    # gyf.add_grad(0, 0)
+    # gyf.add_min(-1)
+    # gyf.add_max(1)
+    gyf = Ones()
+    gzf = CubicFunction()
+    gzf.add_cstr(-1, 0)
+    gzf.add_cstr(1, 0)
+    gzf.add_cstr(-0.2, 1)
+    gzf.add_cstr(0.2, 1)
+    gzf.add_grad(0, 0)
+    gzf.add_min(-1)
+    gzf.add_max(1)
+    gxf = Composite(hw, fw)
+    fault_displacement = FaultDisplacement(gx=gxf, gy=gyf, gz=gzf)

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/fault/fault_function_feature.py

@@ -0,0 +1,75 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class FaultDisplacementFeature:
+    """
+
+    """
+    def __init__(self, fault_frame, displacement, name = 'fault_displacement'):
+        """
+        Geological feature representing the fault displacement
+
+        Parameters
+        ----------
+        fault_frame - geometry of the fault
+        displacement - function defining fault displacement
+        """
+        self.fault_frame = fault_frame
+        self.displacement = displacement
+        self.name = name +'_displacement'
+
+    def evaluate_value(self, location):
+        """
+        Return the value of the fault displacement
+
+        Parameters
+        ----------
+        location
+
+        Returns
+        -------
+
+        """
+        fault_suface = self.fault_frame.features[0].evaluate_value(location)
+        fault_displacement = self.fault_frame.features[1].evaluate_value(
+            location)
+        fault_strike = self.fault_frame.features[2].evaluate_value(location)
+        d = self.displacement(fault_suface, fault_displacement, fault_strike)
+        return d
+
+    def evaluate_gradient(self, location):
+        """
+        get the scaled displacement
+
+        Parameters
+        ----------
+        location
+
+        Returns
+        -------
+
+        """
+        fault_suface = self.fault_frame.features[0].evaluate_value(location)
+        fault_displacement = self.fault_frame.features[1].evaluate_value(
+            location)
+        fault_strike = self.fault_frame.features[2].evaluate_value(location)
+        d = self.displacement(fault_suface, fault_displacement, fault_strike)
+        return d
+
+    def min(self):
+        return -1
+
+    def max(self):
+        return 1
+
+    def evaluate_on_surface(self, location):
+        fault_displacement = self.fault_frame.features[1].evaluate_value(
+            location)
+        fault_strike = self.fault_frame.features[2].evaluate_value(location)
+        d = self.displacement.evaluate(fault_displacement, fault_strike)
+        return d
+
+    def mean(self):
+        return 0

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/fault/fault_segment.py

@@ -0,0 +1,270 @@
+import logging
+
+from LoopStructural.modelling.fault.fault_function_feature import FaultDisplacementFeature
+from LoopStructural.modelling.fault.fault_function import BaseFault
+logger = logging.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)
+
+    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 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))
+        return self.faultframe[0].evaluate_value(locations[mask, :])
+
+    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[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))
+        # need to scale with fault displacement
+        return self.faultframe[1].evaluate_gradient(locations[mask, :])
+
+    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
+

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/features/__init__.py

@@ -0,0 +1,7 @@
+# from .faulted_geological_feature import FaultedGeologicalFeature
+from .geological_feature import GeologicalFeature
+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

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/features/cross_product_geological_feature.py

@@ -0,0 +1,77 @@
+"""
+"""
+import logging
+
+import numpy as np
+
+from LoopStructural.modelling.features.geological_feature import \
+    GeologicalFeature
+
+logger = logging.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
+
+    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
+        -------
+
+        """
+        return np.cross(self.geological_feature_a.evaluate_gradient(locations),
+                        self.geological_feature_b.evaluate_gradient(locations),
+                        axisa=1,
+                        axisb=1)
+
+    def evaluate_value(self, evaluation_points):
+        """
+        Return 0 because there is no value for this feature
+        Parameters
+        ----------
+        evaluation_points
+
+        Returns
+        -------
+
+        """
+        return np.zeros(evaluation_points.shape[0])
+
+    def mean(self):
+        return 0.
+
+    def min(self):
+        return 0.
+
+    def max(self):
+        return 0.