LoopStructural 1.6.23__tar.gz

loopstructural-1.6.23/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Lachlan Grose 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

loopstructural-1.6.23/LoopStructural/__init__.py

@@ -0,0 +1,102 @@
+"""
+LoopStructural
+==============
+
+"""
+
+import logging
+from logging.config import dictConfig
+
+from dataclasses import dataclass
+
+
+__all__ = ["GeologicalModel"]
+import tempfile
+from pathlib import Path
+from .version import __version__
+
+experimental = False
+ch = logging.StreamHandler()
+formatter = logging.Formatter("%(levelname)s: %(asctime)s: %(filename)s:%(lineno)d -- %(message)s")
+ch.setFormatter(formatter)
+ch.setLevel(logging.WARNING)
+loggers = {}
+@dataclass
+class LoopStructuralConfig:
+    """Configuration for LoopStructural package.
+
+    This dataclass holds configuration parameters for the LoopStructural
+    geological modelling package.
+
+    Parameters
+    ----------
+    nelements : int, optional
+        The default number of elements to use in interpolation, by default 10_000
+
+    Examples
+    --------
+    >>> config = LoopStructuralConfig(nelements=50000)
+    >>> config.nelements
+    50000
+    """
+   
+    nelements: int = 10_000
+
+from .modelling.core.geological_model import GeologicalModel
+from .modelling.core.stratigraphic_column import StratigraphicColumn
+from .modelling.core.fault_topology import FaultTopology
+from .interpolators._api import LoopInterpolator
+from .interpolators import InterpolatorBuilder
+from .datatypes import BoundingBox
+from .utils import log_to_console, log_to_file, getLogger, rng, get_levels
+
+logger = getLogger(__name__)
+logger.info("Imported LoopStructural")
+
+
+def setLogging(level="info", handler=None):
+    """Set the logging parameters for log file or custom handler.
+
+    Parameters
+    ----------
+    level : str, optional
+        Logging level to set, by default "info"
+        Valid options: 'info', 'warning', 'error', 'debug'
+    handler : logging.Handler, optional
+        A logging handler to use instead of the default StreamHandler, by default None
+
+    Examples
+    --------
+    >>> import LoopStructural
+    >>> LoopStructural.setLogging('debug')
+    >>> LoopStructural.setLogging('info', logging.FileHandler('loop.log'))
+    """
+    import LoopStructural
+
+    levels = get_levels()
+    level_value = levels.get(level, logging.WARNING)
+
+    # Create default handler if none provided
+    if handler is None:
+        handler = logging.StreamHandler()
+
+    formatter = logging.Formatter(
+        "%(levelname)s: %(asctime)s: %(filename)s:%(lineno)d -- %(message)s"
+    )
+    handler.setFormatter(formatter)
+    handler.setLevel(level_value)
+
+    # Replace handlers in all known loggers
+    for name in LoopStructural.loggers:
+        logger = logging.getLogger(name)
+        logger.handlers = []
+        logger.addHandler(handler)
+        logger.setLevel(level_value)
+
+    # Also apply to main module logger
+    main_logger = logging.getLogger(__name__)
+    main_logger.handlers = []
+    main_logger.addHandler(handler)
+    main_logger.setLevel(level_value)
+
+    main_logger.info(f"Set logging to {level}")

loopstructural-1.6.23/LoopStructural/datasets/__init__.py

@@ -0,0 +1,24 @@
+"""
+Demo Datasets
+=============
+
+Various datasets used for documentation and tutorials.
+"""
+
+from ._base import load_claudius
+from ._base import load_grose2017
+from ._base import load_grose2018
+from ._base import load_grose2019
+from ._base import load_laurent2016
+from ._base import load_noddy_single_fold
+from ._base import load_intrusion
+from ._base import normal_vector_headers
+from ._base import strike_dip_headers
+from ._base import value_headers
+from ._base import load_unconformity
+from ._base import load_duplex
+from ._base import load_tabular_intrusion
+from ._base import load_geological_map_data
+from ._base import load_fault_trace
+from ._base import load_horizontal
+from ._base import load_horizontal_v

loopstructural-1.6.23/LoopStructural/datasets/_base.py

