LoopStructural 1.6.13__py3-none-any.whl → 1.6.15__py3-none-any.whl

LoopStructural/interpolators/_finite_difference_interpolator.py

@@ -160,7 +160,7 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             # print(points[inside,:].shape)
             gi = np.zeros(self.support.n_nodes, dtype=int)
             gi[:] = -1
-            gi[self.region] = np.arange(0, self.nx, dtype=int)
+            gi[self.region] = np.arange(0, self.dof, dtype=int)
             idc = np.zeros(node_idx.shape)
             idc[:] = -1
             idc[inside, :] = gi[node_idx[inside, :]]
@@ -204,7 +204,7 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             )
             gi = np.zeros(self.support.n_nodes, dtype=int)
             gi[:] = -1
-            gi[self.region] = np.arange(0, self.nx, dtype=int)
+            gi[self.region] = np.arange(0, self.dof, dtype=int)
             idc = np.zeros(node_idx.shape).astype(int)
             idc[:] = -1
             idc[inside, :] = gi[node_idx[inside, :]]
@@ -227,11 +227,11 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
                 interface_A = np.hstack([A[mask, :][ij[:, 0], :], -A[mask, :][ij[:, 1], :]])
                 interface_idc = np.hstack([idc[mask, :][ij[:, 0], :], idc[mask, :][ij[:, 1], :]])
                 # now map the index from global to region create array size of mesh
-                # initialise as np.nan, then map points inside region to 0->nx
+                # initialise as np.nan, then map points inside region to 0->dof
                 gi = np.zeros(self.support.n_nodes).astype(int)
                 gi[:] = -1
 
-                gi[self.region] = np.arange(0, self.nx)
+                gi[self.region] = np.arange(0, self.dof)
                 interface_idc = gi[interface_idc]
                 outside = ~np.any(interface_idc == -1, axis=1)
                 self.add_constraints_to_least_squares(
@@ -266,7 +266,7 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             # magnitude
             gi = np.zeros(self.support.n_nodes)
             gi[:] = -1
-            gi[self.region] = np.arange(0, self.nx)
+            gi[self.region] = np.arange(0, self.dof)
             idc = np.zeros(node_idx.shape)
             idc[:] = -1
             idc[inside, :] = gi[node_idx[inside, :]]
@@ -331,7 +331,7 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             )
             gi = np.zeros(self.support.n_nodes)
             gi[:] = -1
-            gi[self.region] = np.arange(0, self.nx)
+            gi[self.region] = np.arange(0, self.dof)
             idc = np.zeros(node_idx.shape)
             idc[:] = -1
             idc[inside, :] = gi[node_idx[inside, :]]
@@ -421,7 +421,7 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
             # magnitude
             gi = np.zeros(self.support.n_nodes)
             gi[:] = -1
-            gi[self.region] = np.arange(0, self.nx)
+            gi[self.region] = np.arange(0, self.dof)
             idc = np.zeros(node_idx.shape)
             idc[:] = -1
 
@@ -454,22 +454,28 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
                 )
             self.up_to_date = False
 
-    def add_regularisation(self, operator, w=0.1):
-        """
 
-        Parameters
-        ----------
-        operator
-        w
 
-        Returns
-        -------
+    # def assemble_borders(self, operator, w, name='regularisation'):
+    #     """
+    #     Adds a constraint to the border of the model to force the value to be equal to the value at the border
 
-        """
-        self.assemble_inner(operator, w)
-        # self.assemble_borders()
+    #     Parameters
+    #     ----------
+    #     operator : Operator
+    #         operator to use for the regularisation
+    #     w : double
+    #         weight of the regularisation
+
+    #     Returns
+    #     -------
+
+    #     """
+    #     # First get the global indicies of the pairs of neighbours this should be an
+    #     # N*27 array for 3d and an N*9 array for 2d
+
+    #     global_indexes = self.support.neighbour_global_indexes()
 
-    # def assemble_borders(self, operator, w):
 
     def assemble_inner(self, operator, w, name='regularisation'):
         """
@@ -484,7 +490,7 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
 
         """
         # First get the global indicies of the pairs of neighbours this should be an
-        # Nx27 array for 3d and an Nx9 array for 2d
+        # N*27 array for 3d and an N*9 array for 2d
 
         global_indexes = self.support.neighbour_global_indexes()  # np.array([ii,jj]))
 
@@ -493,7 +499,7 @@ class FiniteDifferenceInterpolator(DiscreteInterpolator):
 
         gi = np.zeros(self.support.n_nodes)
         gi[:] = -1
