LoopStructural 1.0.4__zip → 1.0.71.dev0__zip

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

@@ -7,13 +7,15 @@ import logging
 import numpy as np
 import pandas as pd
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 from LoopStructural.utils.helper import xyz_names, val_name, normal_vec_names, \
     weight_name, gradient_vec_names, tangent_vec_names, interface_name
 from LoopStructural.modelling.features import GeologicalFeature
 from LoopStructural.utils.helper import get_data_bounding_box_map as get_data_bounding_box
-
+from LoopStructural.utils import get_data_axis_aligned_bounding_box
+from LoopStructural.utils import RegionEverywhere
 
 class GeologicalFeatureInterpolator:
     """[summary]
@@ -32,12 +34,12 @@ class GeologicalFeatureInterpolator:
             defining whether the location (xyz) should be included in the
         kwargs - name of the feature, region to interpolate the feature
         """
-        self.interpolator = interpolator
-        self.name = name
-        self.interpolator.set_property_name(self.name)
+        self._interpolator = interpolator
+        self._name = name
+        self._interpolator.set_property_name(self._name)
         # everywhere region is just a lambda that returns true for all locations
         if region is None:
-            self.region = lambda pos: np.ones(pos.shape[0], dtype=bool)
+            self.region = RegionEverywhere()
         else:
             self.region = region
         header = xyz_names()+val_name()+gradient_vec_names()+\
@@ -45,11 +47,51 @@ class GeologicalFeatureInterpolator:
         self.data = pd.DataFrame(columns=header)
         self.faults = []
         self.data_added = False
-        self.interpolator.set_region(region=self.region)
+        self._interpolator.set_region(region=self.region)
+        self._feature = None
+        self._up_to_date = False
+        self._build_arguments = {}
+        self.fold = None
+        self._feature = GeologicalFeature(self._name,
+                                 self._interpolator,
+                                 builder=self, 
+                                 region=self.region,
+                                 faults=self.faults,
+                                 fold = self.fold
+                                 )
+        self._orthogonal_features = {}
+    @property
+    def feature(self):
+        return self._feature
+
+    @property
+    def build_arguments(self):
+        return self._build_arguments 
+    
+    @build_arguments.setter
+    def build_arguments(self, build_arguments):
+        # self._build_arguments = {}
+        for k, i in build_arguments.items():
+            self._build_arguments[k] = i
 
     def update(self):
-        pass
-
+        self.build(**self.build_arguments)
+    @property
+    def name(self):
+        return self._name
+    @property
+    def interpolator(self):
+        return self._interpolator
+
+    def up_to_date(self):
+        #has anything changed in the builder since we built the feature? if so update
+        if self._up_to_date == False:
+            self.update()
+        #check if the interpolator is up to date, if not solve
+        if self._interpolator.up_to_date == False:
+            self.update()
+        
+        
     def add_fault(self, fault):
         """
         Add a fault to the geological feature builder
@@ -63,9 +105,10 @@ class GeologicalFeatureInterpolator:
         -------
 
         """
+        self._up_to_date = False
         self.faults.append(fault)
 
-    def add_data_from_data_frame(self, data_frame):
+    def add_data_from_data_frame(self, data_frame, overwrite = False):
         """
         Extract data from a pandas dataframe with columns for
 
@@ -80,7 +123,7 @@ class GeologicalFeatureInterpolator:
         """
         self.data = data_frame.copy()
 
-    def add_orthogonal_feature(self, feature, w=1., region=None):
+    def add_orthogonal_feature(self, feature, w=1., region=None,step=1,B=0):
         """
         Add a constraint to the interpolator so that the gradient of an exisitng feature is orthogonal
         to the feature being built. E.g. dot product between gradients should be = 0
@@ -92,17 +135,21 @@ class GeologicalFeatureInterpolator:
         w :  double
             how much to weight in least squares sense
         region : unused
-
+        step : int
+            numpy slicing step size to see how many tetras to add
+        
         Returns
         -------
 
+        Notes
+        -----
+        The constraint can be applied to a random subset of the tetrahedral elements in the mesh
+        in theory this shu
         """