@@ -0,0 +1,342 @@
+from os.path import dirname, join
+from pathlib import Path
+from typing import Tuple
+import numpy as np
+import pandas as pd
+
+
+def load_horizontal() -> Tuple[pd.DataFrame, np.ndarray]:
+    """Synthetic model for horizontal layers
+
+    Returns
+    -------
+    Tuple[pd.DataFrame, np.ndarray]
+        dataframe with feature_name 'strati', bounding box array
+    """
+    bb = np.array([[0, 0, 0], [10, 10, 10]])
+    xy = np.mgrid[0:10, 0:10].reshape(2, -1).T
+    data = pd.DataFrame(
+        np.vstack(
+            [
+                np.hstack(
+                    [
+                        xy,
+                        np.zeros(xy.shape[0])[:, None] + 2,
+                        np.zeros(xy.shape[0])[:, None] + 2,
+                    ]
+                ),
+                np.hstack(
+                    [
+                        xy,
+                        np.zeros(xy.shape[0])[:, None] + 3,
+                        np.zeros(xy.shape[0])[:, None] + 3,
+                    ]
+                ),
+            ]
+        ),
+        columns=["X", "Y", "Z", "val"],
+    )
+
+    data["feature_name"] = "strati"
+    return data, bb
+
+
+def load_horizontal_v(v=0.5) -> Tuple[pd.DataFrame, np.ndarray]:
+    """Synthetic model for horizontal layers
+
+    Returns
+    -------
+    Tuple[pd.DataFrame, np.ndarray]
+        dataframe with feature_name 'strati', bounding box array
+    """
+    import numpy as np
+    import pandas as pd
+
+    bb = np.array([[0, 0, 0], [10, 10, 10]])
+    xy = np.mgrid[0:10, 0:10].reshape(2, -1).T
+    data = pd.DataFrame(
+        np.vstack(
+            [
+                np.hstack(
+                    [
+                        xy,
+                        np.zeros(xy.shape[0])[:, None] + 2,
+                        np.zeros(xy.shape[0])[:, None] + 2,
+                    ]
+                ),
+                np.hstack(
+                    [
+                        xy,
+                        np.zeros(xy.shape[0])[:, None]
+                        + 3 + v +
+                        + np.sin(np.pi / 6 * xy[:, [0]] + np.pi / 2) * v,
+                        np.zeros(xy.shape[0])[:, None] + 3,
+                    ]
+                ),
+            ]
+        ),
+        columns=["X", "Y", "Z", "val"],
+    )
+
+    data["feature_name"] = "strati"
+    return data, bb
+
+
+def load_claudius():
+    """Model dataset sampled from 3D seismic data
+
+
+    Returns
+    -------
+    tuple
+        pandas data frame with loopstructural dataset and numpy array for bounding box
+    """
+    module_path = dirname(__file__)
+    data = pd.read_csv(join(module_path, Path("data/claudius.csv")))
+    bb = np.loadtxt(join(module_path, Path("data/claudiusbb.txt")))
+    return data, bb
+
+
+def load_noddy_single_fold():
+    """Model dataset for plunging cylindrical fold
+
+
+    Returns
+    -------
+    tuple
+        pandas data frame with loopstructural dataset and numpy array for bounding box
+    """
+
+    module_path = dirname(__file__)
+    data = pd.read_csv(join(module_path, Path("data/onefolddata.csv")))
+    bb = np.loadtxt(join(module_path, Path("data/onefoldbb.txt")))
+    return data, bb
+
+
+def load_laurent2016():
+    """Model dataset for refolded fold
+
+
+    Returns
+    -------
+    tuple
+        pandas data frame with loopstructural dataset and numpy array for bounding box
+    """
+    module_path = dirname(__file__)
+    data = pd.read_csv(join(module_path, Path("data/refolded_fold.csv")))
+    bb = np.loadtxt(join(module_path, Path("data/refolded_bb.txt")))
+    return data, bb
+
+
+def load_duplex():
+    """Model dataset for synthetic duplex example
+
+
+    Returns
+    -------
+    tuple
+        pandas data frame with loopstructural dataset and numpy array for bounding box
+    """
+    module_path = dirname(__file__)
+    data = pd.read_csv(join(module_path, Path("data/duplex.csv")))
+    bb = np.loadtxt(join(module_path, Path("data/duplexbb.txt")))
+    return data, bb
+
+
+def load_grose2017():
+    """Model dataset for Cape Conran
+
+
+    Returns
+    -------
+    tuple
+        pandas data frame with loopstructural dataset and numpy array for bounding box
+    """
+    pass
+
+
+def load_grose2018():
+    """Model dataset for synthetic parasitic fold series
+
+
+    Returns
+    -------
+    tuple
+        pandas data frame with loopstructural dataset and numpy array for bounding box
+    """
+    pass
+
+
+def load_grose2019():
+    """Model dataset for Davenport ranges
+
+
+    Returns
+    -------
+    tuple
+        pandas data frame with loopstructural dataset and numpy array for bounding box
+    """
+    pass
+
+
+def load_intrusion():
+    """Model dataset for a faulted intrusion
+
+
+    Returns
+    -------
+    tuple
+        pandas data frame with loopstructural dataset and numpy array for bounding box
+    """
+    module_path = dirname(__file__)
+    data = pd.read_csv(join(module_path, Path("data/intrusion.csv")))
+    bb = np.loadtxt(join(module_path, Path("data/intrusionbb.txt")))
+    return data, bb
+
+
+def load_unconformity():
+    """Model dataset sampled for a model containing an unconformity
+
+
+    Returns
+    -------
+    tuple
+        pandas data frame with loopstructural dataset and numpy array for bounding box
+    """
+    module_path = dirname(__file__)
+    data = pd.read_csv(join(module_path, Path("data/unconformity.csv")))
+    bb = np.array([[0, 0, 0], [4, 6, 4]])
+    return data, bb
+
+
+def value_headers():
+    """Default pandas column names for location and value
+
+    Returns
+    -------
+    list
+        X,Y,Z,val
+    """
+
+    return ["X", "Y", "Z", "val"]
+
+
+def strike_dip_headers():
+    """Default pandas column names for location and strike and dip
+
+    Returns
+    -------
+    list
+        X,Y,Z,strike,dip
+    """
+    return ["X", "Y", "Z", "strike", "dip"]
+
+
+def normal_vector_headers():
+    """Default pandas column names for location and normal vector
+
+    Returns
+    -------
+    list
+        X,Y,Z,nx,ny,nz
+    """
+    return ["X", "Y", "Z", "nx", "ny", "nz"]
+
+
+def load_tabular_intrusion():
+    """Model dataset sampled for a model of a tabular intrusion
+
+
+    Returns
+    -------
+    tuple
+        pandas data frame with loopstructural dataset and numpy array for bounding box
+    """
+    module_path = dirname(__file__)
+    data = pd.read_csv(join(module_path, Path("data/tabular_intrusion.csv")))
+    bb = np.array([[0, 0, 0], [5, 5, 5]])
+    return data, bb
+
+
+def load_geological_map_data():
+    """An example dataset to use the processinput data class
+
+    Returns
+    -------
+    tuple
+        (
+        contacts,
+        stratigraphic_orientations,
+        stratigraphic_thickness,
+        stratigraphic_order,
+        bbox,
+        fault_locations,
+        fault_orientations,
+        fault_properties,
+        fault_edges,
+    )
+    """
+    module_path = dirname(__file__)
+    contacts = pd.read_csv(join(module_path, Path("data/geological_map_data/contacts.csv")))
+    stratigraphic_orientations = pd.read_csv(
+        join(module_path, Path("data/geological_map_data/stratigraphic_orientations.csv"))
+    )
+    stratigraphic_thickness = pd.read_csv(
+        join(module_path, Path("data/geological_map_data/stratigraphic_thickness.csv")),
+        skiprows=1,
+        names=["name", "thickness"],
+    )
+    stratigraphic_order = pd.read_csv(
+        join(module_path, Path("data/geological_map_data/stratigraphic_order.csv")),
+        skiprows=1,
+        names=["order", "unit name"],
+    )
+    bbox = pd.read_csv(
+        join(module_path, Path("data/geological_map_data/bbox.csv")),
+        index_col=0,
+        header=None,
+        names=["X", "Y", "Z"],
+    )
+    fault_properties = pd.read_csv(
+        join(module_path, Path("data/geological_map_data/fault_displacement.csv")),
+        index_col=0,
+    )
+    fault_edges = []
+    with open(join(module_path, Path("data/geological_map_data/fault_edges.txt")), "r") as f:
+        for l in f.read().split("\n"):
+            faults = l.split(",")
+            if len(faults) == 2:
+                fault_edges.append((faults[0], faults[1]))
+    fault_locations = pd.read_csv(
+        join(module_path, Path("data/geological_map_data/fault_locations.csv"))
+    )
+    fault_orientations = pd.read_csv(
+        join(module_path, Path("data/geological_map_data/fault_orientations.csv"))
+    )
+    return (
+        contacts,
+        stratigraphic_orientations,
+        stratigraphic_thickness,
+        stratigraphic_order,
+        bbox,
+        fault_locations,
+        fault_orientations,
+        fault_properties,
+        fault_edges,
+    )
+
+
+def load_fault_trace():
+    """Load the fault trace dataset, requires geopandas
+
+    Returns
+    -------
+    GeoDataFrame
+        dataframe of a shapefile for two faults
+    """
+    import geopandas
+
+    module_path = dirname(__file__)
+
+    fault_trace = geopandas.read_file(join(module_path, Path("data/fault_trace/fault_trace.shp")))
+    return fault_trace

loopstructural-1.6.23/LoopStructural/datasets/_example_models.py

@@ -0,0 +1,10 @@
+vis = True
+try:
+    pass
+except:
+    print("No visualisation")
+    vis = False
+
+
+def _build_claudius():
+    pass