LoopStructural 1.6.1__py3-none-any.whl

LoopStructural/export/gocad.py

@@ -0,0 +1,126 @@
+import numpy as np
+
+
+def _write_feat_surfs_gocad(surf, file_name):
+    """
+    Writes out a GOCAD TSURF file for each surface in list
+
+    Parameters
+    ----------
+    surf_list: [ SimpleNamespace() ... ]
+        Details of the surfaces, as a list of SimpleNamespace() objects. Fields are:
+            verts: vertices, numpy ndarray with dtype = float64 & shape = (N,3)
+            faces: faces, numpy ndarray with dtype = int32 & shape = (M,3)
+            values: values, numpy ndarray with dtype = float32 & shape = (N,)
+            normals: normals, numpy ndarray with dtype = float32 & shape = (N,3)
+            name: name of feature e.g. fault or supergroup, string
+
+    file_name: string
+        Desired filename
+
+    Returns
+    -------
+    True if successful
+
+    """
+    from pathlib import Path
+
+    properties_header = None
+    if surf.properties:
+
+        properties_header = f"""PROPERTIES {' '.join(list(surf.properties.keys()))}
+NO_DATA_VALUES -99999
+PROPERTY_CLASSES {' '.join(list(surf.properties.keys()))}
+        """
+
+    file_name = Path(file_name).with_suffix(".ts")
+    with open(f"{file_name}", "w") as fd:
+        fd.write(
+            f"""GOCAD TSurf 1 
+HEADER {{
+*solid*color: #ffa500
+ivolmap: false
+imap: false
+name: {surf.name}
+}}
+GOCAD_ORIGINAL_COORDINATE_SYSTEM
+NAME Default
+PROJECTION Unknown
+DATUM Unknown
+AXIS_NAME X Y Z
+AXIS_UNIT m m m
+ZPOSITIVE Elevation
+END_ORIGINAL_COORDINATE_SYSTEM
+GEOLOGICAL_FEATURE {surf.name}
+GEOLOGICAL_TYPE fault
+{properties_header if properties_header else ""}
+PROPERTY_CLASS_HEADER X {{
+kind: X
+unit: m
+}}
+PROPERTY_CLASS_HEADER Y {{
+kind: Y
+unit: m
+}}
+PROPERTY_CLASS_HEADER Z {{
+kind: Z
+unit: m
+is_z: on
+}}
+PROPERTY_CLASS_HEADER vector3d {{
+kind: Length
+unit: m
+}}
+TFACE
+"""
+        )
+        v_idx = 1
+        v_map = {}
+        for idx, vert in enumerate(surf.vertices):
+            if not np.isnan(vert[0]) and not np.isnan(vert[1]) and not np.isnan(vert[2]):
+                fd.write(f"VRTX {v_idx:} {vert[0]} {vert[1]} {vert[2]}")
+                if surf.properties:
+                    for value in surf.properties.values():
+                        fd.write(f" {value[idx]}")
+                fd.write("\n")
+                v_map[idx] = v_idx
+                v_idx += 1
+        for face in surf.triangles:
+            if face[0] in v_map and face[1] in v_map and face[2] in v_map:
+                fd.write(f"TRGL {v_map[face[0]]} {v_map[face[1]]} {v_map[face[2]]} \n")
+        fd.write("END\n")
+    return True
+
+
+# def _write_pointset(points, file_name):
+#     """
+#     Write out a GOCAD VS file for a pointset
+
+#     Parameters
+#     ----------
+#     points: SimpleNamespace()
+#         Details of the points, as a SimpleNamespace() object. Fields are:
+#             locations: locations, numpy ndarray with dtype = float64 & shape = (N,3)
+#             vectors: vectors, numpy ndarray with dtype = float64 & shape = (N,3)
+#             name: name of feature e.g. fault or supergroup, string
+
+#     file_name: string
+#         Desired filename
+
+#     Returns
+#     -------
+#     True if successful
+
+#     """
+#     from pathlib import Path
+
+#     file_name = Path(file_name).with_suffix(".vs")
+#     with open(f"{file_name}", "w") as fd:
+#         fd.write(
+#             f"""GOCAD VSet 1
+# HEADER {{
+# name: {points.name}
+# }}
+# GOCAD_ORIGINAL_COORDINATE_SYSTEM
+# NAME Default
+# PROJECTION Unknown

LoopStructural/export/omf_wrapper.py

