emerge 0.6.11__py3-none-any.whl → 1.0.1__py3-none-any.whl

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -19,12 +19,14 @@ from ...mesher import Mesher
 from ...material import Material
 from ...mesh3d import Mesh3D
 from ...coord import Line
+from ...geometry import GeoSurface
 from ...elements.femdata import FEMBasis
 from ...elements.nedelec2 import Nedelec2
 from ...solver import DEFAULT_ROUTINE, SolveRoutine
 from ...system import called_from_main_function
 from ...selection import FaceSelection
 from ...mth.optimized import compute_distances
+from ...settings import Settings
 from .microwave_bc import MWBoundaryConditionSet, PEC, ModalPort, LumpedPort, PortBC
 from .microwave_data import MWData
 from .assembly.assembler import Assembler
@@ -122,16 +124,16 @@ class Microwave3D:
     formulation.
 
     """
-    def __init__(self, mesher: Mesher, mwdata: MWData, order: int = 2):
+    def __init__(self, mesher: Mesher, settings: Settings, mwdata: MWData, order: int = 2):
         self.frequencies: list[float] = []
         self.current_frequency = 0
         self.order: int = order
         self.resolution: float = 1
-
+        self._settings: Settings = settings
         self.mesher: Mesher = mesher
         self.mesh: Mesh3D = Mesh3D(self.mesher)
 
-        self.assembler: Assembler = Assembler()
+        self.assembler: Assembler = Assembler(self._settings)
         self.bc: MWBoundaryConditionSet = MWBoundaryConditionSet(None)
         self.basis: Nedelec2 | None = None
         self.solveroutine: SolveRoutine = DEFAULT_ROUTINE
@@ -190,14 +192,28 @@ class Microwave3D:
         return sorted(self.bc.oftype(PortBC), key=lambda x: x.number) # type: ignore
     
     
-    def _initialize_bcs(self) -> None:
+    def _initialize_bcs(self, surfaces: list[GeoSurface]) -> None:
         """Initializes the boundary conditions to set PEC as all exterior boundaries.
         """
         logger.debug('Initializing boundary conditions.')
 
         tags = self.mesher.domain_boundary_face_tags
+        
+        # Assigning surface impedance boundary condition
+        if self._settings.mw_2dbc:
+            for surf in surfaces:
+                if surf.material.cond.scalar(1e9) > self._settings.mw_2dbc_peclim:
+                    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)
+                
+        
         tags = [tag for tag in tags if tag not in self.bc.assigned(2)]
+        
         self.bc.PEC(FaceSelection(tags))
+        
         logger.info(f'Adding PEC boundary condition with tags {tags}.')
         if self.mesher.periodic_cell is not None:
             self.mesher.periodic_cell.generate_bcs()
@@ -247,6 +263,12 @@ class Microwave3D:
             resolution (float): The desired wavelength fraction.
             
         """
+        if resolution > 0.5:
+            logger.warning('Resolutions greater than 0.5 cannot yield accurate results, capping resolution to 0.4')
+            resolution = 0.4
+        elif resolution > 0.334:
+            logger.warning('A resolution greater than 0.33 may cause accuracy issues.')
+        
         self.resolution = resolution
 
     def set_conductivity_limit(self, condutivity: float) -> None:
@@ -292,6 +314,7 @@ class Microwave3D:
         ''' Initializes auxilliary required boundary condition information before running simulations.
         '''
         logger.debug('Initializing boundary conditions')
+        self.bc.cleanup()
         for port in self.bc.oftype(LumpedPort):
             self.define_lumped_port_integration_points(port)
     
@@ -572,10 +595,10 @@ class Microwave3D:
             elif TEM:
                 G1, G2 = self._find_tem_conductors(port, sigtri=cond)
                 cs, dls = self._compute_integration_line(G1,G2)
-                mode.modetype='TEM'
+                mode.modetype = 'TEM'
                 Ex, Ey, Ez = portfE(cs[0,:], cs[1,:], cs[2,:])
                 voltage = np.sum(Ex*dls[0,:] + Ey*dls[1,:] + Ez*dls[2,:])
-                mode.Z0 = voltage**2/(2*P)
+                mode.Z0 = abs(voltage**2/(2*P))
                 logger.debug(f'Port Z0 = {mode.Z0}')
 
             mode.set_power(P*port._qmode(k0)**2)

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -73,11 +73,11 @@ class MWBoundaryConditionSet(BoundaryConditionSet):
         """
         bcs = self.oftype(PEC)
         for bc in self.oftype(SurfaceImpedance):
-            if bc.sigma > 1e3:
+            if bc.sigma > 10.0:
                 bcs.append(bc)
 
         return bcs
-
+        
     def get_type(self, bctype: Literal['PEC','ModalPort','LumpedPort','PMC','LumpedElement','RectangularWaveguide','Periodic','FloquetPort','SurfaceImpedance']) -> FaceSelection:
         tags = []
         for bc in self.boundary_conditions:
@@ -545,7 +545,7 @@ class ModalPort(PortBC):
                 self.modes[k0] = new_modes
             return
         for k0, modes in self.modes.items():
-            self.modes[k0] = sorted(modes, key=lambda m: m.energy, reverse=True)
+            self.modes[k0] = sorted(modes, key=lambda m: m.beta, reverse=True)
 
     def get_mode(self, k0: float, i=None) -> PortMode:
         """Returns a given mode solution in the form of a PortMode object.
