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

emerge/_emerge/physics/microwave/assembly/assembler.py

@@ -273,13 +273,17 @@ class Assembler:
 
         logger.debug('Implementing PEC Boundary Conditions.')
         pec_ids: list[int] = []
+        pec_tris: list[int] = []
         
         # Conductivity above al imit, consider it all PEC
         ipec = 0
+        
         for itet in range(field.n_tets):
             if cond[0,0,itet] > self.settings.mw_3d_peclim:
                 ipec+=1
                 pec_ids.extend(field.tet_to_field[:,itet])
+                for tri in field.mesh.tet_to_tri[:,itet]:
+                    pec_tris.append(tri)
         if ipec>0:
             logger.trace(f'Extended PEC with {ipec} tets with a conductivity > {self.settings.mw_3d_peclim}.')
 
@@ -295,9 +299,12 @@ class Assembler:
                 eids = field.edge_to_field[:, ii]
                 pec_ids.extend(list(eids))
 
+            
             for ii in tri_ids:
                 tids = field.tri_to_field[:, ii]
                 pec_ids.extend(list(tids))
+                
+            pec_tris.extend(tri_ids)
 
 
         ############################################################
@@ -412,7 +419,8 @@ class Assembler:
         
         simjob.port_vectors = port_vectors
         simjob.solve_ids = solve_ids
