emerge 0.6.10__tar.gz → 1.0.0__tar.gz

{emerge-0.6.10 → emerge-1.0.0}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.6.10"
+current_version = "1.0.0"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{emerge-0.6.10 → emerge-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 0.6.10
+Version: 1.0.0
 Summary: An open source EM FEM simulator in Python
 Project-URL: Homepage, https://github.com/FennisRobert/EMerge
 Project-URL: Issues, https://github.com/FennisRobert/EMerge/issues
@@ -82,17 +82,13 @@ To run this FEM library you need the following libraries
  - numba
  - matplotlib (for the matplotlib base display)
  - pyvista (for the PyVista base display)
- - numba-progress
+ - cloudpickle
  - mkl (x86 devices only)
 
 Optional:
  - scikit-umfpack
  - cudss
 
-## NOTICE
+## Resources / Manual
 
-First time runs will be very slow because Numba needs to generate local C-compiled functions of the assembler and other mathematical functions. These compilations are chached so this should only take time once.
-
-## Third Party License Notice
-
-“This package depends on Intel® Math Kernel Library (MKL), which is licensed separately under the Intel Simplified Software License (October 2022). Installing with pip will fetch the MKL wheel and prompt you to accept that licence.”
+You can find the latest versions of the manual on: **https://www.emerge-software.com/resources/**

{emerge-0.6.10 → emerge-1.0.0}/README.md

@@ -56,17 +56,13 @@ To run this FEM library you need the following libraries
  - numba
  - matplotlib (for the matplotlib base display)
  - pyvista (for the PyVista base display)
- - numba-progress
+ - cloudpickle
  - mkl (x86 devices only)
 
 Optional:
  - scikit-umfpack
  - cudss
 
-## NOTICE
+## Resources / Manual
 
-First time runs will be very slow because Numba needs to generate local C-compiled functions of the assembler and other mathematical functions. These compilations are chached so this should only take time once.
-
-## Third Party License Notice
-
-“This package depends on Intel® Math Kernel Library (MKL), which is licensed separately under the Intel Simplified Software License (October 2022). Installing with pip will fetch the MKL wheel and prompt you to accept that licence.”
+You can find the latest versions of the manual on: **https://www.emerge-software.com/resources/**

{emerge-0.6.10 → emerge-1.0.0}/emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "0.6.10"
+__version__ = "1.0.0"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #

{emerge-0.6.10 → emerge-1.0.0}/emerge/_emerge/bc.py

@@ -53,7 +53,7 @@ class BoundaryCondition:
         
         
         if isinstance(assignment, GeoObject):
-            assignment = assignment.select
+            assignment = assignment.selection
         
         self.selection: Selection = assignment
         self.tags: list[int] = self.selection.tags
@@ -83,7 +83,7 @@ class BoundaryCondition:
             raise ValueError(f'All tags must have the same dimension, instead its {tags}')
         dimension = tags[0][0]
         if self.dimension is BCDimension.ANY:
-            logger.info(f'Assigning dimension {BCDimension(dimension)} to {self}')
+            logger.info(f'Assigning {self} to dimension{BCDimension(dimension)}')
             self.dimension = BCDimension(dimension)
         elif self.dimension != BCDimension(dimension):
             raise ValueError(f'Current boundary condition has dimension {self.dimension}, but tags have dimension {BCDimension(dimension)}')
@@ -131,6 +131,13 @@ class BoundaryConditionSet:
         self.boundary_conditions: list[BoundaryCondition] = []
         self._initialized: bool = False
     
+    def cleanup(self) -> None:
+        """ Removes non assigned boundary conditions"""
+        logger.trace("Cleaning up boundary conditions.")
+        toremove = [bc for bc in self.boundary_conditions if len(bc.tags)==0]
+        logger.trace(f"Removing: {toremove}")
+        self.boundary_conditions = [bc for bc in self.boundary_conditions if len(bc.tags)>0]
+        
     def _construct_bc(self, constructor: type) -> type:
         def constr(*args, **kwargs):
             obj = constructor(*args, **kwargs)
@@ -201,8 +208,6 @@ class BoundaryConditionSet:
 
         bc.add_tags(bc.selection.dimtags)
 
-        logger.info('Excluding other possible boundary conditions')
-
         for existing_bc in self.boundary_conditions:
             excluded = existing_bc.exclude_bc(bc)
             if excluded:

emerge-1.0.0/emerge/_emerge/cacherun.py

@@ -0,0 +1,79 @@
+# inside your module, e.g. utils.py
+import os
+import sys
+
+import ast
+import textwrap
+from pathlib import Path
+
+
+def _is_plain_check_run(test: ast.AST) -> bool:
+    """True only for a bare call to check_run() as the entire if-test."""
+    if not isinstance(test, ast.Call) or test.args or test.keywords:
+        return False
+    f = test.func
+    return (
+        isinstance(f, ast.Attribute) and f.attr == "cache_run"
+    ) or (
+        isinstance(f, ast.Name) and f.id == "cache_run"
+    )
+
+def get_run_block_str(source: str) -> str:
+    """
+    Return all source text before the first `if check_run():` / `if *.check_run():`.
+    Returns None if no matching if-statement exists.
+    """
+    tree = ast.parse(source)
+    candidates = [n for n in ast.walk(tree) if isinstance(n, ast.If) and _is_plain_check_run(n.test)]
+    if not candidates:
+        return None
+    first = min(candidates, key=lambda n: n.lineno)
+    lines = source.splitlines(keepends=True)
+    return "".join(lines[: first.lineno - 1])
+
+
+def get_build_block_str(source: str) -> str | None:
+    """Return the code string inside the first `if *.checkrun(...):` block, or None."""
+    tree = ast.parse(source)
+    for node in ast.walk(tree):
+        if isinstance(node, ast.If) and isinstance(node.test, ast.Call):
+            f = node.test.func
+            called = (isinstance(f, ast.Attribute) and f.attr == "cache_build") or \
+                     (isinstance(f, ast.Name) and f.id == "cache_build")
+            if called and node.body:
+                start = node.body[0].lineno - 1           # 0-based start line
+                end = node.body[-1].end_lineno            # 1-based end line (inclusive)
+                lines = source.splitlines()
+                block = "\n".join(lines[start:end])
+                return textwrap.dedent(block)
+    return None
+
+def entry_script_path():
+    main = sys.modules.get("__main__")
+    # Most normal runs: python path/to/app.py
+    if main and hasattr(main, "__file__"):
+        return os.path.abspath(main.__file__)
+    # Fallbacks (e.g. python -m pkg.mod)
+    if sys.argv and sys.argv[0] not in ("", "-c"):
+        return os.path.abspath(sys.argv[0])
+    # Interactive sessions, notebooks, or embedded interpreters
+    return None
+
+
+def get_build_section() -> str:
+    """ Returns the string section inside the check_build() if statement"""
+    name = entry_script_path()
+
+    lines = get_build_block_str(Path(name).read_text())
+    return lines
+
+def get_run_section() -> str:
+    """Return sthe string section before the check_run() if statement
+
+    Returns:
+        str: _description_
+    """
+    name = entry_script_path()
+
+    lines = get_run_block_str(Path(name).read_text())
+    return lines

{emerge-0.6.10 → emerge-1.0.0}/emerge/_emerge/geo/pcb.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 
 from ..cs import CoordinateSystem, GCS, Axis
 from ..geometry import GeoPolygon, GeoVolume, GeoSurface
-from ..material import Material, AIR, COPPER
+from ..material import Material, AIR, COPPER, PEC
 from .shapes import Box, Plate, Cylinder
 from .polybased import XYPolygon
 from .operations import change_coordinate_system, unite
@@ -86,7 +86,7 @@ class PCBPoly:
                  xs: list[float],
                  ys: list[float],
                  z: float = 0,
-                 material: Material = COPPER):
+                 material: Material = PEC):
         self.xs: list[float] = xs
         self.ys: list[float] = ys
         self.z: float = z