-        self.interpolator.add_gradient_orthogonal_constraint(
-            self.interpolator.support.barycentre(),
-            feature.evaluate_gradient(self.interpolator.support.barycentre()),
-            w=w
-        )
-
+        self._orthogonal_features[feature.name] = [feature,w,region,step,B]
+        self._up_to_date = False
+        
+    
     def add_data_to_interpolator(self, constrained=False, force_constrained=False, **kwargs):
         """
         Iterates through the list of data and applies any faults active on the
@@ -161,7 +208,6 @@ class GeologicalFeatureInterpolator:
             logger.error("Not enough constraints for scalar field add more")
         # self.interpolator.reset()
         mask = ~np.isnan(data.loc[:,val_name()].to_numpy())
-
         # add value constraints
         if mask.shape[0]>0:
             value_data = data.loc[mask[:,0],xyz_names()+val_name()+weight_name()].to_numpy()
@@ -196,7 +242,21 @@ class GeologicalFeatureInterpolator:
             self.interpolator.set_interface_constraints(interface_data)
 
         self.data_added = True
-
+        self._up_to_date = False
+    
+    def install_gradient_constraint(self):
+        for g in self._orthogonal_features.values():
+            feature,w,region,step,B = g
+            vector = feature.evaluate_gradient(self.interpolator.support.barycentre())
+            vector /= np.linalg.norm(vector,axis=1)[:,None]
+            element_idx = np.arange(self.interpolator.support.n_elements)
+            np.random.shuffle(element_idx)
+            self.interpolator.add_gradient_orthogonal_constraint(
+                self.interpolator.support.barycentre()[element_idx[::step],:],
+                vector[element_idx[::step],:],
+                w=w,
+                B=B
+            )
     def get_value_constraints(self):
         """
         Get the value constraints for this geological feature
@@ -225,7 +285,7 @@ class GeologicalFeatureInterpolator:
                 mask, xyz_names() + gradient_vec_names() + weight_name(
                 )].to_numpy()
         else:
-            return np.zeros(0, 7)
+            return np.zeros((0, 7))
 
     def get_tangent_constraints(self):
         """
@@ -242,7 +302,7 @@ class GeologicalFeatureInterpolator:
                 mask, xyz_names() + tangent_vec_names() + weight_name(
                 )].to_numpy()
         else:
-            return np.zeros(0, 7)
+            return np.zeros((0, 7))
 
     def get_norm_constraints(self):
         """
@@ -260,7 +320,7 @@ class GeologicalFeatureInterpolator:
 
                 )].to_numpy()
         else:
-            return np.zeros(0,7)
+            return np.zeros((0,7))
 
     def get_interface_constraints(self):
         mask = np.all(~np.isnan(self.data.loc[:, interface_name()].to_numpy()), axis=1)
@@ -268,7 +328,7 @@ class GeologicalFeatureInterpolator:
             return self.data.loc[
                 mask, xyz_names() + interface_name() + weight_name()].to_numpy()
         else:
-            return np.zeros(0,5)
+            return np.zeros((0,5))
 
     def get_data_locations(self):
         """
@@ -279,8 +339,25 @@ class GeologicalFeatureInterpolator:
 
         """
         return self.data.loc[:, xyz_names()].to_numpy()
+    def set_interpolation_geometry(self,origin,maximum):
+        """Update the interpolation support geometry to new bounding box
 
-    def build(self, fold=None, fold_weights=None, data_region=None, **kwargs):
+        Parameters
+        ----------
+        origin : np.array(3)
+            origin vector
+        maximum : np.array(3)
+            maximum vector
+        """
+        logger.info("Setting mesh origin: {} {} {} ".format(origin[0],origin[1],origin[2]))
+        logger.info("Setting mesh maximum: {} {} {}".format(maximum[0],maximum[1],maximum[2]))
+        self.interpolator.support.origin = origin
+        self.interpolator.support.maximum = maximum
+
+
+        self._up_to_date = False
+
+    def build(self, fold=None, fold_weights={}, data_region=None, **kwargs):
         """
         Runs the interpolation and builds the geological feature
 
@@ -298,32 +375,39 @@ class GeologicalFeatureInterpolator:
 
         """
 
+
+        self.add_data_to_interpolator(**kwargs)
         if data_region is not None:
