emerge 1.0.6__py3-none-any.whl → 1.0.7__py3-none-any.whl

emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "1.0.6"
+__version__ = "1.0.7"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #

emerge/_emerge/elements/index_interp.py

@@ -61,3 +61,48 @@ def index_interp(coords: np.ndarray,
         prop[inside] = itet
 
     return prop
+
+@njit(f8[:](f8[:,:], i8[:,:], f8[:,:], i8[:], f8[:]), cache=True, nogil=True)
+def constant_interp(coords: np.ndarray,
+                tets: np.ndarray, 
+                nodes: np.ndarray,
+                tetids: np.ndarray,
+                value: np.ndarray):
+    ''' Nedelec 2 tetrahedral interpolation of the analytic curl'''
+    # Solution has shape (nEdges, nsols)
+    nNodes = coords.shape[1]
+    
+    prop = np.full((nNodes, ), 0, dtype=np.float64)
+    
+    for i_iter in range(tetids.shape[0]):
+        itet = tetids[i_iter]
+        
+        iv1, iv2, iv3, iv4 = tets[:, itet]
+
+        v1 = nodes[:,iv1]
+        v2 = nodes[:,iv2]
+        v3 = nodes[:,iv3]
+        v4 = nodes[:,iv4]
+
+        bv1 = v2 - v1
+        bv2 = v3 - v1
+        bv3 = v4 - v1
+
+        blocal = np.zeros((3,3))
+        blocal[:,0] = bv1
+        blocal[:,1] = bv2
+        blocal[:,2] = bv3
+        basis = np.linalg.pinv(blocal)
+
+        coords_offset = coords - v1[:,np.newaxis]
+        coords_local = (basis @ (coords_offset))
+
+
+        inside = ((coords_local[0,:] + coords_local[1,:] + coords_local[2,:]) <= 1.00000001) & (coords_local[0,:] >= -1e-6) & (coords_local[1,:] >= -1e-6) & (coords_local[2,:] >= -1e-6)
+
+        if inside.sum() == 0:
+            continue
+        
+        prop[inside] = value[itet]
+
+    return prop

emerge/_emerge/material.py

@@ -59,7 +59,7 @@ class MatProperty:
         self._z: np.ndarray = np.array([], dtype=np.float64)
         
         self._fmax = lambda f: value
-
+        
     def initialize(self, x: np.ndarray, y: np.ndarray, z: np.ndarray, ids: np.ndarray) -> None:
         self._apply_to = np.concatenate([self._apply_to, ids])
         self._x = np.concatenate([self._x, x])

emerge/_emerge/mesh3d.py

@@ -196,7 +196,6 @@ class Mesh3D(Mesh):
             raise ValueError(f'There is no tetrahedron with indices {i1}, {i2}, {i3}, {i4}')
         return output
         
-
     def get_tetrahedra(self, vol_tags: Union[int, list[int]]) -> np.ndarray:
         if isinstance(vol_tags, int):
             vol_tags = [vol_tags,]
@@ -270,6 +269,37 @@ class Mesh3D(Mesh):
             nodes.update(self.get_nodes(tags))
         return np.array([i for i, tet in enumerate(self.tets.T) if not set(tet).isdisjoint(nodes)])
 
+    def _get_dimtags(self, nodes: list[int] | None = None, edges: list[int] | None = None) -> list[tuple[int, int]]:
+        """Returns the geometry dimtags associated with a set of nodes and edges"""
+        if nodes is None:
+            nodes = []
+        if edges is None:
+            edges = []
+        nodes = set(nodes)
+        edges = set(edges)
+        dimtags = []
+        
+        # Test faces
+        for tag, f_nodes in self.ftag_to_node.items():
+            if set(f_nodes).isdisjoint(nodes):
+                continue
+            dimtags.append((2,tag))
+        
+        for tag, f_edges in self.ftag_to_edge.items():
+            if set(f_edges).isdisjoint(edges):
+                continue
+            dimtags.append((2,tag))
+        
+        # test volumes
+        for tag, f_tets in self.vtag_to_tet.items():
+            v_nodes = set(self.tets[:,f_tets].flatten())
+            if not v_nodes.isdisjoint(nodes):
+                dimtags.append((3,tag))
+            v_edges = set(self.tet_to_edge[:,f_tets].flatten())
+            if not v_edges.isdisjoint(edges):
+                dimtags.append((3,tag))
+        return sorted(dimtags)
+    
     def get_nodes(self, face_tags: Union[int, list[int]]) -> np.ndarray:
         '''Returns a numpyarray of all the nodes that belong to the given face tags'''
         if isinstance(face_tags, int):
@@ -572,7 +602,7 @@ class Mesh3D(Mesh):
                 materials.append(vol.material)
                 vol.material._hash_key = i
                 i += 1
-        
+            
         xs = self.centers[0,:]
         ys = self.centers[1,:]
         zs = self.centers[2,:]
@@ -597,7 +627,7 @@ class Mesh3D(Mesh):
     def plot_gmsh(self) -> None:
         gmsh.fltk.run()
 
-    def find_edge_groups(self, edge_ids: np.ndarray) -> list[tuple[Any,...]]:
+    def find_edge_groups(self, edge_ids: np.ndarray) -> list[tuple[int,...]]:
         """
         Find the groups of edges in the mesh.
 

emerge/_emerge/mesher.py

@@ -75,6 +75,7 @@ class Mesher:
         self.objects: list[GeoObject] = []
         self.size_definitions: list[tuple[int, float]] = []
         self.mesh_fields: list[int] = []
+        self._amr_fields: list[int] = []
         self.min_size: float = None
         self.max_size: float = None
         self.periodic_cell: PeriodicCell = None
@@ -222,8 +223,13 @@ class Mesher:
         gmsh.model.mesh.field.set_numbers(ctag, "CurvesList", tags)
         gmsh.model.mesh.field.set_number(ctag, "VIn", max_size)
         self.mesh_fields.append(ctag)
+    
+    def _reset_amr_points(self) -> None:
+        for tag in self._amr_fields:
+            gmsh.model.mesh.field.remove(tag)
+        self._amr_fields = []
         
-    def _set_size_on_point(self, tags: list[int], max_size: float) -> None:
+    def _set_amr_point(self, tags: list[int], max_size: float) -> None:
         """Define the size of the mesh on a point
 
         Args:
@@ -233,7 +239,7 @@ class Mesher:
         ctag = gmsh.model.mesh.field.add("Constant")
         gmsh.model.mesh.field.set_numbers(ctag, "PointsList", tags)
         gmsh.model.mesh.field.set_number(ctag, "VIn", max_size)
-        self.mesh_fields.append(ctag)
+        self._amr_fields.append(ctag)
 
     def _configure_mesh_size(self, discretizer: Callable, resolution: float):
         """Defines the mesh sizes based on a discretization callable.
@@ -267,7 +273,7 @@ class Mesher:
             logger.debug(f'Setting mesh size:{1000*size:.3f}mm in domains: {tag}')
             self._set_size_in_domain([tag,], size)
 
-        gmsh.model.mesh.field.setNumbers(mintag, "FieldsList", self.mesh_fields)
+        gmsh.model.mesh.field.setNumbers(mintag, "FieldsList", self.mesh_fields + self._amr_fields)
         gmsh.model.mesh.field.setAsBackgroundMesh(mintag)
 
         for tag, size in self.size_definitions:
@@ -279,7 +285,19 @@ class Mesher:
         logger.trace(f'Unsetting mesh size constraint for domains: {dimtags}')
         for dimtag in dimtags:
             gmsh.model.mesh.setSizeFromBoundary(dimtag[0], dimtag[1], 0)
-            
+    
+    def add_refinement_point(self,
+                             coordinate: np.ndarray,
+                             refinement: float,
+                             size: float,
+                             gr: float = 1.5):
+        x0, y0, z0 = coordinate
+        disttag = gmsh.model.mesh.field.add("MathEval")
+        newsize = refinement*size
+        funcstr = f"({newsize})/({gr}) - (1-{gr})/({gr}) * Sqrt((x-({x0}))^2+ (y-({y0}))^2 + (z-({z0}))^2)"
+        gmsh.model.mesh.field.setString(disttag, "F", funcstr)
+        self.mesh_fields.append(disttag)
+        
     def set_boundary_size(self, 
                           boundary: GeoObject | Selection | Iterable, 
                           size:float,