@@ -0,0 +1,88 @@
+try:
+    import omf
+except ImportError:
+    raise ImportError(
+        "You need to install the omf package to use this feature. "
+        "You can install it with: pip install --pre omf"
+    )
+
+
+def get_project(filename):
+    try:
+        project = omf.load(filename)
+    except FileNotFoundError:
+        project = omf.Project(name='LoopStructural Model')
+    return project
+
+
+def get_cell_attributes(loopobject):
+    attributes = []
+    if loopobject.cell_properties:
+        attributes += [
+            omf.NumericAttribute(name=k, array=v, location="faces")
+            for k, v in loopobject.cell_properties.items()
+        ]
+    return attributes
+
+
+def get_point_attributed(loopobject):
+    attributes = []
+    if loopobject.properties:
+        attributes += [
+            omf.NumericAttribute(name=k, array=v, location="vertices")
+            for k, v in loopobject.properties.items()
+        ]
+    return attributes
+
+
+def add_surface_to_omf(surface, filename):
+
+    attributes = []
+    attributes += get_cell_attributes(surface)
+    attributes += get_point_attributed(surface)
+    surface = omf.Surface(
+        vertices=surface.vertices,
+        triangles=surface.triangles,
+        attributes=attributes,
+        name=surface.name,
+    )
+    project = get_project(filename)
+
+    project.elements += [surface]
+    omf.save(project, filename, mode='w')
+
+
+def add_pointset_to_omf(points, filename):
+
+    attributes = []
+    attributes += get_point_attributed(points)
+
+    points = omf.PointSet(
+        vertices=points.locations,
+        attributes=attributes,
+        name=points.name,
+    )
+
+    project = get_project(filename)
+    project.elements += [points]
+    omf.save(project, filename, mode='w')
+
+
+def add_structured_grid_to_omf(grid, filename):
+    print('Open Mining Format cannot store structured grids')
+    return
+    # attributes = []
+    # attributes += get_cell_attributes(grid)
+    # attributes += get_point_attributed(grid)
+
+    # vol = omf.TensorGridBlockModel(
+    #     name=grid.name,
+    #     tensor_u=np.ones(grid.nsteps[0]).astype(float),
+    #     tensor_v=np.ones(grid.nsteps[0]).astype(float),
+    #     tensor_w=np.ones(grid.nsteps[0]).astype(float),
+    #     origin=grid.origin,
+    #     attributes=attributes,
+    # )
+    # project = get_project(filename)
+    # project.elements += [vol]
+    # omf.save(project, filename, mode='w')

LoopStructural/interpolators/__init__.py

