LoopStructural 1.0.1__zip

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

@@ -0,0 +1,179 @@
+"""
+structural frame builder
+"""
+
+import logging
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+from LoopStructural.modelling.features.cross_product_geological_feature \
+    import \
+    CrossProductGeologicalFeature
+from LoopStructural.modelling.features import \
+    GeologicalFeatureInterpolator
+from LoopStructural.modelling.features import StructuralFrame
+
+
+class StructuralFrameBuilder:
+    """[summary]
+
+    [extended_summary]
+    """
+    def __init__(self, interpolator=None, interpolators=None, **kwargs):
+        """
+        Class for building a structural frame - has functions to set up the
+        interpolator with
+        data and also orthogonality constraints. Can build a generic
+        structural frame or a
+        subclass of the structural frame if the kwarg `frame` is specified
+
+        Parameters
+        ----------
+        interpolator - a template interpolator for the frame
+        kwargs
+        """
+        self.support = None
+        self.fault_event = None
+        self.name = 'Undefined'
+        # self.region = 'everywhere'
+        self.builders = []
+        if 'name' in kwargs:
+            self.name = kwargs['name']
+            kwargs.pop('name')
+        self.data = [[], [], []]
+        # 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
+        # self.builders
+        self.builders.append(
+            GeologicalFeatureInterpolator(interpolators[0],
+                                          name=self.name + '_0',
+                                          **kwargs))  # ,region=self.region))
+        self.builders.append(
+            GeologicalFeatureInterpolator(interpolators[1],
+                                          name=self.name + '_1',
+                                          **kwargs))  # ,region=self.region))
+        self.builders.append(
+            GeologicalFeatureInterpolator(interpolators[2],
+                                          name=self.name + '_2',
+                                          **kwargs))  # ,region=self.region))
+
+    def __getitem__(self, item):
+        return self.builders[item]
+
+    def add_data_from_data_frame(self, data_frame):
+        """
+        extract the data for a fault from a data frame
+
+        Parameters
+        ----------
+        data_frame
+
+        Returns
+        -------
+
+        """
+        for i in range(3):
+            self.builders[i].add_data_from_data_frame(data_frame.loc[data_frame['coord'] == i,:])
+
+
+    def build(self, w1=1., w2=1., w3=1., frame=StructuralFrame, **kwargs):
+        """
+        Build the structural frame
+        Parameters
+        ----------
+        solver solver to use
+        frame - type of frame to build StructuralFrame or FoldFrame
+        w3
+        w2
+        w1
+        kwargs
+
+        Returns
+        -------
+
+        """
+        gxxgy = 1
+        gxxgz = 1
+        gyxgz = 1
+        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.])
+        # initialise features as none then where data exists build
+        gx_feature = None
+        gy_feature = None
+        gz_feature = None
+        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)
+            # remove fold from kwargs
+
+            fold = kwargs.pop('fold', False)
+        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 'data_region' in kwargs:
+                kwargs.pop('data_region')
+            if 'region' in kwargs:
+                kwargs.pop('region')
+        if len(self.builders[2].data) > 0:
+            logger.info("Building %s coordinate 2"%self.name)
+            # if gy_feature is not None:
+            #     self.builders[
+            #     2].interpolator.add_gradient_orthogonal_constraint(
+            #         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 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 gy_feature is None:
+            logger.warning(
+                "Not enough constraints for structural frame coordinate 1, \n"
+                "Add some more and try again.")
+
+        if len(self.builders[2].data) == 0:
+            if gy_feature is not None:
+                logger.debug(
+                    "Creating analytical structural frame coordinate 2")
+                gz_feature = CrossProductGeologicalFeature(self.name + '_2',
+                                                           gy_feature,
+                                                           gx_feature)
+            if gy_feature is None or gx_feature is None:
+                logger.warning(
+                    "Not enough constraints for fold frame coordinate 1, \n"
+                    "Add some more and try again.")
+        # use the frame argument to build a structural frame
+        return frame(self.name, [gx_feature, gy_feature, gz_feature],fold=fold)

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

@@ -0,0 +1,69 @@
+"""
+
+"""
+class UnconformityFeature:
+    """
+    
+    """
+    def __init__(self, feature, value):
+        """
+
+        Parameters
+        ----------
+        feature
+        value
+        """
+        self.feature = feature
+        self.value = value
+        self.type = 'unconformity'
+        self.name = '{}_unconformity'.format(feature.name)
+
+    def add_region(self, region):
+        # self.feature.add_region(region)
+        pass
+    def set_model(self, model):
+        self.model = model
+
+    def evaluate(self,pos):
+        """
+
+        Parameters
+        ----------
+        pos : numpy array
+            locations to evaluate whether below or above unconformity
+
+        Returns
+        -------
+        boolean
+            true if above the unconformity, false if below
+        """
+        return self.feature.evaluate_value(pos) < self.value
+
+    def evaluate_value(self,pos):
+        """
+
+        Parameters
+        ----------
+        pos : numpy array
+            locations to evaluate the value of the base geological feature
+
+        Returns
+        -------
+
+        """
+        return self.feature.evaluate_value(pos)
+
+    def evaluate_gradient(self,pos):
+        """
+
+        Parameters
+        ----------
+        pos : numpy array
+            location to evaluate the gradient of the base geological feature
+
+        Returns
+        -------
+
+        """
+        return self.feature.evaluate_gradient(pos)
+

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