-            xyz = self.get_data_locations()
-            bb, region = get_data_bounding_box(xyz, data_region)
+            xyz = self.interpolator.get_data_locations()
+            bb, region = get_data_bounding_box(xyz, data_region)    
+            # if self.model.reuse_supports == False:
+            if np.any(np.min(bb[0,:])< self.interpolator.support.origin):
+                neworigin = np.min([self.interpolator.support.origin,bb[0,:]],axis=0)
+                logger.info("Changing origin of support for {} from {} {} {} to {} {} {}"\
+                                .format(self.name,self.interpolator.support.origin[0],\
+                                    self.interpolator.support.origin[1],self.interpolator.support.origin[2],\
+                                                neworigin[0],neworigin[1],neworigin[2]))
+                self.interpolator.support.origin = neworigin
+            if np.any(np.max(bb[0,:])< self.interpolator.support.maximum):
+                newmax = np.max([self.interpolator.support.maximum,bb[0,:]],axis=0)
+                logger.info("Changing origin of support for {} from {} {} {} to {} {} {}"\
+                        .format(self.name,self.interpolator.support.maximum[0],
+                        self.interpolator.support.maximum[1],self.interpolator.support.maximum[2],\
+                                                newmax[0],newmax[1],newmax[2]))
+
+                self.interpolator.support.maximum = newmax
             self.interpolator.set_region(region=region)
-        if not self.data_added:
-            self.add_data_to_interpolator(**kwargs)
-
         # moving this to init because it needs to be done before constraints
         # are added?
         if fold is not None:
             logger.info("Adding fold to %s" % self.name)
             self.interpolator.fold = fold
             # if we have fold weights use those, otherwise just use default
-            if fold_weights is None:
-                self.interpolator.add_fold_constraints()
-            else:
-                self.interpolator.add_fold_constraints(fold_weights)
+            self.interpolator.add_fold_constraints(**fold_weights)
             if 'cgw' not in kwargs:
-                kwargs['cgw'] = 0.
-
+                # try adding very small cg
+                kwargs['cgw'] = 0.0
         self.interpolator.setup_interpolator(**kwargs)
         self.interpolator.solve_system(**kwargs)
-        return GeologicalFeature(self.name,
-                                 self.interpolator,
-                                 builder=self, data=self.data,
-                                 region=self.region,
-                                 faults=self.faults,
-                                 fold = fold
-                                 )
+        self._up_to_date = True
+        return self._feature

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

@@ -0,0 +1,31 @@
+"""
+Geological features
+"""
+import logging
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class LambdaGeologicalFeature:
+    def __init__(self,function = None,name = 'unnamed_lambda', gradient_function = None):
+        self.function = function
+        self.name = name
+        self.gradient_function = gradient_function
+    def evaluate_value(self, xyz):
+        v = np.zeros((xyz.shape[0]))
+        if self.function is None:
+            v[:] =  np.nan
+        else:
+            v[:] = self.function(xyz)
+        return v
+    def evaluate_gradient(self,xyz):
+        v = np.zeros((xyz.shape[0],3))
+        if self.gradient_function is None:
+            v[:,:] =  np.nan
+        else:
+            v[:,:] = self.gradient_function(xyz)
+        return v
+
+    

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

@@ -2,8 +2,9 @@
 Structural frames
 """
 import logging
-
-logger = logging.getLogger(__name__)
+import numpy as np
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class StructuralFrame:
@@ -14,8 +15,7 @@ class StructuralFrame:
     def __init__(self, name, features, fold=None):
         """
         Structural frame is a curvilinear coordinate system defined by
-        structural
-        observations associated with a fault or fold.
+        structural observations associated with a fault or fold.
 
         Parameters
         ----------
@@ -26,6 +26,7 @@ class StructuralFrame:
         self.features = features
         self.data = None
         self.fold = fold
+
     def __getitem__(self, item):
         """
 
@@ -39,6 +40,21 @@ class StructuralFrame:
         """
         return self.features[item]
 
+    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)
+
     def add_region(self, region):
         for i in range(3):
             self.features[i].add_region(region)
@@ -71,7 +87,7 @@ class StructuralFrame:
         """
         self.data = data
 
-    def evaluate_value(self, evaluation_points, i=None):
+    def evaluate_value(self, evaluation_points):
         """
         Evaluate the value of the structural frame for the points.
         Can optionally only evaluate one coordinate
@@ -85,12 +101,13 @@ class StructuralFrame:
         -------
 
         """
-        if i is not None:
-            self.features[i].support.evaluate_value(evaluation_points)
-        return (self.features[0].support.evaluate_value(evaluation_points),
-                self.features[1].support.evaluate_value(evaluation_points),
-                self.features[2].support.evaluate_value(evaluation_points))
-
+        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)
+        v[:,1] = self.features[1].evaluate_value(evaluation_points)
+        v[:,2] = self.features[2].evaluate_value(evaluation_points)
+        return v
+        
     def evaluate_gradient(self, evaluation_points, i=None):
         """
         Evaluate the gradient of the structural frame.

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