@@ -0,0 +1,105 @@
+"""
+Interpolators and interpolation supports
+
+"""
+
+__all__ = [
+    "InterpolatorType",
+    "GeologicalInterpolator",
+    "DiscreteInterpolator",
+    "FiniteDifferenceInterpolator",
+    "PiecewiseLinearInterpolator",
+    "DiscreteFoldInterpolator",
+    "SurfeRBFInterpolator",
+    "P1Interpolator",
+    "P2Interpolator",
+    "TetMesh",
+    "StructuredGrid",
+    "UnStructuredTetMesh",
+    "P1Unstructured2d",
+    "P2Unstructured2d",
+    "StructuredGrid2D",
+    "P2UnstructuredTetMesh",
+]
+from enum import IntEnum
+
+from ..utils import getLogger
+
+logger = getLogger(__name__)
+
+
+class InterpolatorType(IntEnum):
+    """
+    Enum for the different interpolator types
+
+    1-9 should cover interpolators with supports
+    9+ are data supported
+    """
+
+    BASE = 0
+    BASE_DISCRETE = 1
+    FINITE_DIFFERENCE = 2
+    DISCRETE_FOLD = 3
+    PIECEWISE_LINEAR = 4
+    PIECEWISE_QUADRATIC = 5
+    BASE_DATA_SUPPORTED = 10
+    SURFE = 11
+
+
+interpolator_string_map = {
+    "FDI": InterpolatorType.FINITE_DIFFERENCE,
+    "PLI": InterpolatorType.PIECEWISE_LINEAR,
+    "P2": InterpolatorType.PIECEWISE_QUADRATIC,
+    "P1": InterpolatorType.PIECEWISE_LINEAR,
+    "DFI": InterpolatorType.DISCRETE_FOLD,
+}
+from ..interpolators._geological_interpolator import GeologicalInterpolator
+from ..interpolators._discrete_interpolator import DiscreteInterpolator
+from ..interpolators.supports import (
+    TetMesh,
+    StructuredGrid,
+    UnStructuredTetMesh,
+    P1Unstructured2d,
+    P2Unstructured2d,
+    StructuredGrid2D,
+    P2UnstructuredTetMesh,
+    SupportType,
+)
+
+
+from ..interpolators._finite_difference_interpolator import (
+    FiniteDifferenceInterpolator,
+)
+from ..interpolators._p1interpolator import (
+    P1Interpolator as PiecewiseLinearInterpolator,
+)
+from ..interpolators._discrete_fold_interpolator import (
+    DiscreteFoldInterpolator,
+)
+from ..interpolators._p2interpolator import P2Interpolator
+from ..interpolators._p1interpolator import P1Interpolator
+
+interpolator_map = {
+    InterpolatorType.BASE: GeologicalInterpolator,
+    InterpolatorType.BASE_DISCRETE: DiscreteInterpolator,
+    InterpolatorType.FINITE_DIFFERENCE: FiniteDifferenceInterpolator,
+    InterpolatorType.DISCRETE_FOLD: DiscreteFoldInterpolator,
+    InterpolatorType.PIECEWISE_LINEAR: P1Interpolator,
+    InterpolatorType.PIECEWISE_QUADRATIC: P2Interpolator,
+    InterpolatorType.BASE_DATA_SUPPORTED: GeologicalInterpolator,
+}
+
+support_interpolator_map = {
+    InterpolatorType.FINITE_DIFFERENCE: {
+        2: SupportType.StructuredGrid2D,
+        3: SupportType.StructuredGrid,
+    },
+    InterpolatorType.DISCRETE_FOLD: {3: SupportType.TetMesh, 2: SupportType.P1Unstructured2d},
+    InterpolatorType.PIECEWISE_LINEAR: {3: SupportType.TetMesh, 2: SupportType.P1Unstructured2d},
+    InterpolatorType.PIECEWISE_QUADRATIC: {
+        3: SupportType.P2UnstructuredTetMesh,
+        2: SupportType.P2Unstructured2d,
+    },
+}
+
+from ._interpolator_factory import InterpolatorFactory

LoopStructural/interpolators/_api.py

