LoopStructural 1.0.9__cp39-cp39-win32.whl

LoopStructural/modelling/core/stratigraphic_column.py

@@ -0,0 +1,5 @@
+class StratigraphicColumn:
+    def __init__(self):
+        pass
+    def add_series(self,feature,name,maximum,minimum,colour):
+        pass

LoopStructural/modelling/fault/__init__.py

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

LoopStructural/modelling/fault/fault_builder.py

@@ -0,0 +1,143 @@
+from ..features.structural_frame_builder import StructuralFrameBuilder
+
+import numpy as np
+class FaultBuilder(StructuralFrameBuilder):
+    def __init__(self,interpolator=None,interpolators=None,model=None,fault_bounding_box_buffer=0.2,**kwargs):
+        """A specialised structural frame builder for building a fault
+
+        Parameters
+        ----------
+        interpolator : GeologicalInterpolator, optional
+            the interpolator to use for building the fault frame, by default None
+        interpolators : [GeologicalInterpolator, GeologicalInterpolator, GeologicalInterpolator], optional
+            a list of interpolators to use for building the fault frame, by default None
+        model : GeologicalModel
+            reference to the model containing the fault
+        fault_bounding_box_buffer: float, default 0.2
+            the maximum area around the model domain that a fault is modelled. For high displacement faults this
+            may need to be large, smaller values will be result in fewer degrees of freedom = quicker interpolation
+        """
+
+        StructuralFrameBuilder.__init__(self,interpolator,interpolators,**kwargs)
+        self.origin = np.array([np.nan,np.nan,np.nan])
+        self.maximum = np.array([np.nan,np.nan,np.nan])
+        self.model = model
+        # define a maximum area to mesh adding buffer to model
+        buffer = .2
+        self.minimum_origin = self.model.bounding_box[0,:] - buffer*(self.model.bounding_box[1,:]-self.model.bounding_box[0,:])
+        self.maximum_maximum = self.model.bounding_box[1,:] + buffer*(self.model.bounding_box[1,:]-self.model.bounding_box[0,:])
+
+    def update_geometry(self,points):
+        
+        self.origin = np.nanmin(np.array([np.min(points,axis=0),self.origin]),axis=0)
+        self.maximum = np.nanmax(np.array([np.max(points,axis=0),self.maximum]),axis=0)
+        self.origin[self.origin<self.minimum_origin] = self.minimum_origin[self.origin<self.minimum_origin]
+        self.maximum[self.maximum>self.maximum_maximum] = self.maximum_maximum[self.maximum>self.maximum_maximum]
+
+    def create_data_from_geometry(self, 
+                                data,
+                                fault_center, 
+                                normal_vector,
+                                slip_vector,
+                                influence_distance = None,
+                                horizontal_radius = None,
+                                vertical_radius = None):
+        """Generate the required data for building a fault frame for a fault with the 
+        specified parameters
+
+        Parameters
+        ----------
+        data : DataFrame,
+            model data
+        fault_center : np.array(3)
+            x,y,z coordinates of the fault center
+        normal_vector : np.array(3)
+            x,y,z components of normal vector to fault, single observation usually 
+            average direction
+        slip_vector : np.array(3)
+            x,y,z components of slip vector for the fault, single observation usually 
+            average direction
+        influence_distance : double
+            distance away from fault for the fault volume
+        horizontal_radius : double
+            fault extent
+        vertical_radius : double
+            fault volume radius in the slip direction
+        """
+        normal_vector/=np.linalg.norm(normal_vector)
+        slip_vector/=np.linalg.norm(slip_vector)
+        strike_vector = np.cross(normal_vector,slip_vector)
+        fault_edges = np.zeros((2,3))
+        fault_tips = np.zeros((2,3))
+        fault_depth = np.zeros((2,3))
+        if fault_center is not None:
+            if influence_distance is not None:
+                fault_edges[0,:] = fault_center[:3]+normal_vector*influence_distance
+                fault_edges[1,:] = fault_center[:3]-normal_vector*influence_distance
+                self.update_geometry(fault_edges)
+                data.loc[len(data),['X','Y','Z','feature_name','val','coord']] = \
+                    [fault_edges[0,0],fault_edges[0,1],fault_edges[0,2],self.name,1,0]
+                data.loc[len(data),['X','Y','Z','feature_name','val','coord']] = \
+                    [fault_edges[1,0],fault_edges[1,1],fault_edges[1,2],self.name,-1,0]
+            if horizontal_radius is not None:
+                fault_tips[0,:] = fault_center[:3]+strike_vector*horizontal_radius
+                fault_tips[1,:] = fault_center[:3]-strike_vector*horizontal_radius
+                self.update_geometry(fault_tips)
+                data.loc[len(data),['X','Y','Z','feature_name','val','coord']] = \
+                    [fault_center[0],fault_center[1],fault_center[2],self.name,0,2]
+                # data.loc[len(data),['X','Y','Z','feature_name','val','coord']] = \
+                #     [fault_tips[1,0],fault_tips[1,1],fault_tips[1,2],self.name,-1,2]
+                strike_vector /= horizontal_radius
+            if vertical_radius is not None:
+                fault_depth[0,:] = fault_center[:3]+slip_vector*vertical_radius
+                fault_depth[1,:] = fault_center[:3]-slip_vector*vertical_radius
+                data.loc[len(data),['X','Y','Z','feature_name','val','coord']] = \
+                    [fault_center[0],fault_center[1],fault_center[2],self.name,0,1]
+                # data.loc[len(data),['X','Y','Z','feature_name','val','coord']] = \
+                #     [fault_depth[1,0],fault_depth[1,1],fault_depth[1,2],self.name,-1,1]
+                self.update_geometry(fault_depth)
+                #TODO need to add data here
+                slip_vector /= vertical_radius
+
+            data.loc[len(data),['X','Y','Z','feature_name','nx','ny','nz','val','coord']] =\
+                [fault_center[0],fault_center[1],fault_center[2],self.name,slip_vector[0],slip_vector[1],slip_vector[2],0,1]
+        # add strike vector to constraint fault extent
+            data.loc[len(data),['X','Y','Z','feature_name','nx','ny','nz','coord']] = [fault_center[0],fault_center[1],fault_center[2],\
+                self.name, strike_vector[0], strike_vector[1], strike_vector[2], 2]
+        self.add_data_from_data_frame(data)
+    def set_mesh_geometry(self,buffer):
+        """set the mesh geometry
+
+        Parameters
+        ----------
+        buffer : double 
+            percentage of length to add to edges
+        """
+        length = self.maximum-self.origin
+        # origin = self.builders[0].interpolator.support.origin
+        # maximum = self.builders[0].interpolator.support.maximum#set_interpolation_geometry
+        # if origin[2]>self.origin[2]:
+        #     origin[2]=self.origin[2]
+        # if maximum[2]<self.maximum[2]:
+        #     maximum[2]=self.maximum[2]
+        # self.builders[0].set_interpolation_geometry(origin,maximum)
+        # for builder in self.builders:
+        # all three coordinates share the same support
+        self.builders[0].set_interpolation_geometry(self.origin-length*buffer,self.maximum+length*buffer)
+            
+    def add_splay(self,splayregion,splay):
+        # for i in range(3):
+        #     # work out the values of the nodes where we want hard
+        #     # constraints
+        #     idc = np.arange(0, interpolator.support.n_nodes)[
+        #         kwargs['splayregion'](interpolator.support.nodes)]
+        #     val = kwargs['splay'][i].evaluate_value(
+        #         interpolator.support.nodes[
+        #         kwargs['splayregion'](interpolator.support.nodes), :])
+        #     mask = ~np.isnan(val)
+        #     fault_frame_builder[i].interpolator.add_equality_constraints(
+        #         idc[mask], val[mask])
+        pass
+    def update(self):
+        for i in range(3):
+            self.builders[i].update()

LoopStructural/modelling/fault/fault_function.py

@@ -0,0 +1,188 @@
+import logging
+
+import numpy as np
+
+from LoopStructural.utils import getLogger
+logger = 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)

LoopStructural/modelling/fault/fault_function_feature.py

@@ -0,0 +1,76 @@
+import logging
+
+from LoopStructural.utils import getLogger
+logger = 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