LoopStructural 1.0.4__zip

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))

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

@@ -0,0 +1,192 @@
+import logging
+
+import numpy as np
+
+from LoopStructural.modelling.features.structural_frame import StructuralFrame
+
+logger = logging.getLogger(__name__)
+
+
+class FoldFrame(StructuralFrame):
+    def __init__(self, name, features, fold=None):
+        """
+        A structural frame that can calculate the fold axis/limb rotation angle
+        Same constructor arguments as parent StructuralFrame
+
+        Parameters
+        ----------
+        name
+        features
+        """
+        super().__init__(name, features, fold)
+        self.model = None
+
+    def set_model(self, model):
+        self.model = model
+
+    def calculate_fold_axis_rotation(self, feature_builder):
+        """
+        Calculate the fold axis rotation angle by finding the angle between the
+        intersection lineation and the gradient to the 1st coordinate of the
+        fold frame
+        Parameters
+        ----------
+        feature_builder - GeologicalFeatureInterpolator
+            - the builder for the geological feature that is folded
+
+        Returns
+        -------
+
+        """
+        gpoints = feature_builder.get_gradient_constraints()[:,:6]
+        npoints = feature_builder.get_norm_constraints()[:,:6]
+        points = []
+        if gpoints.shape[0] > 0:
+            points.append(gpoints)
+        if npoints.shape[0] > 0:
+            points.append(npoints)
+        if len(points) == 0:
+            return 0, 0
+        points = np.vstack(points)
+        # We need to ignore the fault when we are calculating the splot because it is done
+        # in the restored space
+        # self.features[0].faults_enabled = False
+        # self.features[1].faults_enabled = False
+        s1g = self.features[0].evaluate_gradient(points[:, :3])
+        s1g /= np.linalg.norm(s1g, axis=1)[:, None]
+        s1gyg = self.features[1].evaluate_gradient(points[:, :3])
+        s1gyg /= np.linalg.norm(s1gyg, axis=1)[:, None]
+        l1 = points[:, 3:]
+        l1 /= np.linalg.norm(l1, axis=1)[:, None]
+        fad = self.features[1].evaluate_value(points[:, :3])
+        # Turn the faults back on
+        # self.features[0].faults_enabled = True
+        # self.features[1].faults_enabled = True
+
+        # project s0 onto axis plane B X A X B
+        projected_l1 = np.cross(s1g, np.cross(l1, s1g, axisa=1, axisb=1),
+                                axisa=1, axisb=1)
+        projected_s1gyg = np.cross(s1g, np.cross(s1gyg, s1g, axisa=1, axisb=1),
+                                   axisa=1, axisb=1)
+
+        # einsum dot product
+        far = np.einsum('ij,ij->i', projected_l1, projected_s1gyg)
+        far = np.rad2deg(np.arccos(far))
+        # scalar triple product
+        stp = np.einsum('ij,ij->i', np.cross(l1, s1gyg, axisa=1, axisb=1), s1g)
+        # check bounds
+        far-=90
+        # far[stp < 0] = 360.- far[stp < 0]
+        far[far>90] = far[far>90]+-180
+        far[far<-90] = far[far<-90]+180
+
+        return far, fad
+
+    def calculate_fold_limb_rotation(self, feature_builder, axis=None):
+        """
+        Calculate the fold limb rotation angle using the axis specified and
+        the normals to the folded foliation
+        Parameters
+        ----------
+        feature_builder - GeologicalFeatureInterpolator
+            the feature interpolator for the folded feature that has the
+            datapoints the fold limb rotation angle is
+            going to be calculated for
+        axis - GeologicalFeature
+            Optional. Fold axis feature that when queried for location
+            returns the fold axis
+
+        Returns
+        -------
+        fold_limb_rotation, coordinate_0
+        """
+        # self.features[0].faults_enabled = False
+        # self.features[1].faults_enabled = False
+
+        gpoints = feature_builder.interpolator.get_gradient_constraints()[:,:6]
+        npoints = feature_builder.interpolator.get_norm_constraints()[:,:6]
+        points = []
+        if gpoints.shape[0] > 0:
+            points.append(gpoints)
+        if npoints.shape[0] > 0:
+            points.append(npoints)
+        if len(points) == 0:
+            logger.error("No points to calculate fold rotation angle")
+            return np.array([0]), np.array([0])
+        points = np.vstack(points)
+        # for f in feature_builder.faults:
+        #     points[:,:3] = f.apply_to_points(points[:,:3])
+        # get the normals from the points array
+        s0g = points[:, 3:]
+
+        s0g/=np.linalg.norm(s0g,axis=1)[:,None]
+        # calculate the gradient and value of the first coordinate of the
+        # fold frame
+        # for the locations and normalise
+        s1g = self.features[0].evaluate_gradient(points[:, :3])
+        s1g /= np.linalg.norm(s1g, axis=1)[:, None]
+        s1 = self.features[0].evaluate_value(points[:, :3])
+        # self.features[0].faults_enabled = True
+        # self.features[1].faults_enabled = True
+
+        if axis is None:
+            logger.info("Not using fold axis for fold limb rotation angle calculation")
+            r2 = np.einsum('ij,ij->i', s1g, s0g)
+
+            return np.rad2deg(np.arcsin(r2)), s1
+        if axis is not None:
+            fold_axis = axis(points[:, :3])
+            # project s0 onto axis plane B X A X B
+            projected_s0 = np.cross(fold_axis,
+                                    np.cross(s0g, fold_axis, axisa=1, axisb=1),
+                                    axisa=1, axisb=1)
+            projected_s1 = np.cross(fold_axis,
+                                    np.cross(s1g, fold_axis, axisa=1, axisb=1),
+                                    axisa=1, axisb=1)
+            projected_s0 /= np.linalg.norm(projected_s0, axis=1)[:, None]
+            projected_s1 /= np.linalg.norm(projected_s1, axis=1)[:, None]
+            r2 = np.einsum('ij,ij->i', projected_s1, projected_s0)  #
+            # adjust the fold rotation angle so that its always between -90
+            # and 90
+            vv = np.cross(s1g, s0g, axisa=1, axisb=1)
+            ds = np.einsum('ij,ij->i', fold_axis, vv)
+            flr = np.where(ds > 0, np.rad2deg(np.arcsin(r2)),
+                           (- np.rad2deg(np.arcsin(r2))))
+            flr = np.where(flr < -90, (180. + flr), flr)
+            flr = np.where(flr > 90, -(180. - flr), flr)
+            return flr, s1
+
+    def calculate_intersection_lineation(self, feature_builder):
+        """
+        Calculate the intersection lineation by finding the cross product
+        between the first fold frame
+        coordinate and the vector representing the normal to the folded
+        foliation
+        Parameters
+        ----------
+        feature_builder - GeologicalFeatureInterpolator
+            the feature builder that contains the data points that the
+            intersection lineation is calculated for
+
+
+        Returns Nx3 array of doubles
+        -------
+
+        """
+        self.features[0].faults_enabled = False
+        gpoints = feature_builder.interpolator.get_gradient_constraints()[:,:6]
+        npoints = feature_builder.interpolator.get_norm_constraints()[:,:6]
+        points = []
+        if gpoints.shape[0] > 0:
+            points.append(gpoints)
+        if npoints.shape[0] > 0:
+            points.append(npoints)
+        points = np.vstack(points)
+        s1g = self.features[0].evaluate_gradient(points[:, :3])
+        s1g /= np.linalg.norm(points[:, :3], axis=1)[:, None]
+        s0g = points[:, 3:]
+        s0g /= np.linalg.norm(s0g, axis=1)[:, None]
+        l1 = np.cross(s1g, s0g, axisa=1, axisb=1)
+        l1 /= np.linalg.norm(l1, axis=1)[:, None]
+        self.features[0].faults_enabled = True
+        return l1

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

