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

emerge/_emerge/plot/pyvista/display.py

@@ -539,15 +539,22 @@ class PVDisplay(BaseDisplay):
                      XYZ=None,
                      field: Literal['E','H'] = 'E', 
                      k0: float | None = None,
-                     mode_number: int = 0) -> None:
+                     mode_number: int | None = None) -> None:
         
         if XYZ:
             X,Y,Z = XYZ
         else:
             tris = self._mesh.get_triangles(port.selection.tags)
+            ids = np.sort(np.unique(self._mesh.tris[:,tris].flatten()))
             X = self._mesh.tri_centers[0,tris]
             Y = self._mesh.tri_centers[1,tris]
             Z = self._mesh.tri_centers[2,tris]
+            X2 = self._mesh.nodes[0,ids]
+            Y2 = self._mesh.nodes[1,ids]
+            Z2 = self._mesh.nodes[2,ids]
+            X = np.concatenate((X,X2))
+            Y = np.concatenate((Y,Y2))
+            Z = np.concatenate((Z,Z2))
         
         X = X+dv[0]
         Y = Y+dv[1]
@@ -577,7 +584,10 @@ class PVDisplay(BaseDisplay):
                 k0 = port.get_mode(0).k0
             else:
                 k0 = 1
-        port.selected_mode = mode_number
+        
+        if isinstance(mode_number, int):
+            port.selected_mode = mode_number
+        
         F = port.port_mode_3d_global(xf,yf,zf,k0, which=field)
 
         Fx = F[0,:].reshape(X.shape).T
@@ -680,6 +690,87 @@ class PVDisplay(BaseDisplay):
             self._objs.append(_AnimObject(field_flat, T, grid, grid_no_nan, actor, on_update))
         
         self._reset_cbar()
+    
+    def add_boundary_field(self, 
+                 selection: FaceSelection,
+                 field: tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray],
+                 scale: Literal['lin','log','symlog'] = 'lin',
+                 cmap: cmap_names | None = None,
+                 clim: tuple[float, float] | None = None,
+                 opacity: float = 1.0,
+                 symmetrize: bool = False,
+                 _fieldname: str | None = None,
+                 **kwargs,):
+        """Add a surface plot to the display based on a boundary surface
+       
+        The X,Y,Z coordinates must be a 2D grid of data points. The field must be a real field with the same size.
+
+        Example:
+        >>> display.add_boundary_field(selection, field.boundary(selction).scalar('normE','real'))
+        
+        Args:
+            selection (FaceSelection): The boundary to show the field on
+            field (tuple[np.ndarray]): The output of EMField().boundary().scalar()
+            scale (Literal["lin","log","symlog"], optional): The colormap scaling¹. Defaults to 'lin'.
+            cmap (cmap_names, optional): The colormap. Defaults to 'coolwarm'.
+            clim (tuple[float, float], optional): Specific color limits (min, max). Defaults to None.
+            opacity (float, optional): The opacity of the surface. Defaults to 1.0.
+            symmetrize (bool, optional): Wether to force a symmetrical color limit (-A,A). Defaults to True.
+        
+        (¹): lin: f(x)=x, log: f(x)=log₁₀(|x|), symlog: f(x)=sgn(x)·log₁₀(1+|x·ln(10)|)
+        """
+        
+        grid = self.mesh_surface(selection)
+        
+        field = field[3]
+        field_flat = field.flatten(order='F')
+        
+        if scale=='log':
+            T = lambda x: np.log10(np.abs(x+1e-12))
+        elif scale=='symlog':
+            T = lambda x: np.sign(x) * np.log10(1 + np.abs(x*np.log(10)))
+        else:
+            T = lambda x: x
+        
+        static_field = T(np.real(field_flat))
+        
+        if _fieldname is None:
+            name = 'anim'+str(self._ctr)
+        else:
+            name = _fieldname
+        self._ctr += 1
+        
+        grid[name] = static_field
+        
+        default_cmap = EMERGE_AMP
+        # Determine color limits
+        if clim is None:
+            if self._cbar_lim is not None:
+                clim = self._cbar_lim
+            else:
+                fmin = np.nanmin(static_field)
+                fmax = np.nanmax(static_field)
+                clim = (fmin, fmax)
+        
+        if symmetrize:
+            lim = max(abs(clim[0]), abs(clim[1]))
+            clim = (-lim, lim)
+            default_cmap = EMERGE_WAVE
+        
+        if cmap is None:
+            cmap = default_cmap
+        
+        kwargs = setdefault(kwargs, cmap=cmap, clim=clim, opacity=opacity, pickable=False, multi_colors=True)
+        actor = self._plot.add_mesh(grid, scalars=name, scalar_bar_args=self._cbar_args, **kwargs)
+
+        if self._do_animate:
+            def on_update(obj: _AnimObject, phi: complex):
+                field_anim = obj.T(np.real(obj.field * phi))
+                obj.grid[name] = field_anim
+                #obj.fgrid replace with thresholded scalar data.
+            self._objs.append(_AnimObject(field_flat, T, grid, grid, actor, on_update))
+        
+        self._reset_cbar()
         
     def add_title(self, title: str) -> None:
         """Adds a title

emerge/_emerge/simmodel.py

@@ -479,7 +479,7 @@ class Simulation:
         for geo in _GEOMANAGER.all_geometries():
             self.display.add_object(geo, mesh=plot_mesh, opacity=opacity, volume_mesh=volume_mesh, label=labels)
         if selections:
-            [self.display.add_object(sel, color='red', opacity=0.3, label=labels) for sel in selections]
+            [self.display.add_object(sel, color='red', opacity=0.6, label=labels) for sel in selections]
         self.display.show()
 
         return None
@@ -547,7 +547,7 @@ class Simulation:
         self._set_mesh(dataset['mesh'])
         return self
         
-    def generate_mesh(self) -> None:
+    def generate_mesh(self, regenerate: bool = False) -> None:
         """Generate the mesh. 
         This can only be done after commit_geometry(...) is called and if frequencies are defined.
 