-
+        simjob._pec_tris = pec_tris
+        
         if has_periodic:
             simjob.P = Pmat
             simjob.Pd = Pmat.getH()

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -876,7 +876,7 @@ class Microwave3D:
     def _run_adaptive_mesh(self,
                 iteration: int, 
                 frequency: float,
-                automatic_modal_analysis: bool = True) -> MWData:
+                automatic_modal_analysis: bool = True) -> tuple[MWData, list[int]]:
         """Executes a frequency domain study
 
         The study is distributed over "n_workers" workers.
@@ -965,7 +965,7 @@ class Microwave3D:
         self.solveroutine.reset()
         ### Compute S-parameters and return
         self._post_process([job,], [mats,])
-        return self.data
+        return self.data, job._pec_tris
     
     def eigenmode(self, search_frequency: float,
                         nmodes: int = 6,

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -773,6 +773,7 @@ class RectangularWaveguide(PortBC):
             logger.info(' - Constructing coordinate system from normal port')
             self.cs = Axis(self.selection.normal).construct_cs()
             logger.debug(f' - Port CS: {self.cs}')
+    
     def get_basis(self) -> np.ndarray:
         return self.cs._basis
         

emerge/_emerge/physics/microwave/microwave_data.py

@@ -667,13 +667,51 @@ class MWField:
         return sum([self.excitation[mode.port_number]*self._fields[mode.port_number] for mode in self.port_modes]) # type: ignore
     
     def set_field_vector(self) -> None:
-        """Defines the default excitation coefficients for the current dataset"""
+        """Defines the default excitation coefficients for the current dataset as an excitation of only port 1."""
         self.excitation = {key: 0.0 for key in self._fields.keys()}
         self.excitation[self.port_modes[0].port_number] = 1.0 + 0j
 
-    def excite_port(self, number: int) -> None:
+    def excite_port(self, number: int, excitation: complex = 1.0 + 0.0j) -> None:
+        """Excite a single port provided by a given port number
+
+        Args:
+            number (int): The port number to excite
+            coefficient (complex): The port excitation. Defaults to 1.0 + 0.0j
+        """
+        self.excitation = {key: 0.0 for key in self._fields.keys()}
+        self.excitation[self.port_modes[number-1].port_number] = excitation
+    
+    def set_excitations(self, *excitations: complex) -> None:
+        """Set bulk port excitations by an ordered array of excitation coefficients.
+
+        Returns:
+            *complex: A sequence of complex numbers
+        """
         self.excitation = {key: 0.0 for key in self._fields.keys()}
-        self.excitation[self.port_modes[number].port_number] = 1.0 + 0j
+        for iport, coeff in enumerate(excitations):
+            self.excitation[self.port_modes[iport].port_number] = coeff
+    
+    def combine_ports(self, p1: int, p2: int) -> MWField:
+        """Combines ports p1 and p2 into a cifferential and common mode port respectively.
+        
+        The p1 index becomes the differential mode port
+        The p2 index becomes the common mode port
+
+        Args:
+            p1 (int): The first port number
+            p2 (int): The second port number
+
+        Returns:
+            MWField: _description_
+        """
+        
+        fp1 = self._fields[p1]
+        fp2 = self._fields[p2]
+        
+        self._fields[p1] = (fp1-fp2)/np.sqrt(2)
+        self._fields[p2] = (fp1+fp2)/np.sqrt(2)
+        
+        return self
         
     @property
     def EH(self) -> tuple[np.ndarray, np.ndarray]:
@@ -720,7 +758,9 @@ class MWField:
         xf = xs.flatten()
         yf = ys.flatten()
         zf = zs.flatten()
+        logger.debug(f'Interpolating {xf.shape[0]} field points')
         Ex, Ey, Ez = self.basis.interpolate(self._field, xf, yf, zf, usenan=usenan)
+        logger.debug('E Interpolation complete')
         self.Ex = Ex.reshape(shp)
         self.Ey = Ey.reshape(shp)
         self.Ez = Ez.reshape(shp)
@@ -728,6 +768,7 @@ class MWField:
         
         constants = 1/ (-1j*2*np.pi*self.freq*(self._dur*MU0) )
         Hx, Hy, Hz = self.basis.interpolate_curl(self._field, xf, yf, zf, constants, usenan=usenan)
+        logger.debug('H Interpolation complete')
         ids = self.basis.interpolate_index(xf, yf, zf)
         
         self.er = self._der[ids].reshape(shp)
@@ -743,14 +784,15 @@ class MWField:
         
         return field
     
-    def _solution_quality(self) -> tuple[np.ndarray, np.ndarray]:
+    def _solution_quality(self, solve_ids: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
         from .adaptive_mesh import compute_error_estimate
         
-        error_tet, max_elem_size = compute_error_estimate(self)
+        error_tet, max_elem_size = compute_error_estimate(self, solve_ids)
         return error_tet, max_elem_size
         
     def boundary(self,
                  selection: FaceSelection) -> EHField:
+        """ Interpolate the field on the node coordinates of the surface."""
         nodes = self.mesh.nodes
         x = nodes[0,:]
         y = nodes[1,:]
@@ -1146,6 +1188,54 @@ class MWScalarNdim:
     def S(self, i1: int, i2: int) -> np.ndarray:
         return self.Sp[...,self._portmap[i1], self._portmap[i2]]
     
+    def combine_ports(self, p1: int, p2: int) -> MWScalarNdim:
+        """Combine ports p1 and p2 into a differential and common mode port respectively.
+
+        The p1 index becomes the differential mode port
+        The p2 index becomes the common mode port
+
+        Args:
+            p1 (int): The first port number
+            p2 (int): The second port number
+
+        Returns:
+            MWScalarNdim: _description_
+        """
+        if p1==p2:
+            raise ValueError('p1 and p2 must be different port numbers')
+        
+        F, N, _ = self.Sp.shape
+        p1 = p1-1
+        p2 = p2-1
+        
+        if not (0 <= p1 < N and 0 <= p2 < N):
+            raise IndexError(f'Ports {p1+1} or {p2+1} are out of range {N}')
+        
+        Sout = self.Sp.copy()
+        ii, jj = p1, p2
+        idx = np.ones(N, dtype=np.bool)
+        idx[[ii,jj]] = False
+        others = np.nonzero(idx)[0]
+        isqrt2 = 1.0 / np.sqrt(2.0)
+        
+        Sout[:, others, ii] = (self.Sp[:, others, ii] - self.Sp[:, others, jj]) * isqrt2
+        Sout[:, others, jj] = (self.Sp[:, others, ii] + self.Sp[:, others, jj]) * isqrt2
+        Sout[:, ii, others] = (self.Sp[:, ii, others] - self.Sp[:, jj, others]) * isqrt2
+        Sout[:, jj, others] = (self.Sp[:, ii, others] + self.Sp[:, jj, others]) * isqrt2
+        
+        Sii = self.Sp[:, ii, ii]
+        Sij = self.Sp[:, ii, jj]
+        Sji = self.Sp[:, jj, ii]
+        Sjj = self.Sp[:, jj, jj]
+        
+        Sout[:, ii, ii] = 0.5 *(Sii - Sij - Sji + Sjj)
+        Sout[:, ii, jj] = 0.5 *(Sii + Sij - Sji - Sjj)
+        Sout[:, jj, ii] = 0.5 *(Sii - Sij + Sji - Sjj)
+        Sout[:, jj, jj] = 0.5 *(Sii + Sij + Sji + Sjj)
+        
+        self.Sp = Sout
+        
+        return self
     @property
     def Smat(self) -> np.ndarray:
         """Returns the full S-matrix

