emerge 0.4.6__tar.gz → 0.4.8__tar.gz

emerge-0.4.8/.bumpversion.toml

@@ -0,0 +1,27 @@
+[tool.bumpversion]
+current_version = "0.4.8"
+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"

emerge-0.4.8/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.

emerge-0.4.8/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

emerge-0.4.8/.python-version

@@ -0,0 +1 @@
+3.10

emerge-0.4.8/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.REPL.enableREPLSmartSend": false
+}

{emerge-0.4.6 → emerge-0.4.8}/PKG-INFO

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

@@ -28,7 +28,7 @@ os.environ["NUMEXPR_NUM_THREADS"] = NTHREADS
 
 
 from loguru import logger
-from _emerge.logsettings import logger_format
+from ._emerge.logsettings import logger_format
 import sys
 
 logger.remove()
@@ -36,19 +36,19 @@ logger.add(sys.stderr, format=logger_format)
 
 logger.debug('Importing modules')
 
-from _emerge.simmodel import Simulation3D
-from _emerge.material import Material
-from _emerge import bc
-from _emerge.solver import SolverBicgstab, SolverGMRES, SolveRoutine, ReverseCuthillMckee, Sorter, SolverPardiso, SolverUMFPACK, SolverSuperLU, EMSolver
-from _emerge.cs import CoordinateSystem, CS, GCS, Plane, Axis, XAX, YAX, ZAX, XYPLANE, XZPLANE, YZPLANE, YXPLANE, ZXPLANE, ZYPLANE
-from _emerge.coord import Line
-from _emerge import geo
-from _emerge.selection import Selection, FaceSelection, DomainSelection, EdgeSelection
-from _emerge.mth.common_functions import norm, coax_rout, coax_rin
-from _emerge.physics.microwave.sc import stratton_chu
-from _emerge.periodic import RectCell, HexCell
-from _emerge.mesher import Algorithm2D, Algorithm3D
+from ._emerge.simmodel import Simulation3D
+from ._emerge.material import Material
+from ._emerge import bc
+from ._emerge.solver import SolverBicgstab, SolverGMRES, SolveRoutine, ReverseCuthillMckee, Sorter, SolverPardiso, SolverUMFPACK, SolverSuperLU, EMSolver
+from ._emerge.cs import CoordinateSystem, CS, GCS, Plane, Axis, XAX, YAX, ZAX, XYPLANE, XZPLANE, YZPLANE, YXPLANE, ZXPLANE, ZYPLANE
+from ._emerge.coord import Line
+from ._emerge import geo
+from ._emerge.selection import Selection, FaceSelection, DomainSelection, EdgeSelection
+from ._emerge.mth.common_functions import norm, coax_rout, coax_rin
+from ._emerge.physics.microwave.sc import stratton_chu
+from ._emerge.periodic import RectCell, HexCell
+from ._emerge.mesher import Algorithm2D, Algorithm3D
 from . import lib
-from _emerge.howto import _HowtoClass
+from ._emerge.howto import _HowtoClass
 howto = _HowtoClass()
 logger.debug('Importing complete!')

{emerge-0.4.6 → emerge-0.4.8/emerge}/_emerge/physics/microwave/assembly/curlcurl.py

@@ -85,7 +85,7 @@ for I in range(NFILL):
 VOLUME_COEFF_CACHE = VOLUME_COEFF_CACHE_BASE
 
 @njit(types.Tuple((f8[:], f8[:], f8[:], f8))(f8[:], f8[:], f8[:]), cache = True, nogil=True)