@@ -906,12 +906,14 @@ class PCB:
                  unit: float = 0.001,
                  cs: CoordinateSystem | None = None,
                  material: Material = AIR,
+                 trace_material: Material = PEC,
                  layers: int = 2,
                  ):
 
         self.thickness: float = thickness
         self._zs: np.ndarray = np.linspace(-self.thickness, 0, layers)
         self.material: Material = material
+        self.trace_material: Material = trace_material
         self.width: float | None = None
         self.length: float | None = None
         self.origin: np.ndarray = np.array([0.,0.,0.])
@@ -926,6 +928,9 @@ class PCB:
         self.cs: CoordinateSystem = cs
         if self.cs is None:
             self.cs = GCS
+            
+        self.dielectric_priority: int = 11
+        self.via_priority: int = 12
 
         self.traces: list[GeoPolygon] = []
         self.ports: list[GeoPolygon] = []
@@ -1110,7 +1115,7 @@ class PCB:
 
         plane = Plate(origin, (width*self.unit, 0, 0), (0, height*self.unit, 0)) # type: ignore
         plane = change_coordinate_system(plane, self.cs) # type: ignore
-        plane.set_material(COPPER)
+        plane.set_material(self.trace_material)
         return plane # type: ignore
     
     def generate_pcb(self, 
@@ -1140,9 +1145,10 @@ class PCB:
                           position=(x0, y0, z0+z1*self.unit))
                 box.material = self.material
                 box = change_coordinate_system(box, self.cs)