@@ -0,0 +1,143 @@
+import numpy as np
+
+from typing import Optional
+from LoopStructural.interpolators import (
+    GeologicalInterpolator,
+    InterpolatorFactory,
+    InterpolatorType,
+)
+from LoopStructural.datatypes import BoundingBox
+from LoopStructural.utils import getLogger
+
+logger = getLogger(__name__)
+
+
+class LoopInterpolator:
+    def __init__(
+        self,
+        bounding_box: BoundingBox,
+        dimensions: int = 3,
+        type=InterpolatorType.FINITE_DIFFERENCE,
+        nelements: int = 1000,
+    ):
+        """Scikitlearn like interface for LoopStructural interpolators
+        useful for quickly building an interpolator to apply to a dataset
+        build a generic interpolation object speficying the bounding box
+        and then fit to constraints and evaluate the interpolator
+
+        Parameters
+        ----------
+        bounding_box : BoundingBox
+            Area where the interpolation will work
+        dimensions : int, optional
+            number of dimensions e.g. 3d or 2d, by default 3
+        type : str, optional
+            type of interpolation algorithm FDI- finite difference, PLI - linear finite elements,
+              by default "FDI"
+        nelements : int, optional
+            degrees of freedom for interpolator, by default 1000
+        """
+        self.dimensions = dimensions
+        self.type = "FDI"
+        self.bounding_box = bounding_box
+        self.interpolator: GeologicalInterpolator = InterpolatorFactory.create_interpolator(
+            type,
+            bounding_box,
+            nelements,
+        )
+
+    def fit(
+        self,
+        values: Optional[np.ndarray] = None,
+        tangent_vectors: Optional[np.ndarray] = None,
+        normal_vectors: Optional[np.ndarray] = None,
+        inequality_constraints: Optional[np.ndarray] = None,
+    ):
+        """_summary_
+
+        Parameters
+        ----------
+        values : Optional[np.ndarray], optional
+            Value constraints for implicit function, by default None
+        tangent_vectors : Optional[np.ndarray], optional
+            tangent constraints for implicit function, by default None
+        normal_vectors : Optional[np.ndarray], optional
+            gradient norm constraints for implicit function, by default None
+        inequality_constraints : Optional[np.ndarray], optional
+            _description_, by default None
+        """
+        if values is not None:
+            self.interpolator.set_value_constraints(values)
+        if tangent_vectors is not None:
+            self.interpolator.set_tangent_constraints(tangent_vectors)
+        if normal_vectors is not None:
+            self.interpolator.set_normal_constraints(normal_vectors)
+        if inequality_constraints:
+            pass
+
+        self.interpolator.setup()
+
+    def evaluate_scalar_value(self, locations: np.ndarray) -> np.ndarray:
+        """Evaluate the value of the interpolator at locations
+
+        Parameters
+        ----------
+        locations : np.ndarray
+            Nx3 array of locations to evaluate the interpolator at
+
+        Returns
+        -------
+        np.ndarray
+            value of implicit function at locations
+        """
+        self.interpolator.update()
+        return self.interpolator.evaluate_value(locations)
+
+    def evaluate_gradient(self, locations: np.ndarray) -> np.ndarray:
+        """Evaluate the gradient of the interpolator at locations
+
+        Parameters
+        ----------
+        locations : np.ndarray
+            Nx3 locations
+
+        Returns
+        -------
+        np.ndarray
+            Nx3 gradient of implicit function
+        """
+        self.interpolator.update()
+        return self.interpolator.evaluate_gradient(locations)
+
+    def fit_and_evaluate_value(
+        self,
+        values: Optional[np.ndarray] = None,
+        tangent_vectors: Optional[np.ndarray] = None,
+        normal_vectors: Optional[np.ndarray] = None,
+        inequality_constraints: Optional[np.ndarray] = None,
+    ):
+        # get locations
+        self.fit(
+            values=values,
+            tangent_vectors=tangent_vectors,
+            normal_vectors=normal_vectors,
+            inequality_constraints=inequality_constraints,
+        )
+        locations = self.interpolator.get_data_locations()
+        return self.evalute_scalar_value(locations)
+
+    def fit_and_evaluate_gradient(
+        self,
+        values: Optional[np.ndarray] = None,
+        tangent_vectors: Optional[np.ndarray] = None,
+        normal_vectors: Optional[np.ndarray] = None,
+        inequality_constraints: Optional[np.ndarray] = None,
+    ):
+        self.fit(
+            values=values,
+            tangent_vectors=tangent_vectors,
+            normal_vectors=normal_vectors,
+            inequality_constraints=inequality_constraints,
+        )
+        locations = self.interpolator.get_data_locations()
+        return self.evaluate_gradient(locations)

LoopStructural/interpolators/_builders.py

