LoopStructural 1.6.1__py3-none-any.whl

LoopStructural/interpolators/supports/_aabb.py

@@ -0,0 +1,77 @@
+import numpy as np
+from scipy import sparse
+
+
+def _initialise_aabb(grid):
+    """assigns the tetras to the grid cells where the bounding box
+    of the tetra element overlaps the grid cell.
+    It could be changed to use the separating axis theorem, however this would require
+    significantly more calculations. (12 more I think).. #TODO test timing
+    """
+    # calculate the bounding box for all tetraherdon in the mesh
+    # find the min/max extents for xyz
+    # tetra_bb = np.zeros((grid.elements.shape[0], 19, 3))
+    minx = np.min(grid.nodes[grid.elements[:, :4], 0], axis=1)
+    maxx = np.max(grid.nodes[grid.elements[:, :4], 0], axis=1)
+    miny = np.min(grid.nodes[grid.elements[:, :4], 1], axis=1)
+    maxy = np.max(grid.nodes[grid.elements[:, :4], 1], axis=1)
+
+    cell_indexes = grid.aabb_grid.global_index_to_cell_index(np.arange(grid.aabb_grid.n_elements))
+    corners = grid.aabb_grid.cell_corner_indexes(cell_indexes)
+    positions = grid.aabb_grid.node_indexes_to_position(corners)
+    ## Because we known the node orders just select min/max from each
+    # coordinate. Use these to check whether the tetra is in the cell
+    x_boundary = positions[:, [0, 1], 0]
+    y_boundary = positions[:, [0, 2], 1]
+    a = np.logical_and(
+        minx[None, :] > x_boundary[:, None, 0],
+        minx[None, :] < x_boundary[:, None, 1],
+    )  # min point between cell
+    b = np.logical_and(
+        maxx[None, :] < x_boundary[:, None, 1],
+        maxx[None, :] > x_boundary[:, None, 0],
+    )  # max point between cell
+    c = np.logical_and(
+        minx[None, :] < x_boundary[:, None, 0],
+        maxx[None, :] > x_boundary[:, None, 0],
+    )  # min point < than cell & max point > cell
+
+    x_logic = np.logical_or(np.logical_or(a, b), c)
+
+    a = np.logical_and(
+        miny[None, :] > y_boundary[:, None, 0],
+        miny[None, :] < y_boundary[:, None, 1],
+    )  # min point between cell
+    b = np.logical_and(
+        maxy[None, :] < y_boundary[:, None, 1],
+        maxy[None, :] > y_boundary[:, None, 0],
+    )  # max point between cell
+    c = np.logical_and(
+        miny[None, :] < y_boundary[:, None, 0],
+        maxy[None, :] > y_boundary[:, None, 0],
+    )  # min point < than cell & max point > cell
+
+    y_logic = np.logical_or(np.logical_or(a, b), c)
+    logic = np.logical_and(x_logic, y_logic)
+
+    if grid.dimension == 3:
+        z_boundary = positions[:, [0, 6], 2]
+        minz = np.min(grid.nodes[grid.elements[:, :4], 2], axis=1)
+        maxz = np.max(grid.nodes[grid.elements[:, :4], 2], axis=1)
+        a = np.logical_and(
+            minz[None, :] > z_boundary[:, None, 0],
+            minz[None, :] < z_boundary[:, None, 1],
+        )  # min point between cell
+        b = np.logical_and(
+            maxz[None, :] < z_boundary[:, None, 1],
+            maxz[None, :] > z_boundary[:, None, 0],
+        )  # max point between cell
+        c = np.logical_and(
+            minz[None, :] < z_boundary[:, None, 0],
+            maxz[None, :] > z_boundary[:, None, 0],
+        )  # min point < than cell & max point > cell
+
+        z_logic = np.logical_or(np.logical_or(a, b), c)
+        logic = np.logical_and(logic, z_logic)
+
+    grid._aabb_table = sparse.csr_matrix(logic)

LoopStructural/interpolators/supports/_base_support.py