+                box.prio_set(self.dielectric_priority)
                 boxes.append(box)
             if merge:
-                return GeoVolume.merged(boxes) # type: ignore
+                return GeoVolume.merged(boxes).prio_set(self.dielectric_priority) # type: ignore
             return boxes # type: ignore
         
         box = Box(self.width*self.unit, 
@@ -1150,6 +1156,7 @@ class PCB:
                   self.thickness*self.unit, 
                   position=(x0,y0,z0-self.thickness*self.unit))
         box.material = self.material
+        box.prio_set(self.dielectric_priority)
         box = change_coordinate_system(box, self.cs)
         return box # type: ignore
 
@@ -1304,7 +1311,8 @@ class PCB:
             xg, yg, zg = self.cs.in_global_cs(x0, y0, z0)
             cs = CoordinateSystem(self.cs.xax, self.cs.yax, self.cs.zax, np.array([xg, yg, zg]))
             cyl = Cylinder(via.radius*self.unit, (via.z2-via.z1)*self.unit, cs, via.segments)
-            cyl.material = COPPER
+            cyl.material = self.trace_material
+            cyl.prio_set(self.via_priority)
             vias.append(cyl)
         if merge:
             
@@ -1315,7 +1323,7 @@ class PCB:
                  xs: list[float],
                  ys: list[float],
                  z: float = 0,
-                 material: Material = COPPER) -> None:
+                 material: Material = None) -> None:
         """Add a custom polygon to the PCB
 
         Args:
@@ -1324,6 +1332,8 @@ class PCB:
             z (float, optional): The z-height. Defaults to 0.
             material (Material, optional): The material. Defaults to COPPER.
         """
+        if material is None:
+            material = self.trace_material
         self.polies.append(PCBPoly(xs, ys, z, material))
 
     def _gen_poly(self, xys: list[tuple[float, float]], z: float) -> GeoPolygon:
@@ -1385,7 +1395,7 @@ class PCB:
                     ally.append(y)
             
             poly = self._gen_poly(xys2, z)
-            poly.material = COPPER
+            poly.material = self.trace_material
             polys.append(poly)
 
         for pcbpoly in self.polies:

{emerge-0.6.10 → emerge-1.0.0}/emerge/_emerge/geometry.py

@@ -50,6 +50,9 @@ class _GeometryManager:
         self.geometry_list: dict[str, list[GeoObject]] = dict()
         self.active: str = ''
 
+    def get_surfaces(self) -> list[GeoSurface]:
+        return [geo for geo in self.all_geometries() if geo.dim==2]
+    
     def all_geometries(self, model: str | None = None) -> list[GeoObject]:
         if model is None:
             model = self.active
@@ -250,7 +253,7 @@ class GeoObject:
         return self.material._metal
     
     @property
-    def select(self) -> Selection:
+    def selection(self) -> Selection:
         '''Returns a corresponding Face/Domain or Edge Selection object'''
         if self.dim==1:
             return EdgeSelection(self.tags)
@@ -391,6 +394,30 @@ class GeoObject:
         self._priority = level
         return self
     
