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

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)