@@ -0,0 +1,114 @@
+from abc import ABCMeta, abstractmethod
+import numpy as np
+from typing import Tuple
+
+
+class BaseSupport(metaclass=ABCMeta):
+    """
+    Base support class
+    """
+
+    @abstractmethod
+    def __init__(self):
+        """
+        This class is the base
+        """
+
+    @abstractmethod
+    def evaluate_value(self, evaluation_points: np.ndarray, property_array: np.ndarray):
+        """
+        Evaluate the value of the support at the evaluation points
+        """
+        pass
+
+    @abstractmethod
+    def evaluate_gradient(self, evaluation_points: np.ndarray, property_array: np.ndarray):
+        """
+        Evaluate the gradient of the support at the evaluation points
+        """
+        pass
+
+    @abstractmethod
+    def inside(self, pos):
+        """
+        Check if a position is inside the support
+        """
+        pass
+
+    @abstractmethod
+    def onGeometryChange(self):
+        """
+        Called when the geometry changes
+        """
+        pass
+
+    @abstractmethod
+    def get_element_for_location(
+        self, pos: np.ndarray
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Get the element for a location
+        """
+        pass
+
+    @abstractmethod
+    def get_element_gradient_for_location(
+        self, pos: np.ndarray
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+        pass
+
+    @property
+    @abstractmethod
+    def elements(self):
+        """
+        Return the elements
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def n_elements(self):
+        """
+        Return the number of elements
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def n_nodes(self):
+        """
+        Return the number of points
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def nodes(self):
+        """
+        Return the nodes
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def barycentre(self):
+        """
+        Return the number of dimensions
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def dimension(self):
+        """
+        Return the number of dimensions
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def element_size(self):
+        """
+        Return the element size
+        """
+        pass

LoopStructural/interpolators/supports/_face_table.py

@@ -0,0 +1,70 @@
+import numpy as np
+from scipy import sparse
+
+
+def _init_face_table(grid):
+    """
+    Fill table containing elements that share a face, and another
+    table that contains the nodes for a face.
+    """
+    # need to identify the shared nodes for pairs of elements
+    # we do this by creating a sparse matrix that has N rows (number of elements)
+    # and M columns (number of nodes).
+    # We then fill the location where a node is in an element with true
+    # Then we create a table for the pairs of elements in the mesh
+    # we have the neighbour relationships, which are the 4 neighbours for each element
+    # create a new table that shows the element index repeated four times
+    # flatten both of these arrays so we effectively have a table with pairs of neighbours
+    # disgard the negative neighbours because these are border neighbours
+    rows = np.tile(np.arange(grid.n_elements)[:, None], (1, grid.dimension + 1))
+    elements = grid.elements
+    neighbours = grid.neighbours
+    # add array of bool to the location where there are elements for each node
+
+    # use this to determine shared faces
+
+    element_nodes = sparse.coo_matrix(
+        (
+            np.ones(elements.shape[0] * (grid.dimension + 1)),
+            (rows.ravel(), elements[:, : grid.dimension + 1].ravel()),
+        ),
+        shape=(grid.n_elements, grid.n_nodes),
+        dtype=bool,
+    ).tocsr()
+    n1 = np.tile(np.arange(neighbours.shape[0], dtype=int)[:, None], (1, grid.dimension + 1))
+    n1 = n1.flatten()
+    n2 = neighbours.flatten()
+    n1 = n1[n2 >= 0]
+    n2 = n2[n2 >= 0]
+    el_rel = np.zeros((grid.neighbours.flatten().shape[0], 2), dtype=int)
+    el_rel[:] = -1
+    el_rel[np.arange(n1.shape[0]), 0] = n1
+    el_rel[np.arange(n1.shape[0]), 1] = n2
+    el_rel = el_rel[el_rel[:, 0] >= 0, :]
+
+    # el_rel2 = np.zeros((grid.neighbours.flatten().shape[0], 2), dtype=int)
+    grid._shared_element_relationships[:] = -1
+    el_pairs = sparse.coo_matrix((np.ones(el_rel.shape[0]), (el_rel[:, 0], el_rel[:, 1]))).tocsr()
+    i, j = sparse.tril(el_pairs).nonzero()
+    grid._shared_element_relationships[: len(i), 0] = i
+    grid._shared_element_relationships[: len(i), 1] = j
+
+    grid._shared_element_relationships = grid.shared_element_relationships[
+        grid.shared_element_relationships[:, 0] >= 0, :
+    ]
+
+    faces = element_nodes[grid.shared_element_relationships[:, 0], :].multiply(
+        element_nodes[grid.shared_element_relationships[:, 1], :]
+    )
+    shared_faces = faces[np.array(np.sum(faces, axis=1) == grid.dimension).flatten(), :]
+    row, col = shared_faces.nonzero()
+    row = row[row.argsort()]
+    col = col[row.argsort()]
+    shared_face_index = np.zeros((shared_faces.shape[0], grid.dimension), dtype=int)
+    shared_face_index[:] = -1
+    shared_face_index[row.reshape(-1, grid.dimension)[:, 0], :] = col.reshape(-1, grid.dimension)
+    grid._shared_elements[np.arange(grid.shared_element_relationships.shape[0]), :] = (
+        shared_face_index
+    )
+    # resize
+    grid._shared_elements = grid.shared_elements[: len(grid.shared_element_relationships), :]

LoopStructural/interpolators/supports/_support_factory.py

@@ -0,0 +1,32 @@
+from LoopStructural.interpolators.supports import support_map, SupportType
+
+
+class SupportFactory:
+    @staticmethod
+    def create_support(support_type, **kwargs):
+        if support_type is None:
+            raise ValueError("No support type specified")
+        if isinstance(support_type, str):
+            support_type = SupportType._member_map_[support_type].numerator
+        return support_map[support_type](**kwargs)
+
+    @staticmethod
+    def from_dict(d):
+        d = d.copy()
+        support_type = d.pop("type", None)
+        if support_type is None:
+            raise ValueError("No support type specified")
+        return SupportFactory.create_support(support_type, **d)
+
+    @staticmethod
+    def create_support_from_bbox(
+        support_type, bounding_box, nelements, element_volume=None, buffer: float = 0.2
+    ):
+        if isinstance(support_type, str):
+            support_type = SupportType._member_map_[support_type].numerator
+        bbox = bounding_box.with_buffer(buffer=buffer)
+        bbox.nelements = nelements
+
+        return support_map[support_type](
+            origin=bbox.origin, step_vector=bbox.step_vector, nsteps=bbox.nsteps
+        )

LoopStructural/modelling/__init__.py

@@ -0,0 +1,29 @@
+"""
+Geological modelling classes and functions
+
+"""
+
+__all__ = [
+    "GeologicalModel",
+    "ProcessInputData",
+    "Loop3DView",
+    "Map2LoopProcessor",
+    "LoopProjectfileProcessor",
+]
+from ..utils import getLogger
+from ..utils import LoopImportError
+
+logger = getLogger(__name__)
+from ..modelling.input import (
+    ProcessInputData,
+    Map2LoopProcessor,
+)
+
+try:
+    from ..modelling.input.project_file import LoopProjectfileProcessor
+except (LoopImportError, ImportError):
+    logger.warning(
+        "Cannot use LoopProjectfileProcessor: Loop project file cannot be imported, try installing LoopProjectFile"
+    )
+# from LoopStructural.modelling.features import StructuralFrame
+# from LoopStructural.modelling.features.fault import FaultSegment