@@ -6,7 +6,8 @@ import logging
 
 import numpy as np
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 from LoopStructural.modelling.features.cross_product_geological_feature \
     import \
@@ -106,12 +107,14 @@ class StructuralFrameBuilder:
         gxxgy = 1
         gxxgz = 1
         gyxgz = 1
+        step = kwargs.get('step', 10)
         if 'gxxgy' in kwargs:
             gxxgy = kwargs['gxxgy']
         if 'gxxgz' in kwargs:
             gxxgz = kwargs['gxxgz']
         if 'gyxgz' in kwargs:
             gyxgz = kwargs['gyxgz']
+
         # set regularisation so the the main surface (foliation, fault) is smooth
         # and the fields are allowed to vary more
         regularisation = kwargs.pop('regularisation', [1., 1., 1.])
@@ -122,19 +125,21 @@ class StructuralFrameBuilder:
         fold = None
         if len(self.builders[0].data) > 0:
             logger.info("Building %s coordinate 0"%self.name)
-            gx_feature = self.builders[0].build(regularisation=regularisation[
-                                                    0], **kwargs)
+            gx_feature = self.builders[0].feature
+            kwargs['regularisation']=regularisation[0]
+            self.builders[0].build_arguments = kwargs
+
             # remove fold from kwargs
 
-            fold = kwargs.pop('fold', False)
+            fold = kwargs.pop('fold', None)
         if gx_feature is None:
             logger.warning(
                 "Not enough constraints for structural frame coordinate 0, \n"
                 "Add some more and try again.")
         # make sure that all of the coordinates are using the same region
-        if gx_feature is not None and gx_feature.get_interpolator().region_function is not None:
-            self.builders[1].interpolator.set_region(gx_feature.get_interpolator().region_function)
-            self.builders[2].interpolator.set_region(gx_feature.get_interpolator().region_function)
+        if gx_feature is not None and gx_feature.interpolator.region_function is not None:
+            self.builders[1].interpolator.set_region(gx_feature.interpolator.region_function)
+            self.builders[2].interpolator.set_region(gx_feature.interpolator.region_function)
             if 'data_region' in kwargs:
                 kwargs.pop('data_region')
             if 'region' in kwargs:
@@ -147,17 +152,22 @@ class StructuralFrameBuilder:
             #         np.arange(0, self.support.n_elements),
             #         gy_feature.evaluate_gradient(self.support.barycentre),
             #         w=gyxgz)
-            if gx_feature is not None:
-                self.builders[2].add_orthogonal_feature(gx_feature, gxxgz)
-            gz_feature = self.builders[2].build(regularisation=regularisation[2], **kwargs)
+            if gx_feature is not None and gxxgz>0:
+                self.builders[2].add_orthogonal_feature(gx_feature, gxxgz,step=step)
+            gz_feature = self.builders[2].feature
+            kwargs['regularisation'] = regularisation[2]
+            self.builders[2].build_arguments = kwargs
 
         if len(self.builders[1].data) > 0:
             logger.info("Building %s coordinate 1"%self.name)
