LoopStructural 1.0.4__zip

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

@@ -0,0 +1,286 @@
+"""
+Geological features
+"""
+import logging
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class GeologicalFeature:
+    """
+    Geological feature is class that is used to represent a geometrical element in a geological
+    model. For example foliations, fault planes, fold rotation angles etc. 
+    
+    Attributes
+    ----------
+    name : string
+        should be a unique name for the geological feature
+    support : a ScalarField
+        holds the property values for the feature and links to the
+        support geometry
+    data : list
+        list containing geological data
+    region : list 
+        list of boolean functions defining whether the feature is
+        active
+    faults : list 
+        list of FaultSegments that affect this feature
+    """
+    def __init__(self, name, interpolator, builder=None, data=None, region=None, type=None, 
+                faults=[], fold = None):
+        """Default constructor for geological feature
+
+        Parameters
+        ----------
+        name: string
+        interpolator : GeologicalInterpolator
+        builder : GeologicalFeatureBuilder
+        data : 
+        region :
+        type :
+        faults : list
+
+        
+        """
+        self.name = name
+        self.interpolator = interpolator
+        self.ndim = 1
+        self.data = data
+        self.builder = builder
+        self.region = region
+        self.regions = []
+        self.type = type
+        self.faults = faults
+        self.faults_enabled = True
+        self.fold=fold
+        self._attributes = {}
+        self._attributes['feature'] = self
+        self._attributes['builder'] = self.builder
+        self._attributes['faults'] = self.faults
+        if region is None:
+            self.region = 'everywhere'
+        self.model = None
+
+    def __str__(self):
+        return self.name
+
+    def __getitem__(self,key):
+        return self._attributes[key]
+
+    def __setitem__(self, key, item):
+        self._attributes[key] = item
+
+    def set_model(self, model):
+        self.model = model
+
+    def toggle_faults(self):
+        """
+        Turn the fault off for a feature
+        This function is only really used for debugging or creating methods
+        explanation figures
+
+        Returns
+        -------
+
+        """
+        self.faults_enabled = ~self.faults_enabled
+
+    def add_region(self, region):
+        """
+        Adds a region where the geological feature is active to the model.
+
+        Parameters
+        ----------
+        region : boolean function(x,y,z)
+                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 set_builder(self, builder):
+        """
+
+        Parameters
+        ----------
+        builder : GeologicalFeatureInterpolator
+            the builder associated with this feature
+
+        Returns
+        -------
+
+        """
+        self.builder = builder
+
+    def evaluate_value(self, evaluation_points):
+        """
+        Evaluate the scalar field value of the geological feature at the locations
+        specified
+
+        Parameters
+        ----------
+        evaluation_points : numpy array
+            location to evaluate the scalar value
+
+        Returns
+        -------
+        values : numpy array
+            numpy array containing evaluated values
+
+        """
+
+        # check if the points are within the display region
+        v = np.zeros(evaluation_points.shape[0])
+        v[:] = np.nan
+        mask = np.zeros(evaluation_points.shape[0]).astype(bool)
+        mask[:] = True
+        # check regions
+        for r in self.regions:
+            mask = np.logical_and(mask, r(evaluation_points))
+        # apply faulting after working out which regions are visible
+        if self.faults_enabled:
+            for f in self.faults:
+                evaluation_points = f.apply_to_points(evaluation_points)
+        v[mask] = self.interpolator.evaluate_value(evaluation_points[mask, :])
+        return v
+
+    def evaluate_gradient(self, evaluation_points):
+        """
+
+        Parameters
+        ----------
+        locations : numpy array
+            location where the gradient is being evaluated
+
+        Returns
+        -------
+
+        """
+        v = np.zeros(evaluation_points.shape)
+        v[:] = np.nan
+        mask = np.zeros(evaluation_points.shape[0]).astype(bool)
+        mask[:] = True
+        # check regions
+        for r in self.regions:
+            mask = np.logical_and(mask, r(evaluation_points))
+
+        # apply faulting after working out which regions are visible
+        if self.faults_enabled:
+            for f in self.faults:
+                evaluation_points = f.apply_to_points(evaluation_points)
+        v[mask, :] = self.interpolator.evaluate_gradient(evaluation_points)
+
+        return v
+
+    def evaluate_gradient_misfit(self):
+        """
+
+        Returns
+        -------
+        misfit : np.array(N,dtype=double)
+            dot product between interpolated gradient and constraints
+        """
+        grad = self.interpolator.get_gradient_constraints()
+        norm = self.interpolator.get_norm_constraints()
+
+        dot = []
+        if grad.shape[0] > 0:
+            grad /=np.linalg.norm(grad,axis=1)[:,None]
+            model_grad = self.evaluate_gradient(grad[:,:3])
+            dot.append(np.einsum('ij,ij->i',model_grad,grad[:,:3:6]).tolist())
+
+        if norm.shape[0] > 0:
+            norm /=np.linalg.norm(norm,axis=1)[:,None]
+            model_norm = self.evaluate_gradient(norm[:, :3])
+            dot.append(np.einsum('ij,ij->i', model_norm, norm[:,:3:6]))
+
+        return np.array(dot)
+
+    def evaluate_value_misfit(self):
+        """
+
+        Returns
+        -------
+        misfit : np.array(N,dtype=double)
+            difference between interpolated scalar field and value constraints
+        """
+        locations = self.interpolator.get_value_constraints()
+        diff = np.abs(locations[:, 3] - self.evaluate_value(locations[:, :3]))
+        diff/=(self.max()-self.min())
+        return diff
+
+    def mean(self):
+        """
+        Calculate average of the support values
+
+        Returns
+        -------
+        mean : double
+            average value of the feature evaluated on a (10,10,10) grid in model area
+
+        """
+        if self.model is None:
+            return 0
+        return np.mean(self.evaluate_value(self.model.regular_grid((10,10,10))))
+
+    def min(self):
+        """
+
+        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
+        return np.nanmin(
+            self.evaluate_value(self.model.regular_grid((10, 10, 10))))
+
+    def max(self):
+        """
+        Calculate average of the support values
+
+        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
+        -------
+        interpolator : GeologicalInterpolator
+        """
+        return self.interpolator
+
+

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

