emerge 0.6.2__tar.gz → 0.6.5__tar.gz

emerge-0.6.5/.bumpversion.toml

@@ -0,0 +1,72 @@
+[tool.bumpversion]
+current_version = "0.6.5"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+ignore_missing_files = false
+tag = true
+sign_tags= false
+tag_name = "v{new_version}"
+tag_message = "Bump version: {current_version} → {new_version}"
+allow_dirty = false
+commit = true
+message = "Bump version: {current_version} → {new_version}"
+moveable_tags = []
+commit_args = ""
+setup_hooks = []
+pre_commit_hooks = []
+post_commit_hooks = []
+
+[[tool.bumpversion.files]]
+filename = "uv.lock"
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+
+[[tool.bumpversion.files]]
+filename = "src/emerge/__init__.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo1_stepped_imp_filter.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo2_combline_filter.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo3_coupled_line_filter.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo4_patch_antenna.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo5_revolve.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo6_striplines_with_vias.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo7_periodic_cells.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo8_waveguide_bpf_synthesis.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo9_dielectric_resonator.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo10_sgh.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo11_lumped_element_filter.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo12_mode_alignment.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo13_helix_antenna.py"
+
+[[tool.bumpversion.files]]
+filename = "examples/demo14_boundary_selection.py"

{emerge-0.6.2 → emerge-0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 0.6.2
+Version: 0.6.5
 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-0.6.2 → emerge-0.6.5}/emerge/__init__.py

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

{emerge-0.6.2 → emerge-0.6.5}/emerge/_emerge/geo/polybased.py

@@ -16,7 +16,7 @@
 # <https://www.gnu.org/licenses/>.
 from __future__ import annotations
 import numpy as np
-from ..cs import CoordinateSystem, GCS, Axis
+from ..cs import CoordinateSystem, GCS, Axis, _parse_axis
 from ..geometry import GeoVolume, GeoPolygon, GeoEdge, GeoSurface
 from .shapes import Alignment
 import gmsh
