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

emerge/_emerge/mesh3d.py

@@ -25,6 +25,7 @@ from .geometry import GeoVolume
 from loguru import logger
 from .bc import Periodic
 from .material import Material
+from .logsettings import DEBUG_COLLECTOR
 
 _MISSING_ID: int = -1234
 
@@ -78,9 +79,7 @@ class Mesh3D(Mesh):
     are mapped to mesh elements is managed by the FEMBasis class.
     
     """
-    def __init__(self, mesher: Mesher):
-        
-        self.geometry: Mesher = mesher
+    def __init__(self):
 
         # All spatial objects
         self.nodes: np.ndarray = np.array([])
@@ -186,6 +185,8 @@ class Mesh3D(Mesh):
         i11, i21, i31 = tuple(sorted((int(i1), int(i2), int(i3))))
         output = self.inv_tris.get(tuple(sorted((int(i1), int(i2), int(i3)))), None)
         if output is None:
+            DEBUG_COLLECTOR.add_report(f'Mesh3D: The program is crashed due to a non existing triangle {i11}, {i21}, {i31}. This occurs often if surfaces stick out of the 3D domain.\n' + 
+                                       'Only 3D volumes can be meshed. Parts or entire simulations that are two dimensional will cause this problem.')
             raise ValueError(f'There is no triangle with indices {i11}, {i21}, {i31}')
         return output
     
@@ -419,7 +420,7 @@ class Mesh3D(Mesh):
         self.tet_to_edge_sign = np.zeros((6, self.tets.shape[1]), dtype=int) + _MISSING_ID
         self.tet_to_tri = np.zeros((4, self.tets.shape[1]), dtype=int) + _MISSING_ID
         self.tet_to_tri_sign = np.zeros((4, self.tets.shape[1]), dtype=int) + _MISSING_ID
-
+        
         tri_to_tet = defaultdict(list)
         for itet in range(self.tets.shape[1]):
             edge_ids = [self.get_edge(self.tets[i-1,itet],self.tets[j-1,itet]) for i,j in zip([1, 1, 1, 2, 4, 3], [2, 3, 4, 3, 2, 4])]
@@ -502,7 +503,6 @@ class Mesh3D(Mesh):
                 continue
             self.etag_to_edge[t] = [int(self.edge_t2i.get(tag,None)) for tag in edge_tags[0] if tag in self.edge_t2i]
         
-        
         ## Tag bindings
         logger.trace('Constructing geometry to mesh mappings.')
         face_dimtags = gmsh.model.get_entities(2)
@@ -511,7 +511,6 @@ class Mesh3D(Mesh):
             node_tags = [self.n_t2i[int(t)] for t in node_tags[0]]
             self.ftag_to_node[t] = node_tags
             node_tags = np.squeeze(np.array(node_tags)).reshape(-1,3).T
-            
             self.ftag_to_tri[t] = [self.get_tri(node_tags[0,i], node_tags[1,i], node_tags[2,i]) for i in range(node_tags.shape[1])]
             self.ftag_to_edge[t] = sorted(list(np.unique(self.tri_to_edge[:,self.ftag_to_tri[t]].flatten())))
         
@@ -652,8 +651,6 @@ class Mesh3D(Mesh):
         * Only the connectivity of the supplied edges is considered.  
         In particular, vertices that never occur in `edges` do **not** create extra
         components.
-        * Runtime is *O*(N + V), with N = number of edges, V = number of
-        distinct vertices.  No external libraries are needed.
         """
         edges = self.edges[:,edge_ids]
         if edges.ndim != 2 or edges.shape[0] != 2:
@@ -692,6 +689,7 @@ class Mesh3D(Mesh):
                 group += list(new_edges)
                 ungrouped.difference_update(new_edges)
 
