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

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -61,6 +61,9 @@ def run_job_multi(job: SimJob) -> SimJob:
         job.submit_solution(solution, report)
     return job
 
+def _init_worker():
+    nr = int(mp.current_process().name.split('-')[1])
+    DEFAULT_ROUTINE._configure_routine(proc_nr=nr)
 
 def _dimstring(data: list[float] | np.ndarray) -> str:
     """A String formatter for dimensions in millimeters
@@ -190,7 +193,6 @@ class Microwave3D:
                     logger.debug(f'Assinging PEC to {surf}')
                     self.bc.PEC(surf)
                 elif surf.material.cond.scalar(1e9) > self._settings.mw_2dbc_lim:
-                    logger.debug(f'Assigning SurfaceImpedance to {surf}')
                     self.bc.SurfaceImpedance(surf, surf.material)
                 
         
@@ -619,7 +621,7 @@ class Microwave3D:
     
     def run_sweep(self, 
                 parallel: bool = False,
-                njobs: int = 2, 
+                n_workers: int = 2, 
                 harddisc_threshold: int | None = None,
                 harddisc_path: str = 'EMergeSparse',
                 frequency_groups: int = -1,
@@ -627,7 +629,7 @@ class Microwave3D:
                 automatic_modal_analysis: bool = True) -> MWData:
         """Executes a frequency domain study
 
-        The study is distributed over "njobs" workers.
+        The study is distributed over "n_workers" workers.
         As optional parameter you may set a harddisc_threshold as integer. This determines the maximum
         number of degrees of freedom before which the jobs will be cahced to the harddisk. The
         path that will be used to cache the sparse matrices can be specified.
@@ -637,7 +639,7 @@ class Microwave3D:
         frequency indices will be precomputed and then solved: [[1,2,3,4],[5,6,7,8],[9,10,11]]
 
         Args:
-            njobs (int, optional): The number of jobs. Defaults to 2.
+            n_workers (int, optional): The number of workers. Defaults to 2.
             harddisc_threshold (int, optional): The number of DOF limit. Defaults to None.
             harddisc_path (str, optional): The cached matrix path name. Defaults to 'EMergeSparse'.
             frequency_groups (int, optional): The number of frequency points in a solve group. Defaults to -1.
@@ -687,7 +689,8 @@ class Microwave3D:
         ## DEFINE SOLVE FUNCTIONS
         def get_routine():
             if not hasattr(thread_local, "routine"):
-                thread_local.routine = self.solveroutine.duplicate()._configure_routine('MT')
+                worker_nr = int(threading.current_thread().name.split('_')[1])+1
+                thread_local.routine = self.solveroutine.duplicate()._configure_routine('MT', thread_nr=worker_nr)
             return thread_local.routine
 
         def run_job(job: SimJob):
@@ -750,7 +753,7 @@ class Microwave3D:
                 results.extend(group_results)
         elif not multi_processing:
              # MULTI THREADED
-            with ThreadPoolExecutor(max_workers=njobs) as executor:
+            with ThreadPoolExecutor(max_workers=n_workers, thread_name_prefix='WKR') as executor:
                 # ITERATE OVER FREQUENCIES
                 for i_group, fgroup in enumerate(freq_groups):
                     logger.info(f'Precomputing group {i_group}.')
@@ -771,7 +774,7 @@ class Microwave3D:
                         jobs.append(job)
                         matset.append(mats)
                     
-                    logger.info(f'Starting distributed solve of {len(jobs)} jobs with {njobs} threads.')
+                    logger.info(f'Starting distributed solve of {len(jobs)} jobs with {n_workers} threads.')
                     group_results = list(executor.map(run_job, jobs))
                     results.extend(group_results)
                 executor.shutdown()
@@ -784,7 +787,7 @@ class Microwave3D:
                     "if __name__ == '__main__' guard in the top-level script."
                 )
             # Start parallel pool
-            with mp.Pool(processes=njobs) as pool:
+            with mp.Pool(processes=n_workers, initializer=_init_worker) as pool:
                 for i_group, fgroup in enumerate(freq_groups):
                     logger.debug(f'Precomputing group {i_group}.')
                     jobs = []
@@ -810,7 +813,7 @@ class Microwave3D:
 
                     logger.info(
                         f'Starting distributed solve of {len(jobs)} jobs '
-                        f'with {njobs} processes in parallel'
+                        f'with {n_workers} processes in parallel'
                     )
                     # Distribute taks
                     group_results = pool.map(run_job_multi, jobs)

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -805,7 +805,7 @@ class LumpedPort(PortBC):
                  port_number: int, 
                  width: float | None = None,
                  height: float | None = None,
-                 direction: Axis | None = None,
+                 direction: Axis | tuple[float, float, float] | None = None,
                  power: float = 1,
                  Z0: float = 50):
         """Generates a lumped power boundary condition.
@@ -843,7 +843,7 @@ class LumpedPort(PortBC):
         
         self.width: float = width
         self.height: float = height # type: ignore
-        self.Vdirection: Axis = direction # type: ignore
+        self.Vdirection: Axis = _parse_axis(direction) # type: ignore
         self.type = 'TEM'
         
         # logger.info('Constructing coordinate system from normal port')

emerge/_emerge/physics/microwave/microwave_data.py

@@ -732,6 +732,15 @@ class MWField:
         self._z = zs
         return EHField(xs, ys, zs, self.Ex, self.Ey, self.Ez, self.Hx, self.Hy, self.Hz, self.freq, self.er, self.ur)
 
+    def boundary(self,
+                 selection: FaceSelection) -> EHField:
+        nodes = self.mesh.nodes
+        x = nodes[0,:]
+        y = nodes[1,:]
+        z = nodes[2,:]
+        field = self.interpolate(x, y, z, False)
+        return field
+    
     def cutplane(self, 
                      ds: float,
                      x: float | None = None,

emerge/_emerge/plot/pyvista/display.py

@@ -545,9 +545,16 @@ class PVDisplay(BaseDisplay):
             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]
@@ -680,6 +687,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