-        gi[self.region] = np.arange(0, self.nx)
+        gi[self.region] = np.arange(0, self.dof)
         idc = gi[idc]
         inside = ~np.any(idc == -1, axis=1)  # np.ones(a.shape[0],dtype=bool)#
         # a[idc==-1] = 0

LoopStructural/interpolators/_geological_interpolator.py

@@ -96,7 +96,7 @@ class GeologicalInterpolator(metaclass=ABCMeta):
         json["constraints"] = self.constraints
         json["data"] = self.data
         json["type"] = self.type
-        # json["dof"] = self.nx
+        # json["dof"] = self.dof
         json["up_to_date"] = self.up_to_date
         return json
 

LoopStructural/interpolators/_interpolatortype.py

@@ -0,0 +1,22 @@
+from enum import Enum
+
+class InterpolatorType(Enum):
+    """
+    Enum for the different interpolator types
+
+    Each value is a unique identifier.
+    """
+
+    BASE = "BASE"
+    BASE_DISCRETE = "BASE_DISCRETE"
+    FINITE_DIFFERENCE = "FINITE_DIFFERENCE"
+    DISCRETE_FOLD = "DISCRETE_FOLD"
+    PIECEWISE_LINEAR = "PIECEWISE_LINEAR"
+    PIECEWISE_QUADRATIC = "PIECEWISE_QUADRATIC"
+    BASE_DATA_SUPPORTED = "BASE_DATA_SUPPORTED"
+    SURFE = "SURFE"
+    PIECEWISE_LINEAR_CONSTANT_NORM = "PIECEWISE_LINEAR_CONSTANT_NORM"
+    FINITE_DIFFERENCE_CONSTANT_NORM = "FINITE_DIFFERENCE_CONSTANT_NORM"
+
+
+

LoopStructural/interpolators/_p1interpolator.py

@@ -45,7 +45,7 @@ class P1Interpolator(DiscreteInterpolator):
         points = self.get_norm_constraints()
         if points.shape[0] > 0:
             grad, elements, inside = self.support.evaluate_shape_derivatives(points[:, :3])
-            size = self.support.element_size[elements[inside]]
+            size = self.support.element_scale[elements[inside]]
             wt = np.ones(size.shape[0])
             wt *= w  # s* size
             elements = np.tile(self.support.elements[elements[inside]], (3, 1, 1))
@@ -70,6 +70,7 @@ class P1Interpolator(DiscreteInterpolator):
         if points.shape[0] > 1:
             N, elements, inside = self.support.evaluate_shape(points[:, :3])
             size = self.support.element_size[elements[inside]]