+    def above(self, other: GeoObject) -> GeoObject:
+        """Puts the priority of this object one higher than the other, then returns this object
+
+        Args:
+            other (GeoObject): The other object to put below this object
+
+        Returns:
+            GeoObject: This object
+        """
+        self._priority = other._priority + 1
+        return self
+    
+    def below(self, other: GeoObject) -> GeoObject:
+        """Puts the priority of this object one lower than the other, then returns this object
+
+        Args:
+            other (GeoObject): The other object to put above this object
+
+        Returns:
+            GeoObject: This object
+        """
+        self._priority = other._priority -1
+        return self
+        
     def prio_up(self) -> GeoObject:
         """Increases the material selection priority by 1
 
@@ -517,14 +544,14 @@ class GeoVolume(GeoObject):
             self.tags = [tag,]
 
     @property
-    def select(self) -> DomainSelection:
+    def selection(self) -> DomainSelection:
         return DomainSelection(self.tags)
     
 class GeoPoint(GeoObject):
     dim = 0
 
     @property
-    def select(self) -> PointSelection:
+    def selection(self) -> PointSelection:
         return PointSelection(self.tags)
     
     def __init__(self, tag: int | list[int]):
@@ -540,7 +567,7 @@ class GeoEdge(GeoObject):
     dim = 1
 
     @property
-    def select(self) -> EdgeSelection:
+    def selection(self) -> EdgeSelection:
         return EdgeSelection(self.tags)
     
     def __init__(self, tag: int | list[int]):
@@ -558,7 +585,7 @@ class GeoSurface(GeoObject):
     dim = 2
 
     @property
-    def select(self) -> FaceSelection:
+    def selection(self) -> FaceSelection:
         return FaceSelection(self.tags)
     
     def __init__(self, tag: int | list[int]):

{emerge-0.6.10 → emerge-1.0.0}/emerge/_emerge/material.py

@@ -381,4 +381,5 @@ class Material:
         return self._color_rgb
      
 AIR = Material(color="#4496f3", opacity=0.05, name='Air')
-COPPER = Material(cond=5.8e7, color="#62290c", _metal=True, name='Copper')
+COPPER = Material(cond=5.8e7, color="#62290c", _metal=True, name='Copper')
+PEC = Material(color="#ff78aa", opacity=1.0, cond=1e30, _metal=True, name="PEC")

{emerge-0.6.10 → emerge-1.0.0}/emerge/_emerge/physics/microwave/assembly/assembler.py

@@ -22,6 +22,7 @@ from ....elements.nedleg2 import NedelecLegrange2
 from ....mth.optimized import gaus_quad_tri
 from ....mth.pairing import pair_coordinates
 from ....material import Material
+from ....settings import Settings
 from scipy.sparse import csr_matrix
 from loguru import logger
 from ..simjob import SimJob
@@ -102,13 +103,10 @@ class Assembler:
 
     It stores some cached properties to accellerate preformance.
     """
-    def __init__(self):
+    def __init__(self, settings: Settings):
         
         self.cached_matrices = None
-        self.conductivity_limit = 1e7
-        # Currently not used.
-        #self._Pmat_cache: dict[tuple[int,int], csr_matrix] = dict()
-        #self._remove_cache: list[int] = []
+        self.settings = settings
     
     def assemble_bma_matrices(self,
                               field: Nedelec2,
@@ -155,20 +153,22 @@ class Assembler:
         E, B = generelized_eigenvalue_matrix(nedlegfield, ermesh, urmesh, port.cs._basis, k0)
 
         # TODO: Simplified to all "conductors" loosely defined. Must change to implementing line robin boundary conditions.
-        pecs: list[BoundaryCondition] = bc_set.get_conductors()#[bc for bc in bcs if isinstance(bc,PEC)]
+        pecs: list[BoundaryCondition] = bc_set.get_conductors()
         if len(pecs) > 0:
-            logger.debug(f'.total of equiv. {len(pecs)} PEC BCs implemented')
+            logger.debug(f'.total of equiv. {len(pecs)} PEC BCs implemented for BMA')
 
         pec_ids = []
 
         # Process all concutors. Everything above the conductivity limit is considered pec.
         for it in range(boundary_surface.n_tris):
-            if sigmesh[it] > self.conductivity_limit:
+            if sigmesh[it] > self.settings.mw_3d_peclim:
                 pec_ids.extend(list(nedlegfield.tri_to_field[:,it]))
 
         # Process all PEC Boundary Conditions
         for pec in pecs:
             logger.trace(f'.implementing {pec}')
+            if len(pec.tags)==0:
+                continue
             face_tags = pec.tags
             tri_ids = mesh.get_triangles(face_tags)
             edge_ids = list(mesh.tri_to_edge[:,tri_ids].flatten())
@@ -235,7 +235,7 @@ class Assembler:
         
         er = er*(1-1j*tand) - 1j*cond/(W0*EPS0)
         
-        is_frequency_dependent = is_frequency_dependent or np.any((cond > 0) & (cond < self.conductivity_limit)) # type: ignore
+        is_frequency_dependent = is_frequency_dependent or np.any((cond > 0) & (cond < self.settings.mw_3d_peclim)) # type: ignore
 
         if cache_matrices and not is_frequency_dependent and self.cached_matrices is not None:
             # IF CACHED AND AVAILABLE PULL E AND B FROM CACHE
@@ -273,11 +273,11 @@ class Assembler:
         # Conductivity above al imit, consider it all PEC
         ipec = 0
         for itet in range(field.n_tets):
-            if cond[0,0,itet] > self.conductivity_limit:
+            if cond[0,0,itet] > self.settings.mw_3d_peclim:
                 ipec+=1
                 pec_ids.extend(field.tet_to_field[:,itet])
         if ipec>0:
-            logger.trace(f'Extended PEC with {ipec} tets with a conductivity > {self.conductivity_limit}.')
+            logger.trace(f'Extended PEC with {ipec} tets with a conductivity > {self.settings.mw_3d_peclim}.')
 
         for pec in pec_bcs:
             logger.trace(f'Implementing: {pec}')
@@ -466,7 +466,7 @@ class Assembler:
         
         # Conductivity above a limit, consider it all PEC
         for itet in range(field.n_tets):
-            if cond[0,0,itet] > self.conductivity_limit:
+            if cond[0,0,itet] > self.settings.mw_3d_peclim:
                 pec_ids.extend(field.tet_to_field[:,itet])
         
         # PEC Boundary conditions

{emerge-0.6.10 → emerge-1.0.0}/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)
     
