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

emerge/_emerge/mesher.py

@@ -75,6 +75,9 @@ 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.min_size: float = None
         self.max_size: float = None
         self.periodic_cell: PeriodicCell = None
@@ -172,11 +175,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:
@@ -222,8 +225,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 +241,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 +275,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,11 +287,53 @@ 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_points(self, coords: np.ndarray, sizes: np.ndarray) -> None:
+        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))
             
+    def set_refinement_function(self,
+                                refinement: float,
+                                gr: float = 1.5,
+                                _qf: float = 1.0):
+        xs = self._amr_coords[0,:]
+        ys = self._amr_coords[1,:]
+        zs = self._amr_coords[2,:]
+        newsize = refinement*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.sqrt((x-xs)**2 + (y-ys)**2 + (z-zs)**2))
+            return min(lc,  float(np.min(sizes)))
+        gmsh.model.mesh.setSizeCallback(func)
+        
+    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,
-                          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
 
@@ -305,8 +355,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)
@@ -323,7 +373,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)