LoopStructural 1.0.3__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
+    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]
@@ -22,22 +24,22 @@ class GeologicalFeatureInterpolator:
     """
     def __init__(self, interpolator, name='Feature', region=None, **kwargs):
         """
-        A builder for a GeologicalFeature will link data to the interpolator
-        and run the interpolation
+        Constructor for a GeologicalFeatureInterpolator
 
         Parameters
         ----------
-        interpolator - a GeologicalInterpolator
+        interpolator : GeologicalInterpolator
+            An empty GeologicalInterpolator
         region : lambda function
             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,33 +47,75 @@ 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
 
         Parameters
         ----------
-        fault FaultSegment
+        fault : FaultSegment
             A faultsegment to add to the geological feature
 
         Returns
         -------
 
         """
+        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
 
         Parameters
         ----------
-        data_frame - pandas data frame
+        data_frame : pd.DataFrame
+            a dataframe containing the data to be added
 
         Returns
         -------
@@ -79,18 +123,43 @@ class GeologicalFeatureInterpolator:
         """
         self.data = data_frame.copy()
 
-    def add_orthogonal_feature(self, feature, w=1., region=None):
-        self.interpolator.add_gradient_orthogonal_constraint(
-            self.interpolator.support.barycentre(),
-            feature.evaluate_gradient(self.interpolator.support.barycentre()),
-            w=w
-        )
+    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
 
+        Parameters
+        ----------
+        feature : GeologicalFeature
+            feature which we want to be orthogonal to
+        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._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
         data in the order they are added
 
+        Parameters
+        -----------
+        constrained : boolean
+        force_constrained : boolean
+
         Returns
         -------
 
@@ -139,38 +208,62 @@ 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()
             self.interpolator.set_value_constraints(value_data)
 
+        # add gradient constraints
         mask = np.all(~np.isnan(data.loc[:, gradient_vec_names()].to_numpy()), axis=1)
         if mask.shape[0]>0:
             gradient_data = data.loc[
             mask, xyz_names() + gradient_vec_names() + weight_name()].to_numpy()
             self.interpolator.set_gradient_constraints(gradient_data)
 
+        # add normal vector data
         mask = np.all(~np.isnan(data.loc[:, normal_vec_names()].to_numpy()), axis=1)
         if mask.shape[0]>0:
             normal_data = data.loc[
                 mask, xyz_names() + normal_vec_names() + weight_name()].to_numpy()
             self.interpolator.set_normal_constraints(normal_data)
 
+        # add tangent data
         mask = np.all(~np.isnan(data.loc[:, tangent_vec_names()].to_numpy()), axis=1)
         if mask.shape[0]>0:
             tangent_data = data.loc[
                 mask, xyz_names() + tangent_vec_names() + weight_name()].to_numpy()
             self.interpolator.set_tangent_constraints(tangent_data)
 
-        self.data_added = True
+        # add interface constraints
+        mask = np.all(~np.isnan(data.loc[:, interface_name()].to_numpy()), axis=1)
+        if mask.shape[0] > 0:
+            interface_data = data.loc[
+                mask, xyz_names() + interface_name() + weight_name()].to_numpy()
+            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
 
         Returns
         -------
-        numpy array
+        np.array((N,4),dtype=double)
         """
         header = xyz_names()+val_name()+weight_name()
         mask = ~np.isnan(self.data.loc[:,val_name()].to_numpy())
@@ -192,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):
         """
@@ -209,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):
         """
@@ -227,8 +320,15 @@ 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)
+        if mask.shape[0] > 0:
+            return self.data.loc[
+                mask, xyz_names() + interface_name() + weight_name()].to_numpy()
+        else:
+            return np.zeros((0,5))
 
     def get_data_locations(self):
         """
@@ -239,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
 
@@ -258,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/region_feature.py

@@ -29,3 +29,6 @@ class RegionFeature:
 
     def name(self):
         return self.name
+
+# class VectorFeature:
+#     def __init__(self, function)

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 \
@@ -46,14 +47,14 @@ class StructuralFrameBuilder:
         # list of interpolators
         # self.interpolators = []
         # Create the interpolation objects by copying the template
-
         if interpolators is None:
-            interpolators = []
-            interpolators.append(interpolator)
-            interpolators.append(interpolator.copy())
-            interpolators.append(interpolator.copy())
-        if interpolators is None and interpolator is None:
-            raise BaseException
+            if interpolator is not None:
+                interpolators = []
+                interpolators.append(interpolator)
+                interpolators.append(interpolator.copy())
+                interpolators.append(interpolator.copy())
+            else:
+                raise BaseException("Missing interpolator")
         # self.builders
         self.builders.append(
             GeologicalFeatureInterpolator(interpolators[0],
@@ -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.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):
         """