+        groups = sorted(groups, key = lambda x: sum(self.edge_lengths[np.array(x)]))
         return groups
 
     def boundary_surface(self, 

emerge/_emerge/mesher.py

@@ -75,7 +75,13 @@ class Mesher:
         self.objects: list[GeoObject] = []
         self.size_definitions: list[tuple[int, float]] = []
         self.mesh_fields: list[int] = []
+        
         self._amr_fields: list[int] = []
+        self._amr_coords: np.ndarray = None
+        self._amr_sizes: np.ndarray = None
+        self._amr_ratios: np.ndrray = None
+        self._amr_new: np.ndarray = None
+
         self.min_size: float = None
         self.max_size: float = None
         self.periodic_cell: PeriodicCell = None
@@ -150,7 +156,6 @@ class Mesher:
                                         3: dict()}
         if len(objects) > 0: # type: ignore
             dimtags, output_mapping = gmsh.model.occ.fragment(final_dimtags, embedding_dimtags)
-
             for domain, mapping in zip(final_dimtags + embedding_dimtags, output_mapping):
                 tag_mapping[domain[0]][domain[1]] = [o[1] for o in mapping]
             for dom in objects: # type: ignore
@@ -173,11 +178,11 @@ class Mesher:
         gmsh.model.mesh.set_periodic(2, face2.tags, face1.tags, translation)
 
     def set_algorithm(self,
-                      obj: GeoObject,
                       algorithm: Algorithm3D) -> None:
-        for tag in obj.tags:
-            gmsh.model.mesh.setAlgorithm(obj.dim, tag, algorithm.value)
-            
+        
+        gmsh.option.setNumber("General.NumThreads", 16)
+        gmsh.option.setNumber("Mesh.Algorithm3D", algorithm.value)
+
     def set_periodic_cell(self, cell: PeriodicCell, excluded_faces: Selection | None = None):
         """Sets the periodic cell information based on the PeriodicCell class object"""
         if excluded_faces is None:
@@ -286,6 +291,57 @@ class Mesher:
         for dimtag in dimtags:
             gmsh.model.mesh.setSizeFromBoundary(dimtag[0], dimtag[1], 0)
     