@@ -0,0 +1,329 @@
+"""
+Feature builder
+"""
+import copy
+import logging
+
+import numpy as np
+import pandas as pd
+
+logger = logging.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
+
+
+class GeologicalFeatureInterpolator:
+    """[summary]
+
+    [extended_summary]
+    """
+    def __init__(self, interpolator, name='Feature', region=None, **kwargs):
+        """
+        Constructor for a GeologicalFeatureInterpolator
+
+        Parameters
+        ----------
+        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)
+        # 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)
+        else:
+            self.region = region
+        header = xyz_names()+val_name()+gradient_vec_names()+\
+                 normal_vec_names()+tangent_vec_names()+weight_name()
+        self.data = pd.DataFrame(columns=header)
+        self.faults = []
+        self.data_added = False
+        self.interpolator.set_region(region=self.region)
+
+    def update(self):
+        pass
+
+    def add_fault(self, fault):
+        """
+        Add a fault to the geological feature builder
+
+        Parameters
+        ----------
+        fault : FaultSegment
+            A faultsegment to add to the geological feature
+
+        Returns
+        -------
+
+        """
+        self.faults.append(fault)
+
+    def add_data_from_data_frame(self, data_frame):
+        """
+        Extract data from a pandas dataframe with columns for
+
+        Parameters
+        ----------
+        data_frame : pd.DataFrame
+            a dataframe containing the data to be added
+
+        Returns
+        -------
+
+        """
+        self.data = data_frame.copy()
+
+    def add_orthogonal_feature(self, feature, w=1., region=None):
+        """
+        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
+
+        Returns
+        -------
+
+        """
+        self.interpolator.add_gradient_orthogonal_constraint(
+            self.interpolator.support.barycentre(),
+            feature.evaluate_gradient(self.interpolator.support.barycentre()),
+            w=w
+        )
+
+    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
+        -------
+
+        """
+        # first move the data for the fault
+        logger.info("Adding %i faults to %s" % (len(self.faults), self.name))
+        data = self.data.copy()
+        # convert data locations to numpy array and then update
+        for f in self.faults:
+            data.loc[:,xyz_names()] = f.apply_to_points(
+                self.get_data_locations())
+        # Now check whether there are enough constraints for the
+        # interpolator to be able to solve
+        # we need at least 2 different value points or a single norm
+        # constraint. If there are not enough
+        # try converting grad to norms, if still not enough send user an error
+        if constrained:
+            # Change normals to gradients
+            mask = np.all(~np.isnan(data.loc[:, normal_vec_names()]),axis=1)
+            if mask.shape[0] > 0:
+                data.loc[mask, gradient_vec_names()] = data.loc[mask,
+                                                            normal_vec_names()].to_numpy()
+                data.loc[mask, normal_vec_names()] = np.nan
+        if self.get_norm_constraints().shape[0] > 0:
+            constrained = True
+
+        if np.unique(self.get_value_constraints()[:,3]).shape[0]>1:
+            constrained = True
+
+        if not constrained or force_constrained:
+            # change gradient constraints to normal vector constraints
+            mask = np.all(~np.isnan(data.loc[:, gradient_vec_names()]), axis=1)
+            if mask.shape[0] > 0:
+
+                data.loc[mask, normal_vec_names()] = data.loc[mask,
+                                                            gradient_vec_names()].to_numpy()
+                data.loc[mask, gradient_vec_names()] = np.nan
+                logger.info(
+                    "Setting gradient points to norm constraints")
+                constrained = True
+                mask = np.all(
+                    ~np.isnan(data.loc[:, normal_vec_names()].to_numpy()),
+                    axis=1)
+
+        if not constrained:
+            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)
+
+        # 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
+
+    def get_value_constraints(self):
+        """
+        Get the value constraints for this geological feature
+
+        Returns
+        -------
+        np.array((N,4),dtype=double)
+        """
+        header = xyz_names()+val_name()+weight_name()
+        mask = ~np.isnan(self.data.loc[:,val_name()].to_numpy())
+        return self.data.loc[mask[:,0],header].to_numpy()
+
+    def get_gradient_constraints(self):
+        """
+        Get the gradient direction constraints
+
+        Returns
+        -------
+        numpy array
+        """
+        mask = np.all(
+            ~np.isnan(self.data.loc[:, gradient_vec_names()].to_numpy()),
+            axis=1)
+        if mask.shape[0] > 0:
+            return self.data.loc[
+                mask, xyz_names() + gradient_vec_names() + weight_name(
+                )].to_numpy()
+        else:
+            return np.zeros(0, 7)
+
+    def get_tangent_constraints(self):
+        """
+
+        Returns
+        -------
+        numpy array
+        """
+        mask = np.all(
+            ~np.isnan(self.data.loc[:, tangent_vec_names()].to_numpy()),
+            axis=1)
+        if mask.shape[0] > 0:
+            return self.data.loc[
+                mask, xyz_names() + tangent_vec_names() + weight_name(
+                )].to_numpy()
+        else:
+            return np.zeros(0, 7)
+
+    def get_norm_constraints(self):
+        """
+        Get the gradient norm constraints
+
+        Returns
+        -------
+        numpy array
+        """
+        mask = np.all(~np.isnan(self.data.loc[:, normal_vec_names()].to_numpy()),
+                      axis=1)
+        if mask.shape[0] > 0:
+            return self.data.loc[
+                mask, xyz_names() + normal_vec_names() + weight_name(
+
+                )].to_numpy()
+        else:
+            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):
+        """
+        Get only the location for all data points
+
+        Returns
+        -------
+
+        """
+        return self.data.loc[:, xyz_names()].to_numpy()
+
+    def build(self, fold=None, fold_weights=None, data_region=None, **kwargs):
+        """
+        Runs the interpolation and builds the geological feature
+
+        Parameters
+        ----------
+        fold : FoldEvent
+        fold_weights : dict
+        data_region : double <1
+            If not none adds a region around the data points to the interpolation
+            with data_region as a buffer
+        kwargs
+
+        Returns
+        -------
+
+        """
+
+        if data_region is not None:
+            xyz = self.get_data_locations()
+            bb, region = get_data_bounding_box(xyz, data_region)
+            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)
+            if 'cgw' not in kwargs:
+                kwargs['cgw'] = 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
+                                 )

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

@@ -0,0 +1,34 @@
+class RegionFeature:
+    """
+    """
+    def __init__(self, function):
+        """
+        Create a GeologicalFeature to represent a region in a model
+        The region is defined by a boolean function on position.
+
+        Parameters
+        ----------
+        function lambda function
+            lambda function true inside region, false outside region
+        
+        """
+        self.function = function
+        self.name = 'region'
+
+    def evaluate_value(self, pos):
+        return self.function(pos).astype(float)
+
+    def mean(self):
+        return 0
+
+    def max(self):
+        return 1
+
+    def min(self):
+        return -1
+
+    def name(self):
+        return self.name
+
+# class VectorFeature:
+#     def __init__(self, function)