-def tet_coefficients_bcd(xs: np.ndarray, ys: np.ndarray, zs: np.ndrray) -> tuple[np.ndarray, np.ndarray, np.ndarray, float]:
+def tet_coefficients_bcd(xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray, float]:
     """Computes the a,b,c and d coefficients of a tet barycentric coordinate functions and the volume
 
     Args:

{emerge-0.4.6 → emerge-0.4.8}/emerge/lib.py

@@ -1,4 +1,4 @@
-from _emerge.material import Material, AIR, COPPER
+from ._emerge.material import Material, AIR, COPPER
 
 C0 = 299792458
 Z0 = 376.73031366857

emerge-0.4.8/emerge/plot.py

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

emerge-0.4.8/examples/demo10_sgh.py

@@ -0,0 +1,111 @@
+import emerge as em
+from emerge.plot import plot_sp, plot_ff
+import numpy as np
+
+""" STANDARD GAIN HORN ANTENNA
+
+This demo sets up and simulates a rectangular horn antenna in an
+absorbing domain with PML layers. We compute return loss (S11) over a
+90–110 GHz band and plot the far-field radiation pattern. 
+
+The dimensions come from this paper:
+https://pure.tue.nl/ws/portalfiles/portal/332971061/Uncertainties_in_the_Estimation_of_the_Gain_of_a_Standard_Gain_Horn_in_the_Frequency_Range_of_90_GHz_to_140_GHz.pdf
+"""
+
+# --- Units ---------------------------------------------------------------
+mm = 0.001               # meters per millimeter
+
+# --- Horn and feed dimensions -------------------------------------------
+wga = 2.01 * mm           # waveguide width
+wgb = 1.01 * mm          # waveguide height
+WH = 10 * mm            # Aperture width
+HH = 7 * mm             # Aperture height
+Lhorn = 21 * mm        # Horn length
+
+# --- Feed and simulation setup ------------------------------------------
+Lfeed = 2 * mm           # length of feed waveguide
+th = 1 * mm            # PML thickness
+dx = 2 * mm              # distance from horn exit to PML start
+
+# Create simulation object
+m = em.Simulation3D('HornAntenna', loglevel='DEBUG')
+
+# --- Coordinate system for horn geometry -------------------------------
+hornCS = em.CS(em.YAX, em.ZAX, em.XAX)
+
+# Feed waveguide as rectangular box (metal)
+feed = em.geo.Box(
+    Lfeed,   # length along X
+    wga/2,     # half-width along Y (centered)
+    wgb/2,     # half-height along Z
+    position=(-Lfeed, 0, 0)
+)
+
+# --- Horn geometry ------------------------------------------------------
+# Inner horn taper from (D,E) at throat to (B,C) at mouth over length F
+horn_in = em.geo.Horn(
+    (wga, wgb), (WH, HH), Lhorn, hornCS,
+)
+# Outer horn (including metal thickness) helps define PML subtraction
+horn_out = em.geo.Horn(
+    (wga+2*th, wgb+2*th), (WH+2*th, HH+2*th), Lhorn, hornCS
+)
+
+# --- Bounding objects and PML -------------------------------------------
+# Define large intersection box to trim horn geometry
+ibox = em.geo.Box(30*mm, 30*mm, 30*mm)
+horn_in = em.geo.intersect(horn_in, ibox, remove_tool=False)
+horn_out = em.geo.intersect(horn_out, ibox)
+
+# Create airbox with PML layers on +X, +Y, +Z faces
+rat = 1.6  # PML extension ratio
+air, *pmls = em.geo.pmlbox(
+    4*mm,          # air padding before PML
+    rat*WH/2,       # half-height in Y
+    rat*HH/2,       # half-width in Z
+    (Lhorn - dx, 0, 0),# PML origin offset along X
+    thickness=4*mm,
+    N_mesh_layers=4,
+    top=True, right=True, back=True
+)
+# Subtract horn volume from airbox so PML does not cover metal
+air2 = em.geo.subtract(air, horn_out)
+
+# --- Solver parameters --------------------------------------------------
+m.mw.set_frequency_range(90e9, 110e9, 11)  # 90–110 GHz sweep
+m.mw.set_resolution(0.27)                # mesh resolution fraction
+
+# --- Assemble geometry and mesh -----------------------------------------
+m.generate_mesh()
+
+# --- Boundary conditions ------------------------------------------------
+p1 = m.mw.bc.ModalPort(feed.face('left'), 1)     # excite TE10 in feed
+PMC = m.mw.bc.PMC(m.select.face.inplane(0, 0, 0, 0, 1, 0))  # perfect magnetic on symmetry
+radiation_boundary = air.outside('front', 'left', 'bottom')  # open faces
+abc = m.mw.bc.AbsorbingBoundary(m.select.face.inplane(Lhorn-dx,0,0,1,0,0))
+# View mesh and BC selections
+m.view(selections=[p1.selection, PMC.selection, radiation_boundary])
+
+# --- Run frequency-domain solver ----------------------------------------
+data = m.mw.frequency_domain(True, 2, frequency_groups=4)
+
+# --- Plot return loss ---------------------------------------------------
+scal = data.scalar.grid
+plot_sp(scal.freq, scal.S(1,1))  # S11 vs frequency
+
+# --- Far-field radiation pattern ----------------------------------------
+# Compute E and H on 2D cut for phi=0 plane over -90° to 90°
+ang, E, H = data.field[0].farfield_2d(
+    (1, 0, 0), (0, 1, 0), radiation_boundary,
+    (-90, 90), syms=['Ez','Hy']
+)
+# Normalize to free-space impedance and convert to dB
+
+m.display.add_object(horn_in, opacity=0.1)
+m.display.add_object(air2, opacity=0.1)
+m.display.add_object(feed, opacity=0.1)
+m.display.add_surf(*data.field[0].farfield_3d(radiation_boundary, syms=['Ez','Hy'])\
+                .surfplot('normE', True, True, -30, 5*mm, (Lhorn,0,0)), cmap='viridis', symmetrize=False)
+m.display.add_surf(*data.field[0].cutplane(0.5*mm, z=0).scalar('Ez','real'))
+m.display.show()
+

emerge-0.4.8/examples/demo11_lumped_element_filter.py

@@ -0,0 +1,118 @@
+import emerge as em
+from emerge.plot import plot_sp
+import numpy as np
+
+""" LUMPED COMPONENT FILTER DEMO
+
+This demo constructs a microstrip filter using discrete lumped inductors and
+capacitors mounted on a PCB. We extract the characteristic impedance, place
+lumped elements in the trace, mesh the structure, and compute S-parameters.
+"""
+
+# --- Unit definitions -----------------------------------------------------
+mm = 0.001           # meters per millimeter
+pF = 1e-12           # picofarad in farads
+fF = 1e-15           # femtofarad in farads
+pH = 1e-12           # picohenry in henrys
+nH = 1e-9            # nanohenry in henrys
+
+# --- Lumped element impedance functions ---------------------------------
+def Lf(L):
+    """Return series impedance function for inductor L."""
+    return lambda f: 1j * 2 * np.pi * f * L
+
+def Cf(C):
+    """Return shunt admittance function for capacitor C."""
+    return lambda f: 1 / (1j * 2 * np.pi * f * 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.Simulation3D('LumpedFilter', loglevel='DEBUG')
+th = 0.5         # substrate thickness (meters)
+Hair = 2.0
+pcb = em.geo.PCBLayouter(th, unit=mm, cs=em.GCS,
+                          material=em.lib.ROGERS_RO4003C, layers=2)
+# Compute 50-ohm microstrip width
+w0 = pcb.calc.z0(50)
+
+# Define lengths and lumped element values
+l0 = 2            # straight segment length (mm)
+Lshunt = 35 * nH         # first inductor value
+Cshunt = 35 * pF         # first capacitor value
+Lseries = 70 * nH         # second inductor
+Cseries = 18 * pF         # second capacitor
+
+# --- Route trace with lumped elements via method chaining ----------------
+# Input matching section
+pcb.new(0, 0, w0, (1, 0)).store('p1').straight(3)\
+    .lumped_element(Cf(Cseries), pack).straight(l0)\
+    .lumped_element(Lf(Lseries), pack).straight(l0)\
+    .split((0, -1)).straight(l0)\
+    .lumped_element(Cf(Cshunt), pack).straight(l0 / 2, w0)\
+    .via(pcb.z(1), w0 / 6, False).merge()\
+    .split((0, 1)).straight(l0)\
+    .lumped_element(Lf(Lshunt), pack).straight(l0 / 2, w0)\
+    .via(pcb.z(1), w0 / 6, False).merge()\
+    .straight(l0).lumped_element(Cf(Cseries), pack).straight(l0)\
+    .lumped_element(Lf(Lseries), pack).straight(l0)\
+    .straight(3).store('p2')           
+
+# Retrieve lumped element and via objects
+LEs = pcb.lumped_elements
+vias = pcb.generate_vias(merge=True)
+# Compile trace geometry and determine bounds
+traces = pcb.compile_paths(merge=True)
+pcb.determine_bounds(leftmargin=0, topmargin=1, rightmargin=0, bottommargin=1)
+
+# --- Define modal ports and generate environment ------------------------
+mp1 = pcb.modal_port(pcb.load('p1'), Hair)
+mp2 = pcb.modal_port(pcb.load('p2'), Hair)
+diel = pcb.gen_pcb()                   # substrate dielectric block
+air = pcb.gen_air(Hair)                  # surrounding air block
+
+# Add all geometry to simulation
+m.define_geometry()
+
+# --- Solver and mesh settings -------------------------------------------
+m.mw.set_frequency_range(0.05e9, 0.3e9, 51)       # 50–300 MHz sweep
+m.mesher.set_boundary_size(traces, 0.5 * mm)
+# Refine mesh around lumped component faces
+for le in LEs:
+    m.mesher.set_face_size(le, 0.1 * mm)
+# Domain mesh refinement
+m.mesher.set_domain_size(diel, 1 * mm)
+m.mesher.set_domain_size(air, 3 * mm)
+
+# Build mesh and view
+m.generate_mesh()
+m.view()
+
+# --- Boundary conditions -----------------------------------------------
+# Define modal (TEM) ports at input and output
+p1 = m.mw.bc.ModalPort(mp1, 1, TEM=True)
+p2 = m.mw.bc.ModalPort(mp2, 2, TEM=True)
+# Add lumped element BCs for each element
+for le in LEs:
+    m.mw.bc.LumpedElement(le)
+# Perfect conductor on copper traces and vias
+m.mw.bc.PEC(traces)
+m.mw.bc.PEC(vias.outside())
+
+# --- Run frequency-domain simulation ------------------------------------
+data = m.mw.frequency_domain(parallel=True, njobs=4, frequency_groups=8)
+
+# --- Post-processing: plot S-parameters ---------------------------------
+f = data.scalar.grid.freq
+S11 = data.scalar.grid.S(1, 1)
+S21 = data.scalar.grid.S(2, 1)
+plot_sp(f, [S11, S21], xunit='MHz', labels=['S11', 'S21'])
+
+# --- Visualize field distribution ---------------------------------------
+m.display.add_object(diel, opacity=0.1)
+m.display.add_object(traces, opacity=0.1)
+# Cut-plane of Ez field through substrate center
+cut = data.field.find(freq=2.25e9)\
+    .cutplane(0.1 * mm, z=-th/2 * mm)
+m.display.add_surf(*cut.scalar('Ez', 'real'))
+m.display.show()

emerge-0.4.8/examples/demo1_stepped_imp_filter.py

@@ -0,0 +1,149 @@
+import emerge as em
+import numpy as np
+from emerge.plot import smith, plot_sp
+
+""" STEPPED IMPEDANCE FILTER
+
+In this demo we will look at how we can construct a stepped impedance filter using the
+PCB Layouter interface in EMerge.
+
+"""
+# First we will define some constants/variables/parameters for our simulation.
+mm = 0.001
+mil = 0.0254*mm
+
+L0, L1, L2, L3 = 400, 660, 660, 660 # The lengths of the sections in mil's
+W0, W1, W2, W3 = 50, 128, 8, 224 # The widths of the sections in mil's
+
+th = 62 # The PCB Thickness
+er = 2.2 # The Dielectric constant
+
+Hair = 60
+
+## Material definition
+
+# We can define the material using the Material class. Just supply the dielectric properties and you are done!
+pcbmat = em.Material(er=2.2, tand=0.00, color="#217627")
+
+# We start by creating our simulation object.
+
+m = em.Simulation3D('Demo1_SIF', loglevel='DEBUG')
+
+# 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.
+
+layouter = em.geo.PCBLayouter(th, unit=mil, material=pcbmat, layers=3)
+
+# We will route our PCB using the "method chaining" syntax. First we call the .new() method
+# to start a new trace. This will returna StripPath object on which we may call methods that
+# sequentially constructs our stripline trace. In this case, it is sipmly a sequence of straight
+# sections.
+
+layouter.new(0,0,W0, (1,0), z=layouter.z(2)).store('p1').straight(L0, W0).straight(L1,W1).straight(L2,W2).straight(L3,W3)\
+    .straight(L2,W2).straight(L1,W1).straight(L0,W0).store('p2')
+
+# Next we generate a wave port surface to use for our simulation. A wave port can be automatically
+# generated for a given stripoline section. To easily reference it we use the .ref() method to 
+# recall the sections we created earlier.
+p1 = layouter.modal_port(layouter.load('p1'), height=0)
+p2 = layouter.modal_port(layouter.load('p2'), height=0)
+
+# Finally we compile the stirpline into a polygon. The compile_paths function will return
+# GeoSurface objects that form the polygon. Additionally, we may turn on the Merge feature
+# which will then return a single GeoSurface type object that we can use later.
+polies = layouter.compile_paths(True)
+
+# We can manually define blocks for the dielectric or air or let the PCBLayouter do it for us.
+# First we must determine the bounds of our PCB. This function by default will make a PCB
+# just large enough to contain all the coordinates in it (in the XY plane). By adding extra
+# margins we can make sure to add sufficient space next to the trace. Just make sure that there
+# is no margin where the wave ports need to go.
+layouter.determine_bounds(leftmargin=0, topmargin=200, rightmargin=0, bottommargin=200)
+
+# We can now generate the PCB and air box. The material assignment is automatic!
+
+pcb = layouter.gen_pcb(True, merge=True)
+
+# We now pass all the geometries we have created to the .define_geometry() method.
+m.define_geometry()
+
+# We set our desired resolution (fraction of the wavelength)
+m.mw.set_resolution(0.08)
+
+# And we define our frequency range
+m.mw.set_frequency_range(0.2e9, 8e9, 41)
+
+# EMerge also has a convenient interface to improve surface meshing quality. 
+# With the set_boundary_size(method) we can define a meshing resolution for the edges of boundaries.
+# This is adviced for small stripline structures.
+# The growth_rate setting allows us to change how fast the mesh size will recover to the original size.
+m.mesher.set_boundary_size(polies, 1*mm, growth_rate=1.2)
+m.mesher.set_face_size(p1, 1*mm)
+m.mesher.set_face_size(p2, 1*mm)
+
+# Finally we generate our mesh and view it
+m.generate_mesh()
+
+#m.view(use_gmsh=True)
+
+# We can now define the modal ports for the in and outputs and set the conductor to PEC.
+port1 = m.mw.bc.ModalPort(p1, 1, TEM=True)
+port2 = m.mw.bc.ModalPort(p2, 2, TEM=True)
+pec = m.mw.bc.PEC(polies)
+
+## OPTIONAL
+# If we want to view the port mode we have to first know it. The modes are computed using a modal analysis.
+# Since the latest version of EMerge. Modal analysis is executed automatically. Here we compute them manually
+# as the mode is only calculated during the frequency domain solution.
+if False:
+    # Make sure to set the TEM property to True so that
+    # EMerge knows to handle the port mode as a TEM boundary. This also includes the automatic
+    # determination of a voltage integration line used for computing the port impedance.
+    m.mw.modal_analysis(port1, 1, TEM=True)
+    m.mw.modal_analysis(port2, 1, TEM=True)
+
+    # Finally we import the display class to view the resultant modes
+    m.display.add_object(pcb, opacity=0.1)
+    m.display.add_object(polies)
+    m.display.add_portmode(port1, 21)
+    m.display.add_portmode(port2, 21)
+    m.display.show()
+
+# Finally we execute the frequency domain sweep and compute the Scattering Parameters.
+sol = m.mw.frequency_domain(parallel=True, njobs=4, frequency_groups=8)
+
+
+# Our "sol" variable is of type MWData (Microwave Data). This contains a set of scalar data 
+# like S-parameters and field data like the E/H field. The scalar data is in sol.scalar and the 
+# field data in sol.field. Our data is currently a large list of entries in the dataset simply in order
+# at which it is computed. We can structure our data in cases where we do a single frequency sweep
+# or with a structured parameter sweep. In this case we can use the .grid property which will attempt
+# to construct an N-dimensional grid from our results. 
+
+gritted_data = sol.scalar.grid
+
+# The gritted_data is of type MWGlobalNdim which means its an N-dimensional set of data.
+# From this we can simply take all that we need.
+
+f = gritted_data.freq
+S11 = gritted_data.S(1,1)
+S21 = gritted_data.S(2,1)
+
+# This extracts the actual simulation data.
+plot_sp(f/1e9, [S11, S21], labels=['S11','S21'], dblim=[-40,6], logx=True)
+
+# We can also supersample our data by constructing a model using the Vector Fitting algorithm
+
+f = np.linspace(0.2e9, 8e9, 2001)
+S11 = gritted_data.model_S(1,1,f)
+S21 = gritted_data.model_S(2,1,f)
+
+smith(f,S11)
+
+plot_sp(f/1e9, [S11, S21], labels=['S11','S21'], dblim=[-40,6], logx=True)
+
+m.display.add_object(pcb, opacity=0.1)
+m.display.add_object(polies, opacity=0.5)
+m.display.add_surf(*sol.field[0].cutplane(1*mm, z=-0.75*th*mil).scalar('Ez','real'))
+m.display.show()

emerge-0.4.8/examples/demo2_combline_filter.py

@@ -0,0 +1,130 @@
+import emerge as em
+import numpy as np
+from emerge.plot import plot_sp
+
+""" DEMO: COMBLINE FILTER
+
+In this demo we will look at the design of a combline filter in EMerge. The filter design was taken from
+the book "Modern RF and Microwave Filter Design" by Protap Pramanick and Prakash Bhartia.
+Some of the dimensions where not clear.
+
+In this demo we will look at the Modeler class and how it can help us quickly create complicated geometries.
+
+"""
+
+# First we define some quantities for our simulation.
+mm = 0.001
+mil = 0.0254*mm
+
+a = 240*mil
+b = 248*mil
+d1 = 10*mil
+d2 = 10*mil
+dc = 8.5*mil
+lr1 = b-d1
+lr2 = b-d2
+W = 84*mil
+S1 = 117*mil
+S2 = 136*mil
+C1 = b-dc
+h = 74*mil
+wi = 84*mil
+Lbox = 5*W + 2*(S1+S2+wi)
+
+x1 = wi+W/2
+x2 = x1 + W + S1
+x3 = x2 + W + S2
+x4 = x3 + W + S2
+x5 = x4 + W + S1
+
+rout = 40.5*mil
+rin = 12.5*mil
+lfeed = 100*mil
+
+# A usual we start our simulation file
+model = em.Simulation3D('Combline_DEMO', loglevel='DEBUG')
+
+
+# The filter consists of quarter lamba cylindrical pins inside an airbox.
+# First we create the airbox
+box = em.geo.Box(Lbox, a, b, position=(0,-a/2,0))
+
+# Next we create 5 cyllinders using the Modeler class.
+# The modeler class also implements a method chaining interface. In this example we stick to simpler features.
+# The modeler class allows us to create a parameter series using the modeler.series() method. We provid it with quantities.
+# We can do this for multiple at the same time (as you can also see with the position). The modeler class
+# will recognize the multiple quantities and simply create 5 different cyllinders, one for each parameter pair.
+stubs = model.modeler.cyllinder(W/2, model.modeler.series(C1, lr1, lr2, lr1, C1), position=(model.modeler.series(x1, x2, x3, x4, x5), 0, 0), NPoly=10)
+
+# Next we create the in and output feed cyllinders for the coaxial cable. We will use the Nsections feature in order to guarantee a better
+# adherence to the boundary.
+feed1out = em.geo.Cyllinder(rout, lfeed, em.CoordinateSystem(em.ZAX, em.YAX, em.XAX, np.array([-lfeed, 0, h])), Nsections=12)
+feed1in = em.geo.Cyllinder(rin, lfeed+wi+W/2, em.CoordinateSystem(em.ZAX, em.YAX, em.XAX, np.array([-lfeed, 0, h])), Nsections=8)
+feed2out = em.geo.Cyllinder(rout, lfeed, em.CoordinateSystem(em.ZAX, em.YAX, em.XAX, np.array([Lbox, 0, h])), Nsections=12)
+feed2in = em.geo.Cyllinder(rin, lfeed+wi+W/2, em.CoordinateSystem(em.ZAX, em.YAX, em.XAX, np.array([Lbox-wi-W/2, 0, h])), Nsections=8)
+
+# Next we subtract the stubs and the center conductor from the box and feedline.
+for ro in stubs:
+    box = em.geo.subtract(box, ro)
+box = em.geo.subtract(box, feed1in, remove_tool=False)
+box = em.geo.subtract(box, feed2in, remove_tool=False)
+feed1out = em.geo.subtract(feed1out, feed1in)
+feed2out = em.geo.subtract(feed2out, feed2in)
+
+# Finally we may define our geometry
+model.define_geometry()
+
+model.view()
+
+# We define our frequency range and a fine sampling.
+model.mw.set_frequency_range(6e9, 8e9, 21)
+
+model.mw.resolution = 0.05
+
+# To improve simulation quality we refine the faces at the top of the cylinders.
+for stub in stubs:
+    model.mesher.set_boundary_size(box.face('back', tool=stub), 0.0002)
+
+# Finally we may create our mesh.
+model.generate_mesh()
+
+model.view()
+
+# We define our modal ports, assign the boundary condition and execute a modal analysis to solve for the
+# coaxial field mode.
+port1 = model.mw.bc.ModalPort(model.select.face.near(-lfeed, 0, h), 1, TEM=True)
+port2 = model.mw.bc.ModalPort(model.select.face.near(Lbox+lfeed, 0, h), 2, TEM=True)
+
+# At last we can compute the frequency domain study
+data = model.mw.frequency_domain(parallel=True)
+
+# Next we will use the Vector Fitting algorithm to model our S-parameters with a Rational function
+
+fdense = np.linspace(6e9, 9e9, 2001)
+
+S11 = data.scalar.grid.model_S(1,1,fdense)
+S21 = data.scalar.grid.model_S(2,1,fdense)
+
+plot_sp(fdense/1e9, [S11, S21], labels=['S11','S21'])
+
+# We can also plot the field inside. First we create a grid of sample point coordinates
+xs = np.linspace(0, Lbox, 41)
+ys = np.linspace(-a/2, a/2, 11)
+zs = np.linspace(0, b, 15)
+
+X, Y, Z = np.meshgrid(xs, ys, zs, indexing='ij')
+X = X.flatten()
+Y = Y.flatten()
+Z = Z.flatten()
+
+# The E-field can be interpolated by selecting a desired solution and then interpolating it.
+Ex, Ey, Ez = data.field[3].interpolate(X,Y,Z).E
+
+# We can add the objects we want and fields using the shown methods.
+model.display.add_object(box, opacity=0.1, show_edges=True)
+model.display.add_quiver(X,Y,Z, Ex.real, Ey.real, Ez.real)
+model.display.add_object(feed1out, opacity=0.1)
+model.display.add_portmode(port1, 21)
+model.display.add_portmode(port2, 21)
+model.display.add_surf(*data.field[3].cutplane(ds=0.5*mm, y=0).scalar('normE'))
+model.display.show()