+    
+    def add_refinement_points(self, coords: np.ndarray, sizes: np.ndarray, ratios: np.ndarray):
+        if self._amr_coords is None:
+            self._amr_coords = coords
+        else:
+            self._amr_coords = np.hstack((self._amr_coords, coords))
+        
+        if self._amr_sizes is None:
+            self._amr_sizes = sizes
+        else:
+            self._amr_sizes = np.hstack((self._amr_sizes, sizes))
+        
+        if self._amr_ratios is None:
+            self._amr_ratios = ratios
+        else:
+            self._amr_ratios = np.hstack((self._amr_ratios, ratios))
+        
+        if self._amr_new is None:
+            self._amr_new = np.ones_like(sizes)
+        else:
+            self._amr_new = np.hstack((0.0*self._amr_new, np.ones_like(sizes)))
+        
+        
+    def set_refinement_function(self,
+                                gr: float = 1.5,
+                                _qf: float = 1.0):
+        xs = self._amr_coords[0,:]
+        ys = self._amr_coords[1,:]
+        zs = self._amr_coords[2,:]
+        newsize = self._amr_ratios*self._amr_sizes
+        A = newsize/gr
+        B = (1-gr)/gr
+        from numba import njit, i8, f8
+
+        @njit(f8(i8,i8,f8,f8,f8,f8), nogil=True, fastmath=True, parallel=False)
+        def func(dim, tag, x, y, z, lc):
+            sizes = np.maximum(newsize, A - B * _qf*np.clip(np.sqrt((x-xs)**2 + (y-ys)**2 + (z-zs)**2) - newsize/3, a_min=0, a_max=None))
+            return min(lc,  float(np.min(sizes)))
+        
+        gmsh.model.mesh.setSizeCallback(func)
+    
+    def refine_finer(self, factor: float):
+        newids = self._amr_new==1
+        self._amr_ratios[newids] = self._amr_ratios[newids]*(0.85**factor)
+        return self._amr_ratios[newids][0]
+    
+    def refine_coarser(self, factor: float):
+        newids = self._amr_new==1
+        self._amr_ratios[newids] = self._amr_ratios[newids]/(0.85**factor)
+        return self._amr_ratios[newids][0]
+    
     def add_refinement_point(self,
                              coordinate: np.ndarray,
                              refinement: float,
@@ -301,7 +357,7 @@ class Mesher:
     def set_boundary_size(self, 
                           boundary: GeoObject | Selection | Iterable, 
                           size:float,
-                          growth_rate: float = 1.4,
+                          growth_rate: float = 3,
                           max_size: float | None = None) -> None:
         """Refine the mesh size along the boundary of a conducting surface
 
@@ -323,8 +379,8 @@ class Mesher:
             self._check_ready()
             max_size = self.max_size
         
-        growth_distance = np.log10(max_size/size)/np.log10(growth_rate)
-        
+        #growth_distance = np.log10(max_size/size)/np.log10(growth_rate)
+        growth_distance = (growth_rate*max_size - size)/(growth_rate-1)
         logger.debug(f'Setting boundary size for region {dimtags} to {size*1000:.3f}mm, GR={growth_rate:.3f}, dist={growth_distance*1000:.2f}mm, Max={max_size*1000:.3f}mm')
         
         nodes = gmsh.model.getBoundary(dimtags, combined=False, oriented=False, recursive=False)
@@ -341,7 +397,7 @@ class Mesher:
         gmsh.model.mesh.field.setNumber(thtag, "SizeMin", size)
         gmsh.model.mesh.field.setNumber(thtag, "SizeMax", max_size)
         gmsh.model.mesh.field.setNumber(thtag, "DistMin", size)
-        gmsh.model.mesh.field.setNumber(thtag, "DistMax", growth_distance*size)
+        gmsh.model.mesh.field.setNumber(thtag, "DistMax", growth_distance)
     
         self.mesh_fields.append(thtag)
 
@@ -357,7 +413,7 @@ class Mesher:
             if obj.dim==2:
                 logger.warning('Forwarding to set_face_size')
                 self.set_face_size(obj, size)
-        logger.debug(f'Setting size {size*1000:.3f}ff for object {obj}')
+        logger.debug(f'Setting size {size*1000:.3f}mm for object {obj}')
         self._set_size_in_domain(obj.tags, size)
 
     def set_face_size(self, obj: GeoSurface | Selection, size: float):
@@ -373,7 +429,7 @@ class Mesher:
                 logger.warning('Forwarding to set_domain_size')
                 self.set_face_size(obj, size)
         
-        logger.debug(f'Setting size {size*1000:.3f}ff for face {obj}')
+        logger.debug(f'Setting size {size*1000:.3f}mm for face {obj}')
         self._set_size_on_face(obj.tags, size)
     
     def set_size(self, obj: GeoObject, size: float) -> None:

emerge/_emerge/mth/common_functions.py

@@ -17,7 +17,7 @@
 
 import numpy as np
 
-def  norm(Field: np.ndarray) -> np.ndarray:
+def norm(Field: np.ndarray) -> np.ndarray:
     """ Computes the complex norm of a field (3,N)
 
     Args:

emerge/_emerge/mth/optimized.py

@@ -397,7 +397,7 @@ def matinv(M: np.ndarray) -> np.ndarray:
         out[2,0] = M[1,0]*M[2,1] - M[1,1]*M[2,0]
         out[2,1] = -M[0,0]*M[2,1] + M[0,1]*M[2,0]
         out[2,2] = M[0,0]*M[1,1] - M[0,1]*M[1,0]
-        out = out*det
+        out = out/det
     return out
 
 @njit(f8[:,:](f8[:,:]), cache=True, nogil=True)
@@ -427,7 +427,7 @@ def matinv_r(M: np.ndarray) -> np.ndarray:
         out[2,0] = M[1,0]*M[2,1] - M[1,1]*M[2,0]
         out[2,1] = -M[0,0]*M[2,1] + M[0,1]*M[2,0]
         out[2,2] = M[0,0]*M[1,1] - M[0,1]*M[1,0]
-        out = out*det
+        out = out/det
     return out
 
 @njit(cache=True, nogil=True)