@@ -158,7 +158,35 @@ def rotate_point(point: tuple[float, float, float],
     rotated += o
     return tuple(rotated)
 
+def _dist(p1: tuple[float, float], p2: tuple[float, float]) -> float:
+    return ((p2[0]-p1[0])**2 + (p2[1]-p1[1])**2)**(0.5)
 
+def _pair_points(x1: np.ndarray,
+                 y1: np.ndarray,
+                 x2: np.ndarray,
+                 y2: np.ndarray) -> list[tuple[int,int]]:
+    if x1.shape[0]==x2.shape[0]:
+        return [(i,i) for i in range(x1.shape[0])]
+
+    #create point tuples
+    p1s = [(x,y) for x,y in zip(x1, y1)]
+    p2s = [(x,y) for x,y in zip(x2, y2)]
+    
+    pairs = []
+    for i, p1 in enumerate(p1s):
+        d1 = _dist(p1, p2s[i-1])
+        d2 = _dist(p1, p2s[i])
+        d3 = _dist(p1, p2s[i+1])
+        mind = min([d1, d2, d3])
+        if mind==d1:
+            pairs.append((i,i-1))
+            continue
+        elif mind==d2:
+            pairs.append((i,i))
+        else:
+            pairs.append((i,i+1))
+    return pairs
+            
 def orthonormalize(axis: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Generates a set of orthonormal vectors given an input vector X
 
@@ -233,8 +261,9 @@ class XYPolygon:
     """This class generalizes a polygon in an un-embedded XY space that can be embedded in 3D space.
     """
     def __init__(self, 
-                 xs: np.ndarray | list | tuple = None,
-                 ys: np.ndarray | list | tuple = None):
+                 xs: np.ndarray | list | tuple | None = None,
+                 ys: np.ndarray | list | tuple | None = None,
+                 cs: CoordinateSystem | None = None):
         """Constructs an XY-plane placed polygon.
 
         Args:
@@ -250,7 +279,13 @@ class XYPolygon:
         self.y: np.ndarray = np.asarray(ys)
 
         self.fillets: list[tuple[float, int]] = []
+        
+        self._cs: CoordinateSystem = cs
 
+    @property
+    def center(self) -> tuple[float, float]:
+        return np.mean(self.x), np.mean(self.y)
+    
     @property
     def length(self):
         return sum([((self.x[i2]-self.x[i1])**2 + (self.y[i2]-self.y[i1])**2)**0.5 for i1, i2 in zip(range(self.N-1),range(1, self.N))])
@@ -282,6 +317,10 @@ class XYPolygon:
         """
         return 0.5*np.abs(np.dot(self.x,np.roll(self.y,1))-np.dot(self.y,np.roll(self.x,1)))
 
+    def incs(self, cs: CoordinateSystem) -> XYPolygon:
+        self._cs = cs
+        return self
+
     def extend(self, xpts: list[float], ypts: list[float]) -> XYPolygon:
         """Adds a series for x and y coordinates to the existing polygon.
 
@@ -301,7 +340,7 @@ class XYPolygon:
         for i in range(self.N):
             yield (self.x[i], self.y[i])
 
-    def fillet(self, radius: float, *indices: int) -> None:
+    def fillet(self, radius: float, *indices: int) -> XYPolygon:
         """Add a fillet rounding with a given radius to the provided nodes.
 
         Example:
@@ -313,8 +352,9 @@ class XYPolygon:
         """
         for i in indices:
             self.fillets.append((radius, i))
+        return self
 
-    def _finalize(self, cs: CoordinateSystem = None) -> GeoPolygon:
+    def _make_wire(self, cs: CoordinateSystem) -> tuple[list[int], list[int], int]:
         """Turns the XYPolygon object into a GeoPolygon that is embedded in 3D space.
 
         The polygon will be placed in the XY-plane of the provided coordinate center.
@@ -340,13 +380,27 @@ class XYPolygon:
         
         add = 0
         for radius, index in self.fillets:
-            t1 = lines[index + add]
-            t2 = lines[(index+add-1) % len(lines)]
+            t1 = lines[(index + add-1) % len(lines)]
+            t2 = lines[index + add]
             tag = gmsh.model.occ.fillet2_d(t1, t2, radius)
             lines.insert(index, tag)
             add += 1
 
         wiretag = gmsh.model.occ.add_wire(lines)
+        return ptags, lines, wiretag
+        
+    def _finalize(self, cs: CoordinateSystem) -> GeoPolygon:
+        """Turns the XYPolygon object into a GeoPolygon that is embedded in 3D space.
+
+        The polygon will be placed in the XY-plane of the provided coordinate center.
+
+        Args:
+            cs (CoordinateSystem, optional): The coordinate system in which to put the polygon. Defaults to None.
+
+        Returns:
+            GeoPolygon: The resultant 3D GeoPolygon object.
+        """
+        ptags, lines, wiretag = self._make_wire(cs)
         surftag = gmsh.model.occ.add_plane_surface([wiretag,])
         poly = GeoPolygon([surftag,])
         poly.points = ptags
@@ -384,6 +438,8 @@ class XYPolygon:
         Returns:
             GeoPolygon: The resultant object.
         """
+        if self._cs is not None:
+            return self._finalize(self._cs)
         if cs is None:
             cs = GCS
         return self._finalize(cs) 
@@ -500,7 +556,34 @@ class XYPolygon:
         self.extend(xs, ys)
         return self
     
+    def connect(self, other: XYPolygon) -> GeoVolume:
+        """Connect two XYPolygons with a defined coordinate system
 
+        The coordinate system must be defined before this function can be used. To add a coordinate systme without
+        rendering the Polygon to a GeoVolume, use:
+        >>> polygon.incs(my_cs_obj)
+        
+        Args:
+            other (XYPolygon): _descrThe otheiption_
+
+        Returns:
+            GeoVolume: The resultant volume object
+        """
+        if self._cs is None:
+            raise RuntimeError('Cannot connect XYPolygons without a defined coordinate system. Set this first using .incs()')
+        if other._cs is None:
+            raise RuntimeError('Cannot connect XYPolygons without a defined coordinate system. Set this first using .incs()')
+        p1, l1, w1 = self._make_wire(self._cs)
+        p2, l2, w2 = other._make_wire(other._cs)
+        o1 = np.array(self._cs.in_global_cs(*self.center, 0)).flatten()
+        o2 = np.array(other._cs.in_global_cs(*other.center, 0)).flatten()
+        dts = gmsh.model.occ.addThruSections([w1, w2], True, parametrization="IsoParametric")
+        vol = GeoVolume([t for d,t in dts if d==3])
+        
+        vol._add_face_pointer('front',o1, self._cs.zax.np)
+        vol._add_face_pointer('back', o2, other._cs.zax.np)
+        return vol
+            
 class Disc(GeoSurface):
     
     def __init__(self, origin: tuple[float, float, float],
@@ -525,8 +608,7 @@ class Curve(GeoEdge):
                  degree: int = 3,
                  weights: list[float] | None = None,
                  knots: list[float] | None = None,
-                 ctype: Literal['Spline','BSpline','Bezier'] = 'Bezier',
-                 dstart: tuple[float, float, float] | None = None):
+                 ctype: Literal['Spline','BSpline','Bezier'] = 'Spline'):
         """Generate a Spline/Bspline or Bezier curve based on a series of points
 
         This calls the different curve features in OpenCASCADE.
@@ -547,11 +629,6 @@ class Curve(GeoEdge):
         self.xpts: np.ndarray = xpts
         self.ypts: np.ndarray = ypts
         self.zpts: np.ndarray = zpts
-        
-        if dstart is None:
-            dstart = (xpts[1]-xpts[0], ypts[1]-ypts[0], zpts[1]-zpts[0])
-        
-        self.dstart: tuple[float, float, float] = dstart
 
         points = [gmsh.model.occ.add_point(x,y,z) for x,y,z in zip(xpts, ypts, zpts)]
         
@@ -571,6 +648,14 @@ class Curve(GeoEdge):
         gmsh.model.occ.remove([(0,tag) for tag in points])
         super().__init__(tags)
     
+        gmsh.model.occ.synchronize()
+        p1 = gmsh.model.getValue(self.dim, self.tags[0], [0,])
+        p2 = gmsh.model.getValue(self.dim, self.tags[0], [1e-6])
+        self.dstart: tuple[float, float, float] = (p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
+    
+        
+        
+    
     @property
     def p0(self) -> tuple[float, float, float]:
         """The start coordinate
@@ -653,7 +738,7 @@ class Curve(GeoEdge):
             zp[2] += d/2*dz
             dp = tuple(Z)
         
-        return Curve(xp, yp, zp, ctype='Spline', dstart=dp)
+        return Curve(xp, yp, zp, ctype='Spline')
     
     @staticmethod
     def helix_lh(pstart: tuple[float, float, float],
@@ -731,9 +816,12 @@ class Curve(GeoEdge):
             zp[2] += d/2*dz
             dp = tuple(Z)
         
-        return Curve(xp, yp, zp, ctype='Spline', dstart=dp)
+        return Curve(xp, yp, zp, ctype='Spline')
         
-    def pipe(self, crossection: GeoSurface | XYPolygon, max_mesh_size: float | None = None) -> GeoVolume:
+    def pipe(self, crossection: GeoSurface | XYPolygon, 
+             max_mesh_size: float | None = None,
+             start_tangent: Axis | tuple[float, float, float] | np.ndarray | None = None,
+             x_axis: Axis | tuple[float, float, float] | np.ndarray | None = None) -> GeoVolume:
         """Extrudes a surface or XYPolygon object along the given curve
 
         If a GeoSurface object is used, make sure it starts at the center of the curve. This property
@@ -744,25 +832,31 @@ class Curve(GeoEdge):
         Args:
             crossection (GeoSurface | XYPolygon): The cross section definition to be used
             max_mesh_size (float, optional): The maximum mesh size. Defaults to None
+            start_tangent (Axis, tuple, ndarray, optional): The input polygon plane normal direction. Defaults to None
+            x_axis (Axis, tuple, ndarray optional): The reference X-axis to align the input polygon. Defaults to None
         Returns:
             GeoVolume: The resultant volume object
         """
         if isinstance(crossection, XYPolygon):
-            zax = self.dstart
-            cs = Axis(np.array(zax)).construct_cs(self.p0)
-            surf = crossection.geo(cs)
+            if start_tangent is None:
+                start_tangent = self.dstart
+            if x_axis is not None:
+                xax = _parse_axis(x_axis)
+                zax = _parse_axis(self.dstart)
+                yax = zax.cross(xax)
+                cs = CoordinateSystem(xax, yax, zax, self.p0)
+            else:
+                zax = self.dstart
+                cs = Axis(np.array(zax)).construct_cs(self.p0)
+                surf = crossection.geo(cs)
         else:
             surf = crossection
         x1, y1, z1, x2, y2, z2 = gmsh.model.occ.getBoundingBox(*surf.dimtags[0])
         diag = ((x2-x1)**2 + (y2-y1)**2 + (z2-z1)**2)**(0.5)
-        
         pipetag = gmsh.model.occ.addPipe(surf.dimtags, self.tags[0], 'GuidePlan')
-        
         self.remove()
         surf.remove()
-        
         volume = GeoVolume(pipetag[0][1])
-        
         volume.max_meshsize = diag/2
         return volume
         

{emerge-0.6.2 → emerge-0.6.5}/emerge/_emerge/physics/microwave/microwave_3d.py

@@ -1026,4 +1026,4 @@ class Microwave3D:
         """DEPRICATED VERSION: Use run_sweep() instead.
         """
         logger.warning('This function is depricated. Please use run_sweep() instead')
-        self.run_sweep(*args, **kwargs)
+        return self.run_sweep(*args, **kwargs)

{emerge-0.6.2 → emerge-0.6.5}/emerge/_emerge/physics/microwave/microwave_data.py

@@ -249,7 +249,7 @@ class MWData:
         self.sim.new(**vars)['report'] = report
     
 @dataclass
-class FarfieldData:
+class FarFieldData:
     E: np.ndarray
     H: np.ndarray
     theta: np.ndarray
@@ -816,7 +816,7 @@ class MWField:
                          ang_range: tuple[float, float] = (-180, 180),
                          Npoints: int = 201,
                          origin: tuple[float, float, float] | None = None,
-                         syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] | None = None) -> FarfieldData:#tuple[np.ndarray, np.ndarray, np.ndarray]:
+                         syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] | None = None) -> FarFieldData:#tuple[np.ndarray, np.ndarray, np.ndarray]:
         """Compute the farfield electric and magnetic field defined by a circle.
 
         Args:
@@ -836,14 +836,14 @@ class MWField:
         theta, phi = arc_on_plane(refdir, plane_normal_parsed, ang_range, Npoints)
         E,H = self.farfield(theta, phi, faces, origin, syms = syms)
         angs = np.linspace(*ang_range, Npoints)*np.pi/180
-        return FarfieldData(E, H, theta, phi, ang=angs)
+        return FarFieldData(E, H, theta, phi, ang=angs)
 
     def farfield_3d(self, 
                     faces: FaceSelection | GeoSurface,
                     thetas: np.ndarray | None = None,
                     phis: np.ndarray | None = None,
                     origin: tuple[float, float, float] | None = None,
-                    syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] | None = None) -> FarfieldData:
+                    syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] | None = None) -> FarFieldData:
         """Compute the farfield in a 3D angular grid
 
         If thetas and phis are not provided, they default to a sample space of 2 degrees.
@@ -868,7 +868,7 @@ class MWField:
         E = E.reshape((3, ) + T.shape)
         H = H.reshape((3, ) + T.shape)
         
-        return FarfieldData(E, H, T, P)
+        return FarFieldData(E, H, T, P)
 
     def farfield(self, theta: np.ndarray,
                  phi: np.ndarray,
@@ -924,7 +924,7 @@ class MWField:
         
         return Eff, Hff
 
-    def optycal(self, faces: FaceSelection | GeoSurface | None = None) -> tuple:
+    def optycal_surface(self, faces: FaceSelection | GeoSurface | None = None) -> tuple:
         """Export this models exterior to an Optical acceptable dataset
 
         Args:
