LoopStructural 1.6.1__py3-none-any.whl

LoopStructural/modelling/features/fold/_svariogram.py

@@ -0,0 +1,188 @@
+import numpy as np
+
+from ....utils import getLogger
+
+logger = 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
+        self.wavelength_guess = [None, 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(f"Using lag: {step} kwarg for S-variogram")
+
+        if nlag is not None:
+            nstep = nlag
+            logger.info(f"Using nlag {nstep} kwarg for s-variogram")
+
+            self.lags = np.arange(step / 2.0, 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(f"Using lag kwarg but calculating nlag as {nstep} for s-variogram")
+
+            self.lags = np.arange(step / 2.0, 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.0
+            # find number of steps to cover range in data
+            nstep = int(np.ceil((np.nanmax(self.xdata) - np.nanmin(self.xdata)) / step))
+            if nstep > 200:
+                logger.warning(f"Variogram has too many steps: {nstep}, using 200")
+                maximum = step * nstep
+                nstep = 200
+                step = maximum / nstep
+            self.lags = np.arange(step / 2.0, nstep * step, step)
+            logger.info(
+                f"Using average minimum nearest neighbour distance as lag distance size {step} and using {nstep} lags"
+            )
+        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.0,
+                self.dist < self.lags[i] + tol / 2.0,
+            )
+            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.0)
+            averagey.append((py[i] + py[i + 1]) / 2.0)
+            i += 1  # iterate twice
+        # find the extrema of the average curve
+        px2, py2 = find_peaks_and_troughs(averagex, averagey)
+        wl1 = 0.0
+        wl1py = 0.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] * 0.7:
+                        if py[i + 1] < py[i] * 0.7:
+                            wl1 = px[i]
+                            if wl1 > 0.0:
+                                wl1py = py[i]
+                                break
+        wl2 = 0.0
+        for i in range(len(px2)):
+            if i > 0 and i < len(px2) - 1:
+                if py2[i - 1] < py2[i] * 0.90:
+                    if py2[i + 1] < py2[i] * 0.90:
+                        wl2 = px2[i]
+                        if wl2 > 0.0 and wl2 > wl1 * 2 and wl1py < py2[i]:
+                            break
+        if wl1 == 0.0 and wl2 == 0.0:
+            self.wavelength_guess = [2 * (np.max(self.xdata) - np.min(self.xdata)), 0.0]
+            return self.wavelength_guess
+        if np.isclose(wl1, 0.0):
+            self.wavelength_guess = np.array([wl2 * 2.0, wl1 * 2.0])
+            return self.wavelength_guess
+        # wavelength is 2x the peak on the curve
+        self.wavelength_guess = np.array([wl1 * 2.0, wl2 * 2.0])
+        return self.wavelength_guess

LoopStructural/modelling/input/__init__.py

@@ -0,0 +1,2 @@
+from LoopStructural.modelling.input.map2loop_processor import Map2LoopProcessor
+from LoopStructural.modelling.input.process_data import ProcessInputData

LoopStructural/modelling/input/fault_network.py

@@ -0,0 +1,80 @@
+import numpy as np
+
+
+class FaultNetwork:
+    def __init__(self, faults):
+        """A fault network is a basic graph structure that
+        can return the faults for building a geological model
+
+        Parameters
+        ----------
+        faults : list
+            list of fault names
+        """
+        self.faults = faults
+        self.fault_edge_count = np.zeros(len(faults), dtype=int)
+        self.fault_edges = dict(zip(faults, np.arange(len(faults), dtype=int)))
+        self.fault_edge_properties = {}
+        # connections
+        self.connections = {}
+
+    def add_connection(self, fault1, fault2, properties=None):
+        """fault 1 is younger than fault2
+
+        Parameters
+        ----------
+        fault1 : string
+            name of younger fault
+        fault2 : string
+            name of older fault
+        """
+        self.connections[fault2] = fault1
+        self.fault_edge_properties[(fault1, fault2)] = properties
+        # self.fault_edge_count[self.fault_edges[fault1]] +=1
+        self.fault_edge_count[self.fault_edges[fault1]] += 1
+
+    def get_fault_iterators(self):
+        """
+        Returns
+        -------
+        iterators : list
+            list of fault iterators
+        """
+        fault_idxs = np.where(self.fault_edge_count == 0)[0]
+        iters = []
+        for f in fault_idxs:
+            fault = self.faults[f]
+            iters.append(FaultNetworkIter(fault, self))
+        return iters
+
+
+class FaultNetworkIter:
+    """Iterator object to return the next oldest fault in a fault network following edges"""
+
+    def __init__(self, faultname, fault_network):
+        """[summary]
+
+        Parameters
+        ----------
+        faultname : string
+            unique name of the fault
+        fault_network : FaultNetwork
+            the fault network with edges
+        """
+        self.faultname = faultname
+        self.fault_network = fault_network
+
+    def __next__(self):
+        """next method for iterator
+
+        Returns
+        -------
+        FaultNetworkIterator
+            iterator for the next fault, None if the fault is end of an edge
+        """
+        if self.faultname in self.fault_network.connections:
+            return FaultNetworkIter(
+                self.fault_network.connections[self.faultname], self.fault_network
+            )
+        else:
+            return None