emerge/_emerge/plot/pyvista/display.py

@@ -14,6 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
+
 from __future__ import annotations
 from ...mesh3d import Mesh3D
 from ...simstate import SimState
@@ -43,21 +44,43 @@ cmap_names = Literal['bgy','bgyw','kbc','blues','bmw','bmy','kgy','gray','dimgra
                      'bkr','bky','coolwarm','gwv','bjy','bwy','cwr','colorwheel','isolum','rainbow','fire',
                      'cet_fire','gouldian','kbgyw','cwr','CET_CBL1','CET_CBL3','CET_D1A']
 
-EMERGE_AMP =  make_colormap(["#1F0061","#35188e","#1531ab", "#ff007b", "#ff7c51"], (0.0, 0.2, 0.4, 0.7, 0.9))
+EMERGE_AMP =  make_colormap(["#1F0061","#4218c0","#2849db", "#ff007b", "#ff7c51"], (0.0, 0.15, 0.3, 0.7, 0.9))
 EMERGE_WAVE = make_colormap(["#4ab9ff","#0510B2B8","#3A37466E","#CC0954B9","#ff9036"], (0.0, 0.3, 0.5, 0.7, 1.0))
 
-def _gen_c_cycle():
-    colors = [
+
+## Cycler class
+
+class _Cycler:
+    """Like itertools.cycle(iterable) but with reset(). Materializes the iterable."""
+    def __init__(self, iterable):
+        self._data = list(iterable)
+        self._n = len(self._data)
+        self._i = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self._n == 0:
+            raise StopIteration
+        item = self._data[self._i]
+        self._i += 1
+        if self._i == self._n:
+            self._i = 0
+        return item
+
+    def reset(self):
+        self._i = 0
+
+
+C_CYCLE = _Cycler([
         "#0000aa",
         "#aa0000",
         "#009900",
         "#990099",
         "#994400",
         "#005588"
-    ]
-    return cycle(colors)
-
-C_CYCLE = _gen_c_cycle()
+    ])
 
 class _RunState:
     
@@ -242,6 +265,7 @@ class PVDisplay(BaseDisplay):
         self._stop: bool = False
         self._objs: list[_AnimObject] = []
         self._do_animate: bool = False
+        self._animate_next: bool = False
         self._closed_via_x: bool = False
         self._Nsteps: int  = 0
         self._fps: int = 25
@@ -334,7 +358,9 @@ class PVDisplay(BaseDisplay):
         self._plot = pv.Plotter()
         self._stop = False
         self._objs = []