@@ -948,7 +948,24 @@ class MWField:
         H = field.H
         k0 = self.k0
         return vertices, triangles, E, H, origin, k0
-        
+    
+    def optycal_antenna(self, faces: FaceSelection | GeoSurface | None = None,
+                        origin: tuple[float, float, float] | None = None,
+                        syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] | None = None) -> dict:
+        """Export this models exterior to an Optical acceptable dataset
+
+        Args:
+            faces (FaceSelection | GeoSurface): The faces to export. Defaults to None
+
+        Returns:
+            tuple: _description_
+        """
+        freq = self.freq
+        def function(theta: np.ndarray, phi: np.ndarray, k0: float):
+            E, H = self.farfield(theta, phi, faces, origin, syms)
+            return E[0,:], E[1,:], E[2,:], H[0,:], H[1,:], H[2,:]
+    
+        return dict(freq=freq, ff_function=function)
 
 class MWScalar:
     """The MWDataSet class stores solution data of FEM Time Harmonic simulations.
@@ -1027,6 +1044,42 @@ class MWScalarNdim:
     def S(self, i1: int, i2: int) -> np.ndarray:
         return self.Sp[...,self._portmap[i1], self._portmap[i2]]
     
+    @property
+    def Smat(self) -> np.ndarray:
+        """Returns the full S-matrix
+
+        Returns:
+            np.ndarray: The S-matrix with shape (nF, nP, nP)
+        """
+        Nports = len(self._portmap)
+        nfreq = self.freq.shape[0]
+
+        Smat = np.zeros((nfreq,Nports,Nports), dtype=np.complex128)
+        
+        for i in self._portnumbers:
+            for j in self._portnumbers:
+                Smat[:,i-1,j-1] = self.S(i,j)
+
+        return Smat
+    
+    def emmodel(self, f_sample: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray]:
+        """Returns the required date for a Heavi S-parameter component
+
+        Returns:
+            tuple[np.ndarray, np.ndarray]: Heavi data
+        """
+        
+        if f_sample is not None:
+            f = f_sample
+            S = self.model_Smat(f_sample)
+        else:
+            f = self.freq
+            S = self.Smat
+        
+        Z0s = self.Z0
+        S = renormalise_s(S, Z0s, 50.0)
+        return f, S
+
     def model_S(self, i: int, j: int, 
             freq: np.ndarray, 
             Npoles: int | Literal['auto'] = 'auto', 
@@ -1062,7 +1115,7 @@ class MWScalarNdim:
         Returns:
             np.ndarray: The (Nf,Np,Np) S-parameter matrix
         """