@@ -0,0 +1,149 @@
+from LoopStructural.utils.exceptions import LoopException
+import numpy as np
+from typing import Optional
+from LoopStructural.interpolators import (
+    P1Interpolator,
+    P2Interpolator,
+    FiniteDifferenceInterpolator,
+    GeologicalInterpolator,
+    DiscreteFoldInterpolator,
+    StructuredGrid,
+    TetMesh,
+)
+from LoopStructural.datatypes import BoundingBox
+from LoopStructural.utils.logging import getLogger
+
+logger = getLogger(__name__)
+
+
+def get_interpolator(
+    bounding_box: BoundingBox,
+    interpolatortype: str,
+    nelements: int,
+    element_volume: Optional[float] = None,
+    buffer: float = 0.2,
+    dimensions: int = 3,
+    support=None,
+) -> GeologicalInterpolator:
+    # add a buffer to the interpolation domain, this is necessary for
+    # faults but also generally a good
+    # idea to avoid boundary problems
+    # buffer = bb[1, :]
+    origin = bounding_box.with_buffer(buffer).origin
+    maximum = bounding_box.with_buffer(buffer).maximum
+    box_vol = np.prod(maximum - origin)
+    if interpolatortype == "PLI":
+        if support is None:
+            if element_volume is None:
+                # nelements /= 5
+                element_volume = box_vol / nelements
+            # calculate the step vector of a regular cube
+            step_vector = np.zeros(3)
+            step_vector[:] = element_volume ** (1.0 / 3.0)
+            # step_vector /= np.array([1,1,2])
+            # number of steps is the length of the box / step vector
+            nsteps = np.ceil((maximum - origin) / step_vector).astype(int)
+            if np.any(np.less(nsteps, 3)):
+                axis_labels = ["x", "y", "z"]
+                for i in range(3):
+                    if nsteps[i] < 3:
+                        nsteps[i] = 3
+                        logger.error(
+                            f"Number of steps in direction {axis_labels[i]} is too small, try increasing nelements"
+                        )
+                logger.error("Cannot create interpolator: number of steps is too small")
+                raise ValueError("Number of steps too small cannot create interpolator")
+
+            support = TetMesh(origin=origin, nsteps=nsteps, step_vector=step_vector)
+        logger.info(
+            "Creating regular tetrahedron mesh with %i elements \n"
+            "for modelling using PLI" % (support.ntetra)
+        )
+
+        return P1Interpolator(support)
+    if interpolatortype == "P2":
+        if support is not None:
+            logger.info(
+                "Creating regular tetrahedron mesh with %i elements \n"
+                "for modelling using P2" % (support.ntetra)
+            )
+            return P2Interpolator(support)
+        else:
+            raise ValueError("Cannot create P2 interpolator without support, try using PLI")
+
+    if interpolatortype == "FDI":
+        # find the volume of one element
+        if element_volume is None:
+            element_volume = box_vol / nelements
+        # calculate the step vector of a regular cube
+        step_vector = np.zeros(3)
+        step_vector[:] = element_volume ** (1.0 / 3.0)
+        # number of steps is the length of the box / step vector
+        nsteps = np.ceil((maximum - origin) / step_vector).astype(int)
+        if np.any(np.less(nsteps, 3)):
+            logger.error("Cannot create interpolator: number of steps is too small")
+            axis_labels = ["x", "y", "z"]
+            for i in range(3):
+                if nsteps[i] < 3:
+                    nsteps[i] = 3
+            #         logger.error(
+            #             f"Number of steps in direction {axis_labels[i]} is too small, try increasing nelements"
+            #         )
+            # raise ValueError("Number of steps too small cannot create interpolator")
+        # create a structured grid using the origin and number of steps
+
+        grid = StructuredGrid(origin=origin, nsteps=nsteps, step_vector=step_vector)
+        logger.info(
+            f"Creating regular grid with {grid.n_elements} elements \n" "for modelling using FDI"
+        )
+        return FiniteDifferenceInterpolator(grid)
+    if interpolatortype == "DFI":
+        if element_volume is None:
+            nelements /= 5
+            element_volume = box_vol / nelements
+        # calculate the step vector of a regular cube
+        step_vector = np.zeros(3)
+        step_vector[:] = element_volume ** (1.0 / 3.0)
+        # number of steps is the length of the box / step vector
+        nsteps = np.ceil((maximum - origin) / step_vector).astype(int)
+        # create a structured grid using the origin and number of steps
+
+        mesh = TetMesh(origin=origin, nsteps=nsteps, step_vector=step_vector)
+        logger.info(
+            f"Creating regular tetrahedron mesh with {mesh.ntetra} elements \n"
+            "for modelling using DFI"
+        )
+        return DiscreteFoldInterpolator(mesh, None)
+    raise LoopException("No interpolator")
+    # fi interpolatortype == "DFI" and dfi is True:
+    #     if element_volume is None:
+    #         nelements /= 5
+    #         element_volume = box_vol / nelements
+    #     # calculate the step vector of a regular cube
+    #     step_vector = np.zeros(3)
+    #     step_vector[:] = element_volume ** (1.0 / 3.0)
+    #     # number of steps is the length of the box / step vector
+    #     nsteps = np.ceil((bb[1, :] - bb[0, :]) / step_vector).astype(int)
+    #     # create a structured grid using the origin and number of steps
+    #     if "meshbuilder" in kwargs:
+    #         mesh = kwargs["meshbuilder"].build(bb, nelements)
+    #     else:
+    #         mesh = kwargs.get(
+    #             "mesh",
+    #             TetMesh(origin=bb[0, :], nsteps=nsteps, step_vector=step_vector),
+    #         )
+    #     logger.info(
+    #         f"Creating regular tetrahedron mesh with {mesh.ntetra} elements \n"
+    #         "for modelling using DFI"
+    #     )
+    #     return DFI(mesh, kwargs["fold"])
+    # if interpolatortype == "Surfe" or interpolatortype == "surfe":
+    #     # move import of surfe to where we actually try and use it
+    #     if not surfe:
+    #         logger.warning("Cannot import Surfe, try another interpolator")
+    #         raise ImportError("Cannot import surfepy, try pip install surfe")
+    #     method = kwargs.get("method", "single_surface")
+    #     logger.info("Using surfe interpolator")
+    #     return SurfeRBFInterpolator(method)
+    # logger.warning("No interpolator")
+    # raise InterpolatorError("Could not create interpolator")