LoopStructural/modelling/input/map2loop_processor.py

@@ -0,0 +1,165 @@
+from .process_data import ProcessInputData
+import numpy as np
+import pandas as pd
+import networkx
+
+from ...utils import getLogger
+
+logger = getLogger(__name__)
+
+
+class Map2LoopProcessor(ProcessInputData):
+    def __init__(self, m2l_directory, use_thickness=None):
+        """Function to build a ProcessInputData object for using m2l data
+
+        Parameters
+        ----------
+        m2l_directory : path
+            path to a m2l root directory
+        """
+        groups = pd.read_csv(f"{m2l_directory}/tmp/all_sorts_clean.csv", index_col=0)
+        orientations = pd.read_csv(f"{m2l_directory}/output/orientations_clean.csv")
+        formation_thickness = pd.read_csv(
+            f"{m2l_directory}/output/formation_summary_thicknesses.csv"
+        )
+        contacts = pd.read_csv(m2l_directory + "/output/contacts_clean.csv")
+        fault_displacements = pd.read_csv(f"{m2l_directory}/output/fault_displacements3.csv")
+        fault_orientations = pd.read_csv(f"{m2l_directory}/output/fault_orientations.csv")
+        fault_locations = pd.read_csv(m2l_directory + "/output/faults.csv")
+        fault_strat = pd.read_csv(f"{m2l_directory}/output/supergroup-fault-relationships.csv")
+        fault_dimensions = pd.read_csv(
+            f"{m2l_directory}/output/fault_dimensions.csv", index_col="Fault"
+        )
+        fault_graph = networkx.read_gml(f"{m2l_directory}/tmp/fault_network.gml")
+        fault_orientations.rename(columns={"formation": "fault_name"}, inplace=True)
+
+        bb = np.loadtxt(f"{m2l_directory}/tmp/bbox.csv", skiprows=1, delimiter=",")
+        fault_dimensions["displacement"] = np.nan
+        fault_dimensions["downthrow_dir"] = np.nan
+        fault_dimensions["dip_dir"] = np.nan
+        for fname in fault_dimensions.index:
+            fault_dimensions.loc[fname, "displacement"] = fault_displacements.loc[
+                fault_displacements["fname"] == fname, "vertical_displacement"
+            ].max()
+            fault_dimensions.loc[fname, "downthrow_dir"] = fault_displacements.loc[
+                fault_displacements.loc[
+                    fault_displacements["fname"] == fname, "vertical_displacement"
+                ].idxmax(),
+                "downthrow_dir",
+            ]
+            fault_dimensions.loc[fname, "dip_dir"] = fault_orientations.loc[
+                fault_orientations["fault_name"] == fname, "DipDirection"
+            ].median()
+        fault_properties = fault_dimensions.rename(
+            columns={
+                "Fault": "fault_name",
+                "InfluenceDistance": "minor_axis",
+                "VerticalRadius": "intermediate_axis",
+                "HorizontalRadius": "major_axis",
+            }
+        )
+        self.process_downthrow_direction(fault_properties, fault_orientations)
+        fault_orientations["strike"] = fault_orientations["DipDirection"] + 90
+        fault_edge_properties = []
+        for e in fault_graph.edges():
+            fault_edge_properties.append({"angle": fault_graph.get_edge_data(*e)["angle"]})
+
+        fault_locations.rename(columns={"formation": "fault_name"}, inplace=True)
+        contacts.rename(columns={"formation": "name"}, inplace=True)
+        orientations.rename(columns={"formation": "name"}, inplace=True)
+        fault_stratigraphy = None
+        # make sure supergroups are in the groups dataframe
+
+        supergroups = {}
+        with open(f"{m2l_directory}/tmp/super_groups.csv") as f:
+            for line in f:
+
+                i = 0
+                for g in line.strip(",\n").split(","):
+                    supergroups[g] = "supergroup_{}".format(i)
+                i += 1
+        if "supergroup" not in groups.columns:
+            groups["supergroup"] = "none"
+            for i in groups.index:
+                groups.loc[i, "supergroup"] = supergroups[groups.loc[i, "group"]]
+        # create an ordered list of stratigraphic groups for interpolation,
+        # name of the scalar field will be the name in 'supergroups' column
+        stratigraphic_order = []
+        supergroup = groups.loc[0, "supergroup"]
+        tmp = []
+        for i in groups.index:
+            if supergroup != groups.loc[i, "supergroup"]:
+                stratigraphic_order.append((supergroup, tmp))
+                supergroup = groups.loc[i, "supergroup"]
+                tmp = []
+            tmp.append(groups.loc[i, "code"])
+
+        stratigraphic_order.append((supergroup, tmp))
+
+        # stratigraphic_order = [list(groups['code'])]
+        thicknesses = dict(
+            zip(
+                list(formation_thickness["formation"]),
+                list(formation_thickness["thickness median"]),
+            )
+        )
+        fault_properties["colour"] = "black"
+        if (
+            np.sum(orientations["polarity"] == 0) > 0
+            and np.sum(orientations["polarity"] == -1) == 0
+        ):
+            orientations.loc[orientations["polarity"] == 0, "polarity"] = -1
+
+        fault_stratigraphy = {}
+        for strat in fault_strat["supergroup"].unique():
+            mask = (fault_strat.loc[fault_strat["supergroup"] == strat, :] == 1).to_numpy()
+            fault_stratigraphy[strat] = fault_strat.columns[mask[0, :]].tolist()
+        super().__init__(
+            contacts,
+            orientations,
+            stratigraphic_order,
+            thicknesses=thicknesses,
+            fault_orientations=fault_orientations,
+            fault_locations=fault_locations,
+            fault_properties=fault_properties,
+            fault_edges=list(fault_graph.edges),
+            colours=dict(zip(groups["code"], groups["colour"])),
+            fault_stratigraphy=fault_stratigraphy,
+            intrusions=None,
+            use_thickness=use_thickness,
+            fault_edge_properties=fault_edge_properties,
+        )
+        self.origin = bb[[0, 1, 4]]
+        self.maximum = bb[[2, 3, 5]]
+
+    def process_downthrow_direction(self, fault_properties, fault_orientations):
+        """Helper function to update the dip direction given downthrow direction
+
+        Fault dip direction should point to the hanging wall
+
+        Parameters
+        ----------
+        fault_properties : DataFrame
+            data frame with fault name as index and downthrow direction
+            and average dip_dir as columns
+        fault_orientations : DataFrame
+            orientation data for the faults
+        """
+        for fname in fault_properties.index:
+            if fault_properties.loc[fname, "downthrow_dir"] == 1.0:
+                logger.info(f"{fname}: Estimating downthrow direction using fault intersections")
+            # fault_intersection_angles[f]
+            if (
+                np.abs(
+                    fault_properties.loc[fname, "downthrow_dir"]
+                    - fault_properties.loc[fname, "dip_dir"]
+                )
+                > 90
+            ):
+                fault_orientations.loc[
+                    fault_orientations["fault_name"] == fname, "DipDirection"
+                ] -= 180
+                fault_properties.loc[fname, "dip_dir"] -= 180
+
+
+#