@@ -557,26 +557,27 @@ class Simulation:
         Raises:
             ValueError: ValueError if no frequencies are defined.
         """
-        logger.trace('Starting mesh generation phase.')
-        if not self._defined_geometries:
-            self.commit_geometry()
-        
-        logger.trace(' (1) Installing periodic boundaries in mesher.')
-        # Set the cell periodicity in GMSH
-        if self._cell is not None:
-            self.mesher.set_periodic_cell(self._cell)
-        
-        self.mw._initialize_bcs(_GEOMANAGER.get_surfaces())
+        if not regenerate:
+            logger.trace('Starting mesh generation phase.')
+            if not self._defined_geometries:
+                self.commit_geometry()
+            
+            logger.trace(' (1) Installing periodic boundaries in mesher.')
+            # Set the cell periodicity in GMSH
+            if self._cell is not None:
+                self.mesher.set_periodic_cell(self._cell)
+            
+            self.mw._initialize_bcs(_GEOMANAGER.get_surfaces())
 
-        # Check if frequencies are defined: TODO: Replace with a more generic check
-        if self.mw.frequencies is None:
-            raise ValueError('No frequencies defined for the simulation. Please set frequencies before generating the mesh.')
+            # Check if frequencies are defined: TODO: Replace with a more generic check
+            if self.mw.frequencies is None:
+                raise ValueError('No frequencies defined for the simulation. Please set frequencies before generating the mesh.')
 
         gmsh.model.occ.synchronize()
 
         # Set the mesh size
         self.mesher._configure_mesh_size(self.mw.get_discretizer(), self.mw.resolution)
-        
+            
         logger.trace(' (2) Calling GMSH mesher')
         try:
             gmsh.logger.start()
@@ -589,6 +590,7 @@ class Simulation:
             logger.error('GMSH Mesh error detected.')
             print(_GMSH_ERROR_TEXT)
             raise
+        
         logger.info('GMSH Meshing complete!')
         self.mesh._pre_update(self.mesher._get_periodic_bcs())
         self.mesh.exterior_face_tags = self.mesher.domain_boundary_face_tags
@@ -596,6 +598,14 @@ class Simulation:
         self._set_mesh(self.mesh)
         logger.trace(' (3) Mesh routine complete')
 
+    def _reset_mesh(self):
+        #gmsh.clear()
+        gmsh.model.mesh.clear()
+        mesh = Mesh3D(self.mesher)
+        
+        self.mw.reset(False)
+        self._set_mesh(mesh)
+        
     def parameter_sweep(self, clear_mesh: bool = True, **parameters: np.ndarray) -> Generator[tuple[float,...], None, None]:
         """Executes a parameteric sweep iteration.
 
@@ -654,6 +664,67 @@ class Simulation:
         
         self.mw.cache_matrices = True
     
+    
+    def _beta_adaptive_mesh_refinement(self, 
+                                 max_steps: int = 6,
+                                 convergence: float = 0.02,
+                                 refinement_percentage: float = 0.1,
+                                 refinement_ratio: float = 0.3,
+                                 growth_rate: float = 3) -> None:
+        """Beta implementation of Adaptive Mesh Refinement
+
+        Args:
+            max_steps (int, optional): _description_. Defaults to 6.
+            convergence (float, optional): _description_. Defaults to 0.02.
+            refinement_percentage (float, optional): _description_. Defaults to 0.1.
+            refinement_ratio (float, optional): _description_. Defaults to 0.3.
+            growth_rate (float, optional): _description_. Defaults to 3.
+        """
+        from .physics.microwave.adaptive_mesh import select_refinement_indices, reduce_point_set, compute_convergence
+   
+        max_freq = np.max(self.mw.frequencies)
+        
+        regenerate = False
+        
+        Smats = []
+
+        for step in range(max_steps):
+            amr_params = dict(iter_step=step)
+            self.mw._params = amr_params
+            self.data.sim.new(**amr_params)
+            
+            
+            data = self.mw._run_adaptive_mesh(step, max_freq)
+            
+            field = data.field[-1]
+            
+            Smat_new = data.scalar[-1].Sp
+            Smats.append(Smat_new)
+            if step > 0:
+                S0 = Smats[-2]
+                S1 = Smats[-1]
+                conv = compute_convergence(S0, S1)
+                logger.info(f'Convergence = {conv}')
+                if conv < convergence:
+                    logger.info('Mesh refinement passed!')
+                    break
+            error, lengths = field._solution_quality()
+                
+            idx = select_refinement_indices(error, refinement_percentage)
+            
+            idx = idx[reduce_point_set(self.mw.mesh.centers[:,idx], growth_rate, lengths[idx], refinement_ratio)]
+            centers = self.mw.mesh.centers
+            
+            self.mesher._reset_amr_points()
+            self._reset_mesh()
+            logger.debug(f'Adding {len(idx)} refinement points.')
+            for i in idx:
+                coord = centers[:,i]
+                size = lengths[i]
+                self.mesher.add_refinement_point(coord, refinement_ratio, size, growth_rate)
+            
+            self.generate_mesh(True)            
+            self.view(plot_mesh=True)
     def export(self, filename: str):
         """Exports the model or mesh depending on the extension.