@@ -1002,6 +1002,7 @@ class SurfaceImpedance(RobinBC):
                  material: Material | None = None,
                  surface_conductance: float | None = None,
                  surface_roughness: float = 0,
+                 thickness: float | None = None,
                  sr_model: Literal['Hammerstad-Jensen'] = 'Hammerstad-Jensen',
                  ):
         """Generates a SurfaceImpedance bounary condition.
@@ -1021,7 +1022,8 @@ class SurfaceImpedance(RobinBC):
             material (Material | None, optional): The matrial to assign. Defaults to None.
             surface_conductance (float | None, optional): The specific bulk conductivity to use. Defaults to None.
             surface_roughness (float, optional): The surface roughness. Defaults to 0.
-            sr_model (Literal['Hammerstad, optional): The surface roughness model. Defaults to 'Hammerstad-Jensen'.
+            thickness (float | None, optional): The layer thickness. Defaults to None
+            sr_model (Literal["Hammerstad-Jensen", optional): The surface roughness model. Defaults to 'Hammerstad-Jensen'.
         """
         super().__init__(face)
 
@@ -1029,9 +1031,13 @@ class SurfaceImpedance(RobinBC):
         self._mur: float | complex = 1.0
         self._epsr: float | complex = 1.0
         self.sigma: float = 0.0
+        self.thickness: float | None = thickness
         
+        if isinstance(face, GeoObject) and thickness is None:
+            self.thickness = face._load('thickness')
+            
         if material is not None:
-            self.sigma = material.cond
+            self.sigma = material.cond.scalar(1e9)
             self._mur = material.ur
             self._epsr = material.er
         
@@ -1064,13 +1070,20 @@ class SurfaceImpedance(RobinBC):
         
         w0 = k0*C0
         f0 = w0/(2*np.pi)
-        sigma = self.sigma.scalar(f0)
+        sigma = self.sigma
         mur = self._material.ur.scalar(f0)
         er = self._material.er.scalar(f0)
-        
+        eps = EPS0*er
+        mu = MU0*mur
         rho = 1/sigma
-        d_skin = (2*rho/(w0*MU0*mur) * ((1+(w0*EPS0*er*rho)**2)**0.5 + rho*w0*EPS0*er))**0.5
-        R = rho/d_skin
+        d_skin = (2*rho/(w0*mu) * ((1+(w0*eps*rho)**2)**0.5 + rho*w0*eps))**0.5
+        logger.debug(f'Computed skin depth δ={d_skin*1e6:.2}μm')
+        R = (1+1j)*rho/d_skin
+        if self.thickness is not None:
+            eps_c = eps - 1j * sigma / w0
+            gamma_m = 1j * w0 * np.sqrt(mu*eps_c)
+            R = R / np.tanh(gamma_m * self.thickness)
+            logger.debug(f'Impedance scaler due to thickness: {1/ np.tanh(gamma_m * self.thickness) :.4f}')
         if self._sr_model=='Hammerstad-Jensen' and self._sr > 0.0:
             R = R * (1 + 2/np.pi * np.arctan(1.4*(self._sr/d_skin)**2))
         return 1j*k0*Z0/R

emerge/_emerge/physics/microwave/microwave_data.py

@@ -1137,6 +1137,9 @@ class MWScalarNdim:
         self._portmap: dict[int, float|int] = dict()
         self._portnumbers: list[int | float] = []
 
+    def dense_f(self, N: int) -> np.ndarray:
+        return np.linspace(np.min(self.freq), np.max(self.freq), N)
+    
     def S(self, i1: int, i2: int) -> np.ndarray:
         return self.Sp[...,self._portmap[i1], self._portmap[i2]]
     

emerge/_emerge/plot/pyvista/display.py

@@ -435,7 +435,7 @@ class PVDisplay(BaseDisplay):
             return None
 
     ## OBLIGATORY METHODS
-    def add_object(self, obj: GeoObject | Selection, mesh: bool = False, volume_mesh: bool = True, *args, **kwargs):
+    def add_object(self, obj: GeoObject | Selection, mesh: bool = False, volume_mesh: bool = True, label: bool = False, *args, **kwargs):
         
         show_edges = False
         opacity = obj.opacity
@@ -446,13 +446,13 @@ class PVDisplay(BaseDisplay):
         
         # Default render settings
         metallic = 0.05
-        roughness = 0.5
+        roughness = 0.0
         pbr = False
         
         if metal:
             pbr = True
             metallic = 0.8
-            roughness = 0.3
+            roughness = self.set.metal_roughness
         
         # Default keyword arguments when plotting Mesh mode.
         if mesh is True:
@@ -482,10 +482,24 @@ class PVDisplay(BaseDisplay):
         if obj.dim==3:
             mapper = actor.GetMapper()
             mapper.SetResolveCoincidentTopology(1)
