emerge 1.1.1__tar.gz → 1.2.0__tar.gz

{emerge-1.1.1 → emerge-1.2.0}/.bumpversion.toml

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

{emerge-1.1.1 → emerge-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 1.1.1
+Version: 1.2.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

{emerge-1.1.1 → emerge-1.2.0}/emerge/__init__.py

@@ -32,7 +32,7 @@ warnings.filterwarnings(
 ############################################################
 import os
 
-__version__ = "1.1.1"
+__version__ = "1.2.0"
 
 NTHREADS = "1"
 os.environ["EMERGE_STD_LOGLEVEL"] = os.getenv("EMERGE_STD_LOGLEVEL", default="INFO")

{emerge-1.1.1 → emerge-1.2.0}/emerge/_emerge/physics/microwave/adaptive_mesh.py

@@ -17,7 +17,7 @@
 
 from .microwave_data import MWField
 import numpy as np
-from ...mth.optimized import matmul, outward_normal, cross_c
+from ...mth.optimized import matmul, outward_normal
 from numba import njit, f8, c16, i8, types, prange # type: ignore, p
 from loguru import logger
 from ...const import C0, MU0, EPS0
@@ -783,32 +783,33 @@ def compute_error_single(nodes, tets, tris, edges, centers,
                          pec_tris,
                          k0,) -> np.ndarray:
 
-    is_pec = np.zeros((tris.shape[1],), dtype=np.bool)
-    is_pec[pec_tris] = True
+    tet_is_pec = np.zeros((tris.shape[1],), dtype=np.bool)
+    tet_is_pec[pec_tris] = True
 
     # CONSTANTS
-    ntet = tets.shape[1]
-    nedges = edges.shape[1]
-    W0 = k0*C0
+    N_TETS = tets.shape[1]
+    N_EDGES = edges.shape[1]
     N2D = DPTS_2D.shape[1]
-    W_VOL = DPTS_3D[0,:]
+    WEIGHTS_VOL = DPTS_3D[0,:]
+    
+    W0 = k0*C0
     Y0 = np.sqrt(1/MU0)
     
     # INIT POSTERIORI ERROR ESTIMATE QUANTITIES
-    alpha_t = np.zeros((ntet,), dtype=np.complex128)
-    max_elem_size = np.zeros((ntet,), dtype=np.float64)
+    alpha_t = np.zeros((N_TETS,), dtype=np.complex128)
+    max_elem_size = np.zeros((N_TETS,), dtype=np.float64)
     
-    Qf_face1 = np.zeros((4,N2D,ntet), dtype=np.complex128)
-    Qf_face2 = np.zeros((4,N2D,ntet), dtype=np.complex128)
-    Jf_face1 = np.zeros((4,3,N2D,ntet), dtype=np.complex128)
-    Jf_face2 = np.zeros((4,3,N2D,ntet), dtype=np.complex128)
+    Qf_face1 = np.zeros((4,N2D,N_TETS), dtype=np.complex128)
+    Qf_face2 = np.zeros((4,N2D,N_TETS), dtype=np.complex128)
+    Jf_face1 = np.zeros((4,3,N2D,N_TETS), dtype=np.complex128)
+    Jf_face2 = np.zeros((4,3,N2D,N_TETS), dtype=np.complex128)
     
-    areas_fr = np.zeros((4, N2D, ntet), dtype=np.float64)
-    Rf_fr = np.zeros((4, ntet), dtype=np.float64)
-    adj_tets_mat = -np.ones((4,ntet), dtype=np.int32)
+    areas_face_residual = np.zeros((4, N2D, N_TETS), dtype=np.float64)
+    Rf_face_residual = np.zeros((4, N_TETS), dtype=np.float64)
+    adj_tets_mat = -np.ones((4,N_TETS), dtype=np.int32)
     
     # Compute Error estimate
-    for itet in range(ntet):
+    for itet in range(N_TETS):
         uinv = (1/ur[itet])*np.eye(3)
         ermat = er[itet]*np.eye(3)
         erc = er[itet]
@@ -834,7 +835,7 @@ def compute_error_single(nodes, tets, tris, edges, centers,
         # TET TRI NODE COUPLINGS
         g_node_ids = tets[:, itet]
         g_edge_ids = edges[:, tet_to_field[:6, itet]]
-        g_tri_ids = tris[:, tet_to_field[6:10, itet]-nedges]
+        g_tri_ids = tris[:, tet_to_field[6:10, itet]-N_EDGES]
         l_edge_ids = local_mapping(g_node_ids, g_edge_ids)
         l_tri_ids = local_mapping(g_node_ids, g_tri_ids)
         triids = tet_to_tri[:,itet]
@@ -842,17 +843,16 @@ def compute_error_single(nodes, tets, tris, edges, centers,
         size_max = circum_sphere_diam(v1,v2,v3,v4)
         #size_max = np.max(edge_lengths[tet_to_edge[:,itet]])
         
-        Volume = compute_volume(vertices[0,:], vertices[1,:], vertices[2,:])
-        
+        TET_VOLUME = compute_volume(vertices[0,:], vertices[1,:], vertices[2,:])
         Rt = size_max
+        
         # Efield
         Ef = Efield[tet_to_field[:,itet]]
         
         # Qt term
-        Qt = Volume*EPS0*np.sum(W_VOL*compute_div(intpts, vertices, Ef, l_edge_ids, l_tri_ids, ermat), axis=0)
+        Qt = TET_VOLUME*EPS0*np.sum(WEIGHTS_VOL*compute_div(intpts, vertices, Ef, l_edge_ids, l_tri_ids, ermat), axis=0)
 
         # Jt term
-        
         Rv1 = compute_curl_curl(vertices, Ef, l_edge_ids, l_tri_ids, uinv)
         Rv2 = -k0**2*(ermat @ compute_field(intpts, vertices, Ef, l_edge_ids, l_tri_ids))
         Rv = 1*Rv2
@@ -860,11 +860,11 @@ def compute_error_single(nodes, tets, tris, edges, centers,
         Rv[1,:] += Rv1[1] # Y-component
         Rv[2,:] += Rv1[2] # Z-component
         
-        Rv[0,:] = Rv[0,:]*W_VOL
-        Rv[1,:] = Rv[1,:]*W_VOL
-        Rv[2,:] = Rv[2,:]*W_VOL
+        Rv[0,:] = Rv[0,:]*WEIGHTS_VOL
+        Rv[1,:] = Rv[1,:]*WEIGHTS_VOL
+        Rv[2,:] = Rv[2,:]*WEIGHTS_VOL
         
-        Jt = -Volume*np.sum(1/(1j*W0*MU0) * Rv, axis=1)
+        Jt = -TET_VOLUME*np.sum(1/(1j*W0*MU0) * Rv, axis=1)
   
         Gt = (1j*W0*np.exp(-1j*k0*Rt)/(4*np.pi*Rt))
         alpha_t[itet] = - Gt/(erc*EPS0) * Qt*Qt - Gt*urc*MU0 * np.sum(Jt*Jt)
@@ -892,7 +892,7 @@ def compute_error_single(nodes, tets, tris, edges, centers,
         for iface in range(4):
             tri_index = triids[iface]
             
-            pec_face = is_pec[tri_index]
+            pec_face = tet_is_pec[tri_index]
             
             i1, i2, i3 = tris[:, tri_index]
             
@@ -911,8 +911,8 @@ def compute_error_single(nodes, tets, tris, edges, centers,
             l3 = np.linalg.norm(n3-n2)
             Rf = np.max(np.array([l1, l2, l3]))
             Rf = diam_circum_circle(n1,n2,n3)
-            Rf_fr[iface,itet] = Rf
-            areas_fr[iface, :, itet] = area
+            Rf_face_residual[iface,itet] = Rf
+            areas_face_residual[iface, :, itet] = area
             
             adj_tets = [int(tri_to_tet[j,triids[iface]]) for j in range(2)]
             adj_tets = [num for num in adj_tets if num not in (itet, -1234)]
@@ -943,7 +943,7 @@ def compute_error_single(nodes, tets, tris, edges, centers,
             adj_tets_mat[iface,itet] = itet_adj
 
     # Compute 2D Gauss quadrature weight matrix
-    fWs = np.empty_like(areas_fr, dtype=np.float64)
+    fWs = np.empty_like(areas_face_residual, dtype=np.float64)
     for i in range(N2D):
         fWs[:,i,:] = DPTS_2D[0,i]
     
@@ -952,16 +952,16 @@ def compute_error_single(nodes, tets, tris, edges, centers,
     Jf_delta = Jf_face1 - Jf_face2
     
     # Perform Gauss-Quadrature integration (4, NTET)
-    Qf_int = np.sum(Qf_delta*areas_fr*fWs, axis=1)
-    Jf_int_x = np.sum(Jf_delta[:,0,:,:]*areas_fr*fWs, axis=1)
-    Jf_int_y = np.sum(Jf_delta[:,1,:,:]*areas_fr*fWs, axis=1)
-    Jf_int_z = np.sum(Jf_delta[:,2,:,:]*areas_fr*fWs, axis=1)
+    Qf_int = np.sum(Qf_delta*areas_face_residual*fWs, axis=1)
+    Jf_int_x = np.sum(Jf_delta[:,0,:,:]*areas_face_residual*fWs, axis=1)
+    Jf_int_y = np.sum(Jf_delta[:,1,:,:]*areas_face_residual*fWs, axis=1)
+    Jf_int_z = np.sum(Jf_delta[:,2,:,:]*areas_face_residual*fWs, axis=1)
     
-    Gf = (1j*W0*np.exp(-1j*k0*Rf_fr)/(4*np.pi*Rf_fr))
+    Gf = (1j*W0*np.exp(-1j*k0*Rf_face_residual)/(4*np.pi*Rf_face_residual))
     alpha_Df = - Gf/(er*EPS0)*(Qf_int*Qf_int) - Gf*(ur*MU0) * (Jf_int_x*Jf_int_x + Jf_int_y*Jf_int_y + Jf_int_z*Jf_int_z)
     
-    alpha_Nf = np.zeros((4, ntet), dtype=np.complex128)
-    for it in range(ntet):
+    alpha_Nf = np.zeros((4, N_TETS), dtype=np.complex128)
+    for it in range(N_TETS):
         for iface in range(4):
             it2 = adj_tets_mat[iface, it]
             if it2==-1:
@@ -973,7 +973,16 @@ def compute_error_single(nodes, tets, tris, edges, centers,
     
     return error, max_elem_size
 
-def compute_error_estimate(field: MWField, pec_tris: list[int]) -> np.ndarray:
+def compute_error_estimate(field: MWField, pec_tris: list[int]) -> tuple[np.ndarray, np.ndarray]:
+    """Top level function to compute the EM error of a field solution.
+
+    Args:
+        field (MWField): The MWField object to analyse
+        pec_tris (list[int]): A list of triangles that ought to be considered PEC (non-neighbouring.)
+
+    Returns:
+        np.ndarray, np.ndarray: The error estimate in an (Ntet,) float array and the tetrahedral size value.
+    """
     mesh = field.mesh
 
     nodes = mesh.nodes

{emerge-1.1.1 → emerge-1.2.0}/emerge/_emerge/physics/microwave/microwave_data.py

@@ -792,6 +792,7 @@ class MWField:
         
     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,:]

{emerge-1.1.1 → emerge-1.2.0}/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:
     
@@ -336,7 +359,8 @@ class PVDisplay(BaseDisplay):
         self._stop = False
         self._objs = []
         self._animate_next = False
-        C_CYCLE = _gen_c_cycle()
+        self._reset_cbar()
+        C_CYCLE.reset()
 
     def _close_callback(self, arg):
         """The private callback function that stops the animation.

{emerge-1.1.1 → emerge-1.2.0}/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-1.1.1 → emerge-1.2.0}/emerge/_emerge/simmodel.py

@@ -317,12 +317,14 @@ class Simulation:
     
     def check_version(self, target_version: str, *, log: bool = False) -> None:
         """
-        Ensure the script targets an EMerge version compatible with the current runtime.
+        Ensure the script targets an EMerge major.minor compatible with the current runtime.
+
+        Only major.minor is enforced. Patch differences are ignored.
 
         Parameters
         ----------
         target_version : str
-            The EMerge version this script was written for (e.g. "1.4.0").
+            The EMerge version this script was written for (e.g. "1.4.0" or "1.4").
         log : bool, optional
             If True and a `logger` is available, emit a single WARNING with the same
             message as the exception. Defaults to False.
@@ -330,40 +332,50 @@ class Simulation:
         Raises
         ------
         VersionError
-            If the script's target version differs from the running EMerge version.
+            If the script's target major.minor differs from the running EMerge major.minor.
         """
         try:
             from packaging.version import Version as _V
-            v_script = _V(target_version)
-            v_runtime = _V(__version__)
-            newer = v_script > v_runtime
-            older = v_script < v_runtime
+            def _mm(v: str):
+                pv = _V(v)
+                return (pv.major, pv.minor)
+            script_mm = _mm(target_version)
+            runtime_mm = _mm(__version__)
+            newer = script_mm > runtime_mm
+            older = script_mm < runtime_mm
         except Exception:
-            def _parse(v: str):
+            def _parse_mm(v: str):
+                parts = v.split(".")
                 try:
-                    return tuple(int(p) for p in v.split("."))
+                    major = int(parts[0])
+                    minor = int(parts[1]) if len(parts) > 1 else 0
+                    return (major, minor)
                 except Exception:
-                    # Last-resort: compare as strings to avoid crashing the check itself
-                    return tuple(v.split("."))
-            v_script = _parse(target_version)
-            v_runtime = _parse(__version__)
-            newer = v_script > v_runtime
-            older = v_script < v_runtime
+                    # Fallback: compare as strings to avoid crashing the check itself
+                    major = parts[0] if parts else "0"
+                    minor = parts[1] if len(parts) > 1 else "0"
+                    return (str(major), str(minor))
+            script_mm = _parse_mm(target_version)
+            runtime_mm = _parse_mm(__version__)
+            newer = script_mm > runtime_mm
+            older = script_mm < runtime_mm
 
         if not newer and not older:
-            return  # exact match
+            return  # major.minor match
 
         if newer:
             msg = (
-                f"Script targets EMerge {target_version}, but runtime is {__version__}. "
-                "The script may rely on features added after your installed version. "
+                f"Script targets EMerge {target_version} (major.minor {script_mm[0]}.{script_mm[1]}), "
+                f"but runtime is {__version__} (major.minor {runtime_mm[0]}.{runtime_mm[1]}). "
+                "The script may rely on features added after your installed major.minor. "
                 "Recommended: upgrade EMerge (`pip install --upgrade emerge`). "
                 "If you know the script is compatible, you may remove this check."
             )
         else:  # older
             msg = (
-                f"Script targets EMerge {target_version}, but runtime is {__version__}. "
-                "APIs may have changed since the targeted version. "
+                f"Script targets EMerge {target_version} (major.minor {script_mm[0]}.{script_mm[1]}), "
+                f"but runtime is {__version__} (major.minor {runtime_mm[0]}.{runtime_mm[1]}). "
+                "APIs may have changed since the targeted major.minor. "
                 "Recommended: update the script for the current EMerge, or run a matching older release. "
                 "If you know the script is compatible, you may remove this check."
             )
@@ -700,9 +712,7 @@ class SimulationBeta(Simulation):
         
         
     def _reset_mesh(self):
-        #gmsh.clear()
         gmsh.model.mesh.clear()
-        
         self.mw.reset(_reset_bc = False)
         self.state.reset_mesh()
         
@@ -716,6 +726,7 @@ class SimulationBeta(Simulation):
                                  growth_rate: float = 2,
                                  minimum_refinement_percentage: float = 20.0, 
                                  error_field_inclusion_percentage: float = 60.0,
+                                 minimum_steps: int = 1,
                                  frequency: float = None,
                                  show_mesh: bool = False) -> SimulationDataset:
         """ A beta-version of adaptive mesh refinement.
@@ -735,6 +746,7 @@ class SimulationBeta(Simulation):
             growth_rate (float, optional): The mesh size growth rate. Defaults to 3.0.
             minimum_refinement_percentage (float, optional): The minimum mesh size increase . Defaults to 15.0.
             error_field_inclusion_percentage (float, optional): A percentage of tet elements to be included for refinement. Defaults to 5.0.
+            minimum_steps (int, optional): The minimum number of adaptive steps to execute. Defaults to 1.
             frequency (float, optional): The refinement frequency. Defaults to None.
             show_mesh (bool, optional): If the intermediate meshes should be shown (freezes simulation). Defaults to False
 
@@ -742,7 +754,6 @@ class SimulationBeta(Simulation):
             SimulationDataset: _description_
         """
         from .physics.microwave.adaptive_mesh import select_refinement_indices, reduce_point_set, compute_convergence
-        from collections import defaultdict
         
         max_freq = np.max(self.mw.frequencies)
         
@@ -758,6 +769,7 @@ class SimulationBeta(Simulation):
         
         self.state.stash()
         
+        # Coefficients for the refinement ratio calculation.
         a0 = 0.26
         c0 = 0.75
         x0 = 12
@@ -765,6 +777,7 @@ class SimulationBeta(Simulation):
         b0 = np.tan((c0-a0)/q0)/x0
         q0 = (0.8-a0)*2/np.pi
         
+        
         for step in range(1,max_steps+1):
             
             self.data.sim.new(iter_step=step)
@@ -776,7 +789,7 @@ class SimulationBeta(Simulation):
             Smat_new = data.scalar[-1].Sp
             S_matrices.append(Smat_new)
             
-            if step > 1:
+            if step > minimum_steps:
                 S0 = S_matrices[-2]
                 S1 = S_matrices[-1]
                 conv_complex, conv_mag, conv_phase = compute_convergence(S0, S1)
@@ -787,7 +800,7 @@ class SimulationBeta(Simulation):
                 else:
                     passed = 0
             
-            if passed >= min_refined_passes:
+            if passed >= min_refined_passes and step > minimum_steps:
                 logger.info(f'Adaptive mesh refinement successfull with {self.mesh.n_tets} tetrahedra.')
                 break
             
@@ -800,7 +813,7 @@ class SimulationBeta(Simulation):
             np_percentage = npts/self.mesh.n_tets * 100
             
             refinement_ratio = (a0 + np.arctan(b0*np_percentage)*q0)
-            #calc_refinement_ratio(refinement_throttle, point_percentage)
+            
             logger.info(f'Adding {npts} refinement points with a ratio: {refinement_ratio}')
             
             # tet_nodes = defaultdict(lambda: 1000.)
@@ -832,15 +845,13 @@ class SimulationBeta(Simulation):
             self.mesher._amr_ratios = self.mesher._amr_ratios[new_ids]
             self.mesher._amr_new = self.mesher._amr_new[new_ids]
             
-            def clip(value: float):
-                return max(1.3, value)
-            
             logger.debug(f'Initial refinement ratio: {refinement_ratio}')
             
             over = False
             under = False
             throttle = 1.0
             
+            # Mesh refinement loop. Only escapes if the mesh refined a certain set percentage.
             while True:
                 
                 if over and under:

{emerge-1.1.1 → emerge-1.2.0}/emerge/_emerge/solve_interfaces/cudss_interface.py

@@ -91,7 +91,7 @@ class CuDSSInterface:
         self._config = cudss.config_create()
         self._data = cudss.data_create(self._handle)
 
-        self.MTYPE = cudss.MatrixType.SYMMETRIC
+        self.MTYPE = cudss.MatrixType.GENERAL
         self.MVIEW = cudss.MatrixViewType.FULL
         self.RALG = cudss.AlgType.ALG_DEFAULT
         self.VTYPE = CudaDataType.CUDA_R_64F

{emerge-1.1.1 → emerge-1.2.0}/emerge/plot.py

@@ -1 +1 @@
-from ._emerge.plot.simple_plots import smith, plot_sp, plot, plot_ff, plot_ff_polar
+from ._emerge.plot.simple_plots import smith, plot_sp, plot, plot_ff, plot_ff_polar, plot_vswr

{emerge-1.1.1 → emerge-1.2.0}/examples/demo0_parallel_plate.py

@@ -32,7 +32,7 @@ box = em.geo.Box(20*mm, 20*mm, 50*mm, position=(-10*mm, -10*mm, 0))
 
 # As the box is all we need, we will say that we stop with our modelling so we can proceed
 model.commit_geometry()
-model.check_version("1.1.1")
+model.check_version("1.2.0")
 
 # Before we can generate the mesh we have to set a simulation frequency (range)
 model.mw.set_frequency(10e9)

{emerge-1.1.1 → emerge-1.2.0}/examples/demo10_sgh.py

@@ -33,7 +33,7 @@ dx = 2 * mm              # distance from horn exit to PML start
 
 # Create simulation object
 m = em.Simulation('StandardGainHornAntenna')
-m.check_version("1.1.1") # Checks version compatibility.
+m.check_version("1.2.0") # Checks version compatibility.
 # --- Coordinate system for horn geometry -------------------------------
 hornCS = em.CS(em.YAX, em.ZAX, em.XAX)
 

{emerge-1.1.1 → emerge-1.2.0}/examples/demo11_lumped_element_filter.py

@@ -29,7 +29,7 @@ def Cf(C):
 pack = '0603'         # package footprint for lumped components
 # Create simulation and PCB layouter with substrate thickness and material
 m = em.Simulation('LumpedFilter')
-m.check_version("1.1.1") # Checks version compatibility.
+m.check_version("1.2.0") # Checks version compatibility.
 
 th = 0.5         # substrate thickness (meters)
 Hair = 2.0

{emerge-1.1.1 → emerge-1.2.0}/examples/demo12_mode_alignment.py

@@ -12,7 +12,7 @@ direction (+Z vs -Z). In EMerge we can alignm modes using the .align_mode() meth
 
 # First we define our simulation
 m = em.Simulation('AlignmentDemo')
-m.check_version("1.1.1") # Checks version compatibility.
+m.check_version("1.2.0") # Checks version compatibility.
 
 # We create a cyllindrical waveguide in the Y-axis.
 cyl = em.geo.Cylinder(0.012, 0.05, em.YAX.construct_cs())

{emerge-1.1.1 → emerge-1.2.0}/examples/demo13_helix_antenna.py

@@ -25,7 +25,7 @@ porth = 2*mm                    # vertical height of the feed extrusion
 
 # --- Simulation object -------------------------------------------------------
 model = em.Simulation('HelixAntennas')
-model.check_version("1.1.1") # Checks version compatibility.
+model.check_version("1.2.0") # Checks version compatibility.
 
 dfeed = 3*mm                    # straight feed length before the helix starts