-            if gx_feature is not None:
-                self.builders[1].add_orthogonal_feature(gx_feature, gxxgy)
-            if gz_feature is not None:
-                self.builders[1].add_orthogonal_feature(gz_feature, gyxgz)
-            gy_feature = self.builders[1].build(regularisation=regularisation[1], **kwargs)
+            if gx_feature is not None and gxxgy>0:
+                self.builders[1].add_orthogonal_feature(gx_feature, gxxgy,step=step)
+            if gz_feature is not None and gyxgz>0:
+                self.builders[1].add_orthogonal_feature(gz_feature, gyxgz,step=step)
+            gy_feature = self.builders[1].feature
+            kwargs['regularisation'] = regularisation[1]
+            self.builders[1].build_arguments = kwargs
+
 
         if gy_feature is None:
             logger.warning(

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

@@ -17,7 +17,7 @@ class UnconformityFeature:
         self.value = value
         self.type = 'unconformity'
         self.name = '{}_unconformity'.format(feature.name)
-
+        self.builder = self.feature.builder
     def add_region(self, region):
         # self.feature.add_region(region)
         pass
@@ -67,3 +67,8 @@ class UnconformityFeature:
         """
         return self.feature.evaluate_gradient(pos)
 
+    def min(self):
+        return self.feature.min()
+    
+    def max(self):
+        return self.feature.max()

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

@@ -2,7 +2,8 @@ import logging
 
 import numpy as np
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class FoldEvent:
@@ -26,7 +27,7 @@ class FoldEvent:
         self.fold_limb_rotation = fold_limb_rotation
         self.fold_axis = fold_axis
         self.name = name
-
+        
     def get_fold_axis_orientation(self, points):
         """
         gets the fold axis orientation for evaluation points
@@ -61,7 +62,7 @@ class FoldEvent:
 
     def get_deformed_orientation(self, points):
         """
-        Calculate the normal to the folded foliation at locations
+        Calculate the direction vectors of the fold
 
         Parameters
         ----------
@@ -70,6 +71,13 @@ class FoldEvent:
 
         Returns
         -------
+        fold_direction : np.array
+            a vector parallel to the fold
+        fold axis : np.array
+            the fold axis
+        dgz : np.array
+            the X direction of the finite strain ellipsoid, perpendicular to both
+            fold axis and fold direction
 
         """
         fold_axis = self.get_fold_axis_orientation(points)
@@ -89,8 +97,8 @@ class FoldEvent:
         dgz[d < 0] = -dgz[d < 0]
         return fold_direction, fold_axis, dgz
 
-    def get_regularisation_direction(self, points):
-        self.foldframe.features[2].evaluate_gradient(points)
+    # def get_regularisation_direction(self, points):
+    #     self.foldframe.features[2].evaluate_gradient(points)
 
     def rot_mat(self, axis, angle):
         """

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/fold/fold_rotation_angle.py

@@ -7,7 +7,8 @@ from LoopStructural.modelling.fold.fold_rotation_angle_feature import \
     fourier_series
 from LoopStructural.modelling.fold import SVariogram
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class FoldRotationAngle:
@@ -31,7 +32,7 @@ class FoldRotationAngle:
             self.svario = SVariogram(self.fold_frame_coordinate, self.rotation_angle)
         self.fitted_params = None
 
-    def fit_fourier_series(self, wl = None, lags = None, nlag = None, lag = None):
+    def fit_fourier_series(self, wl = None, lags = None, nlag = None, lag = None, skip_variogram=False,**kwargs):
         """
 
         Parameters
@@ -48,8 +49,8 @@ class FoldRotationAngle:
         if self.svario is None:
             self.svario = SVariogram(self.fold_frame_coordinate,
                                      self.rotation_angle)
-
-        self.svario.calc_semivariogram(lags=lags, nlag=nlag, lag=lag)
+        if skip_variogram == False:
+            self.svario.calc_semivariogram(lags=lags, nlag=nlag, lag=lag)
         if wl is None:
             wl = self.svario.find_wavelengths(lags=lags, nlag=nlag, lag=lag)
             # for now only consider single fold wavelength

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/fold/fold_rotation_angle_feature.py

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

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/fold/foldframe.py

@@ -4,7 +4,8 @@ import numpy as np
 
 from LoopStructural.modelling.features.structural_frame import StructuralFrame
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class FoldFrame(StructuralFrame):
@@ -21,10 +22,7 @@ class FoldFrame(StructuralFrame):
         super().__init__(name, features, fold)
         self.model = None
 
-    def set_model(self, model):
-        self.model = model
-
-    def calculate_fold_axis_rotation(self, feature_builder):
+    def calculate_fold_axis_rotation(self, feature_builder,fold_axis=None):
         """
         Calculate the fold axis rotation angle by finding the angle between the
         intersection lineation and the gradient to the 1st coordinate of the
@@ -45,6 +43,9 @@ class FoldFrame(StructuralFrame):
             points.append(gpoints)
         if npoints.shape[0] > 0:
             points.append(npoints)
+        if fold_axis is not None:
+            if fold_axis.shape[0] > 0 and fold_axis.shape[1] == 6:
+                points.append(fold_axis)
         if len(points) == 0:
             return 0, 0
         points = np.vstack(points)

Miniconda/envs/loop/Lib/site-packages/LoopStructural/modelling/fold/svariogram.py

@@ -2,7 +2,8 @@ import logging
 
 import numpy as np
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 def find_peaks_and_troughs(x, y):

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

@@ -11,4 +11,8 @@ Submodules
     utils
 
 """
-from .map2loop import process_map2loop, build_model
+from .logging import getLogger, log_to_file, log_to_console
+from .map2loop import process_map2loop, build_model
+from .helper import get_data_axis_aligned_bounding_box, get_data_bounding_box, get_data_bounding_box_map
+from .helper import get_dip_vector,get_strike_vector, get_vectors
+from .regions import RegionEverywhere