@@ -311,22 +334,25 @@ class Microwave3D:
 
         if points.size==0:
             raise SimulationError(f'The lumped port {port} has no nodes associated with it')
+        
         xs = self.mesh.nodes[0,points]
         ys = self.mesh.nodes[1,points]
         zs = self.mesh.nodes[2,points]
 
         dotprod = xs*field_axis[0] + ys*field_axis[1] + zs*field_axis[2]
 
-        start_id = points[np.argwhere(dotprod == np.min(dotprod))]
+        start_id = np.argwhere(dotprod == np.min(dotprod)).flatten()
+        
+        xs = xs[start_id]
+        ys = ys[start_id]
+        zs = zs[start_id]
         
-        start = _pick_central(self.mesh.nodes[:,start_id.flatten()])
-        logger.info(f'Starting node = {_dimstring(start)}')
-        end = start + port.Vdirection.np*port.height
-
-
-        port.vintline = Line.from_points(start, end, 21)
 
-        logger.info(f'Ending node = {_dimstring(end)}')
+        for x,y,z in zip(xs, ys, zs):
+            start = np.array([x,y,z])
+            end = start + port.Vdirection.np*port.height
+            port.vintline.append(Line.from_points(start, end, 21))
+            logger.trace(f'Port[{port.port_number}] integration line {start} -> {end}.')
         
         port.v_integration = True
     
@@ -569,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)
@@ -1003,7 +1029,8 @@ class Microwave3D:
             if bc.Z0 is None:
                 raise SimulationError('Trying to compute the impedance of a boundary condition with no characteristic impedance.')
             
-            V = bc.vintline.line_integral(fieldfunction)
+            Voltages = [line.line_integral(fieldfunction) for line in bc.vintline]
+            V = sum(Voltages)/len(Voltages)
             
             if bc.active:
                 if bc.voltage is None:

{emerge-0.6.10 → emerge-1.0.0}/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.
@@ -834,7 +834,7 @@ class LumpedPort(PortBC):
         # logger.info('Constructing coordinate system from normal port')
         # self.cs = Axis(self.selection.normal).construct_cs()  # type: ignore
         self.cs = GCS
-        self.vintline: Line | None = None
+        self.vintline: list[Line] = []
         self.v_integration = True
 
     @property
@@ -1031,7 +1031,7 @@ class SurfaceImpedance(RobinBC):
         self.sigma: float = 0.0
         
         if material is not None:
-            self.sigma = material.cond
+            self.sigma = material.cond.scalar(1e9)
             self._mur = material.ur
             self._epsr = material.er
         
@@ -1064,7 +1064,7 @@ 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)
         

{emerge-0.6.10 → emerge-1.0.0}/emerge/_emerge/plot/matplotlib/mpldisplay.py

@@ -145,7 +145,7 @@ def _norm(x, y, z):
 
 def _select(obj: GeoObject | Selection) -> Selection:
     if isinstance(obj, GeoObject):
-        return obj.select
+        return obj.selection
     return obj
 
 def _merge(lst: list[GeoObject | Selection]) -> Selection: