LoopStructural 1.6.14__py3-none-any.whl → 1.6.16__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
 
@@ -472,7 +472,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()
 
@@ -490,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]))
 
@@ -499,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
 
@@ -154,16 +154,22 @@ class GeologicalInterpolator(metaclass=ABCMeta):
         ----------
         points : np.ndarray
             array containing the value constraints usually 7-8 columns.
-            X,Y,Z,nx,ny,nz,weight
+            X,Y,Z,nx,ny,nz,(weight, default : 1 for each row)
 
         Returns
         -------
 
+        Notes
+        -------
+        If no weights are provided, w = 1 is assigned to each normal constraint.
+
         """
         if points.shape[1] == self.dimensions * 2:
             points = np.hstack([points, np.ones((points.shape[0], 1))])
+            logger.warning(f"No weight provided for normal constraints, all weights are set to 1")
+            raise Warning
         if points.shape[1] < self.dimensions * 2 + 1:
-            raise ValueError("Nonrmal constraints must at least have X,Y,Z,nx,ny,nz")
+            raise ValueError("Normal constraints must at least have X,Y,Z,nx,ny,nz")
         self.n_n = points.shape[0]
         self.data["normal"] = points
         self.up_to_date = False

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]),

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_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)