LoopStructural 1.0.3__zip → 1.0.71.dev0__zip

Miniconda/envs/loop/Lib/site-packages/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

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

@@ -1,3 +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

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

@@ -0,0 +1,127 @@
+from ..features.structural_frame_builder import StructuralFrameBuilder
+
+import numpy as np
+class FaultBuilder(StructuralFrameBuilder):
+    def __init__(self,interpolator=None,interpolators=None,**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
+        """
+
+        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])
+
+    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)
+        
+    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_tips[0,0],fault_tips[0,1],fault_tips[0,2],self.name,1,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]
+            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_depth[0,0],fault_depth[0,1],fault_depth[0,2],self.name,1,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
+            data.loc[len(data),['X','Y','Z','feature_name','nx','ny','nz','coord']] =\
+                [fault_center[0],fault_center[1],fault_center[2],self.name,slip_vector[0],slip_vector[1],slip_vector[2],1]
+        # add strike vector to constraint fault extent
+            data.loc[len(data),['X','Y','Z','feature_name','gx','gy','gz','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()

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

@@ -2,7 +2,8 @@ import logging
 
 import numpy as np
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class CubicFunction:

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

@@ -1,6 +1,7 @@
 import logging
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class FaultDisplacementFeature:

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

@@ -2,7 +2,8 @@ import logging
 
 from LoopStructural.modelling.fault.fault_function_feature import FaultDisplacementFeature
 from LoopStructural.modelling.fault.fault_function import BaseFault
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 from concurrent.futures import ThreadPoolExecutor
 import numpy as np
 
@@ -45,7 +46,8 @@ class FaultSegment:
         if self.faultframe is not None:
             self.displacementfeature = FaultDisplacementFeature(
                 self.faultframe, self.faultfunction, name = self.name)
-
+        self.builder = None
+    
     def __getitem__(self, item):
         """
 
@@ -58,7 +60,7 @@ class FaultSegment:
 
         """
         return self.faultframe[item]
-
+    
     def set_model(self, model):
         """
         Link a geological model to the feature
@@ -138,6 +140,10 @@ class FaultSegment:
 
         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
@@ -192,6 +198,27 @@ class FaultSegment:
         # need to scale with fault displacement
         return self.faultframe[1].evaluate_gradient(locations[mask, :])
 
+    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

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

@@ -1,5 +1,6 @@
 # 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

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

@@ -7,7 +7,8 @@ import numpy as np
 from LoopStructural.modelling.features.geological_feature import \
     GeologicalFeature
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class CrossProductGeologicalFeature(GeologicalFeature):
@@ -34,7 +35,7 @@ class CrossProductGeologicalFeature(GeologicalFeature):
         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
@@ -49,8 +50,11 @@ class CrossProductGeologicalFeature(GeologicalFeature):
         -------
 
         """
-        return np.cross(self.geological_feature_a.evaluate_gradient(locations),
-                        self.geological_feature_b.evaluate_gradient(locations),
+        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)
 
@@ -65,13 +69,22 @@ class CrossProductGeologicalFeature(GeologicalFeature):
         -------
 
         """
-        return np.zeros(evaluation_points.shape[0])
+        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.

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

@@ -5,7 +5,8 @@ import logging
 
 import numpy as np
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class GeologicalFeature:
@@ -40,14 +41,13 @@ class GeologicalFeature:
         data : 
         region :
         type :
-        faults :
+        faults : list
 
         
         """
         self.name = name
         self.interpolator = interpolator
         self.ndim = 1
-        self.data = data
         self.builder = builder
         self.region = region
         self.regions = []
@@ -94,7 +94,7 @@ class GeologicalFeature:
         Parameters
         ----------
         region : boolean function(x,y,z)
-                - returns true if inside region, false if outside
+                returns true if inside region, false if outside
                 can be passed as a lambda function e.g.
                 lambda pos : feature.evaluate_value(pos) > 0
 
@@ -104,19 +104,6 @@ class GeologicalFeature:
         """
         self.regions.append(region)
 
-    def set_builder(self, builder):
-        """
-
-        Parameters
-        ----------
-        builder
-
-        Returns
-        -------
-
-        """
-        self.builder = builder
-
     def evaluate_value(self, evaluation_points):
         """
         Evaluate the scalar field value of the geological feature at the locations
@@ -133,7 +120,10 @@ class GeologicalFeature:
             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
@@ -161,6 +151,7 @@ class GeologicalFeature:
         -------
 
         """
+        self.builder.up_to_date()
         v = np.zeros(evaluation_points.shape)
         v[:] = np.nan
         mask = np.zeros(evaluation_points.shape[0]).astype(bool)
@@ -182,8 +173,10 @@ class GeologicalFeature:
 
         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()
 
@@ -205,8 +198,11 @@ class GeologicalFeature:
 
         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())
@@ -218,6 +214,8 @@ class GeologicalFeature:
 
         Returns
         -------
+        mean : double
+            average value of the feature evaluated on a (10,10,10) grid in model area
 
         """
         if self.model is None:
@@ -229,7 +227,8 @@ class GeologicalFeature:
 
         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
@@ -242,38 +241,12 @@ class GeologicalFeature:
 
         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))))
 
-    def update(self):
-        """
-        Calculate average of the support values
-
-        Returns
-        -------
-
-        """
-        # re-run the interpolator and update the support.
-        # this is a bit clumsy and not abstract, i think
-        # if evaluating the property doesn't require the dictionary on
-        # the nodes and actually just uses the interpolator values this
-        # would be
-        # much better.
-        self.interpolator.up_to_date = False
-        self.interpolator.update()
-
-    def get_interpolator(self):
-        """
-        Get the interpolator used to build this feature
-
-        Returns
-        -------
-        GeologicalInterpolator
-        """
-        return self.interpolator
-