-            mapper.SetRelativeCoincidentTopologyPolygonOffsetParameters(1,1)
+            mapper.SetRelativeCoincidentTopologyPolygonOffsetParameters(1,0.5)
         
         self._plot.add_mesh(self._volume_edges(_select(obj)), color='#000000', line_width=2, show_edges=True)
 
+        if isinstance(obj, GeoObject) and label:
+            points = []
+            labels = []
+            for dt in obj.dimtags:
+                points.append(self._mesh.dimtag_to_center[dt])
+                labels.append(obj.name)
+            self._plot.add_point_labels(points, labels, shape_color='white')
+            
+    def add_objects(self, *objects, **kwargs) -> None:
+        """Add a series of objects provided as a list of arguments
+        """
+        for obj in objects:
+            self.add_object(obj, **kwargs)
+        
     def add_scatter(self, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray):
         """Adds a scatter point cloud
 
@@ -569,10 +583,10 @@ class PVDisplay(BaseDisplay):
                  z: np.ndarray,
                  field: np.ndarray,
                  scale: Literal['lin','log','symlog'] = 'lin',
-                 cmap: cmap_names = 'coolwarm',
+                 cmap: cmap_names = 'viridis',
                  clim: tuple[float, float] | None = None,
                  opacity: float = 1.0,
-                 symmetrize: bool = True,
+                 symmetrize: bool = False,
                  _fieldname: str | None = None,
                  **kwargs,):
         """Add a surface plot to the display

emerge/_emerge/plot/pyvista/display_settings.py

@@ -23,6 +23,7 @@ class PVDisplaySettings:
         self.background_bottom: str = "#c0d2e8"
         self.background_top: str = "#ffffff"
         self.grid_line_color: str = "#8e8e8e"
-        self.z_boost: float = 0#1e-9
+        self.z_boost: float = 0.0
         self.depth_peeling: bool = True
         self.anti_aliassing: Literal["msaa","ssaa",'fxaa'] = "msaa"
+        self.metal_roughness: float = 0.3

emerge/_emerge/plot/simple_plots.py

@@ -317,6 +317,7 @@ and sparse frequency annotations (e.g., labeled by frequency).
     colors_list  = _broadcast(colors, None, 'colors')
     lw_list      = _broadcast(linewidth, None, 'linewidth')
     labels_list: Optional[List[Optional[str]]]
+    
     if labels is None:
         labels_list = None
     else:
@@ -377,7 +378,9 @@ and sparse frequency annotations (e.g., labeled by frequency).
 
         # frequency labels (sparse)
         fi = fs_list[i]
-        if fi[0] is not None and n_flabels > 0 and len(s) > 0 and len(fi) > 0:
+        if fi is None:
+            continue
+        if n_flabels > 0 and len(s) > 0 and len(fi) > 0:
             n = min(len(s), len(fi))
             step = max(1, int(round(n / n_flabels))) if n_flabels > 0 else n  # avoid step=0
             idx = np.arange(0, n, step)

emerge/_emerge/selection.py

@@ -537,9 +537,8 @@ class Selector:
                 x: float,
                 y: float,
                 z: float,
-                nx: float,
-                ny: float,
-                nz: float,
+                normal_axis: Axis | tuple[float, float, float] | None = None,
+                plane: Plane | None = None,
                 tolerance: float = 1e-8) -> FaceSelection:
         """Returns a FaceSelection for all faces that lie in a provided infinite plane
         specified by an origin plus a plane normal vector.
@@ -548,17 +547,20 @@ class Selector:
             x (float): The plane origin X-coordinate
             y (float): The plane origin Y-coordinate
             z (float): The plane origin Z-coordinate
-            nx (float): The plane normal X-component
-            ny (float): The plane normal Y-component
-            nz (float): The plane normal Z-component
+            normal_axis (Axis, tuple): The plane normal vector
             tolerance (float, optional): An in plane tolerance (displacement and normal dot product). Defaults to 1e-6.
 
         Returns:
             FaceSelection: All faces that lie in the specified plane
         """
         orig = np.array([x,y,z])
-        norm = np.array([nx,ny,nz])
-        norm = norm/np.linalg.norm(norm)
+        if plane is not None:
+            norm = plane.normal.np
+        elif normal_axis is not None:
+            norm = _parse_vector(normal_axis)
+            norm = norm/np.linalg.norm(norm)
+        else:
+            raise RuntimeError('No plane or axis defined for selection.')
         
         dimtags = gmsh.model.getEntities(2)
         coords = [gmsh.model.occ.getCenterOfMass(*tag) for tag in dimtags]

emerge/_emerge/settings.py

@@ -0,0 +1,12 @@
+
+from typing import Literal
+
+class Settings:
+    
+    def __init__(self):
+        self.mw_2dbc: bool = True
+        self.mw_2dbc_lim: float = 10.0
+        self.mw_2dbc_peclim: float = 1e8
+        self.mw_3d_peclim: float = 1e7
+        
+DEFAULT_SETTINGS = Settings()