-        Nports = len(self.datasets[0].excitation)
+        Nports = len(self._portmap)
         nfreq = frequencies.shape[0]
 
         Smat = np.zeros((nfreq,Nports,Nports), dtype=np.complex128)

{emerge-0.6.2 → emerge-0.6.5}/emerge/_emerge/simmodel.py

@@ -37,7 +37,7 @@ import inspect
 from pathlib import Path
 from atexit import register
 import signal
-
+from .. import __version__
 
 ############################################################
 #                   EXCEPTION DEFINITIONS                  #
@@ -54,6 +54,9 @@ Known problems/solutions:
 class SimulationError(Exception):
     pass
 
+class VersionError(Exception):
+    pass
+
 ############################################################
 #                 BASE 3D SIMULATION MODEL                 #
 ############################################################
@@ -228,6 +231,28 @@ class Simulation:
     #                       PUBLIC FUNCTIONS                  #
     ############################################################
 
+    def check_version(self, version: str) -> None:
+        """Compares the provided version number with the version number of EMerge that is running the script.
+        
+        You may remove any call to check_version to suppress VersionErrors and warnings.
+        
+        Args:
+            version (str): The EMerge version you intend to write this code for.
+
+        Raises:
+            VersionError: A potential version error if incompatibility is possible
+        """
+        vM, vm, vp = [float(x) for x in version.split('.')]
+        cM, cm, cp = [float(x) for x in __version__.split('.')]
+        if vM != cM:
+            raise VersionError(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}")
+        if vm != cm:
+            raise VersionError(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}")
+        if vp != cp:
+            logger.warning(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}")
+            logger.warning("You may suppress this error by removing the call to .check_version().")
+            input('Press enter to proceed...')
+
     def save(self) -> None:
         """Saves the current model in the provided project directory."""
         # Ensure directory exists