+
             wt = np.ones(size.shape[0])
             wt *= w  # * size
             self.add_constraints_to_least_squares(
@@ -110,13 +111,16 @@ class P1Interpolator(DiscreteInterpolator):
         const_n = -np.einsum("ij,ijk->ik", norm, Dn)
         # const_t_cp2 = np.einsum('ij,ikj->ik',normal,cp2_Dt)
         # const_n_cp2 = -np.einsum('ij,ikj->ik',normal,cp2_Dn)
-
+        # shared_element_size = self.support.shared_element_size
+        # const_t /= shared_element_size[:, None]  # normalise by element size
+        # const_n /= shared_element_size[:, None]  # normalise by element size
         const = np.hstack([const_t, const_n])
 
         # get vertex indexes
         tri_cp1 = np.hstack([self.support.elements[tri1], self.support.elements[tri2]])
         # tri_cp2 = np.hstack([self.support.elements[cp2_tri1],self.support.elements[tri2]])
         # add cp1 and cp2 to the least squares system
+
         self.add_constraints_to_least_squares(
             const,
             np.zeros(const.shape[0]),
@@ -146,7 +150,7 @@ class P1Interpolator(DiscreteInterpolator):
         self.reset()
         for key in kwargs:
             if "regularisation" in kwargs:
-                self.interpolation_weights["cgw"] = 0.1 * kwargs["regularisation"]
+                self.interpolation_weights["cgw"] = kwargs["regularisation"]
             self.up_to_date = False
             self.interpolation_weights[key] = kwargs[key]
         if self.interpolation_weights["cgw"] > 0.0:

LoopStructural/interpolators/_surfe_wrapper.py

@@ -203,5 +203,8 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
         return
 
     @property
-    def nx(self):
+    def dof(self):
         return self.get_data_locations().shape[0]
+    @property
+    def n_elements(self)->int:
+        return self.get_data_locations().shape[0]

LoopStructural/interpolators/supports/_2d_base_unstructured.py

@@ -30,7 +30,7 @@ class BaseUnstructured2d(BaseSupport):
             self.order = 1
         elif self.elements.shape[1] == 6:
             self.order = 2
-        self.nx = self.vertices.shape[0]
+        self.dof = self.vertices.shape[0]
         self.neighbours = neighbours
         self.minimum = np.min(self.nodes, axis=0)
         self.maximum = np.max(self.nodes, axis=0)

LoopStructural/interpolators/supports/_2d_structured_grid.py

@@ -372,6 +372,22 @@ class StructuredGrid2D(BaseSupport):
         return xy
 
     def position_to_cell_corners(self, pos):
+        """Get the global indices of the vertices (corner) nodes of the cell containing each point.
+
+        Parameters
+        ----------
+        pos : np.array
+            (N, 2) array of xy coordinates representing the positions of N points.
+    
+        Returns
+        -------
+        globalidx : np.array
+            (N, 4) array of global indices corresponding to the 4 corner nodes of the cell 
+            each point lies in. If a point lies outside the support, its corresponding entry 
+            will be set to -1.
+        inside : np.array
+            (N,) boolean array indicating whether each point is inside the support domain.
+        """
         corner_index, inside = self.position_to_cell_index(pos)
         corners = self.cell_corner_indexes(corner_index)
         globalidx = self.global_node_indices(corners)

LoopStructural/interpolators/supports/_3d_base_structured.py

@@ -373,6 +373,22 @@ class BaseStructuredSupport(BaseSupport):
         return corner_indexes
 
     def position_to_cell_corners(self, pos):
+        """Get the global indices of the vertices (corners) of the cell containing each point.
+
+        Parameters
+        ----------
+        pos : np.array
+            (N, 3) array of xyz coordinates representing the positions of N points.
+    
+        Returns
+        -------
+        globalidx : np.array
+            (N, 8) array of global indices corresponding to the 8 corner nodes of the cell 
+            each point lies in. If a point lies outside the support, its corresponding entry 
+            will be set to -1.
+        inside : np.array
+            (N,) boolean array indicating whether each point is inside the support domain.
+        """
         cell_indexes, inside = self.position_to_cell_index(pos)
         corner_indexes = self.cell_corner_indexes(cell_indexes)
         globalidx = self.global_node_indices(corner_indexes)

LoopStructural/interpolators/supports/_3d_structured_grid.py

@@ -437,8 +437,9 @@ class StructuredGrid(BaseStructuredSupport):
         T[:, 2, 6] = (1 - local_coords[:, 0]) * local_coords[:, 1]
         T[:, 2, 3] = -local_coords[:, 0] * local_coords[:, 1]
         T[:, 2, 7] = local_coords[:, 0] * local_coords[:, 1]
-        T /= self.step_vector[0]
-
+        T[:, 0, :] /= self.step_vector[None, 0]
+        T[:, 1, :] /= self.step_vector[None, 1]
+        T[:, 2, :] /= self.step_vector[None, 2]
         return vertices, T, elements, inside
 
     def get_element_for_location(self, pos: np.ndarray):

LoopStructural/interpolators/supports/_3d_structured_tetra.py

@@ -85,10 +85,14 @@ class TetMesh(BaseStructuredSupport):
         )
 
         return np.abs(np.linalg.det(vecs)) / 6
-
+    
     @property
     def element_scale(self):
-        return self.element_size / np.mean(self.element_size)
+        size = self.element_size
+        size-= np.min(size)
+        size/= np.max(size)
+        size+=1.
+        return size
 
     @property
     def barycentre(self) -> np.ndarray:
@@ -189,7 +193,7 @@ class TetMesh(BaseStructuredSupport):
         """
         norm = self.shared_element_norm
         return 0.5 * np.linalg.norm(norm, axis=1)
-
+    
     @property
     def shared_element_scale(self):
         return self.shared_element_size / np.mean(self.shared_element_size)

LoopStructural/modelling/__init__.py

@@ -22,6 +22,14 @@ from ..modelling.input import (
 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"
-    )
+    class LoopProjectfileProcessor(ProcessInputData):
+        """
+        Dummy class to handle the case where LoopProjectFile is not installed.
+        This will raise a warning when used.
+        """
+
+        def __init__(self, *args, **kwargs):
+            raise LoopImportError(
+                "LoopProjectFile cannot be imported. Please install LoopProjectFile."
+            )
+