-        C_CYCLE = _gen_c_cycle()
+        self._animate_next = False
+        self._reset_cbar()
+        C_CYCLE.reset()
 
     def _close_callback(self, arg):
         """The private callback function that stops the animation.
@@ -403,6 +429,7 @@ class PVDisplay(BaseDisplay):
         print('If you closed the animation without using (Q) press Ctrl+C to kill the process.')
         self._Nsteps = Nsteps
         self._fps = fps
+        self._animate_next = True
         self._do_animate = True
         return self
     
@@ -518,7 +545,7 @@ class PVDisplay(BaseDisplay):
         
         self._plot.add_mesh(self._volume_edges(_select(obj)), color='#000000', line_width=2, show_edges=True)
         
-        if isinstance(obj, GeoObject) and label:
+        if label:
             points = []
             labels = []
             for dt in obj.dimtags:
@@ -691,14 +718,14 @@ class PVDisplay(BaseDisplay):
         actor = self._plot.add_mesh(grid_no_nan, scalars=name, scalar_bar_args=self._cbar_args, **kwargs)
 
 
-        if self._do_animate:
+        if self._animate_next:
             def on_update(obj: _AnimObject, phi: complex):
                 field_anim = obj.T(np.real(obj.field * phi))
                 obj.grid[name] = field_anim
                 obj.fgrid[name] = obj.grid.threshold(scalars=name)[name]
                 #obj.fgrid replace with thresholded scalar data.
             self._objs.append(_AnimObject(field_flat, T, grid, grid_no_nan, actor, on_update))
-        
+            self._animate_next = False
         self._reset_cbar()
     
     def add_boundary_field(self, 
@@ -773,13 +800,13 @@ class PVDisplay(BaseDisplay):
         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:
+        if self._animate_next:
             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._animate_next = False
         self._reset_cbar()
         
     def add_title(self, title: str) -> None:
@@ -921,7 +948,7 @@ class PVDisplay(BaseDisplay):
         
         actor = self._plot.add_mesh(contour, opacity=opacity, cmap=cmap, clim=clim, pickable=False, scalar_bar_args=self._cbar_args)
         
-        if self._do_animate:
+        if self._animate_next:
             def on_update(obj: _AnimObject, phi: complex):
                 new_vals = obj.T(np.real(obj.field * phi))
                 obj.grid['anim'] = new_vals
@@ -929,7 +956,7 @@ class PVDisplay(BaseDisplay):
                 obj.actor.GetMapper().SetInputData(new_contour) # type: ignore
                 
             self._objs.append(_AnimObject(field, T, grid, None, actor, on_update)) # type: ignore
-            
+            self._animate_next = False
         self._reset_cbar()
         
     def _add_aux_items(self) -> None:

emerge/_emerge/plot/simple_plots.py

@@ -495,11 +495,11 @@ def plot_sp(f: np.ndarray | list[np.ndarray], S: list[np.ndarray] | np.ndarray,
         if isinstance(levelindicator, (int, float)) and levelindicator is not None:
             lvl = levelindicator
             fcross = hintersections(f, SdB, lvl)
-            for fs in fcross:
+            for freqs in fcross:
                 ax_mag.annotate(
-                    f"{str(fs)[:4]}{xunit}",
-                    xy=(fs, lvl),
-                    xytext=(fs + 0.08 * (max(f) - min(f)) / unitdivider[xunit], lvl),
+                    f"{str(freqs)[:4]}{xunit}",
+                    xy=(freqs, lvl),
+                    xytext=(freqs + 0.08 * (max(f) - min(f)) / unitdivider[xunit], lvl),
                     arrowprops=dict(facecolor="black", width=1, headwidth=5),
                 )
     if fill_areas is not None:
@@ -541,6 +541,118 @@ def plot_sp(f: np.ndarray | list[np.ndarray], S: list[np.ndarray] | np.ndarray,
 
     return fig, ax_mag, ax_phase
 
+def plot_vswr(f: np.ndarray | list[np.ndarray], S: list[np.ndarray] | np.ndarray, 
+            swrlim=[1, 5], 
+            xunit="GHz", 
+            levelindicator: int | float | None = None, 
+            fill_areas: list[tuple] | None = None, 
+            spec_area: list[tuple[float,...]] | None = None,
+            labels: list[str] | None = None,
+            linestyles: list[str] | None = None,
+            colorcycle: list[int] | None = None,
+            filename: str | None = None,
+            show_plot: bool = True,
+            figdata: tuple | None = None) -> tuple[plt.Figure, plt.Axes, plt.Axes]:
+    """Plot S-parameters in VSWR
+    
+    One may provide:
+     - A single frequency with a single S-parameter
+     - A single frequency with a list of S-parameters
+     - A list of frequencies with a list of S-parameters
+
+    Args:
+        f (np.ndarray | list[np.ndarray]): Frequency vector or list of frequencies
+        S (list[np.ndarray] | np.ndarray): S-parameters to plot (list or single array)
+        swrlim (list, optional): VSWR y-axis limit. Defaults to [1, 5].
+        xunit (str, optional): Frequency unit. Defaults to "GHz".
+        levelindicator (int | float, optional): Level at which annotation arrows will be added. Defaults to None.
+        fill_areas (list[tuple], optional): Regions to fill (fmin, fmax). Defaults to None.
+        spec_area (list[tuple[float]], optional): _description_. Defaults to None.
+        labels (list[str], optional): A lists of labels to use. Defaults to None.
+        linestyles (list[str], optional): The linestyle to use (list or single string). Defaults to None.
+        colorcycle (list[int], optional): A list of colors to use. Defaults to None.
+        filename (str, optional): The filename (will automatically save). Defaults to None.
+        show_plot (bool, optional): If or not to show the resulting plot. Defaults to True.
+        
+    """    
+    if not isinstance(S, list):
+        Ss = [S]
+    else:
+        Ss = S
+        
+    if not isinstance(f, list):
+        fs = [f for _ in Ss]
+    else:
+        fs = f
+    
+    if linestyles is None:
+        linestyles = ['-' for _ in S]
+
+    if colorcycle is None:
+        colorcycle = [i for i, S in enumerate(S)]
+
+    unitdivider: dict[str, float] = {"MHz": 1e6, "GHz": 1e9, "kHz": 1e3}
+    
+    fs = [f / unitdivider[xunit] for f in fs]
+
+    if figdata is None:
+        # Create two subplots: one for magnitude and one for phase
+        fig, ax_swr = plt.subplots()
+        fig.subplots_adjust(hspace=0.3)
+    else:
+        fig, ax_swr = figdata
+    maxy = 5
+
+
+    for f, s, ls, cid in zip(fs, Ss, linestyles, colorcycle):
+        # Calculate and plot magnitude in dB
+        SWR = np.divide((1 + abs(s)), (1 - abs(s)))
+        ax_swr.plot(f, SWR, label="VSWR", linestyle=ls, color=EMERGE_COLORS[cid % len(EMERGE_COLORS)])
+        if np.max(SWR) > maxy:
+            maxy = np.max(SWR)
+
+        # Annotate level indicators if specified
+        if isinstance(levelindicator, (int, float)) and levelindicator is not None:
+            lvl = levelindicator
+            fcross = hintersections(f, SWR, lvl)
+            for fa in fcross:
+                ax_swr.annotate(
+                    f"{str(fa)[:4]}{xunit}",
+                    xy=(fa, lvl),
+                    xytext=(fa + 0.08 * (max(f) - min(f)) / unitdivider[xunit], lvl),
+                    arrowprops=dict(facecolor="black", width=1, headwidth=5),
+                )
+    
+    
+    if fill_areas is not None:
+        for fmin, fmax in fill_areas:
+            f1 = fmin / unitdivider[xunit]
+            f2 = fmax / unitdivider[xunit]
+            ax_swr.fill_between([f1, f2], swrlim[0], swrlim[1], color='grey', alpha= 0.2)
+
+    if spec_area is not None:
+        for fmin, fmax, vmin, vmax in spec_area:
+            f1 = fmin / unitdivider[xunit]
+            f2 = fmax / unitdivider[xunit]
+            ax_swr.fill_between([f1, f2], vmin,vmax, color='red', alpha=0.2)
+
+    # Configure magnitude plot (ax_swr)
+    fmin = min([min(f) for f in fs])
+    fmax = max([max(f) for f in fs])
+    ax_swr.set_ylabel("VSWR")
+    ax_swr.set_xlabel(f"Frequency ({xunit})")
+    ax_swr.axis([fmin, fmax, swrlim[0], max(maxy*1.1,swrlim[1])]) # type: ignore
+    ax_swr.xaxis.set_minor_locator(tck.AutoMinorLocator(2))
+    ax_swr.yaxis.set_minor_locator(tck.AutoMinorLocator(2))
+
+    if labels is not None:
+        ax_swr.legend(labels)
+    if show_plot:
+        plt.show()
+    if filename is not None:
+        fig.savefig(filename)
+
+    return fig, ax_swr
     
 def plot_ff(
     theta: np.ndarray | list[np.ndarray],

emerge/_emerge/selection.py

@@ -21,6 +21,9 @@ import numpy as np
 from .cs import Axis, CoordinateSystem, _parse_vector, Plane
 from typing import Callable, TypeVar, Iterable, Any
 
+class SelectionError(Exception):
+    pass
+
 def align_rectangle_frame(pts3d: np.ndarray, normal: np.ndarray) -> dict[str, Any]:
     """Tries to find a rectangle as convex-hull of a set of points with a given normal vector.
 
@@ -174,7 +177,7 @@ class Selection:
     """
     dim: int = -1
     def __init__(self, tags: list[int] | set[int] | tuple[int] | None = None):
-
+        self.name: str = 'Selection'
         self._tags: set[int] = set()
 
         if tags is not None:
@@ -252,7 +255,19 @@ class Selection:
                 maxy = max(maxy, y1)
                 maxz = max(maxz, z1)
             return (minx, miny, minz), (maxx, maxy, maxz)
-        
+    
+    def _named(self, name: str) -> Selection:
+        """Sets the name of the selection and returns it
+
+        Args:
+            name (str): The name of the selection
+
+        Returns:
+            Selection: The same selection object
+        """
+        self.name = name
+        return self
+    
     def exclude(self, xyz_excl_function: Callable = lambda x,y,z: True, plane: Plane | None = None, axis: Axis | None = None) -> Selection:
         """Exclude points by evaluating a function(x,y,z)-> bool