{emerge-0.6.2 → emerge-0.6.5}/examples/demo10_sgh.py

@@ -28,8 +28,8 @@ th = 1 * mm            # PML thickness
 dx = 2 * mm              # distance from horn exit to PML start
 
 # Create simulation object
-m = em.Simulation('HornAntenna', loglevel='DEBUG')
-
+m = em.Simulation('HornAntenna')
+m.check_version("0.6.5") # Checks version compatibility.
 # --- Coordinate system for horn geometry -------------------------------
 hornCS = em.CS(em.YAX, em.ZAX, em.XAX)
 

{emerge-0.6.2 → emerge-0.6.5}/examples/demo11_lumped_element_filter.py

@@ -28,7 +28,9 @@ def Cf(C):
 # --- PCB and lumped-component parameters ---------------------------------
 pack = '0603'         # package footprint for lumped components
 # Create simulation and PCB layouter with substrate thickness and material
-m = em.Simulation('LumpedFilter', loglevel='DEBUG')
+m = em.Simulation('LumpedFilter')
+m.check_version("0.6.5") # Checks version compatibility.
+
 th = 0.5         # substrate thickness (meters)
 Hair = 2.0
 pcb = em.geo.PCB(th, unit=mm, cs=em.GCS,

{emerge-0.6.2 → emerge-0.6.5}/examples/demo12_mode_alignment.py

@@ -11,7 +11,8 @@ direction (+Z vs -Z). In EMerge we can alignm modes using the .align_mode() meth
 """
 
 # First we define our simulation
-m = em.Simulation('aligntest', loglevel='INFO')
+m = em.Simulation('aligntest')
+m.check_version("0.6.5") # Checks version compatibility.
 
 # We create a cyllindrical waveguide in the Y-axis.
 cyl = em.geo.Cylinder(0.012, 0.05, em.CS(em.XAX, em.ZAX, em.YAX))

{emerge-0.6.2 → emerge-0.6.5}/examples/demo13_helix_antenna.py

@@ -24,8 +24,10 @@ L = 4*rad0                      # helix axial length
 porth = 2*mm                    # vertical height of the feed extrusion
 
 # --- Simulation object -------------------------------------------------------
-model = em.Simulation('helix', loglevel="DEBUG")
-dfeed = 5*mm                    # straight feed length before the helix starts
+model = em.Simulation('helix')
+model.check_version("0.6.5") # Checks version compatibility.
+
+dfeed = 3*mm                    # straight feed length before the helix starts
 
 # --- Geometry: helix curve and metal pipe -----------------------------------
 # Helix curve from (0,0,porth+dfeed/2) to (0,0,porth+dfeed/2+L)
@@ -44,11 +46,15 @@ dfeed = 5*mm                    # straight feed length before the helix starts
 #   (x0,y1)               
 
 # We add the porth height + half of the startfeed distance to the total height to put the helix in the right spot.
-h_curve = em.geo.Curve.helix_lh((0,0,porth+dfeed/2), (0,0,porth+dfeed/2+L), rad0, 13, r_end=0.8*rad0, startfeed=dfeed)
+h_curve = em.geo.Curve.helix_lh((0,0,porth+dfeed/2), (0,0,porth+dfeed/2+L), rad0, 13, r_end=0.8*rad0)
+
+cross_section = em.geo.XYPolygon.circle(radw, Nsections=6)
 
 # Sweep a circular cross-section along the curve to make a metallic pipe
-helix = h_curve.pipe(em.geo.XYPolygon.circle(radw, Nsections=6)).set_material(em.lib.MET_COPPER)
+helix = h_curve.pipe(cross_section).set_material(em.lib.MET_COPPER)
 
+# We add a block to make attachment of ports easier.
+block = em.geo.Box(dfeed, dfeed, dfeed, position=h_curve.p0, alignment=em.geo.Alignment.CENTER).set_material(em.lib.MET_COPPER)
 # Optional preview of current scene (geometry only at this point)
 model.view()
 

emerge-0.6.2/examples/demo4_boundary_selection.py → emerge-0.6.5/examples/demo14_boundary_selection.py

@@ -37,6 +37,7 @@ wgb = 10.16*mm
 L = 50*mm
 
 model = em.Simulation('Test Mode')
+model.check_version("0.6.5") # Checks version compatibility.
 
 # first lets define a WR90 waveguide
 wg_box = em.geo.Box(L, wga, wgb, position=(-L, -wga/2, -wgb/2))

{emerge-0.6.2 → emerge-0.6.5}/examples/demo1_stepped_imp_filter.py

@@ -28,7 +28,7 @@ pcbmat = em.Material(er=2.2, tand=0.00, color="#217627", opacity=0.2)
 # We start by creating our simulation object.
 
 m = em.Simulation('Demo1_SIF', loglevel='INFO')
-
+m.check_version("0.6.5") # Checks version compatibility.
 # To accomodate PCB routing we make use of the PCBLayouter class. To use it we need to 
 # supply it with a thickness, the desired air-box height, the units at which we supply
 # the dimensions and the PCB material.

{emerge-0.6.2 → emerge-0.6.5}/examples/demo2_combline_filter.py

@@ -42,8 +42,8 @@ rin = 12.5*mil
 lfeed = 100*mil
 
 # A usual we start our simulation file
-model = em.Simulation('Combline_DEMO', loglevel='DEBUG')
-
+model = em.Simulation('Combline_DEMO')
+model.check_version("0.6.5") # Checks version compatibility.
 
 # The filter consists of quarter lamba cylindrical pins inside an airbox.
 # First we create the airbox

{emerge-0.6.2 → emerge-0.6.5}/examples/demo3_coupled_line_filter.py

@@ -37,8 +37,8 @@ Dtot = 750              # total clearance (mil)
 extra = 100             # extra margin (mil)
 
 # --- Simulation setup ----------------------------------------------------
-model = em.Simulation('Demo3', loglevel='DEBUG')
-
+model = em.Simulation('Demo3')
+model.check_version("0.6.5") # Checks version compatibility.
 # --- Material and layouter -----------------------------------------------
 mat = em.Material(er=3.55, color="#488343", opacity=0.1)
 # Create PCB layouter with given substrate thickness and units

emerge-0.6.2/examples/demo3_patch_antenna.py → emerge-0.6.5/examples/demo4_patch_antenna.py

@@ -35,8 +35,8 @@ f2 = 1.6e9              # stop frequency
 
 # --- Create simulation object -------------------------------------------
 # Using PVDisplay backend for 3D visualization
-model = em.Simulation('MyPatchAntenna', loglevel='DEBUG')
-
+model = em.Simulation('MyPatchAntenna')
+model.check_version("0.6.5") # Checks version compatibility.
 # --- Define geometry primitives -----------------------------------------
 # Substrate block centered at origin in XY, thickness in Z (negative down)
 dielectric = em.geo.Box(wsub, hsub, th,

{emerge-0.6.2 → emerge-0.6.5}/examples/demo5_revolve.py

@@ -4,6 +4,7 @@ import emerge as em
 For now it just shows you how to work with the revolve system.
 """
 model = em.Simulation('Revolve test')
+model.check_version("0.6.5") # Checks version compatibility.
 
 mm = 0.001
 rad_feed = 30*mm

{emerge-0.6.2 → emerge-0.6.5}/examples/demo6_striplines_with_vias.py

@@ -11,7 +11,9 @@ PCB related demos (demo1 and demo3) to get more information on the PCBLayouter.
 mm = 0.001
 th = 1
 
-model = em.Simulation('Stripline_test', loglevel='DEBUG')
+model = em.Simulation('Stripline_test')
+model.check_version("0.6.5") # Checks version compatibility.
+
 # As usual we start by creating our layouter
 ly = em.geo.PCB(th, mm, em.GCS, em.lib.DIEL_RO4350B)
 

{emerge-0.6.2 → emerge-0.6.5}/examples/demo7_periodic_cells.py

@@ -28,7 +28,8 @@ wgb = 18*mm
 fl = 25*mm
 
 # We start again by defining our simulation model
-model = em.Simulation('Periodic', loglevel='DEBUG')
+model = em.Simulation('Periodic')
+model.check_version("0.6.5") # Checks version compatibility.
 
 # Next we will create a PeriodicCell class (in our case a hexagonal cell). This class
 # is simply meant to simplify our lives and improve the simulation setup flow.

{emerge-0.6.2 → emerge-0.6.5}/examples/demo8_waveguide_bpf_synthesis.py

@@ -79,7 +79,8 @@ def KZ0(S11, S12, S21, S22):
 wgaps = np.linspace(1*mm, 20*mm, 21)
 Ks = []
 hphis = []
-with em.Simulation('IrisSim', loglevel='DEBUG') as sim:
+with em.Simulation('IrisSim') as sim:
+    sim.check_version("0.6.5") # Checks version compatibility.
     for (wgap,) in sim.parameter_sweep(True, wgap=wgaps):
         # Define two short waveguide sections separated by iris plate
         wg1 = em.geo.Box(wga, Lfeed, wgb, (-wga/2, -Lfeed - t_thickness/2, 0))
@@ -128,7 +129,7 @@ cavity_lengths = (1/beta0 * np.array([
 ])).real
 
 # --- Build and simulate full filter -------------------------------------
-with em.Simulation('FullFilter', loglevel='DEBUG') as mf:
+with em.Simulation('FullFilter') as mf:
     # Input feed section
     feed1 = em.geo.Box(wga, Lfeed, wgb, (-wga/2, -Lfeed, 0))
     # Create cavities and irises sequentially
@@ -149,7 +150,7 @@ with em.Simulation('FullFilter', loglevel='DEBUG') as mf:
     mf.commit_geometry(feed1, feed2, last_iris, *(cavities + irises))
 
     # Simulation settings and mesh
-    mf.mw.set_frequency_range(f1 - 0.2e9, f2 + 0.2e9, 101)
+    mf.mw.set_frequency_range(f1 - 0.2e9, f2 + 0.2e9, 51)
     mf.mw.set_resolution(0.10)
     for ir in irises:
         mf.mesher.set_domain_size(ir, 2*mm)

{emerge-0.6.2 → emerge-0.6.5}/examples/demo9_dielectric_resonator.py

@@ -32,7 +32,8 @@ mat_resonator = em.lib.Material(er=34, color="#ededed")
 Nmodes = 5
 
 # --- Create simulation ---------------------------------------------------
-model = em.Simulation('DielectricResonatorFilter', loglevel='INFO')
+model = em.Simulation('DielectricResonatorFilter')
+model.check_version("0.6.5") # Checks version compatibility.
 
 # --- Build geometry ------------------------------------------------------
 # Metal enclosure box (PEC by default)

{emerge-0.6.2 → emerge-0.6.5}/pyproject.toml

@@ -3,7 +3,7 @@ allow-direct-references = true
 
 [project]
 name = "emerge"
-version = "0.6.2"
+version = "0.6.5"
 description = "An open source EM FEM simulator in Python"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"

{emerge-0.6.2 → emerge-0.6.5}/uv.lock

@@ -236,7 +236,7 @@ wheels = [
 
 [[package]]
 name = "emerge"
-version = "0.6.2"
+version = "0.6.5"
 source = { editable = "." }
 dependencies = [
     { name = "gmsh" },

emerge-0.6.2/.bumpversion.toml

@@ -1,30 +0,0 @@
-[tool.bumpversion]
-current_version = "0.6.2"
-parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
-serialize = ["{major}.{minor}.{patch}"]
-search = "{current_version}"
-replace = "{new_version}"
-regex = false
-ignore_missing_version = false
-ignore_missing_files = false
-tag = true
-sign_tags= false
-tag_name = "v{new_version}"
-tag_message = "Bump version: {current_version} → {new_version}"
-allow_dirty = false
-commit = true
-message = "Bump version: {current_version} → {new_version}"
-moveable_tags = []
-commit_args = ""
-setup_hooks = []
-pre_commit_hooks = []
-post_commit_hooks = []
-
-[[tool.bumpversion.files]]
-filename = "uv.lock"
-
-[[tool.bumpversion.files]]
-filename = "pyproject.toml"
-
-[[tool.bumpversion.files]]
-filename = "src/emerge/__init__.py"

emerge-0.6.2/emerge/_emerge/geo/pipes.py

@@ -1,62 +0,0 @@
-# EMerge is an open source Python based FEM EM simulation module.
-# Copyright (C) 2025  Robert Fennis.
-
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-
-# 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
-import gmsh
-import numpy as np
-from typing import Literal, Callable
-from ..geometry import GeoEdge, GeoSurface, GeoVolume
-
-
-
-class Curve(GeoEdge):
-    
-    
-    def __init__(self, xpts: np.ndarray, ypts: np.ndarray, zpts: np.ndarray, 
-                 degree: int = 3,
-                 weights: list[float] | None = None,
-                 knots: list[float] | None = None,
-                 ctype: Literal['Spline','BSpline','Bezier'] = 'Bezier'):
-        self.xpts: np.ndarray = xpts
-        self.ypts: np.ndarray = ypts
-        self.zpts: np.ndarray = zpts
-        
-        points = [gmsh.model.occ.add_point(x,y,z) for x,y,z in zip(xpts, ypts, zpts)]
-        
-        if ctype.lower()=='spline':
-            tags = gmsh.model.occ.addSpline(points)
-            
-        elif ctype.lower()=='bspline':
-            if weights is None:
-                weights = []
-            if knots is None:
-                knots = []
-            tags = gmsh.model.occ.addBSpline(points, degree=degree, weights=weights, knots=knots)
-        else:
-            tags = gmsh.model.occ.addBezier(points)
-        
-        tags = gmsh.model.occ.addWire([tags,])
-        gmsh.model.occ.remove([(0,tag) for tag in points])
-        super().__init__(tags)
-    
-
-
-
-class Helix(GeoVolume):
-    
-    
-