@@ -0,0 +1,179 @@
+import logging
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+def find_peaks_and_troughs(x, y):
+    """
+
+    Parameters
+    ----------
+    x np.array or list
+        x axis data for plot
+    y np.array or list
+        y axis data for plot
+    Returns
+    -------
+    (np.array, np.array)
+    Notes
+    -----
+    Returns the loations of maxima/minima on the curve using finite
+    difference forward/backwards
+    finding the change in derivative
+    """
+    if len(x) != len(y):
+        return False
+    pairsx = []
+    pairsy = []
+    # #TODO numpyize
+    for i in range(0, len(x)):
+        if i < 1:
+            pairsx.append(x[i])
+            pairsy.append(y[i])
+
+            continue
+        if i > len(x) - 2:
+            pairsx.append(x[i])
+            pairsy.append(y[i])
+            continue
+        left_grad = (y[i - 1] - y[i]) / (x[i - 1] - x[i])
+        right_grad = (y[i] - y[i + 1]) / (x[i] - x[i + 1])
+        if np.sign(left_grad) != np.sign(right_grad):
+            pairsx.append(x[i])
+            pairsy.append(y[i])
+    return pairsx, pairsy
+
+
+class SVariogram():
+    """
+    The SVariogram is an experimental semi-variogram.
+    """
+
+    def __init__(self, xdata, ydata):
+        self.xdata = xdata
+        self.ydata = ydata
+        self.dist = np.abs(self.xdata[:, None] - self.xdata[None, :])
+        self.variance_matrix = (self.ydata[:, None] - self.ydata[None, :]) ** 2
+        self.lags = None
+        self.variogram = None
+
+    def calc_semivariogram(self, lag = None, nlag = None, lags = None):
+        """
+        Calculate a semi-variogram for the x and y data for this object.
+        You can specify the lags as an array or specify the step size and
+        number of steps.
+        If neither are specified then the lags are created to be the average
+        spacing of the data
+
+        Parameters
+        ----------
+        step:   float
+                lag distance for the s-variogram
+        nstep:  int
+                number of lags for the s-variogram
+        lags:   array
+                num
+
+        Returns
+        -------
+
+        """
+        logger.info("Calculating S-Variogram")
+        if lag is not None:
+            step = lag
+            logger.info("Using lag: %f kwarg for S-variogram"%step)
+
+        if nlag is not None:
+            nstep = nlag
+            logger.info("Using nlag %i kwarg for s-variogram"%nstep)
+
+            self.lags = np.arange(step / 2., nstep * step, step)
+
+        if nlag is None and lag is not None:
+            nstep = int(
+                np.ceil((np.nanmax(self.xdata) - np.nanmin(self.xdata)) / step))
+            logger.info("Using lag kwarg but calculating nlag as %i for s-variogram"%nstep)
+
+            self.lags = np.arange(step / 2., nstep * step, step)
+
+        if lags is not None:
+            self.lags = lags
+
+        if self.lags is None:
+            # time to guess the step size
+            # find the average distance between elements in the input data
+            d = np.copy(self.dist)
+            d[d == 0] = np.nan
+
+            step = np.nanmean(np.nanmin(d, axis=1))*4.
+            # find number of steps to cover range in data
+            nstep = int(
+                np.ceil((np.nanmax(self.xdata) - np.nanmin(self.xdata)) / step))
+            self.lags = np.arange(step / 2., nstep * step, step)
+            logger.info("Using average minimum nearest neighbour distance "
+                        "as lag distance size {} and using {} lags".format(step,nstep))
+        tol = self.lags[1] - self.lags[0]
+        self.variogram = np.zeros(self.lags.shape)
+        self.variogram[:] = np.nan
+        npairs = np.zeros(self.lags.shape)
+        for i in range(len(self.lags)):
+            logic = np.logical_and(self.dist > self.lags[i]
+                                   - tol / 2.,
+                                   self.dist < self.lags[i] + tol / 2.)
+            npairs[i] = np.sum(logic.astype(int))
+            if npairs[i] > 0:
+                self.variogram[i] = np.mean(self.variance_matrix[logic])
+        return self.lags, self.variogram, npairs
+
+    def find_wavelengths(self, **kwargs):
+        """
+        Picks the wavelengths of the fold by finding the maximum and
+        minimums of the s-variogram
+        the fold wavelength is the first minimum but it is more reliable to
+        use the first maximum
+        as the estimate of the wavelength.
+
+        Parameters
+        ----------
+        kwargs : object
+        """
+        h, var, npairs = self.calc_semivariogram(**kwargs)
+
+        px, py = find_peaks_and_troughs(h, var)
+
+        averagex = []
+        averagey = []
+        for i in range(len(px) - 1):
+            averagex.append((px[i] + px[i + 1]) / 2.)
+            averagey.append((py[i] + py[i + 1]) / 2.)
+            i += 1  # iterate twice
+        # find the extrema of the average curve
+        px2, py2 = find_peaks_and_troughs(averagex, averagey)
+        wl1 = 0.
+        wl1py = 0.
+        for i in range(len(px)):
+            if i > 0 and i < len(px) - 1:
+                if py[i] > 10:
+
+                    if py[i - 1] < py[i] * .7:
+                        if py[i + 1] < py[i] * .7:
+                            wl1 = px[i]
+                            if wl1 > 0.:
+                                wl1py = py[i]
+                                break
+        wl2 = 0.
+        for i in range(len(px2)):
+            if i > 0 and i < len(px2) - 1:
+                if py2[i - 1] < py2[i] * .90:
+                    if py2[i + 1] < py2[i] * .90:
+                        wl2 = px2[i]
+                        if wl2 > 0. and wl2 > wl1 * 2 and wl1py < py2[i]:
+                            break
+        if wl1 == 0.0 and wl2 == 0.0:
+            return 2 * (np.max(self.xdata) - np.min(self.xdata)), 0.
+        if np.isclose(wl1, 0.0):
+            return np.array([wl2 * 2., wl1 * 2.])
+        # wavelength is 2x the peak on the curve
+        return np.array([wl1 * 2., wl2 * 2.])

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

@@ -0,0 +1,14 @@
+"""
+This is contains all of the utilities for loop structural
+
+Submodules
+==========
+
+.. autosummary::
+    :toctree: _autosummary
+
+    helper
+    utils
+
+"""
+from .map2loop import process_map2loop, build_model

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

@@ -0,0 +1,9 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+class LoopBaseException(Exception):
+    """
+    Base loop exception
+    """
+    # logger.error("Raising loop base exception")