@@ -0,0 +1,8 @@
+"""
+
+"""
+from .fold import FoldEvent
+from .svariogram import SVariogram
+from .fold_rotation_angle_feature import FoldRotationAngleFeature, fourier_series
+from .foldframe import FoldFrame
+from .fold_rotation_angle import FoldRotationAngle

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

@@ -0,0 +1,135 @@
+import logging
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class FoldEvent:
+    """
+
+    """
+    def __init__(self, foldframe, fold_axis_rotation=None, fold_limb_rotation=None, fold_axis=None, name='Fold'):
+        """
+        A fold event describes the geometry of the fold using a fold frame
+        and two geometrical descriptors
+
+        Parameters
+        ----------
+        foldframe the fold frame object
+        fold_axis_rotation function for the fold axis rotation angle
+        fold_limb_rotation function for the fold limb rotation angle
+        """
+
+        self.foldframe = foldframe
+        self.fold_axis_rotation = fold_axis_rotation
+        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
+
+        Parameters
+        ----------
+        points locations to calculate fold axis numpy array Nx3
+
+        Returns
+        -------
+
+        """
+        # evaluate fold axis from rotation angle
+        if self.fold_axis_rotation is not None:
+            logger.info("Using fold_axis_rotation function")
+            # get the gz direction
+            dgx = self.foldframe.features[0].evaluate_gradient(points)
+            dgy = self.foldframe.features[1].evaluate_gradient(points)
+            dgx /= np.linalg.norm(dgx, axis=1)[:, None]
+            dgy /= np.linalg.norm(dgy, axis=1)[:, None]
+            # get gy
+            gy = self.foldframe.features[1].evaluate_value(points)
+            R1 = self.rot_mat(-dgx, self.fold_axis_rotation(gy))
+            fold_axis = np.einsum('ijk,ki->kj', R1, dgy)
+            fold_axis /= np.linalg.norm(fold_axis, axis=1)[:, None]
+            return fold_axis
+
+        # use constant fold axis
+        if self.fold_axis is not None:
+            logger.info("Using constant fold axis")
+            return np.tile(self.fold_axis, (points.shape[0], 1))
+
+    def get_deformed_orientation(self, points):
+        """
+        Calculate the normal to the folded foliation at locations
+
+        Parameters
+        ----------
+        points - np.array
+            location Nx3 array of x,y,z locations to evaluate fold
+
+        Returns
+        -------
+
+        """
+        fold_axis = self.get_fold_axis_orientation(points)
+        gx = self.foldframe.features[0].evaluate_value(points)
+        dgx = self.foldframe.features[0].evaluate_gradient(points)
+        dgx /= np.linalg.norm(dgx, axis=1)[:, None]
+        dgz = np.cross(dgx,fold_axis,axisa=1,axisb=1)
+        # dgz = self.foldframe.features[2].evaluate_gradient(points)
+        dgz /= np.linalg.norm(dgz, axis=1)[:, None]
+
+        R2 = self.rot_mat(fold_axis, self.fold_limb_rotation(gx))
+        fold_direction = np.einsum('ijk,ki->kj', R2, dgx)
+        fold_direction /= np.sum(fold_direction, axis=1)[:, None]
+        # calculate dot product between fold_direction and axis
+        # if its less than 0 then inverse dgz
+        d = np.einsum('ij,ik->i', fold_direction, fold_axis)
+        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 rot_mat(self, axis, angle):
+        """
+        Create a rotation matrix for axis and angle
+
+        Parameters
+        ----------
+        axis Nx3 vector for axis
+        angle N array for angle in degrees
+
+        Returns 3,3,N rotation matrix
+        -------
+
+        """
+        c = np.cos(np.deg2rad(angle))
+        s = np.sin(np.deg2rad(angle))
+        C = 1.0 - c
+        x = axis[:, 0]
+        y = axis[:, 1]
+        z = axis[:, 2]
+        xs = x * s
+        ys = y * s
+        zs = z * s
+        xC = x * C
+        yC = y * C
+        zC = z * C
+        xyC = x * yC
+        yzC = y * zC
+        zxC = z * xC
+        rotation_mat = np.zeros((3, 3, len(angle)))
+        rotation_mat[0, 0, :] = x * xC + c
+        rotation_mat[0, 1, :] = xyC - zs
+        rotation_mat[0, 2, :] = zxC + ys
+
+        rotation_mat[1, 0, :] = xyC + zs
+        rotation_mat[1, 1, :] = y * yC + c
+        rotation_mat[1, 2, :] = yzC - xs
+
+        rotation_mat[2, 0, :] = zxC - ys
+        rotation_mat[2, 1, :] = yzC + xs
+        rotation_mat[2, 2, :] = z * zC + c
+        return rotation_mat

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

@@ -0,0 +1,132 @@
+import logging
+
+import numpy as np
+from scipy.optimize import curve_fit
+
+from LoopStructural.modelling.fold.fold_rotation_angle_feature import \
+    fourier_series
+from LoopStructural.modelling.fold import SVariogram
+
+logger = logging.getLogger(__name__)
+
+
+class FoldRotationAngle:
+    """
+
+    """
+    def __init__(self, rotation_angle, fold_frame_coordinate, svario=False):
+        """
+
+        Parameters
+        ----------
+        rotation_angle
+        fold_frame_coordinate
+        svario
+        """
+        self.rotation_angle = rotation_angle
+        self.fold_frame_coordinate = fold_frame_coordinate
+        self.fold_rotation_function = None
+        self.svario = None
+        if svario:
+            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):
+        """
+
+        Parameters
+        ----------
+        wl
+        lags
+        nlag
+        lag
+
+        Returns
+        -------
+
+        """
+        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 wl is None:
+            wl = self.svario.find_wavelengths(lags=lags, nlag=nlag, lag=lag)
+            # for now only consider single fold wavelength
+            wl = wl[0]
+        guess = np.zeros(4)
+        guess[3] = wl  # np.max(limb_wl)
+        logger.info(
+            'Guess: %f %f %f %f' % (guess[0], guess[1], guess[2], guess[3]))
+        # mask nans
+        mask = np.logical_or(~np.isnan(self.fold_frame_coordinate), ~np.isnan(self.rotation_angle))
+        logger.info(
+            "There are %i nans for the fold limb rotation angle and "
+            "%i observations" % (np.sum(~mask), np.sum(mask)))
+        if np.sum(mask) < len(guess):
+            logger.error(
+                "Not enough data points to fit Fourier series setting "
+                "fold rotation angle"
+                "to 0")
+            self.fold_rotation_function = lambda x: np.zeros(x.shape)
+        else:
+            try:
+                # try fitting using wavelength guess
+                popt, pcov = curve_fit(fourier_series,
+                                       self.fold_frame_coordinate[mask],
+                                       np.tan(np.deg2rad(self.rotation_angle[mask])),
+                                       guess)
+            except RuntimeError:
+                try:
+                    # if fitting failed, try with just 0s
+                    logger.info("Running curve fit without initial guess")
+                    popt, pcov = curve_fit(fourier_series,
+                                           self.fold_frame_coordinate[mask],
+                                           np.tan(np.deg2rad(self.rotation_angle[mask])))
+                except RuntimeError:
+                    # otherwise set the fourier series parameters to 0
+                    popt = guess
+                    logger.error(
+                        "Could not fit curve to S-Plot, check the wavelength")
+            logger.info(
+                'Fitted: %f %f %f %f' % (popt[0], popt[1], popt[2], popt[3]))
+            self.fold_rotation_function = lambda x: np.rad2deg(
+                np.arctan(
+                    fourier_series(x, popt[0], popt[1], popt[2], popt[3])))
+            self.fitted_params = popt
+
+    def __call__(self, fold_frame_coordinate):
+        """
+
+        Parameters
+        ----------
+        fold_frame_coordinate
+
+        Returns
+        -------
+
+        """
+        return self.fold_rotation_function(fold_frame_coordinate)
+
+    def calculate_misfit(self):
+        """
+
+        Returns
+        -------
+
+        """
+        return np.tan(np.deg2rad(self.rotation_angle)) - np.tan(np.deg2rad(
+            self.__call__(self.fold_frame_coordinate)))
+
+    def set_function(self, function):
+        """
+
+        Parameters
+        ----------
+        function
+
+        Returns
+        -------
+
+        """
+        self. fold_rotation_function = function

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

@@ -0,0 +1,57 @@
+import logging
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class FoldRotationAngleFeature:
+    """
+
+    """
+    def __init__(self, fold_frame, rotation):
+        """
+
+        Parameters
+        ----------
+        fold_frame
+        rotation
+        """
+        self.fold_frame = fold_frame
+        self.rotation = rotation
+
+    def evaluate_value(self, location):
+        """
+
+        Parameters
+        ----------
+        location
+
+        Returns
+        -------
+
+        """
+        s1 = self.fold_frame.features[0].evaluate_value(location)
+        r = self.rotation(s1)
+        return r
+
+
+def fourier_series(x, c0, c1, c2, w):
+    """
+
+    Parameters
+    ----------
+    x
+    c0
+    c1
+    c2
+    w
+
+    Returns
+    -------
+
+    """
+    v = np.array(x.astype(float))
+    # v.fill(c0)
+    v = c0 + c1 * np.cos(2 * np.pi / w * x) + c2 * np.sin(2 * np.pi / w * x)
+    return np.rad2deg(np.arctan(v))